@poe-platform/safe-bash 0.1.822 → 0.1.824

package/dist/safe-bash/command-chunks/chunk-NNGWTDVJ.js

@@ -0,0 +1,2819 @@
+import {
+  createPythonPackageEnvironment,
+  createPythonPackageManifestStore,
+  pythonDocumentPackages,
+  stagePythonPackage
+} from "./chunk-IKBTII7C.js";
+import {
+  pythonShellDispatchActive
+} from "./chunk-NHAG4DWL.js";
+import {
+  openPythonPackageFile
+} from "./chunk-NXCJNPL3.js";
+import {
+  PythonInvocationError,
+  parsePythonInvocation,
+  pythonPackageUrlHash
+} from "./chunk-3EBQOZET.js";
+import {
+  pythonLlmProvider
+} from "./chunk-YYRVGXJH.js";
+import {
+  createPythonExecutorPool
+} from "./chunk-GT27M77E.js";
+import {
+  PythonFailure,
+  isPythonFailureCategory,
+  reportPythonFailure
+} from "./chunk-TO6UNFEF.js";
+import {
+  createPythonHostBridge
+} from "./chunk-EPYJSPOY.js";
+
+// packages/safe-bash-command-python/src/executor.ts
+import { PythonFileSystem, PythonStatTranslator } from "@poe-platform/safe-fs/core";
+import { validateExitCode } from "../../safe-bash-contracts/command.js";
+import { openCommandFile } from "../../safe-bash-contracts/filesystem-descriptor.js";
+
+// packages/safe-bash-command-python/src/reply.ts
+import { FsError } from "../../safe-bash-contracts/errors.js";
+function encodePythonReply(value, maxBytes) {
+  let used = 0;
+  const ancestors = /* @__PURE__ */ new Set();
+  const reserve = (bytes) => {
+    used += bytes;
+    if (used > maxBytes) throw new FsError("EFBIG", { syscall: "python reply" });
+  };
+  const string = (text) => {
+    if (text.length + 2 > maxBytes - used) throw new FsError("EFBIG", { syscall: "python reply" });
+    reserve(2);
+    for (let index = 0; index < text.length; index++) {
+      const code = text.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 && text.charCodeAt(index + 1) >= 56320 && text.charCodeAt(index + 1) <= 57343) {
+        reserve(4);
+        index++;
+      } else reserve(code >= 55296 && code <= 57343 ? 6 : 3);
+    }
+    return text;
+  };
+  const own = (input, depth) => {
+    if (depth > 64) throw new 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 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 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-command-python/src/installation.ts
+var PythonInstallationError = class extends Error {
+};
+var pythonInstallationHelp = `Usage: python -m pip install [OPTIONS] PACKAGE ...
+       python -m pip uninstall [-y/--yes] PACKAGE ...
+Install: -r/--requirement FILE, -e/--editable PATH, --pre, -U/--upgrade,
+         --force-reinstall, --no-cache-dir
+Both accept -h/--help and --.
+`;
+function parsePythonInstallation(pipArgs) {
+  const controls = {};
+  const packages = [];
+  const requirements = [];
+  if (pipArgs.length === 0 || 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, controls, help: true };
+  }
+  const uninstall = pipArgs[0] === "uninstall";
+  let yes = false;
+  if (!uninstall && 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;
+    }
+    const flag = { "--pre": "pre", "--no-cache-dir": "noCache", "-U": "upgrade", "--upgrade": "upgrade", "--force-reinstall": "forceReinstall" }[option];
+    if (!uninstall && flag) {
+      controls[flag] = true;
+      continue;
+    }
+    if (option === "--") {
+      operands = true;
+      continue;
+    }
+    if (option === "--help" || option === "-h") {
+      help = true;
+      continue;
+    }
+    if (uninstall && (option === "-y" || option === "--yes")) {
+      yes = true;
+      continue;
+    }
+    if (!uninstall) {
+      const kind = ["requirement", "editable"].find((name) => option.startsWith("-" + name[0]) || option.split("=", 1)[0] === "--" + name);
+      if (kind) {
+        const prefix = "--" + kind;
+        const path = option.startsWith(prefix + "=") ? option.slice(prefix.length + 1) : option === prefix || option.length === 2 ? pipArgs[++index] : option.slice(2);
+        if (!path || path.startsWith("-")) throw new PythonInvocationError(option + " requires a path");
+        (kind === "editable" ? controls.editable ??= [] : requirements).push(path);
+        continue;
+      }
+    }
+    throw new PythonInvocationError("unsupported pip option " + option);
+  }
+  if (!help && packages.length === 0 && requirements.length === 0 && !controls.editable?.length) throw new PythonInvocationError("pip " + pipArgs[0] + " requires at least one package or requirements file");
+  return { packages, requirements, help, controls, ...uninstall ? { uninstall, yes } : {} };
+}
+
+// packages/safe-bash-command-python/src/executor.ts
+import { readBytes, writeBytes } from "../../safe-bash-contracts/io.js";
+import { createOutputOperation } from "../../safe-bash-contracts/output.js";
+import { inheritYieldCheckpoint, yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-python/src/llm-package-manager.ts
+import { toByteSource } from "../../safe-bash-contracts/index.js";
+function createPythonLlmPackageManager(options) {
+  if (!options.createExecutor || !options.environment || options.provisioning) throw new TypeError("LLM package management requires an asynchronous executor and a shared Python environment");
+  const planners = /* @__PURE__ */ new WeakMap();
+  const pool = createPythonExecutorPool({
+    createExecutor: options.createExecutor,
+    ...options.maxConcurrentWorkers === void 0 || options.maxConcurrentWorkers === Infinity ? {} : { maxConcurrentExecutors: options.maxConcurrentWorkers }
+  });
+  const configuration = { ...options, createExecutor: pool.createExecutor, createCapabilities(context) {
+    const capabilities = options.createCapabilities?.(context) ?? {};
+    if (capabilities.llm_packages) throw new Error("Python package capability is reserved");
+    const capability = planners.get(context.args);
+    return capability ? { ...capabilities, llm_packages: capability } : capabilities;
+  } };
+  const installer = createPythonExecutorCommands(configuration)[0];
+  const { environment: ignoredEnvironment, packages: ignoredPackages, requirements: ignoredRequirements, packageProfile: ignoredProfile, ...planning } = configuration;
+  const command = createPythonExecutorCommands(planning)[0];
+  return async ({ context, args }) => {
+    if (!Array.isArray(args) || !["install", "uninstall"].includes(args[0]) || args.some((value) => typeof value !== "string")) throw new TypeError("Invalid LLM package command");
+    context.signal.throwIfAborted();
+    let planned;
+    const { registerCleanup: ignoredCleanup, argumentValues: ignoredArguments, ...isolated } = context;
+    const invocation = { ...isolated, command: "python", args: ["-c", pythonLlmPackageProgram, ...args], stdin: toByteSource("") };
+    planners.set(invocation.args, { async call(value) {
+      if (planned || !Array.isArray(value) || value.some((item) => typeof item !== "string") || value[0] !== "pip" || value[1] !== args[0]) throw new Error("Invalid native LLM package request");
+      planned = value.slice(1);
+      return null;
+    } });
+    let result;
+    try {
+      result = await command.execute(invocation);
+    } finally {
+      planners.delete(invocation.args);
+    }
+    if (result.exitCode || !planned) return result;
+    context.signal.throwIfAborted();
+    return installer.execute({ ...isolated, command: "python", args: ["-m", "pip", ...planned] });
+  };
+}
+var pythonLlmPackageProgram = String.raw`
+import sys
+import safe_host
+import llm.cli
+
+def _safe_package_request(module, run_name):
+    if module != 'pip' or run_name != '__main__':
+        raise RuntimeError('Unexpected LLM package entrypoint')
+    safe_host.call('llm_packages', list(sys.argv))
+
+llm.cli.run_module = _safe_package_request
+llm.cli.cli.main(args=sys.argv[1:], prog_name='llm')
+`;
+
+// packages/safe-bash-command-python/src/llm-plugin-setup.ts
+var pythonLlmPluginSetup = /* @__PURE__ */ (() => String.raw`
+def load_plugins(request):
+ import llm.plugins as manager
+ manager.load_plugins()
+ if request['plugins']:
+  original = (manager.DEFAULT_PLUGINS, manager.LLM_LOAD_PLUGINS, manager._loaded)
+  try:
+   manager.DEFAULT_PLUGINS = ()
+   manager.LLM_LOAD_PLUGINS = ','.join(request['plugins'])
+   manager._loaded = False
+   manager.load_plugins()
+  finally:
+   manager.DEFAULT_PLUGINS, manager.LLM_LOAD_PLUGINS, manager._loaded = original
+`)();
+
+// packages/safe-bash-command-python/src/llm-json-loader.ts
+import { LlmLoaderLookupError } from "../../safe-bash-command-llm/index.js";
+import { toByteSource as toByteSource2 } from "../../safe-bash-contracts/index.js";
+function createPythonLlmJsonLoader(options, capabilityName, program, label) {
+  if (!options.createExecutor) throw new TypeError(`Python ${label} loading requires an asynchronous executor`);
+  if (options.plugins !== void 0 && (!Array.isArray(options.plugins) || options.plugins.some((name) => typeof name !== "string" || !name || name !== name.trim() || name.includes(",")))) throw new TypeError(`Python ${label} plugins must be explicit distribution names`);
+  const plugins = Object.freeze([...options.plugins ?? []]), capabilities = /* @__PURE__ */ new WeakMap();
+  const command = createPythonExecutorCommands({ ...options, createCapabilities(context) {
+    const provided = options.createCapabilities?.(context) ?? {};
+    if (provided[capabilityName]) throw new Error(`Python ${label} capability is reserved`);
+    const capability = capabilities.get(context.args);
+    if (!capability) throw new Error(`Unknown Python ${label} invocation`);
+    return { ...provided, [capabilityName]: capability };
+  } })[0];
+  return async (request, context, admitBytes) => {
+    if (!context) throw new TypeError(`Python ${label} loading requires caller context`);
+    const { maxBytes, signal } = context;
+    if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError(`Invalid Python ${label} byte limit`);
+    signal.throwIfAborted();
+    let size = 0, done = false, failure;
+    const chunks = [];
+    const invocation = { ...context, command: "python", args: ["-c", program], signal, env: context.env ?? {}, stdin: toByteSource2(""), stdout: context.stdout ?? { async write() {
+    } }, stderr: context.stderr ?? { async write() {
+    } } };
+    capabilities.set(invocation.args, { async call(input) {
+      try {
+        signal.throwIfAborted();
+        if (!input || typeof input !== "object" || Array.isArray(input) || done) throw new TypeError(`Invalid Python ${label} message`);
+        const message = input;
+        if (message.op === "request") return { ...request, plugins };
+        if (message.op === "missing" || message.op === "lookup" || message.op === "error") {
+          failure ??= message.op === "error" ? new Error(String(message.message)) : new LlmLoaderLookupError(String(message.message));
+          done = true;
+          return null;
+        }
+        if (message.op === "done") {
+          done = true;
+          return null;
+        }
+        if (message.op !== "text" || typeof message.text !== "string" || message.text.length > 8192) throw new TypeError(`Invalid Python ${label} text window`);
+        const bytes = new TextEncoder().encode(message.text).length;
+        if (bytes > 16384) throw new TypeError(`Invalid Python ${label} text window`);
+        if (bytes > maxBytes - size) throw new RangeError(`Python ${label} byte limit exceeded`);
+        admitBytes?.(bytes);
+        size += bytes;
+        if (bytes) chunks.push(message.text);
+        return null;
+      } catch (error) {
+        failure ??= error;
+        throw error;
+      }
+    } });
+    try {
+      const result = await command.execute(invocation);
+      signal.throwIfAborted();
+      if (failure) throw failure;
+      if (result.exitCode) throw new Error(`Python ${label} interpreter exited with status ${result.exitCode}`);
+      if (!done) throw new Error(`Python ${label} interpreter returned no result`);
+      return JSON.parse(chunks.join(""));
+    } finally {
+      capabilities.delete(invocation.args);
+    }
+  };
+}
+
+// packages/safe-bash-command-python/src/llm-template-loader.ts
+function createPythonLlmTemplateLoader(options, prefix) {
+  if (typeof prefix !== "string" || !prefix) throw new TypeError("Python template loader requires a prefix");
+  const load = createPythonLlmJsonLoader(options, "llm_templates", pythonLlmTemplateProgram, "template");
+  return async (value, signal, context) => {
+    if (!context) throw new TypeError("Python template loading requires caller context");
+    if (typeof value !== "string") throw new TypeError("Python template input must be a string");
+    const template = await load({ prefix, value }, { ...context, signal });
+    if (!template || typeof template !== "object" || Array.isArray(template) || typeof template.name !== "string") throw new TypeError("Invalid native Python template");
+    return template;
+  };
+}
+var pythonLlmTemplateProgram = /* @__PURE__ */ (() => String.raw`
+import json, llm, safe_host
+
+${pythonLlmPluginSetup}
+
+def send(op, **fields):
+ return safe_host.call('llm_templates', dict(op=op, **fields))
+
+def main():
+ request = send('request')
+ try:
+  load_plugins(request)
+  loaders = llm.get_template_loaders()
+ except Exception as error:
+  send('lookup', message=str(error))
+  return
+ if request['prefix'] not in loaders:
+  send('missing', message='Unknown template prefix: ' + request['prefix'])
+  return
+ template = loaders[request['prefix']](request['value'])
+ encoder = json.JSONEncoder(ensure_ascii=False, separators=(',', ':'))
+ for part in encoder.iterencode(template.model_dump(exclude_none=True)):
+  for offset in range(0, len(part), 4096): send('text', text=part[offset:offset + 4096])
+ send('done')
+try:
+ main()
+except Exception as error:
+ send('error', message=str(error))
+`)();
+
+// packages/safe-bash-command-python/src/llm-fragment-loader.ts
+import { createLlmSpool, createLlmUrlSource, LlmLoaderLookupError as LlmLoaderLookupError2 } from "../../safe-bash-command-llm/index.js";
+import { toByteSource as toByteSource3 } from "../../safe-bash-contracts/index.js";
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  void promise.catch(() => {
+  });
+  return { promise, resolve, reject };
+}
+function createPythonLlmFragmentLoader(options, prefix) {
+  if (!options.createExecutor) throw new TypeError("Python fragment loading requires an asynchronous executor");
+  if (typeof prefix !== "string" || !prefix) throw new TypeError("Python fragment loader requires a prefix");
+  if (options.plugins !== void 0 && (!Array.isArray(options.plugins) || options.plugins.some((name) => typeof name !== "string" || !name || name !== name.trim() || name.includes(",")))) throw new TypeError("Python fragment plugins must be explicit distribution names");
+  const plugins = Object.freeze([...options.plugins ?? []]), capabilities = /* @__PURE__ */ new WeakMap();
+  const command = createPythonExecutorCommands({ ...options, createCapabilities(context) {
+    const provided = options.createCapabilities?.(context) ?? {};
+    if (provided.llm_fragments) throw new Error("Python fragment capability is reserved");
+    const capability = capabilities.get(context.args);
+    if (!capability) throw new Error("Unknown Python fragment invocation");
+    return { ...provided, llm_fragments: capability };
+  } })[0];
+  return async function* (value, context) {
+    if (typeof value !== "string") throw new TypeError("Python fragment input must be a string");
+    const { fs, cwd, maxBytes } = context;
+    if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("Invalid Python fragment byte limit");
+    const controller = new AbortController(), signal = AbortSignal.any([context.signal, controller.signal]);
+    signal.throwIfAborted();
+    let ready = deferred(), resume;
+    let current, spool, closed = false, bytes = 0;
+    const sources = /* @__PURE__ */ new Set();
+    const admit = (size) => {
+      if (size > maxBytes - bytes) throw new RangeError("Python fragment byte limit exceeded");
+      bytes += size;
+    };
+    const fail = (error) => {
+      ready.reject(error);
+      resume?.resolve(false);
+      controller.abort(error);
+    };
+    const aborted = () => {
+      ready.reject(signal.reason);
+      resume?.resolve(false);
+    };
+    signal.addEventListener("abort", aborted, { once: true });
+    const retire = async (source) => {
+      try {
+        await source.dispose();
+      } finally {
+        sources.delete(source);
+      }
+    };
+    const dispatch = async (input) => {
+      signal.throwIfAborted();
+      if (!input || typeof input !== "object" || Array.isArray(input)) throw new TypeError("Invalid Python fragment message");
+      const message = input;
+      if (message.op === "request") return { prefix, value, plugins };
+      if (message.op === "missing" || message.op === "lookup") throw new LlmLoaderLookupError2(String(message.message));
+      if (message.op === "error") throw new Error(String(message.message));
+      if (message.op === "begin") {
+        if (current || resume) throw new Error("Python fragment already active");
+        if (message.type !== "text" && message.type !== "attachment") throw new TypeError("Invalid Python fragment type");
+        if (message.type === "attachment" && (typeof message.mimeType !== "string" || typeof message.id !== "string")) throw new TypeError("Invalid Python fragment metadata");
+        let source;
+        if (message.url !== void 0) {
+          if (message.type !== "attachment" || typeof message.url !== "string" || !context.capabilities?.fetch) throw new TypeError("Attachment URL loading is not configured");
+          source = createLlmUrlSource({ url: message.url, fetch: context.capabilities.fetch, signal, maxBytes: maxBytes - bytes, admitBytes: admit });
+        } else {
+          const owned = await createLlmSpool(fs, cwd, signal, "input");
+          spool = owned;
+          source = { bytes: owned.replay(), dispose: () => owned.close() };
+        }
+        sources.add(source);
+        current = message.type === "text" ? { type: "text", source: { ...source, normalizeNewlines: false } } : { type: "attachment", source, mimeType: message.mimeType, id: message.id };
+        sources.delete(source);
+        sources.add(current.source);
+        return null;
+      }
+      if (!current) throw new Error("No active Python fragment");
+      if (message.op === "text" || message.op === "bytes") {
+        if (!spool) throw new Error("Remote Python fragments cannot accept inline bytes");
+        let chunk;
+        if (message.op === "text") {
+          if (current.type !== "text" || typeof message.text !== "string" || message.text.length > 8192) throw new TypeError("Invalid Python fragment text window");
+          chunk = new TextEncoder().encode(message.text);
+          if (chunk.length > 16384) throw new TypeError("Invalid Python fragment text window");
+        } else {
+          if (current.type !== "attachment" || !Array.isArray(message.bytes) || message.bytes.length > 4096 || message.bytes.some((byte) => typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255)) throw new TypeError("Invalid Python fragment byte window");
+          chunk = Uint8Array.from(message.bytes);
+        }
+        admit(chunk.length);
+        await spool.write(chunk);
+        return null;
+      }
+      if (message.op === "end") {
+        const continuation = resume = deferred();
+        ready.resolve(current);
+        return continuation.promise;
+      }
+      throw new TypeError("Invalid Python fragment operation");
+    };
+    const invocation = { ...context, command: "python", args: ["-c", pythonLlmFragmentProgram], fs, cwd, signal, env: context.env ?? {}, stdin: toByteSource3(""), stdout: context.stdout ?? { async write() {
+    } }, stderr: context.stderr ?? { async write() {
+    } } };
+    capabilities.set(invocation.args, { async call(input) {
+      try {
+        return await dispatch(input);
+      } catch (error) {
+        fail(error);
+        throw error;
+      }
+    } });
+    const running = Promise.resolve().then(() => command.execute(invocation)).then((result) => {
+      if (closed) return;
+      if (result.exitCode) fail(new Error(`Python fragment interpreter exited with status ${result.exitCode}`));
+      else ready.resolve(void 0);
+    }, (error) => {
+      if (!closed) fail(error);
+    });
+    let closing;
+    const close = () => closing ??= (async () => {
+      closed = true;
+      resume?.resolve(false);
+      controller.abort(new Error("Python fragment session closed"));
+      await running;
+      capabilities.delete(invocation.args);
+      signal.removeEventListener("abort", aborted);
+      await Promise.all([...sources].map(retire));
+    })();
+    context.registerCleanup?.(close);
+    try {
+      while (true) {
+        const fragment = await ready.promise;
+        if (!fragment) break;
+        let advance = false;
+        try {
+          yield fragment;
+          advance = true;
+        } finally {
+          await retire(fragment.source);
+          current = void 0;
+          spool = void 0;
+          ready = deferred();
+          const continuation = resume;
+          resume = void 0;
+          continuation?.resolve(advance);
+        }
+      }
+    } finally {
+      await close();
+    }
+  };
+}
+var pythonLlmFragmentProgram = /* @__PURE__ */ (() => String.raw`
+import hashlib, llm, safe_host
+from llm_safe_host import _attachment_type
+
+${pythonLlmPluginSetup}
+
+def send(op, **fields):
+ return safe_host.call('llm_fragments', dict(op=op, **fields))
+
+def emit_attachment(value):
+ mime = _attachment_type(value)
+ if not value.content and value.path:
+  with open(value.path, 'rb') as source:
+   if value._id is None:
+    digest = hashlib.sha256()
+    for chunk in iter(lambda: source.read(4096), b''): digest.update(chunk)
+    value._id = digest.hexdigest()
+    source.seek(0)
+   send('begin', type='attachment', mimeType=mime, id=value.id())
+   for chunk in iter(lambda: source.read(4096), b''): send('bytes', bytes=list(chunk))
+ elif not value.content and value.url:
+  send('begin', type='attachment', mimeType=mime, id=value.id(), url=value.url)
+ else:
+  send('begin', type='attachment', mimeType=mime, id=value.id())
+  content = memoryview(value.content or b'')
+  for offset in range(0, len(content), 4096): send('bytes', bytes=list(content[offset:offset + 4096]))
+
+def main():
+ request = send('request')
+ try:
+  load_plugins(request)
+  loaders = llm.get_fragment_loaders()
+ except Exception as error:
+  send('lookup', message=str(error))
+  return
+ if request['prefix'] not in loaders:
+  send('missing', message='Unknown fragment prefix: ' + request['prefix'])
+  return
+ result = loaders[request['prefix']](request['value'])
+ if not isinstance(result, list): result = [result]
+ for value in result:
+  if isinstance(value, llm.Attachment): emit_attachment(value)
+  elif isinstance(value, str):
+   send('begin', type='text')
+   for offset in range(0, len(value), 4096): send('text', text=value[offset:offset + 4096])
+  else: raise TypeError('Fragment loader must return text or attachments')
+  if not send('end'): return
+try:
+ main()
+except Exception as error:
+ send('error', message=str(error))
+`)();
+
+// packages/safe-bash-command-python/src/llm-loader-discovery.ts
+function createPythonLlmLoaderProvider(options) {
+  const discover = createPythonLlmLoaderDiscovery(options), configured = { ...options, plugins: Object.freeze([...options.plugins ?? []]) };
+  return { discover, fragments: createPythonLlmFragmentLoader.bind(null, configured), templates: createPythonLlmTemplateLoader.bind(null, configured) };
+}
+function createPythonLlmLoaderDiscovery(options) {
+  const load = createPythonLlmJsonLoader(options, "llm_loaders", pythonLlmLoaderDiscoveryProgram, "loader discovery");
+  const configured = { ...options, plugins: Object.freeze([...options.plugins ?? []]) };
+  return async (context) => {
+    if (context.kind !== void 0 && context.kind !== "fragments" && context.kind !== "templates") throw new TypeError("Invalid native loader discovery kind");
+    const result = await load(context.kind === void 0 ? {} : { kind: context.kind }, context, context.admitBytes);
+    if (!result || typeof result !== "object" || Array.isArray(result)) throw new TypeError("Invalid native loader discovery");
+    function loaders(entries, create) {
+      if (!Array.isArray(entries)) throw new TypeError("Invalid native loader discovery");
+      const values = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || !entry[0] || values.has(entry[0]) || entry[1] !== null && typeof entry[1] !== "string") throw new TypeError("Invalid native loader registration");
+        const loader = create(configured, entry[0]);
+        if (entry[1] !== null) Object.defineProperty(loader, "description", { value: entry[1], enumerable: true });
+        values.set(entry[0], loader);
+      }
+      return values;
+    }
+    const data = result;
+    return { fragmentLoaders: loaders(data.fragments, createPythonLlmFragmentLoader), templateLoaders: loaders(data.templates, createPythonLlmTemplateLoader) };
+  };
+}
+var pythonLlmLoaderDiscoveryProgram = /* @__PURE__ */ (() => String.raw`
+import json, llm, safe_host
+
+${pythonLlmPluginSetup}
+
+def send(op, **fields):
+ return safe_host.call('llm_loaders', dict(op=op, **fields))
+
+def main():
+ request = send('request')
+ load_plugins(request)
+ encoder = json.JSONEncoder(ensure_ascii=False, separators=(',', ':'))
+ kind = request.get('kind')
+ result = dict(fragments=[] if kind == 'templates' else [(prefix, loader.__doc__) for prefix, loader in llm.get_fragment_loaders().items()],
+               templates=[] if kind == 'fragments' else [(prefix, loader.__doc__) for prefix, loader in llm.get_template_loaders().items()])
+ for part in encoder.iterencode(result):
+  for offset in range(0, len(part), 4096): send('text', text=part[offset:offset + 4096])
+ send('done')
+try:
+ main()
+except Exception as error:
+ send('error', message=str(error))
+`)();
+
+// packages/safe-bash-command-python/src/llm-functions-loader.ts
+import { createLlmSpool as createLlmSpool2, createLlmToolRegistry } from "../../safe-bash-command-llm/index.js";
+import { toByteSource as toByteSource4 } from "../../safe-bash-contracts/index.js";
+
+// packages/safe-bash-command-python/src/llm-functions-program.ts
+var pythonLlmFunctionsProgram = /* @__PURE__ */ (() => String.raw`
+import asyncio, codecs, inspect, json
+import safe_host
+from _poe_llm_capability import bridge
+from llm.cli import _tools_from_code, _gather_tools
+from llm import ToolOutput, Tool, Toolbox, get_tools, get_plugins
+from llm.models import _wrap_tools, _get_instance
+from llm_safe_host import _attachment_type
+
+
+def send(op, **fields):
+    return safe_host.call("llm_tools", dict(op=op, **fields))
+
+
+def load_definition(definition):
+    if "\n" in definition or not definition.endswith(".py"):
+        send("admit", size=len(definition.encode("utf-8")))
+        return definition
+    decoder = codecs.getincrementaldecoder("utf-8")()
+    chunks = []
+    try:
+        with open(definition, "rb") as source:
+            for chunk in iter(lambda: source.read(4096), b""):
+                send("admit", size=len(chunk))
+                chunks.append(decoder.decode(chunk))
+            chunks.append(decoder.decode(b"", final=True))
+    except FileNotFoundError:
+        from click import ClickException
+        raise ClickException("File not found: " + definition)
+    code = "".join(chunks).replace("\r\n", "\n").replace("\r", "\n")
+    return code + "\n" if "\n" not in code and code.endswith(".py") else code
+
+
+def write_text(identifier, value):
+    for offset in range(0, len(value), 4096):
+        send("text", id=identifier, text=value[offset:offset + 4096])
+
+
+def write_attachment(identifier, attachment):
+    mime = _attachment_type(attachment)
+    if attachment.content:
+        descriptor = dict(mimeType=mime, id=attachment.id())
+        handle = send("attachment", id=identifier, descriptor=descriptor)
+        content = memoryview(attachment.content)
+        for offset in range(0, len(content), 4096):
+            send("bytes", id=identifier, attachment=handle, bytes=list(content[offset:offset + 4096]))
+    elif attachment.path:
+        handle = send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id()))
+        with open(attachment.path, "rb") as source:
+            for chunk in iter(lambda: source.read(4096), b""):
+                send("bytes", id=identifier, attachment=handle, bytes=list(chunk))
+    elif attachment.url:
+        send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id(), url=attachment.url))
+    else:
+        send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id()))
+
+
+async def main():
+    definitions = send("definitions")
+    selection = send("selection")
+    names = selection.get("names", [])
+    discovery = selection.get("discovery", False)
+    tools = []
+    try:
+        requested_plugins = selection.get("plugins", [])
+        if requested_plugins:
+            import llm.plugins as plugin_manager
+            plugin_manager.load_plugins()
+            original = (plugin_manager.DEFAULT_PLUGINS, plugin_manager.LLM_LOAD_PLUGINS, plugin_manager._loaded)
+            try:
+                # Reuse native explicit-distribution loading. The host's tooling
+                # registration guard and ambient-entrypoint prohibition stay active.
+                plugin_manager.DEFAULT_PLUGINS = ()
+                plugin_manager.LLM_LOAD_PLUGINS = ",".join(requested_plugins)
+                plugin_manager._loaded = False
+                plugin_manager.load_plugins()
+            finally:
+                plugin_manager.DEFAULT_PLUGINS, plugin_manager.LLM_LOAD_PLUGINS, plugin_manager._loaded = original
+        plugin_query = selection.get("pluginQuery")
+        if plugin_query is not None:
+            plugins = get_plugins(plugin_query["all"])
+            hooks = set(plugin_query["hooks"])
+            if hooks:
+                plugins = [plugin for plugin in plugins if hooks.intersection(plugin["hooks"])]
+            send("plugins", plugins=plugins)
+        registered = get_tools() if discovery and not names else {}
+        functions = []
+        for definition in definitions:
+            functions.extend(_tools_from_code(load_definition(definition)))
+        if discovery:
+            if names:
+                registered = {tool.name: tool for tool in functions + _gather_tools(names, [])}
+            else:
+                for tool in functions:
+                    registered[tool.name] = tool
+            entries = [(key, tool, None) for key, tool in registered.items()]
+        else:
+            entries = [(tool.name, tool, None) for tool in functions]
+            for selection_index, selected in enumerate(_gather_tools(names, [])):
+                entries.extend((tool.name, tool, selection_index) for tool in _wrap_tools([selected]))
+        for key, tool, selection_index in entries:
+            if not isinstance(tool, Tool):
+                methods = []
+                for method in tool.method_tools():
+                    methods.append(dict(name=method.name, description=method.description,
+                        inputSchema=method.input_schema,
+                        signature=str(inspect.signature(method.implementation)).replace("(self, ", "(").replace("(self)", "()")))
+                send("toolbox", name=key, tools=methods)
+                continue
+            index = len(tools)
+            tools.append(tool)
+            send("register", index=index, name=tool.name, registryKey=key, description=tool.description,
+                 plugin=tool.plugin, selectionIndex=selection_index, inputSchema=tool.input_schema,
+                 signature=str(inspect.signature(tool.implementation)),
+                 asynchronous=inspect.iscoroutinefunction(tool.implementation))
+    except Exception as error:
+        send("failed", message=getattr(error, "message", str(error)))
+        return
+    send("ready", prepare=any(isinstance(_get_instance(tool.implementation), Toolbox) for tool in tools))
+    pending = set()
+    cancelled = False
+
+    async def execute(command):
+        identifier = command["id"]
+        try:
+            if command.get("prepare"):
+                asynchronous = command.get("asynchronous", False)
+                flag = "_async_prepared" if asynchronous else "_prepared"
+                instances = []
+                for tool in {tool.name: tool for tool in tools}.values():
+                    instance = _get_instance(tool.implementation)
+                    if isinstance(instance, Toolbox) and not getattr(instance, flag, False):
+                        instances.append(instance)
+                for instance in instances:
+                    if asynchronous:
+                        await instance.prepare_async()
+                    else:
+                        instance.prepare()
+                    setattr(instance, flag, True)
+                send("done", id=identifier)
+                return
+            output = tools[command["tool"]].implementation(**command["arguments"])
+            if inspect.isawaitable(output):
+                output = await output
+            attachments = []
+            if isinstance(output, ToolOutput):
+                attachments, output = output.attachments, output.output
+            if not isinstance(output, str):
+                output = json.dumps(output, default=repr)
+            write_text(identifier, output)
+            for attachment in attachments:
+                write_attachment(identifier, attachment)
+            send("done", id=identifier)
+        except Exception as error:
+            send("error", id=identifier, message=str(error))
+
+    def completed(task):
+        pending.discard(task)
+        # Host transport failures already reject all outstanding calls. Retrieve
+        # the exception so a completed task cannot leak an unobserved failure.
+        if not task.cancelled():
+            task.exception()
+
+    try:
+        while True:
+            command = await bridge.wait("begin", capability="llm_tools", value=dict(op="next"))
+            if command is None:
+                break
+            if command.get("cancel"):
+                cancelled = True
+                break
+            task = asyncio.create_task(execute(command))
+            pending.add(task)
+            task.add_done_callback(completed)
+        if pending and not cancelled:
+            await asyncio.gather(*pending)
+    finally:
+        for task in pending:
+            task.cancel()
+        if pending:
+            await asyncio.gather(*pending, return_exceptions=True)
+
+asyncio.run(main())
+`)();
+
+// packages/safe-bash-command-python/src/llm-functions-loader.ts
+function deferred2() {
+  let resolve, reject;
+  const promise = new Promise((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid Python tool protocol");
+  return value;
+}
+function createPythonLlmToolLoader(options) {
+  if (!options.createExecutor) throw new TypeError("Python tool loading requires an asynchronous executor");
+  if (options.plugins !== void 0 && (!Array.isArray(options.plugins) || options.plugins.some((name) => typeof name !== "string" || !name || name !== name.trim() || name.includes(",")))) throw new TypeError("Python tool plugins must be explicit distribution names");
+  const pluginNames = Object.freeze([...options.plugins ?? []]);
+  const capabilitiesByArguments = /* @__PURE__ */ new WeakMap();
+  const command = createPythonExecutorCommands({ ...options, createCapabilities: (current) => {
+    const capabilities = options.createCapabilities?.(current) ?? {};
+    if (capabilities.llm_tools) throw new Error("Python tool capability is reserved");
+    const capability = capabilitiesByArguments.get(current.args);
+    if (!capability) throw new Error("Unknown Python tool invocation");
+    return { ...capabilities, llm_tools: capability };
+  } })[0];
+  return async ({ context, definitions, toolNames = [], discovery = false, pluginQuery, maxInputBytes, maxOutputBytes }) => {
+    if (!Array.isArray(definitions) || definitions.some((value) => typeof value !== "string")) throw new TypeError("Python tool definitions must be strings");
+    if (!Array.isArray(toolNames) || toolNames.some((value) => typeof value !== "string") || typeof discovery !== "boolean") throw new TypeError("Invalid Python tool selection");
+    if (pluginQuery && (typeof pluginQuery.all !== "boolean" || !Array.isArray(pluginQuery.hooks) || pluginQuery.hooks.some((value) => typeof value !== "string"))) throw new TypeError("Invalid Python plugin query");
+    for (const limit of [maxInputBytes, maxOutputBytes]) if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid Python tool byte limit");
+    context.signal.throwIfAborted();
+    const controller = new AbortController();
+    const runtimeController = new AbortController();
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    const ready = deferred2();
+    const tools = [];
+    const toolboxes = [];
+    let plugins;
+    const spools = /* @__PURE__ */ new Set();
+    const jobs = /* @__PURE__ */ new Map();
+    const queue = [];
+    let waiter;
+    let serial3 = 0, controls = 0, loaded = false, initializationFailed = false, closed = false, closing;
+    const encoder2 = new TextEncoder();
+    const fail = (error) => {
+      ready.reject(error);
+      queue.length = 0;
+      if (waiter) {
+        waiter.resolve({ cancel: true });
+        waiter = void 0;
+      } else queue.push({ cancel: true });
+      for (const job of jobs.values()) job.result.reject(error);
+      jobs.clear();
+      controller.abort(error);
+    };
+    const aborted = () => fail(signal.reason);
+    signal.addEventListener("abort", aborted, { once: true });
+    const spool = async () => {
+      const value = await createLlmSpool2(context.fs, context.cwd, signal);
+      spools.add(value);
+      if (closed || signal.aborted) {
+        await value.close();
+        spools.delete(value);
+        signal.throwIfAborted();
+        throw new Error("Python tool session is closed");
+      }
+      return value;
+    };
+    const source = (value) => ({ bytes: value.replay(), async dispose() {
+      try {
+        await value.close();
+      } finally {
+        spools.delete(value);
+      }
+    } });
+    const invoke = async (fields, callContext) => {
+      signal.throwIfAborted();
+      callContext.signal.throwIfAborted();
+      if (closed) throw new Error("Python tool session is closed");
+      const stop = () => fail(callContext.signal.reason);
+      callContext.signal.addEventListener("abort", stop, { once: true });
+      let output;
+      try {
+        output = await spool();
+        callContext.signal.throwIfAborted();
+        const result = deferred2(), id = ++serial3;
+        jobs.set(id, { result, output, attachments: [], files: /* @__PURE__ */ new Map(), bytes: 0, limit: Math.min(callContext.maxBytes, maxOutputBytes) });
+        const request = { id, ...fields };
+        if (waiter) {
+          waiter.resolve(request);
+          waiter = void 0;
+        } else queue.push(request);
+        return await result.promise;
+      } catch (error) {
+        if (output) {
+          await output.close();
+          spools.delete(output);
+        }
+        throw error;
+      } finally {
+        callContext.signal.removeEventListener("abort", stop);
+      }
+    };
+    const prepare = async (callContext, mode) => {
+      const result = await invoke({ prepare: true, asynchronous: mode.async }, callContext);
+      await result.source?.dispose();
+    };
+    const dispatch = async (value) => {
+      const message = record(value);
+      if (message.op !== "next" && message.op !== "failed") signal.throwIfAborted();
+      if (message.op === "definitions") return [...definitions];
+      if (message.op === "selection") return { names: [...toolNames], discovery, ...pluginNames.length ? { plugins: [...pluginNames] } : {}, ...pluginQuery ? { pluginQuery: { all: pluginQuery.all, hooks: [...pluginQuery.hooks] } } : {} };
+      if (message.op === "admit") {
+        if (typeof message.size !== "number" || !Number.isSafeInteger(message.size) || message.size < 0) throw new TypeError("Invalid Python definition byte count");
+        controls += message.size;
+        if (controls > maxInputBytes) {
+          const error = new RangeError("Python tool definition byte limit exceeded");
+          fail(error);
+          throw error;
+        }
+        return null;
+      }
+      if (message.op === "failed") {
+        initializationFailed = true;
+        fail(new Error(String(message.message)));
+        return null;
+      }
+      if (message.op === "register" || message.op === "toolbox" || message.op === "plugins") {
+        controls += encoder2.encode(JSON.stringify(message)).length;
+        if (controls > maxInputBytes) throw new RangeError("Python tool definition byte limit exceeded");
+      }
+      if (message.op === "plugins") {
+        if (loaded || plugins || !pluginQuery || !Array.isArray(message.plugins)) throw new TypeError("Invalid Python plugin discovery");
+        plugins = Object.freeze(message.plugins.map((value2) => {
+          const plugin = record(value2);
+          if (typeof plugin.name !== "string" || !Array.isArray(plugin.hooks) || plugin.hooks.some((hook) => typeof hook !== "string") || plugin.version !== void 0 && typeof plugin.version !== "string") throw new TypeError("Invalid Python plugin metadata");
+          return Object.freeze({ name: plugin.name, hooks: Object.freeze(plugin.hooks), ...typeof plugin.version === "string" ? { version: plugin.version } : {} });
+        }));
+        return null;
+      }
+      if (message.op === "toolbox") {
+        if (loaded || typeof message.name !== "string" || !Array.isArray(message.tools)) throw new TypeError("Invalid Python toolbox registration");
+        const methods = message.tools.map((value2) => {
+          const method = record(value2);
+          const tool = {
+            name: String(method.name),
+            inputSchema: record(method.inputSchema),
+            ...typeof method.description === "string" ? { description: method.description } : {},
+            ...typeof method.signature === "string" ? { signature: method.signature } : {}
+          };
+          if (typeof method.name !== "string") throw new TypeError("Invalid Python toolbox method");
+          createLlmToolRegistry([tool]);
+          return tool;
+        });
+        toolboxes.push({ name: message.name, tools: methods });
+        return null;
+      }
+      if (message.op === "register") {
+        if (loaded || message.index !== tools.length || typeof message.name !== "string" || typeof message.signature !== "string" || typeof message.asynchronous !== "boolean") throw new TypeError("Invalid Python tool registration");
+        const index = tools.length;
+        const tool = {
+          name: message.name,
+          inputSchema: record(message.inputSchema),
+          signature: message.signature,
+          ...typeof message.description === "string" ? { description: message.description } : {},
+          ...typeof message.plugin === "string" ? { plugin: message.plugin } : {},
+          ...typeof message.registryKey === "string" ? { registryKey: message.registryKey } : {},
+          ...typeof message.selectionIndex === "number" ? { selectionIndex: message.selectionIndex } : {},
+          async: message.asynchronous,
+          async implementation(args, callContext) {
+            return invoke({ tool: index, arguments: args }, callContext);
+          }
+        };
+        createLlmToolRegistry([tool]);
+        tools.push(tool);
+        return null;
+      }
+      if (message.op === "ready") {
+        if (loaded) throw new Error("Python tools already loaded");
+        if (message.prepare === true) for (let index = 0; index < tools.length; index++) tools[index] = { ...tools[index], prepare };
+        loaded = true;
+        ready.resolve();
+        return null;
+      }
+      if (message.op === "next") {
+        if (signal.aborted) return { cancel: true };
+        if (!loaded || waiter) throw new Error("Invalid Python tool request queue");
+        if (queue.length) return queue.shift();
+        waiter = deferred2();
+        return waiter.promise;
+      }
+      if (typeof message.id !== "number") throw new TypeError("Invalid Python tool call identity");
+      const job = jobs.get(message.id);
+      if (!job) throw new Error("Unknown Python tool call");
+      if (message.op === "text" || message.op === "bytes") {
+        let bytes, target = job.output;
+        if (message.op === "text") {
+          if (typeof message.text !== "string" || message.text.length > 8192) throw new TypeError("Invalid Python tool output window");
+          bytes = encoder2.encode(message.text);
+          if (bytes.length > 16384) throw new TypeError("Invalid Python tool output window");
+        } else {
+          if (!Array.isArray(message.bytes) || message.bytes.length > 4096 || message.bytes.some((value2) => typeof value2 !== "number" || !Number.isInteger(value2) || value2 < 0 || value2 > 255)) throw new TypeError("Invalid Python attachment window");
+          if (typeof message.attachment !== "number" || !job.files.has(message.attachment)) throw new Error("Unknown Python attachment");
+          target = job.files.get(message.attachment);
+          bytes = Uint8Array.from(message.bytes);
+        }
+        if (bytes.length > job.limit - job.bytes) throw new RangeError("Python tool output byte limit exceeded");
+        job.bytes += bytes.length;
+        await target.write(bytes);
+        return null;
+      }
+      if (message.op === "attachment") {
+        const metadata = record(message.descriptor);
+        if (typeof metadata.mimeType !== "string" || typeof metadata.id !== "string" || metadata.url !== void 0 && typeof metadata.url !== "string") throw new TypeError("Invalid Python tool attachment");
+        const size = encoder2.encode(JSON.stringify(metadata)).length;
+        if (size > job.limit - job.bytes) throw new RangeError("Python tool attachment metadata limit exceeded");
+        job.bytes += size;
+        const index = job.attachments.length;
+        if (metadata.url !== void 0) job.attachments.push({ mimeType: metadata.mimeType, id: metadata.id, url: metadata.url });
+        else {
+          const file = await spool();
+          job.files.set(index, file);
+          job.attachments.push({ mimeType: metadata.mimeType, id: metadata.id, source: source(file) });
+        }
+        return index;
+      }
+      if (message.op === "error") {
+        jobs.delete(message.id);
+        await Promise.all([job.output, ...job.files.values()].map(async (value2) => {
+          await value2.close();
+          spools.delete(value2);
+        }));
+        job.result.reject(new Error(String(message.message)));
+        return null;
+      }
+      if (message.op === "done") {
+        jobs.delete(message.id);
+        job.result.resolve({ source: source(job.output), attachments: job.attachments });
+        return null;
+      }
+      throw new TypeError("Invalid Python tool operation");
+    };
+    const capability = { async call(value) {
+      try {
+        return await dispatch(value);
+      } catch (error) {
+        fail(error);
+        throw error;
+      }
+    } };
+    const { registerCleanup: ignoredParentCleanup, ...isolatedContext } = context;
+    const invocation = { ...isolatedContext, signal: runtimeController.signal, command: "python", args: ["-c", pythonLlmFunctionsProgram], stdin: toByteSource4("") };
+    capabilitiesByArguments.set(invocation.args, capability);
+    const running = Promise.resolve().then(() => command.execute(invocation)).then(
+      (result) => {
+        if (!closed) fail(new Error(`Python tool interpreter exited with status ${result.exitCode}`));
+      },
+      (error) => {
+        if (!closed) fail(error);
+      }
+    );
+    const close = () => closing ??= (async () => {
+      closed = true;
+      if (loaded && !signal.aborted && !jobs.size) {
+        if (waiter) {
+          waiter.resolve(null);
+          waiter = void 0;
+        } else queue.push(null);
+      } else {
+        controller.abort(new Error("Python tool session closed"));
+        if (!loaded && !initializationFailed) runtimeController.abort(signal.reason);
+      }
+      await running;
+      capabilitiesByArguments.delete(invocation.args);
+      controller.abort(new Error("Python tool session closed"));
+      signal.removeEventListener("abort", aborted);
+      await Promise.all([...spools].map((value) => value.close()));
+      spools.clear();
+    })();
+    context.registerCleanup?.(close);
+    try {
+      signal.throwIfAborted();
+      await ready.promise;
+      return { tools: Object.freeze(tools), toolboxes: Object.freeze(toolboxes), ...plugins ? { plugins } : {}, close };
+    } catch (error) {
+      await close();
+      throw error;
+    }
+  };
+}
+
+// packages/safe-bash-command-python/src/build-environment.ts
+function createPythonBuildEnvironment(options = {}) {
+  const manifestStore = createPythonPackageManifestStore({ maxEntries: 1, ...options.maxManifestBytes === void 0 ? {} : { maxBytes: options.maxManifestBytes } });
+  const isolated = { ...options, manifestStore, scope: "build" };
+  delete isolated.editable;
+  delete isolated.requirements;
+  delete isolated.requirementFiles;
+  delete isolated.profile;
+  const environment = createPythonPackageEnvironment(isolated);
+  let disposing;
+  return { ...environment, dispose() {
+    return disposing ??= environment.dispose().finally(() => manifestStore.dispose());
+  } };
+}
+
+// packages/safe-bash-command-python/src/build-dependencies.ts
+import { toByteSource as toByteSource6 } from "../../safe-bash-contracts/index.js";
+
+// packages/safe-bash-command-python/src/source-origin-program.generated.ts
+var pythonSourceOriginProgram = "def read_source_origin(request):\n import re, json\n from urllib.parse import urlsplit, urlunsplit\n source = request['source']\n if source.startswith('/'):\n  from pathlib import Path\n  source = Path(source).as_uri()\n url = urlsplit(source)\n netloc = url.netloc\n if '@' in netloc:\n  credentials, host = netloc.split('@', 1)\n  if not re.match(r'^\\$\\{[A-Za-z0-9-_]+\\}(:\\$\\{[A-Za-z0-9-_]+\\})?$', credentials): netloc = host\n result = {'url': urlunsplit((url.scheme, netloc, url.path, url.query, ''))}\n subdirectory = re.search(r'[#&]subdirectory=([^&]*)', source)\n if subdirectory: result['subdirectory'] = subdirectory.group(1)\n info = {}\n if not request['directory']:\n  hashed = re.search(r'(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)', source)\n  if hashed: info['hash'] = hashed.group(1) + '=' + hashed.group(2)\n result['dir_info' if request['directory'] else 'archive_info'] = info\n return json.dumps(result, sort_keys=True)\n";
+
+// packages/safe-bash-command-python/src/source-filename-program.ts
+var pythonDownloadFilenameProgram = /* @__PURE__ */ (() => String.raw`
+MIME_PREFERENCES = {"application/andrew-inset":".ez","application/applixware":".aw","application/atom+xml":".atom","application/atomcat+xml":".atomcat","application/atomsvc+xml":".atomsvc","application/ccxml+xml":".ccxml","application/cdmi-capability":".cdmia","application/cdmi-container":".cdmic","application/cdmi-domain":".cdmid","application/cdmi-object":".cdmio","application/cdmi-queue":".cdmiq","application/cu-seeme":".cu","application/davmount+xml":".davmount","application/docbook+xml":".dbk","application/dssc+der":".dssc","application/dssc+xml":".xdssc","application/ecmascript":".ecma","application/emma+xml":".emma","application/epub+zip":".epub","application/exi":".exi","application/font-tdpfr":".pfr","application/gml+xml":".gml","application/gpx+xml":".gpx","application/gxf":".gxf","application/hyperstudio":".stk","application/inkml+xml":".ink","application/ipfix":".ipfix","application/java-archive":".jar","application/java-serialized-object":".ser","application/java-vm":".class","application/json":".json","application/jsonml+json":".jsonml","application/lost+xml":".lostxml","application/mac-binhex40":".hqx","application/mac-compactpro":".cpt","application/mads+xml":".mads","application/manifest+json":".webmanifest","application/marc":".mrc","application/marcxml+xml":".mrcx","application/mathematica":".ma","application/mathml+xml":".mathml","application/mbox":".mbox","application/mediaservercontrol+xml":".mscml","application/metalink+xml":".metalink","application/metalink4+xml":".meta4","application/mets+xml":".mets","application/mods+xml":".mods","application/mp21":".m21","application/mp4":".mp4s","application/msword":".doc","application/mxf":".mxf","application/octet-stream":".bin","application/oda":".oda","application/oebps-package+xml":".opf","application/ogg":".ogx","application/omdoc+xml":".omdoc","application/onenote":".onetoc","application/oxps":".oxps","application/patch-ops-error+xml":".xer","application/pdf":".pdf","application/pgp-encrypted":".pgp","application/pgp-signature":".asc","application/pics-rules":".prf","application/pkcs10":".p10","application/pkcs7-mime":".p7c","application/pkcs7-signature":".p7s","application/pkcs8":".p8","application/pkix-attr-cert":".ac","application/pkix-cert":".cer","application/pkix-crl":".crl","application/pkix-pkipath":".pkipath","application/pkixcmp":".pki","application/pls+xml":".pls","application/postscript":".ps","application/prs.cww":".cww","application/pskc+xml":".pskcxml","application/rdf+xml":".rdf","application/reginfo+xml":".rif","application/relax-ng-compact-syntax":".rnc","application/resource-lists+xml":".rl","application/resource-lists-diff+xml":".rld","application/rls-services+xml":".rs","application/rpki-ghostbusters":".gbr","application/rpki-manifest":".mft","application/rpki-roa":".roa","application/rsd+xml":".rsd","application/rss+xml":".rss","application/rtf":".rtf","application/sbml+xml":".sbml","application/scvp-cv-request":".scq","application/scvp-cv-response":".scs","application/scvp-vp-request":".spq","application/scvp-vp-response":".spp","application/sdp":".sdp","application/set-payment-initiation":".setpay","application/set-registration-initiation":".setreg","application/shf+xml":".shf","application/smil+xml":".smi","application/sparql-query":".rq","application/sparql-results+xml":".srx","application/srgs":".gram","application/srgs+xml":".grxml","application/sru+xml":".sru","application/ssdl+xml":".ssdl","application/ssml+xml":".ssml","application/tei+xml":".tei","application/thraud+xml":".tfi","application/timestamped-data":".tsd","application/vnd.3gpp.pic-bw-large":".plb","application/vnd.3gpp.pic-bw-small":".psb","application/vnd.3gpp.pic-bw-var":".pvb","application/vnd.3gpp2.tcap":".tcap","application/vnd.3m.post-it-notes":".pwn","application/vnd.accpac.simply.aso":".aso","application/vnd.accpac.simply.imp":".imp","application/vnd.acucobol":".acu","application/vnd.acucorp":".atc","application/vnd.adobe.air-application-installer-package+zip":".air","application/vnd.adobe.formscentral.fcdt":".fcdt","application/vnd.adobe.fxp":".fxp","application/vnd.adobe.xdp+xml":".xdp","application/vnd.adobe.xfdf":".xfdf","application/vnd.ahead.space":".ahead","application/vnd.airzip.filesecure.azf":".azf","application/vnd.airzip.filesecure.azs":".azs","application/vnd.amazon.ebook":".azw","application/vnd.americandynamics.acc":".acc","application/vnd.amiga.ami":".ami","application/vnd.android.package-archive":".apk","application/vnd.anser-web-certificate-issue-initiation":".cii","application/vnd.anser-web-funds-transfer-initiation":".fti","application/vnd.antix.game-component":".atx","application/vnd.apple.installer+xml":".mpkg","application/vnd.aristanetworks.swi":".swi","application/vnd.astraea-software.iota":".iota","application/vnd.audiograph":".aep","application/vnd.blueice.multipass":".mpm","application/vnd.bmi":".bmi","application/vnd.businessobjects":".rep","application/vnd.chemdraw+xml":".cdxml","application/vnd.chipnuts.karaoke-mmd":".mmd","application/vnd.cinderella":".cdy","application/vnd.claymore":".cla","application/vnd.cloanto.rp9":".rp9","application/vnd.clonk.c4group":".c4g","application/vnd.cluetrust.cartomobile-config":".c11amc","application/vnd.cluetrust.cartomobile-config-pkg":".c11amz","application/vnd.commonspace":".csp","application/vnd.contact.cmsg":".cdbcmsg","application/vnd.cosmocaller":".cmc","application/vnd.crick.clicker":".clkx","application/vnd.crick.clicker.keyboard":".clkk","application/vnd.crick.clicker.palette":".clkp","application/vnd.crick.clicker.template":".clkt","application/vnd.crick.clicker.wordbank":".clkw","application/vnd.criticaltools.wbs+xml":".wbs","application/vnd.ctc-posml":".pml","application/vnd.cups-ppd":".ppd","application/vnd.curl.car":".car","application/vnd.curl.pcurl":".pcurl","application/vnd.dart":".dart","application/vnd.data-vision.rdz":".rdz","application/vnd.dece.data":".uvf","application/vnd.dece.ttml+xml":".uvt","application/vnd.dece.unspecified":".uvx","application/vnd.dece.zip":".uvz","application/vnd.denovo.fcselayout-link":".fe_launch","application/vnd.dna":".dna","application/vnd.dolby.mlp":".mlp","application/vnd.dpgraph":".dpg","application/vnd.dreamfactory":".dfac","application/vnd.ds-keypoint":".kpxx","application/vnd.dvb.ait":".ait","application/vnd.dvb.service":".svc","application/vnd.dynageo":".geo","application/vnd.ecowin.chart":".mag","application/vnd.enliven":".nml","application/vnd.epson.esf":".esf","application/vnd.epson.msf":".msf","application/vnd.epson.quickanime":".qam","application/vnd.epson.salt":".slt","application/vnd.epson.ssf":".ssf","application/vnd.eszigno3+xml":".es3","application/vnd.ezpix-album":".ez2","application/vnd.ezpix-package":".ez3","application/vnd.fdf":".fdf","application/vnd.fdsn.mseed":".mseed","application/vnd.fdsn.seed":".seed","application/vnd.flographit":".gph","application/vnd.fluxtime.clip":".ftc","application/vnd.framemaker":".fm","application/vnd.frogans.fnc":".fnc","application/vnd.frogans.ltf":".ltf","application/vnd.fsc.weblaunch":".fsc","application/vnd.fujitsu.oasys":".oas","application/vnd.fujitsu.oasys2":".oa2","application/vnd.fujitsu.oasys3":".oa3","application/vnd.fujitsu.oasysgp":".fg5","application/vnd.fujitsu.oasysprs":".bh2","application/vnd.fujixerox.ddd":".ddd","application/vnd.fujixerox.docuworks":".xdw","application/vnd.fujixerox.docuworks.binder":".xbd","application/vnd.fuzzysheet":".fzs","application/vnd.genomatix.tuxedo":".txd","application/vnd.geogebra.file":".ggb","application/vnd.geogebra.slides":".ggs","application/vnd.geogebra.tool":".ggt","application/vnd.geometry-explorer":".gex","application/vnd.geonext":".gxt","application/vnd.geoplan":".g2w","application/vnd.geospace":".g3w","application/vnd.gmx":".gmx","application/vnd.google-earth.kml+xml":".kml","application/vnd.google-earth.kmz":".kmz","application/vnd.grafeq":".gqf","application/vnd.groove-account":".gac","application/vnd.groove-help":".ghf","application/vnd.groove-identity-message":".gim","application/vnd.groove-injector":".grv","application/vnd.groove-tool-message":".gtm","application/vnd.groove-tool-template":".tpl","application/vnd.groove-vcard":".vcg","application/vnd.hal+xml":".hal","application/vnd.handheld-entertainment+xml":".zmm","application/vnd.hbci":".hbci","application/vnd.hhe.lesson-player":".les","application/vnd.hp-hpgl":".hpgl","application/vnd.hp-hpid":".hpid","application/vnd.hp-hps":".hps","application/vnd.hp-jlyt":".jlt","application/vnd.hp-pcl":".pcl","application/vnd.hp-pclxl":".pclxl","application/vnd.hydrostatix.sof-data":".sfd-hdstx","application/vnd.ibm.minipay":".mpy","application/vnd.ibm.modcap":".afp","application/vnd.ibm.rights-management":".irm","application/vnd.ibm.secure-container":".sc","application/vnd.iccprofile":".icc","application/vnd.igloader":".igl","application/vnd.immervision-ivp":".ivp","application/vnd.immervision-ivu":".ivu","application/vnd.insors.igm":".igm","application/vnd.intercon.formnet":".xpw","application/vnd.intergeo":".i2g","application/vnd.intu.qbo":".qbo","application/vnd.intu.qfx":".qfx","application/vnd.ipunplugged.rcprofile":".rcprofile","application/vnd.irepository.package+xml":".irp","application/vnd.is-xpr":".xpr","application/vnd.isac.fcs":".fcs","application/vnd.jam":".jam","application/vnd.jcp.javame.midlet-rms":".rms","application/vnd.jisp":".jisp","application/vnd.joost.joda-archive":".joda","application/vnd.kahootz":".ktz","application/vnd.kde.karbon":".karbon","application/vnd.kde.kchart":".chrt","application/vnd.kde.kformula":".kfo","application/vnd.kde.kivio":".flw","application/vnd.kde.kontour":".kon","application/vnd.kde.kpresenter":".kpr","application/vnd.kde.kspread":".ksp","application/vnd.kde.kword":".kwd","application/vnd.kenameaapp":".htke","application/vnd.kidspiration":".kia","application/vnd.kinar":".kne","application/vnd.koan":".skp","application/vnd.kodak-descriptor":".sse","application/vnd.las.las+xml":".lasxml","application/vnd.llamagraphics.life-balance.desktop":".lbd","application/vnd.llamagraphics.life-balance.exchange+xml":".lbe","application/vnd.lotus-1-2-3":".123","application/vnd.lotus-approach":".apr","application/vnd.lotus-freelance":".pre","application/vnd.lotus-notes":".nsf","application/vnd.lotus-organizer":".org","application/vnd.lotus-screencam":".scm","application/vnd.lotus-wordpro":".lwp","application/vnd.macports.portpkg":".portpkg","application/vnd.mcd":".mcd","application/vnd.medcalcdata":".mc1","application/vnd.mediastation.cdkey":".cdkey","application/vnd.mfer":".mwf","application/vnd.mfmp":".mfm","application/vnd.micrografx.flo":".flo","application/vnd.micrografx.igx":".igx","application/vnd.mif":".mif","application/vnd.mobius.daf":".daf","application/vnd.mobius.dis":".dis","application/vnd.mobius.mbk":".mbk","application/vnd.mobius.mqy":".mqy","application/vnd.mobius.msl":".msl","application/vnd.mobius.plc":".plc","application/vnd.mobius.txf":".txf","application/vnd.mophun.application":".mpn","application/vnd.mophun.certificate":".mpc","application/vnd.mozilla.xul+xml":".xul","application/vnd.ms-artgalry":".cil","application/vnd.ms-cab-compressed":".cab","application/vnd.ms-excel":".xls","application/vnd.ms-excel.addin.macroenabled.12":".xlam","application/vnd.ms-excel.sheet.binary.macroenabled.12":".xlsb","application/vnd.ms-excel.sheet.macroenabled.12":".xlsm","application/vnd.ms-excel.template.macroenabled.12":".xltm","application/vnd.ms-fontobject":".eot","application/vnd.ms-htmlhelp":".chm","application/vnd.ms-ims":".ims","application/vnd.ms-lrm":".lrm","application/vnd.ms-officetheme":".thmx","application/vnd.ms-pki.seccat":".cat","application/vnd.ms-pki.stl":".stl","application/vnd.ms-powerpoint":".ppt","application/vnd.ms-powerpoint.addin.macroenabled.12":".ppam","application/vnd.ms-powerpoint.presentation.macroenabled.12":".pptm","application/vnd.ms-powerpoint.slide.macroenabled.12":".sldm","application/vnd.ms-powerpoint.slideshow.macroenabled.12":".ppsm","application/vnd.ms-powerpoint.template.macroenabled.12":".potm","application/vnd.ms-project":".mpp","application/vnd.ms-word.document.macroenabled.12":".docm","application/vnd.ms-word.template.macroenabled.12":".dotm","application/vnd.ms-works":".wps","application/vnd.ms-wpl":".wpl","application/vnd.ms-xpsdocument":".xps","application/vnd.mseq":".mseq","application/vnd.musician":".mus","application/vnd.muvee.style":".msty","application/vnd.mynfc":".taglet","application/vnd.neurolanguage.nlu":".nlu","application/vnd.nitf":".ntf","application/vnd.noblenet-directory":".nnd","application/vnd.noblenet-sealer":".nns","application/vnd.noblenet-web":".nnw","application/vnd.nokia.n-gage.data":".ngdat","application/vnd.nokia.n-gage.symbian.install":".n-gage","application/vnd.nokia.radio-preset":".rpst","application/vnd.nokia.radio-presets":".rpss","application/vnd.novadigm.edm":".edm","application/vnd.novadigm.edx":".edx","application/vnd.novadigm.ext":".ext","application/vnd.oasis.opendocument.chart":".odc","application/vnd.oasis.opendocument.chart-template":".otc","application/vnd.oasis.opendocument.database":".odb","application/vnd.oasis.opendocument.formula":".odf","application/vnd.oasis.opendocument.formula-template":".odft","application/vnd.oasis.opendocument.graphics":".odg","application/vnd.oasis.opendocument.graphics-template":".otg","application/vnd.oasis.opendocument.image":".odi","application/vnd.oasis.opendocument.image-template":".oti","application/vnd.oasis.opendocument.presentation":".odp","application/vnd.oasis.opendocument.presentation-template":".otp","application/vnd.oasis.opendocument.spreadsheet":".ods","application/vnd.oasis.opendocument.spreadsheet-template":".ots","application/vnd.oasis.opendocument.text":".odt","application/vnd.oasis.opendocument.text-master":".odm","application/vnd.oasis.opendocument.text-template":".ott","application/vnd.oasis.opendocument.text-web":".oth","application/vnd.olpc-sugar":".xo","application/vnd.oma.dd2+xml":".dd2","application/vnd.openofficeorg.extension":".oxt","application/vnd.openxmlformats-officedocument.presentationml.presentation":".pptx","application/vnd.openxmlformats-officedocument.presentationml.slide":".sldx","application/vnd.openxmlformats-officedocument.presentationml.slideshow":".ppsx","application/vnd.openxmlformats-officedocument.presentationml.template":".potx","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":".xlsx","application/vnd.openxmlformats-officedocument.spreadsheetml.template":".xltx","application/vnd.openxmlformats-officedocument.wordprocessingml.document":".docx","application/vnd.openxmlformats-officedocument.wordprocessingml.template":".dotx","application/vnd.osgeo.mapguide.package":".mgp","application/vnd.osgi.dp":".dp","application/vnd.osgi.subsystem":".esa","application/vnd.palm":".pdb","application/vnd.pawaafile":".paw","application/vnd.pg.format":".str","application/vnd.pg.osasli":".ei6","application/vnd.picsel":".efif","application/vnd.pmi.widget":".wg","application/vnd.pocketlearn":".plf","application/vnd.powerbuilder6":".pbd","application/vnd.previewsystems.box":".box","application/vnd.proteus.magazine":".mgz","application/vnd.publishare-delta-tree":".qps","application/vnd.pvi.ptid1":".ptid","application/vnd.quark.quarkxpress":".qxd","application/vnd.realvnc.bed":".bed","application/vnd.recordare.musicxml":".mxl","application/vnd.recordare.musicxml+xml":".musicxml","application/vnd.rig.cryptonote":".cryptonote","application/vnd.rim.cod":".cod","application/vnd.rn-realmedia":".rm","application/vnd.rn-realmedia-vbr":".rmvb","application/vnd.route66.link66+xml":".link66","application/vnd.sailingtracker.track":".st","application/vnd.seemail":".see","application/vnd.sema":".sema","application/vnd.semd":".semd","application/vnd.semf":".semf","application/vnd.shana.informed.formdata":".ifm","application/vnd.shana.informed.formtemplate":".itp","application/vnd.shana.informed.interchange":".iif","application/vnd.shana.informed.package":".ipk","application/vnd.simtech-mindmapper":".twd","application/vnd.smaf":".mmf","application/vnd.smart.teacher":".teacher","application/vnd.solent.sdkm+xml":".sdkm","application/vnd.spotfire.dxp":".dxp","application/vnd.spotfire.sfs":".sfs","application/vnd.stardivision.calc":".sdc","application/vnd.stardivision.draw":".sda","application/vnd.stardivision.impress":".sdd","application/vnd.stardivision.math":".smf","application/vnd.stardivision.writer":".sdw","application/vnd.stardivision.writer-global":".sgl","application/vnd.stepmania.package":".smzip","application/vnd.stepmania.stepchart":".sm","application/vnd.sun.xml.calc":".sxc","application/vnd.sun.xml.calc.template":".stc","application/vnd.sun.xml.draw":".sxd","application/vnd.sun.xml.draw.template":".std","application/vnd.sun.xml.impress":".sxi","application/vnd.sun.xml.impress.template":".sti","application/vnd.sun.xml.math":".sxm","application/vnd.sun.xml.writer":".sxw","application/vnd.sun.xml.writer.global":".sxg","application/vnd.sun.xml.writer.template":".stw","application/vnd.sus-calendar":".sus","application/vnd.svd":".svd","application/vnd.symbian.install":".sis","application/vnd.syncml+xml":".xsm","application/vnd.syncml.dm+wbxml":".bdm","application/vnd.syncml.dm+xml":".xdm","application/vnd.tao.intent-module-archive":".tao","application/vnd.tcpdump.pcap":".pcap","application/vnd.tmobile-livetv":".tmo","application/vnd.trid.tpt":".tpt","application/vnd.triscape.mxs":".mxs","application/vnd.trueapp":".tra","application/vnd.ufdl":".ufd","application/vnd.uiq.theme":".utz","application/vnd.umajin":".umj","application/vnd.unity":".unityweb","application/vnd.uoml+xml":".uoml","application/vnd.vcx":".vcx","application/vnd.visio":".vsd","application/vnd.visionary":".vis","application/vnd.vsf":".vsf","application/vnd.wap.wbxml":".wbxml","application/vnd.wap.wmlc":".wmlc","application/vnd.wap.wmlscriptc":".wmlsc","application/vnd.webturbo":".wtb","application/vnd.wolfram.player":".nbp","application/vnd.wordperfect":".wpd","application/vnd.wqd":".wqd","application/vnd.wt.stf":".stf","application/vnd.xara":".xar","application/vnd.xfdl":".xfdl","application/vnd.yamaha.hv-dic":".hvd","application/vnd.yamaha.hv-script":".hvs","application/vnd.yamaha.hv-voice":".hvp","application/vnd.yamaha.openscoreformat":".osf","application/vnd.yamaha.openscoreformat.osfpvg+xml":".osfpvg","application/vnd.yamaha.smaf-audio":".saf","application/vnd.yamaha.smaf-phrase":".spf","application/vnd.yellowriver-custom-menu":".cmp","application/vnd.zul":".zir","application/vnd.zzazz.deck+xml":".zaz","application/voicexml+xml":".vxml","application/wasm":".wasm","application/widget":".wgt","application/winhlp":".hlp","application/wsdl+xml":".wsdl","application/wspolicy+xml":".wspolicy","application/x-7z-compressed":".7z","application/x-abiword":".abw","application/x-ace-compressed":".ace","application/x-apple-diskimage":".dmg","application/x-authorware-bin":".aab","application/x-authorware-map":".aam","application/x-authorware-seg":".aas","application/x-bcpio":".bcpio","application/x-bittorrent":".torrent","application/x-blorb":".blb","application/x-bzip":".bz","application/x-bzip2":".bz2","application/x-cbr":".cbr","application/x-cdlink":".vcd","application/x-cfs-compressed":".cfs","application/x-chat":".chat","application/x-chess-pgn":".pgn","application/x-conference":".nsc","application/x-cpio":".cpio","application/x-csh":".csh","application/x-debian-package":".deb","application/x-dgc-compressed":".dgc","application/x-director":".dir","application/x-doom":".wad","application/x-dtbncx+xml":".ncx","application/x-dtbook+xml":".dtb","application/x-dtbresource+xml":".res","application/x-dvi":".dvi","application/x-envoy":".evy","application/x-eva":".eva","application/x-font-bdf":".bdf","application/x-font-ghostscript":".gsf","application/x-font-linux-psf":".psf","application/x-font-pcf":".pcf","application/x-font-snf":".snf","application/x-font-type1":".pfa","application/x-freearc":".arc","application/x-futuresplash":".spl","application/x-gca-compressed":".gca","application/x-glulx":".ulx","application/x-gnumeric":".gnumeric","application/x-gramps-xml":".gramps","application/x-gtar":".gtar","application/x-hdf":".hdf","application/x-install-instructions":".install","application/x-iso9660-image":".iso","application/x-java-jnlp-file":".jnlp","application/x-latex":".latex","application/x-lzh-compressed":".lzh","application/x-mie":".mie","application/x-mobipocket-ebook":".prc","application/x-mpegurl":".m3u8","application/x-ms-application":".application","application/x-ms-shortcut":".lnk","application/x-ms-wmd":".wmd","application/x-ms-xbap":".xbap","application/x-msaccess":".mdb","application/x-msbinder":".obd","application/x-mscardfile":".crd","application/x-msclip":".clp","application/x-msdownload":".exe","application/x-msmediaview":".mvb","application/x-msmetafile":".wmf","application/x-msmoney":".mny","application/x-mspublisher":".pub","application/x-msschedule":".scd","application/x-msterminal":".trm","application/x-mswrite":".wri","application/x-netcdf":".cdf","application/x-nzb":".nzb","application/x-pkcs12":".p12","application/x-pkcs7-certificates":".p7b","application/x-pkcs7-certreqresp":".p7r","application/x-python-code":".pyc","application/x-rar-compressed":".rar","application/x-research-info-systems":".ris","application/x-sh":".sh","application/x-shar":".shar","application/x-shockwave-flash":".swf","application/x-silverlight-app":".xap","application/x-sql":".sql","application/x-stuffit":".sit","application/x-stuffitx":".sitx","application/x-subrip":".srt","application/x-sv4cpio":".sv4cpio","application/x-sv4crc":".sv4crc","application/x-t3vm-image":".t3","application/x-tads":".gam","application/x-tar":".tar","application/x-tcl":".tcl","application/x-tex":".tex","application/x-tex-tfm":".tfm","application/x-texinfo":".texi","application/x-tgif":".obj","application/x-ustar":".ustar","application/x-wais-source":".src","application/x-x509-ca-cert":".der","application/x-xfig":".fig","application/x-xliff+xml":".xlf","application/x-xpinstall":".xpi","application/x-xz":".xz","application/x-zmachine":".z1","application/xaml+xml":".xaml","application/xcap-diff+xml":".xdf","application/xenc+xml":".xenc","application/xhtml+xml":".xhtml","application/xml":".xsl","application/xml-dtd":".dtd","application/xop+xml":".xop","application/xproc+xml":".xpl","application/xslt+xml":".xslt","application/xspf+xml":".xspf","application/xv+xml":".mxml","application/yang":".yang","application/yin+xml":".yin","application/zip":".zip","audio/adpcm":".adp","audio/basic":".au","audio/midi":".mid","audio/mp4":".m4a","audio/mp4a-latm":".m4a","audio/mpeg":".mp3","audio/ogg":".oga","audio/s3m":".s3m","audio/silk":".sil","audio/vnd.dece.audio":".uva","audio/vnd.digital-winds":".eol","audio/vnd.dra":".dra","audio/vnd.dts":".dts","audio/vnd.dts.hd":".dtshd","audio/vnd.lucent.voice":".lvp","audio/vnd.ms-playready.media.pya":".pya","audio/vnd.nuera.ecelp4800":".ecelp4800","audio/vnd.nuera.ecelp7470":".ecelp7470","audio/vnd.nuera.ecelp9600":".ecelp9600","audio/vnd.rip":".rip","audio/webm":".weba","audio/x-aac":".aac","audio/x-aiff":".aif","audio/x-caf":".caf","audio/x-flac":".flac","audio/x-matroska":".mka","audio/x-mpegurl":".m3u","audio/x-ms-wax":".wax","audio/x-ms-wma":".wma","audio/x-pn-realaudio":".ra","audio/x-pn-realaudio-plugin":".rmp","audio/x-wav":".wav","audio/xm":".xm","chemical/x-cdx":".cdx","chemical/x-cif":".cif","chemical/x-cmdf":".cmdf","chemical/x-cml":".cml","chemical/x-csml":".csml","chemical/x-xyz":".xyz","font/collection":".ttc","font/otf":".otf","font/ttf":".ttf","font/woff":".woff","font/woff2":".woff2","image/avif":".avif","image/bmp":".bmp","image/cgm":".cgm","image/g3fax":".g3","image/gif":".gif","image/ief":".ief","image/jp2":".jp2","image/jpeg":".jpg","image/jxl":".jxl","image/ktx":".ktx","image/pict":".pict","image/png":".png","image/prs.btif":".btif","image/sgi":".sgi","image/svg+xml":".svg","image/tiff":".tiff","image/vnd.adobe.photoshop":".psd","image/vnd.dece.graphic":".uvi","image/vnd.djvu":".djvu","image/vnd.dwg":".dwg","image/vnd.dxf":".dxf","image/vnd.fastbidsheet":".fbs","image/vnd.fpx":".fpx","image/vnd.fst":".fst","image/vnd.fujixerox.edmics-mmr":".mmr","image/vnd.fujixerox.edmics-rlc":".rlc","image/vnd.ms-modi":".mdi","image/vnd.ms-photo":".wdp","image/vnd.net-fpx":".npx","image/vnd.wap.wbmp":".wbmp","image/vnd.xiff":".xif","image/webp":".webp","image/x-3ds":".3ds","image/x-cmu-raster":".ras","image/x-cmx":".cmx","image/x-freehand":".fh","image/x-icon":".ico","image/x-macpaint":".pntg","image/x-mrsid-image":".sid","image/x-pcx":".pcx","image/x-pict":".pic","image/x-portable-anymap":".pnm","image/x-portable-bitmap":".pbm","image/x-portable-graymap":".pgm","image/x-portable-pixmap":".ppm","image/x-quicktime":".qtif","image/x-rgb":".rgb","image/x-tga":".tga","image/x-xbitmap":".xbm","image/x-xpixmap":".xpm","image/x-xwindowdump":".xwd","message/rfc822":".eml","model/iges":".igs","model/mesh":".msh","model/vnd.collada+xml":".dae","model/vnd.dwf":".dwf","model/vnd.gdl":".gdl","model/vnd.gtw":".gtw","model/vnd.vtu":".vtu","model/vrml":".wrl","model/x3d+binary":".x3db","model/x3d+vrml":".x3dv","model/x3d+xml":".x3d","text/cache-manifest":".manifest","text/calendar":".ics","text/css":".css","text/csv":".csv","text/html":".html","text/javascript":".js","text/n3":".n3","text/plain":".txt","text/prs.lines.tag":".dsc","text/richtext":".rtx","text/sgml":".sgml","text/tab-separated-values":".tsv","text/troff":".t","text/turtle":".ttl","text/uri-list":".uri","text/vcard":".vcard","text/vnd.curl":".curl","text/vnd.curl.dcurl":".dcurl","text/vnd.curl.mcurl":".mcurl","text/vnd.curl.scurl":".scurl","text/vnd.dvb.subtitle":".sub","text/vnd.fly":".fly","text/vnd.fmi.flexstor":".flx","text/vnd.graphviz":".gv","text/vnd.in3d.3dml":".3dml","text/vnd.in3d.spot":".spot","text/vnd.sun.j2me.app-descriptor":".jad","text/vnd.wap.wml":".wml","text/vnd.wap.wmlscript":".wmls","text/x-asm":".s","text/x-c":".c","text/x-fortran":".f","text/x-java-source":".java","text/x-nfo":".nfo","text/x-opml":".opml","text/x-pascal":".p","text/x-python":".py","text/x-setext":".etx","text/x-sfv":".sfv","text/x-uuencode":".uu","text/x-vcalendar":".vcs","text/x-vcard":".vcf","video/3gpp":".3gp","video/3gpp2":".3g2","video/h261":".h261","video/h263":".h263","video/h264":".h264","video/jpeg":".jpgv","video/jpm":".jpm","video/mj2":".mj2","video/mp2t":".ts","video/mp4":".mp4","video/mpeg":".mpeg","video/ogg":".ogv","video/quicktime":".mov","video/vnd.dece.hd":".uvh","video/vnd.dece.mobile":".uvm","video/vnd.dece.pd":".uvp","video/vnd.dece.sd":".uvs","video/vnd.dece.video":".uvv","video/vnd.dvb.file":".dvb","video/vnd.fvt":".fvt","video/vnd.mpegurl":".mxu","video/vnd.ms-playready.media.pyv":".pyv","video/vnd.uvvu.mp4":".uvu","video/vnd.vivo":".viv","video/webm":".webm","video/x-dv":".dv","video/x-f4v":".f4v","video/x-fli":".fli","video/x-flv":".flv","video/x-m4v":".m4v","video/x-matroska":".mkv","video/x-mng":".mng","video/x-ms-asf":".asf","video/x-ms-vob":".vob","video/x-ms-wm":".wm","video/x-ms-wmv":".wmv","video/x-ms-wmx":".wmx","video/x-ms-wvx":".wvx","video/x-msvideo":".avi","video/x-sgi-movie":".movie","video/x-smv":".smv","x-conference/x-cooltalk":".ice"}
+
+def read_download_filename(request):
+ from urllib.parse import urlsplit, unquote
+ import posixpath
+ url = urlsplit(request['source'])
+ filename = unquote(posixpath.basename(url.path.rstrip('/'))) or url.netloc.rsplit('@', 1)[-1]
+ headers = {key.lower(): value for key, value in request['headers']}
+ # CPython 3.9 cgi.parse_header rules, including last duplicate wins.
+ remaining = ';' + headers.get('content-disposition', '')
+ parameters = []
+ while remaining[:1] == ';':
+  remaining = remaining[1:]
+  end = remaining.find(';')
+  while end > 0 and (remaining.count('"', 0, end) - remaining.count('\\"', 0, end)) % 2:
+   end = remaining.find(';', end + 1)
+  if end < 0: end = len(remaining)
+  parameters.append(remaining[:end].strip())
+  remaining = remaining[end:]
+ selected = None
+ for parameter in parameters[1:]:
+  if '=' not in parameter: continue
+  key, value = parameter.split('=', 1)
+  if key.strip().lower() != 'filename': continue
+  value = value.strip()
+  if len(value) >= 2 and value[0] == value[-1] == '"':
+   value = value[1:-1].replace('\\\\', '\\').replace('\\"', '"')
+  selected = posixpath.basename(value) if value else ''
+ filename = selected or filename
+ ext = posixpath.splitext(filename)[1]
+ if not ext:
+  ext = MIME_PREFERENCES.get(headers.get('content-type', '').lower())
+  if ext: filename += ext
+ if not ext and request['source'] != request['responseUrl']:
+  ext = posixpath.splitext(request['responseUrl'])[1]
+  if ext: filename += ext
+ return filename
+`)();
+
+// packages/safe-bash-command-python/src/build-backend.ts
+import { toByteSource as toByteSource5 } from "../../safe-bash-contracts/index.js";
+function createPythonBuildBackend(options) {
+  if (!options.createExecutor || !options.environment || options.provisioning) throw new TypeError("Python build hooks require an asynchronous executor and explicit environment");
+  const capabilities = /* @__PURE__ */ new WeakMap();
+  const environment = options.environment, legacy = /* @__PURE__ */ new WeakSet();
+  const command = createPythonExecutorCommands({ ...options, environment: { ...environment, async prepare(context) {
+    return { ...await environment.prepare(context), bootstrap: true, ...context.args && legacy.has(context.args) ? { bootstrapPackages: ["setuptools"] } : {} };
+  } }, createCapabilities(context) {
+    const provided = options.createCapabilities?.(context) ?? {};
+    if (provided.python_build) throw new Error("Python build capability is reserved");
+    const capability = capabilities.get(context.args);
+    if (!capability) throw new Error("Unknown Python build invocation");
+    return { ...provided, python_build: capability };
+  } })[0];
+  return async function run(input, context) {
+    context.signal.throwIfAborted();
+    const { maxBytes } = context;
+    if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("Invalid Python build metadata limit");
+    if (!input || !["read_source_origin", "read_download_filename", "read_editable_requirement", "get_requires_for_legacy_wheel", "read_source_requirement", "read_build_system", "check_build_requirements", "get_requires_for_build_wheel", "build_wheel", "build_legacy_wheel"].includes(input.hook) || typeof input.source !== "string" || !input.source) throw new TypeError("Invalid Python build hook request");
+    if (input.hook === "read_editable_requirement" && input.requirementLine !== void 0 && typeof input.requirementLine !== "boolean") throw new TypeError("Invalid editable requirement line");
+    if (input.hook === "read_source_origin") {
+      if (typeof input.directory !== "boolean") throw new TypeError("Invalid Python source origin");
+    } else if (input.hook === "read_download_filename") {
+      if (typeof input.responseUrl !== "string" || !Array.isArray(input.headers) || input.headers.some((pair) => !Array.isArray(pair) || pair.length !== 2 || pair.some((value) => typeof value !== "string"))) throw new TypeError("Invalid Python download metadata");
+    } else if (input.hook === "build_legacy_wheel") {
+      if (typeof input.wheelDirectory !== "string" || !input.wheelDirectory || input.editable !== void 0 && typeof input.editable !== "boolean") throw new TypeError("Invalid Python legacy wheel directory");
+    } else if (input.hook === "check_build_requirements") {
+      if ([input.requirements, input.installed].some((values) => !Array.isArray(values) || values.some((value) => typeof value !== "string"))) throw new TypeError("Invalid Python build requirements request");
+    } else if (input.hook === "read_build_system") {
+      if (input.installation !== void 0 && !["directory", "archive"].includes(input.installation)) throw new TypeError("Invalid Python source installation");
+      if (input.name !== void 0 && typeof input.name !== "string" || input.usePep517 !== void 0 && typeof input.usePep517 !== "boolean") throw new TypeError("Invalid Python build system request");
+    } else if (input.hook !== "read_source_requirement" && input.hook !== "read_editable_requirement" && input.hook !== "get_requires_for_legacy_wheel") {
+      if (typeof input.backend !== "string" || !input.backend || input.backendPath !== void 0 && (!Array.isArray(input.backendPath) || input.backendPath.some((path) => typeof path !== "string")) || input.hook === "build_wheel" && (typeof input.wheelDirectory !== "string" || !input.wheelDirectory || input.metadataDirectory !== void 0 && typeof input.metadataDirectory !== "string")) throw new TypeError("Invalid Python build hook request");
+      if (input.configSettings !== void 0 && (!input.configSettings || typeof input.configSettings !== "object" || Array.isArray(input.configSettings) || Object.values(input.configSettings).some((value) => typeof value !== "string" && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))))) throw new TypeError("Invalid Python build configuration");
+    }
+    const request = structuredClone(input.hook === "read_build_system" ? { ...input, maxBytes: maxBytes === Infinity ? null : maxBytes } : input);
+    let done = false, size = 0, failure;
+    const chunks = [];
+    const invocation = { ...context, command: "python", args: ["-c", pythonBuildBackendProgram], stdin: toByteSource5("") };
+    if (request.hook === "build_legacy_wheel" || request.hook === "get_requires_for_legacy_wheel") legacy.add(invocation.args);
+    capabilities.set(invocation.args, { async call(value) {
+      try {
+        context.signal.throwIfAborted();
+        if (!value || typeof value !== "object" || Array.isArray(value) || done) throw new TypeError("Invalid Python build message");
+        const message = value;
+        if (message.op === "request") return request;
+        if (message.op === "error") {
+          if (typeof message.type !== "string" || typeof message.message !== "string") throw new TypeError("Invalid Python build failure");
+          failure ??= Object.assign(message.type === "InstallationError" ? new PythonInstallationError(message.message) : new Error(message.message), { name: message.type });
+          done = true;
+          return null;
+        }
+        if (message.op === "done") {
+          done = true;
+          return null;
+        }
+        if (message.op !== "text" || typeof message.text !== "string" || message.text.length > 8192) throw new TypeError("Invalid Python build metadata window");
+        const bytes = new TextEncoder().encode(message.text).length;
+        if (bytes > 16384 || bytes > maxBytes - size) throw new RangeError("Python build metadata limit exceeded");
+        size += bytes;
+        if (bytes) chunks.push(message.text);
+        return null;
+      } catch (error) {
+        failure ??= error;
+        throw error;
+      }
+    } });
+    try {
+      const result = await command.execute(invocation);
+      context.signal.throwIfAborted();
+      if (failure) throw failure;
+      if (result.exitCode) throw new Error(`Python build interpreter exited with status ${result.exitCode}`);
+      if (!done) throw new Error("Python build interpreter returned no result");
+      const value = JSON.parse(chunks.join(""));
+      if (request.hook === "read_source_origin" || request.hook === "read_download_filename") {
+        if (typeof value !== "string") throw new TypeError("Invalid Python download filename");
+      } else if (request.hook === "read_source_requirement" || request.hook === "read_editable_requirement") {
+        const result2 = value;
+        if (result2 !== null && (!result2 || typeof result2.name !== "string" || typeof result2.url !== "string" || typeof result2.active !== "boolean" || result2.marker !== null && typeof result2.marker !== "string" || !Array.isArray(result2.extras) || result2.extras.some((extra) => typeof extra !== "string"))) throw new TypeError("Invalid Python source requirement");
+      } else if (request.hook === "check_build_requirements") {
+        const result2 = value;
+        if (!result2 || !Array.isArray(result2.missing) || result2.missing.some((value2) => typeof value2 !== "string") || !Array.isArray(result2.conflicting) || result2.conflicting.some((pair) => !Array.isArray(pair) || pair.length !== 2 || pair.some((value2) => typeof value2 !== "string"))) throw new TypeError("Invalid Python build requirement status");
+      } else if (request.hook === "read_build_system") {
+        if (value !== null) {
+          if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid Python build system");
+          const details = value;
+          if (typeof details.backend !== "string" || !details.backend || ["requires", "check", "backendPath"].some((key) => !Array.isArray(details[key]) || details[key].some((item) => typeof item !== "string"))) throw new TypeError("Invalid Python build system");
+        }
+      } else if (request.hook === "build_wheel" || request.hook === "build_legacy_wheel") {
+        if (typeof value !== "string" || !value.endsWith(".whl") || value.includes("/") || value.includes("\\") || value.includes("\0")) throw new TypeError("Invalid Python build wheel filename");
+      } else if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new TypeError("Invalid Python build requirements");
+      return value;
+    } finally {
+      capabilities.delete(invocation.args);
+      legacy.delete(invocation.args);
+    }
+  };
+}
+var pythonBuildBackendProgram = /* @__PURE__ */ (() => String.raw`
+import importlib, json, os, sys, safe_host
+${pythonDownloadFilenameProgram}
+
+def send(op, **fields):
+ return safe_host.call('python_build', dict(op=op, **fields))
+
+
+${pythonSourceOriginProgram}
+
+def parse_build_requirement(value):
+ from urllib.parse import urlparse, urlunparse
+ from micropip._vendored.packaging.src.packaging.requirements import Requirement, InvalidRequirement
+ requirement = Requirement(value)
+ if requirement.url:
+  url = urlparse(requirement.url)
+  if (url.scheme == 'file' and urlunparse(url) != requirement.url) or (url.scheme != 'file' and not (url.scheme and url.netloc)): raise InvalidRequirement(value)
+ return requirement
+
+def check_build_requirements(request):
+ from importlib.metadata import distribution, PackageNotFoundError
+ from micropip._vendored.packaging.src.packaging.utils import canonicalize_name
+ from micropip._vendored.packaging.src.packaging.version import Version
+ installed = {canonicalize_name(name) for name in request['installed']}
+ conflicting, missing = set(), set()
+ for value in request['requirements']:
+  requirement = parse_build_requirement(value)
+  if canonicalize_name(requirement.name) not in installed:
+   missing.add(value)
+   continue
+  try: version = Version(distribution(requirement.name).version)
+  except PackageNotFoundError:
+   missing.add(value)
+   continue
+  if version not in requirement.specifier: conflicting.add((requirement.name + '==' + str(version), value))
+ return dict(conflicting=sorted(conflicting), missing=sorted(missing))
+
+def read_build_system(request):
+ import tomllib
+ from micropip._vendored.packaging.src.packaging.requirements import InvalidRequirement
+ class InstallationError(Exception): pass
+ source = request['source']
+ filename = os.path.join(source, 'pyproject.toml')
+ has_project, has_setup = os.path.isfile(filename), os.path.isfile(os.path.join(source, 'setup.py'))
+ if request.get('installation') == 'directory' and not has_project and not has_setup:
+  raise InstallationError("Directory {!r} is not installable. Neither 'setup.py' nor 'pyproject.toml' found.".format(request.get('name', source)))
+ system = None
+ if has_project:
+  limit = request['maxBytes']
+  with open(filename, 'rb') as stream: raw = stream.read() if limit is None else stream.read(limit + 1)
+  if limit is not None and len(raw) > limit: raise ValueError('Python build configuration limit exceeded')
+  system = tomllib.loads(raw.decode('utf-8')).get('build-system')
+ selected = request.get('usePep517')
+ if has_project and not has_setup:
+  if selected is False: raise InstallationError('Disabling PEP 517 processing is invalid: project does not have a setup.py')
+  selected = True
+ elif system and 'build-backend' in system:
+  if selected is False: raise InstallationError('Disabling PEP 517 processing is invalid: project specifies a build backend of {} in pyproject.toml'.format(system['build-backend']))
+  selected = True
+ elif selected is None: selected = has_project
+ if not selected:
+  if request.get('installation') and not os.path.exists(os.path.join(source, 'setup.py')):
+   raise InstallationError('File "setup.py" not found for legacy project {}.'.format(request.get('name', source)))
+  return None
+ defaults = ['setuptools>=40.8.0', 'wheel']
+ if system is None: system = {'requires': defaults, 'build-backend': 'setuptools.build_meta:__legacy__'}
+ def invalid(reason):
+  raise InstallationError('{} has a pyproject.toml file that does not comply with PEP 518: {}'.format(request.get('name', source), reason))
+ if 'requires' not in system: invalid("it has a 'build-system' table but not 'build-system.requires' which is mandatory in the table")
+ requirements = system['requires']
+ if not isinstance(requirements, list) or not all(isinstance(value, str) for value in requirements): invalid("'build-system.requires' is not a list of strings.")
+ for value in requirements:
+  try:
+   parse_build_requirement(value)
+  except InvalidRequirement: invalid("'build-system.requires' contains an invalid requirement: {!r}".format(value))
+ backend = system.get('build-backend')
+ return dict(requires=requirements, backend=backend if backend is not None else 'setuptools.build_meta:__legacy__', check=defaults if backend is None else [], backendPath=system.get('backend-path', []))
+
+def build_legacy_wheel(request):
+ source = os.path.realpath(request['source'])
+ directory = os.path.abspath(request['wheelDirectory'])
+ filename = os.path.join(source, 'setup.py')
+ os.chdir(source)
+ sys.path.insert(0, '')
+ sys.argv = [filename, 'bdist_wheel', '-d', directory]
+ namespace = dict(__name__='__main__', __file__=filename)
+ try:
+  exec("import io, os, sys, setuptools, tokenize\nsys.argv[0] = __file__\nf = getattr(tokenize, 'open', open)(__file__) if os.path.exists(__file__) else io.StringIO('from setuptools import setup; setup()')\ncode = f.read().replace('\\r\\n', '\\n')\nf.close()\nexec(compile(code, __file__, 'exec'))", namespace)
+ except SystemExit as error:
+  if error.code not in (None, 0): raise
+ first = None
+ with os.scandir(directory) as entries:
+  for entry in entries:
+   if first is None or entry.name < first: first = entry.name
+ if first is None: raise RuntimeError('Legacy wheel build created no files')
+ return first
+
+def read_source_requirement(request):
+ from micropip._vendored.packaging.src.packaging.requirements import InvalidRequirement
+ try: requirement = parse_build_requirement(request['source'])
+ except InvalidRequirement: return None
+ if not requirement.url: return None
+ marker = requirement.marker
+ return dict(name=requirement.name, extras=sorted({'_'.join(part for part in extra.lower().split('_') if part) for extra in requirement.extras}), url=requirement.url, marker=str(marker) if marker else None, active=not marker or marker.evaluate({'extra': ''}))
+
+def read_editable_requirement(request):
+ from pathlib import Path
+ from micropip._vendored.packaging.src.packaging.requirements import Requirement
+ class InstallationError(Exception): pass
+ source, extras = request['source'], None
+ if request.get('requirementLine'):
+  import shlex, optparse
+  class OptionParsingError(Exception): pass
+  class Parser(optparse.OptionParser):
+   def exit(self, status=0, message=None): raise OptionParsingError(message)
+  parser = Parser(add_help_option=False)
+  parser.add_option('-e', '--editable', action='append', dest='editables')
+  options, _ = parser.parse_args(shlex.split(source))
+  if not options.editables: raise InstallationError('Editable requirement line requires -e')
+  source = options.editables[0]
+ start = source.rfind('[')
+ if start > 0 and source.endswith(']') and start < len(source) - 2 and ']' not in source[start + 1:-1]:
+  source, extras = source[:start], source[start:]
+ if os.path.isdir(source):
+  if not any(os.path.exists(os.path.join(source, name)) for name in ('setup.py', 'setup.cfg')):
+   message = 'File "setup.py" or "setup.cfg" not found. Directory cannot be installed in editable mode: {}'.format(os.path.abspath(source))
+   if os.path.isfile(os.path.join(source, 'pyproject.toml')): message += '\n(A "pyproject.toml" file was found, but editable mode currently requires a setuptools-based build.)'
+   raise InstallationError(message)
+  source = Path(os.path.abspath(source)).as_uri()
+ if not source.lower().startswith('file:'): raise InstallationError('Editable source requires a local directory')
+ name = ''
+ for index, character in enumerate(source):
+  if character in '#&' and source.startswith('egg=', index + 1):
+   name = source[index + 5:].split('&', 1)[0]
+   break
+ return dict(name=name, url=source, extras=sorted(Requirement('placeholder' + extras.lower()).extras) if extras else [], marker=None, active=True)
+
+def main():
+ request = send('request')
+ if request['hook'] == 'get_requires_for_legacy_wheel': request.update(hook='get_requires_for_build_wheel', backend='setuptools.build_meta:__legacy__')
+ if request['hook'] == 'read_source_origin': return read_source_origin(request)
+ if request['hook'] == 'read_download_filename': return read_download_filename(request)
+ if request['hook'] == 'read_source_requirement': return read_source_requirement(request)
+ if request['hook'] == 'read_editable_requirement': return read_editable_requirement(request)
+ if request['hook'] == 'build_legacy_wheel':
+  if not request.get('editable'): return build_legacy_wheel(request)
+  request.update(hook='build_wheel', backend='setuptools.build_meta:__legacy__')
+ if request['hook'] == 'read_build_system': return read_build_system(request)
+ if request['hook'] == 'check_build_requirements': return check_build_requirements(request)
+ source = os.path.realpath(request['source'])
+ wheel_directory = os.path.abspath(request['wheelDirectory']) if request['hook'] == 'build_wheel' else None
+ metadata_directory = os.path.abspath(request['metadataDirectory']) if request.get('metadataDirectory') is not None else None
+ os.chdir(source)
+ paths = []
+ for entry in request.get('backendPath', []):
+  if os.path.isabs(entry): raise ValueError('paths must be relative')
+  path = os.path.realpath(os.path.join(source, entry))
+  if os.path.commonpath([source, path]) != source: raise ValueError('paths must be inside source tree')
+  paths.append(path)
+ sys.path[:0] = paths
+ module, _, attributes = request['backend'].partition(':')
+ backend = importlib.import_module(module)
+ if paths and not any(os.path.commonpath([os.path.realpath(backend.__file__), path]) == path for path in paths):
+  raise ValueError('Backend was not loaded from backend-path')
+ if attributes:
+  for name in attributes.split('.'): backend = getattr(backend, name)
+ settings = request.get('configSettings')
+ if request['hook'] == 'get_requires_for_build_wheel':
+  try: hook = backend.get_requires_for_build_wheel
+  except AttributeError: result = []
+  else: result = hook(settings)
+ else:
+  if request.get('editable'): result = backend.build_editable(wheel_directory, {'editable_mode': 'compat'}, metadata_directory)
+  else: result = backend.build_wheel(wheel_directory, settings, metadata_directory)
+ return result
+
+try:
+ result = main()
+ encoder = json.JSONEncoder(ensure_ascii=False, separators=(',', ':'))
+ for part in encoder.iterencode(result):
+  for offset in range(0, len(part), 4096): send('text', text=part[offset:offset + 4096])
+ send('done')
+except Exception as error:
+ send('error', type=type(error).__name__, message=str(error))
+`)();
+
+// packages/safe-bash-command-python/src/build-dependencies.ts
+function createPythonBuildDependencies(options) {
+  const isolated = { ...options };
+  for (const key of ["packages", "requirements", "packageProfile", "provisioning"]) Reflect.deleteProperty(isolated, key);
+  const hook = createPythonBuildBackend(isolated), command = createPythonExecutorCommands(isolated)[0];
+  return async (input, caller) => {
+    const context = { ...caller };
+    context.signal.throwIfAborted();
+    const request = structuredClone(input), { source, buildSystem, configSettings } = request;
+    if (typeof source !== "string" || !source || request.name !== void 0 && typeof request.name !== "string" || buildSystem !== null && (!buildSystem || typeof buildSystem.backend !== "string" || !buildSystem.backend || [buildSystem.requires, buildSystem.check, buildSystem.backendPath].some((values) => !Array.isArray(values) || values.some((value) => typeof value !== "string")))) throw new TypeError("Invalid Python build dependency request");
+    if (configSettings !== void 0 && (!configSettings || typeof configSettings !== "object" || Array.isArray(configSettings) || Object.values(configSettings).some((value) => typeof value !== "string" && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))))) throw new TypeError("Invalid Python build configuration");
+    if (context.maxBytes !== Infinity && (!Number.isSafeInteger(context.maxBytes) || context.maxBytes < 0)) throw new RangeError("Invalid Python build metadata limit");
+    const install = async (requirements2) => {
+      if (!requirements2.length) return;
+      const result = await command.execute({ ...context, command: "python", args: ["-m", "pip", "install", "--", ...requirements2], stdin: toByteSource6("") });
+      context.signal.throwIfAborted();
+      if (result.exitCode) throw new Error("Python build dependency installation exited with status " + result.exitCode);
+    };
+    const check = async (requirements2, against) => {
+      if (!requirements2.length) return [];
+      const receipt = await isolated.environment.prepare(context);
+      let installed;
+      try {
+        if (!receipt.records && receipt.restore?.length) throw new Error("Python build dependency checks require an installed metadata manifest");
+        installed = receipt.records?.map((record2) => record2[0]) ?? [];
+      } finally {
+        await isolated.environment.finish(receipt);
+      }
+      const status = await hook({ hook: "check_build_requirements", source, requirements: requirements2, installed }, context);
+      if (status.conflicting.length) throw Object.assign(new Error("Some build dependencies for " + (request.name ?? source) + " conflict with " + against + ": " + [...status.conflicting].sort(([a, b], [c, d]) => a < c ? -1 : a > c ? 1 : b < d ? -1 : b > d ? 1 : 0).map(([installed2, wanted]) => installed2 + " is incompatible with " + wanted).join(", ") + "."), { name: "InstallationError" });
+      return status.missing;
+    };
+    if (buildSystem) {
+      await install(buildSystem.requires);
+      const missing = await check(buildSystem.check, "PEP 517/518 supported requirements");
+      if (missing.length) await context.stderr.write(new TextEncoder().encode("Missing build requirements in pyproject.toml for " + (request.name ?? source) + ".\nThe project does not specify a build backend, and pip cannot fall back to setuptools without " + missing.map((value) => "'" + value + "'").join(" and ") + ".\n"));
+    }
+    const requirements = await hook(buildSystem ? { hook: "get_requires_for_build_wheel", source, backend: buildSystem.backend, backendPath: buildSystem.backendPath, ...configSettings === void 0 ? {} : { configSettings } } : { hook: "get_requires_for_legacy_wheel", source }, context);
+    await install(await check(requirements, "the backend dependencies"));
+  };
+}
+
+// packages/safe-bash-command-python/src/source-snapshot.ts
+import { compareIdentity } from "@poe-platform/safe-fs/core";
+import { FsError as FsError2 } from "../../safe-bash-contracts/index.js";
+import { resolvePath } from "../../safe-bash-contracts/path.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { admitCopySource, admitCopyDestination, copyCheckedSource } from "../../safe-bash-io-engine/commands/copy-source.js";
+var serial = 0;
+async function createPythonSourceSnapshot(source, directory, context) {
+  const { fs, signal } = context, settings = { signal };
+  signal.throwIfAborted();
+  if (!fs.iterateDirectory) throw new Error("Python source snapshots require lazy directory enumeration");
+  const origin = await fs.realpath(resolvePath(context.cwd, source), settings);
+  const parentPath = await fs.realpath(resolvePath(context.cwd, directory), settings);
+  const capabilities = await fs.capabilitiesFor?.(parentPath, settings) ?? fs.capabilities;
+  if (!fs.prepareDirectory || !fs.removeTreeConditional || !fs.confineExtraction || !capabilities.atomicTreeRemoval) throw new Error("Python source snapshots require confined writes, conditional directory creation and tree removal");
+  const original = await fs.stat(origin, settings), parent = await fs.stat(parentPath, settings);
+  if (original.type !== "directory" || parent.type !== "directory") throw new FsError2("ENOTDIR", { path: origin });
+  let path = "", owned;
+  for (let attempt = 0; attempt < 16; attempt++) {
+    path = resolvePath(parentPath, ".python-source-" + ++serial);
+    try {
+      owned = await fs.prepareDirectory(path, { parent, expected: null, mode: 448, signal });
+      break;
+    } catch (error) {
+      signal.throwIfAborted();
+      if (!(error instanceof FsError2) || !["EEXIST", "EAGAIN"].includes(error.code)) throw error;
+    }
+  }
+  if (!owned) throw new Error("Python source snapshot names exhausted");
+  let disposing;
+  const snapshot = { path, dispose() {
+    return disposing ??= (async () => {
+      const current = await fs.lstat(path);
+      if (compareIdentity(owned, current) !== "same") throw new Error("Python source snapshot identity changed");
+      await fs.removeTreeConditional(path, { parent, expected: current });
+    })();
+  } };
+  try {
+    const destination = await fs.confineExtraction([path], settings);
+    if (compareIdentity(owned, await fs.lstat(path, settings)) !== "same") throw new Error("Python source snapshot identity changed");
+    let activeCleanup;
+    context.registerCleanup?.(() => activeCleanup?.());
+    const copyContext = { ...context, registerCleanup(cleanup) {
+      activeCleanup = cleanup;
+    }, fs: new Proxy(destination, { get(target, key) {
+      const owner = key === "openReadFile" ? fs : target, value = Reflect.get(owner, key);
+      return typeof value === "function" ? value.bind(owner) : value;
+    } }) };
+    const metadata = async (from, to, expected) => {
+      const current = await fs.lstat(from, settings);
+      if (compareIdentity(expected, current) !== "same") throw new Error("Python source identity changed while copying");
+      if (destination.chmod) await destination.chmod(to, current.mode & 4095, settings);
+      if (destination.utimes) await destination.utimes(to, current.atimeMs, current.mtimeMs, settings);
+    };
+    const copy = async (from, to, expected) => {
+      signal.throwIfAborted();
+      if (expected.type === "symlink") {
+        if (!destination.symlink || !fs.readlink) throw new Error("Python source snapshots require symlink support");
+        const target = await fs.readlink(from, settings);
+        if (compareIdentity(expected, await fs.lstat(from, settings)) !== "same") throw new Error("Python source identity changed while copying");
+        await destination.symlink(target, to, settings);
+        return;
+      }
+      if (expected.type === "file") {
+        await admitCopySource(context, from);
+        await admitCopyDestination(copyContext, to, true);
+        try {
+          await copyCheckedSource(copyContext, from, to, expected, true);
+        } finally {
+          activeCleanup = void 0;
+        }
+      } else if (expected.type === "directory") {
+        if (to !== path) await destination.mkdir(to, { mode: 448, signal });
+        for await (const entry of fs.iterateDirectory(from, settings)) {
+          await yieldTurn(signal);
+          if (!entry.name || entry.name === "." || entry.name === ".." || entry.name.includes("/") || entry.name.includes("\0")) throw new Error("Invalid Python source directory entry");
+          const child = resolvePath(from, entry.name);
+          if (child === path || from === origin && [".tox", ".nox"].includes(entry.name)) continue;
+          await copy(child, resolvePath(to, entry.name), await fs.lstat(child, settings));
+        }
+      } else throw new Error("Unsupported Python source entry: " + from);
+      await metadata(from, to, expected);
+    };
+    await copy(origin, path, original);
+    signal.throwIfAborted();
+    return snapshot;
+  } catch (error) {
+    try {
+      await snapshot.dispose();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "Python source snapshot cleanup failed");
+    }
+    throw error;
+  }
+}
+
+// packages/safe-bash-command-python/src/llm-manifest.ts
+var pythonLlmManifest = {
+  "llm": "0.27.1",
+  "pyodide": "314.0.6",
+  "distributions": [
+    {
+      "name": "llm",
+      "version": "0.27.1",
+      "url": "https://files.pythonhosted.org/packages/6c/67/47585c961ff2299749e519891681025c2685b75801e3f784ee232853c5b0/llm-0.27.1-py3-none-any.whl",
+      "sha256": "a884a575062fbea8c2b129708a80e146fa9682bd1c444d8d7b028196107de727",
+      "bytes": 82500,
+      "expandedBytes": 348753,
+      "nativeModules": [],
+      "file": "llm-0.27.1-py3-none-any.whl"
+    },
+    {
+      "name": "pydantic",
+      "version": "2.12.5",
+      "url": "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl",
+      "sha256": "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d",
+      "bytes": 463580,
+      "expandedBytes": 1851456,
+      "nativeModules": [],
+      "file": "pydantic-2.12.5-py3-none-any.whl"
+    },
+    {
+      "name": "pydantic-core",
+      "version": "2.41.5",
+      "url": "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+      "sha256": "9802bd7a5e6679ec4c13be778f19f021e6147459c89cc916b913f7970f86dddb",
+      "bytes": 1310163,
+      "expandedBytes": 4592549,
+      "nativeModules": [
+        {
+          "path": "pydantic_core/_pydantic_core.cpython-314-wasm32-emscripten.so",
+          "bytes": 4275289,
+          "sha256": "94477475eb48c67b6b25fd47a7955c1d01479f7971522aff90215bb517be8246"
+        }
+      ],
+      "file": "pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl"
+    },
+    {
+      "name": "httpx",
+      "version": "0.28.1",
+      "url": "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl",
+      "sha256": "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad",
+      "bytes": 73517,
+      "expandedBytes": 295303,
+      "nativeModules": [],
+      "file": "httpx-0.28.1-py3-none-any.whl"
+    },
+    {
+      "name": "click",
+      "version": "8.1.8",
+      "url": "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl",
+      "sha256": "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2",
+      "bytes": 98188,
+      "expandedBytes": 355272,
+      "nativeModules": [],
+      "file": "click-8.1.8-py3-none-any.whl"
+    },
+    {
+      "name": "sqlite-utils",
+      "version": "3.38",
+      "url": "https://files.pythonhosted.org/packages/4d/eb/f8e8e827805f810838efff3311cccd2601238c5fa3fc35c1f878709e161b/sqlite_utils-3.38-py3-none-any.whl",
+      "sha256": "8a27441015c3b2ef475f555861f7a2592f73bc60d247af9803a11b65fc605bf9",
+      "bytes": 68183,
+      "expandedBytes": 278821,
+      "nativeModules": [],
+      "file": "sqlite_utils-3.38-py3-none-any.whl"
+    },
+    {
+      "name": "sqlite-migrate",
+      "version": "0.1b0",
+      "url": "https://files.pythonhosted.org/packages/df/92/994545b912e6d6feb40323047f02ca039321e690aa2c27afcd5c4105e37b/sqlite_migrate-0.1b0-py3-none-any.whl",
+      "sha256": "a4125e35e1de3dc56b6b6ec60e9833ce0ce20192b929ddcb2d4246c5098859c6",
+      "bytes": 9986,
+      "expandedBytes": 25349,
+      "nativeModules": [],
+      "file": "sqlite_migrate-0.1b0-py3-none-any.whl"
+    },
+    {
+      "name": "python-ulid",
+      "version": "3.0.0",
+      "url": "https://files.pythonhosted.org/packages/63/4e/cc2ba2c0df2589f35a4db8473b8c2ba9bbfc4acdec4a94f1c78934d2350f/python_ulid-3.0.0-py3-none-any.whl",
+      "sha256": "e4c4942ff50dbd79167ad01ac725ec58f924b4018025ce22c858bfcff99a5e31",
+      "bytes": 11194,
+      "expandedBytes": 30439,
+      "nativeModules": [],
+      "file": "python_ulid-3.0.0-py3-none-any.whl"
+    },
+    {
+      "name": "condense-json",
+      "version": "0.1.3",
+      "url": "https://files.pythonhosted.org/packages/28/5f/63badd4924358fad1efa6defd66eef700ccf8783c0e44098987f867e8b1f/condense_json-0.1.3-py3-none-any.whl",
+      "sha256": "e0a3d42db4f44a89e74af8737d8e517e97420be0f7e5437087f4decfd38c3366",
+      "bytes": 8432,
+      "expandedBytes": 21056,
+      "nativeModules": [],
+      "file": "condense_json-0.1.3-py3-none-any.whl"
+    },
+    {
+      "name": "puremagic",
+      "version": "1.30",
+      "url": "https://files.pythonhosted.org/packages/91/ed/1e347d85d05b37a8b9a039ca832e5747e1e5248d0bd66042783ef48b4a37/puremagic-1.30-py3-none-any.whl",
+      "sha256": "5eeeb2dd86f335b9cfe8e205346612197af3500c6872dffebf26929f56e9d3c1",
+      "bytes": 43304,
+      "expandedBytes": 185153,
+      "nativeModules": [],
+      "file": "puremagic-1.30-py3-none-any.whl"
+    },
+    {
+      "name": "anyio",
+      "version": "4.15.1",
+      "url": "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl",
+      "sha256": "6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101",
+      "bytes": 132079,
+      "expandedBytes": 539217,
+      "nativeModules": [],
+      "file": "anyio-4.15.1-py3-none-any.whl"
+    },
+    {
+      "name": "httpcore",
+      "version": "1.0.9",
+      "url": "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl",
+      "sha256": "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55",
+      "bytes": 78784,
+      "expandedBytes": 288016,
+      "nativeModules": [],
+      "file": "httpcore-1.0.9-py3-none-any.whl"
+    },
+    {
+      "name": "typing-extensions",
+      "version": "4.16.0",
+      "url": "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl",
+      "sha256": "481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8",
+      "bytes": 45571,
+      "expandedBytes": 182767,
+      "nativeModules": [],
+      "file": "typing_extensions-4.16.0-py3-none-any.whl"
+    },
+    {
+      "name": "annotated-types",
+      "version": "0.8.0",
+      "url": "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl",
+      "sha256": "f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0",
+      "bytes": 13427,
+      "expandedBytes": 36347,
+      "nativeModules": [],
+      "file": "annotated_types-0.8.0-py3-none-any.whl"
+    },
+    {
+      "name": "click-default-group",
+      "version": "1.2.4",
+      "url": "https://files.pythonhosted.org/packages/2c/1a/aff8bb287a4b1400f69e09a53bd65de96aa5cee5691925b38731c67fc695/click_default_group-1.2.4-py2.py3-none-any.whl",
+      "sha256": "9b60486923720e7fc61731bdb32b617039aba820e22e1c88766b1125592eaa5f",
+      "bytes": 4123,
+      "expandedBytes": 8671,
+      "nativeModules": [],
+      "file": "click_default_group-1.2.4-py2.py3-none-any.whl"
+    },
+    {
+      "name": "h11",
+      "version": "0.16.0",
+      "url": "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl",
+      "sha256": "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86",
+      "bytes": 37515,
+      "expandedBytes": 103935,
+      "nativeModules": [],
+      "file": "h11-0.16.0-py3-none-any.whl"
+    },
+    {
+      "name": "idna",
+      "version": "3.20",
+      "url": "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl",
+      "sha256": "ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c",
+      "bytes": 69583,
+      "expandedBytes": 342091,
+      "nativeModules": [],
+      "file": "idna-3.20-py3-none-any.whl"
+    },
+    {
+      "name": "typing-inspection",
+      "version": "0.4.4",
+      "url": "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl",
+      "sha256": "65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147",
+      "bytes": 14750,
+      "expandedBytes": 54538,
+      "nativeModules": [],
+      "file": "typing_inspection-0.4.4-py3-none-any.whl"
+    },
+    {
+      "name": "certifi",
+      "version": "2026.7.22",
+      "url": "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl",
+      "sha256": "62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775",
+      "bytes": 136983,
+      "expandedBytes": 248921,
+      "nativeModules": [],
+      "file": "certifi-2026.7.22-py3-none-any.whl"
+    },
+    {
+      "name": "pluggy",
+      "version": "1.6.0",
+      "url": "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl",
+      "sha256": "e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746",
+      "bytes": 20538,
+      "expandedBytes": 65823,
+      "nativeModules": [],
+      "file": "pluggy-1.6.0-py3-none-any.whl"
+    },
+    {
+      "name": "python-dateutil",
+      "version": "2.9.0.post0",
+      "url": "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl",
+      "sha256": "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427",
+      "bytes": 229892,
+      "expandedBytes": 441579,
+      "nativeModules": [],
+      "file": "python_dateutil-2.9.0.post0-py2.py3-none-any.whl"
+    },
+    {
+      "name": "six",
+      "version": "1.17.0",
+      "url": "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl",
+      "sha256": "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274",
+      "bytes": 11050,
+      "expandedBytes": 37975,
+      "nativeModules": [],
+      "file": "six-1.17.0-py2.py3-none-any.whl"
+    },
+    {
+      "name": "pyyaml",
+      "version": "6.0.3",
+      "url": "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/pyyaml-6.0.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+      "sha256": "b1447216501f0d3aef290558fe33691dd51b0839e70f9a970defb12b36d82df8",
+      "bytes": 111318,
+      "expandedBytes": 439274,
+      "nativeModules": [
+        {
+          "path": "yaml/_yaml.cpython-314-wasm32-emscripten.so",
+          "bytes": 214986,
+          "sha256": "a3b18ccfd3c043f10f4ae4044bea14079f14a30707bf5c6ddf1f6dc61abaffc1"
+        }
+      ],
+      "file": "pyyaml-6.0.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl"
+    },
+    {
+      "name": "sniffio",
+      "version": "1.3.1",
+      "url": "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl",
+      "sha256": "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2",
+      "bytes": 10235,
+      "expandedBytes": 22921,
+      "nativeModules": [],
+      "file": "sniffio-1.3.1-py3-none-any.whl"
+    },
+    {
+      "name": "sqlite-fts4",
+      "version": "1.0.3",
+      "url": "https://files.pythonhosted.org/packages/51/29/0096e8b1811aaa78cfb296996f621f41120c21c2f5cd448ae1d54979d9fc/sqlite_fts4-1.0.3-py3-none-any.whl",
+      "sha256": "0359edd8dea6fd73c848989e1e2b1f31a50fe5f9d7272299ff0e8dbaa62d035f",
+      "bytes": 9972,
+      "expandedBytes": 28735,
+      "nativeModules": [],
+      "file": "sqlite_fts4-1.0.3-py3-none-any.whl"
+    },
+    {
+      "name": "tabulate",
+      "version": "0.10.0",
+      "url": "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl",
+      "sha256": "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3",
+      "bytes": 39814,
+      "expandedBytes": 150857,
+      "nativeModules": [],
+      "file": "tabulate-0.10.0-py3-none-any.whl"
+    }
+  ]
+};
+
+// packages/safe-bash-command-python/src/llm-packages.ts
+var pythonLlmPackages = pythonLlmManifest;
+function installPythonLlmPackages(runtime, assets) {
+  if (runtime.version !== pythonLlmManifest.pyodide) throw new Error("LLM packages require the pinned Python runtime");
+  if (assets.length !== pythonLlmManifest.distributions.length) throw new Error("Incomplete Python LLM package assets");
+  const root = "/lib/python3.14/site-packages";
+  const wheelRoot = root + "/llm-wheels";
+  runtime.FS.mkdirTree(wheelRoot);
+  const paths = [];
+  for (const distribution of pythonLlmManifest.distributions) {
+    const asset = assets.find((asset2) => asset2.file === distribution.file);
+    if (!asset || asset.bytes.byteLength !== distribution.bytes) throw new Error("Invalid Python LLM package asset: " + distribution.file);
+    if (distribution.nativeModules.length || ["llm", "puremagic"].includes(distribution.name)) {
+      runtime.unpackArchive(asset.bytes, "zip", { extractDir: root });
+    } else {
+      const path = wheelRoot + "/" + distribution.file;
+      runtime.FS.writeFile(path, asset.bytes);
+      paths.push(path);
+    }
+  }
+  runtime.FS.writeFile(root + "/readline.py", new TextEncoder().encode(
+    '"""Readline key bindings for the non-terminal Worker input stream."""\ndef parse_and_bind(binding):\n import sys\n if sys.stdin.isatty():\n  raise OSError("Terminal line editing is unavailable in this runtime")\n'
+  ));
+  runtime.FS.writeFile(root + "/llm_safe_host.py", new TextEncoder().encode(pythonLlmProvider));
+  const metadata = root + "/llm_safe_host-0.1.dist-info";
+  runtime.FS.mkdirTree(metadata);
+  runtime.FS.writeFile(metadata + "/METADATA", new TextEncoder().encode("Metadata-Version: 2.1\nName: llm-safe-host\nVersion: 0.1\n"));
+  runtime.FS.writeFile(metadata + "/entry_points.txt", new TextEncoder().encode("[llm]\nsafe_host = llm_safe_host\n"));
+  runtime.globals.set("_safe_llm_wheel_paths", JSON.stringify(paths));
+  try {
+    runtime.runPython(String.raw`
+import json, sys
+sys.path.extend(json.loads(_safe_llm_wheel_paths))
+def _install_safe_llm_import():
+    if any(getattr(finder, "_safe_llm_provider", False) for finder in sys.meta_path):
+        return
+    def configure_plugins(module):
+        module.DEFAULT_PLUGINS = ("llm.default_plugins.default_tools",)
+        module.LLM_LOAD_PLUGINS = "llm-safe-host"
+
+    def configure_provider(module):
+        configure_plugins(module.plugins)
+        module.plugins.load_plugins()
+        from llm_safe_host import restrict_providers
+        restrict_providers()
+
+    class HostLlmFinder:
+        _safe_llm_provider = True
+        def find_spec(self, fullname, path=None, target=None):
+            if fullname not in ("llm", "llm.plugins"):
+                return None
+            for finder in tuple(sys.meta_path):
+                if finder is self:
+                    continue
+                spec = finder.find_spec(fullname, path, target)
+                if spec is None:
+                    continue
+                original = spec.loader
+                class HostLlmLoader:
+                    def create_module(self, spec):
+                        return original.create_module(spec)
+                    def exec_module(self, module):
+                        original.exec_module(module)
+                        if fullname == "llm.plugins":
+                            configure_plugins(module)
+                        else:
+                            configure_provider(module)
+                    def __getattr__(self, name):
+                        return getattr(original, name)
+                spec.loader = HostLlmLoader()
+                return spec
+            return None
+
+    sys.meta_path.insert(0, HostLlmFinder())
+    if "llm" in sys.modules:
+        configure_provider(sys.modules["llm"])
+_install_safe_llm_import()
+del _install_safe_llm_import
+`);
+  } finally {
+    runtime.globals.delete("_safe_llm_wheel_paths");
+  }
+}
+
+// packages/safe-bash-command-python/src/build-wheel.ts
+import { FsError as FsError3 } from "../../safe-bash-contracts/index.js";
+import { resolvePath as resolvePath2, basename } from "../../safe-bash-contracts/path.js";
+async function publishPythonBuildWheel(source, directory, maxBytes, context) {
+  const { fs, signal } = context, settings = { signal };
+  signal.throwIfAborted();
+  if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("Invalid Python wheel size limit");
+  const filename = basename(source);
+  if (!filename.endsWith(".whl") || filename.includes("\\") || filename.includes("\0")) throw new TypeError("Invalid Python build wheel filename");
+  const root = await fs.realpath(resolvePath2(context.cwd, directory), settings);
+  const caps = await fs.capabilitiesFor?.(root, settings) ?? fs.capabilities;
+  if (!fs.confineExtraction || !fs.prepareDirectory || !caps.retainedStagingWrite || !caps.retainedStagingCleanup || !caps.retainedRead || !caps.atomicFileStaging) throw new Error("Python wheel publication requires confined retained atomic staging");
+  const artifact = await openPythonPackageFile(context, resolvePath2(context.cwd, source), maxBytes);
+  if (!artifact) throw new Error("Python wheel publication requires retained source reads");
+  let reading;
+  try {
+    const confined = await fs.confineExtraction([root], settings);
+    const destination = new Proxy(confined, { get(target, key) {
+      const owner = key === "openReadFile" ? fs : target, value = Reflect.get(owner, key);
+      return typeof value === "function" ? value.bind(owner) : value;
+    } });
+    const parent = await destination.stat(root, settings), path = resolvePath2(root, artifact.key);
+    try {
+      await destination.prepareDirectory(path, { parent, expected: null, mode: 448, signal });
+    } catch (error) {
+      if (!(error instanceof FsError3) || !["EEXIST", "EAGAIN"].includes(error.code)) throw error;
+    }
+    if ((await destination.lstat(path, settings)).type !== "directory") throw new Error("Python wheel publication directory changed");
+    const output = resolvePath2(path, filename);
+    const body = async function* () {
+      for (let offset = 0; offset < artifact.size; ) {
+        const bytes = await (reading = artifact.read(offset, 65536));
+        offset += bytes.length;
+        yield bytes;
+      }
+    };
+    const published = await stagePythonPackage({ ...context, fs: destination }, path, body(), maxBytes, () => {
+    }, (key) => {
+      if (key !== artifact.key) throw new Error("Built Python wheel integrity mismatch");
+    }, () => output);
+    if (!published) throw new Error("Python wheel publication requires retained atomic staging");
+    try {
+      return { url: "file://" + output.split("/").map(encodeURIComponent).join("/"), digest: published.key, size: published.size };
+    } finally {
+      await published.close();
+    }
+  } finally {
+    try {
+      await reading?.catch(() => {
+      });
+    } finally {
+      await artifact.close();
+    }
+  }
+}
+
+// packages/safe-bash-command-python/src/source-origin.ts
+import { FsError as FsError4 } from "../../safe-bash-contracts/index.js";
+import { resolvePath as resolvePath3, dirname, basename as basename2 } from "../../safe-bash-contracts/path.js";
+function withPythonSourceOrigins(environment, directory, maxBytes) {
+  const origins = /* @__PURE__ */ new Map(), encoder2 = new TextEncoder();
+  return {
+    ...environment,
+    async dispatch(operation, args, context) {
+      const result = await environment.dispatch(operation, args, context), session = String(args[0]);
+      if (operation === "package-open") {
+        origins.delete(session);
+        const url = new URL(String(args[1]));
+        if (url.protocol === "file:" && url.hash.startsWith("#python-source=")) {
+          const parent = dirname(decodeURIComponent(url.pathname));
+          if (basename2(parent) !== result.key) return result;
+          let root;
+          try {
+            root = await context.fs.realpath(resolvePath3(context.cwd, directory), { signal: context.signal });
+          } catch (error) {
+            if (error instanceof FsError4 && error.code === "ENOENT") return result;
+            throw error;
+          }
+          if (dirname(parent) !== root) return result;
+          const origin = decodeURIComponent(url.hash.slice("#python-source=".length));
+          if (encoder2.encode(origin).length > maxBytes) throw new RangeError("Python source origin exceeds maxMetadataBytes");
+          origins.set(session, { key: result.key, origin });
+        }
+      } else if (operation === "package-retain") {
+        const origin = origins.get(session);
+        origins.delete(session);
+        if (origin !== void 0) return { ...result, metadata: origin.origin === "null" ? {} : { "direct_url.json": origin.origin } };
+      } else if (operation === "package-close" && origins.get(session)?.key === String(args[1])) origins.delete(session);
+      return result;
+    },
+    finish(start) {
+      origins.delete(start.session);
+      return environment.finish(start);
+    },
+    async dispose() {
+      try {
+        await environment.dispose();
+      } finally {
+        origins.clear();
+      }
+    }
+  };
+}
+
+// packages/safe-bash-command-python/src/source-environment.ts
+import { compareIdentity as compareIdentity2 } from "@poe-platform/safe-fs/core";
+import { FsError as FsError5, toByteSource as toByteSource7 } from "../../safe-bash-contracts/index.js";
+import { resolvePath as resolvePath5 } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-python/src/source-download.ts
+import { dirname as dirname2, resolvePath as resolvePath4 } from "../../safe-bash-contracts/path.js";
+import { sha224, sha256, sha384, sha512 } from "@noble/hashes/sha2.js";
+import { sha1, md5 } from "@noble/hashes/legacy.js";
+async function* verifiedBytes(source, expected, maxBytes, signal) {
+  const checksum = expected ? { sha1, sha224, sha384, sha256, sha512, md5 }[expected[0]].create() : void 0;
+  let count = 0;
+  try {
+    for await (const bytes of source) {
+      signal.throwIfAborted();
+      if (!(bytes instanceof Uint8Array)) throw new TypeError("Python package body must yield bytes");
+      if (bytes.length > maxBytes - count) throw new Error("Package download exceeds maxDownloadBytes");
+      count += bytes.length;
+      for (let offset = 0; offset < bytes.length; offset += 65536) {
+        signal.throwIfAborted();
+        const chunk = bytes.subarray(offset, offset + 65536);
+        checksum?.update(chunk);
+        yield chunk;
+      }
+    }
+    if (checksum && Array.from(checksum.digest(), (byte) => byte.toString(16).padStart(2, "0")).join("") !== expected[1]) throw new Error("Python source archive integrity mismatch: " + expected[0]);
+  } finally {
+    checksum?.destroy();
+  }
+}
+async function downloadPythonSourceArchive(url, path, options, context) {
+  const { fs, signal } = context, cacheDirectory = resolvePath4(context.cwd, options.cacheDirectory ?? dirname2(path));
+  const caps = await fs.capabilitiesFor?.(cacheDirectory, { signal }) ?? fs.capabilities;
+  if (!caps.retainedStagingWrite || !caps.retainedStagingCleanup || !caps.retainedRead || !caps.atomicFileStaging || !fs.createStagedFile || !fs.openReadFile || !fs.publishStagedFile || !fs.confineExtraction) throw new Error("Remote Python sources require retained caller storage");
+  const output = await fs.confineExtraction([dirname2(path)], { signal });
+  if (!output.writeStream) throw new Error("Remote Python sources require streaming writes");
+  const expected = pythonPackageUrlHash(url.href), supplied = options.transport, maxBytes = options.maxDownloadBytes ?? Infinity;
+  const transport = supplied && expected ? Object.assign(async (request) => {
+    const response = await supplied(request);
+    return response.status >= 200 && response.status < 300 ? {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      ...response.httpVersion === void 0 ? {} : { httpVersion: response.httpVersion },
+      ...response.contentDecoded === void 0 ? {} : { contentDecoded: response.contentDecoded },
+      body: verifiedBytes(response.body, expected, maxBytes, signal),
+      dispose: response.dispose.bind(response)
+    } : response;
+  }, supplied.supportsPrivateNetworkDeny ? { supportsPrivateNetworkDeny: true } : {}) : supplied;
+  const environment = createPythonBuildEnvironment({ ...options, ...transport ? { transport } : {}, cacheDirectory });
+  try {
+    const start = await environment.prepare({ ...context, requirements: [], requirementFiles: [] });
+    try {
+      const address = new URL(url);
+      address.hash = "";
+      const receipt = await environment.dispatch("package-open", [start.session, address.href], context);
+      let consumed = false;
+      const bytes = verifiedBytes((async function* () {
+        for (let offset = 0; offset < receipt.size; ) {
+          const chunk = await environment.dispatch("package-read", [start.session, receipt.key, offset, Math.min(65536, receipt.size - offset)], context);
+          if (!chunk.length) throw new Error("Remote Python source ended early");
+          offset += chunk.length;
+          yield Uint8Array.from(chunk);
+        }
+        consumed = true;
+      })(), expected, maxBytes, signal);
+      try {
+        await output.writeStream(path, bytes, { flag: "wx", mode: 384, signal });
+        if (!consumed) throw new Error("Remote Python source write ended early");
+      } finally {
+        await bytes.return(void 0);
+      }
+      return { url: receipt.url, headers: receipt.headers };
+    } finally {
+      await environment.finish(start);
+    }
+  } finally {
+    await environment.dispose();
+  }
+}
+async function snapshotPythonSourceArchive(source, path, url, maxBytes, context) {
+  const { fs, signal } = context;
+  if (!fs.writeStream) throw new Error("Local Python sources require streaming writes");
+  const file = await openPythonPackageFile(context, source, maxBytes);
+  if (!file) throw new Error("Local Python sources require retained reads");
+  const bytes = verifiedBytes((async function* () {
+    for (let offset = 0; offset < file.size; ) {
+      const chunk = await file.read(offset, Math.min(65536, file.size - offset));
+      offset += chunk.length;
+      yield chunk;
+    }
+  })(), pythonPackageUrlHash(url), maxBytes, signal);
+  let complete = false;
+  try {
+    await fs.writeStream(path, (async function* () {
+      yield* bytes;
+      complete = true;
+    })(), { flag: "wx", mode: 384, signal });
+    if (!complete) throw new Error("Local Python source write ended early");
+  } finally {
+    try {
+      await bytes.return(void 0);
+    } finally {
+      await file.close();
+    }
+  }
+}
+
+// packages/safe-bash-command-python/src/source-environment.ts
+var serial2 = 0;
+var archiveSuffix = (path) => [".zip", ".tar", ".tar.gz", ".tgz", ".tar.bz2", ".tbz", ".tar.xz", ".txz"].find((suffix) => path.toLowerCase().endsWith(suffix));
+var wheelLink = (url) => {
+  let path = url.pathname;
+  while (path.endsWith("/")) path = path.slice(0, -1);
+  const parts = (path.slice(path.lastIndexOf("/") + 1) || url.host).split("%");
+  let name = parts.shift();
+  for (const part of parts) {
+    const hex = part.slice(0, 2).toLowerCase();
+    name += hex.length === 2 && [...hex].every((value) => "0123456789abcdef".includes(value)) ? String.fromCharCode(Number.parseInt(hex, 16)) + part.slice(2) : "%" + part;
+  }
+  name = name.slice(name.lastIndexOf("/") + 1);
+  return name.endsWith(".whl") && name.slice(0, -4).split(".").some(Boolean);
+};
+function createPythonSourcePackageEnvironment(options, build) {
+  if (options.prepareRequirements || !build.python.createExecutor || !build.directory) throw new TypeError("Source packages require an asynchronous build executor and caller storage");
+  const prepareRequirement = async (requirement, context, editable = false) => {
+    const { fs, signal } = context, settings = { signal }, requirementLine = requirement.startsWith("-");
+    editable ||= requirementLine;
+    let source = requirement, named = null;
+    let remote;
+    const at = requirement.indexOf("@");
+    let namedSource = false;
+    if (at >= 0 && !requirement.startsWith("file:")) {
+      const tail = requirement.slice(at + 1).trimStart();
+      let end = 0;
+      while (end < tail.length && ![" ", "	", "\r", "\n"].includes(tail[end])) end++;
+      try {
+        const url = new URL(tail.slice(0, end));
+        namedSource = url.protocol === "file:" || ["http:", "https:"].includes(url.protocol) && !wheelLink(url);
+      } catch {
+      }
+    }
+    const editableExtras = editable && requirement.endsWith("]") && requirement.lastIndexOf("[") > 0;
+    if (namedSource || editableExtras || requirementLine) {
+      if (!context.stdout || !context.stderr || !context.env) throw new TypeError("Source requirement parsing requires command output and environment context");
+      const environment2 = createPythonBuildEnvironment(options);
+      const parsing = { ...context, env: context.env, stdout: context.stdout, stderr: context.stderr, maxBytes: options.maxMetadataBytes ?? Infinity };
+      Reflect.deleteProperty(parsing, "editable");
+      try {
+        named = await createPythonBuildBackend({ ...build.python, environment: environment2 })({ hook: editableExtras || requirementLine ? "read_editable_requirement" : "read_source_requirement", source: requirement, ...requirementLine ? { requirementLine } : {} }, parsing);
+      } finally {
+        await environment2.dispose();
+      }
+      if (named) {
+        if (!named.active) return requirement;
+        source = named.url;
+      }
+    }
+    const originalLink = source.slice(0, 5).toLowerCase() === "file:" || source.startsWith("https://") || source.startsWith("http://") ? source : void 0;
+    let subdirectory;
+    if (source.startsWith("file:") || source.startsWith("https://") || source.startsWith("http://")) {
+      for (let index = 0; index < source.length; index++) if ((source[index] === "#" || source[index] === "&") && source.startsWith("subdirectory=", index + 1)) {
+        const start = index + 1 + "subdirectory=".length, end = source.indexOf("&", start);
+        subdirectory = source.slice(start, end < 0 ? void 0 : end);
+        break;
+      }
+    }
+    if (source.slice(0, 5).toLowerCase() === "file:") {
+      const url = new URL(source);
+      if (url.host && url.host !== "localhost") {
+        if (editable) throw new Error("Editable source requires a local directory");
+        return requirement;
+      }
+      source = decodeURIComponent(url.pathname);
+    } else if (source.startsWith("https://") || source.startsWith("http://")) remote = new URL(source);
+    else if (source.includes("://")) {
+      if (editable) throw new Error("Editable source requires a local directory");
+      return requirement;
+    }
+    if (editable && remote) throw new Error("Editable source requires a local directory");
+    const suffix = archiveSuffix(remote?.pathname ?? source);
+    let archived = !!remote && !wheelLink(remote);
+    if (remote) {
+      if (!archived) return requirement;
+    } else {
+      source = resolvePath5(context.cwd, source);
+      try {
+        const stat = await fs.stat(source, settings);
+        archived = stat.type === "file" && !!suffix;
+        if (editable && stat.type !== "directory") throw new Error("Editable source requires a local directory");
+        if (stat.type !== "directory" && !archived) return requirement;
+      } catch (error) {
+        if (error instanceof FsError5 && error.code === "ENOENT") {
+          if (editable) throw new Error("Editable source requires an existing local directory");
+          return requirement;
+        }
+        throw error;
+      }
+    }
+    const originSource = originalLink ?? source;
+    if (!context.stdout || !context.stderr || !context.env) throw new TypeError("Source package preparation requires command output and environment context");
+    if (!fs.prepareDirectory || !fs.removeTreeConditional || !fs.confineExtraction) throw new Error("Source packages require conditional caller storage");
+    const root = await fs.realpath(resolvePath5(context.cwd, build.directory), settings), parent = await fs.stat(root, settings);
+    const caps = await fs.capabilitiesFor?.(root, settings) ?? fs.capabilities;
+    if (!caps.atomicTreeRemoval) throw new Error("Source packages require conditional tree cleanup");
+    let path = "", owned;
+    for (let attempt = 0; attempt < 16; attempt++) {
+      path = resolvePath5(root, ".python-build-" + ++serial2);
+      try {
+        owned = await fs.prepareDirectory(path, { parent, expected: null, mode: 448, signal });
+        break;
+      } catch (error) {
+        if (!(error instanceof FsError5) || !["EEXIST", "EAGAIN"].includes(error.code)) throw error;
+        signal.throwIfAborted();
+      }
+    }
+    if (!owned) throw new Error("Python build directory names exhausted");
+    const environment = createPythonBuildEnvironment(options);
+    let cleaning;
+    const remove = async () => {
+      const current = await fs.lstat(path);
+      if (compareIdentity2(owned, current) !== "same") throw new Error("Python build directory identity changed");
+      await fs.removeTreeConditional(path, { parent, expected: current });
+    };
+    const cleanup = () => cleaning ??= (async () => {
+      try {
+        await environment.dispose();
+      } finally {
+        await remove();
+      }
+    })();
+    try {
+      const confined = await fs.confineExtraction([path], settings);
+      if (compareIdentity2(owned, await fs.lstat(path, settings)) !== "same") throw new Error("Python build directory identity changed");
+      const staging = new Proxy(confined, { get(target, key) {
+        const owner = ["stat", "lstat", "realpath", "openReadFile", "iterateDirectory", "readlink", "confineExtraction", "removeTreeConditional"].includes(String(key)) ? fs : target, value = Reflect.get(owner, key);
+        return typeof value === "function" ? value.bind(owner) : value;
+      } });
+      const command = { ...context, env: context.env, stdout: context.stdout, stderr: context.stderr, command: "python", args: [], stdin: toByteSource7("") };
+      Reflect.deleteProperty(command, "editable");
+      const configuration = { ...build.python, environment }, hook = createPythonBuildBackend(configuration), hookContext = { ...command, maxBytes: options.maxMetadataBytes ?? Infinity };
+      let prepared;
+      if (archived) {
+        prepared = resolvePath5(path, "source");
+        await confined.mkdir(prepared, settings);
+        if (!build.extractArchive) throw new Error("Source archives require an extraction capability");
+        let metadata;
+        if (remote) {
+          source = resolvePath5(path, "archive");
+          const response = await downloadPythonSourceArchive(remote, source, options, command);
+          const filename2 = await hook({ hook: "read_download_filename", source: remote.href, responseUrl: response.url, headers: response.headers }, hookContext);
+          const headers = new Map(response.headers.map(([key, value]) => [key.toLowerCase(), value]));
+          metadata = { filename: filename2, ...headers.has("content-type") ? { contentType: headers.get("content-type") } : {} };
+        }
+        if (!remote && originalLink && pythonPackageUrlHash(originalLink)) {
+          const snapshot = resolvePath5(path, "archive" + suffix);
+          await snapshotPythonSourceArchive(source, snapshot, originalLink, options.maxDownloadBytes ?? Infinity, { ...command, fs: staging });
+          source = snapshot;
+        }
+        await build.extractArchive(source, prepared, options.maxDownloadBytes ?? Infinity, { ...command, fs: staging }, metadata);
+      } else prepared = editable ? await fs.realpath(source, settings) : (await createPythonSourceSnapshot(source, path, { ...command, fs: staging })).path;
+      if (subdirectory) {
+        const selected = resolvePath5(prepared, subdirectory);
+        if (selected !== prepared && !selected.startsWith(prepared + "/")) throw new Error("Source subdirectory escapes the build tree");
+        const root2 = await fs.realpath(prepared, settings), actual = await fs.realpath(selected, settings);
+        if (actual !== root2 && !actual.startsWith(root2 + "/")) throw new Error("Source subdirectory escapes the build tree");
+        prepared = actual;
+      }
+      const wheelDirectory = resolvePath5(path, "wheels");
+      await confined.mkdir(wheelDirectory, settings);
+      const buildSystem = await hook({ hook: "read_build_system", source: prepared, name: requirement, installation: archived ? "archive" : "directory" }, hookContext);
+      await createPythonBuildDependencies(configuration)({ source: prepared, buildSystem }, hookContext);
+      const filename = await hook(editable ? { hook: "build_legacy_wheel", source: prepared, wheelDirectory, editable: true } : buildSystem ? { hook: "build_wheel", source: prepared, backend: buildSystem.backend, backendPath: buildSystem.backendPath, wheelDirectory } : { hook: "build_legacy_wheel", source: prepared, wheelDirectory }, hookContext);
+      const published = await publishPythonBuildWheel(resolvePath5(wheelDirectory, filename), root, options.maxDownloadBytes ?? Infinity, context);
+      const origin = buildSystem && !editable ? await hook({ hook: "read_source_origin", source: originSource, directory: !archived }, hookContext) : void 0;
+      const url = published.url + "#python-source=" + encodeURIComponent(origin ?? "null");
+      await cleanup();
+      return named ? (named.name || filename.slice(0, filename.indexOf("-"))) + (named.extras.length ? "[" + named.extras.join(",") + "]" : "") + " @ " + url + (named.marker ? " ; " + named.marker : "") : url;
+    } catch (error) {
+      try {
+        await cleanup();
+      } catch (retirement) {
+        if (retirement === error) throw error;
+        throw new AggregateError([error, retirement], "Python source build cleanup failed");
+      }
+      throw error;
+    }
+  };
+  return withPythonSourceOrigins(createPythonPackageEnvironment({ ...options, async prepareRequirements(requirements, context) {
+    const resolved = [];
+    for (const requirement of /* @__PURE__ */ new Set([...options.editable ?? [], ...context.editable ?? []])) resolved.push(await prepareRequirement(requirement, context, true));
+    for (const requirement of new Set(requirements)) resolved.push(await prepareRequirement(requirement, context));
+    return resolved;
+  } }), build.directory, options.maxMetadataBytes ?? Infinity);
+}
+
+// packages/safe-bash-command-python/src/executor.ts
+var encoder = new TextEncoder();
+var PythonInputChunkError = class extends RangeError {
+};
+function createPythonExecutorCommands(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 ?? Infinity;
+  const transferChunkBytes = Math.min(maxTransferBytes, 65536);
+  const maxOpenFiles = options.maxOpenFiles;
+  const maxConcurrentWorkers = options.maxConcurrentWorkers ?? Infinity;
+  const maxInputChunkBytes = options.maxInputChunkBytes ?? Infinity;
+  if (maxConcurrentWorkers !== Infinity && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1)) throw new RangeError("Invalid Python worker concurrency limit");
+  if (maxInputChunkBytes !== Infinity && (!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 && size !== Infinity && (!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 writeBytes(context.stderr, encoder.encode("python: nested Python execution is unavailable while the parent interpreter is suspended\n"), context.signal);
+      return { exitCode: 1 };
+    }
+    let installation;
+    try {
+      const invocation = parsePythonInvocation(context.args, context.env);
+      installation = invocation.module?.name === "pip" ? parsePythonInstallation(invocation.module.args) : void 0;
+    } catch (error) {
+      if (!(error instanceof PythonInvocationError)) throw error;
+      await writeBytes(context.stderr, encoder.encode("python: " + error.message + "\n"), context.signal);
+      return { exitCode: 2 };
+    }
+    if (installation?.help) {
+      await writeBytes(context.stdout, encoder.encode(pythonInstallationHelp), context.signal);
+      return { exitCode: 0 };
+    }
+    context.signal.throwIfAborted();
+    if (activeWorkers >= maxConcurrentWorkers) {
+      const failure = reportPythonFailure("capacity", void 0, options.onDiagnostic);
+      await writeBytes(context.stderr, encoder.encode("python: " + failure.message + "\n"), context.signal);
+      return { exitCode: 1 };
+    }
+    const controller = new AbortController();
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    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) => 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 = 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) results.push(...await Promise.allSettled([Promise.resolve().then(() => environment.finish(packages))]));
+        if (results[1]?.status === "fulfilled" && admitted) {
+          activeWorkers--;
+          admitted = false;
+        }
+        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 = createOutputOperation(outputContext, context.stdout);
+      stderrOperation = 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 failure = reportPythonFailure(category, error, options.onDiagnostic);
+          await writeBytes(stderrOperation.output, encoder.encode("python: " + failure.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 yieldTurn2(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 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: [transferChunkBytes] });
+            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({
+        ...context,
+        signal,
+        ...installation?.controls,
+        ...installation?.uninstall ? { uninstall: { packages: installation.packages, yes: !!installation.yes } } : {},
+        requirements: [...options.packages ?? [], ...options.packageProfile ? pythonDocumentPackages : [], ...installation?.uninstall ? [] : 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 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 + transferChunkBytes * 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 = 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 failure = reportPythonFailure("runtime-assets", error, options.onDiagnostic);
+                    pending.delete(work);
+                    reply({ code: "EPACKAGE", message: failure.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: transferChunkBytes, ...packages ? { packages } : {}, installOnly: !!installation };
+          signal.throwIfAborted();
+          try {
+            endpoint.postMessage(start);
+          } catch (reason) {
+            transportFailure(reason);
+          }
+        });
+      }
+    } catch (reason) {
+      if (!signal.aborted && (reason instanceof PythonInputChunkError || reason instanceof PythonInstallationError)) {
+        try {
+          await writeBytes(stderrOperation.output, encoder.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 failure = primary.reason;
+      await writeBytes(context.stderr, encoder.encode("python: " + failure.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 pythonExecutorCommands(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 = createPythonExecutorCommands({ ...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 {
+  createPythonLlmPackageManager,
+  createPythonLlmTemplateLoader,
+  createPythonLlmFragmentLoader,
+  createPythonLlmLoaderProvider,
+  createPythonLlmLoaderDiscovery,
+  createPythonLlmToolLoader,
+  createPythonBuildEnvironment,
+  createPythonBuildBackend,
+  createPythonBuildDependencies,
+  createPythonSourceSnapshot,
+  pythonLlmPackages,
+  installPythonLlmPackages,
+  publishPythonBuildWheel,
+  createPythonSourcePackageEnvironment,
+  createPythonExecutorCommands,
+  pythonExecutorCommands
+};