@smthrs/std 0.0.0-stage → 1.0.0-rc.4

package/dist/esm/internal/Ignore.js

@@ -0,0 +1,128 @@
+/**
+ * Root-scoped gitignore rules, compiled once per visited directory.
+ *
+ * @since 1.0.0
+ */
+import { escapeRegex } from "./SearchContract.js";
+// Like the search glob contract, rg's globset matches UTF-8 bytes, not code points.
+const bytes = (value) => /[^\x20-\x7e]/.test(value)
+    ? Array.from(new TextEncoder().encode(value), (byte) => String.fromCharCode(byte)).join("")
+    : value;
+// The caller-glob subset cannot parse ignore files: escapes and classes are
+// intentionally refused there. Keep their richer grammar here, including rg's
+// brace alternatives. Invalid lines are skipped without discarding valid rules.
+const expression = (pattern) => {
+    let source = "";
+    const groups = [];
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern[index];
+        if (character === "\\") {
+            if (++index === pattern.length)
+                throw new Error("dangling escape");
+            source += escapeRegex(pattern[index]);
+        }
+        else if (character === "[") {
+            let end = index + 1;
+            const negated = pattern[end] === "!" || pattern[end] === "^";
+            if (negated)
+                end++;
+            if (pattern[end] === "]")
+                end++;
+            end = pattern.indexOf("]", end);
+            if (end < 0)
+                source += "\\[";
+            else {
+                const content = pattern.slice(index + (negated ? 2 : 1), end);
+                source += `[${negated ? "^" : ""}${content.replace(/[\\[\]^]/g, "\\$&")}]`;
+                index = end;
+            }
+        }
+        else if (character === "{") {
+            groups.push({ prefix: source, alternatives: [] });
+            source = "";
+        }
+        else if (character === "," && groups.length > 0) {
+            groups[groups.length - 1].alternatives.push(source);
+            source = "";
+        }
+        else if (character === "}") {
+            const group = groups.pop();
+            if (group === undefined)
+                throw new Error("unopened alternatives");
+            const alternatives = [...group.alternatives, source].filter((part) => part.length > 0);
+            source = group.prefix + (alternatives.length > 0 ? `(?:${alternatives.join("|")})` : "");
+        }
+        else if (character === "*" && pattern[index + 1] === "*" &&
+            (index === 0 || "/{,".includes(pattern[index - 1])) &&
+            (pattern[index + 2] === undefined || "/},".includes(pattern[index + 2]))) {
+            source += pattern[index + 2] === "/" ? "(?:.*/)?" : ".*";
+            index += pattern[index + 2] === "/" ? 2 : 1;
+        }
+        else if (character === "*")
+            source += "[^/]*";
+        else if (character === "?")
+            source += "[^/]";
+        else
+            source += escapeRegex(character);
+    }
+    if (groups.length > 0)
+        throw new Error("unclosed alternatives");
+    return new RegExp(`^(?:${source})$`);
+};
+/**
+ * Parses gitignore lines without widening the caller-glob grammar.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const parse = (directory, content) => {
+    const rules = [];
+    for (let line of content.replace(/^\uFEFF/, "").split(/\r?\n/)) {
+        if (line.startsWith("#"))
+            continue;
+        // Match rg's gitignore parser: an escaped final space preserves whitespace.
+        if (!line.endsWith("\\ "))
+            line = line.trimEnd();
+        if (line.length === 0)
+            continue;
+        const negated = line.startsWith("!");
+        if (negated)
+            line = line.slice(1);
+        const rooted = line.startsWith("/");
+        if (rooted)
+            line = line.slice(1);
+        const directoryOnly = line.endsWith("/");
+        if (directoryOnly)
+            line = line.slice(0, -1).replace(/\\$/, "");
+        const byPath = rooted || line.includes("/");
+        try {
+            rules.push({ expression: expression(bytes(line)), negated, directoryOnly, byPath });
+        }
+        catch {
+            // rg --no-messages also tolerates malformed rules and unreadable files.
+        }
+    }
+    return { directory, rules };
+};
+/**
+ * Tests an entry before descent; deeper scopes and later rules take priority.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const ignored = (scopes, candidate, basename, directory, relative) => {
+    // The nearest ignore file wins; within a file, the last matching line wins.
+    for (let scopeIndex = scopes.length - 1; scopeIndex >= 0; scopeIndex--) {
+        const scope = scopes[scopeIndex];
+        const scoped = bytes(relative(scope.directory, candidate));
+        for (let index = scope.rules.length - 1; index >= 0; index--) {
+            const rule = scope.rules[index];
+            if (rule.directoryOnly && !directory)
+                continue;
+            if (rule.expression.test(rule.byPath ? scoped : bytes(basename)))
+                return !rule.negated;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=Ignore.js.map

package/dist/esm/internal/Ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ignore.js","sourceRoot":"","sources":["../../../src/internal/Ignore.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Root-scoped gitignore rules, compiled once per visited directory.\n *\n * @since 1.0.0\n */\n\nimport { escapeRegex } from \"./SearchContract.ts\"\n\ninterface Rule {\n  readonly expression: RegExp\n  readonly directoryOnly: boolean\n  readonly negated: boolean\n  readonly byPath: boolean\n}\n\n/**\n * Rules belonging to one visited directory.\n *\n * @private\n * @since 1.0.0\n */\nexport interface Scope {\n  readonly directory: string\n  readonly rules: ReadonlyArray<Rule>\n}\n\n// Like the search glob contract, rg's globset matches UTF-8 bytes, not code points.\nconst bytes = (value: string): string =>\n  /[^\\x20-\\x7e]/.test(value)\n    ? Array.from(new TextEncoder().encode(value), (byte) => String.fromCharCode(byte)).join(\"\")\n    : value\n\n// The caller-glob subset cannot parse ignore files: escapes and classes are\n// intentionally refused there. Keep their richer grammar here, including rg's\n// brace alternatives. Invalid lines are skipped without discarding valid rules.\nconst expression = (pattern: string): RegExp => {\n  let source = \"\"\n  const groups: Array<{ prefix: string; alternatives: Array<string> }> = []\n  for (let index = 0; index < pattern.length; index++) {\n    const character = pattern[index]!\n    if (character === \"\\\\\") {\n      if (++index === pattern.length) throw new Error(\"dangling escape\")\n      source += escapeRegex(pattern[index]!)\n    } else if (character === \"[\") {\n      let end = index + 1\n      const negated = pattern[end] === \"!\" || pattern[end] === \"^\"\n      if (negated) end++\n      if (pattern[end] === \"]\") end++\n      end = pattern.indexOf(\"]\", end)\n      if (end < 0) source += \"\\\\[\"\n      else {\n        const content = pattern.slice(index + (negated ? 2 : 1), end)\n        source += `[${negated ? \"^\" : \"\"}${content.replace(/[\\\\[\\]^]/g, \"\\\\$&\")}]`\n        index = end\n      }\n    } else if (character === \"{\") {\n      groups.push({ prefix: source, alternatives: [] })\n      source = \"\"\n    } else if (character === \",\" && groups.length > 0) {\n      groups[groups.length - 1]!.alternatives.push(source)\n      source = \"\"\n    } else if (character === \"}\") {\n      const group = groups.pop()\n      if (group === undefined) throw new Error(\"unopened alternatives\")\n      const alternatives = [...group.alternatives, source].filter((part) => part.length > 0)\n      source = group.prefix + (alternatives.length > 0 ? `(?:${alternatives.join(\"|\")})` : \"\")\n    } else if (\n      character === \"*\" && pattern[index + 1] === \"*\" &&\n      (index === 0 || \"/{,\".includes(pattern[index - 1]!)) &&\n      (pattern[index + 2] === undefined || \"/},\".includes(pattern[index + 2]!))\n    ) {\n      source += pattern[index + 2] === \"/\" ? \"(?:.*/)?\" : \".*\"\n      index += pattern[index + 2] === \"/\" ? 2 : 1\n    } else if (character === \"*\") source += \"[^/]*\"\n    else if (character === \"?\") source += \"[^/]\"\n    else source += escapeRegex(character)\n  }\n  if (groups.length > 0) throw new Error(\"unclosed alternatives\")\n  return new RegExp(`^(?:${source})$`)\n}\n\n/**\n * Parses gitignore lines without widening the caller-glob grammar.\n *\n * @private\n * @since 1.0.0\n */\nexport const parse = (directory: string, content: string): Scope => {\n  const rules: Array<Rule> = []\n  for (let line of content.replace(/^\\uFEFF/, \"\").split(/\\r?\\n/)) {\n    if (line.startsWith(\"#\")) continue\n    // Match rg's gitignore parser: an escaped final space preserves whitespace.\n    if (!line.endsWith(\"\\\\ \")) line = line.trimEnd()\n    if (line.length === 0) continue\n    const negated = line.startsWith(\"!\")\n    if (negated) line = line.slice(1)\n    const rooted = line.startsWith(\"/\")\n    if (rooted) line = line.slice(1)\n    const directoryOnly = line.endsWith(\"/\")\n    if (directoryOnly) line = line.slice(0, -1).replace(/\\\\$/, \"\")\n    const byPath = rooted || line.includes(\"/\")\n    try {\n      rules.push({ expression: expression(bytes(line)), negated, directoryOnly, byPath })\n    } catch {\n      // rg --no-messages also tolerates malformed rules and unreadable files.\n    }\n  }\n  return { directory, rules }\n}\n\n/**\n * Tests an entry before descent; deeper scopes and later rules take priority.\n *\n * @private\n * @since 1.0.0\n */\nexport const ignored = (\n  scopes: ReadonlyArray<Scope>,\n  candidate: string,\n  basename: string,\n  directory: boolean,\n  relative: (from: string, to: string) => string\n): boolean => {\n  // The nearest ignore file wins; within a file, the last matching line wins.\n  for (let scopeIndex = scopes.length - 1; scopeIndex >= 0; scopeIndex--) {\n    const scope = scopes[scopeIndex]!\n    const scoped = bytes(relative(scope.directory, candidate))\n    for (let index = scope.rules.length - 1; index >= 0; index--) {\n      const rule = scope.rules[index]!\n      if (rule.directoryOnly && !directory) continue\n      if (rule.expression.test(rule.byPath ? scoped : bytes(basename))) return !rule.negated\n    }\n  }\n  return false\n}\n"]}

