@poe-platform/safe-bash 0.1.755 → 0.1.757

package/dist/safe-bash/chunks/chunk-MJPFHANT.js

@@ -1,3350 +0,0 @@
-import {
-  sha256
-} from "./chunk-CTYJJD4O.js";
-import {
-  PythonFailure,
-  PythonInvocationError,
-  isPythonFailureCategory,
-  parsePythonInvocation,
-  pythonDirectoryEntries,
-  pythonExecution,
-  pythonImportMetadata,
-  pythonRuntimeRelocation,
-  pythonStatProjection,
-  pythonTreeCleanup,
-  reportPythonFailure
-} from "./chunk-BMO5LWEX.js";
-import {
-  yield_exports
-} from "./chunk-XPF5XHLY.js";
-import {
-  dirname,
-  errors_exports,
-  output_exports,
-  resolvePath
-} from "./chunk-OUUVROTM.js";
-import {
-  command_exports,
-  io_exports
-} from "./chunk-G2VCIF2J.js";
-import {
-  path_exports
-} from "./chunk-ISCZG7WA.js";
-import {
-  sniffMimeType
-} from "./chunk-ZBFOWARG.js";
-import {
-  __reExport,
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/python/index.ts
-init_platform();
-import { PythonFileSystem, PythonStatTranslator } from "@poe-platform/safe-fs/core";
-
-// packages/safe-bash/src/contracts/filesystem-descriptor.ts
-var filesystem_descriptor_exports = {};
-init_platform();
-__reExport(filesystem_descriptor_exports, filesystem_descriptor_star);
-import * as filesystem_descriptor_star from "../../safe-bash-contracts/filesystem-descriptor.js";
-
-// packages/safe-bash/src/commands/python/reply.ts
-init_platform();
-function encodePythonReply(value, maxBytes) {
-  let used = 0;
-  const ancestors = /* @__PURE__ */ new Set();
-  const reserve = (bytes) => {
-    used += bytes;
-    if (used > maxBytes) throw new errors_exports.FsError("EFBIG", { syscall: "python reply" });
-  };
-  const string = (text2) => {
-    if (text2.length + 2 > maxBytes - used) throw new errors_exports.FsError("EFBIG", { syscall: "python reply" });
-    reserve(2);
-    for (let index = 0; index < text2.length; index++) {
-      const code = text2.charCodeAt(index);
-      if (code < 32) reserve([8, 9, 10, 12, 13].includes(code) ? 2 : 6);
-      else if (code === 34 || code === 92) reserve(2);
-      else if (code < 128) reserve(1);
-      else if (code < 2048) reserve(2);
-      else if (code >= 55296 && code <= 56319 && text2.charCodeAt(index + 1) >= 56320 && text2.charCodeAt(index + 1) <= 57343) {
-        reserve(4);
-        index++;
-      } else reserve(code >= 55296 && code <= 57343 ? 6 : 3);
-    }
-    return text2;
-  };
-  const own = (input, depth) => {
-    if (depth > 64) throw new errors_exports.FsError("EFBIG", { syscall: "python reply" });
-    if (input === null || input === void 0) {
-      reserve(4);
-      return null;
-    }
-    if (typeof input === "string") return string(input);
-    if (typeof input === "number") {
-      reserve(Number.isFinite(input) ? String(input).length : 4);
-      return input;
-    }
-    if (typeof input === "boolean") {
-      reserve(input ? 4 : 5);
-      return input;
-    }
-    if (typeof input !== "object") throw new TypeError("Invalid Python reply value");
-    if (ancestors.has(input)) throw new TypeError("Cyclic Python reply value");
-    ancestors.add(input);
-    try {
-      if (input instanceof Uint8Array || Array.isArray(input)) {
-        if (input.length > maxBytes - used) throw new errors_exports.FsError("EFBIG", { syscall: "python reply" });
-        reserve(2);
-        const output2 = [];
-        for (let index = 0; index < input.length; index++) {
-          if (index) reserve(1);
-          const descriptor = Object.getOwnPropertyDescriptor(input, String(index));
-          if (descriptor && !("value" in descriptor)) throw new TypeError("Accessor Python reply");
-          output2.push(own(descriptor?.value, depth + 1));
-        }
-        return output2;
-      }
-      reserve(2);
-      const output = /* @__PURE__ */ Object.create(null);
-      let count = 0;
-      let visited = 0;
-      for (const key in input) {
-        if (!Object.hasOwn(input, key)) continue;
-        if (++visited > maxBytes) throw new errors_exports.FsError("EFBIG", { syscall: "python reply" });
-        const descriptor = Object.getOwnPropertyDescriptor(input, key);
-        if (!("value" in descriptor)) throw new TypeError("Accessor Python reply");
-        if (descriptor.value === void 0 || typeof descriptor.value === "function") continue;
-        if (count++) reserve(1);
-        string(key);
-        reserve(1);
-        output[key] = own(descriptor.value, depth + 1);
-      }
-      return output;
-    } finally {
-      ancestors.delete(input);
-    }
-  };
-  const owned = own(value, 0);
-  return new TextEncoder().encode(JSON.stringify(owned));
-}
-
-// packages/safe-bash/src/commands/python/installation.ts
-init_platform();
-var pythonInstallationHelp = `Usage: python -m pip install [-r FILE | --requirement FILE] PACKAGE ...
-Installs compatible wheels and dependencies using the configured Pyodide installer.
-PACKAGE is a package requirement or a canonical filesystem wheel path.
-Supported options: -r, --requirement, -h, --help, --.
-All other pip options and commands are unsupported, including --upgrade,
---force-reinstall, --no-index, --no-deps, --target, --user, --prefix, --root, --editable,
---index-url, --extra-index-url, --find-links, --trusted-host, --require-hashes,
---constraint, --dry-run, --quiet, --verbose and cache/build/configuration flags.
-Configure transport and integrity through the Python package SDK configuration.
-`;
-function parsePythonInstallation(args) {
-  let pipArgs;
-  scan: for (let index = 0; index < args.length; index++) {
-    const option = args[index];
-    if (option === "--" || option === "-" || !option.startsWith("-") || option.startsWith("--")) return void 0;
-    for (let offset = 1; offset < option.length; offset++) {
-      const flag = option[offset];
-      if ("h?V".includes(flag)) return void 0;
-      if ("cmWX".includes(flag)) {
-        const operand = option.slice(offset + 1) || args[++index];
-        if (flag === "c") return void 0;
-        if (flag === "m") {
-          if (operand !== "pip") return void 0;
-          pipArgs = args.slice(index + 1);
-          break scan;
-        }
-        break;
-      }
-    }
-  }
-  if (!pipArgs) return void 0;
-  const packages = [];
-  const requirements = [];
-  if (pipArgs.length === 0) return { packages, requirements, help: true };
-  if (pipArgs[0] === "--help" || pipArgs[0] === "-h") {
-    if (pipArgs.length > 1) throw new PythonInvocationError("unsupported pip option or argument after help: " + pipArgs[1]);
-    return { packages, requirements, help: true };
-  }
-  if (pipArgs[0] !== "install") throw new PythonInvocationError("unsupported pip command " + pipArgs[0]);
-  let operands = false;
-  let help = false;
-  for (let index = 1; index < pipArgs.length; index++) {
-    const option = pipArgs[index];
-    if (operands || !option.startsWith("-")) {
-      packages.push(option);
-      continue;
-    }
-    if (option === "--") {
-      operands = true;
-      continue;
-    }
-    if (option === "--help" || option === "-h") {
-      help = true;
-      continue;
-    }
-    if (option === "-r" || option === "--requirement" || option.startsWith("--requirement=") || option.startsWith("-r")) {
-      const path = option.startsWith("--requirement=") ? option.slice("--requirement=".length) : option !== "-r" && option.startsWith("-r") ? option.slice(2) : pipArgs[++index];
-      if (!path || path.startsWith("-")) throw new PythonInvocationError(option + " requires a path");
-      requirements.push(path);
-      continue;
-    }
-    throw new PythonInvocationError("unsupported pip option " + option);
-  }
-  if (!help && packages.length === 0 && requirements.length === 0) throw new PythonInvocationError("pip install requires at least one package or requirements file");
-  return { packages, requirements, help };
-}
-
-// packages/safe-bash/src/commands/python/provisioning.ts
-init_platform();
-
-// 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 ?? Infinity;
-  if (options.maxBytes !== void 0 && (!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) {
-        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",
-  "pillow==12.2.0",
-  "python-docx==1.2.0",
-  "openpyxl==3.1.5",
-  "XlsxWriter==3.2.9",
-  "pypdf==6.18.1",
-  "fpdf2==2.8.8",
-  "fonttools==4.65.0",
-  "defusedxml==0.7.1",
-  "et-xmlfile==2.0.0",
-  "typing-extensions==4.16.0"
-]);
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function digest(value) {
-  return Array.from(sha256(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-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";
-}
-function normalizeRequirement(value, cwd) {
-  const requirement = value.trim();
-  if (!requirement || requirement.startsWith("-")) throw failure(`Unsupported requirement: ${value}`);
-  if (requirement.endsWith(".whl") && !requirement.includes("://")) return "file://" + resolvePath(cwd, requirement).split("/").map(encodeURIComponent).join("/");
-  return requirement;
-}
-function checkSession(session) {
-  session.signal.throwIfAborted();
-  if (session.closed) throw failure("Python package session is closed");
-}
-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 ?? 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"]) {
-    const value = options[name];
-    if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`${name} must be a positive integer`);
-  }
-  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);
-    });
-    pending.add(work);
-    void work.then(() => {
-      pending.delete(work);
-    }, () => {
-      pending.delete(work);
-    });
-    return work;
-  };
-  let counter = 0;
-  let committing = Promise.resolve();
-  async function prepare(input) {
-    const invocation = new AbortController();
-    const signal = AbortSignal.any([input.signal, controller.signal, invocation.signal]);
-    (0, yield_exports.inheritYieldCheckpoint)(input.signal, signal);
-    const context = { ...input, signal };
-    context.signal.throwIfAborted();
-    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 {
-          return await context.fs.readFile(resolvePath(directory, key), { signal: context.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(resolvePath(directory, key), bytes, { signal: context.signal });
-      }
-    });
-    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 > maxManifestBytes) throw failure("Python package manifest exceeds maxManifestBytes");
-    const manifest = stored === void 0 ? "" : decoder.decode(stored);
-    let previous;
-    try {
-      previous = stored === void 0 ? [] : JSON.parse(manifest);
-    } 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));
-    for (const file of [...options.requirementFiles ?? [], ...context.requirementFiles ?? []]) {
-      const path = resolvePath(context.cwd, file);
-      let source;
-      try {
-        source = decoder.decode(await context.fs.readFile(path, { signal: context.signal, ...options.maxRequirementBytes === void 0 ? {} : { maxBytes: options.maxRequirementBytes } }));
-      } catch (error) {
-        context.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() === ""));
-        const text2 = (comment < 0 ? line : line.slice(0, comment)).trim();
-        if (!text2) continue;
-        if (text2.endsWith("\\") || text2.startsWith("-")) throw failure(`Unsupported requirements option or continuation in ${path}: ${text2}`);
-        requirements.push(normalizeRequirement(text2, dirname(path)));
-      }
-    }
-    context.signal.throwIfAborted();
-    const session = String(++counter);
-    const unique = [...new Set(requirements)];
-    const aborted = () => {
-      const current = sessions.get(session);
-      if (current) {
-        current.closed = true;
-        current.opened.clear();
-      }
-      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 };
-  }
-  async function dispatch(op, args, _context) {
-    _context.signal.throwIfAborted();
-    const session = sessions.get(String(args[0]));
-    if (!session) throw failure("Python package session is closed");
-    checkSession(session);
-    if (op === "package-commit") {
-      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));
-      if (manifestBytes.length > maxManifestBytes) throw failure("Python package manifest exceeds maxManifestBytes");
-      const commit = committing.then(async () => {
-        checkSession(session);
-        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 > maxManifestBytes) throw failure("Python package manifest exceeds maxManifestBytes");
-          if ((current === void 0 ? "" : decoder.decode(current)) !== session.manifest) throw new PythonPackageConflictError();
-          await session.manifestCache.set(manifestKey, manifestBytes);
-        }
-        checkSession(session);
-      });
-      committing = commit.catch(() => {
-      });
-      await commit;
-      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-close") {
-      session.opened.delete(String(args[1]));
-      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];
-      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 = 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 = [];
-      if (metadata) {
-        if (metadata.length > maxMetadataBytes) throw failure("Python package cache metadata exceeds maxMetadataBytes");
-        let record2;
-        try {
-          record2 = JSON.parse(decoder.decode(metadata));
-        } catch {
-          throw failure(`Invalid package cache metadata: ${url}`);
-        }
-        if (typeof record2 !== "object" || record2 === null || typeof record2.digest !== "string" || record2.digest.length !== 64 || Array.from(record2.digest).some((char) => !"0123456789abcdef".includes(char)) || !Array.isArray(record2.headers) || record2.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-" + record2.digest);
-        headers = record2.headers;
-        checkSession(session);
-        if (bytes && bytes.length > maxBytes) throw failure("Cached package exceeds maxDownloadBytes");
-        if (bytes) bytes = Uint8Array.from(bytes);
-        if (bytes && digest(bytes) !== record2.digest) throw failure(`Package cache integrity mismatch: ${url}`);
-        if (bytes) options.onProgress?.({ phase: "cached", url, bytes: bytes.length });
-      }
-      if (!bytes) {
-        if (canonicalWheel) {
-          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 } : {} });
-          } catch (error) {
-            checkSession(session);
-            throw failure(`Cannot read canonical Python wheel ${path.pathname}: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        } else {
-          if (session.offline) throw failure(`Offline package cache miss: ${url}`);
-          if (!options.transport || !options.authorize) throw failure("Python package download requires configured transport and authorization");
-          let current = new URL(url);
-          let redirectFrom;
-          for (let redirect = 0; ; redirect++) {
-            if (current.protocol !== "https:" && current.protocol !== "http:") throw failure(`Unsupported package transport protocol: ${current.protocol}`);
-            if (current.username || current.password) throw failure("Package URLs with credentials are unsupported");
-            let denyPrivate = false;
-            const allowed = await options.authorize({ url: current.href, method: "GET", attempt: 0, signal: session.signal, ...redirectFrom === void 0 ? {} : { redirectFrom }, requirePrivateNetworkDeny() {
-              denyPrivate = true;
-            } });
-            checkSession(session);
-            if (!allowed) throw failure(`Python package download authorization denied: ${current.href}`);
-            if (denyPrivate && !options.transport.supportsPrivateNetworkDeny) throw failure("Package transport cannot enforce private network denial");
-            checkSession(session);
-            const response = await options.transport({ url: current.href, method: "GET", headers: [["accept", "application/vnd.pypi.simple.v1+json, application/json;q=0.9, */*;q=0.1"]], signal: session.signal, ...denyPrivate ? { denyPrivateNetworks: true } : {} });
-            try {
-              checkSession(session);
-              if ([301, 302, 303, 307, 308].includes(response.status)) {
-                if (redirect >= 5) throw failure("Too many package redirects");
-                const location = response.headers.find(([key2]) => key2.toLowerCase() === "location")?.[1];
-                if (!location) throw failure("Package redirect has no location");
-                redirectFrom = current.href;
-                current = new URL(location, current);
-                continue;
-              }
-              if (response.status < 200 || response.status >= 300) throw failure(`Package download failed: HTTP ${response.status} ${current.href}`);
-              headers = response.headers;
-              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 chunks = [];
-              let count = 0;
-              for await (const chunk of response.body) {
-                checkSession(session);
-                if (chunk.length === 0) continue;
-                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 } : {} });
-              }
-              bytes = new Uint8Array(count);
-              let offset = 0;
-              for (const chunk of chunks) {
-                bytes.set(chunk, offset);
-                offset += chunk.length;
-              }
-              break;
-            } finally {
-              await response.dispose();
-            }
-          }
-        }
-        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);
-      }
-      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 };
-    } finally {
-      session.opening = false;
-    }
-  }
-  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;
-    }
-  };
-}
-
-// packages/safe-bash/src/commands/python/host-capabilities.ts
-init_platform();
-function pythonHostFailureCode(error) {
-  if (error instanceof RangeError) return "limit";
-  if (error instanceof Error && error.name === "TimeoutError") return "timeout";
-  return "service";
-}
-function createPythonHostBridge(capabilities, options) {
-  const maxMessageBytes = options.maxMessageBytes ?? Infinity;
-  const maxConcurrentCalls = options.maxConcurrentCalls ?? Infinity;
-  const maxStreams = options.maxStreams ?? Infinity;
-  const maxStreamBytes = options.maxStreamBytes ?? Infinity;
-  const maxMessageDepth = options.maxMessageDepth ?? Infinity;
-  for (const limit of [maxMessageBytes, maxMessageDepth, maxConcurrentCalls, maxStreams, maxStreamBytes]) {
-    if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1)) throw new RangeError("Invalid Python host capability limit");
-  }
-  const registry = new Map(Object.entries(capabilities));
-  const controller = new AbortController();
-  const signal = AbortSignal.any([options.signal, controller.signal]);
-  const pending = /* @__PURE__ */ new Set();
-  const streams = /* @__PURE__ */ new Map();
-  const jobs = /* @__PURE__ */ new Map();
-  const cleanupFailures = [];
-  const jobWork = /* @__PURE__ */ new Set();
-  let nextJob = 1;
-  let nextHandle = 1;
-  let retired = false;
-  let closing;
-  const data = (value) => {
-    const ancestors = /* @__PURE__ */ new Set();
-    let nodes = 0;
-    let estimatedBytes = 0;
-    const inspect = (item, depth) => {
-      if (++nodes > maxMessageBytes || depth > maxMessageDepth) throw new RangeError("Python host message limit exceeded");
-      if (item === null || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)) {
-        estimatedBytes += JSON.stringify(item).length;
-        if (estimatedBytes > maxMessageBytes) throw new RangeError("Python host message limit exceeded");
-        return;
-      }
-      if (typeof item === "string") {
-        if (item.length > maxMessageBytes) throw new RangeError("Python host message limit exceeded");
-        estimatedBytes += new TextEncoder().encode(JSON.stringify(item)).length;
-        if (estimatedBytes > maxMessageBytes) throw new RangeError("Python host message limit exceeded");
-        return;
-      }
-      if (typeof item !== "object" || item === null || !Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null) throw new TypeError("Python host messages must contain data only");
-      if (Array.isArray(item) && item.length > maxMessageBytes) throw new RangeError("Python host message limit exceeded");
-      if (ancestors.has(item)) throw new TypeError("Python host messages must not contain cycles");
-      ancestors.add(item);
-      estimatedBytes += 2;
-      if (Object.getOwnPropertySymbols(item).length) throw new TypeError("Python host messages must contain data only");
-      for (const key in item) {
-        if (!Object.hasOwn(item, key)) continue;
-        estimatedBytes += 2;
-        if (estimatedBytes > maxMessageBytes) throw new RangeError("Python host message limit exceeded");
-        if (Array.isArray(item) && key === "length") continue;
-        if (typeof key !== "string") throw new TypeError("Python host messages must contain data only");
-        const descriptor = Object.getOwnPropertyDescriptor(item, key);
-        if (!("value" in descriptor)) throw new TypeError("Python host messages must contain data only");
-        if (!Array.isArray(item)) inspect(key, depth + 1);
-        inspect(descriptor.value, depth + 1);
-      }
-      ancestors.delete(item);
-    };
-    inspect(value, 0);
-    const encoded = JSON.stringify(value);
-    if (new TextEncoder().encode(encoded).length > maxMessageBytes) throw new RangeError("Python host message limit exceeded");
-    return JSON.parse(encoded);
-  };
-  const assertLive = () => {
-    if (retired) throw new Error("Python host capability retired");
-    signal.throwIfAborted();
-  };
-  const release = async (handle, cancel = true) => {
-    const stream = streams.get(handle);
-    if (!stream) throw new Error("Unknown Python host stream");
-    streams.delete(handle);
-    if (cancel) stream.controller.abort(new Error("Python host stream released"));
-    try {
-      await stream.iterator.return?.();
-    } catch (error) {
-      cleanupFailures.push(error);
-      throw error;
-    }
-  };
-  const pull = async (handle) => {
-    const stream = streams.get(handle);
-    if (!stream) throw new Error("Unknown Python host stream");
-    stream.busy = true;
-    try {
-      const result = await stream.iterator.next();
-      assertLive();
-      stream.controller.signal.throwIfAborted();
-      if (result.done) {
-        await release(handle, false);
-        return { done: true };
-      }
-      const chunkBytes = result.value instanceof Uint8Array ? result.value.length : new TextEncoder().encode(typeof result.value === "string" ? result.value : JSON.stringify(data(result.value))).length;
-      if (chunkBytes > maxStreamBytes - stream.bytes) throw new RangeError("Python host stream byte limit exceeded");
-      stream.bytes += chunkBytes;
-      const value = result.value instanceof Uint8Array ? (() => {
-        if (result.value.length > maxMessageBytes / 4) throw new RangeError("Python host message limit exceeded");
-        return { type: "bytes", bytes: Array.from(result.value) };
-      })() : typeof result.value === "string" ? { type: "text", text: result.value } : { type: "data", value: result.value };
-      return data({ done: false, value });
-    } catch (error) {
-      if (streams.has(handle)) await release(handle);
-      throw error;
-    } finally {
-      stream.busy = false;
-    }
-  };
-  const request = async (incoming) => {
-    assertLive();
-    if (pending.size >= maxConcurrentCalls) throw new Error("Python host call concurrency limit exceeded");
-    const payload = data(incoming);
-    if (!payload || Array.isArray(payload) || typeof payload !== "object" || payload.version !== 1) throw new TypeError("Unsupported Python host protocol");
-    const operation = Promise.resolve().then(async () => {
-      assertLive();
-      if (payload.operation === "poll" || payload.operation === "cancel") {
-        const handle = payload.handle;
-        if (typeof handle !== "number") throw new TypeError("Invalid Python host job");
-        const job = jobs.get(handle);
-        if (!job) throw new Error("Unknown Python host job");
-        if (payload.operation === "cancel") {
-          jobs.delete(handle);
-          job.controller.abort(new Error("Python guest cancelled host operation"));
-          return null;
-        }
-        if (job.result === void 0 && !job.failed) return { done: false };
-        jobs.delete(handle);
-        return job.failed ? { done: true, error: "Python host operation failed", errorCode: job.failed } : { done: true, value: job.result };
-      }
-      if (Math.max(jobWork.size, jobs.size) >= maxConcurrentCalls) throw new Error("Python host call concurrency limit exceeded");
-      if (payload.operation === "begin" || payload.operation === "begin-next") {
-        let work;
-        let child;
-        if (payload.operation === "begin-next") {
-          const stream = typeof payload.handle === "number" ? streams.get(payload.handle) : void 0;
-          if (!stream || stream.busy) throw new Error("Unknown or busy Python host stream");
-          child = stream.controller;
-          work = () => pull(payload.handle);
-        } else {
-          const capability2 = typeof payload.capability === "string" ? registry.get(payload.capability) : void 0;
-          if (!capability2?.call) throw new Error("Unknown Python host capability");
-          child = new AbortController();
-          work = (childSignal) => capability2.call(payload.value ?? null, { signal: childSignal });
-        }
-        const handle = nextJob++;
-        const job = { controller: child };
-        jobs.set(handle, job);
-        const task = Promise.resolve().then(() => {
-          const childSignal = AbortSignal.any([signal, child.signal]);
-          childSignal.throwIfAborted();
-          return work(childSignal);
-        }).then((value) => {
-          assertLive();
-          child.signal.throwIfAborted();
-          job.result = data(value);
-        }).catch((error) => {
-          job.failed = pythonHostFailureCode(error);
-        }).finally(() => {
-          jobWork.delete(task);
-        });
-        jobWork.add(task);
-        return handle;
-      }
-      if (payload.operation === "next" || payload.operation === "release") {
-        const handle = payload.handle;
-        if (typeof handle !== "number" || !Number.isSafeInteger(handle)) throw new TypeError("Invalid Python host stream handle");
-        const stream = streams.get(handle);
-        if (!stream) throw new Error("Unknown Python host stream");
-        if (stream.busy) throw new Error("Python host stream already pulling");
-        if (payload.operation === "release") {
-          await release(handle);
-          return null;
-        }
-        return pull(handle);
-      }
-      if (typeof payload.capability !== "string") throw new TypeError("Invalid Python host capability");
-      const capability = registry.get(payload.capability);
-      if (!capability) throw new Error("Unknown Python host capability");
-      if (payload.operation === "call" && capability.call) {
-        const result = await capability.call(payload.value ?? null, { signal });
-        assertLive();
-        return data(result);
-      }
-      if (payload.operation === "stream" && capability.stream) {
-        if (streams.size >= maxStreams) throw new Error("Python host stream limit exceeded");
-        const child = new AbortController();
-        const iterator = capability.stream(payload.value ?? null, { signal: AbortSignal.any([signal, child.signal]) })[Symbol.asyncIterator]();
-        const handle = nextHandle++;
-        streams.set(handle, { iterator, busy: false, controller: child, bytes: 0 });
-        return handle;
-      }
-      throw new Error("Unsupported Python host capability operation");
-    });
-    pending.add(operation);
-    try {
-      return await operation;
-    } finally {
-      pending.delete(operation);
-    }
-  };
-  const close = () => {
-    if (closing) return closing;
-    retired = true;
-    controller.abort(new Error("Python host capability retired"));
-    closing = (async () => {
-      for (const job of jobs.values()) job.controller.abort(controller.signal.reason);
-      await Promise.allSettled([...pending, ...jobWork]);
-      jobs.clear();
-      const results = await Promise.allSettled([...streams.keys()].map((handle) => release(handle)));
-      registry.clear();
-      for (const result of results) if (result.status === "rejected") throw result.reason;
-      if (cleanupFailures.length) throw cleanupFailures[0];
-    })();
-    return closing;
-  };
-  return { request, close };
-}
-
-// packages/safe-bash/src/commands/python/shell-capability.ts
-init_platform();
-var dispatching = /* @__PURE__ */ new WeakMap();
-function pythonShellDispatchActive(scope) {
-  return scope !== void 0 && (dispatching.get(scope) ?? 0) > 0;
-}
-function createPythonShellCapability(context, options = {}) {
-  if (!context.invoke || !context.executionScope) throw new TypeError("Python shell capability requires a parent shell invocation");
-  const maxInputBytes = options.maxInputBytes ?? Infinity;
-  const maxOutputBytes = options.maxOutputBytes ?? Infinity;
-  const maxConcurrentCalls = options.maxConcurrentCalls ?? Infinity;
-  for (const limit of [maxInputBytes, maxOutputBytes, maxConcurrentCalls]) if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1)) throw new RangeError("Invalid Python shell limit");
-  const chunkBytes = options.maxStreamChunkBytes ?? 16384;
-  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid Python shell stream chunk limit");
-  const scope = context.executionScope;
-  const invoke = context.invoke;
-  let running = 0;
-  const execute = async (value, { signal }, publish) => {
-    signal.throwIfAborted();
-    if (running >= maxConcurrentCalls) throw new Error("Python nested shell concurrency limit exceeded");
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected a Python shell request");
-    const request = value;
-    const requestedOutput = request.maxOutputBytes;
-    if (requestedOutput !== void 0 && (typeof requestedOutput !== "number" || requestedOutput !== Infinity && (!Number.isSafeInteger(requestedOutput) || requestedOutput < 0))) throw new RangeError("Invalid Python shell output limit");
-    const outputLimit = Math.min(maxOutputBytes, typeof requestedOutput === "number" ? requestedOutput : maxOutputBytes);
-    const timeoutMs = request.timeoutMs;
-    if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)) throw new RangeError("Invalid Python shell timeout");
-    const childSignal = typeof timeoutMs === "number" ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : signal;
-    const script = request.script;
-    const argv = request.argv;
-    if (typeof script === "string" === Array.isArray(argv)) throw new TypeError("Provide either literal argv or a script");
-    if (argv !== void 0 && (!Array.isArray(argv) || !argv.length || argv.some((item) => typeof item !== "string" || item.includes("\0")))) throw new TypeError("Invalid Python shell argv");
-    if (request.cwd !== void 0 && (typeof request.cwd !== "string" || request.cwd.includes("\0"))) throw new TypeError("Invalid Python shell cwd");
-    const env = request.env === void 0 ? { ...context.env } : {};
-    if (request.env !== void 0) {
-      if (!request.env || typeof request.env !== "object" || Array.isArray(request.env)) throw new TypeError("Invalid Python shell environment");
-      for (const [key, item] of Object.entries(request.env)) {
-        if (typeof item !== "string" || key.includes("=") || key.includes("\0") || item.includes("\0")) throw new TypeError("Invalid Python shell environment");
-        Object.defineProperty(env, key, { value: item, enumerable: true, configurable: true, writable: true });
-      }
-    }
-    const input = request.stdin ?? [];
-    if (typeof input !== "string" && (!Array.isArray(input) || input.some((byte) => typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255))) throw new TypeError("Invalid Python shell stdin");
-    if (input.length > maxInputBytes) throw new RangeError("Python shell input limit exceeded");
-    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : Uint8Array.from(input);
-    if (bytes.length > maxInputBytes) throw new RangeError("Python shell input limit exceeded");
-    const source = request.stdinMode === "inherit" && request.stdin === void 0 ? context.stdin : { async *[Symbol.asyncIterator]() {
-      yield bytes;
-    } };
-    const childInput = { async *[Symbol.asyncIterator]() {
-      let received = 0;
-      for await (const fragment of source) {
-        childSignal.throwIfAborted();
-        received += fragment.length;
-        if (received > maxInputBytes) throw new RangeError("Python shell input limit exceeded");
-        yield fragment;
-      }
-    } };
-    const stdout = [];
-    const stderr = [];
-    let captured = 0;
-    const sink = (target, type) => ({ async write(chunk) {
-      childSignal.throwIfAborted();
-      if (chunk.length > outputLimit - captured) throw new RangeError("Python shell output limit exceeded");
-      captured += chunk.length;
-      if (publish) {
-        for (let offset = 0; offset < chunk.length; offset += chunkBytes) {
-          childSignal.throwIfAborted();
-          await publish({ type, data: Array.from(chunk.subarray(offset, offset + chunkBytes)) });
-        }
-      } else for (const byte of chunk) target.push(byte);
-    } });
-    running++;
-    dispatching.set(scope, (dispatching.get(scope) ?? 0) + 1);
-    try {
-      const args = argv;
-      const result = await invoke(args ? args[0] : "sh", args ? args.slice(1) : ["-c", script], {
-        signal: childSignal,
-        cwd: request.cwd ?? context.cwd,
-        env,
-        replaceEnv: true,
-        stdin: childInput,
-        stdout: sink(stdout, "stdout"),
-        stderr: sink(stderr, "stderr"),
-        externalInvocation: true
-      });
-      childSignal.throwIfAborted();
-      return { stdout, stderr, exitCode: result.exitCode };
-    } catch (error) {
-      if (!publish && !signal.aborted && childSignal.aborted && childSignal.reason?.name === "TimeoutError") {
-        return { error: { code: "timeout", message: "Python shell deadline exceeded", stdout, stderr } };
-      }
-      throw error;
-    } finally {
-      running--;
-      const count = dispatching.get(scope) - 1;
-      if (count) dispatching.set(scope, count);
-      else dispatching.delete(scope);
-    }
-  };
-  return { call: execute, async *stream(value, context2) {
-    const controller = new AbortController();
-    const signal = AbortSignal.any([context2.signal, controller.signal]);
-    let queued;
-    let wake;
-    let ended = false;
-    let failure2;
-    let failed = false;
-    let publishing = Promise.resolve();
-    const publish = async (event) => {
-      const next = publishing.then(async () => {
-        signal.throwIfAborted();
-        await new Promise((resolve, reject) => {
-          const abort = () => {
-            signal.removeEventListener("abort", abort);
-            reject(signal.reason);
-            wake?.();
-          };
-          signal.addEventListener("abort", abort, { once: true });
-          queued = { event, accept() {
-            signal.removeEventListener("abort", abort);
-            resolve();
-          } };
-          wake?.();
-          if (signal.aborted) abort();
-        });
-      });
-      publishing = next.catch(() => void 0);
-      await next;
-    };
-    const child = execute(value, { signal }, publish).then(async (result) => {
-      await publish({ type: "exit", returncode: result.exitCode });
-    }).catch((error) => {
-      failure2 = error;
-      failed = true;
-    }).finally(() => {
-      ended = true;
-      wake?.();
-    });
-    try {
-      while (true) {
-        signal.throwIfAborted();
-        if (queued) {
-          const item = queued;
-          queued = void 0;
-          yield item.event;
-          item.accept();
-        } else if (ended) {
-          if (failed) throw failure2;
-          break;
-        } else await new Promise((resolve) => {
-          wake = resolve;
-        });
-      }
-    } finally {
-      controller.abort(new Error("Python shell stream closed"));
-      await child;
-    }
-  } };
-}
-
-// packages/safe-bash/src/commands/python/llm-capability.ts
-init_platform();
-function record(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected a structured Python LLM request");
-  return value;
-}
-function createPythonLlmCapability(context, service, options = {}) {
-  const chunkBytes = options.maxStreamChunkBytes ?? 16384;
-  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid Python LLM stream chunk limit");
-  const prepare = async (value, signal) => {
-    const payload = record(value);
-    for (const key of ["template", "conversation"]) {
-      if (payload[key] !== void 0 && payload[key] !== null) throw new TypeError(`The shared LLM service does not yet support persisted ${key}`);
-    }
-    if (payload.parameters !== void 0 && Object.keys(record(payload.parameters)).length) throw new TypeError("Template parameters require shared-service template support");
-    const timeout = payload.timeout;
-    if (timeout !== void 0 && timeout !== null) {
-      if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0 || timeout * 1e3 > 2147483647) throw new RangeError("Invalid LLM timeout");
-      signal = AbortSignal.any([signal, AbortSignal.timeout(Math.max(1, Math.ceil(timeout * 1e3)))]);
-    }
-    signal.throwIfAborted();
-    const limit = payload.max_response_bytes;
-    if (limit !== void 0 && limit !== null && (typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid LLM response limit");
-    const attachments = [];
-    const inputLimit = context.inputBudget?.maxBytes ?? Infinity;
-    let inputBytes = 0;
-    const checkInput = (size) => {
-      if (size > inputLimit - inputBytes) throw new RangeError("LLM input byte limit exceeded");
-      context.inputBudget?.check(inputBytes + size);
-    };
-    const inputs = payload.attachments ?? [];
-    if (!Array.isArray(inputs)) throw new TypeError("Expected canonical LLM attachments");
-    for (const value2 of inputs) {
-      const attachment = record(value2);
-      if (typeof attachment.path !== "string" || !attachment.path || attachment.path.includes("\0") || attachment.path.includes("://")) throw new TypeError("Attachment requires a canonical filesystem path");
-      if (attachment.mimeType !== void 0 && typeof attachment.mimeType !== "string") throw new TypeError("Invalid attachment MIME type");
-      const path = (0, path_exports.pathOf)(context, attachment.path);
-      const stat = await context.fs.stat(path, { signal });
-      checkInput(stat.size);
-      const bytes = await context.fs.readFile(path, { signal, ...inputLimit === Infinity ? {} : { maxBytes: inputLimit - inputBytes } });
-      signal.throwIfAborted();
-      checkInput(bytes.byteLength);
-      inputBytes += bytes.byteLength;
-      attachments.push({ mimeType: attachment.mimeType ?? sniffMimeType(path, bytes), bytes: new Uint8Array(bytes) });
-    }
-    return {
-      prompt: payload.prompt === void 0 ? "" : payload.prompt,
-      ...payload.model == null ? {} : { model: payload.model },
-      ...payload.system === void 0 ? {} : { system: payload.system },
-      ...payload.messages === void 0 ? {} : { messages: payload.messages },
-      ...payload.schema === void 0 ? {} : { schema: record(payload.schema) },
-      options: record(payload.options ?? {}),
-      attachments,
-      signal,
-      ...limit == null ? {} : { maxOutputBytes: limit }
-    };
-  };
-  const events = async function* (value, { signal }) {
-    const request = await prepare(value, signal);
-    for await (const event of service.stream(request)) {
-      if (event.type === "bytes") {
-        for (let offset = 0; offset < event.data.length; offset += chunkBytes) {
-          request.signal.throwIfAborted();
-          yield { type: "bytes", data: Array.from(event.data.subarray(offset, offset + chunkBytes)) };
-        }
-      } else yield event;
-    }
-  };
-  return {
-    async call(value, { signal }) {
-      signal.throwIfAborted();
-      const operation = record(value);
-      const payload = record(operation.payload ?? {});
-      if (operation.operation === "models") return service.models.map(({ provider, model }) => ({
-        id: model.id,
-        aliases: [...model.aliases ?? []],
-        capabilities: [...model.capabilities ?? []],
-        metadata: { provider: provider.name, attachmentTypes: [...model.attachmentTypes ?? []], outputType: model.outputType ?? "text/plain" }
-      }));
-      if (operation.operation === "embed") {
-        return await service.embed({
-          ...payload.model == null ? {} : { model: payload.model },
-          inputs: payload.inputs,
-          options: record(payload.options ?? {}),
-          signal
-        });
-      }
-      if (operation.operation !== "complete") throw new TypeError("Unsupported Python LLM operation");
-      const text2 = [], data = [];
-      let response = {};
-      for await (const value2 of events(payload, { signal })) {
-        const event = record(value2);
-        if (event.type === "text") text2.push(event.text);
-        else if (event.type === "bytes") for (const byte of event.data) data.push(byte);
-        else if (event.type === "response") response = { ...record(event.response) };
-      }
-      return { ...response, text: text2.join(""), data };
-    },
-    stream: events
-  };
-}
-
-// 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 ?? Infinity;
-  if (options.maxConcurrentExecutors !== void 0 && (!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/jspi.ts
-init_platform();
-import { createPythonNativeSyscalls } from "@poe-platform/safe-fs/core";
-
-// packages/safe-bash/src/commands/python/llm-module.ts
-init_platform();
-var pythonLlmModule = String.raw`
-"""Async Python workflows for the invocation-owned JavaScript LLM service."""
-from __future__ import annotations
-
-import asyncio
-import copy
-import inspect
-import math
-from dataclasses import dataclass, field, replace
-from typing import Any, AsyncIterator, Callable, Mapping, Optional, Protocol, Sequence, Union
-
-Option = Union[str, int, float, bool, None]
-
-class LlmError(Exception):
-    def __init__(self, code: str, message: str):
-        super().__init__(message)
-        self.code = code
-
-class LimitError(LlmError):
-    def __init__(self, message="LLM response byte limit exceeded"):
-        super().__init__("limit", message)
-
-class CapabilityError(LlmError):
-    def __init__(self, message="This Python invocation has no LLM capability"):
-        super().__init__("capability", message)
-
-class Bridge(Protocol):
-    async def call(self, operation: str, payload: Mapping[str, Any]) -> Any: ...
-    def stream(self, payload: Mapping[str, Any]) -> AsyncIterator[Mapping[str, Any]]: ...
-
-@dataclass(frozen=True)
-class Model:
-    id: str
-    aliases: tuple[str, ...] = ()
-    capabilities: tuple[str, ...] = ()
-    metadata: Mapping[str, Any] = field(default_factory=dict)
-
-@dataclass(frozen=True)
-class Message:
-    role: str
-    content: str
-
-@dataclass(frozen=True)
-class Attachment:
-    path: str
-    mime_type: Optional[str] = None
-
-    def payload(self):
-        if not isinstance(self.path, str) or not self.path or "\0" in self.path:
-            raise ValueError("Attachment requires an agent filesystem path")
-        result = {"path": self.path}
-        if self.mime_type is not None:
-            result["mimeType"] = self.mime_type
-        return result
-
-def _options(values):
-    result = dict(values)
-    for key, value in result.items():
-        if not isinstance(key, str) or not key:
-            raise TypeError("Option names must be nonempty strings")
-        if value is not None and type(value) not in (str, int, float, bool):
-            raise TypeError("Model options must be strings, numbers, booleans or None")
-        if type(value) is int and abs(value) > 9007199254740991:
-            raise ValueError("Integer model options must fit the JavaScript safe integer range")
-        if type(value) is float and not math.isfinite(value):
-            raise ValueError("Model options must be finite")
-    return result
-
-@dataclass(frozen=True)
-class Request:
-    prompt: str = ""
-    model: Optional[str] = None
-    system: Optional[str] = None
-    messages: Sequence[Message] = ()
-    attachments: Sequence[Attachment] = ()
-    options: Mapping[str, Option] = field(default_factory=dict)
-    schema: Optional[Mapping[str, Any]] = None
-    template: Optional[str] = None
-    parameters: Mapping[str, Any] = field(default_factory=dict)
-    conversation: Optional[str] = None
-
-    def payload(self):
-        if not isinstance(self.prompt, str):
-            raise TypeError("Prompt must be a string")
-        if self.model is not None and (not isinstance(self.model, str) or not self.model):
-            raise TypeError("Model must be a nonempty identity or alias")
-        if self.system is not None and not isinstance(self.system, str):
-            raise TypeError("System prompt must be a string")
-        messages = []
-        for message in self.messages:
-            if not isinstance(message, Message) or not isinstance(message.role, str) or not isinstance(message.content, str):
-                raise TypeError("Messages must contain typed Message values")
-            messages.append({"role": message.role, "content": message.content})
-        result = {"prompt": self.prompt, "messages": messages,
-                  "attachments": [attachment.payload() for attachment in self.attachments],
-                  "options": _options(self.options)}
-        for key in ("model", "system", "schema", "template", "conversation"):
-            value = getattr(self, key)
-            if value is not None:
-                result[key] = copy.deepcopy(value)
-        if self.parameters:
-            result["parameters"] = copy.deepcopy(dict(self.parameters))
-        return result
-
-def _bytes(value):
-    if value is None:
-        return b""
-    if isinstance(value, (bytes, bytearray, memoryview)):
-        return bytes(value)
-    if isinstance(value, (tuple, list)) and all(type(item) is int and 0 <= item <= 255 for item in value):
-        return bytes(value)
-    raise LlmError("protocol", "Invalid binary LLM result")
-
-@dataclass(frozen=True)
-class Response:
-    model: str
-    text: str = ""
-    data: bytes = b""
-    usage: Mapping[str, Any] = field(default_factory=dict)
-    conversation: Optional[str] = None
-    metadata: Mapping[str, Any] = field(default_factory=dict)
-
-    @classmethod
-    def from_payload(cls, value):
-        if not isinstance(value, Mapping) or not isinstance(value.get("model"), str) or not isinstance(value.get("text", ""), str):
-            raise LlmError("protocol", "Invalid complete LLM response")
-        return cls(model=value["model"], text=value.get("text", ""), data=_bytes(value.get("data")),
-                   usage=copy.deepcopy(value.get("usage", {})), conversation=value.get("conversation"),
-                   metadata=copy.deepcopy(value.get("metadata", {})))
-
-    def json(self):
-        import json
-        return json.loads(self.text)
-
-@dataclass(frozen=True)
-class Embeddings:
-    model: str
-    vectors: tuple[tuple[float, ...], ...]
-    usage: Mapping[str, Any] = field(default_factory=dict)
-    metadata: Mapping[str, Any] = field(default_factory=dict)
-
-@dataclass(frozen=True)
-class Event:
-    type: str
-    text: str = ""
-    data: bytes = b""
-    response: Optional[Response] = None
-    metadata: Mapping[str, Any] = field(default_factory=dict)
-
-async def _transform(function, value):
-    result = function(value) if function else value
-    return await result if inspect.isawaitable(result) else result
-
-_DEFAULT_LIMIT = object()
-
-class Stream:
-    """Use async with to close the host iterator after an early break."""
-    def __init__(self, client, request, timeout=None, max_response_bytes=_DEFAULT_LIMIT):
-        self._client = client
-        self._request = request
-        self._iterator = None
-        self._closed = False
-        self._close_task = None
-        self._pending = None
-        self._lock = asyncio.Lock()
-        self._bytes = 0
-        self._limit = client._limit if max_response_bytes is _DEFAULT_LIMIT else _limit(max_response_bytes)
-        self._timeout = client._timeout if timeout is None else _timeout(timeout)
-        self._deadline = None
-        self.response = None
-
-    async def __aenter__(self):
-        self._client._check_open()
-        return self
-
-    async def __aexit__(self, *exception):
-        await self.aclose()
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        async with self._lock:
-            if self._closed:
-                raise StopAsyncIteration
-            self._client._check_open()
-            try:
-                if self._deadline is None and self._timeout is not None:
-                    self._deadline = asyncio.get_running_loop().time() + self._timeout
-                async def read():
-                    if self._iterator is None:
-                        payload = await self._client._payload(self._request)
-                        payload["timeout"] = self._timeout
-                        payload["max_response_bytes"] = self._limit
-                        self._iterator = self._client._bridge.stream(payload).__aiter__()
-                    return await self._iterator.__anext__()
-                remaining = None if self._deadline is None else max(0, self._deadline - asyncio.get_running_loop().time())
-                self._pending = asyncio.ensure_future(read())
-                value = await asyncio.wait_for(self._pending, remaining)
-                kind = value.get("type")
-                if kind == "text":
-                    if not isinstance(value.get("text"), str):
-                        raise LlmError("protocol", "Invalid text stream event")
-                    event = Event(kind, text=value["text"])
-                elif kind == "bytes":
-                    event = Event(kind, data=_bytes(value.get("data")))
-                elif kind == "response":
-                    self.response = Response.from_payload(value["response"])
-                    _check_size(self.response, self._limit)
-                    event = Event(kind, response=self.response)
-                else:
-                    raise LlmError("protocol", "Unknown stream event")
-                self._bytes += len(event.text.encode("utf-8")) + len(event.data)
-                if self._limit is not None and self._bytes > self._limit:
-                    raise LimitError()
-                return event
-            except BaseException:
-                await self.aclose()
-                raise
-
-    async def aclose(self):
-        if self._close_task is None:
-            self._closed = True
-            async def close():
-                try:
-                    if self._pending is not None and not self._pending.done():
-                        self._pending.cancel()
-                        await asyncio.gather(self._pending, return_exceptions=True)
-                    if self._iterator is not None:
-                        await self._iterator.aclose()
-                finally:
-                    self._client._streams.discard(self)
-            self._close_task = asyncio.ensure_future(close())
-        await asyncio.shield(self._close_task)
-
-def _limit(value):
-    if value is None or type(value) is float and value == math.inf:
-        return None
-    if type(value) is not int or value < 1:
-        raise ValueError("max_response_bytes must be a positive integer")
-    return value
-
-def _timeout(value):
-    if value is not None and (type(value) not in (int, float) or not math.isfinite(value) or value <= 0):
-        raise ValueError("timeout must be a positive number of seconds")
-    return value
-
-def _check_size(response, limit):
-    if limit is not None and len(response.text.encode("utf-8")) + len(response.data) > limit:
-        raise LimitError()
-
-class Client:
-    def __init__(self, *, bridge=None, model=None, options=None, system=None,
-                 request_transform=None, response_transform=None,
-                 max_response_bytes=None, timeout=None):
-        if bridge is None:
-            try:
-                from _poe_llm_capability import bridge
-            except ImportError as error:
-                raise CapabilityError() from error
-        self._bridge = bridge
-        self._defaults = {"model": model, "system": system, "options": _options(options or {})}
-        self._request_transform = request_transform
-        self._response_transform = response_transform
-        self._limit = _limit(max_response_bytes)
-        self._timeout = _timeout(timeout)
-        self._streams = set()
-        self._tasks = set()
-        self._closed = False
-        self._close_task = None
-
-    def _check_open(self):
-        if self._closed:
-            raise CapabilityError("LLM client has been closed")
-
-    async def __aenter__(self):
-        self._check_open()
-        return self
-
-    async def __aexit__(self, *exception):
-        await self.aclose()
-
-    async def aclose(self):
-        if self._close_task is None:
-            self._closed = True
-            current = asyncio.current_task()
-            async def close():
-                pending = [task for task in self._tasks if task is not current]
-                for task in pending:
-                    task.cancel()
-                await asyncio.gather(*pending, return_exceptions=True)
-                results = await asyncio.gather(*(stream.aclose() for stream in tuple(self._streams)), return_exceptions=True)
-                for result in results:
-                    if isinstance(result, BaseException):
-                        raise result
-            self._close_task = asyncio.ensure_future(close())
-        await asyncio.shield(self._close_task)
-
-    def with_defaults(self, **defaults):
-        self._check_open()
-        values = dict(self._defaults)
-        values.update(defaults)
-        values["options"] = {**self._defaults["options"], **defaults.get("options", {})}
-        return Client(bridge=self._bridge, request_transform=self._request_transform,
-                      response_transform=self._response_transform, max_response_bytes=self._limit,
-                      timeout=self._timeout, **values)
-
-    def _request(self, prompt, values):
-        if isinstance(prompt, Request):
-            if values:
-                raise TypeError("A Request cannot be combined with keyword fields")
-            return replace(prompt, model=prompt.model if prompt.model is not None else self._defaults["model"],
-                           system=prompt.system if prompt.system is not None else self._defaults["system"],
-                           options={**self._defaults["options"], **prompt.options})
-        fields = {**self._defaults, **values, "prompt": prompt}
-        fields["options"] = {**self._defaults["options"], **values.get("options", {})}
-        return Request(**fields)
-
-    async def _payload(self, request):
-        self._check_open()
-        transformed = await _transform(self._request_transform, request)
-        self._check_open()
-        if not isinstance(transformed, Request):
-            raise TypeError("Request transform must return a Request")
-        return transformed.payload()
-
-    async def _run(self, operation, timeout):
-        self._check_open()
-        task = asyncio.ensure_future(operation())
-        self._tasks.add(task)
-        try:
-            return await asyncio.wait_for(task, timeout)
-        finally:
-            self._tasks.discard(task)
-
-    async def models(self):
-        values = await self._run(lambda: self._bridge.call("models", {}), self._timeout)
-        return tuple(Model(id=value["id"], aliases=tuple(value.get("aliases", ())),
-                           capabilities=tuple(value.get("capabilities", ())),
-                           metadata=copy.deepcopy(value.get("metadata", {}))) for value in values)
-
-    async def complete(self, prompt="", *, timeout=None, max_response_bytes=_DEFAULT_LIMIT, **values):
-        limit = self._limit if max_response_bytes is _DEFAULT_LIMIT else _limit(max_response_bytes)
-        timeout = self._timeout if timeout is None else _timeout(timeout)
-        request = self._request(prompt, values)
-        async def execute():
-            payload = await self._payload(request)
-            payload["timeout"] = timeout
-            payload["max_response_bytes"] = limit
-            response = Response.from_payload(await self._bridge.call("complete", payload))
-            _check_size(response, limit)
-            return await _transform(self._response_transform, response)
-        return await self._run(execute, timeout)
-
-    def stream(self, prompt="", *, timeout=None, max_response_bytes=_DEFAULT_LIMIT, **values):
-        self._check_open()
-        stream = Stream(self, self._request(prompt, values), timeout, max_response_bytes)
-        self._streams.add(stream)
-        return stream
-
-    async def embed(self, inputs, *, model=None, options=None, timeout=None):
-        if isinstance(inputs, str):
-            raise TypeError("Embedding inputs must be an iterable of strings")
-        inputs = tuple(inputs)
-        if not all(isinstance(value, str) for value in inputs):
-            raise TypeError("Embedding inputs must be an iterable of strings")
-        payload = {"model": model if model is not None else self._defaults["model"], "inputs": list(inputs),
-                   "options": _options({**self._defaults["options"], **(options or {})})}
-        payload["timeout"] = self._timeout if timeout is None else _timeout(timeout)
-        result = await self._run(lambda: self._bridge.call("embed", payload), payload["timeout"])
-        vectors = tuple(tuple(vector) for vector in result["vectors"])
-        if len(vectors) != len(inputs) or any(type(value) not in (int, float) or not math.isfinite(value) for vector in vectors for value in vector):
-            raise LlmError("protocol", "Invalid embedding result")
-        if self._limit is not None and sum(len(vector) for vector in vectors) * 8 > self._limit:
-            raise LimitError()
-        return Embeddings(result["model"], vectors, copy.deepcopy(result.get("usage", {})), copy.deepcopy(result.get("metadata", {})))
-
-    def prompt(self, function, **defaults):
-        async def invoke(*args, **kwargs):
-            value = function(*args, **kwargs)
-            value = await value if inspect.isawaitable(value) else value
-            return await self.complete(value, **defaults)
-        return invoke
-
-    def conversation(self, *, system=None, messages=(), conversation=None):
-        return Conversation(self, system=system, messages=messages, conversation=conversation)
-
-class Conversation:
-    """Serial turn orchestration; failed calls never append partial turns."""
-    def __init__(self, client, *, system=None, messages=(), conversation=None):
-        self.client = client
-        self.system = system if system is not None else client._defaults["system"]
-        self.messages = list(messages)
-        self.id = conversation
-        self._lock = asyncio.Lock()
-
-    async def complete(self, prompt, **values):
-        async with self._lock:
-            response = await self.client.complete(prompt, system=self.system, messages=tuple(self.messages),
-                                                  conversation=self.id, **values)
-            if not isinstance(response, Response):
-                raise TypeError("Conversation requires a Response-returning transform")
-            self.messages.extend((Message("user", prompt), Message("assistant", response.text)))
-            self.id = response.conversation or self.id
-            return response
-`;
-function installPythonLlmModule(runtime) {
-  runtime.globals.set("_safe_llm_source", pythonLlmModule);
-  try {
-    runtime.runPython(`
-import sys as _safe_llm_sys, importlib.machinery as _safe_llm_imports
-class _SafeLlmLoader:
- def __init__(self, source, spec):
-  self._source = source
-  self._spec = spec
- def find_spec(self, fullname, path=None, target=None):
-  if fullname == 'poe_llm':
-   return self._spec(fullname, self, origin='poe_llm.py')
- def create_module(self, spec):
-  return None
- def exec_module(self, module):
-  module.__file__ = 'poe_llm.py'
-  exec(compile(self._source, 'poe_llm.py', 'exec'), module.__dict__)
-_safe_llm_sys.meta_path.insert(0, _SafeLlmLoader(_safe_llm_source, _safe_llm_imports.ModuleSpec))
-del _SafeLlmLoader, _safe_llm_sys, _safe_llm_imports
-`);
-  } finally {
-    runtime.globals.delete("_safe_llm_source");
-  }
-}
-
-// packages/safe-bash/src/commands/python/shell-module.ts
-init_platform();
-var pythonShellModule = String.raw`
-from __future__ import annotations
-import asyncio
-import math
-import inspect
-import subprocess
-from dataclasses import dataclass
-
-class ShellError(RuntimeError):
-    def __init__(self, code, message):
-        super().__init__(message)
-        self.code = code
-
-def _bridge():
-    try:
-        from _poe_shell_capability import bridge
-        return bridge
-    except ImportError as error:
-        raise ShellError('capability', 'This Python invocation has no shell capability') from error
-
-def _bytes(value):
-    if isinstance(value, (bytes, bytearray, memoryview)):
-        return bytes(value)
-    if isinstance(value, list) and all(type(item) is int and 0 <= item <= 255 for item in value):
-        return bytes(value)
-    raise ShellError('protocol', 'Invalid shell result bytes')
-
-def _payload(args, *, shell=False, input=None, cwd=None, env=None, timeout=None,
-             max_output_bytes=None, text=False, encoding=None, errors=None):
-    if shell:
-        if not isinstance(args, str):
-            raise TypeError('shell=True requires an explicit Safe Bash script string')
-        result = {'script': args}
-    else:
-        if isinstance(args, (str, bytes)):
-            raise TypeError('Literal execution requires an argv sequence')
-        args = list(args)
-        if not args or any(not isinstance(value, str) or '\0' in value for value in args):
-            raise TypeError('argv must contain nonempty command and literal strings without NUL')
-        if not args[0]:
-            raise ValueError('Command must not be empty')
-        result = {'argv': args}
-    if cwd is not None and (not isinstance(cwd, str) or '\0' in cwd):
-        raise TypeError('cwd must be a canonical filesystem path')
-    if env is not None and (not isinstance(env, dict) or any(not isinstance(key, str) or not isinstance(value, str) or '\0' in key + value or '=' in key for key, value in env.items())):
-        raise TypeError('env must map strings to strings')
-    if timeout is not None and (type(timeout) not in (int, float) or not math.isfinite(timeout) or timeout <= 0):
-        raise ValueError('timeout must be positive and finite')
-    if type(max_output_bytes) is float and max_output_bytes == math.inf:
-        max_output_bytes = None
-    if max_output_bytes is not None and (type(max_output_bytes) is not int or max_output_bytes < 0):
-        raise ValueError('max_output_bytes must be a nonnegative integer')
-    if input is not None:
-        if text or encoding or errors:
-            if not isinstance(input, str):
-                raise TypeError('Text input must be a string')
-            input = input.encode(encoding or 'utf-8', errors or 'strict')
-        elif not isinstance(input, (bytes, bytearray, memoryview)):
-            raise TypeError('Binary input must be bytes')
-        result['input'] = list(input)
-    result.update(cwd=cwd, env=env, timeout=timeout, max_output_bytes=max_output_bytes)
-    return result
-
-def _result(args, payload, value, *, check=False, text=False, encoding=None, errors=None, stdout=True, stderr=True):
-    if not isinstance(value, dict):
-        raise ShellError('protocol', 'Invalid shell result')
-    failure = value.get('error')
-    if failure:
-        if failure.get('code') == 'timeout':
-            raise subprocess.TimeoutExpired(args, payload['timeout'], output=_bytes(failure.get('stdout', [])), stderr=_bytes(failure.get('stderr', [])))
-        raise ShellError(failure.get('code', 'shell'), failure.get('message', 'Shell execution failed'))
-    code = value.get('returncode')
-    if type(code) is not int:
-        raise ShellError('protocol', 'Invalid shell return code')
-    output, diagnostic = _bytes(value.get('stdout', [])), _bytes(value.get('stderr', []))
-    if payload['max_output_bytes'] is not None and len(output) + len(diagnostic) > payload['max_output_bytes']:
-        raise ShellError('limit', 'Shell captured output limit exceeded')
-    if text or encoding or errors:
-        output = output.decode(encoding or 'utf-8', errors or 'strict').replace('\r\n', '\n').replace('\r', '\n')
-        diagnostic = diagnostic.decode(encoding or 'utf-8', errors or 'strict').replace('\r\n', '\n').replace('\r', '\n')
-    result = subprocess.CompletedProcess(args, code, output if stdout else None, diagnostic if stderr else None)
-    if check:
-        result.check_returncode()
-    return result
-
-@dataclass(frozen=True)
-class Event:
-    type: str
-    data: bytes = b''
-    returncode: int | None = None
-
-class Stream:
-    def __init__(self, client, payload):
-        self.client, self.payload = client, payload
-        self.iterator = None
-        self.pending = None
-        self.closed = False
-        self.count = 0
-    async def __aenter__(self):
-        self.client._check()
-        self.client.streams.add(self)
-        self.iterator = self.client.bridge.stream(self.payload).__aiter__()
-        return self
-    async def __aexit__(self, *ignored):
-        await self.aclose()
-    def __aiter__(self):
-        return self
-    async def __anext__(self):
-        if self.closed or self.iterator is None:
-            raise StopAsyncIteration
-        if self.pending is not None:
-            raise ShellError('concurrent', 'Only one shell stream read is allowed')
-        task = self.pending = asyncio.create_task(self.iterator.__anext__())
-        try:
-            value = await task
-            if value.get('error'):
-                error = value['error']
-                raise ShellError(error.get('code', 'shell'), error.get('message', 'Shell stream failed'))
-            data = _bytes(value.get('data', []))
-            self.count += len(data)
-            if self.payload['max_output_bytes'] is not None and self.count > self.payload['max_output_bytes']:
-                raise ShellError('limit', 'Shell streamed output limit exceeded')
-            return Event(value['type'], data, value.get('returncode'))
-        except BaseException:
-            self.pending = None
-            await self.aclose()
-            raise
-        finally:
-            if self.pending is task:
-                self.pending = None
-    async def aclose(self):
-        if self.closed:
-            return
-        self.closed = True
-        if self.pending:
-            self.pending.cancel()
-            await asyncio.gather(self.pending, return_exceptions=True)
-        if self.iterator and hasattr(self.iterator, 'aclose'):
-            await self.iterator.aclose()
-        self.client.streams.discard(self)
-
-class Client:
-    def __init__(self, *, bridge=None):
-        self.bridge = bridge if bridge is not None else _bridge()
-        self.closed = False
-        self.tasks = set()
-        self.streams = set()
-    def _check(self):
-        if self.closed:
-            raise ShellError('closed', 'Shell client is closed')
-    async def __aenter__(self):
-        self._check()
-        return self
-    async def __aexit__(self, *ignored):
-        await self.aclose()
-    async def aclose(self):
-        if self.closed:
-            return
-        self.closed = True
-        for task in self.tasks:
-            task.cancel()
-        await asyncio.gather(*self.tasks, return_exceptions=True)
-        await asyncio.gather(*(stream.aclose() for stream in tuple(self.streams)))
-    async def run(self, args, *, check=False, text=False, encoding=None, errors=None, **options):
-        self._check()
-        payload = _payload(args, text=text, encoding=encoding, errors=errors, **options)
-        async def operation():
-            value = getattr(self.bridge, 'async_call', self.bridge.call)('run', payload)
-            if inspect.isawaitable(value):
-                value = await value
-            return _result(args, payload, value, check=check, text=text, encoding=encoding, errors=errors)
-        task = asyncio.create_task(operation())
-        self.tasks.add(task)
-        try:
-            return await task
-        finally:
-            self.tasks.discard(task)
-    async def script(self, source, **options):
-        return await self.run(source, shell=True, **options)
-    def stream(self, args, **options):
-        self._check()
-        return Stream(self, _payload(args, **options))
-
-def _subprocess_run(args, *, stdin=None, stdout=None, stderr=None, input=None,
-                    capture_output=False, shell=False, cwd=None, env=None, timeout=None,
-                    check=False, text=False, encoding=None, errors=None, universal_newlines=None, **unsupported):
-    if unsupported:
-        raise NotImplementedError('Unsupported subprocess options: ' + ', '.join(sorted(unsupported)))
-    if stdin not in (None, subprocess.PIPE, subprocess.DEVNULL) or stdout not in (None, subprocess.PIPE, subprocess.DEVNULL) or stderr not in (None, subprocess.PIPE, subprocess.DEVNULL):
-        raise NotImplementedError('Only inherited, PIPE and DEVNULL standard streams are supported')
-    if input is not None and stdin is not None:
-        raise ValueError('stdin and input cannot both be supplied')
-    if capture_output:
-        if stdout is not None or stderr is not None:
-            raise ValueError('capture_output cannot be combined with stdout or stderr')
-        stdout = stderr = subprocess.PIPE
-    if universal_newlines is not None:
-        if text and not universal_newlines:
-            raise ValueError('text and universal_newlines disagree')
-        text = text or universal_newlines
-    payload = _payload(args, shell=shell, input=input, cwd=cwd, env=env, timeout=timeout, text=text, encoding=encoding, errors=errors)
-    payload.update(stdin='empty' if stdin in (subprocess.PIPE, subprocess.DEVNULL) else 'inherit',
-                   stdout='capture' if stdout == subprocess.PIPE else 'discard' if stdout == subprocess.DEVNULL else 'inherit',
-                   stderr='capture' if stderr == subprocess.PIPE else 'discard' if stderr == subprocess.DEVNULL else 'inherit')
-    value = _bridge().call('run', payload)
-    return _result(args, payload, value, check=check, text=text, encoding=encoding, errors=errors,
-                   stdout=stdout == subprocess.PIPE, stderr=stderr == subprocess.PIPE)
-
-def _check_output(args, **options):
-    if 'stdout' in options:
-        raise ValueError('stdout is not allowed with check_output')
-    return _subprocess_run(args, stdout=subprocess.PIPE, check=True, **options).stdout
-
-def _unsupported_popen(*args, **kwargs):
-    raise NotImplementedError('Safe Bash does not expose OS processes; use run or check_output')
-`;
-function installPythonShellModule(runtime) {
-  runtime.globals.set("_safe_shell_source", pythonShellModule);
-  try {
-    runtime.runPython(`
-import sys as _safe_shell_sys, importlib.machinery as _safe_shell_imports
-class _SafeShellLoader:
- def __init__(self, source, spec):
-  self.source, self.spec = source, spec
- def find_spec(self, fullname, path=None, target=None):
-  if fullname == 'poe_shell':
-   return self.spec(fullname, self, origin='poe_shell.py')
- def create_module(self, spec):
-  return None
- def exec_module(self, module):
-  module.__file__ = 'poe_shell.py'
-  exec(compile(self.source, 'poe_shell.py', 'exec'), module.__dict__)
-_safe_shell_sys.meta_path.insert(0, _SafeShellLoader(_safe_shell_source, _safe_shell_imports.ModuleSpec))
-import subprocess as _safe_subprocess
-def _safe_subprocess_getattr(name):
- if name not in ('run', 'check_output', 'Popen'):
-  raise AttributeError(name)
- from poe_shell import _subprocess_run, _check_output, _unsupported_popen
- import subprocess
- subprocess.run = _subprocess_run
- subprocess.check_output = _check_output
- subprocess.Popen = _unsupported_popen
- return getattr(subprocess, name)
-del _safe_subprocess.run, _safe_subprocess.check_output, _safe_subprocess.Popen
-_safe_subprocess.__getattr__ = _safe_subprocess_getattr
-del _SafeShellLoader, _safe_shell_sys, _safe_shell_imports, _safe_subprocess
-`);
-  } finally {
-    runtime.globals.delete("_safe_shell_source");
-  }
-}
-
-// packages/safe-bash/src/commands/python/jspi-run-sync.ts
-init_platform();
-function installPythonJspiRunSync(runtime) {
-  runtime.runPython(`
-import pyodide.ffi as _safe_jspi_ffi
-def _safe_jspi_run_sync(awaitable, _original=_safe_jspi_ffi.run_sync):
- async def capture():
-  try:
-   return True, await awaitable
-  except BaseException as error:
-   return False, error
- completed, value = _original(capture())
- if completed:
-  return value
- raise value
-_safe_jspi_ffi.run_sync = _safe_jspi_run_sync
-del _safe_jspi_ffi, _safe_jspi_run_sync
-`);
-}
-
-// packages/safe-bash/src/commands/python/library-adapter.ts
-init_platform();
-var pythonLibraryAdapter = String.raw`
-import sys as _safe_library_sys, types as _safe_library_types
-import safe_host as _safe_library_host
-
-class _SafeLibraryBridge:
- def __init__(self, name, host):
-  self.name, self.host = name, host
- def call(self, operation, payload):
-  if self.name != 'shell' or operation != 'run':
-   raise NotImplementedError('Unsupported synchronous library operation')
-  request = self.shell_request(payload)
-  try:
-   result = self.host.call('shell', request)
-  except self.host.HostError as error:
-   return dict(error=dict(code=error.code, message=str(error), stdout=[], stderr=[]))
-  if result.get('error'):
-   return result
-  for name in ('stdout', 'stderr'):
-   if payload.get(name) == 'inherit':
-    import sys
-    getattr(sys, name).buffer.write(bytes(result[name]))
-  return dict(returncode=result['exitCode'], stdout=result['stdout'], stderr=result['stderr'])
- async def async_call(self, operation, payload):
-  if self.name != 'shell' or operation != 'run':
-   raise NotImplementedError('Unsupported asynchronous shell operation')
-  try:
-   result = await self.wait('begin', capability='shell', value=self.shell_request(payload))
-  except self.host.HostError as error:
-   return dict(error=dict(code=error.code, message=str(error), stdout=[], stderr=[]))
-  if result.get('error'):
-   return result
-  return dict(returncode=result['exitCode'], stdout=result['stdout'], stderr=result['stderr'])
- def shell_request(self, payload):
-  request = {key: payload[key] for key in ('argv', 'script', 'cwd', 'env') if payload.get(key) is not None}
-  if 'input' in payload:
-   request['stdin'] = payload['input']
-  elif payload.get('stdin') == 'inherit':
-   request['stdinMode'] = 'inherit'
-  if payload.get('max_output_bytes') is not None:
-   request['maxOutputBytes'] = payload['max_output_bytes']
-  if payload.get('timeout') is not None:
-   request['timeoutMs'] = max(1, int(payload['timeout'] * 1000))
-  return request
- def fail(self, error):
-  code, message = error.get('code', 'service'), error.get('message', 'Host service failed')
-  if self.name == 'llm':
-   from poe_llm import LlmError, LimitError, CapabilityError
-   if code == 'limit':
-    raise LimitError(message)
-   if code == 'timeout':
-    import asyncio
-    raise asyncio.TimeoutError(message)
-   if code == 'capability':
-    raise CapabilityError(message)
-   raise LlmError(code, message)
-  from poe_shell import ShellError
-  raise ShellError(code, message)
- async def wait(self, operation, **fields):
-  import asyncio
-  handle = self.host._send(operation, **fields)
-  delay = 0.001
-  try:
-   while True:
-    result = self.host._send('poll', handle=handle)
-    if result['done']:
-     handle = None
-     if result.get('error'):
-      raise self.host.HostError(result['error'], result.get('errorCode', 'service'))
-     return result['value']
-    await asyncio.sleep(delay)
-    delay = min(0.016, delay * 2)
-  finally:
-   if handle is not None:
-    self.host._send('cancel', handle=handle)
- async def stream(self, payload):
-  if self.name == 'shell':
-   payload = self.shell_request(payload)
-  handle = self.host._send('stream', capability=self.name, value=payload)
-  cancelled = False
-  try:
-   while True:
-    result = await self.wait('begin-next', handle=handle)
-    if result['done']:
-     handle = None
-     break
-    event = result['value']
-    if event['type'] == 'bytes':
-     yield dict(type='bytes', data=event['bytes'])
-    elif event['type'] == 'text':
-     yield dict(type='text', text=event['text'])
-    else:
-     value = event['value']
-     if isinstance(value, dict) and value.get('error'):
-      self.fail(value['error'])
-     yield value
-  except self.host.HostError as error:
-   cancelled = True
-   self.fail(dict(code=error.code, message=str(error)))
-  except BaseException:
-   cancelled = True
-   raise
-  finally:
-   if handle is not None:
-    try:
-     self.host._send('release', handle=handle)
-    except self.host.HostError:
-     if not cancelled:
-      raise
-
-class _SafeAsyncLibraryBridge(_SafeLibraryBridge):
- async def call(self, operation, payload):
-  try:
-   value = await self.wait('begin', capability=self.name, value=dict(operation=operation, payload=payload))
-  except self.host.HostError as error:
-   self.fail(dict(code=error.code if error.code != 'service' else 'capability', message=str(error)))
-  if isinstance(value, dict) and value.get('error'):
-   self.fail(value['error'])
-  return value
-
-for _safe_library_name in ('llm', 'shell'):
- _safe_library_module = _safe_library_types.ModuleType('_poe_' + _safe_library_name + '_capability')
- _safe_library_type = _SafeAsyncLibraryBridge if _safe_library_name == 'llm' else _SafeLibraryBridge
- _safe_library_module.bridge = _safe_library_type(_safe_library_name, _safe_library_host)
- _safe_library_sys.modules[_safe_library_module.__name__] = _safe_library_module
-
-del _safe_library_sys, _safe_library_types, _safe_library_host, _safe_library_name, _safe_library_module, _safe_library_type
-`;
-
-// packages/safe-bash/src/commands/python/host-module.ts
-init_platform();
-var pythonHostModule = `
-import types as _safe_host_types
-_safe_host_module = _safe_host_types.ModuleType('safe_host')
-exec('''
-import json
-from _safe_native_fs import request as _request
-
-class HostError(RuntimeError):
- def __init__(self, message, code='service'):
-  super().__init__(message)
-  self.code = code
-
-def _send(operation, **fields):
- payload = dict(version=1, operation=operation, **fields)
- response = json.loads(_request(json.dumps(['host', payload], allow_nan=False)))
- if 'error' in response:
-  raise HostError(response['error'], response.get('errorCode', 'service'))
- return response['value']
-
-def call(capability, value=None):
- """Call an explicitly granted host operation using JSPI suspension."""
- return _send('call', capability=capability, value=value)
-
-class Stream:
- def __init__(self, capability, value=None):
-  self._handle = _send('stream', capability=capability, value=value)
- def __iter__(self):
-  return self
- def __next__(self):
-  if self._handle is None:
-   raise StopIteration
-  try:
-   item = _send('next', handle=self._handle)
-  except BaseException:
-   self.close()
-   raise
-  if item['done']:
-   self._handle = None
-   raise StopIteration
-  event = item['value']
-  if event['type'] == 'bytes':
-   return bytes(event['bytes'])
-  if event['type'] == 'text':
-   return event['text']
-  return event['value']
- def close(self):
-  handle, self._handle = self._handle, None
-  if handle is not None:
-   _send('release', handle=handle)
- def __enter__(self):
-  return self
- def __exit__(self, *_):
-  self.close()
-
-def stream(capability, value=None):
- return Stream(capability, value)
-
-class CalledProcessError(HostError):
- def __init__(self, result):
-  self.returncode, self.cmd = result.returncode, result.args
-  self.output, self.stderr = result.stdout, result.stderr
-  super().__init__('Safe Bash command exited with status ' + str(self.returncode))
-
-class CompletedProcess:
- def __init__(self, args, result, text):
-  self.args, self.returncode = args, result['exitCode']
-  self.stdout, self.stderr = bytes(result['stdout']), bytes(result['stderr'])
-  if text:
-   self.stdout, self.stderr = self.stdout.decode('utf-8'), self.stderr.decode('utf-8')
- def check_returncode(self):
-  if self.returncode:
-   raise CalledProcessError(self)
-
-def run(args, *, shell=False, input=None, cwd=None, env=None, text=False, check=False, timeout=None):
- """Run a configured Safe Bash command; capture is bounded by the host."""
- if shell:
-  if not isinstance(args, str):
-   raise TypeError('script mode requires a string')
-  request = dict(script=args)
- else:
-  if isinstance(args, str):
-   raise TypeError('literal execution requires an argv sequence')
-  request = dict(argv=list(args))
- if input is not None:
-  request['stdin'] = input if isinstance(input, str) else list(input)
- if cwd is not None:
-  request['cwd'] = cwd
- if env is not None:
-  request['env'] = env
- if timeout is not None:
-  request['timeoutMs'] = max(1, int(timeout * 1000))
- value = call('shell', request)
- if value.get('error'):
-  failure = value['error']
-  if failure.get('code') == 'timeout':
-   import subprocess
-   raise subprocess.TimeoutExpired(args, timeout, output=bytes(failure['stdout']), stderr=bytes(failure['stderr']))
-  raise HostError(failure.get('message', 'Shell service failed'), failure.get('code', 'service'))
- result = CompletedProcess(args, value, text)
- if check:
-  result.check_returncode()
- return result
-
-def check_output(args, **options):
- return run(args, check=True, **options).stdout
-''', _safe_host_module.__dict__)
-sys.modules['safe_host'] = _safe_host_module
-`;
-
-// packages/safe-bash/src/commands/python/jspi-trampoline.ts
-init_platform();
-var pythonJspiSignatures = Object.freeze({
-  __syscall_chdir: "ip",
-  __syscall_chmod: "ipi",
-  __syscall_dup: "ii",
-  __syscall_faccessat: "iipii",
-  __syscall_fcntl64: "iiip",
-  __syscall_fdatasync: "ii",
-  __syscall_fstat64: "iip",
-  __syscall_ftruncate64: "iij",
-  __syscall_getcwd: "ipp",
-  __syscall_getdents64: "iipp",
-  __syscall_ioctl: "iiip",
-  __syscall_lstat64: "ipp",
-  __syscall_mkdirat: "iipi",
-  __syscall_newfstatat: "iippi",
-  __syscall_openat: "iipip",
-  __syscall_readlinkat: "iippp",
-  __syscall_renameat: "iipip",
-  __syscall_rmdir: "ip",
-  __syscall_stat64: "ipp",
-  __syscall_symlinkat: "ipip",
-  __syscall_truncate64: "ipj",
-  __syscall_unlinkat: "iipi",
-  __syscall_utimensat: "iippi",
-  fd_close: "ii",
-  fd_fdstat_get: "iip",
-  fd_pread: "iippjp",
-  fd_pwrite: "iippjp",
-  fd_read: "iippp",
-  fd_seek: "iijip",
-  fd_sync: "ii",
-  fd_write: "iippp"
-});
-var unsigned = (value) => {
-  const bytes = [];
-  do {
-    bytes.push(value & 127 | (value > 127 ? 128 : 0));
-    value >>>= 7;
-  } while (value);
-  return bytes;
-};
-var vector = (entries) => [...unsigned(entries.length), ...entries.flat()];
-var text = (value) => {
-  const bytes = new TextEncoder().encode(value);
-  return [...unsigned(bytes.length), ...bytes];
-};
-var section = (type, bytes) => [type, ...unsigned(bytes.length), ...bytes];
-var signature = (parameters, result) => [96, ...vector(parameters.map((type) => [type])), ...result === void 0 ? [0] : [1, result]];
-function createPythonJspiTrampoline() {
-  const entries = Object.entries(pythonJspiSignatures);
-  const types = entries.flatMap(([, value]) => {
-    const parameters = [...value.slice(1)].map((type) => type === "j" ? 126 : 127);
-    return [signature(parameters, 127), signature(parameters, 111)];
-  });
-  types.push(signature([111], 127));
-  const imports = entries.flatMap(([name], index) => [
-    [...text("original"), ...text(name), 0, ...unsigned(index * 2)],
-    [...text("request"), ...text(name), 0, ...unsigned(index * 2 + 1)],
-    [...text("shutdown"), ...text(name), 0, ...unsigned(index * 2)]
-  ]);
-  imports.push([...text("control"), ...text("syncify"), 1, 112, 0, 1]);
-  imports.push([...text("control"), ...text("active"), 3, 127, 1]);
-  const functions = entries.map(([, value], index) => {
-    const argumentsBytes = [...value.slice(1)].flatMap((_type, parameter) => [32, ...unsigned(parameter)]);
-    const code = [
-      0,
-      35,
-      0,
-      4,
-      127,
-      35,
-      0,
-      65,
-      2,
-      70,
-      4,
-      127,
-      ...argumentsBytes,
-      16,
-      ...unsigned(index * 3 + 2),
-      5,
-      ...argumentsBytes,
-      16,
-      ...unsigned(index * 3 + 1),
-      65,
-      0,
-      17,
-      ...unsigned(entries.length * 2),
-      0,
-      11,
-      5,
-      ...argumentsBytes,
-      16,
-      ...unsigned(index * 3),
-      11,
-      11
-    ];
-    return [...unsigned(code.length), ...code];
-  });
-  return new Uint8Array([
-    0,
-    97,
-    115,
-    109,
-    1,
-    0,
-    0,
-    0,
-    ...section(1, vector(types)),
-    ...section(2, vector(imports)),
-    ...section(3, vector(entries.map((_entry, index) => unsigned(index * 2)))),
-    ...section(7, vector(entries.map(([name], index) => [...text(name), 0, ...unsigned(entries.length * 3 + index)]))),
-    ...section(10, vector(functions))
-  ]);
-}
-function createPythonJspiNativeCall() {
-  const types = [
-    signature([127], 127),
-    signature([127]),
-    signature([127], 111),
-    signature([111], 127),
-    signature([127, 127], 127),
-    signature([], 127)
-  ];
-  const imports = [
-    ["python", "utf8", 0],
-    ["python", "unicode", 0],
-    ["python", "free", 1],
-    ["python", "noMemory", 5],
-    ["request", "send", 2],
-    ["shutdown", "send", 0]
-  ];
-  const code = [
-    1,
-    2,
-    127,
-    32,
-    1,
-    16,
-    0,
-    34,
-    2,
-    69,
-    4,
-    127,
-    65,
-    0,
-    5,
-    35,
-    0,
-    65,
-    2,
-    70,
-    4,
-    127,
-    32,
-    2,
-    16,
-    5,
-    5,
-    32,
-    2,
-    16,
-    4,
-    65,
-    0,
-    17,
-    3,
-    0,
-    11,
-    34,
-    2,
-    69,
-    4,
-    127,
-    16,
-    3,
-    5,
-    32,
-    2,
-    16,
-    1,
-    33,
-    3,
-    32,
-    2,
-    16,
-    2,
-    32,
-    3,
-    11,
-    11,
-    11
-  ];
-  return new Uint8Array([
-    0,
-    97,
-    115,
-    109,
-    1,
-    0,
-    0,
-    0,
-    ...section(1, vector(types)),
-    ...section(2, vector([
-      ...imports.map(([namespace, name, type]) => [...text(namespace), ...text(name), 0, type]),
-      [...text("control"), ...text("syncify"), 1, 112, 0, 1],
-      [...text("control"), ...text("active"), 3, 127, 1]
-    ])),
-    ...section(3, vector([[4]])),
-    ...section(7, vector([[...text("call"), 0, 6]])),
-    ...section(10, vector([[...unsigned(code.length), ...code]]))
-  ]);
-}
-function createPythonJspiStatResult() {
-  const types = [
-    signature([127], 127),
-    signature([127]),
-    signature([127, 127], 127),
-    signature([127, 127, 127]),
-    signature([], 127)
-  ];
-  const imports = [["create", 0], ["size", 0], ["item", 2], ["retain", 1], ["set", 3], ["invalid", 4]];
-  const code = [
-    1,
-    3,
-    127,
-    32,
-    1,
-    16,
-    1,
-    35,
-    0,
-    71,
-    4,
-    64,
-    16,
-    5,
-    15,
-    11,
-    32,
-    0,
-    16,
-    0,
-    34,
-    2,
-    69,
-    4,
-    127,
-    65,
-    0,
-    5,
-    2,
-    64,
-    3,
-    64,
-    32,
-    3,
-    35,
-    0,
-    79,
-    13,
-    1,
-    32,
-    1,
-    32,
-    3,
-    16,
-    2,
-    34,
-    4,
-    16,
-    3,
-    32,
-    2,
-    32,
-    3,
-    32,
-    4,
-    16,
-    4,
-    32,
-    3,
-    65,
-    1,
-    106,
-    33,
-    3,
-    12,
-    0,
-    11,
-    11,
-    32,
-    2,
-    11,
-    11
-  ];
-  return new Uint8Array([
-    0,
-    97,
-    115,
-    109,
-    1,
-    0,
-    0,
-    0,
-    ...section(1, vector(types)),
-    ...section(2, vector([
-      ...imports.map(([name, type]) => [...text("python"), ...text(name), 0, type]),
-      [...text("python"), ...text("fields"), 3, 127, 0]
-    ])),
-    ...section(3, vector([[2]])),
-    ...section(7, vector([[...text("construct"), 0, 6]])),
-    ...section(10, vector([[...unsigned(code.length), ...code]]))
-  ]);
-}
-
-// packages/safe-bash/src/commands/python/jspi-scheduler.ts
-init_platform();
-function createPythonJspiScheduler() {
-  const queued = /* @__PURE__ */ new Map();
-  const active = /* @__PURE__ */ new Set();
-  const failures = [];
-  let closed = false;
-  let retirement;
-  return {
-    scheduleCallback(callback, delay = 0) {
-      if (closed) {
-        callback.destroy?.();
-        throw new Error("Python scheduler is closed");
-      }
-      const timer = setTimeout(() => {
-        queued.delete(timer);
-        const work = Promise.resolve().then(() => callback()).then(() => {
-        }, (error) => {
-          failures.push(error);
-        }).finally(() => {
-          active.delete(work);
-        });
-        active.add(work);
-      }, delay);
-      queued.set(timer, callback);
-    },
-    close() {
-      if (retirement) return retirement;
-      if (!active.size) closed = true;
-      retirement = Promise.resolve().then(async () => {
-        while (active.size) await Promise.all(active);
-        closed = true;
-        for (const [timer, callback] of queued) {
-          clearTimeout(timer);
-          try {
-            callback.destroy?.();
-          } catch (error) {
-            failures.push(error);
-          }
-        }
-        queued.clear();
-        if (failures.length === 1) throw failures[0];
-        if (failures.length) throw new AggregateError(failures, "Python callback retirement failed");
-      });
-      return retirement;
-    }
-  };
-}
-
-// packages/safe-bash/src/commands/python/jspi.ts
-function createPythonJspiExecutor(options) {
-  const engine = globalThis.WebAssembly;
-  const active = new engine.Global({ value: "i32", mutable: true }, 0);
-  const syncify = new engine.Table({ element: "anyfunc", initial: 1 });
-  const controller = new AbortController();
-  const scheduler = createPythonJspiScheduler();
-  let admitted = false;
-  let running;
-  let retirement;
-  let schedulerCleanup;
-  let cleanup;
-  let runtime;
-  let native;
-  let instanceBound = false;
-  let importsBound = false;
-  let schedulerBound = false;
-  let methodDefinition = 0;
-  let methodPointer;
-  let statPointer;
-  const originals = {};
-  const execute = async (start) => {
-    const signal = AbortSignal.any([start.signal, controller.signal]);
-    const configuration = parsePythonInvocation(start.invocation.args, start.invocation.env);
-    let guestMask = 18;
-    let qualified = false;
-    let exitCode = 0;
-    let finalized = 0;
-    let acceptingHostCalls = true;
-    let hostCleanupFailure;
-    try {
-      signal.throwIfAborted();
-      if (start.packages?.requirements.length || start.installOnly) throw new PythonFailure("runtime-assets", { cause: new Error("JSPI runtime requires statically qualified packages") });
-      runtime = await options.loadRuntime({
-        jsglobals: /* @__PURE__ */ Object.create(null),
-        args: configuration.startupArgs,
-        env: configuration.env,
-        bindImports(imports) {
-          if (importsBound) throw new PythonFailure("runtime-abi");
-          const namespaces = [...new Set(Object.values(imports))];
-          for (const namespace of namespaces) {
-            for (const [name, value] of Object.entries(namespace)) {
-              if (typeof value !== "function") continue;
-              if (name === "__syscall_umask_js") namespace[name] = (mask) => {
-                const previous = guestMask;
-                guestMask = mask & 511;
-                return previous;
-              };
-              else if (name in pythonJspiSignatures) originals[name] = value;
-              else if (name.startsWith("__syscall_") || name === "_maybe_connect_async") namespace[name] = () => -52;
-              else if (name === "_emscripten_system") namespace[name] = (command) => command === 0 ? 0 : -52;
-            }
-          }
-          if (!originals.fd_read || !originals.fd_write || !originals.__syscall_openat) throw new PythonFailure("runtime-abi");
-          const original = Object.fromEntries(Object.keys(pythonJspiSignatures).map((name) => [name, originals[name] ?? (() => -52)]));
-          const request = Object.fromEntries(Object.keys(pythonJspiSignatures).map((name) => [
-            name,
-            (...args) => native.invoke(name, args)
-          ]));
-          const shutdown = Object.fromEntries(Object.entries(request).map(([name, dispatch]) => [name, new engine.Suspending(dispatch)]));
-          const bridge = new engine.Instance(options.trampoline, { original, request, shutdown, control: { active, syncify } });
-          for (const namespace of namespaces) for (const name of Object.keys(originals)) {
-            if (typeof namespace[name] === "function") namespace[name] = bridge.exports[name];
-          }
-          importsBound = true;
-        },
-        bindInstance(instance) {
-          if (instanceBound || !importsBound || typeof instance.exports.syscall_syncify !== "function") throw new PythonFailure("runtime-abi");
-          syncify.set(0, instance.exports.syscall_syncify);
-          instanceBound = true;
-        },
-        bindScheduler(api) {
-          if (schedulerBound) throw new PythonFailure("runtime-abi");
-          api.scheduleCallback = scheduler.scheduleCallback;
-          schedulerBound = true;
-        }
-      });
-      if (!importsBound || !instanceBound || !schedulerBound || runtime.version !== "314.0.6" || !runtime._module.jspiSupported) throw new PythonFailure("runtime-abi");
-      qualified = true;
-      signal.throwIfAborted();
-      runtime.runPython("import sys, os, json, runpy, traceback, types, warnings, textwrap, io, struct, linecache, importlib.machinery, shutil, stat, pyodide.ffi");
-      runtime.globals.set("_safe_runtime_mount", start.runtimeMount);
-      const filesystem = runtime.FS;
-      const bootstrap = filesystem.root;
-      filesystem.root = null;
-      filesystem.mount(filesystem.filesystems.MEMFS, {}, "/");
-      filesystem.mkdir(start.runtimeMount);
-      filesystem.mount({ mount: () => bootstrap }, {}, start.runtimeMount);
-      runtime.runPython(pythonRuntimeRelocation);
-      filesystem.currentPath = start.invocation.cwd;
-      native = createPythonNativeSyscalls({
-        getUmask: () => guestMask,
-        runtime: runtime._module,
-        cwd: start.invocation.cwd,
-        runtimeMount: start.runtimeMount,
-        maxTransferBytes: start.maxTransferBytes,
-        signal,
-        dispatch: start.dispatch,
-        original: (name, args) => originals[name](...args)
-      });
-      const errno = JSON.parse(runtime.runPython("__import__('json').dumps({name:value for name,value in vars(__import__('errno')).items() if name.startswith('E') and isinstance(value,int)})"));
-      const encode = async (operation) => {
-        try {
-          return JSON.stringify(await operation());
-        } catch (error) {
-          return JSON.stringify({ errno: signal.aborted ? errno.EINTR : error.errno ?? errno[error.code ?? ""] ?? errno.EIO });
-        }
-      };
-      const absolute = (path) => path.startsWith("/") ? path : filesystem.cwd() + "/" + path;
-      const bootstrapPath = (path) => path === start.runtimeMount || path.startsWith(start.runtimeMount + "/");
-      const module = runtime._module;
-      const send = async (pointer) => {
-        let response = await encode(async () => {
-          const payload = JSON.parse(module.UTF8ToString(pointer));
-          if (payload[0] === "host") {
-            try {
-              if (!start.host || !acceptingHostCalls) throw new Error("Python host capability unavailable");
-              return { value: await start.host.request(payload[1]) };
-            } catch (error) {
-              return { errorCode: pythonHostFailureCode(error), error: signal.aborted ? "Python host operation cancelled" : "Python host operation failed" };
-            }
-          }
-          signal.throwIfAborted();
-          const [operation, path, follow] = payload;
-          if (operation === "stat") return native.metadata(path, follow);
-          if (typeof path !== "string") throw Object.assign(new Error("Invalid native Python path"), { code: "EINVAL" });
-          const target = absolute(path);
-          if (operation === "directory") {
-            const entries = bootstrapPath(target) ? filesystem.readdir(target).filter((name) => name !== "." && name !== "..") : (await start.dispatch({ op: "readdir", args: [target] })).map((entry) => entry.name);
-            return { entries };
-          }
-          if (operation === "tree") {
-            if (bootstrapPath(target) || !await start.dispatch({ op: "rmtreeSupported", args: [target] })) return { supported: false };
-            try {
-              await start.dispatch({ op: "rmtree", args: [target] });
-              return { supported: true };
-            } catch (error) {
-              return { supported: true, errno: errno[error.code ?? ""] ?? errno.EIO };
-            }
-          }
-          throw Object.assign(new Error("Invalid native Python operation"), { code: "EINVAL" });
-        });
-        if (response.length > 1048576) response = JSON.stringify({ errno: errno.EFBIG });
-        let bytes = new TextEncoder().encode(response);
-        if (bytes.length > 1048576) bytes = new TextEncoder().encode(JSON.stringify({ errno: errno.EFBIG }));
-        const output = module._malloc(bytes.length + 1);
-        if (!output) return 0;
-        module.HEAPU8.set(bytes, output);
-        module.HEAPU8[output + bytes.length] = 0;
-        return output;
-      };
-      const nativeCall = new engine.Instance(options.nativeCall, {
-        python: {
-          utf8: module._PyUnicode_AsUTF8,
-          unicode: module._PyUnicode_FromString,
-          free: module._free,
-          noMemory: module._PyErr_NoMemory
-        },
-        request: { send },
-        shutdown: { send: new engine.Suspending(send) },
-        control: { active, syncify }
-      });
-      methodPointer = module.addFunction(nativeCall.exports.call, "iii");
-      methodDefinition = module._malloc(128);
-      if (!methodDefinition) throw new PythonFailure("runtime-assets");
-      module.HEAPU8.fill(0, methodDefinition, methodDefinition + 128);
-      module.HEAPU8.set(new TextEncoder().encode("request\0_safe_native_fs\0"), methodDefinition + 16);
-      module.HEAPU32.set([methodDefinition + 16, methodPointer, 8, 0], methodDefinition / 4);
-      const extension = module._PyImport_AddModule(methodDefinition + 24);
-      const callable = module._PyCFunction_NewEx(methodDefinition, 0, 0);
-      if (!extension || !callable || module._PyModule_AddObject(extension, methodDefinition + 16, callable) < 0) throw new PythonFailure("runtime-abi");
-      const fields = Number(runtime.runPython("os.stat_result.n_fields"));
-      const statResult = new engine.Instance(options.statResult, { python: {
-        fields: new engine.Global({ value: "i32" }, fields),
-        create: module._PyStructSequence_New,
-        size: module._PyTuple_Size,
-        item: module._PyTuple_GetItem,
-        retain: module._Py_IncRef,
-        set: module._PyStructSequence_SetItem,
-        invalid: module._PyErr_BadArgument
-      } });
-      statPointer = module.addFunction(statResult.exports.construct, "iii");
-      module.HEAPU8.set(new TextEncoder().encode("stat_result\0os\0"), methodDefinition + 80);
-      module.HEAPU32.set([methodDefinition + 80, statPointer, 8, 0], (methodDefinition + 64) / 4);
-      const osModule = module._PyImport_AddModule(methodDefinition + 92);
-      const statType = module._PyObject_GetAttrString(osModule, methodDefinition + 80);
-      const constructStat = module._PyCFunction_NewEx(methodDefinition + 64, statType, 0);
-      module._Py_DecRef(statType);
-      if (!constructStat || module._PyModule_AddObject(extension, methodDefinition + 80, constructStat) < 0) throw new PythonFailure("runtime-abi");
-      runtime.runPython(`
-from _safe_native_fs import request as _safe_native_request
-def _safe_stat_projection(path, follow):
- return _safe_native_request(json.dumps(['stat', path, follow]))
-def _safe_import_stat(path):
- return _safe_stat_projection(path, True)
-def _safe_directory_entries(path):
- return _safe_native_request(json.dumps(['directory', path]))
-def _safe_tree_cleanup(path):
- return _safe_native_request(json.dumps(['tree', path]))
-`);
-      for (const script of [pythonImportMetadata, pythonDirectoryEntries, pythonStatProjection, pythonTreeCleanup]) runtime.runPython(script);
-      runtime.runPython(`
-from _safe_native_fs import stat_result as _safe_construct_stat
-_safe_stat_fields = os.stat_result.n_fields
-_safe_stat_probe = os.stat_result(tuple(range(_safe_stat_fields)))
-_safe_stat_indexes = {name: getattr(_safe_stat_probe, name) for name in dir(_safe_stat_probe) if name.startswith('st_')}
-def _safe_native_stat_type(values, extras):
- fields = list(values) + [None] * (_safe_stat_fields - len(values))
- for name, value in extras.items():
-  if name in _safe_stat_indexes:
-   fields[_safe_stat_indexes[name]] = value
- return _safe_construct_stat(tuple(fields))
-_safe_stat_type = _safe_native_stat_type
-`);
-      runtime.runPython(pythonHostModule);
-      installPythonLlmModule(runtime);
-      installPythonShellModule(runtime);
-      installPythonJspiRunSync(runtime);
-      runtime.runPython(pythonLibraryAdapter);
-      runtime.globals.set("_safe_invocation_json", JSON.stringify(start.invocation));
-      runtime.globals.set("_safe_execution_code", pythonExecution);
-      runtime.globals.set("_safe_is_cancelled", () => signal.aborted);
-      active.value = 1;
-      start.onReady();
-      exitCode = Number(await runtime.runPythonAsync(`
-try:
- exec(_safe_execution_code)
-except BaseException:
- if not _safe_is_cancelled():
-  raise
- _safe_exit = 130
-_safe_exit
-`)) & 255;
-    } finally {
-      try {
-        if (qualified) {
-          acceptingHostCalls = false;
-          try {
-            try {
-              await start.host?.close();
-            } catch (error) {
-              if (!signal.aborted) hostCleanupFailure = { reason: error };
-            }
-          } finally {
-            try {
-              await runtime.runPythonAsync(`
-import asyncio as _safe_asyncio
-async def _safe_quiesce_tasks():
- current = _safe_asyncio.current_task()
- while True:
-  pending = [task for task in _safe_asyncio.all_tasks() if task is not current]
-  if not pending:
-   break
-  for task in pending:
-   task.cancel()
-  await _safe_asyncio.gather(*pending, return_exceptions=True)
- loop = _safe_asyncio.get_running_loop()
- await loop.shutdown_asyncgens()
- await loop.shutdown_default_executor()
-await _safe_quiesce_tasks()
-`);
-            } finally {
-              try {
-                await scheduler.close();
-              } finally {
-                active.value = native ? 2 : 0;
-                finalized = Number(await engine.promising(runtime._module._Py_FinalizeEx)());
-              }
-            }
-          }
-        }
-      } finally {
-        active.value = 0;
-        schedulerCleanup = scheduler.close();
-        cleanup = schedulerCleanup.finally(() => native?.close());
-        try {
-          await cleanup;
-        } finally {
-          if (methodDefinition) runtime?._module._free(methodDefinition);
-          if (methodPointer !== void 0) runtime?._module.removeFunction(methodPointer);
-          if (statPointer !== void 0) runtime?._module.removeFunction(statPointer);
-          runtime = void 0;
-          native = void 0;
-          syncify.set(0, null);
-          for (const name of Object.keys(originals)) delete originals[name];
-        }
-      }
-    }
-    if (hostCleanupFailure) throw hostCleanupFailure.reason;
-    signal.throwIfAborted();
-    return finalized < 0 ? 120 : exitCode;
-  };
-  return {
-    run(start) {
-      if (admitted || retirement) return Promise.reject(new PythonFailure("executor-unavailable"));
-      admitted = true;
-      running = execute(start);
-      return running;
-    },
-    terminate() {
-      retirement ??= (async () => {
-        controller.abort();
-        await running?.catch(() => {
-        });
-        await cleanup?.catch(() => {
-        });
-        await schedulerCleanup;
-      })();
-      return retirement;
-    }
-  };
-}
-
-// packages/safe-bash/src/commands/python/jspi-assets.ts
-init_platform();
-function createPythonJspiAssets(options) {
-  const engine = globalThis.WebAssembly;
-  const main = options.main;
-  const registry = options.modules.map((entry) => ({ module: entry.module, bytes: Uint8Array.from(entry.bytes) }));
-  if (![main, ...registry.map((entry) => entry.module)].every((module) => module instanceof engine.Module)) throw new TypeError("Expected precompiled Python Wasm modules");
-  const stdlib = Uint8Array.from(options.stdlib);
-  const responses = /* @__PURE__ */ new WeakMap();
-  const approved = /* @__PURE__ */ new Set([main, ...registry.map((entry) => entry.module)]);
-  const select = (source) => {
-    const bytes = ArrayBuffer.isView(source) ? new Uint8Array(source.buffer, source.byteOffset, source.byteLength) : new Uint8Array(source);
-    const entry = registry.find((candidate) => candidate.bytes.length === bytes.length && candidate.bytes.every((byte, index) => byte === bytes[index]));
-    if (!entry) throw new engine.CompileError("Unapproved Python runtime Wasm bytes");
-    return entry.module;
-  };
-  const WebAssembly = Object.create(engine);
-  WebAssembly.Module = function(source) {
-    return select(source);
-  };
-  Object.setPrototypeOf(WebAssembly.Module, engine.Module);
-  WebAssembly.Module.prototype = engine.Module.prototype;
-  WebAssembly.compile = async (source) => select(source);
-  WebAssembly.compileStreaming = async () => {
-    throw new engine.CompileError("Unapproved Python streaming compilation");
-  };
-  WebAssembly.instantiate = async (source, imports) => {
-    if (source instanceof engine.Module) {
-      if (!approved.has(source)) throw new engine.CompileError("Unapproved Python Wasm module");
-      return new engine.Instance(source, imports);
-    }
-    const module = select(source);
-    return { module, instance: new engine.Instance(module, imports) };
-  };
-  WebAssembly.instantiateStreaming = async (response, imports) => {
-    const module = responses.get(await response);
-    if (!module) throw new engine.CompileError("Unapproved Python Wasm response");
-    return { module, instance: new engine.Instance(module, imports) };
-  };
-  const location = "https://safe-python.invalid/";
-  return { WebAssembly, location, async fetch(url) {
-    const target = new URL(url, location).href;
-    if (target === location + "python_stdlib.zip") return new Response(stdlib);
-    if (target === location + "pyodide.asm.wasm") {
-      const response = new Response(null, { headers: { "Content-Type": "application/wasm" } });
-      responses.set(response, main);
-      return response;
-    }
-    throw new Error("Unapproved Python runtime asset");
-  } };
-}
-
-// packages/safe-bash/src/commands/python/index.ts
-var PythonInputChunkError = class extends RangeError {
-};
-function createPythonCommands(options) {
-  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.createCapabilities && !options.createExecutor) throw new TypeError("Python host capabilities require an asynchronous executor");
-  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;
-  const maxConcurrentWorkers = options.maxConcurrentWorkers ?? Infinity;
-  const maxInputChunkBytes = options.maxInputChunkBytes ?? Infinity;
-  if (options.maxConcurrentWorkers !== void 0 && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1)) throw new RangeError("Invalid Python worker concurrency limit");
-  if (options.maxInputChunkBytes !== void 0 && (!Number.isSafeInteger(maxInputChunkBytes) || maxInputChunkBytes < 1)) throw new RangeError("Invalid Python input chunk limit");
-  let activeWorkers = 0;
-  for (const size of [maxTransferBytes, maxOpenFiles, options.maxDirectoryEntries]) if (size !== void 0 && (!Number.isSafeInteger(size) || size < 1)) 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 = options.environment ?? createPythonPackageEnvironment(options.provisioning);
-  const execute = async (context) => {
-    if (pythonShellDispatchActive(context.executionScope)) {
-      await (0, io_exports.writeBytes)(context.stderr, new TextEncoder().encode("python: nested Python execution is unavailable while the parent interpreter is suspended\n"), context.signal);
-      return { exitCode: 1 };
-    }
-    let installation;
-    try {
-      parsePythonInvocation(context.args, context.env);
-      installation = parsePythonInstallation(context.args);
-    } catch (error) {
-      if (!(error instanceof PythonInvocationError)) throw error;
-      await (0, io_exports.writeBytes)(context.stderr, new TextEncoder().encode("python: " + error.message + "\n"), context.signal);
-      return { exitCode: 2 };
-    }
-    if (installation?.help) {
-      await (0, io_exports.writeBytes)(context.stdout, new TextEncoder().encode(pythonInstallationHelp), context.signal);
-      return { exitCode: 0 };
-    }
-    context.signal.throwIfAborted();
-    if (activeWorkers >= maxConcurrentWorkers) {
-      const failure2 = reportPythonFailure("capacity", void 0, options.onDiagnostic);
-      await (0, io_exports.writeBytes)(context.stderr, new TextEncoder().encode("python: " + failure2.message + "\n"), context.signal);
-      return { exitCode: 1 };
-    }
-    const controller = new AbortController();
-    const signal = AbortSignal.any([context.signal, controller.signal]);
-    (0, yield_exports.inheritYieldCheckpoint)(context.signal, signal);
-    const fileContext = { ...context, descriptorCleanup: "caller" };
-    const metadata = new PythonStatTranslator();
-    const service = new PythonFileSystem(context.fs, {
-      cwd: context.cwd,
-      signal,
-      maxTransferBytes,
-      ...maxOpenFiles === void 0 ? {} : { maxOpenFiles },
-      ...options.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options.maxDirectoryEntries },
-      open: (path, settings) => (0, filesystem_descriptor_exports.openCommandFile)(fileContext, path, settings)
-    });
-    let hostBridge;
-    let stdoutOperation;
-    let stderrOperation;
-    let endpoint;
-    let executor;
-    let packages;
-    let unsubscribe;
-    let admitted = false;
-    let closed = false;
-    let closing;
-    const pending = /* @__PURE__ */ new Set();
-    const input = (0, io_exports.readBytes)(context.stdin, signal)[Symbol.asyncIterator]();
-    let fragment;
-    let offset = 0;
-    let inputBytes = 0;
-    let rejectRun;
-    const close = () => {
-      if (closing) return closing;
-      let finish;
-      let fail;
-      closing = new Promise((resolve, reject) => {
-        finish = resolve;
-        fail = reject;
-      });
-      closed = true;
-      controller.abort(new Error("Python invocation retired"));
-      void (async () => {
-        signal.removeEventListener("abort", aborted);
-        const subscription = Promise.resolve().then(() => unsubscribe?.());
-        const termination = Promise.resolve().then(() => executor ? executor.terminate() : endpoint?.terminate());
-        const filesystemRetirement = termination.finally(() => service.close());
-        const results = await Promise.allSettled([subscription, termination, filesystemRetirement, hostBridge?.close(), stdoutOperation?.close(), stderrOperation?.close(), ...pending]);
-        await input.return?.(void 0);
-        fragment = void 0;
-        if (packages) environment.finish(packages);
-        for (const result2 of results) if (result2.status === "rejected") throw result2.reason;
-      })().then(() => {
-        if (admitted) {
-          activeWorkers--;
-          admitted = false;
-        }
-        finish();
-      }, (reason) => {
-        fail(reportPythonFailure("cleanup", reason, options.onDiagnostic));
-      });
-      return closing;
-    };
-    const aborted = () => {
-      rejectRun?.(signal.reason);
-    };
-    context.registerCleanup?.(close);
-    let primary;
-    let ready = false;
-    const filesystemDiagnostics = /* @__PURE__ */ new Set();
-    let result = 1;
-    try {
-      signal.throwIfAborted();
-      activeWorkers++;
-      admitted = true;
-      const outputContext = { signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} };
-      stdoutOperation = (0, output_exports.createOutputOperation)(outputContext, context.stdout);
-      stderrOperation = (0, output_exports.createOutputOperation)(outputContext, context.stderr);
-      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 (0, io_exports.writeBytes)(stderrOperation.output, new TextEncoder().encode("python: " + failure2.message + "\n"), signal);
-        }
-      };
-      const dispatch = async (request) => {
-        if (request.op === "close") return service.dispatch(request);
-        signal.throwIfAborted();
-        if (request.op.startsWith("package-")) return environment.dispatch(request.op, request.args, { fs: context.fs, cwd: context.cwd, signal });
-        if (request.op === "stdin") {
-          const length = request.args[0];
-          if (!Number.isSafeInteger(length) || length < 1 || length > maxTransferBytes) throw new RangeError("Invalid Python input request");
-          let pulls = 0;
-          while (!fragment || offset === fragment.length) {
-            if (++pulls % 128 === 0) await (0, yield_exports.yieldTurn)(signal);
-            const next = await input.next();
-            if (next.done) return [];
-            inputBytes += next.value.length;
-            context.inputBudget?.check(inputBytes);
-            if (next.value.length > maxInputChunkBytes) throw new PythonInputChunkError("Python input chunk exceeds maxInputChunkBytes");
-            fragment = Uint8Array.from(next.value);
-            offset = 0;
-          }
-          const end = Math.min(fragment.length, offset + length);
-          const bytes = Array.from(fragment.subarray(offset, end));
-          offset = end;
-          return bytes;
-        }
-        if (request.op === "stdout" || request.op === "stderr") {
-          const bytes = request.args[0];
-          if (!Array.isArray(bytes) || bytes.length > maxTransferBytes || bytes.some((value2) => !Number.isInteger(value2) || value2 < 0 || value2 > 255)) throw new TypeError("Invalid Python output bytes");
-          const operation = request.op === "stdout" ? stdoutOperation : stderrOperation;
-          await (0, io_exports.writeBytes)(operation.output, Uint8Array.from(bytes), signal);
-          return bytes.length;
-        }
-        const value = await service.dispatch(request);
-        return request.op === "stat" || request.op === "lstat" || request.op === "fstat" ? metadata.translate(value) : value;
-      };
-      if (options.createCapabilities) {
-        const capabilityInput = { async *[Symbol.asyncIterator]() {
-          while (true) {
-            const bytes = await dispatch({ op: "stdin", args: [maxTransferBytes] });
-            if (!bytes.length) break;
-            yield Uint8Array.from(bytes);
-          }
-        } };
-        hostBridge = createPythonHostBridge(options.createCapabilities({ ...context, stdin: capabilityInput, signal }), { ...options.capabilityLimits, signal });
-      }
-      options.onProgress?.({ phase: "initializing", command: context.command });
-      const preparation = environment.prepare({
-        fs: context.fs,
-        cwd: context.cwd,
-        signal,
-        requirements: [...options.packages ?? [], ...options.packageProfile ? pythonDocumentPackages : [], ...installation?.packages ?? []],
-        requirementFiles: [...options.requirements ?? [], ...installation?.requirements ?? []]
-      }).then((value) => {
-        packages = value;
-      });
-      pending.add(preparation);
-      try {
-        await preparation;
-      } finally {
-        pending.delete(preparation);
-      }
-      signal.throwIfAborted();
-      if (options.createExecutor) {
-        try {
-          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 } },
-          ...hostBridge ? { host: hostBridge } : {},
-          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;
-            }
-          },
-          async dispatch(request) {
-            if (!request || typeof request.op !== "string" || !Array.isArray(request.args)) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
-            const releasing = request.op === "close";
-            if (!releasing) signal.throwIfAborted();
-            if (closed && !releasing || !running || requesting) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
-            requesting = true;
-            const operation = Promise.resolve().then(() => dispatch(request)).catch(async (error) => {
-              if (releasing) throw 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);
-            }
-          }
-        };
-        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 (0, command_exports.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;
-              }
-              const message = value;
-              if (message.type === "ready") {
-                ready = true;
-                try {
-                  options.onProgress?.({ phase: "ready", command: context.command });
-                } catch (error) {
-                  fail(error);
-                }
-                return;
-              }
-              if (message.type === "exit") {
-                if (pending.size) {
-                  transportFailure(new TypeError("Python worker exited with an outstanding request"));
-                  return;
-                }
-                try {
-                  const status = (0, command_exports.validateExitCode)(message.exitCode);
-                  settled = true;
-                  resolve(status);
-                } catch (error) {
-                  transportFailure(error);
-                }
-                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);
-                    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);
-                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 {
-          await (0, io_exports.writeBytes)(stderrOperation.output, new TextEncoder().encode("python: " + reason.message + "\n"), signal);
-        } catch (error) {
-          primary = { reason: error };
-        }
-      } else if (!signal.aborted && typeof reason === "object" && reason !== null && "code" in reason && reason.code === "EPACKAGE") {
-        primary = { reason: reportPythonFailure("runtime-assets", reason, options.onDiagnostic) };
-      } else primary = { reason };
-    }
-    try {
-      await close();
-    } catch (reason) {
-      primary ??= { reason };
-    }
-    try {
-      options.onProgress?.({ phase: "finished", command: context.command });
-    } catch (reason) {
-      primary ??= { reason };
-    }
-    context.signal.throwIfAborted();
-    if (primary) {
-      if (!(primary.reason instanceof PythonFailure)) throw primary.reason;
-      const failure2 = primary.reason;
-      await (0, io_exports.writeBytes)(context.stderr, new TextEncoder().encode("python: " + failure2.message + "\n"), context.signal);
-      return { exitCode: 1 };
-    }
-    return { exitCode: result };
-  };
-  return ["python", "python3"].map((name) => ({ name, description: "Python with an explicit interpreter executor and canonical filesystem", execute }));
-}
-function pythonCommands(options) {
-  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);
-  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}`);
-    }
-    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
-  } };
-}
-
-export {
-  filesystem_descriptor_exports,
-  PythonPackageConflictError,
-  createPythonPackageManifestStore,
-  createPythonPackageCache,
-  pythonDocumentPackages,
-  createPythonPackageEnvironment,
-  pythonHostFailureCode,
-  createPythonHostBridge,
-  createPythonShellCapability,
-  createPythonLlmCapability,
-  createPythonExecutorPool,
-  createPythonJspiTrampoline,
-  createPythonJspiNativeCall,
-  createPythonJspiStatResult,
-  createPythonJspiExecutor,
-  createPythonJspiAssets,
-  createPythonCommands,
-  pythonCommands
-};
-//# sourceMappingURL=chunk-MJPFHANT.js.map