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

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

@@ -0,0 +1,109 @@
+/**
+ * Mutation preparation for versioned hosts and cooperative locks for ordinary hosts.
+ * Ordinary locks fail closed after process death; they are never stolen on a timer.
+ *
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import * as StdError from "../StdError.ts";
+/**
+ * Authenticated standard-flow call session; absent callers cannot borrow another run's base.
+ *
+ * @category context
+ * @since 1.0.0
+ */
+export declare const ReadSession: Context.Reference<string | undefined>;
+/**
+ * The coding host attaches one run-scoped precondition policy to its guarded filesystem.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const Preconditions: unique symbol;
+/**
+ * One prepared file change; moves include a write and a guarded source removal.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Change {
+    readonly path: string;
+    /** Null removes a file. Writes preserve existing metadata; new files use host defaults. */
+    readonly content: Uint8Array | null;
+}
+/**
+ * A per-invocation provider receipt boundary, with immutable captured read bases.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Prepared {
+    /** Return bytes matching the captured base, never an unchecked current read. */
+    readonly read: (path: string) => Effect.Effect<Uint8Array, StdError.StdError>;
+    readonly commit: (changes: ReadonlyArray<Change>) => Effect.Effect<void, StdError.StdError>;
+}
+/**
+ * Read records only successful model-facing reads; mutation-internal reads never refresh a base.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface VersionedFileSystem extends FileSystem.FileSystem {
+    readonly [Preconditions]?: {
+        readonly record: (path: string, bytes: Uint8Array, session: string | undefined) => Effect.Effect<void, StdError.StdError>;
+        readonly validate: (paths: ReadonlyArray<string>, session: string | undefined) => Effect.Effect<void, StdError.StdError>;
+        /** Capture this invocation's bases from the existing ledger before tool-internal
+         * reads. The returned commit must compare them again inside the provider, then
+         * settle the entire batch before advancing the ledger. Concurrent reads or
+         * commits must never replace these captured bases. Preparation does not freeze
+         * callers; only the complete commit may acquire guest-wide exclusion.
+         */
+        readonly prepare?: (paths: ReadonlyArray<string>, session: string | undefined) => Effect.Effect<Prepared, StdError.StdError>;
+    };
+}
+/**
+ * Versioned hosts own parent creation and locking inside their atomic commit.
+ *
+ * @category guards
+ * @since 1.0.0
+ */
+export declare const isVersioned: (fs: FileSystem.FileSystem) => boolean;
+/**
+ * Record the entire original file, before pagination, through the host's existing policy.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export declare const recordRead: (fs: FileSystem.FileSystem, path: string, bytes: Uint8Array) => Effect.Effect<void, StdError.StdError, never>;
+/**
+ * Refuse an unqualified provider before creating any parent or lock directories.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export declare const validate: (fs: FileSystem.FileSystem, paths: ReadonlyArray<string>) => Effect.Effect<undefined, StdError.StdError, never>;
+/**
+ * The portable body is used only for an ordinary, unversioned filesystem.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Mutation {
+    readonly read: (path: string, ordinary: Effect.Effect<Uint8Array, StdError.StdError>) => Effect.Effect<Uint8Array, StdError.StdError>;
+    readonly commit: (changes: ReadonlyArray<Change>, ordinary: Effect.Effect<void, StdError.StdError>) => Effect.Effect<void, StdError.StdError>;
+}
+/**
+ * Versioned hosts capture bases under a local semaphore until scope exit.
+ * Ordinary hosts hold all named files using exclusive mkdir, so independently
+ * composed hosts and processes agree.
+ * A hash collision only refuses an unrelated edit; it cannot lose exclusion.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const acquire: (fileSystem: FileSystem.FileSystem, paths: ReadonlyArray<string>, creationPaths?: Path.Path) => Effect.Effect<Mutation, StdError.StdError, Scope.Scope>;
+//# sourceMappingURL=FileMutation.d.ts.map

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

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

package/dist/esm/internal/FileMutation.js

@@ -0,0 +1,123 @@
+/**
+ * Mutation preparation for versioned hosts and cooperative locks for ordinary hosts.
+ * Ordinary locks fail closed after process death; they are never stolen on a timer.
+ *
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Semaphore from "effect/Semaphore";
+import * as StdError from "../StdError.js";
+import * as FsFailure from "./FsFailure.js";
+/**
+ * Authenticated standard-flow call session; absent callers cannot borrow another run's base.
+ *
+ * @category context
+ * @since 1.0.0
+ */
+export const ReadSession = Context.Reference("@smthrs/std/ReadSession", {
+    defaultValue: () => undefined
+});
+/**
+ * The coding host attaches one run-scoped precondition policy to its guarded filesystem.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export const Preconditions = Symbol.for("@smthrs/std/file-preconditions");
+const unavailable = () => Effect.fail(new StdError.StdError({
+    code: "provider_unavailable",
+    message: "Authenticated atomic file mutation provider unavailable"
+}));
+/**
+ * Versioned hosts own parent creation and locking inside their atomic commit.
+ *
+ * @category guards
+ * @since 1.0.0
+ */
+export const isVersioned = (fs) => fs[Preconditions] !== undefined;
+/**
+ * Record the entire original file, before pagination, through the host's existing policy.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export const recordRead = (fs, path, bytes) => Effect.flatMap(ReadSession, (session) => fs[Preconditions]?.record(path, bytes, session) ?? Effect.void);
+/**
+ * Refuse an unqualified provider before creating any parent or lock directories.
+ *
+ * @category filesystem
+ * @since 1.0.0
+ */
+export const validate = (fs, paths) => Effect.gen(function* () {
+    const policy = fs[Preconditions];
+    if (policy === undefined)
+        return;
+    const session = yield* ReadSession;
+    yield* policy.validate(paths, session);
+    if (policy.prepare === undefined)
+        return yield* unavailable();
+});
+// This serializes one host's preparation, ledger and diagnostic ordering only.
+// It is NOT the guest's outside-writer exclusion or its atomic commit boundary.
+const hostLocks = new WeakMap();
+// The on-disk lock protocol owns this hash; dependency upgrades must not
+// change the name and let two versions acquire different locks for one file.
+// Case/normalization aliases deliberately share a lock, including on hosts
+// whose realPath preserves caller casing. Case-sensitive hosts may refuse a
+// simultaneous change to a distinct case variant; that is safe contention.
+const lockHash = (value) => {
+    value = value.normalize("NFC").toUpperCase();
+    let hash = 5381;
+    for (let index = 0; index < value.length; index++)
+        hash = (hash * 33) ^ value.charCodeAt(index);
+    return (hash >>> 0).toString(16);
+};
+const parent = (path) => path.slice(0, path.lastIndexOf(path.startsWith("/") ? "/" : "\\") + 1);
+/**
+ * Versioned hosts capture bases under a local semaphore until scope exit.
+ * Ordinary hosts hold all named files using exclusive mkdir, so independently
+ * composed hosts and processes agree.
+ * A hash collision only refuses an unrelated edit; it cannot lose exclusion.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const acquire = (fileSystem, paths, creationPaths) => Effect.gen(function* () {
+    // Unavailable coding providers refuse before acquiring even protocol state.
+    // The versioned provider owns exclusion and revalidation at its commit;
+    // cooperative caller-side locks cannot exclude terminal or SSH writers.
+    yield* validate(fileSystem, paths);
+    const policy = fileSystem[Preconditions];
+    if (policy !== undefined) {
+        let lock = hostLocks.get(policy);
+        if (lock === undefined) {
+            lock = Semaphore.makeUnsafe(1);
+            hostLocks.set(policy, lock);
+        }
+        const held = lock;
+        yield* Effect.acquireRelease(held.take(1), () => held.release(1), { interruptible: true });
+        const session = yield* ReadSession;
+        const prepared = yield* policy.prepare(paths, session);
+        return { read: (path) => prepared.read(path), commit: (changes) => prepared.commit(changes) };
+    }
+    const locks = new Map();
+    for (const path of paths) {
+        const destination = yield* fileSystem.realPath(path).pipe(Effect.catch((error) => error.reason._tag === "NotFound" && creationPaths !== undefined
+            ? fileSystem.realPath(creationPaths.dirname(path)).pipe(Effect.map((directory) => creationPaths.join(directory, creationPaths.basename(path))))
+            : Effect.fail(error)), Effect.mapError(FsFailure.reading(path, `File not found: ${path}`)));
+        const lock = `${parent(destination)}.smithers-${lockHash(destination)}.lock`;
+        locks.set(lock, path);
+    }
+    for (const [lock, path] of [...locks].sort(([left], [right]) => left.localeCompare(right))) {
+        yield* Effect.acquireRelease(fileSystem.makeDirectory(lock, { mode: 0o700 }).pipe(Effect.mapError(FsFailure.denied(path, (error) => new StdError.StdError({
+            code: error.reason._tag === "AlreadyExists" ? "no_match" : "command_failed",
+            message: error.reason._tag === "AlreadyExists"
+                ? `Concurrent mutation of ${path}: lock ${lock} is held. Re-read and retry after the other writer finishes; a stopped writer's lock requires explicit recovery.`
+                : `Could not lock ${path} for mutation`,
+            path
+        })))), () => fileSystem.remove(lock, { recursive: true }).pipe(Effect.orDie));
+    }
+    return { read: (_path, ordinary) => ordinary, commit: (_changes, ordinary) => ordinary };
+});
+//# sourceMappingURL=FileMutation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileMutation.js","sourceRoot":"","sources":["../../../src/internal/FileMutation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mutation preparation for versioned hosts and cooperative locks for ordinary hosts.\n * Ordinary locks fail closed after process death; they are never stolen on a timer.\n *\n * @since 1.0.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport type * as FileSystem from \"effect/FileSystem\"\nimport type * as Path from \"effect/Path\"\nimport type * as Scope from \"effect/Scope\"\nimport * as Semaphore from \"effect/Semaphore\"\nimport * as StdError from \"../StdError.ts\"\nimport * as FsFailure from \"./FsFailure.ts\"\n\n/**\n * Authenticated standard-flow call session; absent callers cannot borrow another run's base.\n *\n * @category context\n * @since 1.0.0\n */\nexport const ReadSession = Context.Reference<string | undefined>(\"@smthrs/std/ReadSession\", {\n  defaultValue: () => undefined\n})\n\n/**\n * The coding host attaches one run-scoped precondition policy to its guarded filesystem.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const Preconditions = Symbol.for(\"@smthrs/std/file-preconditions\")\n\n/**\n * One prepared file change; moves include a write and a guarded source removal.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Change {\n  readonly path: string\n  /** Null removes a file. Writes preserve existing metadata; new files use host defaults. */\n  readonly content: Uint8Array | null\n}\n\n/**\n * A per-invocation provider receipt boundary, with immutable captured read bases.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Prepared {\n  /** Return bytes matching the captured base, never an unchecked current read. */\n  readonly read: (path: string) => Effect.Effect<Uint8Array, StdError.StdError>\n  readonly commit: (changes: ReadonlyArray<Change>) => Effect.Effect<void, StdError.StdError>\n}\n\n/**\n * Read records only successful model-facing reads; mutation-internal reads never refresh a base.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface VersionedFileSystem extends FileSystem.FileSystem {\n  readonly [Preconditions]?: {\n    readonly record: (\n      path: string,\n      bytes: Uint8Array,\n      session: string | undefined\n    ) => Effect.Effect<void, StdError.StdError>\n    readonly validate: (\n      paths: ReadonlyArray<string>,\n      session: string | undefined\n    ) => Effect.Effect<void, StdError.StdError>\n    /** Capture this invocation's bases from the existing ledger before tool-internal\n     * reads. The returned commit must compare them again inside the provider, then\n     * settle the entire batch before advancing the ledger. Concurrent reads or\n     * commits must never replace these captured bases. Preparation does not freeze\n     * callers; only the complete commit may acquire guest-wide exclusion.\n     */\n    readonly prepare?: (\n      paths: ReadonlyArray<string>,\n      session: string | undefined\n    ) => Effect.Effect<Prepared, StdError.StdError>\n  }\n}\n\nconst unavailable = () =>\n  Effect.fail(\n    new StdError.StdError({\n      code: \"provider_unavailable\",\n      message: \"Authenticated atomic file mutation provider unavailable\"\n    })\n  )\n\n/**\n * Versioned hosts own parent creation and locking inside their atomic commit.\n *\n * @category guards\n * @since 1.0.0\n */\nexport const isVersioned = (fs: FileSystem.FileSystem): boolean =>\n  (fs as VersionedFileSystem)[Preconditions] !== undefined\n\n/**\n * Record the entire original file, before pagination, through the host's existing policy.\n *\n * @category filesystem\n * @since 1.0.0\n */\nexport const recordRead = (fs: FileSystem.FileSystem, path: string, bytes: Uint8Array) =>\n  Effect.flatMap(\n    ReadSession,\n    (session) => (fs as VersionedFileSystem)[Preconditions]?.record(path, bytes, session) ?? Effect.void\n  )\n\n/**\n * Refuse an unqualified provider before creating any parent or lock directories.\n *\n * @category filesystem\n * @since 1.0.0\n */\nexport const validate = (fs: FileSystem.FileSystem, paths: ReadonlyArray<string>) =>\n  Effect.gen(function*() {\n    const policy = (fs as VersionedFileSystem)[Preconditions]\n    if (policy === undefined) return\n    const session = yield* ReadSession\n    yield* policy.validate(paths, session)\n    if (policy.prepare === undefined) return yield* unavailable()\n  })\n\n/**\n * The portable body is used only for an ordinary, unversioned filesystem.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Mutation {\n  readonly read: (\n    path: string,\n    ordinary: Effect.Effect<Uint8Array, StdError.StdError>\n  ) => Effect.Effect<Uint8Array, StdError.StdError>\n  readonly commit: (\n    changes: ReadonlyArray<Change>,\n    ordinary: Effect.Effect<void, StdError.StdError>\n  ) => Effect.Effect<void, StdError.StdError>\n}\n\n// This serializes one host's preparation, ledger and diagnostic ordering only.\n// It is NOT the guest's outside-writer exclusion or its atomic commit boundary.\nconst hostLocks = new WeakMap<object, Semaphore.Semaphore>()\n\n// The on-disk lock protocol owns this hash; dependency upgrades must not\n// change the name and let two versions acquire different locks for one file.\n// Case/normalization aliases deliberately share a lock, including on hosts\n// whose realPath preserves caller casing. Case-sensitive hosts may refuse a\n// simultaneous change to a distinct case variant; that is safe contention.\nconst lockHash = (value: string): string => {\n  value = value.normalize(\"NFC\").toUpperCase()\n  let hash = 5381\n  for (let index = 0; index < value.length; index++) hash = (hash * 33) ^ value.charCodeAt(index)\n  return (hash >>> 0).toString(16)\n}\n\nconst parent = (path: string) => path.slice(0, path.lastIndexOf(path.startsWith(\"/\") ? \"/\" : \"\\\\\") + 1)\n\n/**\n * Versioned hosts capture bases under a local semaphore until scope exit.\n * Ordinary hosts hold all named files using exclusive mkdir, so independently\n * composed hosts and processes agree.\n * A hash collision only refuses an unrelated edit; it cannot lose exclusion.\n *\n * @private\n * @since 1.0.0\n */\nexport const acquire = (\n  fileSystem: FileSystem.FileSystem,\n  paths: ReadonlyArray<string>,\n  creationPaths?: Path.Path\n): Effect.Effect<Mutation, StdError.StdError, Scope.Scope> =>\n  Effect.gen(function*() {\n    // Unavailable coding providers refuse before acquiring even protocol state.\n    // The versioned provider owns exclusion and revalidation at its commit;\n    // cooperative caller-side locks cannot exclude terminal or SSH writers.\n    yield* validate(fileSystem, paths)\n    const policy = (fileSystem as VersionedFileSystem)[Preconditions]\n    if (policy !== undefined) {\n      let lock = hostLocks.get(policy)\n      if (lock === undefined) {\n        lock = Semaphore.makeUnsafe(1)\n        hostLocks.set(policy, lock)\n      }\n      const held = lock\n      yield* Effect.acquireRelease(held.take(1), () => held.release(1), { interruptible: true })\n      const session = yield* ReadSession\n      const prepared = yield* policy.prepare!(paths, session)\n      return { read: (path) => prepared.read(path), commit: (changes) => prepared.commit(changes) }\n    }\n    const locks = new Map<string, string>()\n    for (const path of paths) {\n      const destination = yield* fileSystem.realPath(path).pipe(\n        Effect.catch((error) =>\n          error.reason._tag === \"NotFound\" && creationPaths !== undefined\n            ? fileSystem.realPath(creationPaths.dirname(path)).pipe(\n              Effect.map((directory) => creationPaths.join(directory, creationPaths.basename(path)))\n            )\n            : Effect.fail(error)\n        ),\n        Effect.mapError(FsFailure.reading(path, `File not found: ${path}`))\n      )\n      const lock = `${parent(destination)}.smithers-${lockHash(destination)}.lock`\n      locks.set(lock, path)\n    }\n    for (const [lock, path] of [...locks].sort(([left], [right]) => left.localeCompare(right))) {\n      yield* Effect.acquireRelease(\n        fileSystem.makeDirectory(lock, { mode: 0o700 }).pipe(\n          Effect.mapError(FsFailure.denied(path, (error) =>\n            new StdError.StdError({\n              code: error.reason._tag === \"AlreadyExists\" ? \"no_match\" : \"command_failed\",\n              message: error.reason._tag === \"AlreadyExists\"\n                ? `Concurrent mutation of ${path}: lock ${lock} is held. Re-read and retry after the other writer finishes; a stopped writer's lock requires explicit recovery.`\n                : `Could not lock ${path} for mutation`,\n              path\n            })))\n        ),\n        () => fileSystem.remove(lock, { recursive: true }).pipe(Effect.orDie)\n      )\n    }\n    return { read: (_path, ordinary) => ordinary, commit: (_changes, ordinary) => ordinary }\n  })\n"]}

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

