@odla-ai/harness 0.11.11 → 0.11.13

package/dist/{chunk-ZM6AITC2.js → chunk-3ON6UAOV.js}

@@ -543,9 +543,11 @@ export {
   buildContainerRunArgs,
   runContainerAttempt,
   SKIP_WORKSPACE_DIRS,
+  SECRET_WORKSPACE_FILE,
+  allowedWorkspacePath,
   materializeGitTree,
   stageWorkspace,
   stageWorkspacePair,
   safeWorkspaceLabel
 };
-//# sourceMappingURL=chunk-ZM6AITC2.js.map
+//# sourceMappingURL=chunk-3ON6UAOV.js.map

package/dist/{chunk-4IGSN53G.js → chunk-B2PQAORN.js}

@@ -1,13 +1,14 @@
 import {
   observedBroker
-} from "./chunk-INL642J5.js";
+} from "./chunk-OXWLPB7P.js";
 import {
+  SECRET_WORKSPACE_FILE,
   SKIP_WORKSPACE_DIRS,
   assertPinnedImage,
   stageWorkspace,
   stageWorkspacePair,
   verifyContainerEngineBoundary
-} from "./chunk-ZM6AITC2.js";
+} from "./chunk-3ON6UAOV.js";
 import {
   HARNESS_PROTOCOL_VERSION
 } from "./chunk-ONYW2VSB.js";
@@ -290,7 +291,7 @@ async function withOverloadRetry(call, wait2, onRetry = () => void 0, retryable
 }
 
 // src/code-runtime-reconciler.ts
