Bypass search cache on truncated searches at embed-escape boundary

src/parsing/regex.rs

@@ -345,4 +345,27 @@ mod tests {
         let back_to_str = serde_json::to_string(&pattern).unwrap();
         assert_eq!(back_to_str, "\"just a string\"");
     }
+
+    // The parser uses `end < text.len()` to clip a search at an embed-escape
+    // boundary. Negative lookaheads inside the embedded context's rules must
+    // treat the boundary as effective end-of-input — otherwise patterns like
+    // `done(?!cmd_char)` fail when `done` is immediately followed by the
+    // closing escape glyph (e.g. `` `for...done` `` in shell).
+    #[test]
+    fn search_clips_lookahead_at_end() {
+        let regex = Regex::new(String::from(r"done(?!X)"));
+        let mut region = Region::new();
+        let matched = regex.search("doneX", 0, 4, Some(&mut region), true);
+        assert!(matched, "lookahead must not see byte at index 4");
+        assert_eq!(region.pos(0), Some((0, 4)));
+    }
+
+    // Sanity check: when not clipped, the same lookahead correctly fails.
+    #[test]
+    fn search_lookahead_fails_when_unclipped() {
+        let regex = Regex::new(String::from(r"done(?!X)"));
+        let mut region = Region::new();
+        let matched = regex.search("doneX", 0, 5, Some(&mut region), true);
+        assert!(!matched, "lookahead must see the X when end == text.len()");
+    }
 }

src/parsing/syntax_definition.rs

@@ -274,17 +274,20 @@ impl<'a> Iterator for MatchIter<'a> {
                             _ => return self.next(),
                         };
                         let ctx_ptr = self.syntax_set.get_context(context_id).unwrap();
-                        // Also include the external syntax's prototype if the context allows it
+                        // Push target first, then external prototype on top so
+                        // its patterns are iterated first: `MatchIter::next`
+                        // reads the stack top, and ST's `apply_prototype` runs
+                        // the prototype ahead of the included context — mirror
+                        // of `ParseState::find_best_match`'s prototype chaining.
+                        self.ctx_stack.push(ctx_ptr);
+                        self.index_stack.push(0);
                         if ctx_ptr.meta_include_prototype.unwrap_or(true) {
                             if let Some(ref proto_id) = ctx_ptr.prototype {
                                 let proto_ctx = self.syntax_set.get_context(proto_id).unwrap();
-                                // Push prototype first (it will be iterated first)
                                 self.ctx_stack.push(proto_ctx);
                                 self.index_stack.push(0);
                             }
                         }
-                        self.ctx_stack.push(ctx_ptr);
-                        self.index_stack.push(0);
                     }
                 }
             } else {