@jigging/jig 0.1.0-alpha.26 → 0.1.0-alpha.27

package/libexec/installed-cli.js

@@ -9087,7 +9087,7 @@ import { setTimeout as delay } from "timers/promises";
 // package.json
 var package_default = {
   name: "@jigging/jig",
-  version: "0.1.0-alpha.26",
+  version: "0.1.0-alpha.27",
   description: "A local, secure host for admitted FLOW packages",
   license: "SEE LICENSE IN LICENSE.md",
   repository: {
@@ -21199,6 +21199,7 @@ async function captureAttempt(root, backing, selection) {
   const directories = new Set([identityKey(root.information)]);
   let totalBytes = 0;
   let directoryCount = 0;
+  const copyBuffer = new Uint8Array(COPY_CHUNK_BYTES);
   async function walk(directory, logicalDirectory) {
     directoryCount += 1;
     if (directoryCount > MAX_DIRECTORIES) {
@@ -21224,7 +21225,7 @@ async function captureAttempt(root, backing, selection) {
           invalid("PACKAGE_LIMIT", "selected dependency source exceeds its capture budget", logicalPath);
         await rejectKnownOversizeFile(entry.handle, entry.information, logicalPath);
         const offset = totalBytes;
-        const size = await copyToBacking(entry.handle, backing, offset, totalBytes, logicalPath, selection?.maximumBytes);
+        const size = await copyToBacking(entry.handle, backing, offset, totalBytes, logicalPath, copyBuffer, selection?.maximumBytes);
         totalBytes += size;
         if (selection !== undefined && totalBytes > selection.maximumBytes)
           invalid("PACKAGE_LIMIT", "selected dependency source exceeds its capture budget", logicalPath);
@@ -21248,10 +21249,9 @@ async function captureAttempt(root, backing, selection) {
   }
   return { records, fingerprints };
 }
-async function copyToBacking(source, backing, backingOffset, priorTotal, logicalPath, maximumBytes = MAX_TOTAL_BYTES2) {
+async function copyToBacking(source, backing, backingOffset, priorTotal, logicalPath, buffer, maximumBytes = MAX_TOTAL_BYTES2) {
   let sourceOffset = 0;
   while (true) {
-    const buffer = new Uint8Array(COPY_CHUNK_BYTES);
     let bytesRead;
     try {
       ({ bytesRead } = await source.read(buffer, 0, buffer.byteLength, sourceOffset));
@@ -25903,7 +25903,7 @@ var MAX_RECORD_BYTES = 192;
 class PrivateProfileCapture {
   #fd;
   #startedAtMs = performance.now();
-  #events = [];
+  #recordCount = 0;
   #nextSpanId = 1;
   #truncated = false;
   #closed = false;
@@ -25919,8 +25919,7 @@ class PrivateProfileCapture {
       timeOriginMs: performance.timeOrigin
     };
     try {
-      writeSync3(this.#fd, `${JSON.stringify(header)}
-`);
+      this.#write(JSON.stringify(header));
     } catch (error) {
       closeSync9(this.#fd);
       throw error;
@@ -25932,13 +25931,13 @@ class PrivateProfileCapture {
       return;
     }
     const span = { spanId: this.#nextSpanId++, phase, startMs: elapsed(this.#startedAtMs) };
-    this.#events.push(JSON.stringify({ kind: "start", spanId: span.spanId, phase, timeMs: span.startMs }));
+    this.#record(JSON.stringify({ kind: "start", spanId: span.spanId, phase, timeMs: span.startMs }));
     return span;
   }
   end(span, outcome) {
     if (this.#closed)
       return;
-    this.#events.push(JSON.stringify({
+    this.#record(JSON.stringify({
       kind: "end",
       spanId: span.spanId,
       phase: span.phase,
@@ -25947,29 +25946,18 @@ class PrivateProfileCapture {
     }));
   }
   instant(phase) {
-    if (this.#closed || this.#events.length >= MAX_SPANS * 2) {
-      this.#truncated = true;
+    if (this.#closed)
       return;
-    }
     const timeMs = elapsed(this.#startedAtMs);
-    this.#events.push(JSON.stringify({ kind: "instant", phase, timeMs }));
+    this.#record(JSON.stringify({ kind: "instant", phase, timeMs }));
   }
   finish() {
     if (this.#closed)
       return;
     this.#closed = true;
     try {
-      for (const event of this.#events) {
-        if (Buffer.byteLength(event) > MAX_RECORD_BYTES) {
-          this.#truncated = true;
-          continue;
-        }
-        writeSync3(this.#fd, `${event}
-`);
-      }
       if (this.#truncated) {
-        writeSync3(this.#fd, `${JSON.stringify({ kind: "truncated", phaseLimit: MAX_SPANS })}
-`);
+        this.#write(JSON.stringify({ kind: "truncated", phaseLimit: MAX_SPANS }));
       }
     } finally {
       closeSync9(this.#fd);
@@ -25981,6 +25969,25 @@ class PrivateProfileCapture {
     this.#closed = true;
     closeSync9(this.#fd);
   }
+  #record(event) {
+    if (this.#recordCount >= MAX_SPANS * 2 || Buffer.byteLength(event) > MAX_RECORD_BYTES) {
+      this.#truncated = true;
+      return;
+    }
+    this.#recordCount++;
+    this.#write(event);
+  }
+  #write(event) {
+    const bytes = Buffer.from(`${event}
+`);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const written = writeSync3(this.#fd, bytes, offset, bytes.length - offset);
+      if (written === 0)
+        throw new Error("private profile write made no progress");
+      offset += written;
+    }
+  }
 }
 var configuredPath = process.env[PROFILE_ENVIRONMENT_KEY];
 var activeCapture;
@@ -26151,7 +26158,7 @@ function privateMacosExecutionPlan(intent, allocation) {
       network: intent.network ?? "isolated"
     },
     maxOutputBytes: intent.maxOutputBytes,
-    ...intent.readOnlyCwd === undefined ? {
+    ...intent.readOnlyCwd === undefined || (intent.inputDirectories?.length ?? 0) > 0 ? {
       storage: {
         mountPath: data,
         bytes: intent.storageBytes,
@@ -27351,6 +27358,7 @@ var STOP_REASONS = new Set([
   "coordinator_lost",
   "deadline",
   "payload_exit",
+  "core_dump",
   "setup_failed",
   "recovered"
 ]);
@@ -28018,6 +28026,7 @@ var SUPERVISOR_STOP_REASONS = new Set([
   "coordinator_lost",
   "deadline",
   "payload_exit",
+  "core_dump",
   "setup_failed"
 ]);
 function receiptFor(prepared, final) {
@@ -29795,7 +29804,9 @@ function requirePrivateMacosGuardianStorage(storage, files, cwd) {
   if (storage === null || typeof storage !== "object" || Object.keys(storage).sort().join() !== "bytes,collect,mountPath" || typeof storage.mountPath !== "string" || !storage.mountPath.startsWith("/") || storage.mountPath === "/" || posix8.normalize(storage.mountPath) !== storage.mountPath || !Number.isSafeInteger(storage.bytes) || storage.bytes < 16 * 1024 * 1024 || storage.bytes > 512 * 1024 * 1024 || storage.bytes % (1024 * 1024) !== 0 || ![null, "output", "work"].includes(storage.collect))
     throw new TypeError("invalid macOS guardian storage");
   const roots = ["work", "tmp", "output"].map((name) => join10(storage.mountPath, name));
-  if (files.writableTrees.some((path) => !roots.includes(path)) || !roots.some((root) => cwd === root || cwd.startsWith(`${root}/`)))
+  const inputs = join10(storage.mountPath, "inputs");
+  const readOnlyInputCwd = files.writableTrees.length === 0 && storage.collect === null && files.readOnlyTrees.includes(inputs) && (cwd === inputs || cwd.startsWith(`${inputs}/`));
+  if (files.writableTrees.some((path) => !roots.includes(path)) || !roots.some((root) => cwd === root || cwd.startsWith(`${root}/`)) && !readOnlyInputCwd)
     throw new TypeError("macOS writable projection is outside bounded storage");
 }
 async function allocatePrivateMacosGuardianStorage(owner, token, storage) {
@@ -31421,6 +31432,9 @@ function recordKind(value) {
   return value !== null && typeof value === "object" ? value.kind : undefined;
 }
 
+// src/project/author-evaluator.ts
+init_input_capture();
+
 // src/internal/installed-bun-support.ts
 init_macos_process_controls();
 import { constants as constants18 } from "fs";
@@ -31644,6 +31658,28 @@ async function exactDirectory(path2, label) {
   return resolved;
 }
 
+// src/internal/project-evaluator-policy.ts
+var PRIVATE_AUTHOR_EVALUATOR_PROTOCOL = "jig-author-evaluator/1";
+var PRIVATE_AUTHOR_EVALUATOR_MAX_ENTRIES = 256;
+var PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS = 3000;
+var PRIVATE_AUTHOR_EVALUATOR_MACOS_ENTRY_MS = 1e4;
+var PRIVATE_AUTHOR_EVALUATOR_BATCH_FIXED_OVERHEAD_MS = 2000;
+var PRIVATE_AUTHOR_EVALUATOR_BATCH_ENTRY_OVERHEAD_MS = 500;
+function privateAuthorEvaluatorWallClockCeilingMs(entries, entryWallClockCeilingMs = PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS) {
+  return entryWallClockCeilingMs * entries + (entries > 1 ? PRIVATE_AUTHOR_EVALUATOR_BATCH_FIXED_OVERHEAD_MS + PRIVATE_AUTHOR_EVALUATOR_BATCH_ENTRY_OVERHEAD_MS * entries : 0);
+}
+var PRIVATE_AUTHOR_EVALUATOR_DIRECTORY = "/jig-input/evaluator";
+var PRIVATE_AUTHOR_EVALUATOR_WORKER = `${PRIVATE_AUTHOR_EVALUATOR_DIRECTORY}/project-evaluator-worker.js`;
+var PRIVATE_AUTHOR_EVALUATOR_LIMITS = Object.freeze({
+  memoryBytes: 256 * 1024 * 1024,
+  pids: 64,
+  cpuQuotaMicros: 50000,
+  cpuPeriodMicros: 1e5,
+  wallClockCeilingMs: PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS,
+  cancellationGraceMs: 1000,
+  cleanupTimeoutMs: 5000
+});
+
 // src/project/author-module.ts
 import { createHash as createHash11 } from "crypto";
 import { constants as constants19 } from "fs";
@@ -32038,19 +32074,10 @@ function errorText7(error) {
 }
 
 // src/project/author-evaluator.ts
-var PROTOCOL = "jig-author-evaluator/1";
+var PROTOCOL = PRIVATE_AUTHOR_EVALUATOR_PROTOCOL;
 var MAX_STDERR_BYTES = 64 * 1024;
 var MAX_STDOUT_BYTES = JSON_1_LIMITS.bytes + 16 * 1024;
-var EVALUATOR_LIMIT_POLICY = Object.freeze({
-  memoryBytes: 256 * 1024 * 1024,
-  pids: 64,
-  cpuQuotaMicros: 50000,
-  cpuPeriodMicros: 1e5,
-  wallClockCeilingMs: 3000,
-  cancellationGraceMs: 1000,
-  cleanupTimeoutMs: 5000
-});
-var MACOS_EVALUATOR_WALL_CLOCK_CEILING_MS = 1e4;
+var EVALUATOR_LIMIT_POLICY = PRIVATE_AUTHOR_EVALUATOR_LIMITS;
 var EVALUATION_CODES = new Set([
   "PROJECT_AUTHORING_VALUE",
   "PROJECT_DEFAULT_EXPORT",
@@ -32058,19 +32085,38 @@ var EVALUATION_CODES = new Set([
   "PROJECT_EVALUATION_LIMIT",
   "PROJECT_EVALUATOR_COMPILE",
   "PROJECT_EVALUATOR_IMPORT",
-  "PROJECT_EVALUATOR_PROTOCOL"
+  "PROJECT_EVALUATOR_PROTOCOL",
+  "PROJECT_EVALUATOR_DEADLINE"
 ]);
 var decoder6 = new TextDecoder("utf-8", { fatal: true });
 var evaluationSequence = 0;
 async function evaluateAuthorClosure(options, captured, entryProjectPath, expected, signal) {
+  const results = await evaluateAuthorClosureBatch(options, captured, [{ entryProjectPath, expected }], signal);
+  return results[0];
+}
+async function evaluateAuthorClosureBatch(options, captured, requestedEntries, signal) {
+  const entries = Object.freeze(requestedEntries.map(({ entryProjectPath: entryProjectPath2, expected }) => Object.freeze({ entryProjectPath: entryProjectPath2, expected })));
   if (!isCapturedAuthorClosure(captured)) {
     invalid("PROJECT_AUTHOR_CAPTURE", "author closure was not produced by the capture boundary");
   }
-  if (!captured.entries.includes(entryProjectPath)) {
-    invalid("PROJECT_AUTHOR_CAPTURE", "selected entry is outside the author closure", entryProjectPath);
+  if (entries.length === 0 || entries.length > PRIVATE_AUTHOR_EVALUATOR_MAX_ENTRIES) {
+    invalid("PROJECT_AUTHOR_CAPTURE", "evaluator batch has an invalid declaration count");
+  }
+  const selected = new Set;
+  for (const { entryProjectPath: entryProjectPath2 } of entries) {
+    if (!captured.entries.includes(entryProjectPath2) || selected.has(entryProjectPath2)) {
+      invalid("PROJECT_AUTHOR_CAPTURE", "selected entry is absent or repeated", entryProjectPath2);
+    }
+    selected.add(entryProjectPath2);
   }
+  const entryProjectPath = entries[0].entryProjectPath;
+  const entryWallClockCeilingMs = privateExecutionBackendKind(options.backend) === "macos" ? PRIVATE_AUTHOR_EVALUATOR_MACOS_ENTRY_MS : PRIVATE_AUTHOR_EVALUATOR_ENTRY_MS;
+  const limitPolicy = Object.freeze({
+    ...EVALUATOR_LIMIT_POLICY,
+    wallClockCeilingMs: privateAuthorEvaluatorWallClockCeilingMs(entries.length, entryWallClockCeilingMs)
+  });
   const installedSupport = requirePrivateInstalledBunSupport(options.installedSupport);
-  await revalidatePrivateInstalledBunSupport(installedSupport).catch((error) => unavailable("PROJECT_EVALUATOR_SUPPORT", `installed evaluator support is unavailable: ${errorText8(error)}`, entryProjectPath));
+  await privateProfileSpan("author-support-verification", () => revalidatePrivateInstalledBunSupport(installedSupport)).catch((error) => unavailable("PROJECT_EVALUATOR_SUPPORT", `installed evaluator support is unavailable: ${errorText8(error)}`, entryProjectPath));
   const runtimeMounts = installedSupport.runtimeMounts;
   const [workerBytes, sdkBytes, schemaBytes] = await Promise.all([
     readFile3(join15(installedSupport.evaluatorSupportPath, "project-evaluator-worker.js")),
@@ -32078,6 +32124,14 @@ async function evaluateAuthorClosure(options, captured, entryProjectPath, expect
     readFile3(join15(installedSupport.evaluatorSupportPath, "project-authoring-1.schema.json"))
   ]).catch((error) => unavailable("PROJECT_EVALUATOR_SUPPORT", `cannot seal evaluator toolchain: ${errorText8(error)}`, entryProjectPath));
   const authoringProfile = "project-authoring/1";
+  const capturedSupportDigest = privateDomainDigest("JIG-Installed-Evaluator-Support/1", [
+    { name: "project-evaluator-worker.js", digest: digestBytes(workerBytes) },
+    { name: "project-evaluator-sdk.bundle.js", digest: digestBytes(sdkBytes) },
+    { name: "project-authoring-1.schema.json", digest: digestBytes(schemaBytes) }
+  ]);
+  if (capturedSupportDigest !== installedSupport.evaluatorSupportDigest) {
+    unavailable("PROJECT_EVALUATOR_SUPPORT", "evaluator support changed during capture", entryProjectPath);
+  }
   const profileBase = Object.freeze({
     protocol: PROTOCOL,
     authoringProfile,
@@ -32092,7 +32146,12 @@ async function evaluateAuthorClosure(options, captured, entryProjectPath, expect
       kind: installedSupport.kind,
       digest: installedSupport.digest
     }),
-    buildOptions: "bun-cjs-closed-static-closure/1"
+    buildOptions: "bun-cjs-closed-static-closure/1",
+    evaluation: Object.freeze({
+      kind: "finite-isolated-declarations/1",
+      entries: entries.length,
+      entryWallClockCeilingMs
+    })
   });
   const modules = captured.modules.map((module) => ({
     projectPath: module.projectPath,
@@ -32102,177 +32161,213 @@ async function evaluateAuthorClosure(options, captured, entryProjectPath, expect
   const request = canonicalJson({
     protocol: PROTOCOL,
     authoringProfile,
-    entryProjectPath,
+    entries: entries.map(({ entryProjectPath: entryProjectPath2 }) => entryProjectPath2),
     modules
   });
   const runId = `config-${process.pid.toString(36)}-${(++evaluationSequence).toString(36)}`;
-  const policy = evaluatorLimitPolicy(options.backend);
-  const limits = evaluatorLimits(policy);
-  const component = await launchPrivateExecution(options.backend, evaluatorLaunchPlan(installedSupport, runId, limits), signal).catch((error) => {
-    return unavailable("PROJECT_EVALUATOR_LAUNCH", `cannot launch evaluator envelope: ${errorText8(error)}`, entryProjectPath);
-  });
-  const validEnvelope = component.envelope.kind === "linux-rootless-cgroup-v2-bubblewrap/1" ? component.envelope.privateProcessFilesystem && component.envelope.privateRuntimeDevices && sameEvaluatorLimits(component.envelope.limits, limits) && component.envelope.trustedCoordinatorBunDigest === installedSupport.executableDigest : component.envelope.resourceAccounting === "supervised-sampled-with-termination" && component.envelope.resourceOvershoot === true && sameEvaluatorLimits(component.envelope.limits, limits);
-  if (!validEnvelope) {
-    await component.terminate().catch(() => {
-      return;
-    });
-    const completion = await component.completion.catch((error) => unavailable("PROJECT_EVALUATOR_CLEANUP", `evaluator envelope lost while rejecting its predicates: ${errorText8(error)}`, entryProjectPath));
-    if (!completion.fenced || completion.cleanupError !== undefined) {
-      unavailable("PROJECT_EVALUATOR_CLEANUP", "evaluator envelope predicates were absent and cleanup was not proven", entryProjectPath);
-    }
-    unavailable("PROJECT_EVALUATOR_ENVELOPE", "evaluator envelope did not preserve its sealed runtime or root-only predicates", entryProjectPath);
-  }
-  const profile = Object.freeze({
-    ...profileBase,
-    sandbox: component.envelope.kind === "linux-rootless-cgroup-v2-bubblewrap/1" ? Object.freeze({
-      kind: component.envelope.kind,
-      mechanismDigest: component.envelope.mechanismDigest,
-      sealedPlanDigest: component.envelope.sealedPlanDigest,
-      bubblewrapPath: component.envelope.trustedBubblewrapPath,
-      bubblewrapDigest: component.envelope.trustedBubblewrapDigest,
-      coordinatorRuntimePath: component.envelope.trustedCoordinatorBunPath,
-      coordinatorRuntimeDigest: component.envelope.trustedCoordinatorBunDigest,
-      supervisorPath: component.envelope.trustedSupervisorPath,
-      supervisorDigest: component.envelope.trustedSupervisorDigest,
-      payloadUid: component.envelope.payloadUid,
-      payloadGid: component.envelope.payloadGid,
-      limits: policy,
-      privateProcessFilesystem: component.envelope.privateProcessFilesystem,
-      privateRuntimeDevices: component.envelope.privateRuntimeDevices
-    }) : Object.freeze({
-      kind: component.envelope.kind,
-      mechanismDigest: component.envelope.mechanismDigest,
-      sealedPlanDigest: component.envelope.sealedPlanDigest,
-      supervisorPath: installedSupport.supervisorPath,
-      supervisorDigest: installedSupport.supervisorDigest,
-      launcherPath: installedSupport.launcherPath,
-      launcherDigest: installedSupport.launcherDigest,
-      limits: policy,
-      resourceAccounting: component.envelope.resourceAccounting,
-      resourceOvershoot: component.envelope.resourceOvershoot
-    })
-  });
-  const stdout = collectBounded(component.stdout, MAX_STDOUT_BYTES, component.terminate);
-  const stderr = collectBounded(component.stderr, MAX_STDERR_BYTES, component.terminate);
+  const limits = evaluatorLimits(limitPolicy);
+  const inputs = [];
+  let operationFailure;
   try {
-    await component.write(request);
-    await component.closeInput();
-    const [output, diagnostics, exit, evidence, terminationReason] = await Promise.all([
-      stdout,
-      stderr,
-      component.completion,
-      component.evidence,
-      component.terminationReason
-    ]);
-    if (exit.cleanupError !== undefined || !exit.fenced) {
-      unavailable("PROJECT_EVALUATOR_CLEANUP", `evaluator cleanup was not proven: ${exit.cleanupError ?? "not fenced"}`, entryProjectPath);
-    }
-    if ("memoryEvents" in evidence && (evidence.memoryEvents.max ?? 0) > 0 || terminationReason === "memory_limit") {
-      invalid("PROJECT_EVALUATION_LIMIT", "evaluator reached its hard memory limit", entryProjectPath);
-    }
-    if ("pidsEvents" in evidence && (evidence.pidsEvents.max ?? 0) > 0 || terminationReason === "process_limit") {
-      invalid("PROJECT_EVALUATION_LIMIT", "evaluator reached its hard process limit", entryProjectPath);
-    }
-    if (terminationReason === "deadline") {
-      invalid("PROJECT_EVALUATION_LIMIT", "evaluator reached its hard wall deadline", entryProjectPath);
-    }
-    if (terminationReason !== "payload_exit") {
-      unavailable("PROJECT_EVALUATOR_INTERRUPTED", `evaluator ended for an unexpected reason: ${terminationReason}`, entryProjectPath);
-    }
-    if (exit.exitCode !== 0 || exit.signal !== null) {
-      invalid("PROJECT_EVALUATION_FAILED", `evaluator exited ${exit.exitCode ?? exit.signal}${diagnostics.length === 0 ? "" : `: ${safeText2(diagnostics)}`}`, entryProjectPath);
-    }
-    let response;
     try {
-      response = decodeJson1(output);
-    } catch (error) {
-      if (error instanceof Json1Error) {
-        unavailable("PROJECT_EVALUATOR_PROTOCOL", error.message, entryProjectPath);
+      for (const [name, bytes] of [
+        ["project-evaluator-worker.js", workerBytes],
+        ["project-evaluator-sdk.bundle.js", sdkBytes]
+      ]) {
+        inputs.push({
+          input: capturePrivateInput(bytes),
+          destination: `${PRIVATE_AUTHOR_EVALUATOR_DIRECTORY}/${name}`
+        });
       }
-      throw error;
+    } catch {
+      unavailable("PROJECT_EVALUATOR_SUPPORT", "cannot seal evaluator support", entryProjectPath);
     }
-    const value = checkedResponse(response, entryProjectPath);
-    contextualAuthorSchema(schemaBytes, expected, entryProjectPath).validate(value, "PROJECT_AUTHORING_SCHEMA_INVALID");
-    let normalized;
+    const component = await privateProfileSpan("author-envelope-startup", () => launchPrivateExecution(options.backend, evaluatorLaunchPlan(installedSupport, runId, limits, inputs), signal)).catch((error) => {
+      return unavailable("PROJECT_EVALUATOR_LAUNCH", `cannot launch evaluator envelope: ${errorText8(error)}`, entryProjectPath);
+    });
+    const validEnvelope = component.envelope.kind === "linux-rootless-cgroup-v2-bubblewrap/1" ? component.envelope.privateProcessFilesystem && component.envelope.privateRuntimeDevices && sameEvaluatorLimits(component.envelope.limits, limits) && component.envelope.trustedCoordinatorBunDigest === installedSupport.executableDigest : component.envelope.resourceAccounting === "supervised-sampled-with-termination" && component.envelope.resourceOvershoot === true && sameEvaluatorLimits(component.envelope.limits, limits);
+    if (!validEnvelope) {
+      await component.terminate().catch(() => {
+        return;
+      });
+      const completion = await component.completion.catch((error) => unavailable("PROJECT_EVALUATOR_CLEANUP", `evaluator envelope lost while rejecting its predicates: ${errorText8(error)}`, entryProjectPath));
+      if (!completion.fenced || completion.cleanupError !== undefined) {
+        unavailable("PROJECT_EVALUATOR_CLEANUP", "evaluator envelope predicates were absent and cleanup was not proven", entryProjectPath);
+      }
+      unavailable("PROJECT_EVALUATOR_ENVELOPE", "evaluator envelope did not preserve its sealed runtime or root-only predicates", entryProjectPath);
+    }
+    const profile = Object.freeze({
+      ...profileBase,
+      sandbox: component.envelope.kind === "linux-rootless-cgroup-v2-bubblewrap/1" ? Object.freeze({
+        kind: component.envelope.kind,
+        mechanismDigest: component.envelope.mechanismDigest,
+        sealedPlanDigest: component.envelope.sealedPlanDigest,
+        bubblewrapPath: component.envelope.trustedBubblewrapPath,
+        bubblewrapDigest: component.envelope.trustedBubblewrapDigest,
+        coordinatorRuntimePath: component.envelope.trustedCoordinatorBunPath,
+        coordinatorRuntimeDigest: component.envelope.trustedCoordinatorBunDigest,
+        supervisorPath: component.envelope.trustedSupervisorPath,
+        supervisorDigest: component.envelope.trustedSupervisorDigest,
+        payloadUid: component.envelope.payloadUid,
+        payloadGid: component.envelope.payloadGid,
+        limits: limitPolicy,
+        privateProcessFilesystem: component.envelope.privateProcessFilesystem,
+        privateRuntimeDevices: component.envelope.privateRuntimeDevices
+      }) : Object.freeze({
+        kind: component.envelope.kind,
+        mechanismDigest: component.envelope.mechanismDigest,
+        sealedPlanDigest: component.envelope.sealedPlanDigest,
+        supervisorPath: installedSupport.supervisorPath,
+        supervisorDigest: installedSupport.supervisorDigest,
+        launcherPath: installedSupport.launcherPath,
+        launcherDigest: installedSupport.launcherDigest,
+        limits: limitPolicy,
+        resourceAccounting: component.envelope.resourceAccounting,
+        resourceOvershoot: component.envelope.resourceOvershoot
+      })
+    });
+    const stdout = collectBounded(component.stdout, MAX_STDOUT_BYTES, component.terminate);
+    const stderr = collectBounded(component.stderr, MAX_STDERR_BYTES, component.terminate);
     try {
-      normalized = expected === "project" ? normalizeJigDefinition(value) : normalizePackageBindingDefinition(value);
+      await component.write(request);
+      await component.closeInput();
+      const [output, diagnostics, exit, evidence, terminationReason] = await privateProfileSpan("author-execution-settlement", () => Promise.all([
+        stdout,
+        stderr,
+        component.completion,
+        component.evidence,
+        component.terminationReason
+      ]));
+      if (exit.cleanupError !== undefined || !exit.fenced) {
+        unavailable("PROJECT_EVALUATOR_CLEANUP", `evaluator cleanup was not proven: ${exit.cleanupError ?? "not fenced"}`, entryProjectPath);
+      }
+      if ("memoryEvents" in evidence && (evidence.memoryEvents.max ?? 0) > 0 || terminationReason === "memory_limit") {
+        invalid("PROJECT_EVALUATOR_MEMORY_LIMIT", "evaluator reached its hard memory limit", entryProjectPath);
+      }
+      if ("pidsEvents" in evidence && (evidence.pidsEvents.max ?? 0) > 0 || terminationReason === "process_limit") {
+        invalid("PROJECT_EVALUATOR_PROCESS_LIMIT", "evaluator reached its hard process limit", entryProjectPath);
+      }
+      if (terminationReason === "deadline") {
+        invalid("PROJECT_EVALUATOR_DEADLINE", "evaluator reached its hard wall deadline", entryProjectPath);
+      }
+      if (terminationReason !== "payload_exit") {
+        unavailable("PROJECT_EVALUATOR_INTERRUPTED", `evaluator ended for an unexpected reason: ${terminationReason}`, entryProjectPath);
+      }
+      if (exit.exitCode !== 0 || exit.signal !== null) {
+        invalid("PROJECT_EVALUATION_FAILED", `evaluator exited ${exit.exitCode ?? exit.signal}${diagnostics.length === 0 ? "" : `: ${safeText2(diagnostics)}`}`, entryProjectPath);
+      }
+      let response;
+      try {
+        response = decodeJson1(output);
+      } catch (error) {
+        if (error instanceof Json1Error) {
+          unavailable("PROJECT_EVALUATOR_PROTOCOL", error.message, entryProjectPath);
+        }
+        throw error;
+      }
+      const values = checkedResponse(response, entries);
+      return Object.freeze(entries.map(({ entryProjectPath: entryProjectPath2, expected }, index) => {
+        const value = values[index];
+        contextualAuthorSchema(schemaBytes, expected, entryProjectPath2).validate(value, "PROJECT_AUTHORING_SCHEMA_INVALID");
+        let normalized;
+        try {
+          normalized = expected === "project" ? normalizeJigDefinition(value) : normalizePackageBindingDefinition(value);
+        } catch (error) {
+          invalid("PROJECT_DECLARATION_INVALID", errorText8(error), entryProjectPath2);
+        }
+        const outputBytes = canonicalJson(normalized);
+        return Object.freeze({
+          expected,
+          source: Object.freeze({
+            entryProjectPath: entryProjectPath2,
+            bytes: captured.sourceBytes,
+            digest: captured.closureDigest,
+            modules: Object.freeze(captured.modules.map((module) => Object.freeze({
+              projectPath: module.projectPath,
+              bytes: module.sourceBytes,
+              digest: module.sourceDigest,
+              imports: Object.freeze(module.imports.map((edge) => Object.freeze({ ...edge })))
+            })))
+          }),
+          profile,
+          outputDigest: digestBytes(outputBytes),
+          value: normalized,
+          enforcement: Object.freeze({
+            owner: "cgroup" in component ? Object.freeze({ kind: "linux-cgroup", ...component.cgroup }) : Object.freeze({ kind: "macos-process", ...component.process }),
+            terminal: Object.freeze({
+              reason: terminationReason,
+              exitCode: exit.exitCode,
+              signal: exit.signal,
+              fenced: exit.fenced
+            }),
+            evidence: "cpuStat" in evidence ? Object.freeze({
+              ...prefixNumbers("cpu", evidence.cpuStat),
+              ...prefixNumbers("memory", evidence.memoryEvents),
+              ...prefixNumbers("pids", evidence.pidsEvents)
+            }) : Object.freeze({ ...evidence })
+          })
+        });
+      }));
     } catch (error) {
-      invalid("PROJECT_DECLARATION_INVALID", errorText8(error), entryProjectPath);
+      await component.terminate().catch(() => {
+        return;
+      });
+      const settled = await Promise.allSettled([
+        stdout,
+        stderr,
+        component.completion,
+        component.evidence
+      ]);
+      const cleanup = settled[2];
+      if (cleanup.status === "rejected") {
+        throw new AggregateError([error, cleanup.reason], "evaluator failed and cleanup was not confirmed");
+      }
+      if (!cleanup.value.fenced || cleanup.value.cleanupError !== undefined) {
+        throw new AggregateError([error, cleanup.value], "evaluator failed without a clean fence");
+      }
+      throw error;
     }
-    const outputBytes = canonicalJson(normalized);
-    return Object.freeze({
-      expected,
-      source: Object.freeze({
-        entryProjectPath,
-        bytes: captured.sourceBytes,
-        digest: captured.closureDigest,
-        modules: Object.freeze(captured.modules.map((module) => Object.freeze({
-          projectPath: module.projectPath,
-          bytes: module.sourceBytes,
-          digest: module.sourceDigest,
-          imports: Object.freeze(module.imports.map((edge) => Object.freeze({ ...edge })))
-        })))
-      }),
-      profile,
-      outputDigest: digestBytes(outputBytes),
-      value: normalized,
-      enforcement: Object.freeze({
-        owner: "cgroup" in component ? Object.freeze({ kind: "linux-cgroup", ...component.cgroup }) : Object.freeze({ kind: "macos-process", ...component.process }),
-        terminal: Object.freeze({
-          reason: terminationReason,
-          exitCode: exit.exitCode,
-          signal: exit.signal,
-          fenced: exit.fenced
-        }),
-        evidence: "cpuStat" in evidence ? Object.freeze({
-          ...prefixNumbers("cpu", evidence.cpuStat),
-          ...prefixNumbers("memory", evidence.memoryEvents),
-          ...prefixNumbers("pids", evidence.pidsEvents)
-        }) : Object.freeze({ ...evidence })
-      })
-    });
   } catch (error) {
-    await component.terminate().catch(() => {
-      return;
-    });
-    const settled = await Promise.allSettled([
-      stdout,
-      stderr,
-      component.completion,
-      component.evidence
-    ]);
-    const cleanup = settled[2];
-    if (cleanup.status === "rejected") {
-      throw new AggregateError([error, cleanup.reason], "evaluator failed and cleanup was not confirmed");
+    operationFailure = error;
+    throw error;
+  } finally {
+    const failures = [];
+    for (const { input } of inputs) {
+      try {
+        input.close();
+      } catch (error) {
+        failures.push(error);
+      }
     }
-    if (!cleanup.value.fenced || cleanup.value.cleanupError !== undefined) {
-      throw new AggregateError([error, cleanup.value], "evaluator failed without a clean fence");
+    if (failures.length > 0) {
+      throw new AggregateError(operationFailure === undefined ? failures : [operationFailure, ...failures], "evaluator input cleanup failed");
     }
-    throw error;
   }
 }
-function checkedResponse(response, projectPath) {
+function checkedResponse(response, entries) {
+  const projectPath = entries[0].entryProjectPath;
   if (!isRecord(response) || response.protocol !== PROTOCOL || response.status !== "ok" && response.status !== "error") {
     unavailable("PROJECT_EVALUATOR_PROTOCOL", "evaluator returned an invalid envelope", projectPath);
   }
   if (response.status === "error") {
-    if (!exactKeys(response, ["code", "message", "protocol", "status"]) || typeof response.code !== "string" || typeof response.message !== "string") {
+    if (!exactKeys(response, ["code", "entryIndex", "message", "protocol", "status"]) || typeof response.code !== "string" || typeof response.message !== "string" || !(response.entryIndex === null || typeof response.entryIndex === "number" && Number.isInteger(response.entryIndex) && response.entryIndex >= 0 && response.entryIndex < entries.length)) {
       unavailable("PROJECT_EVALUATOR_PROTOCOL", "evaluator error has an invalid shape", projectPath);
     }
     if (!EVALUATION_CODES.has(response.code)) {
       unavailable("PROJECT_EVALUATOR_PROTOCOL", "evaluator returned an unknown error code", projectPath);
     }
     const code2 = response.code;
+    const location = response.entryIndex === null ? projectPath : entries[response.entryIndex].entryProjectPath;
     if (code2 === "PROJECT_EVALUATOR_PROTOCOL") {
-      unavailable(code2, response.message, projectPath);
+      unavailable(code2, response.message, location);
     }
     const message2 = response.message;
-    invalid(code2, message2, projectPath);
+    invalid(code2, message2, location);
   }
-  if (!exactKeys(response, ["protocol", "status", "value"])) {
+  if (!exactKeys(response, ["protocol", "status", "values"]) || !Array.isArray(response.values) || response.values.length !== entries.length) {
     unavailable("PROJECT_EVALUATOR_PROTOCOL", "evaluator success has an invalid shape", projectPath);
   }
-  return response.value;
+  return response.values;
 }
 function contextualAuthorSchema(bytes, expected, projectPath) {
   let document;
@@ -32287,41 +32382,36 @@ function contextualAuthorSchema(bytes, expected, projectPath) {
   const definition = expected === "project" ? "project" : "bindingDefinition";
   try {
     return compileEmbeddedSchema(Object.freeze({ $ref: `#/$defs/${definition}` }), {
-      path: "project-authoring-1.schema.json",
+      path: projectPath,
       rootDefs: document.$defs
     });
   } catch (error) {
     unavailable("PROJECT_EVALUATOR_SUPPORT", `captured authoring schema cannot compile: ${errorText8(error)}`, projectPath);
   }
 }
-function evaluatorLaunchPlan(support, runId, limits) {
+function evaluatorLaunchPlan(support, runId, limits, inputs) {
   return {
     runId,
     limits,
-    projections: [
-      ...privateExecutionFileProjections(support.runtimeMounts),
-      { source: support.evaluatorSupportPath, destination: "/jig-evaluator", kind: "tree" }
-    ],
+    projections: [...privateExecutionFileProjections(support.runtimeMounts)],
     command: [
       privateExecutionPath(support.sandboxExecutablePath),
-      privateExecutionPath("/jig-evaluator/project-evaluator-worker.js")
+      privateExecutionPath(PRIVATE_AUTHOR_EVALUATOR_WORKER)
     ],
-    readOnlyCwd: "/jig-evaluator",
-    relocatedEnvironment: { JIG_EVALUATOR_SDK: "/jig-evaluator/project-evaluator-sdk.bundle.js" },
+    capturedInputs: inputs,
+    inputDirectories: [PRIVATE_AUTHOR_EVALUATOR_DIRECTORY],
+    readOnlyCwd: PRIVATE_AUTHOR_EVALUATOR_DIRECTORY,
+    relocatedEnvironment: {
+      JIG_EVALUATOR_SDK: `${PRIVATE_AUTHOR_EVALUATOR_DIRECTORY}/project-evaluator-sdk.bundle.js`
+    },
     maxOutputBytes: MAX_STDOUT_BYTES + MAX_STDERR_BYTES,
-    storageBytes: 0
+    storageBytes: 16 * 1024 * 1024
   };
 }
 function exactKeys(value, expected) {
   const keys = Object.keys(value).sort();
   return keys.length === expected.length && keys.every((key, index) => key === expected[index]);
 }
-function evaluatorLimitPolicy(backend) {
-  return privateExecutionBackendKind(backend) === "macos" ? Object.freeze({
-    ...EVALUATOR_LIMIT_POLICY,
-    wallClockCeilingMs: MACOS_EVALUATOR_WALL_CLOCK_CEILING_MS
-  }) : EVALUATOR_LIMIT_POLICY;
-}
 function evaluatorLimits(policy) {
   return Object.freeze({
     memoryBytes: policy.memoryBytes,
@@ -32901,14 +32991,21 @@ async function retainOpenedPackageProject(options, signal) {
     ]);
     closure = capturedClosure;
     assertBootstrapPreserved(bootstrapClosure, capturedClosure);
-    const project = await privateProfileSpan("author-configuration-evaluation", () => evaluateAuthorClosure(options.evaluator, capturedClosure, entry, "project", signal));
+    const evaluations = await privateProfileSpan("author-configuration-evaluation", () => evaluateAuthorClosureBatch(options.evaluator, capturedClosure, [
+      { entryProjectPath: entry, expected: "project" },
+      ...bindingSource.members.map(({ projectPath }) => ({
+        entryProjectPath: projectPath,
+        expected: "binding"
+      }))
+    ], signal));
+    const project = evaluations[0];
     if (project.outputDigest !== bootstrapProject.outputDigest) {
       invalid("PROJECT_SOURCE_CHANGED", "project definition changed while its complete declaration closure was captured", entry);
     }
     const grantSource = await captureGrantSource(root, project.value.grants);
     const bindings = [];
-    for (const member2 of bindingSource.members) {
-      const evaluation = await privateProfileSpan("author-configuration-evaluation", () => evaluateAuthorClosure(options.evaluator, capturedClosure, member2.projectPath, "binding", signal));
+    for (const [index, member2] of bindingSource.members.entries()) {
+      const evaluation = evaluations[index + 1];
       let attachments;
       try {
         if (evaluation.value.attachments !== undefined)
@@ -33585,22 +33682,28 @@ function assertPrivateBunExecutionLayoutFiles(layout, files) {
   assertPrivatePackageAliasFiles(layout.aliases, files);
 }
 function normalizePrivateBunExecutionArtifact(value) {
-  const record3 = exact5(value, ["package", "layout"], ["preparationInputDigest"]);
-  if (Object.hasOwn(record3, "preparationInputDigest") && (typeof record3.preparationInputDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(record3.preparationInputDigest)))
-    invalid3();
+  const record3 = exact5(value, ["package", "layout"], ["preparation"]);
+  let preparation;
+  if (Object.hasOwn(record3, "preparation")) {
+    const evidence = exact5(record3.preparation, ["inputDigest", "package"]);
+    if (typeof evidence.inputDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(evidence.inputDigest))
+      invalid3();
+    preparation = Object.freeze({
+      inputDigest: evidence.inputDigest,
+      package: normalizePackageArtifactRef(exact5(evidence.package, ["kind", "digest"]))
+    });
+  }
   return Object.freeze({
     package: normalizePackageArtifactRef(exact5(record3.package, ["kind", "digest"])),
     layout: normalizePrivateBunExecutionLayout(record3.layout),
-    ...record3.preparationInputDigest === undefined ? {} : {
-      preparationInputDigest: record3.preparationInputDigest
-    }
+    ...preparation === undefined ? {} : { preparation }
   });
 }
-function privateBunExecutionArtifact(artifact, layout = EMPTY_PRIVATE_BUN_EXECUTION_LAYOUT, preparationInputDigest) {
+function privateBunExecutionArtifact(artifact, layout = EMPTY_PRIVATE_BUN_EXECUTION_LAYOUT, preparation) {
   return normalizePrivateBunExecutionArtifact({
     package: artifact,
     layout,
-    ...preparationInputDigest === undefined ? {} : { preparationInputDigest }
+    ...preparation === undefined ? {} : { preparation }
   });
 }
 function privateBunExecutionMaterialization(execution) {
@@ -37890,12 +37993,10 @@ async function capturePrivateActivationPlanningBase(input) {
 function readPrivateAdmittedExecutionReuse(input) {
   const base = requirePrivateActivationPlanningBase(input.planningBase);
   const request = requirePrivateActivationRequest(input.request);
-  const target = base.admittedCandidate?.candidate.targets.find((candidate) => candidate.request.digest === request.digest);
+  const target = base.admittedCandidate?.candidate.targets.find((candidate) => privateActivationTargetKey(candidate.request.target) === privateActivationTargetKey(request.target) && candidate.request.packagePath === request.packagePath);
   if (target?.disposition.state !== "ready")
     return;
   return Object.freeze({
-    recipeDigest: target.disposition.recipeDigest,
-    observationDigest: target.disposition.observationDigest,
     execution: target.disposition.execution
   });
 }
@@ -40880,7 +40981,10 @@ async function reacquireCandidateArtifacts(packageStoreRoot, candidate) {
       candidate.candidate.declarationArtifact.package.digest,
       ...Object.values(candidate.lock.packages).map((entry) => entry.digest),
       ...Object.values(candidate.lock.bindings).flatMap((entry) => Object.values(entry.attachments ?? {}).map((item2) => item2.digest)),
-      ...candidate.candidate.targets.flatMap((target) => target.disposition.state === "ready" ? [target.disposition.execution.package.digest] : [])
+      ...candidate.candidate.targets.flatMap((target) => target.disposition.state === "ready" ? [
+        target.disposition.execution.package.digest,
+        ...target.disposition.execution.preparation === undefined ? [] : [target.disposition.execution.preparation.package.digest]
+      ] : [])
     ]);
     for (const digest6 of [...digests].sort()) {
       const reference = normalizePackageArtifactRef({ kind: "flow-package/0", digest: digest6 });
@@ -41363,6 +41467,9 @@ class PrivateRunDiagnostics {
 
 // src/project/evaluator-diagnostics.ts
 var EVALUATOR_HINTS = Object.freeze({
+  PROJECT_EVALUATOR_MEMORY_LIMIT: "The configuration evaluator reached its enforced memory limit. Keep declarations small and inert; preserve this diagnostic if a small declaration fails. No Flow was started.",
+  PROJECT_EVALUATOR_PROCESS_LIMIT: "The configuration evaluator reached its enforced process limit. Preserve this diagnostic and report it with the indicated declaration; changing a Flow deadline will not fix review. No Flow was started.",
+  PROJECT_EVALUATOR_DEADLINE: "The configuration evaluator reached its enforced wall-clock deadline. This does not establish whether authored work or runtime startup consumed the budget. Preserve this diagnostic if a small, inert declaration fails. No Flow was started.",
   PROJECT_EVALUATOR_SUPPORT: "Jig could not verify its configuration evaluator files. Restore the complete Jig installation and retry review. No Flow was started.",
   PROJECT_EVALUATOR_LAUNCH: "Jig could not start the contained configuration evaluator. Check supported host prerequisites and host load before retrying review; the underlying cause is not established. No Flow was started.",
   PROJECT_EVALUATOR_ENVELOPE: "The configuration evaluator did not establish its required isolation. Check the supported host prerequisites; do not bypass containment. No Flow was started.",
@@ -42819,7 +42926,7 @@ function renderFailure(error, runtime) {
       PROJECT_MEMBER_MISSING: "a selected project member is missing; restore it or update the membership in jig.ts",
       PROJECT_MEMBER_COLLISION: "project members have colliding paths or names; give each selected member a distinct identity",
       PROJECT_EVALUATION_FAILED: "the project definition could not be evaluated; check the indicated module for unknown fields, invalid values, syntax or import errors. defineJig accepts only flows, bindings, grants, defaultProviders and entrypoint",
-      PROJECT_EVALUATION_LIMIT: "project evaluation exceeded its resource or time limit; keep authoring modules small and inert. If they already are, check host load before retrying review. No Flow was started",
+      PROJECT_EVALUATION_LIMIT: "project evaluation exceeded a capture or execution limit; keep authoring modules small and inert. The specific limiting resource was not retained. Preserve this diagnostic if a small declaration fails. No Flow was started",
       PROJECT_DECLARATION_INVALID: "export a valid defineJig or defineBinding declaration from the indicated module",
       CHANNEL_FIELD: "check channel declarations and descriptors against FLOW Channel Contract/0",
       CHANNEL_LIMIT: "check channel declaration counts and descriptor bounds",
@@ -42947,7 +43054,7 @@ Inspect any effects before starting new work. See https://jig.md/guide/results.`
     UNAVAILABLE: "Required execution support was unavailable.",
     PERMISSION_DENIED: "The requested action was outside the approved permissions.",
     RESOURCE_EXHAUSTED: "Execution reached a resource limit.",
-    INVALID_RESULT: "The Flow returned a result that does not match its declared contract.",
+    INVALID_RESULT: "A Flow or one of its operations rejected a returned result.",
     UNCERTAIN: "The operation may have produced effects; do not blindly repeat the Run.",
     EXECUTION_FAILED: "The Flow could not complete execution.",
     CHANNEL_LOST: "A required connection was lost.",
@@ -45446,6 +45553,120 @@ function limit(code2, message2, path2) {
   return new CheckError("invalid", code2, message2, path2);
 }
 
+// src/internal/bun-preparation-evidence.ts
+import { createHash as createHash14 } from "crypto";
+
+// src/internal/bun-native-inputs.ts
+async function privateBunNativeInputs(input) {
+  const manifests = [
+    "package.json",
+    ...input.members?.map((path2) => `${path2}/package.json`) ?? []
+  ];
+  const paths2 = new Set(manifests);
+  if (input.paths.includes("bun.lock"))
+    paths2.add("bun.lock");
+  let patches = {};
+  for (const path2 of manifests) {
+    const bytes = await input.read(path2);
+    if (bytes.byteLength > 1024 * 1024)
+      throw new TypeError("oversized native manifest");
+    const manifest = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    requirePrivateBunResolutionManifest(manifest, input.members === undefined ? undefined : path2 === "package.json" ? "root" : "member");
+    if (path2 === "package.json")
+      patches = requirePrivateBunPatches(manifest.patchedDependencies);
+  }
+  for (const path2 of Object.values(patches)) {
+    if ((await input.read(path2)).byteLength > 1024 * 1024)
+      throw new TypeError("oversized captured patch");
+    paths2.add(path2);
+  }
+  return Object.freeze({ paths: paths2, patches });
+}
+
+// src/internal/bun-preparation-evidence.ts
+async function privateBunPreparationInputs(input) {
+  const { captured, workspace } = input;
+  if (captured.files.length > PRIVATE_BUN_PREPARATION_LIMITS.sourceFiles || captured.files.reduce((sum, file) => sum + file.size, 0) > PRIVATE_BUN_PREPARATION_LIMITS.sourceBytes)
+    throw failure("PACKAGE_BUN_INPUT_LIMIT", "Bun preparation source exceeds its bounded input limits");
+  let paths2;
+  try {
+    paths2 = (await privateBunNativeInputs({
+      paths: captured.files.map(({ path: path2 }) => path2),
+      ...workspace === undefined ? {} : { members: workspace.members },
+      read: (path2) => captured.read(path2, 1024 * 1024)
+    })).paths;
+  } catch {
+    throw failure("PACKAGE_BUN_SOURCE_UNSUPPORTED", "native manifests or declared patch inputs are unsupported or incomplete");
+  }
+  const nativeFiles = [];
+  for (const path2 of [...paths2].sort(comparePathBytes)) {
+    const hash = createHash14("sha256");
+    for await (const bytes of captured.stream(path2))
+      hash.update(bytes);
+    nativeFiles.push({ path: path2, digest: `sha256:${hash.digest("hex")}` });
+  }
+  const sourcePaths = new Set(captured.files.filter(({ path: path2 }) => workspace === undefined || paths2.has(path2) || workspace.selected.some((member2) => path2.startsWith(`${member2}/`))).map(({ path: path2 }) => path2));
+  if (workspace !== undefined) {
+    for (const member2 of workspace.members)
+      if (!workspace.selected.includes(member2))
+        sourcePaths.delete(`${member2}/package.json`);
+  }
+  return Object.freeze({
+    digest: privateDomainDigest("JIG-Bun-Preparation-Inputs/1", {
+      supportDigest: input.supportDigest,
+      workspace: workspace === undefined ? null : {
+        target: workspace.target,
+        members: [...workspace.members],
+        selected: [...workspace.selected]
+      },
+      nativeFiles
+    }),
+    sourcePaths
+  });
+}
+async function capturePrivateBunDependencies(prepared, sourcePaths) {
+  const files = prepared.files.filter(({ path: path2 }) => !sourcePaths.has(path2));
+  requireDependencyFiles(files);
+  return captureView("retained Bun dependencies", files, () => prepared);
+}
+async function assemblePrivateBunExecution(input) {
+  requireDependencyFiles(input.dependencies.files);
+  const source = input.source.files.filter(({ path: path2 }) => input.sourcePaths.has(path2));
+  const sourcePaths = new Set(source.map(({ path: path2 }) => path2));
+  const files = [...source, ...input.dependencies.files].sort((a, b) => comparePathBytes(a.path, b.path));
+  try {
+    assertNoPathCollisions(files.map(({ path: path2 }) => path2));
+    const regularPaths = new Set(files.map(({ path: path2 }) => path2));
+    for (const file of files) {
+      const parts = file.path.split("/");
+      for (let length = 1;length < parts.length; length++)
+        if (regularPaths.has(parts.slice(0, length).join("/")))
+          throw new TypeError("file parent collision");
+    }
+    assertPrivateBunExecutionLayoutFiles(input.layout, files);
+  } catch {
+    throw failure("PACKAGE_BUN_SOURCE_UNSUPPORTED", "fresh source conflicts with the retained dependency layout");
+  }
+  if (files.length + input.layout.aliases.length > PRIVATE_BUN_PREPARATION_LIMITS.preparedFiles || files.reduce((sum, file) => sum + file.size, Buffer.byteLength(JSON.stringify(input.layout))) > PRIVATE_BUN_PREPARATION_LIMITS.preparedBytes)
+    throw failure("PACKAGE_BUN_OUTPUT_LIMIT", "assembled Bun execution exceeds its bounded output limits");
+  return captureView("fresh Bun execution image", files, (path2) => sourcePaths.has(path2) ? input.source : input.dependencies);
+}
+function requireDependencyFiles(files) {
+  if (files.some(({ path: path2 }) => path2 !== "bun.lock" && !path2.split("/").includes("node_modules")))
+    throw failure("PACKAGE_BUN_PROTOCOL", "retained Bun dependency evidence contains authored source");
+}
+async function captureView(label, files, owner) {
+  const frozenFiles = Object.freeze([...files]);
+  const backing2 = {
+    stream: (path2) => owner(path2).stream(path2),
+    async dispose() {}
+  };
+  return createCapturedPackage(label, frozenFiles, await packageDigest(frozenFiles, (file) => backing2.stream(file.path)), backing2);
+}
+function failure(code2, message2) {
+  return new CheckError("invalid", code2, message2);
+}
+
 // src/internal/bun-workspace-capture.ts
 import { constants as constants29 } from "fs";
 import { dirname as dirname17, relative as relative3, resolve as resolve13 } from "path";
@@ -45848,7 +46069,7 @@ function fail(code2, message2) {
 }
 
 // src/internal/contract-generation.ts
-import { createHash as createHash14, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash15, randomUUID as randomUUID4 } from "crypto";
 import { constants as constants30 } from "fs";
 
 // ../agent-method/dist/errors.js
@@ -46222,7 +46443,7 @@ async function generateContract(source, signal, workerPath) {
 var SOURCE = "FLOW.contract.tsp";
 var DESCRIPTOR = "FLOW.contract.json";
 var MAX_RECORD = 4 * 1024 * 1024;
-var hash = (s) => createHash14("sha256").update(s).digest("hex");
+var hash = (s) => createHash15("sha256").update(s).digest("hex");
 var conflict = (name) => invalid("AUTHORING_CONFLICT", "Generated files or source changed. Preserve edits and resolve ownership before generation.", name);
 function inputNames(inputs) {
   if (!inputs || typeof inputs !== "object" || Array.isArray(inputs) || Object.keys(inputs).length > 256)
@@ -46798,9 +47019,9 @@ function executionChangeExplanation(before, after) {
       reasons.push("The execution request changed; see the package, settings and permission changes in this review.");
     if (!samePolicy(before.disposition.execution?.package, after.disposition.execution?.package) || !samePolicy(before.disposition.execution?.layout, after.disposition.execution?.layout))
       reasons.push("Prepared execution files or dependency layout changed.");
-    else if (before.disposition.execution?.preparationInputDigest !== after.disposition.execution?.preparationInputDigest)
-      reasons.push(before.disposition.execution?.preparationInputDigest === undefined ? `This review records captured workspace inputs for future preparation reuse.
-  Prepared files and dependency layout are unchanged.` : `Workspace preparation inputs changed.
+    else if (!samePolicy(before.disposition.execution?.preparation, after.disposition.execution?.preparation))
+      reasons.push(before.disposition.execution?.preparation === undefined ? `This review records dependency inputs and installed bytes for future preparation reuse.
+  Prepared files and dependency layout are unchanged.` : `Dependency preparation evidence changed.
   Prepared files and dependency layout are unchanged.`);
     if (reasons.length === 0) {
       reasons.push("Execution environment changed: Jig installation, Agent configuration, or sandbox support.");
@@ -47467,7 +47688,7 @@ import { lstat as lstat24, mkdir as mkdir11, realpath as realpath24 } from "fs/p
 import { join as join30 } from "path";
 
 // src/run/session.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 var ROOT_ID = "host:1";
 var MAX_PENDING_COMPONENT_REQUESTS = 64;
 var MAX_COMPONENT_REQUEST_IDS = 65536;
@@ -47902,16 +48123,16 @@ class RunHostSession {
       this.failProtocol("component returned its root error before owned requests settled");
       return;
     }
-    let failure;
+    let failure2;
     try {
-      failure = parseRootFailure(response.error);
+      failure2 = parseRootFailure(response.error);
     } catch (error) {
       this.failProtocol(`invalid root error: ${errorText10(error)}`);
       return;
     }
     this.rootOpen = false;
     this.dispatcher?.channels?.finalize(false);
-    this.rootResponse = failure;
+    this.rootResponse = failure2;
     this.closeProtocolInput();
   }
   queueResponse(id, value) {
@@ -48125,7 +48346,7 @@ class RunHostSession {
   }
   finish(exit) {
     const diagnostics = this.diagnostics();
-    const failure = (code2, message2, details) => ({
+    const failure2 = (code2, message2, details) => ({
       status: "failed",
       code: code2,
       message: message2,
@@ -48133,40 +48354,43 @@ class RunHostSession {
       diagnostics
     });
     if (this.protocolFailure !== undefined) {
-      return failure("PROTOCOL_ERROR", this.protocolFailure);
+      return failure2("PROTOCOL_ERROR", this.protocolFailure);
+    }
+    if (exit?.stopReason === "core_dump" && exit.fenced && exit.cleanupError === undefined && this.localTerminal === undefined) {
+      return failure2("EXECUTION_FAILED", "owned execution crashed and was fenced during core dumping");
     }
     if (this.channelFailure !== undefined) {
       if (this.rootResponse === undefined && exit?.stopReason === "deadline") {
-        return failure("DEADLINE_EXCEEDED", "root Run hard deadline elapsed before a terminal response");
+        return failure2("DEADLINE_EXCEEDED", "root Run hard deadline elapsed before a terminal response");
       }
-      return failure("CHANNEL_LOST", this.channelFailure);
+      return failure2("CHANNEL_LOST", this.channelFailure);
     }
     if (exit === undefined) {
-      return failure("CHANNEL_LOST", "component completion was unavailable");
+      return failure2("CHANNEL_LOST", "component completion was unavailable");
     }
     if (exit?.cleanupError !== undefined || exit?.fenced !== true) {
-      return failure("EXECUTION_FAILED", "component cleanup or fencing failed");
+      return failure2("EXECUTION_FAILED", "component cleanup or fencing failed");
     }
     if (this.localTerminal !== undefined) {
-      return failure(this.localTerminal.code, this.localTerminal.message);
+      return failure2(this.localTerminal.code, this.localTerminal.message);
     }
     if (this.postResponseTermination) {
-      return failure("EXECUTION_FAILED", "component did not quiesce after its terminal response");
+      return failure2("EXECUTION_FAILED", "component did not quiesce after its terminal response");
     }
     if (exit.exitCode !== 0 || exit.signal !== null) {
-      return failure("EXECUTION_FAILED", `component exited with code ${String(exit.exitCode)} and signal ${String(exit.signal)}`);
+      return failure2("EXECUTION_FAILED", `component exited with code ${String(exit.exitCode)} and signal ${String(exit.signal)}`);
     }
     if (this.rootResponse === undefined) {
       if (exit.stopReason === "deadline") {
-        return failure("DEADLINE_EXCEEDED", "root Run hard deadline elapsed before a terminal response");
+        return failure2("DEADLINE_EXCEEDED", "root Run hard deadline elapsed before a terminal response");
       }
-      return failure("CHANNEL_LOST", "component exited before a root response");
+      return failure2("CHANNEL_LOST", "component exited before a root response");
     }
     if (this.pendingResponses !== 0 || this.operationWaiters.size !== 0 || this.channelRequests.size !== 0) {
-      return failure("EXECUTION_FAILED", "component exited with pending owned protocol work");
+      return failure2("EXECUTION_FAILED", "component exited with pending owned protocol work");
     }
     if (this.rootResponse.kind === "failure") {
-      return failure(this.rootResponse.code, this.rootResponse.message, this.rootResponse.details);
+      return failure2(this.rootResponse.code, this.rootResponse.message, this.rootResponse.details);
     }
     return { status: "succeeded", result: this.rootResponse.result, diagnostics };
   }
@@ -48390,7 +48614,7 @@ function operationSignature(params) {
     if (key !== "operationId")
       semantic[key] = value;
   }
-  return createHash15("sha256").update(Buffer.from("FLOW-Call/0\x00", "ascii")).update(canonicalJson(semantic)).digest("hex");
+  return createHash16("sha256").update(Buffer.from("FLOW-Call/0\x00", "ascii")).update(canonicalJson(semantic)).digest("hex");
 }
 function errorMessage(id, code2, message2) {
   return { jsonrpc: "2.0", id, error: { code: code2, message: message2 } };
@@ -48569,7 +48793,7 @@ async function materializePrivatePackageLease(captured, value) {
   let packageDirectory;
   let transactionInformation;
   let created = false;
-  let failure;
+  let failure2;
   try {
     await mkdirPrivateFile(privateChildLocation(parent.handle, allocation.name));
     created = true;
@@ -48629,9 +48853,9 @@ async function materializePrivatePackageLease(captured, value) {
     await requireChildIdentity(transaction, PACKAGE_NAME, packageInformation);
     return leaseFromObserved(allocation, transactionInformation, packageInformation);
   } catch (error) {
-    failure = error;
+    failure2 = error;
   } finally {
-    if (failure !== undefined && created) {
+    if (failure2 !== undefined && created) {
       try {
         if (transaction === undefined) {
           const opened = await openOwnedDirectory(parent.handle, allocation.name, parent.information, [0o700n, 0o711n]);
@@ -48644,7 +48868,7 @@ async function materializePrivatePackageLease(captured, value) {
         await removeTransaction(parent, transaction, allocation.name, transactionInformation, allocation.aliases);
         transaction = undefined;
       } catch (cleanupError) {
-        failure = new AggregateError([failure, cleanupError], "durable materialization and exact cleanup did not both complete");
+        failure2 = new AggregateError([failure2, cleanupError], "durable materialization and exact cleanup did not both complete");
       }
     }
     await packageDirectory?.close().catch(() => {
@@ -48657,7 +48881,7 @@ async function materializePrivatePackageLease(captured, value) {
       return;
     });
   }
-  throw failure;
+  throw failure2;
 }
 async function recoverPrivatePackageMaterializationAllocation(protectedParent, value) {
   const allocation = parseAllocation(value);
@@ -51530,6 +51754,7 @@ async function executeOwnedProvider(input, provider, recipe, operation) {
     throw error;
   }
   let attemptedDispatch = false;
+  let phase = "verifying the admitted runtime";
   let execution;
   let output;
   let retained;
@@ -51540,9 +51765,10 @@ async function executeOwnedProvider(input, provider, recipe, operation) {
   const scopeDigest = nativeSessionScope(input, provider);
   let failurePhase = "preparation";
   try {
-    await revalidateProviderSupport(recipe, provider, input);
+    await privateProfileSpan("finite-acp-revalidation", () => revalidateProviderSupport(recipe, provider, input));
     let restored;
     if (operation.session !== undefined && "restore" in operation.session) {
+      phase = "restoring the authorized session";
       const snapshot2 = await claimPrivateNativeSession({
         coordinator: input.coordinator,
         projectRoot: input.projectRoot,
@@ -51565,8 +51791,9 @@ async function executeOwnedProvider(input, provider, recipe, operation) {
     if (operation.session !== undefined)
       credentialBootstrap = runtime.startupInput?.();
     const secrets2 = operation.session === undefined ? [] : privateCodexSessionSecrets(runtime, credentialBootstrap);
+    phase = "preparing containment";
     failurePhase = "sealing";
-    const sealed = await sealPrivateExecutionOwner(input.backend, agentExecutionIntent(recipe, provider, effectiveDeadlineUnixMs, identity3, operation.session !== undefined), ownerAllocation);
+    const sealed = await privateProfileSpan("finite-acp-containment", () => sealPrivateExecutionOwner(input.backend, agentExecutionIntent(recipe, provider, effectiveDeadlineUnixMs, identity3, operation.session !== undefined), ownerAllocation));
     const sandbox = Object.freeze({ kind: SANDBOX_KIND, owner: sealed.identity });
     lifecycle = await recordPrivateRootChildSandbox({
       coordinator: input.coordinator,
@@ -51578,19 +51805,22 @@ async function executeOwnedProvider(input, provider, recipe, operation) {
       sandbox
     });
     attemptedDispatch = true;
+    phase = "starting the native client";
     failurePhase = "admission";
-    const component = await admitPrivateExecutionOwner(sealed, input.signal);
+    const component = await privateProfileSpan("finite-acp-launch", () => admitPrivateExecutionOwner(sealed, input.signal));
     output = component.output;
+    phase = "exchanging native messages";
     failurePhase = "protocol";
-    execution = await runPrivateFiniteAcpResource(component, runtime, endpoints, input.signal, operation.maxTurns, ...operation.session === undefined ? [] : [
+    execution = await privateProfileSpan("finite-acp-exchange", () => runPrivateFiniteAcpResource(component, runtime, endpoints, input.signal, operation.maxTurns, ...operation.session === undefined ? [] : [
       {
         bootstrap: privateCodexSessionBootstrap(restored),
         ...restored === undefined ? {} : { restoreSessionId: restored.nativeId },
         ...credentialBootstrap === undefined ? {} : { credentialBootstrap }
       }
-    ]);
+    ]));
     failurePhase = "settlement";
     if (operation.session !== undefined && !execution.closed && execution.fence.stopReason === "payload_exit" && execution.fence.exitCode === 0 && execution.fence.signal === null && !input.signal.aborted) {
+      phase = "collecting authorized session state";
       if (output === undefined || execution.sessionId === undefined)
         throw new Error("Clean native retention lacks owned output or session identity");
       try {
@@ -51604,13 +51834,14 @@ async function executeOwnedProvider(input, provider, recipe, operation) {
           throw error;
       }
     }
-    await releaseKnownAcp(input, lifecycle, execution.fence);
+    phase = "fencing and cleanup";
+    await privateProfileSpan("finite-acp-release", () => releaseKnownAcp(input, lifecycle, execution.fence));
   } catch (error) {
     reportFailure(input, failurePhase, error);
     try {
       const active = await findLifecycle(input, input.call.operationId);
       if (active !== undefined)
-        await recoverPrivateRootFiniteAcpOwner(input, active);
+        await privateProfileSpan("finite-acp-recovery", () => recoverPrivateRootFiniteAcpOwner(input, active));
     } catch (cleanupError) {
       reportFailure(input, "cleanup", cleanupError);
       throw new RunHostFatalOperationError(isPrivateExecutionFenceUnconfirmed(cleanupError) ? "UNCERTAIN" : "EXECUTION_FAILED", {
@@ -51618,14 +51849,14 @@ async function executeOwnedProvider(input, provider, recipe, operation) {
       });
     }
     if (input.signal.aborted)
-      return failed2("CANCELLED", "the finite ACP operation was cancelled");
+      return failed2("CANCELLED", `the finite ACP operation was cancelled while ${phase}`);
     if (Date.now() >= effectiveDeadlineUnixMs) {
-      return failed2("DEADLINE_EXCEEDED", "the finite ACP operation deadline elapsed");
+      return failed2("DEADLINE_EXCEEDED", `the finite ACP operation deadline elapsed while ${phase}; ${attemptedDispatch ? "dispatch may have occurred and no result was proved" : "dispatch was not attempted"}`);
     }
     if (error instanceof NativeSessionUnavailable)
       return failed2("UNAVAILABLE", "the retained session is unavailable for this admitted caller");
     const explanation = error instanceof PrivateFiniteAcpPolicyError ? error.reason === "native-session" ? " The native client reported a session failure; private details were withheld." : " The finite ACP exchange violated its validated protocol." : "";
-    return attemptedDispatch ? failed2("UNCERTAIN", `Finite ACP dispatch may have occurred but no result was proved.${explanation}`) : failed2("EXECUTION_FAILED", "finite ACP execution failed before dispatch");
+    return attemptedDispatch ? failed2("UNCERTAIN", `Finite ACP dispatch may have occurred but no result was proved while ${phase}.${explanation}`) : failed2("EXECUTION_FAILED", `finite ACP execution failed before dispatch while ${phase}`);
   } finally {
     credentialBootstrap?.fill(0);
     try {
@@ -53188,19 +53419,23 @@ async function releaseAdmitAndClose(input, initial) {
       }
       if (work.lifecycle.backing !== undefined) {
         const backing2 = parseBacking(work.lifecycle.backing.value);
-        await disposePrivatePackageMaterializationLease(plan.packageAllocation.parent.path, backing2.lease);
+        await privateProfileSpan("root-package-release", () => disposePrivatePackageMaterializationLease(plan.packageAllocation.parent.path, backing2.lease));
       } else {
-        const recovered = await recoverPrivatePackageMaterializationAllocation(plan.packageAllocation.parent.path, plan.packageAllocation);
-        if (recovered.state === "complete")
-          await recovered.lease.dispose();
+        await privateProfileSpan("root-package-release", async () => {
+          const recovered = await recoverPrivatePackageMaterializationAllocation(plan.packageAllocation.parent.path, plan.packageAllocation);
+          if (recovered.state === "complete")
+            await recovered.lease.dispose();
+        });
       }
       if (work.lifecycle.sandbox !== undefined) {
         const sandbox = parseSandbox3(work.lifecycle.sandbox.value);
         const fence = parseFence3(work.lifecycle.fence.value);
-        ownerRelease = await releasePrivateExecutionOwnerState(sandbox.owner, fence.receipt);
+        ownerRelease = await privateProfileSpan("root-owner-release", () => releasePrivateExecutionOwnerState(sandbox.owner, fence.receipt));
       } else {
-        const cancelled2 = await cancelPrivateExecutionOwnerStateAllocation(plan.ownerAllocation);
-        ownerRelease = await releasePrivateExecutionOwnerState(plan.ownerAllocation, cancelled2);
+        ownerRelease = await privateProfileSpan("root-owner-release", async () => {
+          const cancelled2 = await cancelPrivateExecutionOwnerStateAllocation(plan.ownerAllocation);
+          return await releasePrivateExecutionOwnerState(plan.ownerAllocation, cancelled2);
+        });
       }
     }
     work = await advanceCheckpoint(input, work, "release", {
@@ -53927,55 +54162,15 @@ function createSession(owner, roots, packageStore, host, onOperationFailure) {
               const source = await captureStoredPackage(packageStoreRoot, request2.package);
               try {
                 host.onStage?.(`Capturing dependency inputs for ${packageLabel}`);
-                const workspace = await capturePrivateBunWorkspace({
+                const workspace = await privateProfileSpan("dependency-workspace-capture", () => capturePrivateBunWorkspace({
                   projectRoot: owner.root,
                   packagePath: request2.packagePath,
                   captured: source,
                   signal: budget2.signal
-                });
+                }));
                 if (workspace !== undefined) {
                   try {
-                    const admitted = readPrivateAdmittedExecutionReuse({ planningBase, request: request2 });
-                    if (admitted?.execution.preparationInputDigest === workspace.captured.digest && admitted.execution.layout.flowRoot === workspace.target) {
-                      const current2 = await planPrivateDirectRun({
-                        request: request2,
-                        execution: admitted.execution,
-                        installedSupport: host.installedBunSupport,
-                        backend: host.backend,
-                        httpGrants: host.httpGrants,
-                        acpResources: host.acpResources
-                      });
-                      if (current2.digest === admitted.recipeDigest && current2.observation.digest === admitted.observationDigest) {
-                        execution = admitted.execution;
-                        privateProfileInstant("dependency-reuse");
-                        host.onStage?.(`Reusing approved dependencies for ${packageLabel}`);
-                      }
-                    }
-                    if (execution === undefined) {
-                      budget2.reserve(workspace.captured.digest, request2.packagePath);
-                      const unlocked = !workspace.captured.files.some(({ path: path2 }) => path2 === "bun.lock");
-                      requirePrivateBunResolutionPermission(unlocked ? { state: "unlocked", manifestPath: "package.json" } : { state: "locked", manifestPath: "package.json", lockPath: "bun.lock" }, host.allowResolutionNetwork);
-                      if (unlocked)
-                        host.onResolution?.(request2.packagePath);
-                      host.onStage?.(`Preparing dependencies for ${packageLabel}`);
-                      const prepared = await privateProfileSpan("dependency-preparation", () => preparePrivateBunPackage({
-                        captured: workspace.captured,
-                        workspace,
-                        installedSupport: host.installedBunSupport,
-                        backend: host.backend,
-                        projectRoot: owner.root.requestedPath,
-                        coordinator: owner.coordinator,
-                        deadlineUnixMs: budget2.deadlineUnixMs,
-                        signal: budget2.signal,
-                        allowResolutionNetwork: host.allowResolutionNetwork === true
-                      }));
-                      try {
-                        budget2.retain(prepared.captured.files, request2.packagePath, Buffer.byteLength(JSON.stringify(prepared.layout)));
-                        execution = privateBunExecutionArtifact(await publishCapturedPackage(packageStoreRoot, prepared.captured), prepared.layout, workspace.captured.digest);
-                      } finally {
-                        await prepared.captured.dispose();
-                      }
-                    }
+                    execution = await prepareExecution(workspace.captured, workspace);
                   } finally {
                     await workspace.captured.dispose();
                   }
@@ -53984,45 +54179,75 @@ function createSession(owner, roots, packageStore, host, onOperationFailure) {
                   if (dependencyInput.state === "direct") {
                     execution = privateBunExecutionArtifact(request2.package);
                   } else {
-                    const admitted = readPrivateAdmittedExecutionReuse({ planningBase, request: request2 });
-                    if (admitted !== undefined) {
-                      const current2 = await planPrivateDirectRun({
-                        request: request2,
-                        execution: admitted.execution,
-                        installedSupport: host.installedBunSupport,
-                        backend: host.backend,
-                        httpGrants: host.httpGrants,
-                        acpResources: host.acpResources
+                    execution = await prepareExecution(source);
+                  }
+                }
+                async function prepareExecution(captured, workspace2) {
+                  const inputs = await privateBunPreparationInputs({
+                    captured,
+                    ...workspace2 === undefined ? {} : { workspace: workspace2 },
+                    supportDigest: privateDomainDigest("JIG-Bun-Preparation-Support/1", {
+                      installation: host.installedBunSupport.digest,
+                      mechanism: (await host.backend.inspectSupport()).digest
+                    })
+                  });
+                  const admitted = readPrivateAdmittedExecutionReuse({ planningBase, request: request2 });
+                  const evidence = admitted?.execution.preparation;
+                  if (admitted !== undefined && evidence?.inputDigest === inputs.digest) {
+                    const previous = await captureStoredPackage(packageStoreRoot, admitted.execution.package);
+                    await previous.dispose();
+                    const dependencies = await captureStoredPackage(packageStoreRoot, evidence.package);
+                    try {
+                      const assembled = await assemblePrivateBunExecution({
+                        source: captured,
+                        sourcePaths: inputs.sourcePaths,
+                        dependencies,
+                        layout: admitted.execution.layout
                       });
-                      if (current2.digest === admitted.recipeDigest && current2.observation.digest === admitted.observationDigest) {
-                        execution = admitted.execution;
-                        privateProfileInstant("dependency-reuse");
-                      }
-                    }
-                    if (execution === undefined) {
-                      requirePrivateBunResolutionPermission(dependencyInput, host.allowResolutionNetwork);
-                      budget2.reserve(request2.package.digest, request2.packagePath);
-                      if (dependencyInput.state === "unlocked")
-                        host.onResolution?.(request2.packagePath);
-                      host.onStage?.(`Preparing dependencies for ${packageLabel}`);
-                      const prepared = await privateProfileSpan("dependency-preparation", () => preparePrivateBunPackage({
-                        captured: source,
-                        installedSupport: host.installedBunSupport,
-                        backend: host.backend,
-                        projectRoot: owner.root.requestedPath,
-                        coordinator: owner.coordinator,
-                        deadlineUnixMs: budget2.deadlineUnixMs,
-                        signal: budget2.signal,
-                        allowResolutionNetwork: host.allowResolutionNetwork === true
-                      }));
                       try {
-                        budget2.retain(prepared.captured.files, request2.packagePath, Buffer.byteLength(JSON.stringify(prepared.layout)));
-                        execution = privateBunExecutionArtifact(await publishCapturedPackage(packageStoreRoot, prepared.captured), prepared.layout);
+                        budget2.signal.throwIfAborted();
+                        const execution2 = privateBunExecutionArtifact(await publishCapturedPackage(packageStoreRoot, assembled), admitted.execution.layout, evidence);
+                        privateProfileInstant("dependency-reuse");
+                        host.onStage?.(`Reusing approved dependencies for ${packageLabel}`);
+                        return execution2;
                       } finally {
-                        await prepared.captured.dispose();
+                        await assembled.dispose();
                       }
+                    } finally {
+                      await dependencies.dispose();
                     }
                   }
+                  const unlocked = !captured.files.some(({ path: path2 }) => path2 === "bun.lock");
+                  requirePrivateBunResolutionPermission(unlocked ? { state: "unlocked", manifestPath: "package.json" } : { state: "locked", manifestPath: "package.json", lockPath: "bun.lock" }, host.allowResolutionNetwork);
+                  budget2.reserve(captured.digest, request2.packagePath);
+                  if (unlocked)
+                    host.onResolution?.(request2.packagePath);
+                  host.onStage?.(`Preparing dependencies for ${packageLabel}`);
+                  const prepared = await privateProfileSpan("dependency-preparation", () => preparePrivateBunPackage({
+                    captured,
+                    ...workspace2 === undefined ? {} : { workspace: workspace2 },
+                    installedSupport: host.installedBunSupport,
+                    backend: host.backend,
+                    projectRoot: owner.root.requestedPath,
+                    coordinator: owner.coordinator,
+                    deadlineUnixMs: budget2.deadlineUnixMs,
+                    signal: budget2.signal,
+                    allowResolutionNetwork: host.allowResolutionNetwork === true
+                  }));
+                  try {
+                    budget2.retain(prepared.captured.files, request2.packagePath, Buffer.byteLength(JSON.stringify(prepared.layout)));
+                    const dependencies = await capturePrivateBunDependencies(prepared.captured, inputs.sourcePaths);
+                    try {
+                      return privateBunExecutionArtifact(await publishCapturedPackage(packageStoreRoot, prepared.captured), prepared.layout, {
+                        inputDigest: inputs.digest,
+                        package: await publishCapturedPackage(packageStoreRoot, dependencies)
+                      });
+                    } finally {
+                      await dependencies.dispose();
+                    }
+                  } finally {
+                    await prepared.captured.dispose();
+                  }
                 }
               } finally {
                 await source.dispose();
@@ -54061,17 +54286,17 @@ function createSession(owner, roots, packageStore, host, onOperationFailure) {
           }),
           mechanismDigest: recipes[0]?.mechanismDigest ?? (await host.backend.inspectSupport()).digest,
           entries: requests.map((request2) => {
-            const failure = featureFailures.get(privateActivationTargetKey(request2.target));
+            const failure2 = featureFailures.get(privateActivationTargetKey(request2.target));
             return {
               target: request2.target,
               requestDigest: request2.digest,
-              disposition: failure === undefined ? {
+              disposition: failure2 === undefined ? {
                 state: "planned",
                 observation: recipes.find((recipe) => recipe.request.digest === request2.digest).observation
               } : {
                 state: "unavailable",
                 code: "FEATURE_UNAVAILABLE",
-                evidenceDigests: [failure]
+                evidenceDigests: [failure2]
               }
             };
           })