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

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/RemoteTree.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A tree another machine listed, served as a read-only `FileSystem`.
+ *
+ * `RemoteSearch` lists a root on the machine with `find` and brings back the
+ * bytes the search reads with `tar`; this module holds what came back and
+ * answers what the walk, the globs, and the matcher ask of a filesystem, so
+ * `PortableSearch` can search the copy as it searches a host.
+ *
+ * @since 1.0.0-rc.8
+ */
+import type * as Path from "@smthrs/kernel/Path";
+import * as FileSystem from "effect/FileSystem";
+/**
+ * What one listed path is: `d` a directory, `u` a directory the machine's
+ * user may not list, `f` a file, `o` anything else, and a symbolic link to a
+ * directory (`D`), to a file (`F`), or to neither (`L`).
+ *
+ * @private
+ * @since 1.0.0-rc.8
+ */
+export type Kind = "d" | "u" | "f" | "o" | "D" | "F" | "L";
+/**
+ * One machine's listing of a root, and the bytes it brought back, by
+ * absolute path.
+ *
+ * @private
+ * @since 1.0.0-rc.8
+ */
+export interface Tree {
+    readonly kinds: ReadonlyMap<string, Kind>;
+    readonly children: ReadonlyMap<string, ReadonlyArray<string>>;
+    readonly contents: ReadonlyMap<string, Uint8Array>;
+}
+/**
+ * The member names `tar` wrote for absolute paths, which it strips of their
+ * leading `/`, as those paths again.
+ *
+ * @private
+ * @since 1.0.0-rc.8
+ */
+export declare const absolute: (members: ReadonlyMap<string, Uint8Array>) => ReadonlyMap<string, Uint8Array>;
+/**
+ * Reads NUL-terminated `<kind><path>` records up to an `E` record, then the
+ * tar stream of `.gitignore` files after it. `root` is the listed root, which
+ * is nobody's child. `undefined` when the bytes are not that shape.
+ *
+ * @private
+ * @since 1.0.0-rc.8
+ */
+export declare const parse: (bytes: Uint8Array, root: string, path: Path.Path) => Tree | undefined;
+/**
+ * The tree as a read-only `FileSystem`, resolving paths with `path`. A file
+ * whose bytes did not come back is one the machine's user could not read,
+ * which the in-process peer skips exactly as it skips such a file on a host.
+ *
+ * @private
+ * @since 1.0.0-rc.8
+ */
+export declare const fileSystem: (tree: Tree, path: Path.Path) => FileSystem.FileSystem;
+//# sourceMappingURL=RemoteTree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteTree.d.ts","sourceRoot":"","sources":["../../../src/internal/RemoteTree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,KAAK,IAAI,MAAM,qBAAqB,CAAA;AAGhD,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAI/C;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AAE1D;;;;;;GAMG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACzC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;IAC7D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACnD;AAID;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,KAAG,WAAW,CAAC,MAAM,EAAE,UAAU,CAC/B,CAAA;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,UAAU,EAAE,MAAM,MAAM,EAAE,MAAM,IAAI,CAAC,IAAI,KAAG,IAAI,GAAG,SAuB/E,CAAA;AAiCD;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,EAAE,MAAM,IAAI,CAAC,IAAI,KAAG,UAAU,CAAC,UAiCnE,CAAA"}

package/dist/cjs/internal/RemoteTree.js