package/dist/esm/internal/LinearRegex.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Thompson matching for the validated ASCII search grammar. Each state is
+ * visited once per input position; alternatives never backtrack over input.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Compiles an already syntax-validated pattern. Compilation is bounded to
+ * 8192 states and 128 nested groups, including expanded counted repetitions.
+ * The iterator yields every 4096 state visits so the host can dispatch timers
+ * and interruption even for long lines and expensive linear matches.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const compile: (pattern: string, insensitive: boolean) => {
+    readonly test: (line: string) => Generator<void, boolean>;
+};
+//# sourceMappingURL=LinearRegex.d.ts.map

package/dist/esm/internal/LinearRegex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearRegex.d.ts","sourceRoot":"","sources":["../../../src/internal/LinearRegex.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAClB,SAAS,MAAM,EACf,aAAa,OAAO,KACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;CA8I7D,CAAA"}

package/dist/esm/internal/LinearRegex.js

@@ -0,0 +1,176 @@
+/**
+ * Thompson matching for the validated ASCII search grammar. Each state is
+ * visited once per input position; alternatives never backtrack over input.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Compiles an already syntax-validated pattern. Compilation is bounded to
+ * 8192 states and 128 nested groups, including expanded counted repetitions.
+ * The iterator yields every 4096 state visits so the host can dispatch timers
+ * and interruption even for long lines and expensive linear matches.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const compile = (pattern, insensitive) => {
+    let offset = 0;
+    const parse = (depth) => {
+        if (depth > 128)
+            throw new Error("patterns must not exceed 128 nested groups");
+        const alternatives = [];
+        let sequence = [];
+        while (offset < pattern.length && pattern[offset] !== ")") {
+            const start = offset;
+            const character = pattern[offset++];
+            if (character === "|") {
+                alternatives.push({ kind: "sequence", terms: sequence });
+                sequence = [];
+                continue;
+            }
+            let term;
+            if (character === "(") {
+                term = parse(depth + 1);
+                offset++;
+            }
+            else {
+                if (character === "\\")
+                    offset++;
+                if (character === "[") {
+                    while (pattern[offset] !== "]") {
+                        if (pattern[offset++] === "\\")
+                            offset++;
+                    }
+                    offset++;
+                }
+                term = { kind: "atom", source: pattern.slice(start, offset) };
+            }
+            const quantifier = pattern[offset];
+            if (quantifier === "*" || quantifier === "+" || quantifier === "?" || quantifier === "{") {
+                offset++;
+                let min = quantifier === "+" ? 1 : 0;
+                let max = quantifier === "?" ? 1 : Infinity;
+                if (quantifier === "{") {
+                    const end = pattern.indexOf("}", offset);
+                    const counts = pattern.slice(offset, end).split(",");
+                    min = Number(counts[0]);
+                    max = counts.length === 1 ? min : counts[1] === "" ? Infinity : Number(counts[1]);
+                    offset = end + 1;
+                }
+                // Greediness affects captures, not whether a line contains a match.
+                if (pattern[offset] === "?")
+                    offset++;
+                term = { kind: "repeat", term, min, max };
+            }
+            sequence.push(term);
+        }
+        alternatives.push({ kind: "sequence", terms: sequence });
+        return { kind: "alternative", terms: alternatives };
+    };
+    const tree = parse(0);
+    const states = [{ kind: "accept" }];
+    const append = (state) => {
+        if (states.length >= 8192)
+            throw new Error("patterns must not exceed 8192 compiled states");
+        states.push(state);
+        return states.length - 1;
+    };
+    const build = (term, next) => {
+        switch (term.kind) {
+            case "atom":
+                if (term.source === "^")
+                    return append({ kind: "start", next });
+                if (term.source === "$")
+                    return append({ kind: "end", next });
+                return append({
+                    kind: "atom",
+                    expression: new RegExp(term.source === "." ? "[^\\n]" : term.source, insensitive ? "iu" : "u"),
+                    next
+                });
+            case "sequence": {
+                let head = next;
+                for (let index = term.terms.length - 1; index >= 0; index--)
+                    head = build(term.terms[index], head);
+                return head;
+            }
+            case "alternative":
+                return append({ kind: "split", next: term.terms.map((child) => build(child, next)) });
+            case "repeat": {
+                let head = next;
+                if (term.max === Infinity) {
+                    const loop = append({ kind: "split", next: [] });
+                    states[loop] = { kind: "split", next: [next, build(term.term, loop)] };
+                    head = loop;
+                }
+                else {
+                    for (let index = term.min; index < term.max; index++) {
+                        head = append({ kind: "split", next: [head, build(term.term, head)] });
+                    }
+                }
+                for (let index = 0; index < term.min; index++)
+                    head = build(term.term, head);
+                return head;
+            }
+        }
+    };
+    const start = build(tree, 0);
+    return {
+        *test(line) {
+            let current = [];
+            let position = 0;
+            let work = 0;
+            const seen = new Int32Array(states.length);
+            let generation = 0;
+            while (true) {
+                generation++;
+                const pending = [...current, start];
+                const consuming = [];
+                while (pending.length > 0) {
+                    if (++work === 4096) {
+                        work = 0;
+                        yield;
+                    }
+                    const id = pending.pop();
+                    if (seen[id] === generation)
+                        continue;
+                    seen[id] = generation;
+                    const state = states[id];
+                    switch (state.kind) {
+                        case "accept":
+                            return true;
+                        case "atom":
+                            consuming.push(id);
+                            break;
+                        case "split":
+                            for (const next of state.next)
+                                pending.push(next);
+                            break;
+                        case "start":
+                            if (position === 0)
+                                pending.push(state.next);
+                            break;
+                        case "end":
+                            if (position === line.length)
+                                pending.push(state.next);
+                            break;
+                    }
+                }
+                if (position === line.length)
+                    return false;
+                const character = String.fromCodePoint(line.codePointAt(position));
+                position += character.length;
+                current = [];
+                for (const id of consuming) {
+                    if (++work === 4096) {
+                        work = 0;
+                        yield;
+                    }
+                    const state = states[id];
+                    if (state.kind === "atom" && state.expression.test(character))
+                        current.push(state.next);
+                }
+            }
+        }
+    };
+};
+//# sourceMappingURL=LinearRegex.js.map

package/dist/esm/internal/LinearRegex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearRegex.js","sourceRoot":"","sources":["../../../src/internal/LinearRegex.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Thompson matching for the validated ASCII search grammar. Each state is\n * visited once per input position; alternatives never backtrack over input.\n *\n * @since 1.0.0\n */\n\ntype Term =\n  | { readonly kind: \"atom\"; readonly source: string }\n  | { readonly kind: \"sequence\" | \"alternative\"; readonly terms: ReadonlyArray<Term> }\n  | { readonly kind: \"repeat\"; readonly term: Term; readonly min: number; readonly max: number }\n\ntype State =\n  | { readonly kind: \"atom\"; readonly expression: RegExp; readonly next: number }\n  | { readonly kind: \"start\" | \"end\"; readonly next: number }\n  | { readonly kind: \"split\"; readonly next: ReadonlyArray<number> }\n  | { readonly kind: \"accept\" }\n\n/**\n * Compiles an already syntax-validated pattern. Compilation is bounded to\n * 8192 states and 128 nested groups, including expanded counted repetitions.\n * The iterator yields every 4096 state visits so the host can dispatch timers\n * and interruption even for long lines and expensive linear matches.\n *\n * @private\n * @since 1.0.0\n */\nexport const compile = (\n  pattern: string,\n  insensitive: boolean\n): { readonly test: (line: string) => Generator<void, boolean> } => {\n  let offset = 0\n  const parse = (depth: number): Term => {\n    if (depth > 128) throw new Error(\"patterns must not exceed 128 nested groups\")\n    const alternatives: Array<Term> = []\n    let sequence: Array<Term> = []\n    while (offset < pattern.length && pattern[offset] !== \")\") {\n      const start = offset\n      const character = pattern[offset++]!\n      if (character === \"|\") {\n        alternatives.push({ kind: \"sequence\", terms: sequence })\n        sequence = []\n        continue\n      }\n      let term: Term\n      if (character === \"(\") {\n        term = parse(depth + 1)\n        offset++\n      } else {\n        if (character === \"\\\\\") offset++\n        if (character === \"[\") {\n          while (pattern[offset] !== \"]\") {\n            if (pattern[offset++] === \"\\\\\") offset++\n          }\n          offset++\n        }\n        term = { kind: \"atom\", source: pattern.slice(start, offset) }\n      }\n      const quantifier = pattern[offset]\n      if (quantifier === \"*\" || quantifier === \"+\" || quantifier === \"?\" || quantifier === \"{\") {\n        offset++\n        let min = quantifier === \"+\" ? 1 : 0\n        let max = quantifier === \"?\" ? 1 : Infinity\n        if (quantifier === \"{\") {\n          const end = pattern.indexOf(\"}\", offset)\n          const counts = pattern.slice(offset, end).split(\",\")\n          min = Number(counts[0])\n          max = counts.length === 1 ? min : counts[1] === \"\" ? Infinity : Number(counts[1])\n          offset = end + 1\n        }\n        // Greediness affects captures, not whether a line contains a match.\n        if (pattern[offset] === \"?\") offset++\n        term = { kind: \"repeat\", term, min, max }\n      }\n      sequence.push(term)\n    }\n    alternatives.push({ kind: \"sequence\", terms: sequence })\n    return { kind: \"alternative\", terms: alternatives }\n  }\n  const tree = parse(0)\n  const states: Array<State> = [{ kind: \"accept\" }]\n  const append = (state: State): number => {\n    if (states.length >= 8192) throw new Error(\"patterns must not exceed 8192 compiled states\")\n    states.push(state)\n    return states.length - 1\n  }\n  const build = (term: Term, next: number): number => {\n    switch (term.kind) {\n      case \"atom\":\n        if (term.source === \"^\") return append({ kind: \"start\", next })\n        if (term.source === \"$\") return append({ kind: \"end\", next })\n        return append({\n          kind: \"atom\",\n          expression: new RegExp(term.source === \".\" ? \"[^\\\\n]\" : term.source, insensitive ? \"iu\" : \"u\"),\n          next\n        })\n      case \"sequence\": {\n        let head = next\n        for (let index = term.terms.length - 1; index >= 0; index--) head = build(term.terms[index]!, head)\n        return head\n      }\n      case \"alternative\":\n        return append({ kind: \"split\", next: term.terms.map((child) => build(child, next)) })\n      case \"repeat\": {\n        let head = next\n        if (term.max === Infinity) {\n          const loop = append({ kind: \"split\", next: [] })\n          states[loop] = { kind: \"split\", next: [next, build(term.term, loop)] }\n          head = loop\n        } else {\n          for (let index = term.min; index < term.max; index++) {\n            head = append({ kind: \"split\", next: [head, build(term.term, head)] })\n          }\n        }\n        for (let index = 0; index < term.min; index++) head = build(term.term, head)\n        return head\n      }\n    }\n  }\n  const start = build(tree, 0)\n  return {\n    *test(line) {\n      let current: Array<number> = []\n      let position = 0\n      let work = 0\n      const seen = new Int32Array(states.length)\n      let generation = 0\n      while (true) {\n        generation++\n        const pending = [...current, start]\n        const consuming: Array<number> = []\n        while (pending.length > 0) {\n          if (++work === 4096) {\n            work = 0\n            yield\n          }\n          const id = pending.pop()!\n          if (seen[id] === generation) continue\n          seen[id] = generation\n          const state = states[id]!\n          switch (state.kind) {\n            case \"accept\":\n              return true\n            case \"atom\":\n              consuming.push(id)\n              break\n            case \"split\":\n              for (const next of state.next) pending.push(next)\n              break\n            case \"start\":\n              if (position === 0) pending.push(state.next)\n              break\n            case \"end\":\n              if (position === line.length) pending.push(state.next)\n              break\n          }\n        }\n        if (position === line.length) return false\n        const character = String.fromCodePoint(line.codePointAt(position)!)\n        position += character.length\n        current = []\n        for (const id of consuming) {\n          if (++work === 4096) {\n            work = 0\n            yield\n          }\n          const state = states[id]!\n          if (state.kind === \"atom\" && state.expression.test(character)) current.push(state.next)\n        }\n      }\n    }\n  }\n}\n"]}

