@poe-platform/safe-bash 0.1.821 → 0.1.823

package/dist/safe-bash/command-chunks/{chunk-R4NPYXQX.js → chunk-WDTWJFPK.js}

@@ -1,9 +1,165 @@
-// packages/safe-bash-command-python/src/provisioning.ts
+// packages/safe-bash-command-python/src/package-download.ts
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { resolvePath } from "../../safe-bash-contracts/path.js";
+import { interruptible } from "../../safe-bash-contracts/runtime-control.js";
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-python/src/package-file.ts
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { sha256 } from "@noble/hashes/sha2.js";
+import { compareIdentity, compareFileVersion } from "@poe-platform/safe-fs/core";
+async function openPythonPackageFile({ fs, signal }, path, maxBytes, expected) {
+  const settings = { signal };
+  const capabilities = await fs.capabilitiesFor?.(path, settings) ?? fs.capabilities;
+  if (!capabilities.retainedRead || !fs.openReadFile) return void 0;
+  const file = await fs.openReadFile(path, settings);
+  try {
+    signal.throwIfAborted();
+    const state = { ...await file.stat(settings) };
+    if (expected && (compareIdentity(expected, state) !== "same" || !compareFileVersion(expected, state))) throw new Error("Canonical Python wheel changed");
+    if (state.type !== "file" || !Number.isSafeInteger(state.size) || state.size < 0) throw new Error("Invalid canonical Python wheel");
+    if (state.size > maxBytes) throw new Error("Canonical package exceeds maxDownloadBytes");
+    const check = async () => {
+      signal.throwIfAborted();
+      const current = await file.stat(settings);
+      if (compareIdentity(state, current) !== "same" || !compareFileVersion(state, current)) throw new Error("Canonical Python wheel changed");
+    };
+    const read = async (offset, length) => {
+      await check();
+      const count = Math.min(length, Math.max(0, state.size - offset));
+      if (!count) return new Uint8Array(0);
+      const bytes = Uint8Array.from(await file.read(offset, count, settings));
+      if (!bytes.length || bytes.length > count) throw new Error("Invalid canonical package read");
+      await check();
+      return bytes;
+    };
+    const hash = sha256.create();
+    for (let offset = 0, pulls = 0; offset < state.size; ) {
+      if (++pulls % 16 === 0) await yieldTurn(signal);
+      const bytes = await read(offset, 65536);
+      hash.update(bytes);
+      offset += bytes.length;
+    }
+    await check();
+    return { key: Array.from(hash.digest(), (byte) => byte.toString(16).padStart(2, "0")).join(""), size: state.size, read, close: () => file.close() };
+  } catch (error) {
+    await file.close();
+    throw error;
+  }
+}
+
+// packages/safe-bash-command-python/src/package-download.ts
+var serial = 0;
+async function stagePythonPackage(context, directory, body, maxBytes, progress, verify, publish) {
+  const { fs, signal } = context, settings = { signal };
+  const caps = await fs.capabilitiesFor?.(directory, settings) ?? fs.capabilities;
+  if (!caps.retainedStagingWrite || !caps.retainedStagingCleanup || !caps.retainedRead || !fs.createStagedFile || !fs.openReadFile || publish && (!caps.atomicFileStaging || !fs.publishStagedFile)) return void 0;
+  const parent = await fs.stat(directory, settings);
+  let stage;
+  for (let attempt = 0; attempt < 16; attempt++) {
+    try {
+      stage = await fs.createStagedFile(resolvePath(directory, ".python-package-" + ++serial), "wheel", { type: "file", data: new Uint8Array(0) }, { parent, mode: 384, retainCleanup: true, signal });
+      break;
+    } catch (error) {
+      signal.throwIfAborted();
+      if (!(error instanceof FsError) || error.code !== "EEXIST") throw error;
+    }
+  }
+  if (!stage) throw new Error("Python package staging names exhausted");
+  const owner = stage;
+  let artifact;
+  let closing;
+  const close = () => closing ??= (async () => {
+    try {
+      await artifact?.close();
+    } finally {
+      try {
+        await owner.cleanup?.remove();
+      } finally {
+        await owner.cleanup?.close();
+      }
+    }
+  })();
+  try {
+    if (!owner.cleanup || !owner.writer) throw new Error("Python package staging handles missing");
+    let count = 0;
+    const iterator = body[Symbol.asyncIterator]();
+    let ended = false;
+    try {
+      while (true) {
+        const next = await interruptible(Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return iterator.next();
+        }), signal);
+        signal.throwIfAborted();
+        if (next.done) {
+          ended = true;
+          break;
+        }
+        const bytes = next.value;
+        if (!(bytes instanceof Uint8Array)) throw new TypeError("Python package body must yield bytes");
+        if (count + bytes.length > maxBytes) throw new Error("Package download exceeds maxDownloadBytes");
+        for (let offset = 0; offset < bytes.length; offset += 65536) {
+          const chunk = Uint8Array.from(bytes.subarray(offset, offset + 65536));
+          await owner.writer.write(chunk, settings);
+          count += chunk.length;
+          await yieldTurn2(signal);
+        }
+        if (bytes.length) progress(count);
+      }
+    } finally {
+      if (!ended) {
+        const returned = Promise.resolve().then(() => iterator.return?.());
+        if (signal.aborted) void returned.catch(() => {
+        });
+        else await interruptible(returned, signal);
+      }
+    }
+    const stat = await owner.writer.finish(settings);
+    if (stat.size !== count) throw new Error("Python package staging size mismatch");
+    artifact = await openPythonPackageFile(context, owner.file.path, maxBytes, stat);
+    if (!artifact) throw new Error("Python package retained reads unavailable");
+    verify(artifact.key);
+    if (publish) {
+      const key = artifact.key, path = publish(key);
+      await artifact.close();
+      artifact = void 0;
+      let destination = null;
+      try {
+        destination = await fs.lstat(path, settings);
+      } catch (error) {
+        if (!(error instanceof FsError) || error.code !== "ENOENT") throw error;
+      }
+      await fs.publishStagedFile({ ...owner, file: { ...owner.file, stat } }, path, { parent, destination, signal });
+      artifact = await openPythonPackageFile(context, path, maxBytes);
+      if (!artifact || artifact.key !== key) throw new Error("Published Python package integrity mismatch");
+    }
+    return { ...artifact, close };
+  } catch (error) {
+    try {
+      await close();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], error instanceof Error ? error.message : "Python package download failed");
+    }
+    throw error;
+  }
+}
+
+// packages/safe-bash-command-python/src/provisioning.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import { resolvePath as resolve, dirname } from "../../safe-bash-contracts/path.js";
 import { inheritYieldCheckpoint } from "../../safe-bash-contracts/yield.js";
 
 // packages/safe-bash-command-python/src/manifest.ts
