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

package/dist/esm/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/esm/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/esm/internal/Paths.js

@@ -0,0 +1,40 @@
+/**
+ * Path containment checks against a declared effect envelope.
+ *
+ * @since 1.0.0
+ */
+import * as Effects from "@smthrs/core/Effects";
+const normalize = (path) => {
+    const collapsed = path.replace(/\/+/g, "/");
+    return collapsed.length > 1 ? collapsed.replace(/\/+$/, "") : collapsed;
+};
+const hasDotSegment = (path) => path.split("/").some((segment) => segment === "." || segment === "..");
+/**
+ * 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 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}/`);
+    });
+};
+/**
+ * A path without its trailing slashes, so a root compares and joins as one name.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export const withoutTrailingSlash = (path) => path.replace(/\/+$/, "");
+//# sourceMappingURL=Paths.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Paths.js","sourceRoot":"","sources":["../../../src/internal/Paths.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAA;AAE/C,MAAM,SAAS,GAAG,CAAC,IAAY,EAAU,EAAE;IACzC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3C,OAAO,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AACzE,CAAC,CAAA;AAED,MAAM,aAAa,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,IAAI,CAAC,CAAA;AAEvH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,QAA+B,EAAE,IAAY,EAAW,EAAE;IACvF,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;IACjC,IAAI,SAAS,KAAK,EAAE,IAAI,aAAa,CAAC,SAAS,CAAC;QAAE,OAAO,KAAK,CAAA;IAC9D,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7B,MAAM,UAAU,GAAG,SAAS,CAAC,KAAK,CAAC,CAAA;QACnC,IAAI,UAAU,KAAK,EAAE;YAAE,OAAO,KAAK,CAAA;QACnC,MAAM,QAAQ,GAAG,UAAU,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAA;QACxD,OAAO,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,UAAU,GAAG,CAAC,CAAA;IACtF,CAAC,CAAC,CAAA;AACJ,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA","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"]}

package/dist/esm/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/esm/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/esm/internal/Preserve.js

@@ -0,0 +1,70 @@
+/**
+ * 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 * as Option from "effect/Option";
+const permissions = 0o7777;
+/**
+ * Replaces a file's text atomically, preserving its permission bits and owner.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export const writeFileString = (fileSystem, path, content) => replace(fileSystem, path, (target, flag, mode) => fileSystem.writeFileString(target, content, { flag, mode }));
+/**
+ * Replaces a file's bytes with the same atomic boundary used for text writes.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export 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(undefined) : Effect.fail(error)));
+    // Keep following an existing symlink, as an in-place write did.
+    const destination = before === undefined ? path : yield* fileSystem.realPath(path);
+    const temporary = destination.replace(/[^/\\]+$/, `.smithers-${globalThis.crypto.randomUUID()}.tmp`);
+    let owned = true;
+    // Set when the sibling cannot take the file's owner; see the chown below.
+    let inPlace = false;
+    yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        // Let the host finish its write before cancellation can unlink the name.
+        yield* write(temporary, "wx", before === undefined ? undefined : before.mode & permissions).pipe(Effect.tapError((error) => Effect.sync(() => {
+            if (error.reason._tag === "AlreadyExists")
+                owned = false;
+        })));
+        yield* restore(Effect.gen(function* () {
+            if (before === undefined)
+                return;
+            const after = yield* fileSystem.stat(temporary);
+            const uid = Option.getOrUndefined(before.uid);
+            const gid = Option.getOrUndefined(before.gid);
+            const ownerChanged = (uid !== undefined && uid !== Option.getOrUndefined(after.uid)) ||
+                (gid !== undefined && gid !== Option.getOrUndefined(after.gid));
+            if (ownerChanged) {
+                // Only root may give a file away. A writable file owned by another
+                // user (a shared checkout, a bind mount) cannot be replaced by a
+                // sibling this process owns without changing its owner, so it is
+                // rewritten in place instead: same inode, owner, and mode, at the
+                // cost of atomicity.
+                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;
+                }
+            }
+            // chown may clear set-id bits, so permissions are restored last.
+            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", undefined);
+});
+//# sourceMappingURL=Preserve.js.map

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

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

package/dist/esm/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/esm/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/esm/internal/Prune.js

@@ -0,0 +1,60 @@
+/**
+ * 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 const checkpointScratch = ".flows-checkpoints";
+/**
+ * Workspace-relative directory holding test-baseline checkouts.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const testBaseScratch = ".flows-test-base";
+/**
+ * Directory basenames no repository walk descends into.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export 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/esm/internal/Prune.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Prune.js","sourceRoot":"","sources":["../../../src/internal/Prune.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,oBAAoB,CAAA;AAErD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAA;AAEjD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA0B;IAC1D,MAAM;IACN,KAAK;IACL,KAAK;IACL,MAAM;IACN,QAAQ;IACR,YAAY;IACZ,sBAAsB;IACtB,aAAa;IACb,YAAY;IACZ,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,cAAc;IACd,aAAa;IACb,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;IACP,aAAa;IACb,eAAe;IACf,aAAa;IACb,SAAS;IACT,QAAQ;IACR,OAAO;CACR,CAAA","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"]}

package/dist/esm/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/esm/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/esm/internal/SearchContract.js

@@ -0,0 +1,66 @@
+/**
+ * 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 * as StdError from "../StdError.js";
+/**
+ * Constructs the common unsupported-pattern failure.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const invalidPattern = (pattern, detail) => new StdError.StdError({ code: "invalid_pattern", message: `${rejectionPrefix}"${pattern}": ${detail}` });
+/**
+ * How every rejection {@link invalidPattern} writes begins.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const rejectionPrefix = "Unsupported ripgrep pattern ";
+/**
+ * Constructs the common invalid-options failure.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const invalidInput = (detail) => new StdError.StdError({ code: "invalid_input", message: `Invalid ripgrep options: ${detail}` });
+/**
+ * Constructs the common missing-root failure.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const notFound = (path) => new StdError.StdError({ code: "not_found", message: `Path not found: ${path}`, path });
+/**
+ * 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 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 });
+/**
+ * Escapes literal text for JavaScript regular expressions.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+//# sourceMappingURL=SearchContract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchContract.js","sourceRoot":"","sources":["../../../src/internal/SearchContract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,OAAe,EAAE,MAAc,EAAqB,EAAE,CACnF,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,GAAG,eAAe,IAAI,OAAO,MAAM,MAAM,EAAE,EAAE,CAAC,CAAA;AAE1G;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,8BAA8B,CAAA;AAE7D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAc,EAAqB,EAAE,CAChE,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,4BAA4B,MAAM,EAAE,EAAE,CAAC,CAAA;AAEjG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAqB,EAAE,CAC1D,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,mBAAmB,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;AAExF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAY,EAAE,KAAkC,EAAqB,EAAE,CACjG,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,UAAU;IAC9B,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;IAChB,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;QAC1C,CAAC,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,iBAAiB,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC;QAChH,CAAC,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,iBAAiB,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;AAEjH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAA","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"]}

package/dist/esm/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/esm/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"}

package/dist/esm/internal/Symbols.js

@@ -0,0 +1,79 @@
+/**
+ * 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
+ */
+/**
+ * Declaration keywords this heuristic recognises across the languages the
+ * standard flows meet. Modifiers before the keyword are skipped, the name after
+ * it is captured, and everything else is left alone.
+ */
+const declaration = /^([ \t]*)(?:(?:async|export|default|public|private|protected|internal|static|final|abstract|open|pub(?:\([^)]*\))?|unsafe|const|declare)[ \t]+)*(def|class|function|fn|func|struct|impl|interface|trait|enum|module|namespace|type|sub|method)[ \t]+([A-Za-z_$][A-Za-z0-9_$]*)/;
+const closer = /^[ \t]*[)}\]]/;
+const indentOf = (line) => /^[ \t]*/.exec(line)[0].length;
+const blank = (line) => line.trim() === "";
+/**
+ * The definition enclosing a 1-based line, or `undefined` when there is none to
+ * read plainly.
+ *
+ * @category navigation
+ * @since 1.0.0
+ */
+export const enclosing = (lines, line) => {
+    const index = line - 1;
+    if (index < 0 || index >= lines.length)
+        return undefined;
+    // A blank match line has no indentation of its own; the nearest text above it
+    // does, and that is the block the blank line belongs to.
+    let reference = index;
+    while (reference > 0 && blank(lines[reference]))
+        reference--;
+    const indent = indentOf(lines[reference]);
+    let start = -1;
+    let parsed = null;
+    for (let candidate = index; candidate >= 0; candidate--) {
+        const text = lines[candidate];
+        if (blank(text))
+            continue;
+        const found = declaration.exec(text);
+        if (found === null)
+            continue;
+        if (candidate !== index && indentOf(text) >= indent)
+            continue;
+        start = candidate;
+        parsed = found;
+        break;
+    }
+    if (parsed === null)
+        return undefined;
+    const opening = indentOf(lines[start]);
+    let end = lines.length - 1;
+    for (let candidate = start + 1; candidate < lines.length; candidate++) {
+        const text = lines[candidate];
+        if (blank(text))
+            continue;
+        if (indentOf(text) > opening)
+            continue;
+        // A brace language closes the block at the declaration's own indentation,
+        // and that closing line is part of the definition rather than what follows.
+        end = closer.test(text) ? candidate : candidate - 1;
+        break;
+    }
+    while (end > start && blank(lines[end]))
+        end--;
+    return { kind: parsed[2], name: parsed[3], startLine: start + 1, endLine: end + 1 };
+};
+//# sourceMappingURL=Symbols.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Symbols.js","sourceRoot":"","sources":["../../../src/internal/Symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH;;;;GAIG;AACH,MAAM,WAAW,GACf,gRAAgR,CAAA;AAElR,MAAM,MAAM,GAAG,eAAe,CAAA;AAE9B,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAA;AAE1E,MAAM,KAAK,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAA;AAE3D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAA4B,EAAE,IAAY,EAAsB,EAAE;IAC1F,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,CAAA;IACtB,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM;QAAE,OAAO,SAAS,CAAA;IACxD,8EAA8E;IAC9E,yDAAyD;IACzD,IAAI,SAAS,GAAG,KAAK,CAAA;IACrB,OAAO,SAAS,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,SAAS,CAAE,CAAC;QAAE,SAAS,EAAE,CAAA;IAC7D,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAE,CAAC,CAAA;IAC1C,IAAI,KAAK,GAAG,CAAC,CAAC,CAAA;IACd,IAAI,MAAM,GAA2B,IAAI,CAAA;IACzC,KAAK,IAAI,SAAS,GAAG,KAAK,EAAE,SAAS,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC;QACxD,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAE,CAAA;QAC9B,IAAI,KAAK,CAAC,IAAI,CAAC;YAAE,SAAQ;QACzB,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACpC,IAAI,KAAK,KAAK,IAAI;YAAE,SAAQ;QAC5B,IAAI,SAAS,KAAK,KAAK,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,MAAM;YAAE,SAAQ;QAC7D,KAAK,GAAG,SAAS,CAAA;QACjB,MAAM,GAAG,KAAK,CAAA;QACd,MAAK;IACP,CAAC;IACD,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,SAAS,CAAA;IACrC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAE,CAAC,CAAA;IACvC,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC1B,KAAK,IAAI,SAAS,GAAG,KAAK,GAAG,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;QACtE,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAE,CAAA;QAC9B,IAAI,KAAK,CAAC,IAAI,CAAC;YAAE,SAAQ;QACzB,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO;YAAE,SAAQ;QACtC,0EAA0E;QAC1E,4EAA4E;QAC5E,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAA;QACnD,MAAK;IACP,CAAC;IACD,OAAO,GAAG,GAAG,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAE,CAAC;QAAE,GAAG,EAAE,CAAA;IAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAE,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAE,EAAE,SAAS,EAAE,KAAK,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,CAAC,EAAE,CAAA;AACvF,CAAC,CAAA","sourcesContent":["/**\n * The definition a line sits inside, read off the file's own shape.\n *\n * A search hit is a line number, and a line number is not a read window. Agents\n * guess one: `offset: line - 10, limit: 40`, which lands short (astropy-15569\n * missed `get_lookup` by one line and probed the wrong binding) or long (six\n * blind-offset reads on sympy-13878). The enclosing definition is the window the\n * hit actually belongs to, and for indentation- and brace-structured source it\n * is derivable from the text already in hand.\n *\n * This is a heuristic and reports only what it can see plainly: a declaration\n * keyword, a name, and the block that keyword opens. When the shape is not\n * plain — a match at top level, a language this table does not name, a\n * declaration split across lines — it answers `undefined` rather than guessing,\n * because a wrong window is worse than none.\n *\n * @since 1.0.0\n */\n\n/**\n * The definition enclosing a line.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Symbol {\n  readonly kind: string\n  readonly name: string\n  readonly startLine: number\n  readonly endLine: number\n}\n\n/**\n * Declaration keywords this heuristic recognises across the languages the\n * standard flows meet. Modifiers before the keyword are skipped, the name after\n * it is captured, and everything else is left alone.\n */\nconst declaration =\n  /^([ \\t]*)(?:(?:async|export|default|public|private|protected|internal|static|final|abstract|open|pub(?:\\([^)]*\\))?|unsafe|const|declare)[ \\t]+)*(def|class|function|fn|func|struct|impl|interface|trait|enum|module|namespace|type|sub|method)[ \\t]+([A-Za-z_$][A-Za-z0-9_$]*)/\n\nconst closer = /^[ \\t]*[)}\\]]/\n\nconst indentOf = (line: string): number => /^[ \\t]*/.exec(line)![0].length\n\nconst blank = (line: string): boolean => line.trim() === \"\"\n\n/**\n * The definition enclosing a 1-based line, or `undefined` when there is none to\n * read plainly.\n *\n * @category navigation\n * @since 1.0.0\n */\nexport const enclosing = (lines: ReadonlyArray<string>, line: number): Symbol | undefined => {\n  const index = line - 1\n  if (index < 0 || index >= lines.length) return undefined\n  // A blank match line has no indentation of its own; the nearest text above it\n  // does, and that is the block the blank line belongs to.\n  let reference = index\n  while (reference > 0 && blank(lines[reference]!)) reference--\n  const indent = indentOf(lines[reference]!)\n  let start = -1\n  let parsed: RegExpExecArray | null = null\n  for (let candidate = index; candidate >= 0; candidate--) {\n    const text = lines[candidate]!\n    if (blank(text)) continue\n    const found = declaration.exec(text)\n    if (found === null) continue\n    if (candidate !== index && indentOf(text) >= indent) continue\n    start = candidate\n    parsed = found\n    break\n  }\n  if (parsed === null) return undefined\n  const opening = indentOf(lines[start]!)\n  let end = lines.length - 1\n  for (let candidate = start + 1; candidate < lines.length; candidate++) {\n    const text = lines[candidate]!\n    if (blank(text)) continue\n    if (indentOf(text) > opening) continue\n    // A brace language closes the block at the declaration's own indentation,\n    // and that closing line is part of the definition rather than what follows.\n    end = closer.test(text) ? candidate : candidate - 1\n    break\n  }\n  while (end > start && blank(lines[end]!)) end--\n  return { kind: parsed[2]!, name: parsed[3]!, startLine: start + 1, endLine: end + 1 }\n}\n"]}

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