package/dist/esm/internal/Match.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Exact block location, and the pre-image reported when it misses.
+ *
+ * The editing flows locate a caller's block byte-exactly and refuse everything
+ * else. The tolerant cascade this module used to apply — trailing-whitespace
+ * insensitive, then inner-whitespace collapsed — is gone from the *apply* path,
+ * because a match that is not the caller's bytes is an edit the caller never
+ * inspected: on django-11490 a sixteen-space anchor matched inside a
+ * twenty-space line and silently dedented a guard, and on sympy-15380 a
+ * "successful" fuzzy apply corrupted the file it reported editing. Prior art is
+ * `reference/opencode`'s replacer cascade (`tool/edit.ts`), and this is where we
+ * deviate from it deliberately.
+ *
+ * The cascade survives as *diagnosis*. A miss is only expensive when it is
+ * silent: the agent re-reads, re-guesses, and re-misses. {@link nearest} runs
+ * the same loose strategies to find where the caller's block actually sits and
+ * returns that region's real bytes and line range, so the failing cell can
+ * re-anchor from reality inside the same frame rather than buying another one.
+ *
+ * @since 1.0.0
+ */
+/**
+ * One located block: the exact source span the needle matched.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Located {
+    readonly start: number;
+    readonly end: number;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+/**
+ * The real file region nearest a needle that did not match.
+ *
+ * `text` is raw file bytes, never line-number prefixed, so a caller can quote it
+ * back as an anchor without editing it first.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Nearest {
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly text: string;
+}
+/**
+ * The 1-based line a byte offset falls on.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export declare const lineAt: (content: string, offset: number) => number;
+/**
+ * Every byte-exact occurrence of `needle` in `content`.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export declare const locate: (content: string, needle: string) => ReadonlyArray<Located>;
+/**
+ * The real region a failed needle was aiming at, with its line range.
+ *
+ * The loose strategies run in order — trailing whitespace, then collapsed inner
+ * whitespace, then the needle's first non-blank line alone — and the first that
+ * locates a region wins. `undefined` means not even one line of the needle
+ * occurs in the file, which is itself the answer: this is the wrong file.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export declare const nearest: (content: string, needle: string, pad?: number) => Nearest | undefined;
+/**
+ * The applied region rendered back for inspection: raw bytes, plus its range.
+ *
+ * A bad edit is only expensive when it is invisible. sphinx-7233 lost its
+ * verdict to an in-cell string surgery that captured an `else` branch, and the
+ * model never saw the hunk it had written.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export declare const hunk: (content: string, start: number, end: number, pad?: number) => Nearest;
+//# sourceMappingURL=Match.d.ts.map

package/dist/esm/internal/Match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Match.d.ts","sourceRoot":"","sources":["../../../src/internal/Match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,KAAG,MAMxD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,KAAG,aAAa,CAAC,OAAO,CAyB7E,CAAA;AA0BD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,YAAO,KAAG,OAAO,GAAG,SAkB5E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS,MAAM,EAAE,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,YAAO,KAAG,OAO3E,CAAA"}

package/dist/esm/internal/Match.js

@@ -0,0 +1,142 @@
+/**
+ * Exact block location, and the pre-image reported when it misses.
+ *
+ * The editing flows locate a caller's block byte-exactly and refuse everything
+ * else. The tolerant cascade this module used to apply — trailing-whitespace
+ * insensitive, then inner-whitespace collapsed — is gone from the *apply* path,
+ * because a match that is not the caller's bytes is an edit the caller never
+ * inspected: on django-11490 a sixteen-space anchor matched inside a
+ * twenty-space line and silently dedented a guard, and on sympy-15380 a
+ * "successful" fuzzy apply corrupted the file it reported editing. Prior art is
+ * `reference/opencode`'s replacer cascade (`tool/edit.ts`), and this is where we
+ * deviate from it deliberately.
+ *
+ * The cascade survives as *diagnosis*. A miss is only expensive when it is
+ * silent: the agent re-reads, re-guesses, and re-misses. {@link nearest} runs
+ * the same loose strategies to find where the caller's block actually sits and
+ * returns that region's real bytes and line range, so the failing cell can
+ * re-anchor from reality inside the same frame rather than buying another one.
+ *
+ * @since 1.0.0
+ */
+import { sourceLines } from "./Text.js";
+/**
+ * The 1-based line a byte offset falls on.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export const lineAt = (content, offset) => {
+    let line = 1;
+    for (let index = 0; index < offset && index < content.length; index++) {
+        if (content[index] === "\n")
+            line++;
+    }
+    return line;
+};
+/**
+ * Every byte-exact occurrence of `needle` in `content`.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export const locate = (content, needle) => {
+    const found = [];
+    let cursor = content.indexOf(needle);
+    let line = 1;
+    let scanned = 0;
+    while (cursor >= 0) {
+        for (let index = scanned; index < cursor; index++) {
+            if (content[index] === "\n")
+                line++;
+        }
+        scanned = cursor;
+        const startLine = line;
+        let endLine = line;
+        for (let index = 0; index < needle.length - 1; index++) {
+            if (needle[index] === "\n")
+                endLine++;
+        }
+        found.push({ start: cursor, end: cursor + needle.length, startLine, endLine });
+        // Resume past the match, not one byte into it. A caller replaces these spans
+        // in order, so overlapping occurrences are not separately replaceable: in
+        // "aaa" the anchor "aa" is reported once, because consuming the first
+        // occurrence leaves no second one. Scanning by one byte instead reported
+        // both, and the splice wrote the replacement over bytes the first span
+        // already owned.
+        cursor = content.indexOf(needle, cursor + needle.length);
+    }
+    return found;
+};
+const trimmedRight = (line) => line.replace(/[ \t]+$/, "");
+const collapsed = (line) => line.replace(/[ \t]+/g, " ").trim();
+const matchByLine = (haystack, wanted, normalize) => {
+    const target = wanted.map(normalize);
+    const normalized = haystack.map(normalize);
+    for (let index = 0; index + target.length <= haystack.length; index++) {
+        let matched = true;
+        for (let step = 0; step < target.length; step++) {
+            if (normalized[index + step] !== target[step]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            return index;
+    }
+    return -1;
+};
+/**
+ * The real region a failed needle was aiming at, with its line range.
+ *
+ * The loose strategies run in order — trailing whitespace, then collapsed inner
+ * whitespace, then the needle's first non-blank line alone — and the first that
+ * locates a region wins. `undefined` means not even one line of the needle
+ * occurs in the file, which is itself the answer: this is the wrong file.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export const nearest = (content, needle, pad = 3) => {
+    const haystack = sourceLines(content);
+    const wanted = [...sourceLines(needle)];
+    while (wanted.length > 0 && wanted[wanted.length - 1] === "")
+        wanted.pop();
+    if (wanted.length === 0)
+        return undefined;
+    let at = matchByLine(haystack, wanted, trimmedRight);
+    let span = wanted.length;
+    if (at < 0)
+        at = matchByLine(haystack, wanted, collapsed);
+    if (at < 0) {
+        const anchor = wanted.map(collapsed).find((line) => line !== "");
+        if (anchor === undefined)
+            return undefined;
+        at = haystack.findIndex((line) => collapsed(line) === anchor);
+        span = 1;
+    }
+    if (at < 0)
+        return undefined;
+    const from = Math.max(0, at - pad);
+    const to = Math.min(haystack.length, at + span + pad);
+    return { startLine: from + 1, endLine: to, text: haystack.slice(from, to).join("\n") };
+};
+/**
+ * The applied region rendered back for inspection: raw bytes, plus its range.
+ *
+ * A bad edit is only expensive when it is invisible. sphinx-7233 lost its
+ * verdict to an in-cell string surgery that captured an `else` branch, and the
+ * model never saw the hunk it had written.
+ *
+ * @category matching
+ * @since 1.0.0
+ */
+export const hunk = (content, start, end, pad = 2) => {
+    const startLine = lineAt(content, start);
+    const endLine = startLine + Math.max(0, content.slice(start, end).split("\n").length - 1);
+    const haystack = sourceLines(content);
+    const from = Math.max(0, startLine - 1 - pad);
+    const to = Math.min(haystack.length, endLine + pad);
+    return { startLine: from + 1, endLine: to, text: haystack.slice(from, to).join("\n") };
+};
+//# sourceMappingURL=Match.js.map