+function readPackageManifest(value) {
+  const strings = (values) => Array.isArray(values) && values.every((item) => typeof item === "string");
+  if (Array.isArray(value)) return strings(value) ? value : void 0;
+  if (!value || typeof value !== "object") return;
+  const record = value;
+  if (![1, 2].includes(record.version) || Object.keys(value).length !== record.version + 1) return;
+  if (record.version === 2 && (!Array.isArray(record.records) || !record.records.every((row) => Array.isArray(row) && row.length === 5 && row.every((part, index) => index < 3 ? typeof part === "string" : strings(part))))) return;
+  return strings(record.installed) ? record.installed : void 0;
+}
 var PythonPackageConflictError = class extends Error {
   code = "EPACKAGECONFLICT";
   retryable = true;
@@ -115,7 +271,12 @@ var pythonDocumentPackages = Object.freeze([
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 function digest(value) {
-  return Array.from(sha256(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return Array.from(sha2562(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function validDigest(value) {
+  if (typeof value !== "string" || value.length !== 64) return false;
+  for (const char of value) if (!"0123456789abcdef".includes(char)) return false;
+  return true;
 }
 function failure(message, cause) {
   return Object.assign(new Error(message, { cause }), { code: "EPACKAGE" });
@@ -140,35 +301,49 @@ function createPythonPackageEnvironment(options = {}) {
   const manifestKey = options.manifestStore ? pythonPackageRuntimeKey + "-environment-" + digest(encoder.encode(JSON.stringify(options.scope))) : pythonPackageRuntimeKey + "-environment";
   if (options.profile !== void 0 && options.profile !== "documents") throw new TypeError("Unknown Python package profile");
   const maxBytes = options.maxDownloadBytes ?? Infinity;
-  if (options.maxDownloadBytes !== void 0 && (!Number.isSafeInteger(maxBytes) || maxBytes < 1)) throw new RangeError("maxDownloadBytes must be a positive integer");
   const maxManifestBytes = options.maxManifestBytes ?? Infinity;
   const maxMetadataBytes = options.maxMetadataBytes ?? Infinity;
-  for (const name of ["maxManifestBytes", "maxMetadataBytes", "maxRequirementBytes"]) {
+  for (const name of ["maxDownloadBytes", "maxManifestBytes", "maxMetadataBytes", "maxRequirementBytes", "maxCacheBytes"]) {
     const value = options[name];
     if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`${name} must be a positive integer`);
   }
+  const cacheRecord = (key, headers) => {
+    const bytes = encoder.encode(JSON.stringify({ digest: key, headers }));
+    if (bytes.length > maxMetadataBytes) throw failure("Python package cache metadata exceeds maxMetadataBytes");
+    return bytes;
+  };
   const maxCacheBytes = options.maxCacheBytes;
-  if (maxCacheBytes !== void 0 && (!Number.isSafeInteger(maxCacheBytes) || maxCacheBytes < 1)) throw new RangeError("maxCacheBytes must be a positive integer");
   const defaultCache = createPythonPackageCache(maxCacheBytes === void 0 ? {} : { maxBytes: maxCacheBytes });
   const sessions = /* @__PURE__ */ new Map();
   const controller = new AbortController();
   const pending = /* @__PURE__ */ new Set();
-  let disposed = false;
-  let disposing;
-  const admit = (operation) => (...args) => {
-    if (disposed) return Promise.reject(failure("Python package environment is disposed"));
-    const work = Promise.resolve().then(() => {
-      if (disposed) throw failure("Python package environment is disposed");
-      return operation(...args);
-    });
+  let cleanupFailure;
+  const track = (work, cleanup = false) => {
     pending.add(work);
-    void work.then(() => {
-      pending.delete(work);
-    }, () => {
+    void work.then(() => pending.delete(work), (error) => {
+      if (cleanup) cleanupFailure ??= { error };
       pending.delete(work);
     });
     return work;
   };
+  function release(session, all = false) {
+    const artifacts = all ? [...session.retained.values()] : [];
+    if (all) session.retained.clear();
+    if (session.opened) {
+      artifacts.push(session.opened);
+      session.opened = void 0;
+    }
+    if (!artifacts.length) return session.retiring ?? Promise.resolve();
+    return track(session.retiring = Promise.allSettled([session.retiring, ...artifacts.map((artifact) => Promise.resolve().then(() => artifact.close?.()))]).then((results) => {
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    }), true);
+  }
+  let disposed = false;
+  let disposing;
+  const admit = (operation) => (...args) => track(Promise.resolve().then(() => {
+    if (disposed) throw failure("Python package environment is disposed");
+    return operation(...args);
+  }));
   let counter = 0;
   let committing = Promise.resolve();
   async function prepare(input) {
@@ -176,20 +351,20 @@ function createPythonPackageEnvironment(options = {}) {
     const signal = AbortSignal.any([input.signal, controller.signal, invocation.signal]);
     inheritYieldCheckpoint(input.signal, signal);
     const context = { ...input, signal };
-    context.signal.throwIfAborted();
+    signal.throwIfAborted();
     const directory = options.cacheDirectory === void 0 ? void 0 : resolve(context.cwd, options.cacheDirectory, pythonPackageRuntimeKey);
     const cache = options.cache ?? (directory === void 0 ? defaultCache : {
       async get(key) {
         try {
-          return await context.fs.readFile(resolve(directory, key), { signal: context.signal });
+          return await context.fs.readFile(resolve(directory, key), { signal });
         } catch (error) {
           if (missing(error)) return void 0;
           throw error;
         }
       },
       async set(key, bytes) {
-        await context.fs.mkdir(directory, { recursive: true, signal: context.signal });
-        await context.fs.writeFile(resolve(directory, key), bytes, { signal: context.signal });
+        await context.fs.mkdir(directory, { recursive: true, signal });
+        await context.fs.writeFile(resolve(directory, key), bytes, { signal });
       }
     });
     const manifestCache = options.cacheDirectory === void 0 ? defaultCache : cache;
@@ -198,15 +373,15 @@ function createPythonPackageEnvironment(options = {}) {
       try {
         snapshot = await options.manifestStore.get(manifestKey, context);
       } catch (error) {
-        context.signal.throwIfAborted();
+        signal.throwIfAborted();
         throw failure("Cannot read Python package environment manifest", error);
       }
     }
-    context.signal.throwIfAborted();
+    signal.throwIfAborted();
     if (snapshot !== void 0 && (typeof snapshot !== "object" || snapshot === null || typeof snapshot.revision !== "string" || !snapshot.revision || snapshot.revision.length > 1024 || !(snapshot.bytes instanceof Uint8Array))) throw failure("Invalid Python package manifest snapshot");
     const manifestRevision = snapshot?.revision;
     const stored = options.manifestStore ? snapshot?.bytes : await manifestCache.get(manifestKey);
-    context.signal.throwIfAborted();
+    signal.throwIfAborted();
     if (stored && stored.length > maxManifestBytes) throw failure("Python package manifest exceeds maxManifestBytes");
     const manifest = stored === void 0 ? "" : decoder.decode(stored);
     let previous;
@@ -215,15 +390,18 @@ function createPythonPackageEnvironment(options = {}) {
     } catch {
       throw failure("Invalid Python package environment manifest");
     }
-    if (!Array.isArray(previous) || previous.some((value) => typeof value !== "string")) throw failure("Invalid Python package environment manifest");
-    const requirements = [...previous, ...options.profile === "documents" ? pythonDocumentPackages : [], ...options.requirements ?? [], ...context.requirements ?? []].map((value) => normalizeRequirement(value, context.cwd));
+    const saved = readPackageManifest(previous);
+    if (!saved) throw failure("Invalid Python package environment manifest");
+    const legacy = Array.isArray(previous);
+    const restore = saved.map((value) => normalizeRequirement(value, context.cwd));
+    const requirements = [...options.profile === "documents" ? pythonDocumentPackages : [], ...options.requirements ?? [], ...context.requirements ?? []].map((value) => normalizeRequirement(value, context.cwd));
     for (const file of [...options.requirementFiles ?? [], ...context.requirementFiles ?? []]) {
       const path = resolve(context.cwd, file);
       let source;
       try {
-        source = decoder.decode(await context.fs.readFile(path, { signal: context.signal, ...options.maxRequirementBytes === void 0 ? {} : { maxBytes: options.maxRequirementBytes } }));
+        source = decoder.decode(await context.fs.readFile(path, { signal, ...options.maxRequirementBytes === void 0 ? {} : { maxBytes: options.maxRequirementBytes } }));
       } catch (error) {
-        context.signal.throwIfAborted();
+        signal.throwIfAborted();
         throw failure(`Cannot read Python requirements ${path}: ${error instanceof Error ? error.message : String(error)}`);
       }
       for (const line of source.split("\n")) {
@@ -234,20 +412,23 @@ function createPythonPackageEnvironment(options = {}) {
         requirements.push(normalizeRequirement(text, dirname(path)));
       }
     }
-    context.signal.throwIfAborted();
+    const requested = [...new Set(await options.prepareRequirements?.(requirements, context) ?? requirements)];
+    signal.throwIfAborted();
     const session = String(++counter);
-    const unique = [...new Set(requirements)];
+    const unique = [.../* @__PURE__ */ new Set([...restore, ...requested])];
     const aborted = () => {
       const current = sessions.get(session);
       if (current) {
         current.closed = true;
-        current.opened.clear();
+        void release(current, true);
       }
-      sessions.delete(session);
     };
-    sessions.set(session, { ...context, cache, manifestCache, manifestRevision, controller: invocation, offline: context.offline ?? options.offline ?? false, requirements: unique, opened: /* @__PURE__ */ new Map(), opening: false, closed: false, manifest, aborted });
-    context.signal.addEventListener("abort", aborted, { once: true });
-    return { session, requirements: unique, offline: context.offline ?? options.offline ?? false };
+    const offline = context.offline ?? options.offline ?? false;
+    sessions.set(session, { ...context, cacheDirectory: directory, noCache: context.noCache ?? options.noCache ?? false, cache, manifestCache, manifestRevision, controller: invocation, offline, requirements: unique, opening: false, retained: /* @__PURE__ */ new Map(), closed: false, manifest, aborted });
+    signal.addEventListener("abort", aborted, { once: true });
+    const controls = {};
+    for (const key of ["pre", "upgrade", "forceReinstall"]) if (context[key] ?? options[key]) controls[key] = true;
+    return { session, requirements: unique, restore, requested, legacy, records: previous.records, ...controls, ...input.uninstall ? { uninstall: input.uninstall } : {}, offline };
   }
   async function dispatch(op, args, _context) {
     _context.signal.throwIfAborted();
@@ -255,10 +436,13 @@ function createPythonPackageEnvironment(options = {}) {
     if (!session) throw failure("Python package session is closed");
     checkSession(session);
     if (op === "package-commit") {
+      await release(session, true);
+      checkSession(session);
       const pinned = args[1];
-      if (!Array.isArray(pinned) || pinned.some((value) => typeof value !== "string")) throw failure("Invalid installed package manifest");
-      const merged = [.../* @__PURE__ */ new Set([...session.requirements, ...pinned])];
-      const manifestBytes = encoder.encode(JSON.stringify(merged));
+      const saved = readPackageManifest(pinned);
+      if (!saved) throw failure("Invalid installed package manifest");
+      const state = Array.isArray(pinned) ? [.../* @__PURE__ */ new Set([...session.requirements, ...saved])] : { ...pinned, installed: [...new Set(saved)] };
+      const manifestBytes = encoder.encode(JSON.stringify(state));
       if (manifestBytes.length > maxManifestBytes) throw failure("Python package manifest exceeds maxManifestBytes");
       const commit = committing.then(async () => {
         checkSession(session);
@@ -282,46 +466,86 @@ function createPythonPackageEnvironment(options = {}) {
       options.onProgress?.({ phase: "installed" });
       return null;
     }
-    if (op === "package-read") {
-      const bytes = session.opened.get(String(args[1]));
-      const offset = args[2];
-      const length = args[3];
-      if (!bytes || !Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 1 || length > 65536) throw failure("Invalid package chunk request");
-      return Array.from(bytes.subarray(offset, offset + length));
+    if (op === "package-read" || op === "package-read-retained") {
+      const artifact = op === "package-read" ? session.opened : session.retained.get(String(args[1])), offset = args[2], length = args[3];
+      if (!artifact || op === "package-read" && artifact.key !== String(args[1]) || !Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 1 || length > 65536) throw failure("Invalid package chunk request");
+      const bytes = await artifact.read(offset, length);
+      checkSession(session);
+      return Array.from(bytes);
+    }
+    if (op === "package-retain") {
+      const artifact = session.opened;
+      if (!artifact || artifact.key !== String(args[1])) throw failure("Invalid package retention request");
+      const token = String(++counter);
+      session.retained.set(token, artifact);
+      session.opened = void 0;
+      return { token, key: artifact.key, size: artifact.size };
     }
     if (op === "package-close") {
-      session.opened.delete(String(args[1]));
+      if (session.opened?.key === String(args[1])) await release(session);
       return null;
     }
     if (op !== "package-open" || typeof args[1] !== "string") throw failure("Invalid package operation");
     if (session.opening) throw failure("Package download already in progress");
     session.opening = true;
-    session.opened.clear();
     try {
+      await release(session);
+      checkSession(session);
       const url = args[1];
       const expected = args[2];
-      if (expected !== void 0 && expected !== null && (typeof expected !== "string" || expected.length !== 64 || Array.from(expected).some((c) => !"0123456789abcdef".includes(c)))) throw failure("Invalid SHA-256 package integrity value");
+      const verifyIntegrity = (key2) => {
+        if (expected && key2 !== expected) throw failure(`Package integrity mismatch: ${url}`);
+      };
+      if (expected !== void 0 && expected !== null && !validDigest(expected)) throw failure("Invalid SHA-256 package integrity value");
       const address = pythonPackageRuntimeKey + "-url-" + digest(encoder.encode(url));
       const canonicalWheel = url.startsWith("file:") || url.startsWith("emfs:");
-      const metadata = canonicalWheel ? void 0 : await session.cache.get(address);
+      const metadata = canonicalWheel || session.noCache || args[3] === "metadata" && !session.offline ? void 0 : await session.cache.get(address);
       checkSession(session);
-      let bytes;
+      let key = "", bytes;
       let headers = [];
+      const adopt = async (artifact, ready) => {
+        session.opened = artifact;
+        try {
+          checkSession(session);
+          await ready();
+          checkSession(session);
+          return { key: artifact.key, size: artifact.size, headers };
+        } catch (error) {
+          await release(session);
+          throw error;
+        }
+      };
       if (metadata) {
         if (metadata.length > maxMetadataBytes) throw failure("Python package cache metadata exceeds maxMetadataBytes");
         let record;
         try {
           record = JSON.parse(decoder.decode(metadata));
         } catch {
-          throw failure(`Invalid package cache metadata: ${url}`);
         }
-        if (typeof record !== "object" || record === null || typeof record.digest !== "string" || record.digest.length !== 64 || Array.from(record.digest).some((char) => !"0123456789abcdef".includes(char)) || !Array.isArray(record.headers) || record.headers.some((pair) => !Array.isArray(pair) || pair.length !== 2 || pair.some((value) => typeof value !== "string"))) throw failure(`Invalid package cache metadata: ${url}`);
-        bytes = await session.cache.get(pythonPackageRuntimeKey + "-sha256-" + record.digest);
+        if (typeof record !== "object" || record === null || !validDigest(record.digest) || !Array.isArray(record.headers) || record.headers.some((pair) => !Array.isArray(pair) || pair.length !== 2 || pair.some((value2) => typeof value2 !== "string"))) throw failure(`Invalid package cache metadata: ${url}`);
         headers = record.headers;
+        let absent = false;
+        if (session.cacheDirectory) {
+          let artifact;
+          try {
+            artifact = await openPythonPackageFile(session, resolve(session.cacheDirectory, pythonPackageRuntimeKey + "-sha256-" + record.digest), maxBytes);
+          } catch (error) {
+            if (!missing(error)) throw error;
+            absent = true;
+          }
+          if (artifact) {
+            return await adopt(artifact, () => {
+              if (artifact.key !== record.digest) throw failure(`Package cache integrity mismatch: ${url}`);
+              verifyIntegrity(artifact.key);
+              options.onProgress?.({ phase: "cached", url, bytes: artifact.size });
+            });
+          }
+        }
+        bytes = absent ? void 0 : await session.cache.get(pythonPackageRuntimeKey + "-sha256-" + record.digest);
         checkSession(session);
         if (bytes && bytes.length > maxBytes) throw failure("Cached package exceeds maxDownloadBytes");
         if (bytes) bytes = Uint8Array.from(bytes);
-        if (bytes && digest(bytes) !== record.digest) throw failure(`Package cache integrity mismatch: ${url}`);
+        if (bytes && (key = digest(bytes)) !== record.digest) throw failure(`Package cache integrity mismatch: ${url}`);
         if (bytes) options.onProgress?.({ phase: "cached", url, bytes: bytes.length });
       }
       if (!bytes) {
@@ -329,7 +553,11 @@ function createPythonPackageEnvironment(options = {}) {
           const path = new URL(url);
           if (path.host && path.host !== "localhost") throw failure("Local wheels must use the canonical filesystem");
           try {
-            bytes = await session.fs.readFile(decodeURIComponent(path.pathname), { signal: session.signal, ...Number.isFinite(maxBytes) ? { maxBytes } : {} });
+            const artifact = await openPythonPackageFile(session, decodeURIComponent(path.pathname), maxBytes);
+            if (artifact) {
+              return await adopt(artifact, () => verifyIntegrity(artifact.key));
+            }
+            bytes = Uint8Array.from(await session.fs.readFile(decodeURIComponent(path.pathname), { signal: session.signal, ...Number.isFinite(maxBytes) ? { maxBytes } : {} }));
           } catch (error) {
             checkSession(session);
             throw failure(`Cannot read canonical Python wheel ${path.pathname}: ${error instanceof Error ? error.message : String(error)}`);
@@ -367,6 +595,29 @@ function createPythonPackageEnvironment(options = {}) {
               const length = headers.find(([key2]) => key2.toLowerCase() === "content-length")?.[1];
               const total = length === void 0 || encoding !== void 0 && encoding !== "identity" ? void 0 : Number(length);
               if (total !== void 0 && Number.isFinite(total) && total > maxBytes) throw failure("Package download exceeds maxDownloadBytes");
+              const progress = (count2) => options.onProgress?.({ phase: "download", url, bytes: count2, ...typeof total === "number" && Number.isSafeInteger(total) ? { totalBytes: total } : {} });
+              if (session.cacheDirectory || session.noCache) {
+                const directory = session.cacheDirectory ?? session.cwd;
+                if (session.cacheDirectory) await session.fs.mkdir(directory, { recursive: true, signal: session.signal });
+                let metadataBytes;
+                const artifact = await stagePythonPackage(
+                  session,
+                  directory,
+                  response.body,
+                  maxBytes,
+                  progress,
+                  (key2) => {
+                    verifyIntegrity(key2);
+                    if (!session.noCache) metadataBytes = cacheRecord(key2, headers);
+                  },
+                  session.noCache ? void 0 : (key2) => resolve(directory, pythonPackageRuntimeKey + "-sha256-" + key2)
+                );
+                if (artifact) {
+                  return await adopt(artifact, async () => {
+                    if (!session.noCache) await session.cache.set(address, metadataBytes);
+                  });
+                }
+              }
               const chunks = [];
               let count = 0;
               for await (const chunk of response.body) {
@@ -375,7 +626,7 @@ function createPythonPackageEnvironment(options = {}) {
                 count += chunk.length;
                 if (count > maxBytes) throw failure("Package download exceeds maxDownloadBytes");
                 chunks.push(Uint8Array.from(chunk));
-                options.onProgress?.({ phase: "download", url, bytes: count, ...typeof total === "number" && Number.isSafeInteger(total) ? { totalBytes: total } : {} });
+                progress(count);
               }
               bytes = new Uint8Array(count);
               let offset = 0;
@@ -390,19 +641,18 @@ function createPythonPackageEnvironment(options = {}) {
           }
         }
         checkSession(session);
-        if (expected && digest(bytes) !== expected) throw failure(`Package integrity mismatch: ${url}`);
-        const hash = digest(bytes);
-        const metadataBytes = encoder.encode(JSON.stringify({ digest: hash, headers }));
-        if (metadataBytes.length > maxMetadataBytes) throw failure("Python package cache metadata exceeds maxMetadataBytes");
-        await session.cache.set(pythonPackageRuntimeKey + "-sha256-" + hash, Uint8Array.from(bytes));
-        checkSession(session);
-        if (!canonicalWheel) await session.cache.set(address, metadataBytes);
-        checkSession(session);
+        verifyIntegrity(key = digest(bytes));
+        if (!session.noCache) {
+          const metadataBytes = cacheRecord(key, headers);
+          await session.cache.set(pythonPackageRuntimeKey + "-sha256-" + key, Uint8Array.from(bytes));
+          checkSession(session);
+          if (!canonicalWheel) await session.cache.set(address, metadataBytes);
+        }
       }
       checkSession(session);
-      if (expected && digest(bytes) !== expected) throw failure(`Package integrity mismatch: ${url}`);
-      const key = digest(bytes);
-      session.opened.set(key, bytes);
+      verifyIntegrity(key);
+      const value = bytes;
+      session.opened = { key, size: bytes.length, read: (offset, length) => value.subarray(offset, offset + length) };
       return { key, size: bytes.length, headers };
     } finally {
       session.opening = false;
@@ -415,11 +665,11 @@ function createPythonPackageEnvironment(options = {}) {
       const session = sessions.get(start.session);
       if (session) {
         session.closed = true;
-        session.opened.clear();
         session.signal.removeEventListener("abort", session.aborted);
         session.controller.abort(failure("Python package session is closed"));
+        sessions.delete(start.session);
+        return release(session, true);
       }
-      sessions.delete(start.session);
     },
     dispose() {
       if (!disposing) {
@@ -428,6 +678,7 @@ function createPythonPackageEnvironment(options = {}) {
         disposing = Promise.allSettled([...pending]).then(() => {
           sessions.clear();
           defaultCache.dispose();
+          if (cleanupFailure) throw cleanupFailure.error;
         });
       }
       return disposing;
@@ -436,6 +687,8 @@ function createPythonPackageEnvironment(options = {}) {
 }
 
 export {
+  openPythonPackageFile,
+  stagePythonPackage,
   PythonPackageConflictError,
   createPythonPackageManifestStore,
   createPythonPackageCache,

package/dist/safe-bash/command-chunks/{chunk-GQV5RWMN.js → chunk-ZFXHSFTU.js}

@@ -1,6 +1,6 @@
 import {
   sourceBytes
-} from "./chunk-QX3WKBLI.js";
+} from "./chunk-36FV6BAG.js";
 
 // packages/safe-bash-command-llm/src/base64-stream.ts
 async function* base64Stream(source, signal) {

package/dist/safe-bash/command-chunks/{prompt-tool-debug-ERJKK3XZ.js → prompt-tool-debug-3POFNRYP.js}

@@ -2,22 +2,22 @@ import {
   EmptyJsonDocumentError,
   indentLlmText,
   withEmbeddingJsonDocument
-} from "./chunk-I7MEH76L.js";
+} from "./chunk-UYNJF5QN.js";
 import {
   pythonRepr
-} from "./chunk-MCUDSE4H.js";
+} from "./chunk-EWECMOQ5.js";
 import {
   createLlmSpool,
   floatText
-} from "./chunk-BZLLQWRK.js";
+} from "./chunk-E5CDHXFA.js";
 import "./chunk-3PO534WJ.js";
 import {
   attachmentDigestHex,
   getLlmAttachmentUrlId
 } from "./chunk-B74LVFAN.js";
-import "./chunk-GQV5RWMN.js";
+import "./chunk-ZFXHSFTU.js";
 import "./chunk-B6NAEWHC.js";
-import "./chunk-QX3WKBLI.js";
+import "./chunk-36FV6BAG.js";
 import "./chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-llm/src/prompt-tool-debug.ts

package/dist/safe-bash/commands/bc/index.browser.js

@@ -4,7 +4,7 @@ import {
   createBcCommands,
   settings
 } from "../../chunks/chunk-Q6XBTX6G.js";
-import "../../chunks/chunk-IRJS54AA.js";
+import "../../chunks/chunk-VWLQDZFF.js";
 import "../../chunks/chunk-N4CQ5E3G.js";
 import "../../chunks/chunk-EDJBO2HZ.js";
 import "../../chunks/chunk-IMOFLK26.js";

package/dist/safe-bash/commands/llm/index.browser.js

@@ -1,5 +1,6 @@
 import {
   LlmCancelToolCall,
+  LlmLoaderLookupError,
   createElevenLabsProvider,
   createLlmCommand,
   createLlmCommands,
@@ -39,9 +40,10 @@ import {
   templateYaml,
   validateLlmTemplateParameters,
   validateModelOptions
-} from "../../chunks/chunk-HNT2MR4W.js";
+} from "../../chunks/chunk-363QOIDR.js";
 export {
   LlmCancelToolCall,
+  LlmLoaderLookupError,
   createElevenLabsProvider,
   createLlmCommand,
   createLlmCommands,

package/dist/safe-bash/commands/llm/index.js

@@ -1,2 +1,2 @@
-export { "LlmCancelToolCall", "createElevenLabsProvider", "createLlmCommand", "createLlmCommands", "createLlmConfiguration", "createLlmFragmentLoaders", "createLlmFragmentSource", "createLlmInputBudget", "createLlmService", "createLlmSpool", "createLlmTemplateStore", "createLlmToolRegistry", "createLlmUrlFragmentSource", "createLlmUrlSource", "createOpenAiProvider", "encodeLlmBase64", "evaluateLlmTemplate", "executeLlmToolCalls", "findExtractedRange", "getLlmAttachmentUrlId", "getLlmFragmentPrefix", "getLlmModelAliases", "llmCommands", "llmReferenceVersion", "llmTemplateUsesInput", "loadLlmPluginFragments", "openAiChatOptions", "parseLlmSchemaDsl", "resolveLlmSchemaInput", "resolveLlmUrlAttachment", "selectLlmModelByQuery", "selectLlmTools", "serializeLlmJsonString", "serializeLlmJsonValue", "serializeLlmTokenUsage", "serializeOpenAiChatRequest", "streamLlmToolChain", "templateYaml", "validateLlmTemplateParameters", "validateModelOptions" } from "../../../safe-bash-command-llm/index.js";
+export { "LlmCancelToolCall", "LlmLoaderLookupError", "createElevenLabsProvider", "createLlmCommand", "createLlmCommands", "createLlmConfiguration", "createLlmFragmentLoaders", "createLlmFragmentSource", "createLlmInputBudget", "createLlmService", "createLlmSpool", "createLlmTemplateStore", "createLlmToolRegistry", "createLlmUrlFragmentSource", "createLlmUrlSource", "createOpenAiProvider", "encodeLlmBase64", "evaluateLlmTemplate", "executeLlmToolCalls", "findExtractedRange", "getLlmAttachmentUrlId", "getLlmFragmentPrefix", "getLlmModelAliases", "llmCommands", "llmReferenceVersion", "llmTemplateUsesInput", "loadLlmPluginFragments", "openAiChatOptions", "parseLlmSchemaDsl", "resolveLlmSchemaInput", "resolveLlmUrlAttachment", "selectLlmModelByQuery", "selectLlmTools", "serializeLlmJsonString", "serializeLlmJsonValue", "serializeLlmTokenUsage", "serializeOpenAiChatRequest", "streamLlmToolChain", "templateYaml", "validateLlmTemplateParameters", "validateModelOptions" } from "../../../safe-bash-command-llm/index.js";
 //# sourceMappingURL=index.js.map