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

package/dist/cjs/internal/Ignore.js

@@ -0,0 +1,100 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Ignore_exports = {};
+__export(Ignore_exports, {
+  ignored: () => ignored,
+  parse: () => parse
+});
+module.exports = __toCommonJS(Ignore_exports);
+var import_SearchContract = require("./SearchContract.js");
+const bytes = (value) => /[^\x20-\x7e]/.test(value) ? Array.from(new TextEncoder().encode(value), (byte) => String.fromCharCode(byte)).join("") : value;
+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 += (0, import_SearchContract.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 === void 0) 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] === void 0 || "/},".includes(pattern[index + 2]))) {
+      source += pattern[index + 2] === "/" ? "(?:.*/)?" : ".*";
+      index += pattern[index + 2] === "/" ? 2 : 1;
+    } else if (character === "*") source += "[^/]*";
+    else if (character === "?") source += "[^/]";
+    else source += (0, import_SearchContract.escapeRegex)(character);
+  }
+  if (groups.length > 0) throw new Error("unclosed alternatives");
+  return new RegExp(`^(?:${source})$`);
+};
+const parse = (directory, content) => {
+  const rules = [];
+  for (let line of content.replace(/^\uFEFF/, "").split(/\r?\n/)) {
+    if (line.startsWith("#")) continue;
+    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 {
+    }
+  }
+  return { directory, rules };
+};
+const ignored = (scopes, candidate, basename, directory, relative) => {
+  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/cjs/internal/Ignore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ignore.ts"],
+  "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"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/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/cjs/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/cjs/internal/LinearRegex.js

@@ -0,0 +1,166 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LinearRegex_exports = {};
+__export(LinearRegex_exports, {
+  compile: () => compile
+});
+module.exports = __toCommonJS(LinearRegex_exports);
+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 start2 = 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(start2, 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;
+        }
+        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/cjs/internal/LinearRegex.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/LinearRegex.ts"],
+  "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"],
+  "mappings": "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",
+  "names": ["start"]
+}

