@poe-platform/safe-bash 0.1.662 → 0.1.664

package/dist/safe-bash/chunks/{chunk-Z4UKD5FF.js → chunk-6VT3VSBX.js}

@@ -7,7 +7,7 @@ import {
   isPythonFailureCategory,
   parsePythonInvocation,
   reportPythonFailure
-} from "./chunk-Y7MAMRAF.js";
+} from "./chunk-AJ355TRJ.js";
 import {
   createOutputOperation
 } from "./chunk-CDBQXRWL.js";
@@ -1338,11 +1338,97 @@ function createPythonPackageEnvironment(options = {}) {
   };
 }
 
+// packages/safe-bash/src/commands/python/executor-pool.ts
+init_platform();
+function createPythonExecutorPool(options) {
+  if (typeof options?.createExecutor !== "function") throw new TypeError("Python executor pool requires a factory");
+  const factory = options.createExecutor;
+  const capacity = options.maxConcurrentExecutors;
+  if (!Number.isSafeInteger(capacity) || capacity < 1) throw new RangeError("Invalid Python executor pool capacity");
+  const entries = /* @__PURE__ */ new Set();
+  let closed = false;
+  let disposal;
+  return {
+    createExecutor() {
+      if (closed) throw new PythonFailure("executor-unavailable");
+      if (entries.size >= capacity) throw new PythonFailure("capacity");
+      let acquired;
+      const acquisition = new Promise((resolve) => {
+        acquired = resolve;
+      });
+      let retirement;
+      let execution;
+      let started = false;
+      const entry = {
+        retire() {
+          retirement ??= Promise.resolve().then(async () => {
+            const executor2 = await acquisition;
+            if (executor2 !== void 0) {
+              const results = await Promise.allSettled([Promise.resolve().then(() => {
+                const terminate = executor2?.terminate;
+                if (typeof terminate !== "function") throw new PythonFailure("cleanup");
+                return terminate.call(executor2);
+              }), execution]);
+              const failed = results.find((result) => result.status === "rejected");
+              if (failed?.status === "rejected") throw failed.reason;
+            }
+            entries.delete(entry);
+          });
+          return retirement;
+        }
+      };
+      entries.add(entry);
+      let executor;
+      try {
+        executor = factory();
+      } catch (error) {
+        acquired(void 0);
+        entries.delete(entry);
+        throw error;
+      }
+      acquired(executor);
+      try {
+        if (closed || !executor || typeof executor.run !== "function" || typeof executor.terminate !== "function") throw new PythonFailure("executor-unavailable");
+      } catch (error) {
+        void entry.retire().catch(() => {
+        });
+        throw error;
+      }
+      return {
+        async run(start) {
+          if (started || closed || retirement) throw new PythonFailure("executor-unavailable");
+          started = true;
+          const running = Promise.resolve().then(() => {
+            if (closed || retirement) throw new PythonFailure("executor-unavailable");
+            return executor.run(start);
+          });
+          execution = running.then(() => {
+          }, () => {
+          });
+          return running;
+        },
+        terminate: entry.retire
+      };
+    },
+    inspect() {
+      return { active: entries.size, capacity, closed };
+    },
+    dispose() {
+      closed = true;
+      disposal ??= Promise.allSettled([...entries].map((entry) => entry.retire())).then((results) => {
+        const failed = results.find((result) => result.status === "rejected");
+        if (failed?.status === "rejected") throw failed.reason;
+      });
+      return disposal;
+    }
+  };
+}
+
 // packages/safe-bash/src/commands/python/index.ts
 var PythonInputChunkError = class extends RangeError {
 };
 function createPythonCommands(options) {
-  if (typeof options?.createWorker !== "function") throw new PythonFailure("executor-unavailable");
+  if (!options || typeof options.createWorker === "function" === (typeof options.createExecutor === "function") || options.createWorker !== void 0 && typeof options.createWorker !== "function" || options.createExecutor !== void 0 && typeof options.createExecutor !== "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;
@@ -1391,6 +1477,7 @@ function createPythonCommands(options) {
     let stdoutOperation;
     let stderrOperation;
     let endpoint;
+    let executor;
     let packages;
     let unsubscribe;
     let admitted = false;
@@ -1415,7 +1502,7 @@ function createPythonCommands(options) {
       void (async () => {
         signal.removeEventListener("abort", aborted);
         const subscription = Promise.resolve().then(() => unsubscribe?.());
-        const termination = Promise.resolve().then(() => endpoint?.terminate());
+        const termination = Promise.resolve().then(() => executor ? executor.terminate() : endpoint?.terminate());
         const results = await Promise.allSettled([subscription, termination, service.close(), stdoutOperation?.close(), stderrOperation?.close(), ...pending]);
         await input.return?.(void 0);
         fragment = void 0;
@@ -1447,31 +1534,13 @@ function createPythonCommands(options) {
       const outputContext = { signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} };
       stdoutOperation = createOutputOperation(outputContext, context.stdout);
       stderrOperation = createOutputOperation(outputContext, context.stderr);
-      let shared;
-      try {
-        shared = new SharedArrayBuffer(8 + maxTransferBytes * 6 + 65536);
-      } catch (reason) {
-        throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
-      }
-      const control = new Int32Array(shared, 0, 2);
-      const payload = new Uint8Array(shared, 8);
-      const reply = (value, status) => {
-        if (closed) return;
-        let bytes;
-        try {
-          bytes = encodePythonReply(value, payload.length);
-        } catch (error) {
-          if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EFBIG") throw error;
-          bytes = encodePythonReply({ code: "EFBIG" }, payload.length);
-          status = 2;
-        }
-        payload.set(bytes);
-        try {
-          Atomics.store(control, 1, bytes.length);
-          Atomics.store(control, 0, status);
-          Atomics.notify(control, 0);
-        } catch (reason) {
-          throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
+      const diagnoseFilesystemFailure = async (operation, error) => {
+        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOTSUP") return;
+        const category = operation === "open" ? "filesystem-open" : operation === "read" ? "filesystem-read" : operation === "write" || operation === "ftruncate" ? "filesystem-write" : operation === "readdir" ? "filesystem-directory" : "filesystem-operation";
+        if (!filesystemDiagnostics.has(category)) {
+          filesystemDiagnostics.add(category);
+          const failure2 = reportPythonFailure(category, error, options.onDiagnostic);
+          await writeBytes(stderrOperation.output, new TextEncoder().encode("python: " + failure2.message + "\n"), signal);
         }
       };
       const dispatch = async (request) => {
@@ -1523,114 +1592,213 @@ function createPythonCommands(options) {
         pending.delete(preparation);
       }
       signal.throwIfAborted();
-      try {
-        endpoint = options.createWorker();
-      } catch (reason) {
-        throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : "startup", reason, options.onDiagnostic);
-      }
-      signal.throwIfAborted();
-      result = await new Promise((resolve, reject) => {
-        let settled = false;
-        const fail = (reason) => {
-          settled = true;
-          reject(reason);
-        };
-        rejectRun = fail;
-        signal.addEventListener("abort", aborted, { once: true });
-        const transportFailure = (reason) => {
-          fail(reportPythonFailure("transport-unavailable", reason, options.onDiagnostic));
-        };
+      if (options.createExecutor) {
         try {
-          unsubscribe = endpoint.subscribe((value) => {
-            if (closed || settled) return;
-            if (typeof value !== "object" || value === null) {
-              transportFailure(new TypeError("Invalid Python worker message"));
-              return;
+          executor = options.createExecutor();
+        } catch (reason) {
+          throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : "startup", reason, options.onDiagnostic);
+        }
+        if (!executor || typeof executor.run !== "function" || typeof executor.terminate !== "function") throw reportPythonFailure("executor-unavailable", void 0, options.onDiagnostic);
+        let requesting = false;
+        let running = true;
+        const start = {
+          invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } },
+          runtimeMount,
+          maxTransferBytes,
+          signal,
+          ...packages ? { packages } : {},
+          installOnly: !!installation,
+          onReady() {
+            if (closed || !running || signal.aborted || ready) return;
+            ready = true;
+            try {
+              options.onProgress?.({ phase: "ready", command: context.command });
+            } catch (reason) {
+              running = false;
+              rejectRun?.(reason);
+              throw reason;
             }
-            const message = value;
-            if (message.type === "ready") {
-              ready = true;
-              try {
-                options.onProgress?.({ phase: "ready", command: context.command });
-              } catch (error) {
-                fail(error);
-              }
-              return;
+          },
+          async dispatch(request) {
+            signal.throwIfAborted();
+            if (closed || !running || requesting || !request || typeof request.op !== "string" || !Array.isArray(request.args)) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
+            requesting = true;
+            const operation = Promise.resolve().then(() => dispatch(request)).catch(async (error) => {
+              signal.throwIfAborted();
+              if (error instanceof PythonInputChunkError) rejectRun?.(error);
+              if (request.op.startsWith("package-")) throw Object.assign(reportPythonFailure("runtime-assets", error, options.onDiagnostic), { code: "EPACKAGE" });
+              await diagnoseFilesystemFailure(request.op, error);
+              throw error;
+            });
+            const tracked2 = operation.then(() => {
+            }, () => {
+            });
+            pending.add(tracked2);
+            try {
+              return await operation;
+            } finally {
+              requesting = false;
+              pending.delete(tracked2);
             }
-            if (message.type === "exit") {
-              if (pending.size) {
-                transportFailure(new TypeError("Python worker exited with an outstanding request"));
+          }
+        };
+        const execution = Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return executor.run(start);
+        }).catch((reason) => {
+          running = false;
+          if (signal.aborted) throw signal.reason;
+          throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : ready ? "runtime" : "startup", reason, options.onDiagnostic);
+        }).then((status) => {
+          running = false;
+          if (requesting) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
+          try {
+            return validateExitCode(status);
+          } catch (reason) {
+            throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
+          }
+        });
+        const tracked = execution.then(() => {
+        }, () => {
+        });
+        pending.add(tracked);
+        void tracked.then(() => pending.delete(tracked));
+        result = await new Promise((resolve, reject) => {
+          rejectRun = reject;
+          signal.addEventListener("abort", aborted, { once: true });
+          if (signal.aborted) aborted();
+          execution.then(resolve, reject);
+        });
+      } else {
+        let shared;
+        try {
+          shared = new SharedArrayBuffer(8 + maxTransferBytes * 6 + 65536);
+        } catch (reason) {
+          throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
+        }
+        const control = new Int32Array(shared, 0, 2);
+        const payload = new Uint8Array(shared, 8);
+        const reply = (value, status) => {
+          if (closed) return;
+          let bytes;
+          try {
+            bytes = encodePythonReply(value, payload.length);
+          } catch (error) {
+            if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EFBIG") throw error;
+            bytes = encodePythonReply({ code: "EFBIG" }, payload.length);
+            status = 2;
+          }
+          payload.set(bytes);
+          try {
+            Atomics.store(control, 1, bytes.length);
+            Atomics.store(control, 0, status);
+            Atomics.notify(control, 0);
+          } catch (reason) {
+            throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
+          }
+        };
+        try {
+          endpoint = options.createWorker();
+        } catch (reason) {
+          throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : "startup", reason, options.onDiagnostic);
+        }
+        signal.throwIfAborted();
+        result = await new Promise((resolve, reject) => {
+          let settled = false;
+          const fail = (reason) => {
+            settled = true;
+            reject(reason);
+          };
+          rejectRun = fail;
+          signal.addEventListener("abort", aborted, { once: true });
+          const transportFailure = (reason) => {
+            fail(reportPythonFailure("transport-unavailable", reason, options.onDiagnostic));
+          };
+          try {
+            unsubscribe = endpoint.subscribe((value) => {
+              if (closed || settled) return;
+              if (typeof value !== "object" || value === null) {
+                transportFailure(new TypeError("Invalid Python worker message"));
                 return;
               }
-              try {
-                const status = validateExitCode(message.exitCode);
-                settled = true;
-                resolve(status);
-              } catch (error) {
-                transportFailure(error);
+              const message = value;
+              if (message.type === "ready") {
+                ready = true;
+                try {
+                  options.onProgress?.({ phase: "ready", command: context.command });
+                } catch (error) {
+                  fail(error);
+                }
+                return;
               }
-              return;
-            }
-            if (message.type === "error") {
-              fail(reportPythonFailure(isPythonFailureCategory(message.category) ? message.category : ready ? "runtime" : "startup", message.message, options.onDiagnostic));
-              return;
-            }
-            if (typeof message.op !== "string" || !Array.isArray(message.args) || pending.size) {
-              transportFailure(new TypeError("Invalid concurrent Python worker request"));
-              return;
-            }
-            const work = dispatch({ op: message.op, args: message.args }).then(
-              (value2) => {
-                pending.delete(work);
-                reply(value2, 1);
-              },
-              async (error) => {
-                if (signal.aborted) {
-                  pending.delete(work);
-                  fail(signal.reason);
+              if (message.type === "exit") {
+                if (pending.size) {
+                  transportFailure(new TypeError("Python worker exited with an outstanding request"));
                   return;
                 }
-                if (typeof message.op === "string" && message.op.startsWith("package-")) {
-                  const failure2 = reportPythonFailure("runtime-assets", error, options.onDiagnostic);
-                  pending.delete(work);
-                  reply({ code: "EPACKAGE", message: failure2.message }, 2);
-                  return;
+                try {
+                  const status = validateExitCode(message.exitCode);
+                  settled = true;
+                  resolve(status);
+                } catch (error) {
+                  transportFailure(error);
                 }
-                if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string") {
+                return;
+              }
+              if (message.type === "error") {
+                fail(reportPythonFailure(isPythonFailureCategory(message.category) ? message.category : ready ? "runtime" : "startup", message.message, options.onDiagnostic));
+                return;
+              }
+              if (typeof message.op !== "string" || !Array.isArray(message.args) || pending.size) {
+                transportFailure(new TypeError("Invalid concurrent Python worker request"));
+                return;
+              }
+              const work = dispatch({ op: message.op, args: message.args }).then(
+                (value2) => {
                   pending.delete(work);
-                  fail(error);
-                  return;
-                }
-                if (error.code === "ENOTSUP") {
-                  const category = message.op === "open" ? "filesystem-open" : message.op === "read" ? "filesystem-read" : message.op === "write" || message.op === "ftruncate" ? "filesystem-write" : message.op === "readdir" ? "filesystem-directory" : "filesystem-operation";
-                  if (!filesystemDiagnostics.has(category)) {
-                    filesystemDiagnostics.add(category);
-                    const failure2 = reportPythonFailure(category, error, options.onDiagnostic);
-                    await writeBytes(stderrOperation.output, new TextEncoder().encode("python: " + failure2.message + "\n"), signal);
+                  reply(value2, 1);
+                },
+                async (error) => {
+                  if (signal.aborted) {
+                    pending.delete(work);
+                    fail(signal.reason);
+                    return;
+                  }
+                  if (typeof message.op === "string" && message.op.startsWith("package-")) {
+                    const failure2 = reportPythonFailure("runtime-assets", error, options.onDiagnostic);
+                    pending.delete(work);
+                    reply({ code: "EPACKAGE", message: failure2.message }, 2);
+                    return;
+                  }
+                  if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string") {
+                    pending.delete(work);
+                    fail(error);
+                    return;
                   }
+                  await diagnoseFilesystemFailure(message.op, error);
+                  pending.delete(work);
+                  reply({ code: error.code }, 2);
                 }
+              );
+              pending.add(work);
+              void work.catch((reason) => {
                 pending.delete(work);
-                reply({ code: error.code }, 2);
-              }
-            );
-            pending.add(work);
-            void work.catch((reason) => {
-              pending.delete(work);
-              fail(reason);
-            });
-          }, transportFailure);
-        } catch (reason) {
-          transportFailure(reason);
-        }
-        if (settled) return;
-        const start = { type: "start", shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes, ...packages ? { packages } : {}, installOnly: !!installation };
-        signal.throwIfAborted();
-        try {
-          endpoint.postMessage(start);
-        } catch (reason) {
-          transportFailure(reason);
-        }
-      });
+                fail(reason);
+              });
+            }, transportFailure);
+          } catch (reason) {
+            transportFailure(reason);
+          }
+          if (settled) return;
+          const start = { type: "start", shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes, ...packages ? { packages } : {}, installOnly: !!installation };
+          signal.throwIfAborted();
+          try {
+            endpoint.postMessage(start);
+          } catch (reason) {
+            transportFailure(reason);
+          }
+        });
+      }
     } catch (reason) {
       if (!signal.aborted && reason instanceof PythonInputChunkError) {
         try {
@@ -1661,10 +1829,10 @@ function createPythonCommands(options) {
     }
     return { exitCode: result };
   };
-  return ["python", "python3"].map((name) => ({ name, description: "Python with an explicit synchronous interpreter worker and canonical filesystem", execute }));
+  return ["python", "python3"].map((name) => ({ name, description: "Python with an explicit interpreter executor and canonical filesystem", execute }));
 }
 function pythonCommands(options) {
-  if (typeof options?.createWorker !== "function") throw new PythonFailure("executor-unavailable");
+  if (!options || typeof options.createWorker === "function" === (typeof options.createExecutor === "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);
@@ -1694,7 +1862,8 @@ export {
   createPythonPackageCache,
   pythonDocumentPackages,
   createPythonPackageEnvironment,
+  createPythonExecutorPool,
   createPythonCommands,
   pythonCommands
 };
-//# sourceMappingURL=chunk-Z4UKD5FF.js.map
+//# sourceMappingURL=chunk-6VT3VSBX.js.map