@sema-agent/core 1.294.0 → 1.296.0

package/dist/tools/fs/search.js

@@ -161,6 +161,7 @@ export function walkIsPartial(w) {
 export async function walk(env, root, start, ignore, signal) {
     const out = [];
     const nameOnly = [];
+    const mtimes = new Map();
     let incomplete = false;
     let skippedLarge = 0;
     let skippedUnreadable = 0;
@@ -169,7 +170,10 @@ export async function walk(env, root, start, ignore, signal) {
     const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
     const stack = [{ dir: start, depth: 0 }];
     const visited = new Set();
+    let steps = 0;
     while (stack.length > 0 && out.length < WALK_MAX_FILES) {
+        if (++steps % SCAN_YIELD_EVERY === 0)
+            await yieldEventLoop();
         if (signal?.aborted) {
             aborted = true;
             break;
@@ -199,6 +203,8 @@ export async function walk(env, root, start, ignore, signal) {
             else if (info.kind === "file") {
                 if (ignore(rel(info.path), false))
                     continue;
+                if (typeof info.mtimeMs === "number")
+                    mtimes.set(info.path, info.mtimeMs);
                 if (hasBinaryExtension(info.path)) {
                     if (nameOnly.length < WALK_MAX_FILES)
                         nameOnly.push(info.path);
@@ -224,7 +230,7 @@ export async function walk(env, root, start, ignore, signal) {
     }
     if (stack.length > 0 && out.length >= WALK_MAX_FILES)
         incomplete = true;
-    return { files: out, nameOnly, incomplete, skippedLarge, skippedUnreadable, aborted };
+    return { files: out, nameOnly, incomplete, skippedLarge, skippedUnreadable, aborted, mtimes };
 }
 function walkCaveat(w, forContentSearch) {
     const parts = [];
@@ -240,42 +246,404 @@ function walkCaveat(w, forContentSearch) {
     }
     return parts.length > 0 ? `\n…[results may be incomplete: ${parts.join("; ")}]` : "";
 }
-function compilePattern(p) {
-    if (p.regex) {
-        const re = new RegExp(p.pattern, p.ignore_case ? "i" : "");
-        return (l) => re.test(l);
+const SCAN_YIELD_EVERY = 32;
+const yieldEventLoop = () => new Promise((resolve) => (typeof setImmediate === "function" ? setImmediate(resolve) : setTimeout(resolve, 0)));
+const REDOS_BOUNDED_CEILING = 100;
+const REDOS_AMBIGUOUS_REPEAT_CEILING = 10;
+function analyzeRedos(pattern, ignoreCase = false) {
+    const quantAt = (i) => {
+        const c = pattern[i];
+        if (c === "*" || c === "+")
+            return { len: 1, unbounded: true, max: Infinity, range: true, brace: false };
+        if (c === "?")
+            return { len: 1, unbounded: false, max: 1, range: true, brace: false };
+        if (c === "{") {
+            const m = /^\{(\d+)(?:,(\d*))?\}/.exec(pattern.slice(i));
+            if (!m)
+                return undefined;
+            const lo = Number(m[1]);
+            const hi = m[2] === "" || m[2] === undefined ? (m[2] === "" ? Infinity : lo) : Number(m[2]);
+            return { len: m[0].length, unbounded: hi > REDOS_BOUNDED_CEILING, max: hi, range: lo < hi, brace: true };
+        }
+        return undefined;
+    };
+    let hasNamedGroup = false;
+    const escTokenLen = (s, i) => {
+        const c = s[i + 1];
+        if (c === "x" && /^[0-9a-fA-F]{2}$/.test(s.slice(i + 2, i + 4)))
+            return 4;
+        if (c === "u") {
+            if (/^[0-9a-fA-F]{4}$/.test(s.slice(i + 2, i + 6)))
+                return 6;
+            return 2;
+        }
+        if (c === "c" && /^[a-zA-Z]$/.test(s[i + 2] ?? ""))
+            return 3;
+        if (c === "k" && hasNamedGroup && s[i + 2] === "<") {
+            const close = s.indexOf(">", i + 3);
+            if (close > i + 3)
+                return close - i + 1;
+        }
+        if (c === "0") {
+            let j = i + 2;
+            while (j < s.length && j < i + 4 && s[j] >= "0" && s[j] <= "7")
+                j++;
+            return j - i;
+        }
+        if (c !== undefined && c >= "1" && c <= "9") {
+            let j = i + 2;
+            while (j < s.length && j < i + 10 && s[j] >= "0" && s[j] <= "9")
+                j++;
+            if (Number(s.slice(i + 1, j)) <= captureGroups)
+                return j - i;
+            if (c >= "8")
+                return 2;
+            const maxLen = c <= "3" ? 3 : 2;
+            let k = i + 1;
+            while (k < j && k - i - 1 < maxLen && s[k] >= "0" && s[k] <= "7")
+                k++;
+            return k - i;
+        }
+        return 2;
+    };
+    let captureGroups = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === "\\") {
+            i++;
+            continue;
+        }
+        if (ch === "[") {
+            i++;
+            if (pattern[i] === "^")
+                i++;
+            while (i < pattern.length && pattern[i] !== "]") {
+                if (pattern[i] === "\\")
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        if (ch === "(") {
+            if (pattern[i + 1] !== "?")
+                captureGroups++;
+            else if (pattern[i + 2] === "<" && pattern[i + 3] !== "=" && pattern[i + 3] !== "!") {
+                captureGroups++;
+                hasNamedGroup = true;
+            }
+        }
     }
-    if (p.ignore_case) {
-        const needle = p.pattern.toLowerCase();
-        return (l) => l.toLowerCase().includes(needle);
+    const readClassAtom = (s, pos) => {
+        const ch = s[pos];
+        if (ch === undefined)
+            return undefined;
+        if (ch !== "\\")
+            return { cp: ch, len: 1 };
+        const c = s[pos + 1];
+        if (c === undefined)
+            return undefined;
+        if (c === "x" && /^[0-9a-fA-F]{2}$/.test(s.slice(pos + 2, pos + 4)))
+            return { cp: String.fromCharCode(parseInt(s.slice(pos + 2, pos + 4), 16)), len: 4 };
+        if (c === "u" && /^[0-9a-fA-F]{4}$/.test(s.slice(pos + 2, pos + 6)))
+            return { cp: String.fromCharCode(parseInt(s.slice(pos + 2, pos + 6), 16)), len: 6 };
+        if (c === "c") {
+            if (/^[a-zA-Z0-9_]$/.test(s[pos + 2] ?? ""))
+                return { cp: String.fromCharCode(s[pos + 2].toUpperCase().charCodeAt(0) % 32), len: 3 };
+            return { cp: undefined, len: 2 };
+        }
+        if (c >= "0" && c <= "9") {
+            if (c === "8" || c === "9")
+                return { cp: c, len: 2 };
+            const maxLen = c <= "3" ? 3 : 2;
+            let j = pos + 1;
+            while (j < s.length && j - pos - 1 < maxLen && s[j] >= "0" && s[j] <= "7")
+                j++;
+            return { cp: String.fromCharCode(parseInt(s.slice(pos + 1, j), 8)), len: j - pos };
+        }
+        if (c === "b")
+            return { cp: "\b", len: 2 };
+        if (/[dDwWsS]/.test(c))
+            return { cp: undefined, len: 2 };
+        if (c === "t")
+            return { cp: "\t", len: 2 };
+        if (c === "n")
+            return { cp: "\n", len: 2 };
+        if (c === "r")
+            return { cp: "\r", len: 2 };
+        if (c === "f")
+            return { cp: "\f", len: 2 };
+        if (c === "v")
+            return { cp: "\v", len: 2 };
+        return { cp: c, len: 2 };
+    };
+    const atomKey = (src) => {
+        const canon = (ch) => {
+            if (!ignoreCase)
+                return ch;
+            const u = ch.toUpperCase();
+            if (u.length !== 1)
+                return ch;
+            if (ch.charCodeAt(0) >= 128 && u.charCodeAt(0) < 128)
+                return ch;
+            return u;
+        };
+        const lit = (ch) => `L${canon(ch)}`;
+        if (src.length === 0)
+            return src;
+        if (src[0] !== "\\") {
+            if (src.length === 1)
+                return src === "." ? src : lit(src);
+            if (src[0] === "[" && src.endsWith("]") && src[1] !== "^") {
+                const body = src.slice(1, -1);
+                const a1 = readClassAtom(body, 0);
+                if (a1?.cp !== undefined) {
+                    if (a1.len === body.length)
+                        return lit(a1.cp);
+                    if (body[a1.len] === "-") {
+                        const a2 = readClassAtom(body, a1.len + 1);
+                        if (a2?.cp !== undefined && a1.len + 1 + a2.len === body.length && a1.cp === a2.cp) {
+                            return lit(a1.cp);
+                        }
+                    }
+                }
+                return src;
+            }
+            if (src.startsWith("(?:") && src.endsWith(")")) {
+                const body = src.slice(3, -1);
+                if (body === ".")
+                    return ".";
+                if (body.length === 1 && !"\\^$.|?*+()[]{}".includes(body))
+                    return lit(body);
+                if (body[0] === "\\" && escTokenLen(body, 0) === body.length) {
+                    const k = atomKey(body);
+                    if (k.startsWith("L"))
+                        return k;
+                }
+                if (body[0] === "[") {
+                    const k = atomKey(body);
+                    if (k.startsWith("L"))
+                        return k;
+                }
+                return src;
+            }
+            return src;
+        }
+        const c = src[1];
+        if (c !== undefined && c >= "0" && c <= "9") {
+            const digits = src.slice(1);
+            if (c !== "0" && Number(digits) <= captureGroups)
+                return src;
+            if (c === "8" || c === "9")
+                return digits.length === 1 ? lit(c) : src;
+            if (/^[0-7]{1,3}$/.test(digits) && (digits.length < 3 || digits[0] <= "3")) {
+                return lit(String.fromCharCode(parseInt(digits, 8)));
+            }
+            return src;
+        }
+        if (c === "x" && src.length === 4)
+            return lit(String.fromCharCode(parseInt(src.slice(2), 16)));
+        if (c === "u" && src.length === 6)
+            return lit(String.fromCharCode(parseInt(src.slice(2), 16)));
+        if (c === "c" && src.length === 3)
+            return `L${String.fromCharCode(src[2].toUpperCase().charCodeAt(0) % 32)}`;
+        if (src.length === 2) {
+            if (!/[a-zA-Z]/.test(c))
+                return lit(c);
+            if (/[dDwWsSbB]/.test(c))
+                return src;
+            if (c === "t")
+                return lit("\t");
+            if (c === "n")
+                return lit("\n");
+            if (c === "r")
+                return lit("\r");
+            if (c === "f")
+                return lit("\f");
+            if (c === "v")
+                return lit("\v");
+            if (c === "c")
+                return src;
+            if (c === "k")
+                return hasNamedGroup ? src : lit("k");
+            return lit(c);
+        }
+        return src;
+    };
+    const stack = [{ start: 0, hasUnbounded: false, hasRange: false, hasAlt: false, maxCeil: 1 }];
+    const cur = () => stack[stack.length - 1];
+    const atomCtx = [{}];
+    const atom = () => atomCtx[atomCtx.length - 1];
+    let lastClosedGroup;
+    let quantifiedGroup = false;
+    let unboundedCount = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        const q = quantAt(i);
+        if (q) {
+            const lazy = pattern[i + q.len] === "?" ? 1 : 0;
+            if (q.unbounded)
+                unboundedCount++;
+            const g = lastClosedGroup;
+            const lvl = cur();
+            const ctx = atom();
+            if (g) {
+                quantifiedGroup = true;
+                const snippet = JSON.stringify(pattern.slice(g.start, i + q.len));
+                if (q.unbounded) {
+                    if (g.hasUnbounded)
+                        return { risk: `nested unbounded quantifiers in ${snippet} (an unbounded quantifier applied to a group that itself contains one)`, quantifiedGroup, unboundedCount };
+                    if (g.hasAlt)
+                        return { risk: `quantified alternation in ${snippet} (an unbounded quantifier applied to a group containing "|" — the branches can split the same text many ways)`, quantifiedGroup, unboundedCount };
+                    if (g.hasRange)
+                        return { risk: `ambiguous nested repetition in ${snippet} (an unbounded quantifier applied to a group whose own repetition count can vary)`, quantifiedGroup, unboundedCount };
+                }
+                else if (q.brace && q.max >= 2) {
+                    if (g.hasUnbounded)
+                        return { risk: `nested quantifiers in ${snippet} (an unbounded quantifier inside a group repeated up to ${q.max} times)`, quantifiedGroup, unboundedCount };
+                    if ((g.hasAlt || g.hasRange) && q.max > REDOS_AMBIGUOUS_REPEAT_CEILING)
+                        return { risk: `ambiguous repetition in ${snippet} (a group with ${g.hasAlt ? "alternation" : "variable-count content"} repeated up to ${q.max} times — candidate paths grow exponentially with the repeat count)`, quantifiedGroup, unboundedCount };
+                    if (g.maxCeil >= 2 && g.maxCeil * q.max > REDOS_BOUNDED_CEILING)
+                        return { risk: `compounded bounded repetition in ${snippet} (inner ceiling ${g.maxCeil} × outer ${q.max} exceeds the ${REDOS_BOUNDED_CEILING} safety ceiling)`, quantifiedGroup, unboundedCount };
+                }
+            }
+            const sideUnbounded = q.unbounded && q.range;
+            const atomStart = g ? g.start : ctx.lastAtomStart;
+            if (atomStart !== undefined) {
+                const atomSrc = pattern.slice(atomStart, i);
+                const key = atomKey(atomSrc);
+                const prev = ctx.prevQuant;
+                if (prev && prev.key === key && prev.unbounded && sideUnbounded) {
+                    const snippet = JSON.stringify(pattern.slice(prev.start, i + q.len + lazy));
+                    return {
+                        risk: `adjacent equivalent quantified atoms in ${snippet} (two consecutive unbounded quantifiers apply to the identical atom ${JSON.stringify(atomSrc)} — every split of a matching run between them is a distinct backtracking path, quadratic in line length on non-matching input; merge them into a single quantifier)`,
+                        quantifiedGroup,
+                        unboundedCount,
+                    };
+                }
+                ctx.prevQuant = { key, start: atomStart, unbounded: sideUnbounded };
+            }
+            else
+                ctx.prevQuant = undefined;
+            if (g) {
+                if (q.unbounded)
+                    lvl.hasUnbounded = true;
+                else {
+                    if (q.range)
+                        lvl.hasRange = true;
+                    lvl.maxCeil = Math.max(lvl.maxCeil, Math.max(g.maxCeil, 1) * q.max);
+                }
+            }
+            else if (q.unbounded)
+                lvl.hasUnbounded = true;
+            else {
+                if (q.range)
+                    lvl.hasRange = true;
+                lvl.maxCeil = Math.max(lvl.maxCeil, q.max);
+            }
+            i += q.len + lazy - 1;
+            ctx.lastAtomStart = undefined;
+            lastClosedGroup = undefined;
+            continue;
+        }
+        if (lastClosedGroup !== undefined || atom().lastAtomStart !== undefined)
+            atom().prevQuant = undefined;
+        lastClosedGroup = undefined;
+        if (c === "\\") {
+            atom().lastAtomStart = i;
+            i += escTokenLen(pattern, i) - 1;
+            continue;
+        }
+        if (c === "[") {
+            atom().lastAtomStart = i;
+            i++;
+            if (pattern[i] === "^")
+                i++;
+            while (i < pattern.length && pattern[i] !== "]") {
+                if (pattern[i] === "\\")
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        if (c === "|") {
+            cur().hasAlt = true;
+            const ctx = atom();
+            ctx.lastAtomStart = undefined;
+            ctx.prevQuant = undefined;
+            continue;
+        }
+        if (c === "(") {
+            stack.push({ start: i, hasUnbounded: false, hasRange: false, hasAlt: false, maxCeil: 1 });
+            atomCtx.push({});
+            if (pattern[i + 1] === "?") {
+                const c2 = pattern[i + 2];
+                if (c2 === ":" || c2 === "=" || c2 === "!")
+                    i += 2;
+                else if (c2 === "<") {
+                    const c3 = pattern[i + 3];
+                    if (c3 === "=" || c3 === "!")
+                        i += 3;
+                    else {
+                        const close = pattern.indexOf(">", i + 3);
+                        if (close > 0)
+                            i = close;
+                    }
+                }
+            }
+            continue;
+        }
+        if (c === ")") {
+            if (stack.length === 1)
+                continue;
+            const frame = stack.pop();
+            atomCtx.pop();
+            const lvl = cur();
+            lvl.hasUnbounded ||= frame.hasUnbounded;
+            lvl.hasRange ||= frame.hasRange;
+            lvl.hasAlt ||= frame.hasAlt;
+            lvl.maxCeil = Math.max(lvl.maxCeil, frame.maxCeil);
+            lastClosedGroup = frame;
+            atom().lastAtomStart = undefined;
+            continue;
+        }
+        atom().lastAtomStart = i;
     }
-    return (l) => l.includes(p.pattern);
+    return { quantifiedGroup, unboundedCount };
+}
+export function findRedosRisk(pattern, ignoreCase = false) {
+    return analyzeRedos(pattern, ignoreCase).risk;
+}
+function redosRejection(risk) {
+    return (`Error (grep): pattern rejected by the fallback scanner: ${risk}. ` +
+        `ripgrep is unavailable here, so this pattern would run on a backtracking regex engine where that shape ` +
+        `can hang the scan (catastrophic backtracking). Rewrite it so a repeated group cannot match the same text ` +
+        `in more than one way — remove the nested/variable quantifier or the alternation from the repeated group, ` +
+        `or lower the repetition counts (product ceiling: ${REDOS_BOUNDED_CEILING}).`);
+}
+const GREP_FILE_BUDGET_MS = 2_000;
+const GREP_GRAY_LINE_MAX = 8_192;
+const GREP_LINE_CHECK_EVERY = 256;
+const monotonicNow = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
+class GrepBudgetExceeded extends Error {
+}
+function compilePattern(p) {
+    const re = new RegExp(p.pattern, p.ignore_case ? "i" : "");
+    return (l) => re.test(l);
 }
 function matchedParts(line, p) {
     const parts = [];
-    if (p.regex) {
-        const re = new RegExp(p.pattern, `g${p.ignore_case ? "i" : ""}`);
-        for (let m = re.exec(line); m !== null; m = re.exec(line)) {
-            if (m[0].length > 0)
-                parts.push(m[0]);
-            else
-                re.lastIndex++;
-            if (parts.length > 1000)
-                break;
-        }
-    }
-    else if (p.pattern.length > 0) {
-        const hay = p.ignore_case ? line.toLowerCase() : line;
-        const needle = p.ignore_case ? p.pattern.toLowerCase() : p.pattern;
-        for (let idx = hay.indexOf(needle); idx !== -1; idx = hay.indexOf(needle, idx + needle.length)) {
-            parts.push(line.slice(idx, idx + needle.length));
-            if (parts.length > 1000)
-                break;
-        }
+    const re = new RegExp(p.pattern, `g${p.ignore_case ? "i" : ""}`);
+    for (let m = re.exec(line); m !== null; m = re.exec(line)) {
+        if (m[0].length > 0)
+            parts.push(m[0]);
+        else
+            re.lastIndex++;
+        if (parts.length > 1000)
+            break;
     }
     return parts;
 }
-function multilineSpans(content, p, captureText = false) {
+function multilineSpans(content, p, captureText = false, deadline = Infinity) {
     const spans = [];
     const starts = [0];
     for (let i = 0; i < content.length; i++)
@@ -293,30 +661,33 @@ function multilineSpans(content, p, captureText = false) {
         return lo + 1;
     };
     const MATCH_TEXT_MAX = 2_000;
-    if (p.regex) {
-        const re = new RegExp(p.pattern, `gs${p.ignore_case ? "i" : ""}`);
-        for (let m = re.exec(content); m !== null; m = re.exec(content)) {
-            spans.push([lineAt(m.index), lineAt(m.index + Math.max(0, m[0].length - 1)), captureText ? m[0].slice(0, MATCH_TEXT_MAX) : undefined]);
-            if (m[0].length === 0)
-                re.lastIndex++;
-            if (spans.length > 10_000)
-                break;
-        }
-    }
-    else {
-        const hay = p.ignore_case ? content.toLowerCase() : content;
-        const needle = p.ignore_case ? p.pattern.toLowerCase() : p.pattern;
-        if (needle.length > 0) {
-            for (let idx = hay.indexOf(needle); idx !== -1; idx = hay.indexOf(needle, idx + needle.length)) {
-                spans.push([lineAt(idx), lineAt(idx + needle.length - 1), captureText ? content.slice(idx, idx + Math.min(needle.length, MATCH_TEXT_MAX)) : undefined]);
-                if (spans.length > 10_000)
-                    break;
-            }
-        }
+    const re = new RegExp(p.pattern, `gs${p.ignore_case ? "i" : ""}`);
+    for (;;) {
+        if (monotonicNow() >= deadline)
+            throw new GrepBudgetExceeded();
+        const m = re.exec(content);
+        if (m === null)
+            break;
+        spans.push([lineAt(m.index), lineAt(m.index + Math.max(0, m[0].length - 1)), captureText ? m[0].slice(0, MATCH_TEXT_MAX) : undefined]);
+        if (m[0].length === 0)
+            re.lastIndex++;
+        if (spans.length > 10_000)
+            break;
     }
     return spans;
 }
-export async function jsGrep(env, root, p, signal) {
+export async function jsGrep(env, root, p, signal, guards) {
+    const analysis = analyzeRedos(p.pattern, p.ignore_case === true);
+    if (analysis.risk)
+        return redosRejection(analysis.risk);
+    const budgetMs = guards?.budgetMs ?? GREP_FILE_BUDGET_MS;
+    const longLineLimit = guards?.longLineLimit ?? GREP_GRAY_LINE_MAX;
+    const grayPattern = analysis.quantifiedGroup || analysis.unboundedCount >= 2;
+    const budgetError = (file, elapsedMs) => `Error (grep): scan stopped after ${Math.round(elapsedMs)}ms inside ${file} — the pattern ` +
+        `${JSON.stringify(p.pattern)} is backtracking heavily on this content (fallback-engine budget: ` +
+        `${budgetMs}ms per file). Rewrite the pattern to be more specific, or rerun where ripgrep is available.`;
+    let skippedLongLines = 0;
+    let multilineSkippedFiles = 0;
     let test;
     try {
         test = compilePattern(p);
@@ -332,7 +703,7 @@ export async function jsGrep(env, root, p, signal) {
     let files = walked.files;
     files.sort();
     const cap = p.head_limit === 0 ? Infinity : Math.max(1, Math.floor(p.head_limit ?? GREP_DEFAULT_CAP));
-    const mode = p.output_mode ?? "content";
+    const mode = p.output_mode ?? "files_with_matches";
     const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
     const relOut = (abs) => {
         const r = rel(abs);
@@ -366,7 +737,10 @@ export async function jsGrep(env, root, p, signal) {
     let totalFiles = 0;
     let skippedUnreadableFiles = 0;
     let scanAborted = false;
+    let scanned = 0;
     for (const f of files) {
+        if (++scanned % SCAN_YIELD_EVERY === 0)
+            await yieldEventLoop();
         if (signal?.aborted) {
             scanAborted = true;
             break;
@@ -384,12 +758,19 @@ export async function jsGrep(env, root, p, signal) {
         if (lines.length > 1 && lines.at(-1) === "")
             lines.pop();
         let fileCount = 0;
+        const fileMatchStart = monotonicNow();
         if (p.multiline) {
+            if (grayPattern && read.value.length > longLineLimit) {
+                multilineSkippedFiles++;
+                continue;
+            }
             let spans;
             try {
-                spans = multilineSpans(read.value, p, mode === "content" && p.only_matching === true);
+                spans = multilineSpans(read.value, p, mode === "content" && p.only_matching === true, fileMatchStart + budgetMs);
             }
             catch (e) {
+                if (e instanceof GrepBudgetExceeded)
+                    return budgetError(relOut(f), monotonicNow() - fileMatchStart);
                 return `Error (grep): invalid regex: ${e instanceof Error ? e.message : String(e)}`;
             }
             fileCount = spans.length;
@@ -412,6 +793,22 @@ export async function jsGrep(env, root, p, signal) {
         }
         else {
             for (let i = 0; i < lines.length; i++) {
+                if (grayPattern || (i > 0 && i % GREP_LINE_CHECK_EVERY === 0)) {
+                    const elapsed = monotonicNow() - fileMatchStart;
+                    if (elapsed >= budgetMs)
+                        return budgetError(relOut(f), elapsed);
+                }
+                if (i > 0 && i % GREP_LINE_CHECK_EVERY === 0) {
+                    await yieldEventLoop();
+                    if (signal?.aborted) {
+                        scanAborted = true;
+                        break;
+                    }
+                }
+                if (grayPattern && lines[i].length > longLineLimit) {
+                    skippedLongLines++;
+                    continue;
+                }
                 if (!test(lines[i]))
                     continue;
                 fileCount++;
@@ -434,6 +831,8 @@ export async function jsGrep(env, root, p, signal) {
                 }
             }
         }
+        if (scanAborted)
+            break;
         if (mode === "content")
             totalContent += fileCount;
         if (fileCount > 0) {
@@ -444,12 +843,16 @@ export async function jsGrep(env, root, p, signal) {
                 counts.push(`${relOut(f)}:${fileCount}`);
         }
     }
-    if (scanAborted || skippedUnreadableFiles > 0) {
+    if (scanAborted || skippedUnreadableFiles > 0 || skippedLongLines > 0 || multilineSkippedFiles > 0) {
         const extra = [];
         if (scanAborted && !walked.aborted)
             extra.push("the search was interrupted before finishing");
         if (skippedUnreadableFiles > 0)
             extra.push(`${skippedUnreadableFiles} file(s) could not be read and were skipped`);
+        if (skippedLongLines > 0)
+            extra.push(`${skippedLongLines} line(s) over ${longLineLimit} chars were not matched (the pattern's worst-case matching cost grows superlinearly with line length on the fallback engine)`);
+        if (multilineSkippedFiles > 0)
+            extra.push(`${multilineSkippedFiles} file(s) skipped by multiline matching (content over ${longLineLimit} chars; the pattern's worst-case matching cost grows superlinearly with input length on the fallback engine)`);
         if (extra.length > 0) {
             caveat = caveat.length > 0
                 ? caveat.replace(/\]$/, `; ${extra.join("; ")}]`)
@@ -514,11 +917,9 @@ async function jsGrepFallback(env, root, p, signal, reason) {
     };
 }
 export async function rgGrepDetailed(env, root, p, signal) {
-    const mode = p.output_mode ?? "content";
+    const mode = p.output_mode ?? "files_with_matches";
     const flags = ["--no-messages", "--no-require-git"];
     flags.push("--max-columns", "500", "--max-columns-preview");
-    if (!p.regex)
-        flags.push("-F");
     if (p.ignore_case)
         flags.push("-i");
     if (p.multiline)
@@ -601,7 +1002,14 @@ export async function runGlobDetailed(env, root, pattern, opts = {}, signal) {
     const re = globTokenToRegExp(pattern, false, true);
     const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
     const cap = Math.max(1, Math.floor(opts.max ?? 500));
-    const matchedAll = files.filter((f) => re.test(rel(f)) || re.test(basename(f))).map(rel).sort();
+    const matchedAbs = files.filter((f) => re.test(rel(f)) || re.test(basename(f)));
+    const haveMtimes = matchedAbs.length > 0 && matchedAbs.every((f) => walked.mtimes.has(f));
+    const matchedAll = haveMtimes
+        ? matchedAbs
+            .map((f) => ({ r: rel(f), m: walked.mtimes.get(f) }))
+            .sort((a, b) => b.m - a.m || (a.r < b.r ? -1 : a.r > b.r ? 1 : 0))
+            .map((x) => x.r)
+        : matchedAbs.map(rel).sort();
     const matched = matchedAll.slice(0, cap);
     const totalMatches = matchedAll.length;
     const countIsComplete = !walkIsPartial(walked);