@@ -0,0 +1,38 @@
+/**
+ * Maps a filesystem failure to the standard-flow code that names its reason.
+ *
+ * A permission denial is not a missing file. Telling the model a denied path
+ * does not exist sends it searching for a file that is right there, and hides
+ * the denial from whoever reads the run. Every standard flow that touches the
+ * filesystem routes its failures through here so `PermissionDenied` always
+ * reaches the model as `permission_denied`.
+ *
+ * @since 1.0.0
+ */
+import type * as PlatformError from "effect/PlatformError";
+import * as StdError from "../StdError.ts";
+/**
+ * The failure for a path the host or the kernel guard refused.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const permissionDenied: (path: string) => StdError.StdError;
+/**
+ * Maps `PermissionDenied` to `permission_denied` and any other reason through
+ * `otherwise`.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const denied: (path: string, otherwise: (error: PlatformError.PlatformError) => StdError.StdError) => (error: PlatformError.PlatformError) => StdError.StdError;
+/**
+ * Maps a read-side failure: `NotFound` to `not_found` with `notFoundMessage`,
+ * `PermissionDenied` to `permission_denied`, and anything else to
+ * `command_failed` carrying the host's reason.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const reading: (path: string, notFoundMessage: string) => (error: PlatformError.PlatformError) => StdError.StdError;
+//# sourceMappingURL=FsFailure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FsFailure.d.ts","sourceRoot":"","sources":["../../../src/internal/FsFailure.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,gBAAgB,GAAI,MAAM,MAAM,KAAG,QAAQ,CAAC,QAC0C,CAAA;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GACjB,MAAM,MAAM,EACZ,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,aAAa,KAAK,QAAQ,CAAC,QAAQ,MAErE,OAAO,aAAa,CAAC,aAAa,KAAG,QAAQ,CAAC,QACuC,CAAA;AAEtF;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,iBAAiB,MAAM,aAXrD,aAAa,CAAC,aAAa,KAAG,QAAQ,CAAC,QAesE,CAAA"}

package/dist/esm/internal/FsFailure.js

@@ -0,0 +1,39 @@
+/**
+ * Maps a filesystem failure to the standard-flow code that names its reason.
+ *
+ * A permission denial is not a missing file. Telling the model a denied path
+ * does not exist sends it searching for a file that is right there, and hides
+ * the denial from whoever reads the run. Every standard flow that touches the
+ * filesystem routes its failures through here so `PermissionDenied` always
+ * reaches the model as `permission_denied`.
+ *
+ * @since 1.0.0
+ */
+import * as StdError from "../StdError.js";
+/**
+ * The failure for a path the host or the kernel guard refused.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const permissionDenied = (path) => new StdError.StdError({ code: "permission_denied", message: `Permission denied: ${path}`, path });
+/**
+ * Maps `PermissionDenied` to `permission_denied` and any other reason through
+ * `otherwise`.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const denied = (path, otherwise) => (error) => error.reason._tag === "PermissionDenied" ? permissionDenied(path) : otherwise(error);
+/**
+ * Maps a read-side failure: `NotFound` to `not_found` with `notFoundMessage`,
+ * `PermissionDenied` to `permission_denied`, and anything else to
+ * `command_failed` carrying the host's reason.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export const reading = (path, notFoundMessage) => denied(path, (error) => error.reason._tag === "NotFound"
+    ? new StdError.StdError({ code: "not_found", message: notFoundMessage, path })
+    : new StdError.StdError({ code: "command_failed", message: `Could not read ${path}: ${error.message}`, path }));
+//# sourceMappingURL=FsFailure.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FsFailure.js","sourceRoot":"","sources":["../../../src/internal/FsFailure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAqB,EAAE,CAClE,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,sBAAsB,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;AAEnG;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CACpB,IAAY,EACZ,SAAoE,EACpE,EAAE,CACJ,CAAC,KAAkC,EAAqB,EAAE,CACxD,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;AAEtF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,IAAY,EAAE,eAAuB,EAAE,EAAE,CAC/D,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CACrB,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,UAAU;IAC9B,CAAC,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;IAC9E,CAAC,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,kBAAkB,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA","sourcesContent":["/**\n * Maps a filesystem failure to the standard-flow code that names its reason.\n *\n * A permission denial is not a missing file. Telling the model a denied path\n * does not exist sends it searching for a file that is right there, and hides\n * the denial from whoever reads the run. Every standard flow that touches the\n * filesystem routes its failures through here so `PermissionDenied` always\n * reaches the model as `permission_denied`.\n *\n * @since 1.0.0\n */\n\nimport type * as PlatformError from \"effect/PlatformError\"\nimport * as StdError from \"../StdError.ts\"\n\n/**\n * The failure for a path the host or the kernel guard refused.\n *\n * @private\n * @since 1.0.0\n */\nexport const permissionDenied = (path: string): StdError.StdError =>\n  new StdError.StdError({ code: \"permission_denied\", message: `Permission denied: ${path}`, path })\n\n/**\n * Maps `PermissionDenied` to `permission_denied` and any other reason through\n * `otherwise`.\n *\n * @private\n * @since 1.0.0\n */\nexport const denied = (\n  path: string,\n  otherwise: (error: PlatformError.PlatformError) => StdError.StdError\n) =>\n(error: PlatformError.PlatformError): StdError.StdError =>\n  error.reason._tag === \"PermissionDenied\" ? permissionDenied(path) : otherwise(error)\n\n/**\n * Maps a read-side failure: `NotFound` to `not_found` with `notFoundMessage`,\n * `PermissionDenied` to `permission_denied`, and anything else to\n * `command_failed` carrying the host's reason.\n *\n * @private\n * @since 1.0.0\n */\nexport const reading = (path: string, notFoundMessage: string) =>\n  denied(path, (error) =>\n    error.reason._tag === \"NotFound\"\n      ? new StdError.StdError({ code: \"not_found\", message: notFoundMessage, path })\n      : new StdError.StdError({ code: \"command_failed\", message: `Could not read ${path}: ${error.message}`, path }))\n"]}

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