-var sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var POST_ACK_RETRY_TICKS = 40;
 var CodeRuntimeReconciler = class {
   constructor(control, engine, onDiagnostic, options = {}) {
@@ -392,12 +393,12 @@ function retryableControlFailure(value) {
   return failure.status === 408 || failure.status === 425 || failure.status === 429 || failure.status >= 500;
 }
 function wait(ms, signal) {
-  return new Promise((resolve6) => {
-    if (signal?.aborted) return resolve6();
-    const timer = setTimeout(resolve6, ms);
+  return new Promise((resolve7) => {
+    if (signal?.aborted) return resolve7();
+    const timer = setTimeout(resolve7, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve6();
+      resolve7();
     }, { once: true });
   });
 }
@@ -827,15 +828,121 @@ function isCheckpointEffectCompleted(checkpoint, effectId, actionDigest) {
   return true;
 }
 
-// src/recipe-container.ts
+// src/code-recipe-dependencies.ts
+import { lstat as lstat2, rm, symlink } from "fs/promises";
+import { isAbsolute, join } from "path";
+var RESERVED_MOUNTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+function assertLentPath(mountAs) {
+  const parts = mountAs.split("/");
+  if (isAbsolute(mountAs) || mountAs.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
+    throw new TypeError(`recipe dependencies must mount inside the workspace, not at "${mountAs}"`);
+  }
+}
+function assertReservedMount(mountAs) {
+  assertLentPath(mountAs);
+  if (!RESERVED_MOUNTS.has(mountAs.split("/").at(-1))) {
+    throw new TypeError(`recipe dependencies must mount at a reserved name, not "${mountAs}"`);
+  }
+}
+function lentDirectories(dependencies) {
+  return [{ source: dependencies.source, mountAs: dependencies.mountAs ?? "node_modules" }, ...dependencies.nested ?? []];
+}
+function withRecipeDependencies(executor, dependencies) {
+  const lent = lentDirectories(dependencies);
+  for (const entry of lent) {
+    if (!isAbsolute(entry.source)) {
+      throw new TypeError("recipe dependency source must be an absolute path");
+    }
+    assertReservedMount(entry.mountAs);
+  }
+  return {
+    run: async (input) => {
+      const linked = [];
+      try {
+        for (const entry of lent) {
+          const target = join(input.workspaceDir, entry.mountAs);
+          if (await lstat2(target).catch(() => null)) continue;
+          await symlink(entry.source, target, "dir").then(() => linked.push(target), () => void 0);
+        }
+        return await executor.run(input);
+      } finally {
+        for (const target of linked) await rm(target, { force: true, recursive: false }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function installedDependencies(repoRoot) {
+  const source = join(repoRoot, "node_modules");
+  const info = await lstat2(source).catch(() => null);
+  return info?.isDirectory() ? { source } : null;
+}
+
+// src/recipe-container-lending.ts
 import { spawn as spawn2 } from "child_process";
+import { mkdir, rm as rm2, stat } from "fs/promises";
+import { dirname, join as join2, resolve as resolve3, sep as sep2 } from "path";
+var RUN_ID = /^[A-Za-z0-9_.-]{1,64}$/;
+function copy(args) {
+  return new Promise((accept, reject) => {
+    const child = spawn2("cp", args, { shell: false, stdio: "ignore" });
+    child.once("error", reject);
+    child.once("exit", (code) => accept(code ?? 1));
+  });
+}
+async function cloneTree(source, target, platform = process.platform) {
+  await mkdir(dirname(target), { recursive: true });
+  const fast = platform === "darwin" ? ["-Rc", source, target] : platform === "linux" ? ["-R", "--reflink=auto", source, target] : null;
+  if (fast && await copy(fast) === 0) return;
+  await rm2(target, { recursive: true, force: true });
+  if (await copy(["-R", source, target]) !== 0) throw new Error(`could not clone ${source}`);
+}
+async function lendDependencies(dependencies, runId) {
+  if (!dependencies?.runsDir) return { dependencies, release: async () => void 0 };
+  if (!RUN_ID.test(runId)) throw new TypeError("run id is not a safe directory name");
+  const treeRoot = dirname(dependencies.source);
+  for (const entry of lentDirectories(dependencies)) {
+    if (entry.source !== join2(treeRoot, entry.mountAs)) {
+      throw new TypeError("every directory of a cloned set must lie under its tree root at its mount path");
+    }
+  }
+  const runDir = join2(dependencies.runsDir, runId);
+  await cloneTree(treeRoot, runDir);
+  const rebase = (entry) => ({ source: join2(runDir, entry.mountAs), mountAs: entry.mountAs });
+  return {
+    dependencies: {
+      ...dependencies,
+      source: join2(runDir, dependencies.mountAs ?? "node_modules"),
+      nested: (dependencies.nested ?? []).map(rebase),
+      writable: true
+    },
+    release: () => rm2(runDir, { recursive: true, force: true })
+  };
+}
+async function lendBuildProducts(products, workspaceDir) {
+  const root = resolve3(workspaceDir);
+  const lent = [];
+  for (const product of products) {
+    assertLentPath(product.mountAs);
+    if (SECRET_WORKSPACE_FILE.test(product.mountAs.split("/").at(-1))) throw new TypeError("a secret is never a build product");
+    const target = resolve3(root, product.mountAs);
+    if (!target.startsWith(`${root}${sep2}`)) throw new TypeError("build product escapes the workspace");
+    if (await stat(target).catch(() => null)) continue;
+    if (!await stat(join2(root, product.within ?? dirname(product.mountAs))).catch(() => null)) continue;
+    await cloneTree(product.source, target);
+    lent.push(product.mountAs);
+  }
+  return lent;
+}
+
+// src/recipe-container.ts
+import { spawn as spawn3 } from "child_process";
 import { getgid, getuid } from "process";
 import { randomUUID } from "crypto";
 var ARTIFACT_PATH = /^[A-Za-z0-9_@+.,-]+(?:\/[A-Za-z0-9_@+.,-]+)*$/;
 var PRIVATE_ARTIFACT_PART = /^(?:\.git|\.odla|\.wrangler|\.env(?:\..+)?|\.dev\.vars|credentials(?:\..+)?\.json)$/i;
 function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-recipe-${randomUUID().slice(0, 12)}`, dependencies = null) {
   assertCodeBuildRecipe(recipe2);
-  const mounts = dependencies ? [dependencyMount(engine, dependencies)] : [];
+  const mounts = dependencies ? dependencyMounts(engine, dependencies) : [];
   if (/[,\r\n]/.test(workspaceDir)) throw new TypeError("workspace path contains unsupported mount characters");
   const uid = typeof getuid === "function" ? getuid() : 1e3;
   const gid = typeof getgid === "function" ? getgid() : 1e3;
@@ -861,6 +968,7 @@ function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-re
       ...mounts,
       "--workdir=/workspace",
       "--env=CI=1",
+      "--env=HOME=/tmp",
       recipe2.image,
       ...recipe2.command
     ];
@@ -883,26 +991,34 @@ function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-re
     ...mounts,
     "--workdir=/workspace",
     "--env=CI=1",
+    "--env=HOME=/tmp",
     recipe2.image,
     ...recipe2.command
   ];
 }
-var LENDABLE = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
-function dependencyMount(engine, dependencies) {
-  const mountAs = dependencies.mountAs ?? "node_modules";
-  if (!dependencies.source.startsWith("/") || /[,\r\n]/.test(dependencies.source)) {
-    throw new TypeError("recipe dependency source must be an absolute path without mount separators");
-  }
-  if (!LENDABLE.has(mountAs)) throw new TypeError(`recipe dependencies must mount at a reserved name, not "${mountAs}"`);
-  return engine === "container" ? `--mount=type=bind,source=${dependencies.source},target=/workspace/${mountAs},readonly` : `--mount=type=bind,src=${dependencies.source},dst=/workspace/${mountAs},readonly`;
+function dependencyMounts(engine, dependencies) {
+  const readonly = dependencies.writable ? "" : ",readonly";
+  return lentDirectories(dependencies).map(({ source, mountAs }) => {
+    if (!source.startsWith("/") || /[,\r\n]/.test(source)) {
+      throw new TypeError("recipe dependency source must be an absolute path without mount separators");
+    }
+    assertReservedMount(mountAs);
+    return engine === "container" ? `--mount=type=bind,source=${source},target=/workspace/${mountAs}${readonly}` : `--mount=type=bind,src=${source},dst=/workspace/${mountAs}${readonly}`;
+  });
 }
 function createContainerRecipeExecutor(engine, options = {}) {
   return {
     async run(input) {
       await verifyContainerEngineBoundary(engine);
       const name = `odla-recipe-${randomUUID().slice(0, 12)}`;
-      const args = buildRecipeContainerArgs(engine, input.workspaceDir, input.recipe, name, options.dependencies ?? null);
-      return execute(engine, args, name, input.recipe, input.signal);
+      const lent = await lendDependencies(options.dependencies ?? null, name);
+      try {
+        if (lent.dependencies?.products?.length) await lendBuildProducts(lent.dependencies.products, input.workspaceDir);
+        const args = buildRecipeContainerArgs(engine, input.workspaceDir, input.recipe, name, lent.dependencies);
+        return await execute(engine, args, name, input.recipe, input.signal);
+      } finally {
+        await lent.release();
+      }
     }
   };
 }
@@ -924,10 +1040,14 @@ function parseMemory(value) {
 function execute(engine, args, name, recipe2, signal) {
   return runContainerCommand(engine, args, name, { timeoutMs: recipe2.timeoutMs, maxOutputBytes: recipe2.maxOutputBytes }, signal);
 }
+var CONTAINER_PROGRESS = /^\[\d+\/\d+\] .*$/gm;
+function recipeOutput(engine, stderr) {
+  return engine === "container" ? stderr.replace(CONTAINER_PROGRESS, "").replace(/^\n+/, "") : stderr;
+}
 function runContainerCommand(engine, args, name, recipe2, signal) {
   return new Promise((accept, reject) => {
     const started = Date.now();
-    const child = spawn2(engine, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn3(engine, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
     const stdout = [];
     const stderr = [];
     let bytes = 0;
@@ -940,7 +1060,7 @@ function runContainerCommand(engine, args, name, recipe2, signal) {
       timedOut = reason === "timeout";
       outputLimitExceeded = reason === "output";
       const remove = engine === "container" ? ["delete", "--force", name] : ["rm", "-f", name];
-      const killer = spawn2(engine, remove, { shell: false, stdio: "ignore" });
+      const killer = spawn3(engine, remove, { shell: false, stdio: "ignore" });
       killer.unref();
       child.kill("SIGTERM");
     };
@@ -966,7 +1086,7 @@ function runContainerCommand(engine, args, name, recipe2, signal) {
       accept({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdout).toString("utf8"),
-        stderr: Buffer.concat(stderr).toString("utf8"),
+        stderr: recipeOutput(engine, Buffer.concat(stderr).toString("utf8")),
         durationMs: Date.now() - started,
         outputLimitExceeded,
         timedOut
@@ -978,8 +1098,8 @@ function runContainerCommand(engine, args, name, recipe2, signal) {
 // src/code-verifier.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import { createReadStream } from "fs";
-import { lstat as lstat2 } from "fs/promises";
-import { join } from "path";
+import { lstat as lstat3 } from "fs/promises";
+import { join as join3 } from "path";
 import {
   digestCodeVerificationReceipt
 } from "@odla-ai/camel/code";
@@ -1091,8 +1211,8 @@ async function inspectArtifacts(workspaceDir, recipe2) {
   const receipts = [];
   for (const artifact of recipe2.expectedArtifacts ?? []) {
     try {
-      const path = join(workspaceDir, artifact.path);
-      const info = await lstat2(path);
+      const path = join3(workspaceDir, artifact.path);
+      const info = await lstat3(path);
       if (!info.isFile() || info.isSymbolicLink()) {
         receipts.push({ artifactId: artifact.id, status: "invalid", bytes: null, digest: null });
       } else if (info.size > artifact.maximumBytes) {
@@ -1316,9 +1436,9 @@ var CodeRuntimeCheckpointManager = class {
 
 // src/code-runtime-archive.ts
 import { gunzipSync } from "zlib";
-import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
+import { mkdir as mkdir2, mkdtemp, rm as rm3, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname, join as join2, resolve as resolve3, sep as sep2 } from "path";
+import { dirname as dirname2, join as join4, resolve as resolve4, sep as sep3 } from "path";
 var RESERVED2 = /* @__PURE__ */ new Set([".git", ".odla", ".wrangler", "node_modules", "dist", "coverage"]);
 var SECRET2 = /^(?:\.env(?:\..+)?|\.dev\.vars|credentials(?:\..+)?\.json|dev-token(?:\..+)?\.json)$/i;
 var MAX_NUL_SHARE = 0.1;
@@ -1336,9 +1456,9 @@ async function materializeCodeRuntimeArchive(archive, visiblePaths, tempRoot = t
     throw new TypeError("Code source archive exceeds its decompressed byte bound");
   }
   const entries = parseTar(bytes, archive.limits);
-  const root = await mkdtemp(join2(tempRoot, "odla-code-archive-"));
-  const sourceDir = join2(root, "source");
-  await mkdir(sourceDir);
+  const root = await mkdtemp(join4(tempRoot, "odla-code-archive-"));
+  const sourceDir = join4(root, "source");
+  await mkdir2(sourceDir);
   let visible = 0;
   try {
     for (const entry of entries) {
@@ -1351,16 +1471,16 @@ async function materializeCodeRuntimeArchive(archive, visiblePaths, tempRoot = t
         continue;
       }
       if (nulShare(content) > MAX_NUL_SHARE) continue;
-      const target = resolve3(sourceDir, entry.path);
-      if (!target.startsWith(`${resolve3(sourceDir)}${sep2}`)) throw new TypeError("Code source path escapes its root");
-      await mkdir(dirname(target), { recursive: true });
+      const target = resolve4(sourceDir, entry.path);
+      if (!target.startsWith(`${resolve4(sourceDir)}${sep3}`)) throw new TypeError("Code source path escapes its root");
+      await mkdir2(dirname2(target), { recursive: true });
       await writeFile(target, content, { flag: "wx", mode: 420 });
       visible += 1;
     }
     if (!visible && !visiblePaths) throw new TypeError("GitHub commit has no Code-visible text source");
-    return { sourceDir, cleanup: () => rm(root, { recursive: true, force: true }) };
+    return { sourceDir, cleanup: () => rm3(root, { recursive: true, force: true }) };
   } catch (cause) {
-    await rm(root, { recursive: true, force: true });
+    await rm3(root, { recursive: true, force: true });
     throw cause;
   }
 }
@@ -1663,13 +1783,13 @@ async function prepareRuntimeLocalSource(input) {
 }
 
 // src/code-runtime-source.ts
-import { mkdir as mkdir3, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir4, mkdtemp as mkdtemp2, rm as rm4, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname3, join as join4, resolve as resolve4, sep as sep3 } from "path";
+import { dirname as dirname4, join as join6, resolve as resolve5, sep as sep4 } from "path";
 
 // src/code-runtime-selected-source.ts
-import { chmod, cp, mkdir as mkdir2, readdir as readdir2 } from "fs/promises";
-import { dirname as dirname2, join as join3 } from "path";
+import { chmod, cp, mkdir as mkdir3, readdir as readdir2 } from "fs/promises";
+import { dirname as dirname3, join as join5 } from "path";
 function selectedSourceSet(payload) {
   if (!payload.sourceSet) return null;
   const set = payload.sourceSet && typeof payload.sourceSet === "object" && !Array.isArray(payload.sourceSet) ? payload.sourceSet : null;
@@ -1706,8 +1826,8 @@ async function attachReferenceDirectories(workspace, references) {
   for (const reference of references) {
     validateAlias(reference.alias);
     for (const root of [workspace.baselineDir, workspace.workspaceDir]) {
-      const target = join3(root, ".odla-references", reference.alias);
-      await mkdir2(dirname2(target), { recursive: true });
+      const target = join5(root, ".odla-references", reference.alias);
+      await mkdir3(dirname3(target), { recursive: true });
       await cp(reference.sourceDir, target, { recursive: true, errorOnExist: true, force: false });
       await makeTreeReadOnly(target);
     }
@@ -1720,7 +1840,7 @@ function validateAlias(alias) {
 }
 async function makeTreeReadOnly(root) {
   for (const entry of await readdir2(root, { withFileTypes: true })) {
-    const target = join3(root, entry.name);
+    const target = join5(root, entry.name);
     if (entry.isDirectory()) await makeTreeReadOnly(target);
     else if (entry.isFile()) await chmod(target, 292);
   }
@@ -1734,9 +1854,9 @@ var SOURCE_MAX_BYTES = 80 * 1024 * 1024;
 var SOURCE_SET_MAX_BYTES = 480 * 1024 * 1024;
 async function materializeCodeRuntimeSource(snapshot, tempRoot = tmpdir2()) {
   if (!snapshot.files.length || snapshot.files.length > SOURCE_MAX_FILES) throw new TypeError("Code source file count is invalid");
-  const root = await mkdtemp2(join4(tempRoot, "odla-code-source-"));
-  const sourceDir = join4(root, "source");
-  await mkdir3(sourceDir);
+  const root = await mkdtemp2(join6(tempRoot, "odla-code-source-"));
+  const sourceDir = join6(root, "source");
+  await mkdir4(sourceDir);
   const seen = /* @__PURE__ */ new Set();
   let bytes = 0;
   try {
@@ -1746,9 +1866,9 @@ async function materializeCodeRuntimeSource(snapshot, tempRoot = tmpdir2()) {
       seen.add(file.path);
       bytes += Buffer.byteLength(file.path) + Buffer.byteLength(file.content);
       if (bytes > SOURCE_MAX_BYTES) throw new TypeError("Code source exceeds its byte bound");
-      const target = resolve4(sourceDir, file.path);
-      if (!target.startsWith(`${resolve4(sourceDir)}${sep3}`)) throw new TypeError("Code source path escapes its root");
-      await mkdir3(dirname3(target), { recursive: true });
+      const target = resolve5(sourceDir, file.path);
+      if (!target.startsWith(`${resolve5(sourceDir)}${sep4}`)) throw new TypeError("Code source path escapes its root");
+      await mkdir4(dirname4(target), { recursive: true });
       await writeFile2(target, file.content, { flag: "wx", mode: 420 });
     }
     for (const reference of snapshot.references ?? []) {
@@ -1761,15 +1881,15 @@ async function materializeCodeRuntimeSource(snapshot, tempRoot = tmpdir2()) {
         seen.add(path);
         bytes += Buffer.byteLength(path) + Buffer.byteLength(file.content);
         if (bytes > SOURCE_SET_MAX_BYTES) throw new TypeError("Code source set exceeds its byte bound");
-        const target = resolve4(sourceDir, path);
-        if (!target.startsWith(`${resolve4(sourceDir)}${sep3}`)) throw new TypeError("Code reference path escapes its root");
-        await mkdir3(dirname3(target), { recursive: true });
+        const target = resolve5(sourceDir, path);
+        if (!target.startsWith(`${resolve5(sourceDir)}${sep4}`)) throw new TypeError("Code reference path escapes its root");
+        await mkdir4(dirname4(target), { recursive: true });
         await writeFile2(target, file.content, { flag: "wx", mode: 292 });
       }
     }
-    return { sourceDir, cleanup: () => rm2(root, { recursive: true, force: true }) };
+    return { sourceDir, cleanup: () => rm4(root, { recursive: true, force: true }) };
   } catch (cause) {
-    await rm2(root, { recursive: true, force: true });
+    await rm4(root, { recursive: true, force: true });
     throw cause;
   }
 }
@@ -1788,9 +1908,9 @@ async function attachCodeRuntimeReferences(workspace, references) {
       bytes += Buffer.byteLength(path) + Buffer.byteLength(file.content);
       if (bytes > SOURCE_SET_MAX_BYTES - SOURCE_MAX_BYTES) throw new TypeError("Code reference set exceeds its byte bound");
       for (const root of [workspace.baselineDir, workspace.workspaceDir]) {
-        const target = resolve4(root, path);
-        if (!target.startsWith(`${resolve4(root)}${sep3}`)) throw new TypeError("Code reference path escapes its root");
-        await mkdir3(dirname3(target), { recursive: true });
+        const target = resolve5(root, path);
+        if (!target.startsWith(`${resolve5(root)}${sep4}`)) throw new TypeError("Code reference path escapes its root");
+        await mkdir4(dirname4(target), { recursive: true });
         await writeFile2(target, file.content, { flag: "wx", mode: 292 });
       }
     }
@@ -2236,7 +2356,7 @@ Finish with a concise, non-empty answer to the owner. Do not call tools or promi
 }
 
 // src/code-runtime-session-skills.ts
-var sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var sleep2 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 function createCodeRuntimeSessionSkillLoader(control, options = {}) {
   const wait2 = options.wait ?? sleep2;
   const load = control.collaborationSkills?.bind(control);
@@ -2295,7 +2415,7 @@ var inferWithBackoff = (infer, wait2, onRetry) => withOverloadRetry(infer, wait2
 async function handleCodeRuntimeInference(input) {
   const { command, request, state } = input;
   const startedAt = Date.now();
-  const wait2 = input.wait ?? ((ms) => new Promise((resolve6) => setTimeout(resolve6, ms)));
+  const wait2 = input.wait ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms)));
   const response2 = await inferWithBackoff(
     () => input.control.infer(command.sessionId, {
       requestId: request.requestId,
@@ -2363,9 +2483,9 @@ function createCodeRuntimeInference(options) {
 }
 
 // src/code-tool-discovery.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { readFile as readFile2, readdir as readdir3 } from "fs/promises";
-import { relative as relative2, resolve as resolve5 } from "path";
+import { relative as relative2, resolve as resolve6 } from "path";
 var DEFAULT_MAX_FILES = 2e4;
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_FILE_BYTES = 512 * 1024;
@@ -2393,7 +2513,7 @@ async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
     for (const entry of await readdir3(directory, { withFileTypes: true })) {
       if (SKIP_WORKSPACE_DIRS.has(entry.name)) continue;
       if (entry.isSymbolicLink()) throw new TypeError("workspace contains a symbolic link");
-      const target = resolve5(directory, entry.name);
+      const target = resolve6(directory, entry.name);
       if (entry.isDirectory()) await walk(target);
       else if (entry.isFile()) {
         const path = relative2(root, target).split("\\").join("/");
@@ -2407,7 +2527,7 @@ async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
       }
     }
   };
-  await walk(resolve5(root));
+  await walk(resolve6(root));
   return paths.sort();
 }
 function listWorkspace(paths, options = {}) {
@@ -2469,7 +2589,7 @@ function nativeSearchBatch(root, paths, options, remaining) {
       options.query,
       ...paths
     ];
-    const child = spawn3("rg", args, {
+    const child = spawn4("rg", args, {
       cwd: root,
       stdio: ["ignore", "pipe", "ignore"],
       ...options.signal ? { signal: options.signal } : {}
@@ -2521,7 +2641,7 @@ async function fallbackSearch(root, scoped, options) {
     if (matches.length >= options.maxResults) break;
     let source;
     try {
-      source = await readFile2(resolve5(root, path));
+      source = await readFile2(resolve6(root, path));
     } catch {
       continue;
     }
@@ -2825,7 +2945,7 @@ import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 
 // src/code-tool-graph.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import {
   hubs,
   incident,
@@ -2839,7 +2959,7 @@ var cache = /* @__PURE__ */ new Map();
 function workspaceGraphs(workspaceDir, paths) {
   const existing = cache.get(workspaceDir);
   if (existing) return existing;
-  const read2 = (path) => readFile3(join5(workspaceDir, path), "utf8");
+  const read2 = (path) => readFile3(join7(workspaceDir, path), "utf8");
   const built = (async () => ({
     // No knownTables: a staged workspace may not carry migrations, and a filter
     // that silently drops every table is worse than an unfiltered one. Callers
@@ -2949,8 +3069,8 @@ async function edit(context, request, options, policy, registry) {
 }
 
 // src/code-tool-write.ts
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5 } from "path";
 var MAX_WRITE_BYTES = 256 * 1024;
 var lines = (text) => text === "" ? [] : text.replace(/\n$/, "").split("\n");
 function writeAsDiff(path, current, content) {
@@ -2975,7 +3095,7 @@ async function writeCodeFile(workspaceDir, path, content, current) {
   }
   if (content.includes("\0")) throw new TypeError("content contains NUL bytes; use plain text");
   const target = resolveCodePath(workspaceDir, path);
-  await mkdir4(dirname4(target), { recursive: true });
+  await mkdir5(dirname5(target), { recursive: true });
   await writeFile4(target, content, "utf8");
   return { created: current === null, deletions: current === null ? 0 : lines(current).length, additions: lines(content).length };
 }
@@ -3003,7 +3123,7 @@ async function write(context, request, options, policy, registry) {
 }
 
 // src/code-tool-reads.ts
-import { readFile as readFile6, stat } from "fs/promises";
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
 var GRAPH_TOOLS = /* @__PURE__ */ new Set([
   "sandbox.overview",
   "sandbox.where_is",
@@ -3025,7 +3145,7 @@ async function read(context, request, options, policy, registry) {
   const allowed = await policy.read(policyContext(context, request, options, { paths, path, startLine, endLine }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
   const target = resolveCodePath(context.workspaceDir, path);
-  const info = await stat(target);
+  const info = await stat2(target);
   if (!info.isFile() || info.size > Math.max(options.maxReadBytes ?? 128 * 1024, 2 * 1024 * 1024)) {
     throw new TypeError("file is not a bounded regular source file");
   }
@@ -3382,7 +3502,7 @@ function assertBudget(budget) {
 
 // src/code-repository-recipes.ts
 import { readFile as readFile7 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 
 // src/code-runtime-events.ts
 import { createHash as createHash3 } from "crypto";
@@ -3457,7 +3577,7 @@ function parseRepositoryRecipes(text, envelope) {
 async function readRepositoryRecipes(baselineDir, envelope) {
   let text;
   try {
-    text = await readFile7(join6(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
+    text = await readFile7(join8(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
   } catch (cause) {
     if (cause.code === "ENOENT") return null;
     throw cause;
@@ -3690,8 +3810,8 @@ async function startGoalPursuit(input) {
 function codeRuntimeAcknowledgementGate(signal) {
   let settle;
   let settled = false;
-  const ready = new Promise((resolve6) => {
-    settle = resolve6;
+  const ready = new Promise((resolve7) => {
+    settle = resolve7;
   });
   const release = (run) => {
     if (settled) return;
@@ -4062,9 +4182,18 @@ export {
   createCodeWorkspaceCheckpoint,
   restoreCodeWorkspaceCheckpoint,
   isCheckpointEffectCompleted,
+  assertLentPath,
+  assertReservedMount,
+  lentDirectories,
+  withRecipeDependencies,
+  installedDependencies,
+  cloneTree,
+  lendDependencies,
+  lendBuildProducts,
   buildRecipeContainerArgs,
   createContainerRecipeExecutor,
   assertCodeBuildRecipe,
+  recipeOutput,
   runContainerCommand,
   verifyCodeCandidate,
   prepareRuntimeCheckpoint,
@@ -4103,4 +4232,4 @@ export {
   withProofRecipes,
   TheseusRuntimeEngine
 };
-//# sourceMappingURL=chunk-4IGSN53G.js.map
+//# sourceMappingURL=chunk-B2PQAORN.js.map