@@ -0,0 +1,123 @@
+"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 RemoteTree_exports = {};
+__export(RemoteTree_exports, {
+  absolute: () => absolute,
+  fileSystem: () => fileSystem,
+  parse: () => parse
+});
+module.exports = __toCommonJS(RemoteTree_exports);
+var import_effect = require("effect");
+var ByteSize = __toESM(require("effect/ByteSize"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var PlatformError = __toESM(require("effect/PlatformError"), 1);
+var Tar = __toESM(require("./Tar.js"), 1);
+const kinds = /* @__PURE__ */ new Set(["d", "u", "f", "o", "D", "F", "L"]);
+const absolute = (members) => new Map([...members].map(([name, bytes]) => [`/${name}`, bytes]));
+const parse = (bytes, root, path) => {
+  const decoder = new TextDecoder();
+  const listed = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (; ; ) {
+    const end = bytes.indexOf(0, offset);
+    if (end === -1) return void 0;
+    const record = decoder.decode(bytes.subarray(offset, end));
+    offset = end + 1;
+    if (record === "E") break;
+    const kind = record.slice(0, 1);
+    if (!kinds.has(kind)) return void 0;
+    const entry = record.slice(1);
+    listed.set(entry, kind);
+    if (entry === root) continue;
+    const parent = path.dirname(entry);
+    const siblings = children.get(parent);
+    if (siblings === void 0) children.set(parent, [path.basename(entry)]);
+    else siblings.push(path.basename(entry));
+  }
+  const ignores = Tar.files(bytes.subarray(offset));
+  return ignores === void 0 ? void 0 : { kinds: listed, children, contents: absolute(ignores) };
+};
+const refusal = (tag, method, path) => PlatformError.systemError({ _tag: tag, module: "FileSystem", method, pathOrDescriptor: path });
+const types = {
+  d: "Directory",
+  u: "Directory",
+  D: "Directory",
+  f: "File",
+  F: "File",
+  o: "Unknown",
+  L: void 0
+};
+const info = (type, size) => ({
+  type,
+  size: ByteSize.bytes(BigInt(size)),
+  mtime: import_effect.Option.none(),
+  atime: import_effect.Option.none(),
+  birthtime: import_effect.Option.none(),
+  dev: 0,
+  ino: import_effect.Option.none(),
+  mode: 0,
+  nlink: import_effect.Option.none(),
+  uid: import_effect.Option.none(),
+  gid: import_effect.Option.none(),
+  rdev: import_effect.Option.none(),
+  blksize: import_effect.Option.none(),
+  blocks: import_effect.Option.none()
+});
+const fileSystem = (tree, path) => {
+  const kindOf = (value) => tree.kinds.get(path.resolve(value));
+  const readFile = (value) => {
+    const bytes = tree.contents.get(path.resolve(value));
+    if (bytes !== void 0) return import_effect.Effect.succeed(bytes);
+    const type = types[kindOf(value) ?? "L"];
+    return import_effect.Effect.fail(
+      refusal(type === "File" ? "PermissionDenied" : type === void 0 ? "NotFound" : "BadResource", "readFile", value)
+    );
+  };
+  return FileSystem.makeNoop({
+    stat: (value) => {
+      const type = types[kindOf(value) ?? "L"];
+      return type === void 0 ? import_effect.Effect.fail(refusal("NotFound", "stat", value)) : import_effect.Effect.succeed(info(type, tree.contents.get(path.resolve(value))?.length ?? 0));
+    },
+    readDirectory: (value) => {
+      const kind = kindOf(value);
+      if (kind === "d") return import_effect.Effect.succeed([...tree.children.get(path.resolve(value)) ?? []]);
+      const tag = kind === "u" ? "PermissionDenied" : kind === void 0 || kind === "L" ? "NotFound" : "BadResource";
+      return import_effect.Effect.fail(refusal(tag, "readDirectory", value));
+    },
+    readLink: (value) => {
+      const kind = kindOf(value);
+      return kind === "D" || kind === "F" || kind === "L" ? import_effect.Effect.succeed("") : import_effect.Effect.fail(refusal(kind === void 0 ? "NotFound" : "BadResource", "readLink", value));
+    },
+    readFile,
+    readFileString: (value) => import_effect.Effect.map(readFile(value), (bytes) => new TextDecoder().decode(bytes)),
+    stream: (value) => import_effect.Stream.fromEffect(readFile(value))
+  });
+};
+//# sourceMappingURL=RemoteTree.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/RemoteTree.ts"],
+  "sourcesContent": ["/**\n * A tree another machine listed, served as a read-only `FileSystem`.\n *\n * `RemoteSearch` lists a root on the machine with `find` and brings back the\n * bytes the search reads with `tar`; this module holds what came back and\n * answers what the walk, the globs, and the matcher ask of a filesystem, so\n * `PortableSearch` can search the copy as it searches a host.\n *\n * @since 1.0.0-rc.8\n */\n\nimport type * as Path from \"@smthrs/kernel/Path\"\nimport { Effect, Option, Stream } from \"effect\"\nimport * as ByteSize from \"effect/ByteSize\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as PlatformError from \"effect/PlatformError\"\nimport * as Tar from \"./Tar.ts\"\n\n/**\n * What one listed path is: `d` a directory, `u` a directory the machine's\n * user may not list, `f` a file, `o` anything else, and a symbolic link to a\n * directory (`D`), to a file (`F`), or to neither (`L`).\n *\n * @private\n * @since 1.0.0-rc.8\n */\nexport type Kind = \"d\" | \"u\" | \"f\" | \"o\" | \"D\" | \"F\" | \"L\"\n\n/**\n * One machine's listing of a root, and the bytes it brought back, by\n * absolute path.\n *\n * @private\n * @since 1.0.0-rc.8\n */\nexport interface Tree {\n  readonly kinds: ReadonlyMap<string, Kind>\n  readonly children: ReadonlyMap<string, ReadonlyArray<string>>\n  readonly contents: ReadonlyMap<string, Uint8Array>\n}\n\nconst kinds: ReadonlySet<string> = new Set([\"d\", \"u\", \"f\", \"o\", \"D\", \"F\", \"L\"])\n\n/**\n * The member names `tar` wrote for absolute paths, which it strips of their\n * leading `/`, as those paths again.\n *\n * @private\n * @since 1.0.0-rc.8\n */\nexport const absolute = (members: ReadonlyMap<string, Uint8Array>): ReadonlyMap<string, Uint8Array> =>\n  new Map([...members].map(([name, bytes]) => [`/${name}`, bytes]))\n\n/**\n * Reads NUL-terminated `<kind><path>` records up to an `E` record, then the\n * tar stream of `.gitignore` files after it. `root` is the listed root, which\n * is nobody's child. `undefined` when the bytes are not that shape.\n *\n * @private\n * @since 1.0.0-rc.8\n */\nexport const parse = (bytes: Uint8Array, root: string, path: Path.Path): Tree | undefined => {\n  const decoder = new TextDecoder()\n  const listed = new Map<string, Kind>()\n  const children = new Map<string, Array<string>>()\n  let offset = 0\n  for (;;) {\n    const end = bytes.indexOf(0, offset)\n    if (end === -1) return undefined\n    const record = decoder.decode(bytes.subarray(offset, end))\n    offset = end + 1\n    if (record === \"E\") break\n    const kind = record.slice(0, 1)\n    if (!kinds.has(kind)) return undefined\n    const entry = record.slice(1)\n    listed.set(entry, kind as Kind)\n    if (entry === root) continue\n    const parent = path.dirname(entry)\n    const siblings = children.get(parent)\n    if (siblings === undefined) children.set(parent, [path.basename(entry)])\n    else siblings.push(path.basename(entry))\n  }\n  const ignores = Tar.files(bytes.subarray(offset))\n  return ignores === undefined ? undefined : { kinds: listed, children, contents: absolute(ignores) }\n}\n\nconst refusal = (tag: PlatformError.SystemErrorTag, method: string, path: string): PlatformError.PlatformError =>\n  PlatformError.systemError({ _tag: tag, module: \"FileSystem\", method, pathOrDescriptor: path })\n\n/** What `stat` says each kind is: links resolved, a dangling one absent. */\nconst types: Readonly<Record<Kind, FileSystem.File.Type | undefined>> = {\n  d: \"Directory\",\n  u: \"Directory\",\n  D: \"Directory\",\n  f: \"File\",\n  F: \"File\",\n  o: \"Unknown\",\n  L: undefined\n}\n\nconst info = (type: FileSystem.File.Type, size: number): FileSystem.File.Info => ({\n  type,\n  size: ByteSize.bytes(BigInt(size)),\n  mtime: Option.none(),\n  atime: Option.none(),\n  birthtime: Option.none(),\n  dev: 0,\n  ino: Option.none(),\n  mode: 0,\n  nlink: Option.none(),\n  uid: Option.none(),\n  gid: Option.none(),\n  rdev: Option.none(),\n  blksize: Option.none(),\n  blocks: Option.none()\n})\n\n/**\n * The tree as a read-only `FileSystem`, resolving paths with `path`. A file\n * whose bytes did not come back is one the machine's user could not read,\n * which the in-process peer skips exactly as it skips such a file on a host.\n *\n * @private\n * @since 1.0.0-rc.8\n */\nexport const fileSystem = (tree: Tree, path: Path.Path): FileSystem.FileSystem => {\n  const kindOf = (value: string) => tree.kinds.get(path.resolve(value))\n  const readFile = (value: string) => {\n    const bytes = tree.contents.get(path.resolve(value))\n    if (bytes !== undefined) return Effect.succeed(bytes)\n    const type = types[kindOf(value) ?? \"L\"]\n    return Effect.fail(\n      refusal(type === \"File\" ? \"PermissionDenied\" : type === undefined ? \"NotFound\" : \"BadResource\", \"readFile\", value)\n    )\n  }\n  return FileSystem.makeNoop({\n    stat: (value) => {\n      const type = types[kindOf(value) ?? \"L\"]\n      return type === undefined\n        ? Effect.fail(refusal(\"NotFound\", \"stat\", value))\n        : Effect.succeed(info(type, tree.contents.get(path.resolve(value))?.length ?? 0))\n    },\n    readDirectory: (value) => {\n      const kind = kindOf(value)\n      if (kind === \"d\") return Effect.succeed([...tree.children.get(path.resolve(value)) ?? []])\n      const tag = kind === \"u\" ? \"PermissionDenied\" : kind === undefined || kind === \"L\" ? \"NotFound\" : \"BadResource\"\n      return Effect.fail(refusal(tag, \"readDirectory\", value))\n    },\n    readLink: (value) => {\n      const kind = kindOf(value)\n      return kind === \"D\" || kind === \"F\" || kind === \"L\"\n        ? Effect.succeed(\"\")\n        : Effect.fail(refusal(kind === undefined ? \"NotFound\" : \"BadResource\", \"readLink\", value))\n    },\n    readFile,\n    readFileString: (value) => Effect.map(readFile(value), (bytes) => new TextDecoder().decode(bytes)),\n    stream: (value) => Stream.fromEffect(readFile(value))\n  })\n}\n"],
+  "mappings": "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",
+  "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"}