@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/StepBoundary.js

@@ -0,0 +1,619 @@
+"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 StepBoundary_exports = {};
+__export(StepBoundary_exports, {
+  BoundaryCorruption: () => BoundaryCorruption,
+  BoundaryDeviation: () => BoundaryDeviation,
+  BoundaryEvidence: () => BoundaryEvidence,
+  ExpectedSetDeviation: () => ExpectedSetDeviation,
+  MissingArtifact: () => MissingArtifact,
+  MissingDeclaredOutput: () => MissingDeclaredOutput,
+  MissingOutputDeviation: () => MissingOutputDeviation,
+  PreparedBoundary: () => PreparedBoundary,
+  StepBoundary: () => StepBoundary,
+  SurvivingDeclaredRemoval: () => SurvivingDeclaredRemoval,
+  SurvivingRemovalDeviation: () => SurvivingRemovalDeviation,
+  UndeclaredWrite: () => UndeclaredWrite,
+  UnsupportedBoundary: () => UnsupportedBoundary,
+  exactReads: () => exactReads,
+  layer: () => layer,
+  layerTest: () => layerTest,
+  make: () => make,
+  makeFileSystem: () => makeFileSystem,
+  readSetMatches: () => readSetMatches,
+  referencedDigests: () => referencedDigests
+});
+module.exports = __toCommonJS(StepBoundary_exports);
+var ArtifactStore = __toESM(require("@smthrs/artifacts/ArtifactStore"), 1);
+var import_crypto = require("@smthrs/crypto");
+var import_FileBoundary = require("@smthrs/flow/FileBoundary");
+var import_FileInput = require("@smthrs/flow/FileInput");
+var KernelFileSystem = __toESM(require("@smthrs/kernel/FileSystem"), 1);
+var import_Workspace = require("@smthrs/kernel/Workspace");
+var import_keys = require("@smthrs/keys");
+var FileSet = __toESM(require("@smthrs/plan/FileSet"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Encoding = __toESM(require("effect/Encoding"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Path = __toESM(require("effect/Path"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var FileBoundarySnapshot = __toESM(require("./internal/FileBoundarySnapshot.js"), 1);
+var FileEnumeration = __toESM(require("./internal/FileEnumeration.js"), 1);
+var import_Ordering = require("./internal/Ordering.js");
+const PreparedBoundary = Schema.Struct({
+  descriptor: import_FileBoundary.FileBoundary,
+  /**
+   * What the host actually measured for the declared read set at prepare
+   * time. The declared digests are caller metadata folded into the step key;
+   * this is the evidence that they still describe reality, and a sealed
+   * cache hit is refused when the two disagree (issue #90).
+   */
+  readSnapshot: Schema.Array(import_FileInput.FileInput)
+});
+const exactReads = (descriptor) => descriptor.readSet.filter((entry) => !FileSet.isGlob(entry));
+const readSetMatches = (prepared) => {
+  const digestsByPath = /* @__PURE__ */ new Map();
+  for (const measured of prepared.readSnapshot) {
+    const digests = digestsByPath.get(measured.path);
+    if (digests === void 0) digestsByPath.set(measured.path, /* @__PURE__ */ new Set([measured.digest]));
+    else digests.add(measured.digest);
+  }
+  return prepared.descriptor.readSet.every(
+    (entry) => !FileSet.isGlob(entry) && digestsByPath.get(entry.path)?.has(entry.digest) === true
+  );
+};
+const ExpectedSetDeviation = Schema.TaggedStruct("ExpectedSetDeviation", {
+  paths: Schema.Array(Schema.String),
+  diffIdentity: Schema.NonEmptyString
+});
+const MissingOutputDeviation = Schema.TaggedStruct("MissingDeclaredOutput", {
+  paths: Schema.Array(Schema.String),
+  diffIdentity: Schema.NonEmptyString
+});
+const SurvivingRemovalDeviation = Schema.TaggedStruct("SurvivingDeclaredRemoval", {
+  paths: Schema.Array(Schema.String),
+  diffIdentity: Schema.NonEmptyString
+});
+const BoundaryDeviation = Schema.Union([ExpectedSetDeviation, MissingOutputDeviation, SurvivingRemovalDeviation]);
+const BoundaryEvidence = Schema.Struct({
+  declaredOutputs: Schema.Unknown,
+  diffIdentity: Schema.NonEmptyString,
+  /**
+   * The boundary observed the whole execution tree and proved that every
+   * write was covered by the descriptor's write set. Only evidence carrying
+   * this explicit proof may enter the cross-run cache. Older evidence and
+   * boundaries that can inspect declared paths only omit it.
+   */
+  wholeTreeWritesVerified: Schema.optional(Schema.Literal(true)),
+  /** The body could observe only declared filesystem inputs. */
+  hermeticReadsVerified: Schema.optional(Schema.Literal(true)),
+  deviation: Schema.optional(BoundaryDeviation)
+});
+class UndeclaredWrite extends Schema.TaggedError()(
+  "@smthrs/engine-store/UndeclaredWrite",
+  {
+    code: Schema.Literal("undeclared_write"),
+    paths: Schema.Array(Schema.String),
+    diffIdentity: Schema.NonEmptyString
+  }
+) {
+}
+class MissingDeclaredOutput extends Schema.TaggedError()(
+  "@smthrs/engine-store/MissingDeclaredOutput",
+  {
+    code: Schema.Literal("missing_declared_output"),
+    paths: Schema.Array(Schema.String),
+    diffIdentity: Schema.NonEmptyString
+  }
+) {
+}
+class SurvivingDeclaredRemoval extends Schema.TaggedError()(
+  "@smthrs/engine-store/SurvivingDeclaredRemoval",
+  {
+    code: Schema.Literal("surviving_declared_removal"),
+    paths: Schema.Array(Schema.String),
+    diffIdentity: Schema.NonEmptyString
+  }
+) {
+}
+class UnsupportedBoundary extends Schema.TaggedError()(
+  "@smthrs/engine-store/UnsupportedBoundary",
+  {
+    code: Schema.Literal("unsupported_boundary"),
+    message: Schema.String,
+    /**
+     * The refusing host or artifact-store failure, carried whole rather than
+     * flattened into the message (`PlatformError`'s own convention), so the
+     * journal record and a live debugger both see the original error.
+     */
+    cause: Schema.optional(Schema.Defect())
+  }
+) {
+}
+class BoundaryCorruption extends Schema.TaggedError()(
+  "@smthrs/engine-store/BoundaryCorruption",
+  {
+    code: Schema.Literal("boundary_corruption"),
+    path: Schema.String,
+    recordedDigest: Schema.String,
+    measuredDigest: Schema.String
+  }
+) {
+}
+class MissingArtifact extends Schema.TaggedError()(
+  "@smthrs/engine-store/MissingArtifact",
+  {
+    code: Schema.Literal("missing_artifact"),
+    path: Schema.String,
+    digest: Schema.String
+  }
+) {
+}
+const StepBoundary = Context.Service(
+  "@smthrs/engine-store/StepBoundary"
+);
+const make = (service) => StepBoundary.of(service);
+const absentDigest = "absent";
+const DigestReferencedOutput = Schema.Struct({
+  path: Schema.String,
+  digest: Schema.NullOr(ArtifactStore.Digest),
+  sizeBytes: Schema.optional(Schema.Number),
+  content: Schema.optional(Schema.String)
+});
+const MaterializedOutputs = Schema.Struct({
+  outputs: Schema.Array(DigestReferencedOutput),
+  trees: Schema.optional(Schema.Array(Schema.Struct({
+    path: Schema.String,
+    identity: Schema.String
+  })))
+});
+const parentDirectory = (path) => {
+  const index = path.lastIndexOf("/");
+  return index <= 0 ? void 0 : path.slice(0, index);
+};
+const hostFailure = (cause) => new UnsupportedBoundary({
+  code: "unsupported_boundary",
+  message: "the host filesystem could not enforce the step boundary",
+  cause
+});
+const artifactFailure = (cause) => new UnsupportedBoundary({
+  code: "unsupported_boundary",
+  message: `the artifact store could not serve the step boundary: ${cause.message}`,
+  cause
+});
+const inlineCorruption = (path, recordedDigest) => new BoundaryCorruption({
+  code: "boundary_corruption",
+  path,
+  recordedDigest,
+  measuredDigest: "invalid_base64"
+});
+const defaultMaxInlineBytes = 1024 * 1024;
+const defaultMaxTotalInlineBytes = 8 * 1024 * 1024;
+const referencedDigests = (evidence) => {
+  const decoded = Schema.decodeUnknownResult(MaterializedOutputs)(evidence.declaredOutputs);
+  if (decoded._tag === "Failure") return [];
+  const digests = [];
+  for (const output of decoded.success.outputs) {
+    if (output.digest === null || output.content !== void 0) continue;
+    digests.push(output.digest);
+  }
+  return digests;
+};
+const makeFileSystem = (fs, platformPath, artifacts, options = {}) => {
+  const maxInlineBytes = options.maxInlineBytes ?? defaultMaxInlineBytes;
+  const maxTotalInlineBytes = options.maxTotalInlineBytes ?? defaultMaxTotalInlineBytes;
+  const readDigestFrom = Effect.fn("StepBoundary.readDigest")(function* (host, path) {
+    const bytes = yield* host.readFile(path);
+    const digest = yield* Schema.decodeUnknownEffect(import_crypto.Sha256)(bytes).pipe(Effect.orDie);
+    return { digest, bytes };
+  });
+  const readDigest = (path) => readDigestFrom(fs, path);
+  const batch = KernelFileSystem.batch(fs);
+  const measurements = Effect.fn("StepBoundary.measurements")(
+    function* (paths, content) {
+      if (batch === void 0) {
+        return yield* Effect.forEach(paths, (path) => readDigest(path).pipe(
+          Effect.map((value) => ({
+            digest: value.digest,
+            sizeBytes: value.bytes.length,
+            ...content ? { bytes: value.bytes } : {}
+          })),
+          Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(void 0)),
+          Effect.mapError(hostFailure)
+        ), { concurrency: KernelFileSystem.fallbackConcurrency });
+      }
+      const values = [];
+      for (let offset = 0; offset < paths.length; offset += batch.maxSize) {
+        const response = yield* batch.execute(
+          paths.slice(offset, offset + batch.maxSize).map((path) => ({
+            operation: "digest",
+            path,
+            content
+          }))
+        ).pipe(Effect.mapError(hostFailure));
+        for (const entry of [...response.entries].sort((a, b) => a.index - b.index)) {
+          const measured = yield* Effect.fromResult(entry.result).pipe(
+            Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(void 0)),
+            Effect.mapError(hostFailure)
+          );
+          if (measured === void 0) values.push(void 0);
+          else if (measured.operation !== "digest") {
+            return yield* Effect.fail(hostFailure(new Error("host returned a non-digest batch result")));
+          } else values.push({ ...measured, digest: measured.digest });
+        }
+      }
+      return values;
+    }
+  );
+  const measure = (path, host = fs) => readDigestFrom(host, path).pipe(
+    Effect.map((measured) => measured.digest),
+    Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(absentDigest)),
+    Effect.mapError(hostFailure)
+  );
+  const expandGlob = Effect.fn("StepBoundary.expandGlob")(function* (glob) {
+    return yield* FileEnumeration.expandGlob(fs, glob).pipe(Effect.mapError(hostFailure));
+  });
+  const treeEntries = Effect.fn("StepBoundary.treeEntries")(function* (host, path) {
+    return yield* FileEnumeration.entriesUnder(host, path).pipe(Effect.mapError(hostFailure));
+  });
+  const replayRoot = KernelFileSystem.confinedRoot(fs) ?? options.root ?? ".";
+  const replayHost = KernelFileSystem.isConfinable(fs) ? KernelFileSystem.confined(fs, replayRoot).pipe(
+    Effect.provideService(Path.Path, platformPath),
+    Effect.mapError(hostFailure)
+  ) : Effect.fail(
+    new UnsupportedBoundary({
+      code: "unsupported_boundary",
+      message: "cache replay needs a confined host filesystem; the host carries no descriptor-relative executor or isolation attestation"
+    })
+  );
+  const capture = Effect.fn("StepBoundary.capture")(
+    function* (path, inlineBudget, measured) {
+      yield* Effect.annotateCurrentSpan({ path });
+      if (measured === void 0) {
+        return { output: { path, digest: null }, inlinedBytes: 0 };
+      }
+      const bytes = measured.bytes;
+      if (bytes === void 0) return yield* Effect.fail(hostFailure(new Error("host omitted requested batch content")));
+      const digest = measured.digest;
+      if (bytes.length <= maxInlineBytes && bytes.length <= inlineBudget) {
+        return {
+          output: {
+            path,
+            digest,
+            sizeBytes: bytes.length,
+            content: Encoding.encodeBase64(bytes)
+          },
+          inlinedBytes: bytes.length
+        };
+      }
+      const stored = yield* artifacts.put(bytes).pipe(Effect.mapError(artifactFailure));
+      if (stored !== digest) {
+        return yield* Effect.fail(
+          new BoundaryCorruption({
+            code: "boundary_corruption",
+            path,
+            recordedDigest: `${stored}`,
+            measuredDigest: digest
+          })
+        );
+      }
+      return { output: { path, digest, sizeBytes: bytes.length }, inlinedBytes: 0 };
+    }
+  );
+  const materialize = Effect.fn("StepBoundary.materialize")(function* (host, output) {
+    yield* Effect.annotateCurrentSpan({ path: output.path });
+    const current = yield* measure(output.path, host).pipe(
+      Effect.map((digest) => digest !== absentDigest && digest === output.digest),
+      Effect.catch(() => Effect.succeed(false))
+    );
+    if (current) return;
+    let bytes;
+    if (output.content !== void 0) {
+      const decoded = Encoding.decodeBase64(output.content);
+      if (Result.isFailure(decoded)) {
+        return yield* Effect.fail(inlineCorruption(output.path, `${output.digest}`));
+      }
+      bytes = decoded.success;
+      const measured = yield* Schema.decodeUnknownEffect(import_crypto.Sha256)(bytes).pipe(Effect.orDie);
+      if (measured !== output.digest) {
+        return yield* Effect.fail(
+          new BoundaryCorruption({
+            code: "boundary_corruption",
+            path: output.path,
+            recordedDigest: `${output.digest}`,
+            measuredDigest: measured
+          })
+        );
+      }
+    } else {
+      bytes = yield* artifacts.get(`${output.digest}`).pipe(
+        Effect.catchTags({
+          // A reference this host cannot resolve is not a host refusal: a
+          // shared artifact tier may still hold it, so the caller gets a
+          // typed, repairable failure and fetches before falling back to a
+          // real execution (issue #172).
+          "@smthrs/artifacts/ArtifactMissing": (missing) => Effect.fail(
+            new MissingArtifact({ code: "missing_artifact", path: output.path, digest: missing.digest })
+          ),
+          // Corruption is a distinct typed failure from a transient host
+          // error (issue #150): the caller routes it to the Inconsistency
+          // receiver instead of treating it as an ordinary retryable refusal.
+          "@smthrs/artifacts/ArtifactCorruption": (corrupt) => Effect.fail(
+            new BoundaryCorruption({
+              code: "boundary_corruption",
+              path: output.path,
+              recordedDigest: corrupt.recordedDigest,
+              measuredDigest: corrupt.measuredDigest
+            })
+          ),
+          "@smthrs/artifacts/ArtifactStoreError": (failure) => Effect.fail(artifactFailure(failure))
+        })
+      );
+    }
+    const parent = parentDirectory(output.path);
+    if (parent !== void 0) {
+      yield* host.makeDirectory(parent, { recursive: true }).pipe(Effect.mapError(hostFailure));
+    }
+    yield* host.writeFile(output.path, bytes).pipe(Effect.mapError(hostFailure));
+  });
+  return make({
+    prepare: Effect.fn("StepBoundary.prepare")(function* (descriptor) {
+      const boundary = FileBoundarySnapshot.make(descriptor);
+      yield* Effect.annotateCurrentSpan({
+        reads: boundary.readSet.length,
+        boundaryMode: boundary.boundaryMode
+      });
+      const readSnapshot = [];
+      const paths = [];
+      for (const entry of boundary.readSet) {
+        if (FileSet.isGlob(entry)) {
+          paths.push(...yield* expandGlob(entry));
+        } else paths.push(entry.path);
+      }
+      const measured = yield* measurements(paths, false);
+      for (const [index, path] of paths.entries()) {
+        readSnapshot.push({ path, digest: measured[index]?.digest ?? absentDigest });
+      }
+      readSnapshot.sort((left, right) => (0, import_Ordering.compareText)(left.path, right.path));
+      return Object.freeze({
+        descriptor: boundary,
+        readSnapshot: Object.freeze(readSnapshot.map((entry) => Object.freeze({ ...entry })))
+      });
+    }),
+    settle: Effect.fn("StepBoundary.settle")(function* (prepared) {
+      yield* Effect.annotateCurrentSpan({
+        writes: prepared.descriptor.writeSet.length,
+        boundaryMode: prepared.descriptor.boundaryMode
+      });
+      const removes = prepared.descriptor.removes ?? [];
+      const declaredWrites = [...prepared.descriptor.writeSet, ...removes];
+      const declaredCovers = (path) => declaredWrites.some(
+        (entry) => typeof entry === "string" ? entry === path : entry._tag === "TreeArtifact" ? path === entry.path || path.startsWith(`${entry.path}/`) : FileSet.matchesGlob(entry, path)
+      );
+      const undeclared = [];
+      const checkedReads = prepared.readSnapshot.filter((entry) => !declaredCovers(entry.path));
+      const currentReads = yield* measurements(checkedReads.map((entry) => entry.path), false);
+      for (const [index, entry] of checkedReads.entries()) {
+        if ((currentReads[index]?.digest ?? absentDigest) !== entry.digest) undeclared.push(entry.path);
+      }
+      const outputs = [];
+      const missing = [];
+      const surviving = [];
+      let inlinedBytes = 0;
+      const outputPaths = [];
+      const treeMembers = [];
+      for (const entry of prepared.descriptor.writeSet) {
+        if (typeof entry === "string") outputPaths.push(entry);
+        else if (entry._tag === "Glob") outputPaths.push(...yield* expandGlob(entry));
+        else {
+          const files = (yield* treeEntries(fs, entry.path)).files;
+          outputPaths.push(...files);
+          treeMembers.push({ path: entry.path, files });
+        }
+      }
+      outputPaths.push(...removes);
+      const captured = /* @__PURE__ */ new Map();
+      const sortedPaths = [...new Set(outputPaths)].sort(import_Ordering.compareText);
+      const sizes = batch === void 0 ? void 0 : yield* measurements(sortedPaths, false);
+      for (let offset = 0; offset < sortedPaths.length; ) {
+        let end = offset;
+        let responseBytes = 256;
+        const size = batch?.maxSize ?? KernelFileSystem.fallbackConcurrency;
+        while (end < sortedPaths.length && end - offset < size) {
+          const estimate = 4096 + new TextEncoder().encode(sortedPaths[end]).length * 6 + Math.ceil((sizes?.[end]?.sizeBytes ?? 0) / 3) * 4;
+          if (end > offset && batch !== void 0 && responseBytes + estimate > batch.maxResponseBytes) break;
+          responseBytes += estimate;
+          end++;
+        }
+        const group = sortedPaths.slice(offset, end);
+        const contents = yield* measurements(group, true);
+        for (const [index, path] of group.entries()) {
+          const measured = contents[index];
+          if (sizes !== void 0 && measured?.digest !== sizes[offset + index]?.digest) {
+            return yield* Effect.fail(hostFailure(new Error(`output changed during measurement: ${path}`)));
+          }
+          const output = yield* capture(path, maxTotalInlineBytes - inlinedBytes, measured);
+          inlinedBytes += output.inlinedBytes;
+          outputs.push(output.output);
+          captured.set(path, output.output);
+          if (output.output.digest === null && !removes.includes(path) && prepared.descriptor.writeSet.some((entry) => typeof entry === "string" && entry === path)) missing.push(path);
+          if (output.output.digest !== null && removes.includes(path)) surviving.push(path);
+        }
+        offset = end;
+      }
+      const trees = [];
+      for (const tree of treeMembers) {
+        const pairs = tree.files.map(
+          (path) => [path.slice(tree.path.length + 1), captured.get(path).digest ?? absentDigest]
+        );
+        trees.push({
+          path: tree.path,
+          identity: yield* Schema.decodeUnknownEffect(import_keys.DerivedKey)({ kind: "tree-artifact", files: pairs }).pipe(
+            Effect.orDie
+          )
+        });
+      }
+      const diffIdentity = yield* Schema.decodeUnknownEffect(import_keys.DerivedKey)({
+        kind: "diff-identity",
+        outputs: outputs.map((output) => [output.path, output.digest]),
+        trees
+      }).pipe(Effect.orDie);
+      yield* Effect.annotateCurrentSpan({ diffIdentity });
+      if (prepared.descriptor.boundaryMode === "hard") {
+        if (undeclared.length > 0) {
+          return yield* Effect.fail(
+            new UndeclaredWrite({ code: "undeclared_write", paths: undeclared, diffIdentity })
+          );
+        }
+        if (missing.length > 0) {
+          return yield* Effect.fail(
+            new MissingDeclaredOutput({ code: "missing_declared_output", paths: missing, diffIdentity })
+          );
+        }
+        if (surviving.length > 0) {
+          return yield* Effect.fail(
+            new SurvivingDeclaredRemoval({ code: "surviving_declared_removal", paths: surviving, diffIdentity })
+          );
+        }
+      }
+      return {
+        declaredOutputs: { outputs, ...trees.length === 0 ? {} : { trees } },
+        diffIdentity,
+        // This filesystem-only boundary cannot observe writes elsewhere in
+        // the tree. Omission is deliberate: ActionPersistence treats the
+        // result as run-local and will not publish it to the shared cache.
+        //
+        // An undeclared write is reported ahead of a missing output, and a
+        // missing output ahead of a surviving removal: each is the stronger
+        // claim about the same execution, and every variant bars the evidence
+        // from the shared cache identically.
+        ...undeclared.length > 0 ? { deviation: { _tag: "ExpectedSetDeviation", paths: undeclared, diffIdentity } } : missing.length > 0 ? { deviation: { _tag: "MissingDeclaredOutput", paths: missing, diffIdentity } } : surviving.length > 0 ? { deviation: { _tag: "SurvivingDeclaredRemoval", paths: surviving, diffIdentity } } : {}
+      };
+    }),
+    replayOutputs: Effect.fn("StepBoundary.replayOutputs")(function* (evidence) {
+      yield* Effect.annotateCurrentSpan({ diffIdentity: evidence.diffIdentity });
+      const decoded = Schema.decodeUnknownResult(MaterializedOutputs)(evidence.declaredOutputs);
+      if (decoded._tag === "Failure") {
+        return yield* Effect.fail(
+          new UnsupportedBoundary({
+            code: "unsupported_boundary",
+            message: "the recorded boundary evidence carries no materializable outputs"
+          })
+        );
+      }
+      const foreign = [
+        ...(decoded.success.trees ?? []).map((tree) => tree.path),
+        ...decoded.success.outputs.map((output) => output.path)
+      ].filter((path) => !FileSet.workspaceRelative(path));
+      if (foreign.length > 0) {
+        return yield* Effect.fail(
+          new UnsupportedBoundary({
+            code: "unsupported_boundary",
+            message: `the recorded boundary evidence names paths outside the workspace: ${foreign.join(", ")}`
+          })
+        );
+      }
+      const host = yield* replayHost;
+      const emptyDirectoryCandidates = /* @__PURE__ */ new Set();
+      for (const tree of decoded.success.trees ?? []) {
+        const prefix = `${tree.path}/`.replace(/\/{2,}$/g, "/");
+        const recorded = new Set(
+          decoded.success.outputs.map((output) => output.path).filter((path) => path.startsWith(prefix))
+        );
+        const entries = yield* treeEntries(host, tree.path);
+        for (const path of entries.files) {
+          if (!recorded.has(path)) yield* host.remove(path).pipe(Effect.mapError(hostFailure));
+        }
+        for (const directory of entries.directories) emptyDirectoryCandidates.add(directory);
+      }
+      for (const output of decoded.success.outputs) {
+        if (output.digest === null) {
+          yield* host.remove(output.path, { force: true }).pipe(Effect.mapError(hostFailure));
+        } else {
+          yield* materialize(host, output);
+        }
+      }
+      const directories = [...emptyDirectoryCandidates].sort(
+        (left, right) => right.length - left.length || (0, import_Ordering.compareText)(left, right)
+      );
+      for (const directory of directories) {
+        const entries = yield* host.readDirectory(directory).pipe(Effect.mapError(hostFailure));
+        if (entries.length === 0) yield* host.remove(directory).pipe(Effect.mapError(hostFailure));
+      }
+    })
+  });
+};
+const layer = Layer.effect(
+  StepBoundary,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const platformPath = yield* Path.Path;
+    const artifacts = yield* ArtifactStore.ArtifactStore;
+    const workspace = yield* Effect.serviceOption(import_Workspace.Workspace);
+    return makeFileSystem(fs, platformPath, artifacts, workspace._tag === "Some" ? { root: workspace.value.root } : {});
+  })
+);
+const unsupported = () => new UnsupportedBoundary({
+  code: "unsupported_boundary",
+  message: "the host cannot enforce the declared step boundary"
+});
+const layerTest = (options = {}) => {
+  const diffIdentity = options.diffIdentity ?? "test-diff";
+  const service = make({
+    prepare: Effect.fn("StepBoundary.prepare")(function* (descriptor) {
+      if (options.supported === false) return yield* Effect.fail(unsupported());
+      return {
+        descriptor,
+        readSnapshot: options.readSnapshot ?? exactReads(descriptor)
+      };
+    }),
+    settle: Effect.fn("StepBoundary.settle")(function* (prepared) {
+      if (options.supported === false) return yield* Effect.fail(unsupported());
+      if (options.failure !== void 0) return yield* Effect.fail(options.failure);
+      return {
+        declaredOutputs: options.declaredOutputs ?? { paths: prepared.descriptor.writeSet },
+        diffIdentity,
+        ...options.wholeTreeWriteDetection === false ? {} : { wholeTreeWritesVerified: true },
+        ...options.hermeticReadDetection === false ? {} : { hermeticReadsVerified: true },
+        ...options.deviation === void 0 ? {} : { deviation: options.deviation }
+      };
+    }),
+    replayOutputs: Effect.fn("StepBoundary.replayOutputs")(function* (evidence) {
+      if (options.supported === false) return yield* Effect.fail(unsupported());
+      yield* Effect.sync(() => {
+        options.onReplay?.(evidence);
+      });
+    })
+  });
+  return Layer.succeed(StepBoundary, service);
+};
+//# sourceMappingURL=StepBoundary.js.map