package/dist/cjs/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/cjs/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/cjs/internal/Match.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Match_exports = {};
+__export(Match_exports, {
+  hunk: () => hunk,
+  lineAt: () => lineAt,
+  locate: () => locate,
+  nearest: () => nearest
+});
+module.exports = __toCommonJS(Match_exports);
+var import_Text = require("./Text.js");
+const lineAt = (content, offset) => {
+  let line = 1;
+  for (let index = 0; index < offset && index < content.length; index++) {
+    if (content[index] === "\n") line++;
+  }
+  return line;
+};
+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 });
+    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;
+};
+const nearest = (content, needle, pad = 3) => {
+  const haystack = (0, import_Text.sourceLines)(content);
+  const wanted = [...(0, import_Text.sourceLines)(needle)];
+  while (wanted.length > 0 && wanted[wanted.length - 1] === "") wanted.pop();
+  if (wanted.length === 0) return void 0;
+  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 === void 0) return void 0;
+    at = haystack.findIndex((line) => collapsed(line) === anchor);
+    span = 1;
+  }
+  if (at < 0) return void 0;
+  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") };
+};
+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 = (0, import_Text.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/cjs/internal/Match.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Match.ts"],
+  "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 \u2014 trailing-whitespace\n * insensitive, then inner-whitespace collapsed \u2014 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 \u2014 trailing whitespace, then collapsed inner\n * whitespace, then the needle's first non-blank line alone \u2014 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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,kBAA4B;AAoCrB,MAAM,SAAS,CAAC,SAAiB,WAA2B;AACjE,MAAI,OAAO;AACX,WAAS,QAAQ,GAAG,QAAQ,UAAU,QAAQ,QAAQ,QAAQ,SAAS;AACrE,QAAI,QAAQ,KAAK,MAAM,KAAM;AAAA,EAC/B;AACA,SAAO;AACT;AAQO,MAAM,SAAS,CAAC,SAAiB,WAA2C;AACjF,QAAM,QAAwB,CAAC;AAC/B,MAAI,SAAS,QAAQ,QAAQ,MAAM;AACnC,MAAI,OAAO;AACX,MAAI,UAAU;AACd,SAAO,UAAU,GAAG;AAClB,aAAS,QAAQ,SAAS,QAAQ,QAAQ,SAAS;AACjD,UAAI,QAAQ,KAAK,MAAM,KAAM;AAAA,IAC/B;AACA,cAAU;AACV,UAAM,YAAY;AAClB,QAAI,UAAU;AACd,aAAS,QAAQ,GAAG,QAAQ,OAAO,SAAS,GAAG,SAAS;AACtD,UAAI,OAAO,KAAK,MAAM,KAAM;AAAA,IAC9B;AACA,UAAM,KAAK,EAAE,OAAO,QAAQ,KAAK,SAAS,OAAO,QAAQ,WAAW,QAAQ,CAAC;AAO7E,aAAS,QAAQ,QAAQ,QAAQ,SAAS,OAAO,MAAM;AAAA,EACzD;AACA,SAAO;AACT;AAEA,MAAM,eAAe,CAAC,SAAyB,KAAK,QAAQ,WAAW,EAAE;AAEzE,MAAM,YAAY,CAAC,SAAyB,KAAK,QAAQ,WAAW,GAAG,EAAE,KAAK;AAE9E,MAAM,cAAc,CAClB,UACA,QACA,cACW;AACX,QAAM,SAAS,OAAO,IAAI,SAAS;AACnC,QAAM,aAAa,SAAS,IAAI,SAAS;AACzC,WAAS,QAAQ,GAAG,QAAQ,OAAO,UAAU,SAAS,QAAQ,SAAS;AACrE,QAAI,UAAU;AACd,aAAS,OAAO,GAAG,OAAO,OAAO,QAAQ,QAAQ;AAC/C,UAAI,WAAW,QAAQ,IAAI,MAAM,OAAO,IAAI,GAAG;AAC7C,kBAAU;AACV;AAAA,MACF;AAAA,IACF;AACA,QAAI,QAAS,QAAO;AAAA,EACtB;AACA,SAAO;AACT;AAaO,MAAM,UAAU,CAAC,SAAiB,QAAgB,MAAM,MAA2B;AACxF,QAAM,eAAW,yBAAY,OAAO;AACpC,QAAM,SAAS,CAAC,OAAG,yBAAY,MAAM,CAAC;AACtC,SAAO,OAAO,SAAS,KAAK,OAAO,OAAO,SAAS,CAAC,MAAM,GAAI,QAAO,IAAI;AACzE,MAAI,OAAO,WAAW,EAAG,QAAO;AAChC,MAAI,KAAK,YAAY,UAAU,QAAQ,YAAY;AACnD,MAAI,OAAO,OAAO;AAClB,MAAI,KAAK,EAAG,MAAK,YAAY,UAAU,QAAQ,SAAS;AACxD,MAAI,KAAK,GAAG;AACV,UAAM,SAAS,OAAO,IAAI,SAAS,EAAE,KAAK,CAAC,SAAS,SAAS,EAAE;AAC/D,QAAI,WAAW,OAAW,QAAO;AACjC,SAAK,SAAS,UAAU,CAAC,SAAS,UAAU,IAAI,MAAM,MAAM;AAC5D,WAAO;AAAA,EACT;AACA,MAAI,KAAK,EAAG,QAAO;AACnB,QAAM,OAAO,KAAK,IAAI,GAAG,KAAK,GAAG;AACjC,QAAM,KAAK,KAAK,IAAI,SAAS,QAAQ,KAAK,OAAO,GAAG;AACpD,SAAO,EAAE,WAAW,OAAO,GAAG,SAAS,IAAI,MAAM,SAAS,MAAM,MAAM,EAAE,EAAE,KAAK,IAAI,EAAE;AACvF;AAYO,MAAM,OAAO,CAAC,SAAiB,OAAe,KAAa,MAAM,MAAe;AACrF,QAAM,YAAY,OAAO,SAAS,KAAK;AACvC,QAAM,UAAU,YAAY,KAAK,IAAI,GAAG,QAAQ,MAAM,OAAO,GAAG,EAAE,MAAM,IAAI,EAAE,SAAS,CAAC;AACxF,QAAM,eAAW,yBAAY,OAAO;AACpC,QAAM,OAAO,KAAK,IAAI,GAAG,YAAY,IAAI,GAAG;AAC5C,QAAM,KAAK,KAAK,IAAI,SAAS,QAAQ,UAAU,GAAG;AAClD,SAAO,EAAE,WAAW,OAAO,GAAG,SAAS,IAAI,MAAM,SAAS,MAAM,MAAM,EAAE,EAAE,KAAK,IAAI,EAAE;AACvF;",
+  "names": []
+}