package/dist/esm/internal/Match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Match.js","sourceRoot":"","sources":["../../../src/internal/Match.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Exact block location, and the pre-image reported when it misses.\n *\n * The editing flows locate a caller's block byte-exactly and refuse everything\n * else. The tolerant cascade this module used to apply — trailing-whitespace\n * insensitive, then inner-whitespace collapsed — is gone from the *apply* path,\n * because a match that is not the caller's bytes is an edit the caller never\n * inspected: on django-11490 a sixteen-space anchor matched inside a\n * twenty-space line and silently dedented a guard, and on sympy-15380 a\n * \"successful\" fuzzy apply corrupted the file it reported editing. Prior art is\n * `reference/opencode`'s replacer cascade (`tool/edit.ts`), and this is where we\n * deviate from it deliberately.\n *\n * The cascade survives as *diagnosis*. A miss is only expensive when it is\n * silent: the agent re-reads, re-guesses, and re-misses. {@link nearest} runs\n * the same loose strategies to find where the caller's block actually sits and\n * returns that region's real bytes and line range, so the failing cell can\n * re-anchor from reality inside the same frame rather than buying another one.\n *\n * @since 1.0.0\n */\n\nimport { sourceLines } from \"./Text.ts\"\n\n/**\n * One located block: the exact source span the needle matched.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Located {\n  readonly start: number\n  readonly end: number\n  readonly startLine: number\n  readonly endLine: number\n}\n\n/**\n * The real file region nearest a needle that did not match.\n *\n * `text` is raw file bytes, never line-number prefixed, so a caller can quote it\n * back as an anchor without editing it first.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Nearest {\n  readonly startLine: number\n  readonly endLine: number\n  readonly text: string\n}\n\n/**\n * The 1-based line a byte offset falls on.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const lineAt = (content: string, offset: number): number => {\n  let line = 1\n  for (let index = 0; index < offset && index < content.length; index++) {\n    if (content[index] === \"\\n\") line++\n  }\n  return line\n}\n\n/**\n * Every byte-exact occurrence of `needle` in `content`.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const locate = (content: string, needle: string): ReadonlyArray<Located> => {\n  const found: Array<Located> = []\n  let cursor = content.indexOf(needle)\n  let line = 1\n  let scanned = 0\n  while (cursor >= 0) {\n    for (let index = scanned; index < cursor; index++) {\n      if (content[index] === \"\\n\") line++\n    }\n    scanned = cursor\n    const startLine = line\n    let endLine = line\n    for (let index = 0; index < needle.length - 1; index++) {\n      if (needle[index] === \"\\n\") endLine++\n    }\n    found.push({ start: cursor, end: cursor + needle.length, startLine, endLine })\n    // Resume past the match, not one byte into it. A caller replaces these spans\n    // in order, so overlapping occurrences are not separately replaceable: in\n    // \"aaa\" the anchor \"aa\" is reported once, because consuming the first\n    // occurrence leaves no second one. Scanning by one byte instead reported\n    // both, and the splice wrote the replacement over bytes the first span\n    // already owned.\n    cursor = content.indexOf(needle, cursor + needle.length)\n  }\n  return found\n}\n\nconst trimmedRight = (line: string): string => line.replace(/[ \\t]+$/, \"\")\n\nconst collapsed = (line: string): string => line.replace(/[ \\t]+/g, \" \").trim()\n\nconst matchByLine = (\n  haystack: ReadonlyArray<string>,\n  wanted: ReadonlyArray<string>,\n  normalize: (line: string) => string\n): number => {\n  const target = wanted.map(normalize)\n  const normalized = haystack.map(normalize)\n  for (let index = 0; index + target.length <= haystack.length; index++) {\n    let matched = true\n    for (let step = 0; step < target.length; step++) {\n      if (normalized[index + step] !== target[step]) {\n        matched = false\n        break\n      }\n    }\n    if (matched) return index\n  }\n  return -1\n}\n\n/**\n * The real region a failed needle was aiming at, with its line range.\n *\n * The loose strategies run in order — trailing whitespace, then collapsed inner\n * whitespace, then the needle's first non-blank line alone — and the first that\n * locates a region wins. `undefined` means not even one line of the needle\n * occurs in the file, which is itself the answer: this is the wrong file.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const nearest = (content: string, needle: string, pad = 3): Nearest | undefined => {\n  const haystack = sourceLines(content)\n  const wanted = [...sourceLines(needle)]\n  while (wanted.length > 0 && wanted[wanted.length - 1] === \"\") wanted.pop()\n  if (wanted.length === 0) return undefined\n  let at = matchByLine(haystack, wanted, trimmedRight)\n  let span = wanted.length\n  if (at < 0) at = matchByLine(haystack, wanted, collapsed)\n  if (at < 0) {\n    const anchor = wanted.map(collapsed).find((line) => line !== \"\")\n    if (anchor === undefined) return undefined\n    at = haystack.findIndex((line) => collapsed(line) === anchor)\n    span = 1\n  }\n  if (at < 0) return undefined\n  const from = Math.max(0, at - pad)\n  const to = Math.min(haystack.length, at + span + pad)\n  return { startLine: from + 1, endLine: to, text: haystack.slice(from, to).join(\"\\n\") }\n}\n\n/**\n * The applied region rendered back for inspection: raw bytes, plus its range.\n *\n * A bad edit is only expensive when it is invisible. sphinx-7233 lost its\n * verdict to an in-cell string surgery that captured an `else` branch, and the\n * model never saw the hunk it had written.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const hunk = (content: string, start: number, end: number, pad = 2): Nearest => {\n  const startLine = lineAt(content, start)\n  const endLine = startLine + Math.max(0, content.slice(start, end).split(\"\\n\").length - 1)\n  const haystack = sourceLines(content)\n  const from = Math.max(0, startLine - 1 - pad)\n  const to = Math.min(haystack.length, endLine + pad)\n  return { startLine: from + 1, endLine: to, text: haystack.slice(from, to).join(\"\\n\") }\n}\n"]}