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

package/dist/cjs/internal/HttpNetwork.js

@@ -0,0 +1,146 @@
+"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 HttpNetwork_exports = {};
+__export(HttpNetwork_exports, {
+  ResolveHost: () => ResolveHost,
+  guarded: () => guarded,
+  refusal: () => refusal
+});
+module.exports = __toCommonJS(HttpNetwork_exports);
+var Capability = __toESM(require("@smthrs/capability/Capability"), 1);
+var import_GrantStore = require("@smthrs/kernel/GrantStore");
+var import_HttpClient = require("@smthrs/kernel/HttpClient");
+var import_effect = require("effect");
+var FetchHttpClient = __toESM(require("effect/unstable/http/FetchHttpClient"), 1);
+var HttpClient = __toESM(require("effect/unstable/http/HttpClient"), 1);
+var HttpClientError = __toESM(require("effect/unstable/http/HttpClientError"), 1);
+var import_promises = require("node:dns/promises");
+var import_node_net = require("node:net");
+var StdError = __toESM(require("../StdError.js"), 1);
+var import_Url = require("./Url.js");
+const ResolveHost = import_effect.Context.Reference("@smthrs/std/HttpNetwork/ResolveHost", {
+  defaultValue: () => (hostname) => import_effect.Effect.tryPromise(async () => (await (0, import_promises.lookup)(hostname, { all: true })).map((a) => a.address))
+});
+const blocked = new import_node_net.BlockList();
+for (const [address, prefix] of [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.168.0.0", 16],
+  ["192.0.0.0", 24],
+  ["100.64.0.0", 10],
+  ["198.18.0.0", 15],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+]) blocked.addSubnet(address, prefix, "ipv4");
+const publicV6 = new import_node_net.BlockList();
+publicV6.addSubnet("2000::", 3, "ipv6");
+publicV6.addSubnet("::ffff:0:0", 96, "ipv6");
+blocked.addSubnet("2002::", 16, "ipv6");
+blocked.addSubnet("2001::", 32, "ipv6");
+const isPublic = (address) => {
+  const family = (0, import_node_net.isIP)(address);
+  if (family === 4) return !blocked.check(address, "ipv4");
+  return family === 6 && publicV6.check(address, "ipv6") && !blocked.check(address, "ipv6");
+};
+const failure = (code, message, path) => new StdError.StdError({ code, message, path });
+const check = import_effect.Effect.fn("HttpNetwork.check")(function* (value, client) {
+  const url = (0, import_Url.parseHttpUrl)(value);
+  if (url === void 0) {
+    return yield* import_effect.Effect.fail(failure("invalid_input", "URL must use http or https without user information", value));
+  }
+  if (!(0, import_HttpClient.supportsDestinationPinning)(client)) {
+    return yield* import_effect.Effect.fail(failure("unsupported", "HTTP host must support destination pinning", value));
+  }
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  const local = hostname.replace(/\.$/, "").toLowerCase();
+  const literal = (0, import_node_net.isIP)(hostname) !== 0;
+  const localhost = local === "localhost" || local.endsWith(".localhost");
+  const resolve = yield* ResolveHost;
+  const privateGrant = import_effect.Effect.gen(function* () {
+    const store = yield* import_GrantStore.GrantStore;
+    const capability = yield* import_effect.Effect.try({
+      try: () => Capability.make("net:private", url.origin),
+      catch: () => failure("invalid_input", "Private HTTP origin exceeds the capability resource limit", value)
+    });
+    yield* store.check(capability).pipe(
+      import_effect.Effect.mapError(
+        () => failure("permission_denied", "Private HTTP destination requires a net:private grant", value)
+      )
+    );
+  });
+  if (localhost) yield* privateGrant;
+  const addresses = literal ? [hostname] : [
+    ...yield* resolve(hostname).pipe(
+      import_effect.Effect.mapError(() => failure("request_failed", "Could not resolve HTTP destination", value))
+    )
+  ];
+  if (addresses.length === 0 || addresses.some((address) => (0, import_node_net.isIP)(address) === 0)) {
+    return yield* import_effect.Effect.fail(failure("request_failed", "HTTP destination has no valid addresses", value));
+  }
+  if (!localhost && !addresses.every(isPublic)) yield* privateGrant;
+  return Object.freeze({ origin: url.origin, addresses: Object.freeze(addresses) });
+});
+const guarded = (client, follow = true) => {
+  const checked = HttpClient.transform(
+    client,
+    (execute, request) => (0, import_HttpClient.authorizePreflight)(
+      request,
+      check(request.url, client).pipe(
+        import_effect.Effect.mapError(
+          (cause) => new HttpClientError.HttpClientError({
+            reason: new HttpClientError.TransportError({ request, cause, description: cause.message })
+          })
+        ),
+        import_effect.Effect.flatMap(
+          (destination) => import_effect.Effect.updateContext(execute, (context) => import_effect.Context.add(import_effect.Context.add(context, import_HttpClient.Destination, destination), FetchHttpClient.RequestInit, {
+            ...import_effect.Context.getOrUndefined(context, FetchHttpClient.RequestInit),
+            redirect: "manual"
+          }))
+        )
+      )
+    )
+  );
+  return follow ? HttpClient.followRedirects(checked) : checked;
+};
+const refusal = (error) => {
+  if (!(error instanceof HttpClientError.HttpClientError) || error.reason._tag !== "TransportError") return void 0;
+  if (error.reason.cause instanceof StdError.StdError) return error.reason.cause;
+  if (import_effect.Option.isSome((0, import_HttpClient.fromHttpClientError)(error))) {
+    return failure(
+      "permission_denied",
+      error.reason.description ?? "HTTP permission was refused",
+      error.reason.request.url
+    );
+  }
+  return void 0;
+};
+//# sourceMappingURL=HttpNetwork.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/HttpNetwork.ts"],
+  "sourcesContent": ["/**\n * Destination policy shared by the web tools, including every redirect hop.\n *\n * @since 1.0.0\n */\n\nimport * as Capability from \"@smthrs/capability/Capability\"\nimport { GrantStore } from \"@smthrs/kernel/GrantStore\"\nimport {\n  authorizePreflight,\n  Destination,\n  fromHttpClientError,\n  supportsDestinationPinning\n} from \"@smthrs/kernel/HttpClient\"\nimport { Context, Effect, Option } from \"effect\"\nimport * as FetchHttpClient from \"effect/unstable/http/FetchHttpClient\"\nimport * as HttpClient from \"effect/unstable/http/HttpClient\"\nimport * as HttpClientError from \"effect/unstable/http/HttpClientError\"\nimport { lookup } from \"node:dns/promises\"\nimport { BlockList, isIP } from \"node:net\"\nimport * as StdError from \"../StdError.ts\"\nimport { parseHttpUrl } from \"./Url.ts\"\n\n/** Resolver seam: all addresses must be public before an unprivileged request.\n * @since 1.0.0\n * @private\n */\nexport const ResolveHost = Context.Reference<\n  (hostname: string) => Effect.Effect<ReadonlyArray<string>, unknown>\n>(\"@smthrs/std/HttpNetwork/ResolveHost\", {\n  defaultValue: () => (hostname) =>\n    Effect.tryPromise(async () => (await lookup(hostname, { all: true })).map((a) => a.address))\n})\n\nconst blocked = new BlockList()\nfor (\n  const [address, prefix] of [\n    [\"0.0.0.0\", 8],\n    [\"10.0.0.0\", 8],\n    [\"127.0.0.0\", 8],\n    [\"169.254.0.0\", 16],\n    [\"172.16.0.0\", 12],\n    [\"192.168.0.0\", 16],\n    [\"192.0.0.0\", 24],\n    [\"100.64.0.0\", 10],\n    [\"198.18.0.0\", 15],\n    [\"224.0.0.0\", 4],\n    [\"240.0.0.0\", 4]\n  ] as const\n) blocked.addSubnet(address, prefix, \"ipv4\")\n// Allow global IPv6 and mapped IPv4 only, excluding transition tunnels.\nconst publicV6 = new BlockList()\npublicV6.addSubnet(\"2000::\", 3, \"ipv6\")\npublicV6.addSubnet(\"::ffff:0:0\", 96, \"ipv6\")\nblocked.addSubnet(\"2002::\", 16, \"ipv6\")\nblocked.addSubnet(\"2001::\", 32, \"ipv6\")\n\nconst isPublic = (address: string): boolean => {\n  const family = isIP(address)\n  if (family === 4) return !blocked.check(address, \"ipv4\")\n  return family === 6 && publicV6.check(address, \"ipv6\") && !blocked.check(address, \"ipv6\")\n}\n\nconst failure = (code: StdError.Code, message: string, path: string) => new StdError.StdError({ code, message, path })\n\nconst check = Effect.fn(\"HttpNetwork.check\")(function*(value: string, client: HttpClient.HttpClient) {\n  const url = parseHttpUrl(value)\n  if (url === undefined) {\n    return yield* Effect.fail(failure(\"invalid_input\", \"URL must use http or https without user information\", value))\n  }\n  if (!supportsDestinationPinning(client)) {\n    return yield* Effect.fail(failure(\"unsupported\", \"HTTP host must support destination pinning\", value))\n  }\n  const hostname = url.hostname.replace(/^\\[|\\]$/g, \"\")\n  const local = hostname.replace(/\\.$/, \"\").toLowerCase()\n  const literal = isIP(hostname) !== 0\n  const localhost = local === \"localhost\" || local.endsWith(\".localhost\")\n  const resolve = yield* ResolveHost\n  // Refuse localhost before DNS unless the origin is explicitly authorized.\n  const privateGrant = Effect.gen(function*() {\n    const store = yield* GrantStore\n    const capability = yield* Effect.try({\n      try: () => Capability.make(\"net:private\", url.origin),\n      catch: () => failure(\"invalid_input\", \"Private HTTP origin exceeds the capability resource limit\", value)\n    })\n    yield* store.check(capability).pipe(\n      Effect.mapError(() =>\n        failure(\"permission_denied\", \"Private HTTP destination requires a net:private grant\", value)\n      )\n    )\n  })\n  if (localhost) yield* privateGrant\n  const addresses = literal ? [hostname] : [\n    ...yield* resolve(hostname).pipe(\n      Effect.mapError(() => failure(\"request_failed\", \"Could not resolve HTTP destination\", value))\n    )\n  ]\n  if (addresses.length === 0 || addresses.some((address) => isIP(address) === 0)) {\n    return yield* Effect.fail(failure(\"request_failed\", \"HTTP destination has no valid addresses\", value))\n  }\n  if (!localhost && !addresses.every(isPublic)) yield* privateGrant\n  return Object.freeze({ origin: url.origin, addresses: Object.freeze(addresses) })\n})\n\n/** Decorates the supplied client before following redirects through the guard.\n * The transport must honor manual redirects, as required by the kernel client.\n * @since 1.0.0\n * @private\n */\nexport const guarded = (\n  client: HttpClient.HttpClient,\n  follow = true\n): HttpClient.HttpClient.With<HttpClientError.HttpClientError, GrantStore> => {\n  const checked = HttpClient.transform(\n    client,\n    (execute, request) =>\n      authorizePreflight(\n        request,\n        check(request.url, client).pipe(\n          Effect.mapError((cause) =>\n            new HttpClientError.HttpClientError({\n              reason: new HttpClientError.TransportError({ request, cause, description: cause.message })\n            })\n          ),\n          Effect.flatMap((destination) =>\n            Effect.updateContext(execute, (context: Context.Context<never>) =>\n              Context.add(Context.add(context, Destination, destination), FetchHttpClient.RequestInit, {\n                ...Context.getOrUndefined(context, FetchHttpClient.RequestInit),\n                redirect: \"manual\"\n              }))\n          )\n        )\n      )\n  )\n  return follow ? HttpClient.followRedirects(checked) : checked\n}\n\n/** Recovers the typed refusal carried through Effect's HTTP error channel.\n * @since 1.0.0\n * @private\n */\nexport const refusal = (error: unknown): StdError.StdError | undefined => {\n  if (!(error instanceof HttpClientError.HttpClientError) || error.reason._tag !== \"TransportError\") return undefined\n  if (error.reason.cause instanceof StdError.StdError) return error.reason.cause\n  if (Option.isSome(fromHttpClientError(error))) {\n    return failure(\n      \"permission_denied\",\n      error.reason.description ?? \"HTTP permission was refused\",\n      error.reason.request.url\n    )\n  }\n  return undefined\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Root-scoped gitignore rules, compiled once per visited directory.
+ *
+ * @since 1.0.0
+ */
+interface Rule {
+    readonly expression: RegExp;
+    readonly directoryOnly: boolean;
+    readonly negated: boolean;
+    readonly byPath: boolean;
+}
+/**
+ * Rules belonging to one visited directory.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export interface Scope {
+    readonly directory: string;
+    readonly rules: ReadonlyArray<Rule>;
+}
+/**
+ * Parses gitignore lines without widening the caller-glob grammar.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const parse: (directory: string, content: string) => Scope;
+/**
+ * Tests an entry before descent; deeper scopes and later rules take priority.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const ignored: (scopes: ReadonlyArray<Scope>, candidate: string, basename: string, directory: boolean, relative: (from: string, to: string) => string) => boolean;
+export {};
+//# sourceMappingURL=Ignore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ignore.d.ts","sourceRoot":"","sources":["../../../src/internal/Ignore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,UAAU,IAAI;IACZ,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAA;CACpC;AAyDD;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,WAAW,MAAM,EAAE,SAAS,MAAM,KAAG,KAqB1D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAClB,QAAQ,aAAa,CAAC,KAAK,CAAC,EAC5B,WAAW,MAAM,EACjB,UAAU,MAAM,EAChB,WAAW,OAAO,EAClB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,KAC7C,OAYF,CAAA"}

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"}