@@ -0,0 +1,52 @@
+/**
+ * What a test runner said, read out of what it printed.
+ *
+ * A suite's answer is two facts — how many passed, and which ones failed — and
+ * a runner spends twenty to thirty kilobytes of stdout saying them. Paying a
+ * model to read that is the expensive way to learn a number, and the measured
+ * program shows what it costs: sixteen frames on sphinx-8721 existed because a
+ * pre-existing failure was never isolated, and the failure *names* were in the
+ * output all along.
+ *
+ * The parsers below recognise the report shapes the standard runners print.
+ * Precision is the design constraint, exactly as in `Probe`: a reader claims a
+ * complete report only when the runner printed an authoritative completion
+ * statement and the observed outcomes agree with it. Pytest requires a tally,
+ * TAP requires a plan with every planned outcome, and unittest requires its
+ * `Ran` line plus an `OK` or `FAILED` summary. Incomplete captures still return
+ * the outcomes they contain with `parsed: false`. A wrong failure set is worse
+ * than no failure set, because attribution is built on it.
+ *
+ * @since 1.0.0
+ */
+/**
+ * One run's outcome as this module could read it.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Report {
+    readonly passed: number;
+    readonly failed: ReadonlyArray<string>;
+    readonly reportedFailed: number | undefined;
+    readonly parsed: boolean;
+}
+/**
+ * Reads one run's report, or says plainly that it could not.
+ *
+ * @category parsing
+ * @since 1.0.0
+ */
+export declare const parse: (text: string) => Report;
+/**
+ * How two runs of the same command differ, which is the whole of attribution.
+ *
+ * @category parsing
+ * @since 1.0.0
+ */
+export declare const attribute: (current: Report, base: Report) => {
+    readonly introduced: ReadonlyArray<string>;
+    readonly preexisting: ReadonlyArray<string>;
+    readonly fixed: ReadonlyArray<string>;
+} | undefined;
+//# sourceMappingURL=TestReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TestReport.d.ts","sourceRoot":"","sources":["../../../src/internal/TestReport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACtC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAiHD;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,MAiBpC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,MAAM,MAAM,KACX;IACD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACtC,GAAG,SASH,CAAA"}