@poe-platform/safe-bash 0.1.656 → 0.1.658

package/dist/safe-bash/chunks/{chunk-43HWIHXB.js → chunk-Z4UKD5FF.js}

@@ -917,6 +917,96 @@ var sha384 = /* @__PURE__ */ createHasher(
   /* @__PURE__ */ oidNist(2)
 );
 
+// packages/safe-bash/src/commands/python/manifest.ts
+init_platform();
+var PythonPackageConflictError = class extends Error {
+  code = "EPACKAGECONFLICT";
+  retryable = true;
+  constructor() {
+    super("Python package environment changed during installation; retry the command");
+    this.name = "PythonPackageConflictError";
+  }
+};
+function createPythonPackageManifestStore(options = {}) {
+  const maxBytes = options.maxBytes ?? 1048576;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new RangeError("Python manifest maxBytes must be a positive integer");
+  const manifests = /* @__PURE__ */ new Map();
+  let retainedBytes = 0;
+  let revision = 0;
+  let disposed = false;
+  const check = (scope, signal) => {
+    signal.throwIfAborted();
+    if (disposed) throw new Error("Python manifest store is disposed");
+    if (typeof scope !== "string" || !scope || scope.length > 1024) throw new TypeError("Invalid Python manifest scope");
+  };
+  return {
+    async get(scope, { signal }) {
+      check(scope, signal);
+      const value = manifests.get(scope);
+      return value ? { revision: value.revision, bytes: value.bytes.slice() } : void 0;
+    },
+    async compareAndSet(scope, expected, bytes, { signal }) {
+      check(scope, signal);
+      const current = manifests.get(scope);
+      if (current?.revision !== expected) return false;
+      if (!(bytes instanceof Uint8Array)) throw new TypeError("Python manifest must contain bytes");
+      const nextBytes = retainedBytes - (current?.bytes.length ?? 0) + bytes.length;
+      if (nextBytes > maxBytes || !current && manifests.size >= 1024 || revision >= Number.MAX_SAFE_INTEGER) {
+        throw new RangeError("Python manifest store budget exhausted");
+      }
+      manifests.set(scope, { revision: String(++revision), bytes: Uint8Array.from(bytes) });
+      retainedBytes = nextBytes;
+      return true;
+    },
+    dispose() {
+      disposed = true;
+      manifests.clear();
+      retainedBytes = 0;
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/python/cache.ts
+init_platform();
+var pythonPackageRuntimeKey = "pyodide-314.0.6-cp314-emscripten-wasm32-v1";
+function createPythonPackageCache(options = {}) {
+  const maxBytes = options.maxBytes ?? 128 * 1024 * 1024;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new RangeError("Python cache maxBytes must be a positive integer");
+  const values = /* @__PURE__ */ new Map();
+  const manifestKey = pythonPackageRuntimeKey + "-environment";
+  let retainedBytes = 0;
+  let disposed = false;
+  return {
+    async get(key) {
+      if (disposed) throw new Error("Python package cache is disposed");
+      return values.get(key)?.slice();
+    },
+    async set(key, bytes) {
+      if (disposed) throw new Error("Python package cache is disposed");
+      if (key === manifestKey && bytes.length > maxBytes) throw new RangeError("Python package manifest exceeds maxCacheBytes");
+      const previous = values.get(key);
+      if (previous) {
+        retainedBytes -= previous.length;
+        values.delete(key);
+      }
+      if (bytes.length > maxBytes) return;
+      while (values.size && (retainedBytes + bytes.length > maxBytes || values.size >= 1024)) {
+        const oldest = [...values.keys()].find((entry) => entry !== manifestKey);
+        if (oldest === void 0) return;
+        retainedBytes -= values.get(oldest).length;
+        values.delete(oldest);
+      }
+      values.set(key, Uint8Array.from(bytes));
+      retainedBytes += bytes.length;
+    },
+    dispose() {
+      disposed = true;
+      values.clear();
+      retainedBytes = 0;
+    }
+  };
+}
+
 // packages/safe-bash/src/commands/python/provisioning.ts
 var pythonDocumentPackages = Object.freeze([
   "lxml==6.0.2",
@@ -933,12 +1023,11 @@ var pythonDocumentPackages = Object.freeze([
 ]);
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
-var runtimeKey = "pyodide-314.0.6-cp314-emscripten-wasm32-v1";
 function digest(value) {
   return Array.from(sha256(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function failure(message) {
-  return Object.assign(new Error(message), { code: "EPACKAGE" });
+function failure(message, cause) {
+  return Object.assign(new Error(message, { cause }), { code: "EPACKAGE" });
 }
 function missing(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -955,42 +1044,43 @@ function checkSession(session) {
 }
 function createPythonPackageEnvironment(options = {}) {
   if (options.cache && options.cacheDirectory) throw new TypeError("Choose package cache or cacheDirectory, not both");
+  if (options.manifestStore && (typeof options.scope !== "string" || !options.scope.trim() || options.scope.length > 1024)) throw new TypeError("Shared Python manifests require an explicit nonempty scope");
+  if (options.scope !== void 0 && !options.manifestStore) throw new TypeError("Python scope requires a manifestStore");
+  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 ?? 64 * 1024 * 1024;
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new RangeError("maxDownloadBytes must be a positive integer");
   const maxCacheBytes = options.maxCacheBytes ?? 128 * 1024 * 1024;
   if (!Number.isSafeInteger(maxCacheBytes) || maxCacheBytes < 1) throw new RangeError("maxCacheBytes must be a positive integer");
-  const memory = /* @__PURE__ */ new Map();
-  let memoryBytes = 0;
-  const defaultCache = {
-    async get(key) {
-      return memory.get(key)?.slice();
-    },
-    async set(key, value) {
-      const manifestKey = runtimeKey + "-environment";
-      if (key === manifestKey && value.length > maxCacheBytes) throw failure("Python package manifest exceeds maxCacheBytes");
-      const previous = memory.get(key);
-      if (previous) {
-        memoryBytes -= previous.length;
-        memory.delete(key);
-      }
-      if (value.length > maxCacheBytes) return;
-      while (memory.size && (memoryBytes + value.length > maxCacheBytes || memory.size >= 1024)) {
-        const oldest = Array.from(memory.keys()).find((entry) => entry !== manifestKey);
-        if (oldest === void 0) return;
-        memoryBytes -= memory.get(oldest).length;
-        memory.delete(oldest);
-      }
-      memory.set(key, value.slice());
-      memoryBytes += value.length;
-    }
-  };
+  const defaultCache = createPythonPackageCache({ 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);
+    });
+    pending.add(work);
+    void work.then(() => {
+      pending.delete(work);
+    }, () => {
+      pending.delete(work);
+    });
+    return work;
+  };
   let counter = 0;
   let committing = Promise.resolve();
-  async function prepare(context) {
+  async function prepare(input) {
+    const invocation = new AbortController();
+    const signal = AbortSignal.any([input.signal, controller.signal, invocation.signal]);
+    inheritYieldCheckpoint(input.signal, signal);
+    const context = { ...input, signal };
     context.signal.throwIfAborted();
-    const directory = options.cacheDirectory === void 0 ? void 0 : resolvePath(context.cwd, options.cacheDirectory, runtimeKey);
+    const directory = options.cacheDirectory === void 0 ? void 0 : resolvePath(context.cwd, options.cacheDirectory, pythonPackageRuntimeKey);
     const cache = options.cache ?? (directory === void 0 ? defaultCache : {
       async get(key) {
         try {
@@ -1005,7 +1095,20 @@ function createPythonPackageEnvironment(options = {}) {
         await context.fs.writeFile(resolvePath(directory, key), bytes, { signal: context.signal });
       }
     });
-    const stored = await cache.get(runtimeKey + "-environment");
+    const manifestCache = options.cacheDirectory === void 0 ? defaultCache : cache;
+    let snapshot;
+    if (options.manifestStore) {
+      try {
+        snapshot = await options.manifestStore.get(manifestKey, context);
+      } catch (error) {
+        context.signal.throwIfAborted();
+        throw failure("Cannot read Python package environment manifest", error);
+      }
+    }
+    context.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();
     if (stored && stored.length > maxBytes) throw failure("Python package manifest exceeds maxDownloadBytes");
     const manifest = stored === void 0 ? "" : decoder.decode(stored);
@@ -1045,7 +1148,7 @@ function createPythonPackageEnvironment(options = {}) {
       }
       sessions.delete(session);
     };
-    sessions.set(session, { ...context, cache, offline: context.offline ?? options.offline ?? false, requirements: unique, opened: /* @__PURE__ */ new Map(), opening: false, closed: false, manifest, aborted });
+    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 };
   }
@@ -1062,11 +1165,18 @@ function createPythonPackageEnvironment(options = {}) {
       if (manifestBytes.length > maxBytes) throw failure("Python package manifest exceeds maxDownloadBytes");
       const commit = committing.then(async () => {
         checkSession(session);
-        const current = await session.cache.get(runtimeKey + "-environment");
-        checkSession(session);
-        if (current && current.length > maxBytes) throw failure("Python package manifest exceeds maxDownloadBytes");
-        if ((current === void 0 ? "" : decoder.decode(current)) !== session.manifest) throw failure("Python package environment changed during installation; retry the command");
-        await session.cache.set(runtimeKey + "-environment", manifestBytes);
+        if (options.manifestStore) {
+          const committed = await options.manifestStore.compareAndSet(manifestKey, session.manifestRevision, manifestBytes, { signal: session.signal });
+          checkSession(session);
+          if (typeof committed !== "boolean") throw failure("Invalid Python package manifest publication result");
+          if (!committed) throw new PythonPackageConflictError();
+        } else {
+          const current = await session.manifestCache.get(manifestKey);
+          checkSession(session);
+          if (current && current.length > maxBytes) throw failure("Python package manifest exceeds maxDownloadBytes");
+          if ((current === void 0 ? "" : decoder.decode(current)) !== session.manifest) throw new PythonPackageConflictError();
+          await session.manifestCache.set(manifestKey, manifestBytes);
+        }
         checkSession(session);
       });
       committing = commit.catch(() => {
@@ -1094,8 +1204,9 @@ function createPythonPackageEnvironment(options = {}) {
       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 address = runtimeKey + "-url-" + digest(encoder.encode(url));
-      const metadata = await session.cache.get(address);
+      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);
       checkSession(session);
       let bytes;
       let headers = [];
@@ -1108,7 +1219,7 @@ function createPythonPackageEnvironment(options = {}) {
           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(runtimeKey + "-sha256-" + record.digest);
+        bytes = await session.cache.get(pythonPackageRuntimeKey + "-sha256-" + record.digest);
         headers = record.headers;
         checkSession(session);
         if (bytes && bytes.length > maxBytes) throw failure("Cached package exceeds maxDownloadBytes");
@@ -1117,7 +1228,7 @@ function createPythonPackageEnvironment(options = {}) {
         if (bytes) options.onProgress?.({ phase: "cached", url, bytes: bytes.length });
       }
       if (!bytes) {
-        if (url.startsWith("file:") || url.startsWith("emfs:")) {
+        if (canonicalWheel) {
           const path = new URL(url);
           if (path.host && path.host !== "localhost") throw failure("Local wheels must use the canonical filesystem");
           try {
@@ -1186,9 +1297,9 @@ function createPythonPackageEnvironment(options = {}) {
         const hash = digest(bytes);
         const metadataBytes = encoder.encode(JSON.stringify({ digest: hash, headers }));
         if (metadataBytes.length > maxBytes) throw failure("Python package cache metadata exceeds maxDownloadBytes");
-        await session.cache.set(runtimeKey + "-sha256-" + hash, Uint8Array.from(bytes));
+        await session.cache.set(pythonPackageRuntimeKey + "-sha256-" + hash, Uint8Array.from(bytes));
         checkSession(session);
-        await session.cache.set(address, metadataBytes);
+        if (!canonicalWheel) await session.cache.set(address, metadataBytes);
         checkSession(session);
       }
       checkSession(session);
@@ -1200,15 +1311,31 @@ function createPythonPackageEnvironment(options = {}) {
       session.opening = false;
     }
   }
-  return { prepare, dispatch, finish(start) {
-    const session = sessions.get(start.session);
-    if (session) {
-      session.closed = true;
-      session.opened.clear();
-      session.signal.removeEventListener("abort", session.aborted);
+  return {
+    prepare: admit(prepare),
+    dispatch: admit(dispatch),
+    finish(start) {
+      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);
+    },
+    dispose() {
+      if (!disposing) {
+        disposed = true;
+        controller.abort(failure("Python package environment is disposed"));
+        disposing = Promise.allSettled([...pending]).then(() => {
+          sessions.clear();
+          defaultCache.dispose();
+        });
+      }
+      return disposing;
     }
-    sessions.delete(start.session);
-  } };
+  };
 }
 
 // packages/safe-bash/src/commands/python/index.ts
@@ -1217,6 +1344,7 @@ var PythonInputChunkError = class extends RangeError {
 function createPythonCommands(options) {
   if (typeof options?.createWorker !== "function") throw new PythonFailure("executor-unavailable");
   if (options.onDiagnostic !== void 0 && typeof options.onDiagnostic !== "function") throw new TypeError("Python onDiagnostic must be a function");
+  if (options.environment && options.provisioning) throw new TypeError("A borrowed Python environment cannot be combined with provisioning options");
   const maxTransferBytes = options.maxTransferBytes ?? 65536;
   const maxOpenFiles = options.maxOpenFiles ?? 256;
   const maxConcurrentWorkers = options.maxConcurrentWorkers ?? 4;
@@ -1227,12 +1355,7 @@ function createPythonCommands(options) {
   for (const size of [maxTransferBytes, maxOpenFiles]) if (!Number.isSafeInteger(size) || size < 1 || size > 1048576) throw new RangeError("Invalid Python resource limit");
   const runtimeMount = options.runtimeMount ?? "/.pyodide-runtime";
   if (!runtimeMount.startsWith("/") || runtimeMount === "/" || runtimeMount.slice(1).includes("/") || runtimeMount.includes("\0") || runtimeMount.split("/").some((part) => part === ".." || part === ".")) throw new TypeError("Python runtime mount must be an absolute top-level canonical path");
-  const environment = createPythonPackageEnvironment({
-    ...options.provisioning,
-    requirements: [...options.provisioning?.requirements ?? [], ...options.packages ?? []],
-    requirementFiles: [...options.provisioning?.requirementFiles ?? [], ...options.requirements ?? []],
-    ...options.packageProfile ? { profile: options.packageProfile } : {}
-  });
+  const environment = options.environment ?? createPythonPackageEnvironment(options.provisioning);
   const execute = async (context) => {
     let installation;
     try {
@@ -1388,7 +1511,8 @@ function createPythonCommands(options) {
         fs: context.fs,
         cwd: context.cwd,
         signal,
-        ...installation ? { requirements: installation.packages, requirementFiles: installation.requirements } : {}
+        requirements: [...options.packages ?? [], ...options.packageProfile ? pythonDocumentPackages : [], ...installation?.packages ?? []],
+        requirementFiles: [...options.requirements ?? [], ...installation?.requirements ?? []]
       }).then((value) => {
         packages = value;
       });
@@ -1540,8 +1664,12 @@ function createPythonCommands(options) {
   return ["python", "python3"].map((name) => ({ name, description: "Python with an explicit synchronous interpreter worker and canonical filesystem", execute }));
 }
 function pythonCommands(options) {
-  const commands = createPythonCommands(options);
-  return { name: "python-commands", setup(host) {
+  if (typeof options?.createWorker !== "function") throw new PythonFailure("executor-unavailable");
+  if (options?.environment && options.provisioning) throw new TypeError("A borrowed Python environment cannot be combined with provisioning options");
+  const { provisioning, ...configuration } = options;
+  const environment = options.environment ?? createPythonPackageEnvironment(provisioning);
+  const commands = createPythonCommands({ ...configuration, environment });
+  return { name: "python-commands", ...options.environment ? {} : { dispose: environment.dispose }, setup(host) {
     if (!options.replace) {
       for (const command of commands) if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
     }
@@ -1561,9 +1689,12 @@ export {
   sha224,
   sha512,
   sha384,
+  PythonPackageConflictError,
+  createPythonPackageManifestStore,
+  createPythonPackageCache,
   pythonDocumentPackages,
   createPythonPackageEnvironment,
   createPythonCommands,
   pythonCommands
 };
-//# sourceMappingURL=chunk-43HWIHXB.js.map
+//# sourceMappingURL=chunk-Z4UKD5FF.js.map