@poe-platform/safe-bash 0.1.822 → 0.1.824

package/dist/safe-bash/command-chunks/{chunk-2E53ZL5D.js → chunk-HU72CZBN.js}

@@ -1,6 +1,6 @@
 import {
   openRetainedPresentationIndex
-} from "./chunk-LZHFVNEV.js";
+} from "./chunk-S3QYSI5E.js";
 import {
   stageRetainedOutput,
   streamJson
@@ -13,14 +13,14 @@ import {
   loadShared,
   nextRel,
   relPart
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError,
   decodeSelectionToken
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   openRetainedPresentationValidation
-} from "./chunk-SKDJCMGI.js";
+} from "./chunk-ATUZ7J3B.js";
 import {
   dialects
 } from "./chunk-P3LHQOX7.js";

package/dist/safe-bash/command-chunks/{chunk-AH3ZEPAN.js → chunk-IGHFIRXK.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-DMOWQSKN.js";
 import {
   readPlaywrightStorageState
-} from "./chunk-3TP4SSPS.js";
+} from "./chunk-SRXARACJ.js";
 import {
   parsePlaywrightStorageState
 } from "./chunk-YMZQFL3O.js";

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

@@ -1,9 +1,123 @@
+import {
+  openPythonPackageFile
+} from "./chunk-NXCJNPL3.js";
+
+// 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 } from "../../safe-bash-contracts/yield.js";
+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 yieldTurn(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 } 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, version = record.version;
+  if (![1, 2, 3].includes(version) || Object.keys(value).length !== (version === 1 ? 2 : 3)) return;
+  if (version !== 1 && (!Array.isArray(record.records) || !record.records.every((row) => Array.isArray(row) && row.length === version + 3 && row.every((part, index) => index > 2 && index < 5 ? strings(part) : typeof part === "string" || index === 5 && part === null)))) return;
+  return strings(record.installed) ? record.installed : void 0;
+}
 var PythonPackageConflictError = class extends Error {
   code = "EPACKAGECONFLICT";
   retryable = true;
@@ -117,6 +231,11 @@ var decoder = new TextDecoder();
 function digest(value) {
   return Array.from(sha256(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 +259,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, url) => {
+    const bytes = encoder.encode(JSON.stringify({ digest: key, headers, url }));
+    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 +309,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 +331,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,39 +348,47 @@ 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")) {
-        const comment = line.split("").findIndex((character, index) => character === "#" && (index === 0 || line[index - 1].trim() === ""));
+        let comment = line.indexOf("#");
+        while (comment > 0 && line[comment - 1].trim()) comment = line.indexOf("#", comment + 1);
         const text = (comment < 0 ? line : line.slice(0, comment)).trim();
         if (!text) continue;
-        if (text.endsWith("\\") || text.startsWith("-")) throw failure(`Unsupported requirements option or continuation in ${path}: ${text}`);
-        requirements.push(normalizeRequirement(text, dirname(path)));
+        if (text.endsWith("\\")) throw failure(`Unsupported requirements continuation in ${path}: ${text}`);
+        requirements.push(text[0] === "-" && options.prepareRequirements ? text : normalizeRequirement(text, dirname(path)));
       }
     }
-    context.signal.throwIfAborted();
+    if ((options.editable?.length || context.editable?.length) && !options.prepareRequirements) throw failure("Editable packages require a source package environment");
+    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 +396,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 +426,88 @@ 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 {
-      const url = args[1];
+      await release(session);
+      checkSession(session);
+      const url = args[1], { cacheDirectory, noCache } = session;
       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");
+      let responseUrl = url;
+      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 || 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, url: responseUrl };
+        } 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) || record.url !== void 0 && typeof record.url !== "string" || !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;
+        responseUrl = record.url ?? url;
+        let absent = false;
+        if (cacheDirectory) {
+          let artifact;
+          try {
+            artifact = await openPythonPackageFile(session, resolve(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 +515,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)}`);
@@ -363,10 +553,34 @@ function createPythonPackageEnvironment(options = {}) {
               }
               if (response.status < 200 || response.status >= 300) throw failure(`Package download failed: HTTP ${response.status} ${current.href}`);
               headers = response.headers;
+              responseUrl = current.href;
               const encoding = headers.find(([key2]) => key2.toLowerCase() === "content-encoding")?.[1].trim().toLowerCase();
               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 (cacheDirectory || noCache) {
+                const directory = cacheDirectory ?? session.cwd;
+                if (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 (!noCache) metadataBytes = cacheRecord(key2, headers, responseUrl);
+                  },
+                  noCache ? void 0 : (key2) => resolve(directory, pythonPackageRuntimeKey + "-sha256-" + key2)
+                );
+                if (artifact) {
+                  return await adopt(artifact, async () => {
+                    if (!noCache) await session.cache.set(address, metadataBytes);
+                  });
+                }
+              }
               const chunks = [];
               let count = 0;
               for await (const chunk of response.body) {
@@ -375,7 +589,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,20 +604,19 @@ 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 (!noCache) {
+          const metadataBytes = cacheRecord(key, headers, responseUrl);
+          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);
-      return { key, size: bytes.length, headers };
+      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, url: responseUrl };
     } finally {
       session.opening = false;
     }
@@ -415,11 +628,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 +641,7 @@ function createPythonPackageEnvironment(options = {}) {
         disposing = Promise.allSettled([...pending]).then(() => {
           sessions.clear();
           defaultCache.dispose();
+          if (cleanupFailure) throw cleanupFailure.error;
         });
       }
       return disposing;
@@ -436,6 +650,7 @@ function createPythonPackageEnvironment(options = {}) {
 }
 
 export {
+  stagePythonPackage,
   PythonPackageConflictError,
   createPythonPackageManifestStore,
   createPythonPackageCache,

package/dist/safe-bash/command-chunks/{chunk-J3ISXTYB.js → chunk-JTEAYB72.js}

@@ -12,10 +12,10 @@ import {
   relPart,
   required,
   unique
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   parseXmlPart
 } from "./chunk-YWP62BAZ.js";

package/dist/safe-bash/command-chunks/{chunk-NR7POLKP.js → chunk-KCS25XUJ.js}

@@ -1,10 +1,10 @@
 import {
   dashPresets,
   patternPresets
-} from "./chunk-NDJPULBE.js";
+} from "./chunk-CEKBIZGU.js";
 import {
   themeColorSlots
-} from "./chunk-75OUKYCM.js";
+} from "./chunk-CH5JDE3C.js";
 
 // packages/safe-bash-presentation-engine/src/drawing-schema.ts
 var ratio = { type: "number", minimum: 0, maximum: 1 };