package/dist/cjs/internal/Paths.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Path containment checks against a declared effect envelope.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Whether a path is covered by any entry of a declared read or write set.
+ *
+ * An entry covers itself, everything beneath it when it names a directory,
+ * and everything matched by the prefix-glob subset `/core` supports.
+ *
+ * @category predicates
+ * @since 1.0.0
+ */
+export declare const withinEnvelope: (declared: ReadonlyArray<string>, path: string) => boolean;
+/**
+ * A path without its trailing slashes, so a root compares and joins as one name.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export declare const withoutTrailingSlash: (path: string) => string;
+//# sourceMappingURL=Paths.d.ts.map

package/dist/cjs/internal/Paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Paths.d.ts","sourceRoot":"","sources":["../../../src/internal/Paths.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,KAAG,OAS9E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MAAkC,CAAA"}

package/dist/cjs/internal/Paths.js

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Paths_exports = {};
+__export(Paths_exports, {
+  withinEnvelope: () => withinEnvelope,
+  withoutTrailingSlash: () => withoutTrailingSlash
+});
+module.exports = __toCommonJS(Paths_exports);
+var Effects = __toESM(require("@smthrs/core/Effects"), 1);
+const normalize = (path) => {
+  const collapsed = path.replace(/\/+/g, "/");
+  return collapsed.length > 1 ? collapsed.replace(/\/+$/, "") : collapsed;
+};
+const hasDotSegment = (path) => path.split("/").some((segment) => segment === "." || segment === "..");
+const withinEnvelope = (declared, path) => {
+  const candidate = normalize(path);
+  if (candidate === "" || hasDotSegment(candidate)) return false;
+  return declared.some((entry) => {
+    const normalized = normalize(entry);
+    if (normalized === "") return false;
+    const envelope = normalized === "/" ? "/**" : normalized;
+    return Effects.covers(envelope, candidate) || candidate.startsWith(`${normalized}/`);
+  });
+};
+const withoutTrailingSlash = (path) => path.replace(/\/+$/, "");
+//# sourceMappingURL=Paths.js.map

package/dist/cjs/internal/Paths.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Paths.ts"],
+  "sourcesContent": ["/**\n * Path containment checks against a declared effect envelope.\n *\n * @since 1.0.0\n */\n\nimport * as Effects from \"@smthrs/core/Effects\"\n\nconst normalize = (path: string): string => {\n  const collapsed = path.replace(/\\/+/g, \"/\")\n  return collapsed.length > 1 ? collapsed.replace(/\\/+$/, \"\") : collapsed\n}\n\nconst hasDotSegment = (path: string): boolean => path.split(\"/\").some((segment) => segment === \".\" || segment === \"..\")\n\n/**\n * Whether a path is covered by any entry of a declared read or write set.\n *\n * An entry covers itself, everything beneath it when it names a directory,\n * and everything matched by the prefix-glob subset `/core` supports.\n *\n * @category predicates\n * @since 1.0.0\n */\nexport const withinEnvelope = (declared: ReadonlyArray<string>, path: string): boolean => {\n  const candidate = normalize(path)\n  if (candidate === \"\" || hasDotSegment(candidate)) return false\n  return declared.some((entry) => {\n    const normalized = normalize(entry)\n    if (normalized === \"\") return false\n    const envelope = normalized === \"/\" ? \"/**\" : normalized\n    return Effects.covers(envelope, candidate) || candidate.startsWith(`${normalized}/`)\n  })\n}\n\n/**\n * A path without its trailing slashes, so a root compares and joins as one name.\n *\n * @category conversions\n * @since 1.0.0\n */\nexport const withoutTrailingSlash = (path: string): string => path.replace(/\\/+$/, \"\")\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAyB;AAEzB,MAAM,YAAY,CAAC,SAAyB;AAC1C,QAAM,YAAY,KAAK,QAAQ,QAAQ,GAAG;AAC1C,SAAO,UAAU,SAAS,IAAI,UAAU,QAAQ,QAAQ,EAAE,IAAI;AAChE;AAEA,MAAM,gBAAgB,CAAC,SAA0B,KAAK,MAAM,GAAG,EAAE,KAAK,CAAC,YAAY,YAAY,OAAO,YAAY,IAAI;AAW/G,MAAM,iBAAiB,CAAC,UAAiC,SAA0B;AACxF,QAAM,YAAY,UAAU,IAAI;AAChC,MAAI,cAAc,MAAM,cAAc,SAAS,EAAG,QAAO;AACzD,SAAO,SAAS,KAAK,CAAC,UAAU;AAC9B,UAAM,aAAa,UAAU,KAAK;AAClC,QAAI,eAAe,GAAI,QAAO;AAC9B,UAAM,WAAW,eAAe,MAAM,QAAQ;AAC9C,WAAO,QAAQ,OAAO,UAAU,SAAS,KAAK,UAAU,WAAW,GAAG,UAAU,GAAG;AAAA,EACrF,CAAC;AACH;AAQO,MAAM,uBAAuB,CAAC,SAAyB,KAAK,QAAQ,QAAQ,EAAE;",
+  "names": []
+}