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

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": []
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Per-file atomic replacement that preserves permission bits and ownership.
+ * The sibling is complete before rename; no crash-durability guarantee is made.
+ * A file whose owner this process cannot assign is rewritten in place instead.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as PlatformError from "effect/PlatformError";
+/**
+ * Replaces a file's text atomically, preserving its permission bits and owner.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export declare const writeFileString: (fileSystem: FileSystem.FileSystem, path: string, content: string) => Effect.Effect<void, PlatformError.PlatformError>;
+/**
+ * Replaces a file's bytes with the same atomic boundary used for text writes.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export declare const writeFile: (fileSystem: FileSystem.FileSystem, path: string, content: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>;
+//# sourceMappingURL=Preserve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Preserve.d.ts","sourceRoot":"","sources":["../../../src/internal/Preserve.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAEpD,OAAO,KAAK,KAAK,aAAa,MAAM,sBAAsB,CAAA;AAI1D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,UAAU,CAAC,UAAU,EACjC,MAAM,MAAM,EACZ,SAAS,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,aAAa,CAC8D,CAAA;AAEhH;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,YAAY,UAAU,CAAC,UAAU,EACjC,MAAM,MAAM,EACZ,SAAS,UAAU,KAClB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,aAAa,CACwD,CAAA"}

package/dist/cjs/internal/Preserve.js

@@ -0,0 +1,88 @@
+"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 Preserve_exports = {};
+__export(Preserve_exports, {
+  writeFile: () => writeFile,
+  writeFileString: () => writeFileString
+});
+module.exports = __toCommonJS(Preserve_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+const permissions = 4095;
+const writeFileString = (fileSystem, path, content) => replace(fileSystem, path, (target, flag, mode) => fileSystem.writeFileString(target, content, { flag, mode }));
+const writeFile = (fileSystem, path, content) => replace(fileSystem, path, (target, flag, mode) => fileSystem.writeFile(target, content, { flag, mode }));
+const replace = (fileSystem, path, write) => Effect.gen(function* () {
+  const before = yield* fileSystem.stat(path).pipe(
+    Effect.catch((error) => error.reason._tag === "NotFound" ? Effect.succeed(void 0) : Effect.fail(error))
+  );
+  const destination = before === void 0 ? path : yield* fileSystem.realPath(path);
+  const temporary = destination.replace(/[^/\\]+$/, `.smithers-${globalThis.crypto.randomUUID()}.tmp`);
+  let owned = true;
+  let inPlace = false;
+  yield* Effect.uninterruptibleMask(
+    (restore) => Effect.gen(function* () {
+      yield* write(temporary, "wx", before === void 0 ? void 0 : before.mode & permissions).pipe(
+        Effect.tapError(
+          (error) => Effect.sync(() => {
+            if (error.reason._tag === "AlreadyExists") owned = false;
+          })
+        )
+      );
+      yield* restore(Effect.gen(function* () {
+        if (before === void 0) return;
+        const after = yield* fileSystem.stat(temporary);
+        const uid = Option.getOrUndefined(before.uid);
+        const gid = Option.getOrUndefined(before.gid);
+        const ownerChanged = uid !== void 0 && uid !== Option.getOrUndefined(after.uid) || gid !== void 0 && gid !== Option.getOrUndefined(after.gid);
+        if (ownerChanged) {
+          const chowned = yield* fileSystem.chown(temporary, uid ?? -1, gid ?? -1).pipe(
+            Effect.as(true),
+            Effect.catch(
+              (error) => error.reason._tag === "PermissionDenied" ? Effect.succeed(false) : Effect.fail(error)
+            )
+          );
+          if (!chowned) {
+            inPlace = true;
+            return;
+          }
+        }
+        if (ownerChanged || (after.mode & permissions) !== (before.mode & permissions)) {
+          yield* fileSystem.chmod(temporary, before.mode & permissions);
+        }
+      }));
+      if (!inPlace) yield* fileSystem.rename(temporary, destination);
+    }).pipe(
+      Effect.ensuring(
+        Effect.suspend(() => owned ? fileSystem.remove(temporary, { force: true }).pipe(Effect.orDie) : Effect.void)
+      )
+    )
+  );
+  if (inPlace) yield* write(destination, "w", void 0);
+});
+//# sourceMappingURL=Preserve.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Preserve.ts"],
+  "sourcesContent": ["/**\n * Per-file atomic replacement that preserves permission bits and ownership.\n * The sibling is complete before rename; no crash-durability guarantee is made.\n * A file whose owner this process cannot assign is rewritten in place instead.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport type * as FileSystem from \"effect/FileSystem\"\nimport * as Option from \"effect/Option\"\nimport type * as PlatformError from \"effect/PlatformError\"\n\nconst permissions = 0o7777\n\n/**\n * Replaces a file's text atomically, preserving its permission bits and owner.\n *\n * @category filesystem\n * @since 1.0.0\n */\nexport const writeFileString = (\n  fileSystem: FileSystem.FileSystem,\n  path: string,\n  content: string\n): Effect.Effect<void, PlatformError.PlatformError> =>\n  replace(fileSystem, path, (target, flag, mode) => fileSystem.writeFileString(target, content, { flag, mode }))\n\n/**\n * Replaces a file's bytes with the same atomic boundary used for text writes.\n *\n * @category filesystem\n * @since 1.0.0\n */\nexport const writeFile = (\n  fileSystem: FileSystem.FileSystem,\n  path: string,\n  content: Uint8Array\n): Effect.Effect<void, PlatformError.PlatformError> =>\n  replace(fileSystem, path, (target, flag, mode) => fileSystem.writeFile(target, content, { flag, mode }))\n\nconst replace = (\n  fileSystem: FileSystem.FileSystem,\n  path: string,\n  write: (\n    target: string,\n    flag: \"wx\" | \"w\",\n    mode: number | undefined\n  ) => Effect.Effect<void, PlatformError.PlatformError>\n): Effect.Effect<void, PlatformError.PlatformError> =>\n  Effect.gen(function*() {\n    const before = yield* fileSystem.stat(path).pipe(\n      Effect.catch((error) => error.reason._tag === \"NotFound\" ? Effect.succeed(undefined) : Effect.fail(error))\n    )\n    // Keep following an existing symlink, as an in-place write did.\n    const destination = before === undefined ? path : yield* fileSystem.realPath(path)\n    const temporary = destination.replace(/[^/\\\\]+$/, `.smithers-${globalThis.crypto.randomUUID()}.tmp`)\n    let owned = true\n    // Set when the sibling cannot take the file's owner; see the chown below.\n    let inPlace = false\n    yield* Effect.uninterruptibleMask((restore) =>\n      Effect.gen(function*() {\n        // Let the host finish its write before cancellation can unlink the name.\n        yield* write(temporary, \"wx\", before === undefined ? undefined : before.mode & permissions).pipe(\n          Effect.tapError((error) =>\n            Effect.sync(() => {\n              if (error.reason._tag === \"AlreadyExists\") owned = false\n            })\n          )\n        )\n        yield* restore(Effect.gen(function*() {\n          if (before === undefined) return\n          const after = yield* fileSystem.stat(temporary)\n          const uid = Option.getOrUndefined(before.uid)\n          const gid = Option.getOrUndefined(before.gid)\n          const ownerChanged = (uid !== undefined && uid !== Option.getOrUndefined(after.uid)) ||\n            (gid !== undefined && gid !== Option.getOrUndefined(after.gid))\n          if (ownerChanged) {\n            // Only root may give a file away. A writable file owned by another\n            // user (a shared checkout, a bind mount) cannot be replaced by a\n            // sibling this process owns without changing its owner, so it is\n            // rewritten in place instead: same inode, owner, and mode, at the\n            // cost of atomicity.\n            const chowned = yield* fileSystem.chown(temporary, uid ?? -1, gid ?? -1).pipe(\n              Effect.as(true),\n              Effect.catch((error) =>\n                error.reason._tag === \"PermissionDenied\" ? Effect.succeed(false) : Effect.fail(error)\n              )\n            )\n            if (!chowned) {\n              inPlace = true\n              return\n            }\n          }\n          // chown may clear set-id bits, so permissions are restored last.\n          if (ownerChanged || (after.mode & permissions) !== (before.mode & permissions)) {\n            yield* fileSystem.chmod(temporary, before.mode & permissions)\n          }\n        }))\n        if (!inPlace) yield* fileSystem.rename(temporary, destination)\n      }).pipe(\n        Effect.ensuring(\n          Effect.suspend(() => owned ? fileSystem.remove(temporary, { force: true }).pipe(Effect.orDie) : Effect.void)\n        )\n      )\n    )\n    if (inPlace) yield* write(destination, \"w\", undefined)\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,aAAwB;AAExB,aAAwB;AAGxB,MAAM,cAAc;AAQb,MAAM,kBAAkB,CAC7B,YACA,MACA,YAEA,QAAQ,YAAY,MAAM,CAAC,QAAQ,MAAM,SAAS,WAAW,gBAAgB,QAAQ,SAAS,EAAE,MAAM,KAAK,CAAC,CAAC;AAQxG,MAAM,YAAY,CACvB,YACA,MACA,YAEA,QAAQ,YAAY,MAAM,CAAC,QAAQ,MAAM,SAAS,WAAW,UAAU,QAAQ,SAAS,EAAE,MAAM,KAAK,CAAC,CAAC;AAEzG,MAAM,UAAU,CACd,YACA,MACA,UAMA,OAAO,IAAI,aAAY;AACrB,QAAM,SAAS,OAAO,WAAW,KAAK,IAAI,EAAE;AAAA,IAC1C,OAAO,MAAM,CAAC,UAAU,MAAM,OAAO,SAAS,aAAa,OAAO,QAAQ,MAAS,IAAI,OAAO,KAAK,KAAK,CAAC;AAAA,EAC3G;AAEA,QAAM,cAAc,WAAW,SAAY,OAAO,OAAO,WAAW,SAAS,IAAI;AACjF,QAAM,YAAY,YAAY,QAAQ,YAAY,aAAa,WAAW,OAAO,WAAW,CAAC,MAAM;AACnG,MAAI,QAAQ;AAEZ,MAAI,UAAU;AACd,SAAO,OAAO;AAAA,IAAoB,CAAC,YACjC,OAAO,IAAI,aAAY;AAErB,aAAO,MAAM,WAAW,MAAM,WAAW,SAAY,SAAY,OAAO,OAAO,WAAW,EAAE;AAAA,QAC1F,OAAO;AAAA,UAAS,CAAC,UACf,OAAO,KAAK,MAAM;AAChB,gBAAI,MAAM,OAAO,SAAS,gBAAiB,SAAQ;AAAA,UACrD,CAAC;AAAA,QACH;AAAA,MACF;AACA,aAAO,QAAQ,OAAO,IAAI,aAAY;AACpC,YAAI,WAAW,OAAW;AAC1B,cAAM,QAAQ,OAAO,WAAW,KAAK,SAAS;AAC9C,cAAM,MAAM,OAAO,eAAe,OAAO,GAAG;AAC5C,cAAM,MAAM,OAAO,eAAe,OAAO,GAAG;AAC5C,cAAM,eAAgB,QAAQ,UAAa,QAAQ,OAAO,eAAe,MAAM,GAAG,KAC/E,QAAQ,UAAa,QAAQ,OAAO,eAAe,MAAM,GAAG;AAC/D,YAAI,cAAc;AAMhB,gBAAM,UAAU,OAAO,WAAW,MAAM,WAAW,OAAO,IAAI,OAAO,EAAE,EAAE;AAAA,YACvE,OAAO,GAAG,IAAI;AAAA,YACd,OAAO;AAAA,cAAM,CAAC,UACZ,MAAM,OAAO,SAAS,qBAAqB,OAAO,QAAQ,KAAK,IAAI,OAAO,KAAK,KAAK;AAAA,YACtF;AAAA,UACF;AACA,cAAI,CAAC,SAAS;AACZ,sBAAU;AACV;AAAA,UACF;AAAA,QACF;AAEA,YAAI,iBAAiB,MAAM,OAAO,kBAAkB,OAAO,OAAO,cAAc;AAC9E,iBAAO,WAAW,MAAM,WAAW,OAAO,OAAO,WAAW;AAAA,QAC9D;AAAA,MACF,CAAC,CAAC;AACF,UAAI,CAAC,QAAS,QAAO,WAAW,OAAO,WAAW,WAAW;AAAA,IAC/D,CAAC,EAAE;AAAA,MACD,OAAO;AAAA,QACL,OAAO,QAAQ,MAAM,QAAQ,WAAW,OAAO,WAAW,EAAE,OAAO,KAAK,CAAC,EAAE,KAAK,OAAO,KAAK,IAAI,OAAO,IAAI;AAAA,MAC7G;AAAA,IACF;AAAA,EACF;AACA,MAAI,QAAS,QAAO,MAAM,aAAa,KAAK,MAAS;AACvD,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,35 @@
+/**
+ * The one list of directory names a repository walk leaves out.
+ *
+ * `grep`, `glob` and `ls` walks, the tree fingerprint, and workspace
+ * observation all read this list, so a directory one of them skips is never
+ * counted, matched, or fingerprinted by another. Every entry is derived state:
+ * version-control internals, dependency trees, caches, and the scratch
+ * checkouts the checkpoint and test-baseline flows create inside the
+ * workspace. A scratch checkout is a full copy of the repository at an older
+ * commit, so walking it duplicates every match from a stale tree.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Workspace-relative directory holding checkpoint checkouts.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const checkpointScratch = ".flows-checkpoints";
+/**
+ * Workspace-relative directory holding test-baseline checkouts.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const testBaseScratch = ".flows-test-base";
+/**
+ * Directory basenames no repository walk descends into.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const repositoryDirectories: ReadonlyArray<string>;
+//# sourceMappingURL=Prune.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Prune.d.ts","sourceRoot":"","sources":["../../../src/internal/Prune.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,qBAAqB,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,MAAM,CAyBvD,CAAA"}

package/dist/cjs/internal/Prune.js

@@ -0,0 +1,54 @@
+"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 Prune_exports = {};
+__export(Prune_exports, {
+  checkpointScratch: () => checkpointScratch,
+  repositoryDirectories: () => repositoryDirectories,
+  testBaseScratch: () => testBaseScratch
+});
+module.exports = __toCommonJS(Prune_exports);
+const checkpointScratch = ".flows-checkpoints";
+const testBaseScratch = ".flows-test-base";
+const repositoryDirectories = [
+  ".git",
+  ".hg",
+  ".jj",
+  ".svn",
+  ".flows",
+  ".artifacts",
+  ".backend-go-modcache",
+  ".pnpm-store",
+  ".worktrees",
+  "worktrees",
+  checkpointScratch,
+  testBaseScratch,
+  "node_modules",
+  "__pycache__",
+  ".venv",
+  ".tox",
+  ".nox",
+  ".eggs",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".gradle",
+  ".turbo",
+  ".next"
+];
+//# sourceMappingURL=Prune.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Prune.ts"],
+  "sourcesContent": ["/**\n * The one list of directory names a repository walk leaves out.\n *\n * `grep`, `glob` and `ls` walks, the tree fingerprint, and workspace\n * observation all read this list, so a directory one of them skips is never\n * counted, matched, or fingerprinted by another. Every entry is derived state:\n * version-control internals, dependency trees, caches, and the scratch\n * checkouts the checkpoint and test-baseline flows create inside the\n * workspace. A scratch checkout is a full copy of the repository at an older\n * commit, so walking it duplicates every match from a stale tree.\n *\n * @since 1.0.0\n */\n\n/**\n * Workspace-relative directory holding checkpoint checkouts.\n *\n * @private\n * @since 1.0.0\n */\nexport const checkpointScratch = \".flows-checkpoints\"\n\n/**\n * Workspace-relative directory holding test-baseline checkouts.\n *\n * @private\n * @since 1.0.0\n */\nexport const testBaseScratch = \".flows-test-base\"\n\n/**\n * Directory basenames no repository walk descends into.\n *\n * @private\n * @since 1.0.0\n */\nexport const repositoryDirectories: ReadonlyArray<string> = [\n  \".git\",\n  \".hg\",\n  \".jj\",\n  \".svn\",\n  \".flows\",\n  \".artifacts\",\n  \".backend-go-modcache\",\n  \".pnpm-store\",\n  \".worktrees\",\n  \"worktrees\",\n  checkpointScratch,\n  testBaseScratch,\n  \"node_modules\",\n  \"__pycache__\",\n  \".venv\",\n  \".tox\",\n  \".nox\",\n  \".eggs\",\n  \".mypy_cache\",\n  \".pytest_cache\",\n  \".ruff_cache\",\n  \".gradle\",\n  \".turbo\",\n  \".next\"\n]\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,MAAM,oBAAoB;AAQ1B,MAAM,kBAAkB;AAQxB,MAAM,wBAA+C;AAAA,EAC1D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,63 @@
+/**
+ * The failure constructors and the literal escape both Search peers share.
+ *
+ * The validation and matching rules themselves are public, in
+ * `../SearchContract.ts`, because an external peer has to build on them. What
+ * is left here is what an external peer never calls: the three `StdError`
+ * shapes the contract fails with, the root-failure mapping, and the regex escape a fixed-string search
+ * applies before compiling.
+ *
+ * @since 1.0.0
+ */
+import type * as PlatformError from "effect/PlatformError";
+import * as StdError from "../StdError.ts";
+/**
+ * Constructs the common unsupported-pattern failure.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const invalidPattern: (pattern: string, detail: string) => StdError.StdError;
+/**
+ * How every rejection {@link invalidPattern} writes begins.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const rejectionPrefix = "Unsupported ripgrep pattern ";
+/**
+ * Constructs the common invalid-options failure.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const invalidInput: (detail: string) => StdError.StdError;
+/**
+ * Constructs the common missing-root failure.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const notFound: (path: string) => StdError.StdError;
+/**
+ * Maps a failure to inspect the search root onto the contract's failures.
+ *
+ * Only a root that does not exist is `not_found`. Every other reason a stat
+ * or listing can fail (a guarded host that fails closed, a permission the
+ * process lacks, an I/O error) is a host operation failing, and it is
+ * reported as `command_failed` with the platform's own message, so the
+ * caller reads the real cause instead of a missing-path claim about a path
+ * that exists.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const rootFailure: (path: string, error: PlatformError.PlatformError) => StdError.StdError;
+/**
+ * Escapes literal text for JavaScript regular expressions.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const escapeRegex: (value: string) => string;
+//# sourceMappingURL=SearchContract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchContract.d.ts","sourceRoot":"","sources":["../../../src/internal/SearchContract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,KAAK,aAAa,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,KAAG,QAAQ,CAAC,QACgC,CAAA;AAE1G;;;;;GAKG;AACH,eAAO,MAAM,eAAe,iCAAiC,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,KAAG,QAAQ,CAAC,QAC0C,CAAA;AAEjG;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,QAAQ,CAAC,QACuC,CAAA;AAExF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,OAAO,aAAa,CAAC,aAAa,KAAG,QAAQ,CAAC,QAKyB,CAAA;AAEjH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAAsD,CAAA"}

package/dist/cjs/internal/SearchContract.js

@@ -0,0 +1,46 @@
+"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 SearchContract_exports = {};
+__export(SearchContract_exports, {
+  escapeRegex: () => escapeRegex,
+  invalidInput: () => invalidInput,
+  invalidPattern: () => invalidPattern,
+  notFound: () => notFound,
+  rejectionPrefix: () => rejectionPrefix,
+  rootFailure: () => rootFailure
+});
+module.exports = __toCommonJS(SearchContract_exports);
+var StdError = __toESM(require("../StdError.js"), 1);
+const invalidPattern = (pattern, detail) => new StdError.StdError({ code: "invalid_pattern", message: `${rejectionPrefix}"${pattern}": ${detail}` });
+const rejectionPrefix = "Unsupported ripgrep pattern ";
+const invalidInput = (detail) => new StdError.StdError({ code: "invalid_input", message: `Invalid ripgrep options: ${detail}` });
+const notFound = (path) => new StdError.StdError({ code: "not_found", message: `Path not found: ${path}`, path });
+const rootFailure = (path, error) => error.reason._tag === "NotFound" ? notFound(path) : error.reason._tag === "PermissionDenied" ? new StdError.StdError({ code: "permission_denied", message: `Cannot search ${path}: ${error.message}`, path }) : new StdError.StdError({ code: "command_failed", message: `Cannot search ${path}: ${error.message}`, path });
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+//# sourceMappingURL=SearchContract.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/SearchContract.ts"],
+  "sourcesContent": ["/**\n * The failure constructors and the literal escape both Search peers share.\n *\n * The validation and matching rules themselves are public, in\n * `../SearchContract.ts`, because an external peer has to build on them. What\n * is left here is what an external peer never calls: the three `StdError`\n * shapes the contract fails with, the root-failure mapping, and the regex escape a fixed-string search\n * applies before compiling.\n *\n * @since 1.0.0\n */\n\nimport type * as PlatformError from \"effect/PlatformError\"\nimport * as StdError from \"../StdError.ts\"\n\n/**\n * Constructs the common unsupported-pattern failure.\n *\n * @private\n * @since 1.0.0\n */\nexport const invalidPattern = (pattern: string, detail: string): StdError.StdError =>\n  new StdError.StdError({ code: \"invalid_pattern\", message: `${rejectionPrefix}\"${pattern}\": ${detail}` })\n\n/**\n * How every rejection {@link invalidPattern} writes begins.\n *\n * @private\n * @since 1.0.0\n */\nexport const rejectionPrefix = \"Unsupported ripgrep pattern \"\n\n/**\n * Constructs the common invalid-options failure.\n *\n * @private\n * @since 1.0.0\n */\nexport const invalidInput = (detail: string): StdError.StdError =>\n  new StdError.StdError({ code: \"invalid_input\", message: `Invalid ripgrep options: ${detail}` })\n\n/**\n * Constructs the common missing-root failure.\n *\n * @private\n * @since 1.0.0\n */\nexport const notFound = (path: string): StdError.StdError =>\n  new StdError.StdError({ code: \"not_found\", message: `Path not found: ${path}`, path })\n\n/**\n * Maps a failure to inspect the search root onto the contract's failures.\n *\n * Only a root that does not exist is `not_found`. Every other reason a stat\n * or listing can fail (a guarded host that fails closed, a permission the\n * process lacks, an I/O error) is a host operation failing, and it is\n * reported as `command_failed` with the platform's own message, so the\n * caller reads the real cause instead of a missing-path claim about a path\n * that exists.\n *\n * @private\n * @since 1.0.0\n */\nexport const rootFailure = (path: string, error: PlatformError.PlatformError): StdError.StdError =>\n  error.reason._tag === \"NotFound\"\n    ? notFound(path)\n    : error.reason._tag === \"PermissionDenied\"\n    ? new StdError.StdError({ code: \"permission_denied\", message: `Cannot search ${path}: ${error.message}`, path })\n    : new StdError.StdError({ code: \"command_failed\", message: `Cannot search ${path}: ${error.message}`, path })\n\n/**\n * Escapes literal text for JavaScript regular expressions.\n *\n * @private\n * @since 1.0.0\n */\nexport const escapeRegex = (value: string): string => value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,eAA0B;AAQnB,MAAM,iBAAiB,CAAC,SAAiB,WAC9C,IAAI,SAAS,SAAS,EAAE,MAAM,mBAAmB,SAAS,GAAG,eAAe,IAAI,OAAO,MAAM,MAAM,GAAG,CAAC;AAQlG,MAAM,kBAAkB;AAQxB,MAAM,eAAe,CAAC,WAC3B,IAAI,SAAS,SAAS,EAAE,MAAM,iBAAiB,SAAS,4BAA4B,MAAM,GAAG,CAAC;AAQzF,MAAM,WAAW,CAAC,SACvB,IAAI,SAAS,SAAS,EAAE,MAAM,aAAa,SAAS,mBAAmB,IAAI,IAAI,KAAK,CAAC;AAehF,MAAM,cAAc,CAAC,MAAc,UACxC,MAAM,OAAO,SAAS,aAClB,SAAS,IAAI,IACb,MAAM,OAAO,SAAS,qBACtB,IAAI,SAAS,SAAS,EAAE,MAAM,qBAAqB,SAAS,iBAAiB,IAAI,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,IAC7G,IAAI,SAAS,SAAS,EAAE,MAAM,kBAAkB,SAAS,iBAAiB,IAAI,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC;AAQzG,MAAM,cAAc,CAAC,UAA0B,MAAM,QAAQ,uBAAuB,MAAM;",
+  "names": []
+}

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

@@ -0,0 +1,39 @@
+/**
+ * The definition a line sits inside, read off the file's own shape.
+ *
+ * A search hit is a line number, and a line number is not a read window. Agents
+ * guess one: `offset: line - 10, limit: 40`, which lands short (astropy-15569
+ * missed `get_lookup` by one line and probed the wrong binding) or long (six
+ * blind-offset reads on sympy-13878). The enclosing definition is the window the
+ * hit actually belongs to, and for indentation- and brace-structured source it
+ * is derivable from the text already in hand.
+ *
+ * This is a heuristic and reports only what it can see plainly: a declaration
+ * keyword, a name, and the block that keyword opens. When the shape is not
+ * plain — a match at top level, a language this table does not name, a
+ * declaration split across lines — it answers `undefined` rather than guessing,
+ * because a wrong window is worse than none.
+ *
+ * @since 1.0.0
+ */
+/**
+ * The definition enclosing a line.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Symbol {
+    readonly kind: string;
+    readonly name: string;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+/**
+ * The definition enclosing a 1-based line, or `undefined` when there is none to
+ * read plainly.
+ *
+ * @category navigation
+ * @since 1.0.0
+ */
+export declare const enclosing: (lines: ReadonlyArray<string>, line: number) => Symbol | undefined;
+//# sourceMappingURL=Symbols.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Symbols.d.ts","sourceRoot":"","sources":["../../../src/internal/Symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAgBD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,KAAG,MAAM,GAAG,SAkC/E,CAAA"}