@@ -0,0 +1,108 @@
+/**
+ * Detached checkouts shared by checkpoint reads and baseline test runs.
+ *
+ * ## Host git never reads a file the agent can write that names a program
+ *
+ * The repository is the workspace's, and an agent can write its `.git`: a
+ * containerised agent writes it through the bind mount. Git reads programs out
+ * of that directory in more places than any list of `-c` overrides can close.
+ * Hooks and `core.fsmonitor` can be overridden, but a filter driver
+ * (`filter.<name>.clean`/`.smudge` in `.git/config`, selected by
+ * `.git/info/attributes`) cannot: git has no switch that ignores repository
+ * config or `$GIT_DIR/info/attributes`, and overriding each driver by name
+ * races an agent that keeps rewriting the file.
+ *
+ * So the git that records and checks out trees runs against a **shadow**
+ * `GIT_DIR`: a bare repository this module creates under the host's temporary
+ * directory for one operation and deletes afterwards. Its config, hooks and
+ * `info/attributes` are the ones `git init --template=` writes, which is none.
+ * `GIT_CONFIG_NOSYSTEM` and `GIT_CONFIG_GLOBAL=/dev/null` drop the host's own
+ * config files too, so the only settings are the ones on the command line.
+ * `GIT_OBJECT_DIRECTORY` points at the workspace's object store, because objects
+ * are data: git hashes and inflates them and never runs anything they say.
+ *
+ * What still touches the workspace repository is plain data:
+ *
+ * - `rev-parse` in the workspace, which resolves refs and paths and runs no
+ *   hook, filter, fsmonitor or other configured program;
+ * - `git config --file <workspace config>`, which reads or writes that one file
+ *   and follows no `include`;
+ * - a copy of the workspace index into the shadow, so the recorded tree holds
+ *   what the agent staged without the harness writing the agent's index; and
+ * - a handful of `core.*` settings that change how bytes are hashed
+ *   ({@link dataSettings}), each accepted only as a bare word.
+ *
+ * A materialized checkout gets its own standalone `.git`, written by this
+ * module as files, so a container can still run git in it: `HEAD` names the
+ * commit, `objects/info/alternates` points back at the workspace's objects by a
+ * relative path, and `index` is the one the checkout was written from. Host git
+ * never uses that directory; it is the container's.
+ *
+ * @since 1.0.0
+ */
+import type { ChildProcessSpawner } from "@smthrs/kernel/ChildProcessSpawner";
+import { Effect } from "effect";
+import * as StdError from "../StdError.ts";
+import * as Exec from "./Exec.ts";
+/**
+ * Where one workspace repository keeps what the shadow needs, as its own git
+ * reports it.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Repository {
+    /** The root the caller named, without a trailing slash. */
+    readonly root: string;
+    /** The same directory, as git canonicalizes it. */
+    readonly toplevel: string;
+    /** The common git directory, which holds config and objects. */
+    readonly common: string;
+    /** The workspace index. */
+    readonly index: string;
+    readonly objectFormat: string;
+    /** {@link dataSettings} as `-c` arguments. */
+    readonly settings: ReadonlyArray<string>;
+}
+/**
+ * A harness-owned `GIT_DIR` over one workspace's objects.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Shadow {
+    readonly path: string;
+    readonly repository: Repository;
+    /** Runs host git with the shadow as `GIT_DIR`, and `workTree` as its work tree when given. */
+    readonly git: (args: ReadonlyArray<string>, workTree?: string) => Effect.Effect<Exec.ExecResult, StdError.StdError, ChildProcessSpawner>;
+    /**
+     * Copies the workspace index into the shadow, with its modification time, so
+     * the shadow never writes the agent's own.
+     *
+     * The time is part of what git reads. It trusts an entry's recorded stat
+     * unless the entry is at least as new as the index file, in whole seconds;
+     * a copy stamped at the moment of copying made every entry look older, and a
+     * same-size edit from the second the index was written was recorded as the
+     * committed bytes (#3431). The time is taken before the bytes are read, so
+     * an index rewritten meanwhile leaves the copy looking older, never newer.
+     */
+    readonly adoptIndex: Effect.Effect<void, StdError.StdError, ChildProcessSpawner>;
+}
+/**
+ * Internal Git operations used by both checkpoint and baseline leases.
+ *
+ * @category utilities
+ * @since 1.0.0
+ */
+export declare const GitWorktree: {
+    config: (repository: Pick<Repository, "common">, args: ReadonlyArray<string>) => Effect.Effect<Exec.ExecResult, StdError.StdError, ChildProcessSpawner>;
+    git: (root: string, args: ReadonlyArray<string>) => Effect.Effect<Exec.ExecResult, StdError.StdError, ChildProcessSpawner>;
+    open: (root: string) => Effect.Effect<Repository, StdError.StdError, ChildProcessSpawner>;
+    resolveCommit: (root: string, refs: ReadonlyArray<string>) => Effect.Effect<{
+        ref: string;
+        commit: string;
+    }, StdError.StdError, ChildProcessSpawner>;
+    withDetachedWorktree: <A, E, R>(root: string, prefix: string, commit: string, use: (host: string) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StdError.StdError, R | ChildProcessSpawner>;
+    withShadow: <A, E, R>(root: string | Repository, use: (shadow: Shadow) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StdError.StdError, R | ChildProcessSpawner>;
+};
+//# sourceMappingURL=GitWorktree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GitWorktree.d.ts","sourceRoot":"","sources":["../../../src/internal/GitWorktree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AA+CjC;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACzC;AAuDD;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,8FAA8F;IAC9F,QAAQ,CAAC,GAAG,EAAE,CACZ,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAA;IAC3E;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAA;CACjF;AAmSD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;yBA/WI,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,aAAa,CAAC,MAAM,CAAC;gBA1ChE,MAAM,QAAQ,aAAa,CAAC,MAAM,CAAC;iBA6ClC,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;0BA3CjE,MAAM,QAAQ,aAAa,CAAC,MAAM,CAAC;;;;2BAmXlC,CAAC,EAAE,CAAC,EAAE,CAAC,QAC7B,MAAM,UACJ,MAAM,UACN,MAAM,OACT,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC5C,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,mBAAmB,CAAC;iBA3N/C,CAAC,EAAE,CAAC,EAAE,CAAC,QACnB,MAAM,GAAG,UAAU,OACpB,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC9C,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,mBAAmB,CAAC;CAuP8B,CAAA"}