@poe-platform/safe-bash 0.1.825 → 0.1.827

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

@@ -0,0 +1,604 @@
+import {
+  pythonPublicationFile
+} from "./chunk-HS2L7I4N.js";
+import {
+  PythonFailure
+} from "./chunk-TO6UNFEF.js";
+
+// packages/safe-bash-command-python/src/invocation.ts
+var PythonInvocationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PythonInvocationError";
+  }
+};
+function parsePythonInvocation(args, env) {
+  const startupArgs = [];
+  let informational = false;
+  let module;
+  scan: for (let index = 0; index < args.length; index++) {
+    const option = args[index];
+    if (option === "--" || option === "-" || !option.startsWith("-")) break;
+    if (option === "--help") {
+      informational = true;
+      break;
+    }
+    if (option === "--version") {
+      informational = true;
+      continue;
+    }
+    if (option.startsWith("--")) throw new PythonInvocationError("unsupported option " + option);
+    for (let offset = 1; offset < option.length; offset++) {
+      const flag = option[offset];
+      if (flag === "h" || flag === "?") {
+        informational = true;
+        break scan;
+      }
+      if (flag === "V") {
+        informational = true;
+        continue;
+      }
+      if ("cmWX".includes(flag)) {
+        const operand = option.slice(offset + 1) || args[++index];
+        if (operand === void 0) throw new PythonInvocationError("argument expected for -" + flag);
+        if (flag === "m" && !informational) module = { name: operand, args: args.slice(index + 1) };
+        if (flag === "c" || flag === "m") break scan;
+        if (flag === "X") {
+          const separator = operand.indexOf("=");
+          const name = separator < 0 ? operand : operand.slice(0, separator);
+          const value = separator < 0 ? void 0 : operand.slice(separator + 1);
+          let decimal = value ?? "";
+          while (decimal.length && " 	\n\r\v\f".includes(decimal[0])) decimal = decimal.slice(1);
+          if (decimal[0] === "+" || decimal[0] === "-") decimal = decimal.slice(1);
+          const digits = decimal.length > 0 && [...decimal].every((character) => character >= "0" && character <= "9");
+          const supported = name === "utf8" && (value === void 0 || value === "0" || value === "1") || (name === "dev" || name === "warn_default_encoding") && value === void 0 || name === "int_max_str_digits" && digits && Number.isSafeInteger(Number(value)) && Number(value) <= 2147483647 && (Number(value) === 0 || Number(value) >= 640);
+          if (!supported) throw new PythonInvocationError("unsupported -X option " + operand);
+          startupArgs.push("-X", operand);
+        }
+        break;
+      }
+      if (!"BEPOusISbdvqR".includes(flag)) throw new PythonInvocationError("unsupported option -" + flag);
+      startupArgs.push("-" + flag);
+    }
+  }
+  if (!informational && !startupArgs.includes("-E") && !startupArgs.includes("-I")) {
+    if (env.PYTHONINSPECT) throw new PythonInvocationError("PYTHONINSPECT requires an interactive terminal, which the shell does not expose");
+    if (env.PYTHONHOME) throw new PythonInvocationError("PYTHONHOME cannot replace the configured Pyodide runtime");
+  }
+  const runtimeEnv = { ...env };
+  delete runtimeEnv.PYTHONPATH;
+  delete runtimeEnv.PYTHONHOME;
+  delete runtimeEnv.PYTHONWARNINGS;
+  runtimeEnv.PYTHONINSPECT = "";
+  startupArgs.push("-c", "");
+  return { startupArgs, env: runtimeEnv, module };
+}
+
+// packages/safe-bash-command-python/src/package-program.generated.ts
+var pythonPackageProgramGzip = "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";
+
+// packages/safe-bash-command-python/src/package-program.ts
+var decoded;
+function loadPythonPackageProgram() {
+  return decoded ??= new Response(new Blob([Uint8Array.from(atob(pythonPackageProgramGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).text();
+}
+
+// packages/safe-bash-command-python/src/native-wheel.generated.ts
+var pythonNativeWheelGzip = "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";
+
+// packages/safe-bash-command-python/src/native-wheel.ts
+var decoded2;
+function loadPythonNativeWheel() {
+  return decoded2 ??= new Response(new Blob([Uint8Array.from(atob(pythonNativeWheelGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).text();
+}
+
+// packages/safe-bash-command-python/src/package-url-hash.ts
+function pythonPackageUrlHash(url) {
+  const match = /(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)/.exec(url);
+  return match ? [match[1], match[2]] : void 0;
+}
+
+// packages/safe-bash-command-python/src/provisioning-runtime.ts
+async function installPythonPackages(supplied, start, request, maxTransferBytes, installationRoot) {
+  if (!start.requirements.length && !start.uninstall && !start.bootstrap) return;
+  const runtime = supplied;
+  if (runtime.version !== "314.0.6" || !runtime._api?.packageManager || !runtime._api.lockfile_packages || typeof runtime._api.packageManager.installPackage !== "function" || typeof runtime.loadPackage !== "function" || typeof runtime.runPythonAsync !== "function") throw new PythonFailure("runtime-abi", { cause: new Error("Python package installer ABI requires Pyodide 314.0.6") });
+  let transportFailure;
+  let accepting = true;
+  let pending = Promise.resolve();
+  let installing = Promise.resolve();
+  const manager = runtime._api.packageManager;
+  const transfer = (consume) => {
+    if (!accepting) return Promise.reject(new Error("Python package transport is only available during installation"));
+    const work = pending.then(async () => {
+      if (transportFailure) throw transportFailure.error;
+      try {
+        return await consume();
+      } catch (error) {
+        transportFailure ??= { error };
+        throw error;
+      }
+    });
+    pending = work.then(() => {
+    }, () => {
+    });
+    return work;
+  };
+  const readArtifact = (operation, key, offset, length) => {
+    const failed = (error) => {
+      transportFailure ??= { error };
+      throw error;
+    };
+    try {
+      const result = request(operation, start.session, key, offset, Math.min(length, maxTransferBytes, 65536));
+      return result instanceof Promise ? result.catch(failed) : result;
+    } catch (error) {
+      return failed(error);
+    }
+  };
+  const withArtifact = (url, expected, metadata, consume) => transfer(async () => {
+    const opened = await request("package-open", start.session, url, expected, ...metadata ? [metadata] : []);
+    try {
+      return await consume(opened, (offset, length) => readArtifact("package-read", opened.key, offset, length));
+    } finally {
+      await request("package-close", start.session, opened.key);
+    }
+  });
+  const wheel = async (size, read, configuration) => {
+    const globals = ["_safe_native_wheel_read", "_safe_native_wheel_config", "_safe_extract_native_wheel", "_safe_native_wheel_index", "_safe_native_wheel_dynlib"];
+    let indexed = false;
+    try {
+      runtime.globals.set(globals[0], read);
+      runtime.globals.set(globals[4], async (path) => {
+        try {
+          await runtime._api.loadDynlib(path);
+          return "";
+        } catch (error) {
+          return String(error);
+        }
+      });
+      runtime.globals.set(globals[3], (operation, ...args) => {
+        if (operation === "start") indexed = true;
+        const failed = (error) => {
+          transportFailure ??= { error };
+          throw error;
+        };
+        try {
+          const result2 = request("package-index", start.session, operation, ...args);
+          return result2 instanceof Promise ? result2.catch(failed) : result2;
+        } catch (error) {
+          return failed(error);
+        }
+      });
+      runtime.globals.set(globals[1], JSON.stringify({ ...configuration, size }));
+      const result = JSON.parse(await runtime.runPythonAsync(await loadPythonNativeWheel()));
+      if (result && typeof result === "object" && "wheelError" in result) throw new Error(result.wheelError);
+      if (result && typeof result === "object" && "dynlibError" in result) throw new Error(result.dynlibError);
+      return result;
+    } finally {
+      try {
+        if (indexed) await request("package-index", start.session, "close");
+      } finally {
+        for (const name of globals) runtime.globals.delete(name);
+      }
+    }
+  };
+  const fetch = (url, expected, metadata) => withArtifact(url, expected, metadata, async (opened, read) => {
+    const bytes = new Uint8Array(opened.size);
+    for (let offset = 0; offset < bytes.length; ) {
+      const chunk = await read(offset, bytes.length - offset);
+      if (!Array.isArray(chunk) || chunk.length === 0 || offset + chunk.length > bytes.length) throw new Error("Invalid Python package chunk");
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return { bytes, headers: opened.headers };
+  });
+  manager.downloadPackage = async (metadata) => {
+    if (!accepting) throw new Error("Python package transport is only available during installation");
+    if (metadata.channel === manager.defaultChannel) {
+      const pkg = runtime._api.lockfile_packages[metadata.normalizedName];
+      if (!pkg) throw new Error(`Missing matching Pyodide package: ${metadata.normalizedName}`);
+      return { url: new URL(pkg.file_name, "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/").href, expected: pkg.sha256 };
+    }
+    return { url: metadata.channel };
+  };
+  manager.installPackage = (metadata, source) => {
+    if (!accepting) return Promise.reject(new Error("Python package transport is only available during installation"));
+    const work = installing.then(async () => {
+      if (source instanceof Uint8Array) throw new Error("Expected retained Python package source");
+      const pkg = runtime._api.lockfile_packages[metadata.normalizedName] ?? metadata.packageData;
+      if (!pkg) throw new Error(`Missing matching Pyodide package: ${metadata.normalizedName}`);
+      return withArtifact(source.url, source.expected, void 0, (opened, read) => wheel(opened.size, read, {
+        filename: pkg.file_name,
+        target: pkg.install_dir ?? null,
+        metadata: { INSTALLER: "pyodide.loadPackage", PYODIDE_SOURCE: metadata.channel === manager.defaultChannel ? "pyodide" : metadata.channel }
+      }));
+    });
+    installing = work.then(() => {
+    }, () => {
+    });
+    return work;
+  };
+  const loadPackages = async (names) => {
+    const errors = [];
+    const importlib = runtime._api.importlib;
+    let invalidate = false;
+    if (installationRoot && importlib) runtime._api.importlib = { invalidate_caches() {
+      invalidate = true;
+    } };
+    try {
+      await runtime.loadPackage(names, { messageCallback() {
+      }, errorCallback(message) {
+        errors.push(message);
+      } });
+    } finally {
+      if (installationRoot && importlib) runtime._api.importlib = importlib;
+    }
+    if (invalidate) await runtime.runPythonAsync("import importlib; importlib.invalidate_caches()");
+    if (errors.length) throw new Error(errors.join("\n"));
+  };
+  const installedGlobals = [];
+  const bind = (name, value) => {
+    runtime.globals.set(name, value);
+    installedGlobals.push(name);
+  };
+  try {
+    if (installationRoot) {
+      bind("_safe_installation_root", installationRoot);
+      await runtime.runPythonAsync(`
+import sys, site, sysconfig
+from pathlib import Path
+from pyodide import _package_loader
+sys.prefix = sys.exec_prefix = _safe_installation_root
+site.PREFIXES = [sys.prefix, sys.exec_prefix]
+sysconfig._CONFIG_VARS = None
+_package_loader.SITE_PACKAGES = Path(site.getsitepackages()[0])
+_package_loader.DSO_DIR = _package_loader.SITE_PACKAGES.parents[1]
+_package_loader.TARGETS.update(site=_package_loader.SITE_PACKAGES, dynlib=_package_loader.DSO_DIR)
+_package_loader.SITE_PACKAGES.mkdir(parents=True, exist_ok=True)
+sys.path.insert(0, str(_package_loader.SITE_PACKAGES))
+`);
+    }
+    await loadPackages(["micropip", ...start.bootstrapPackages ?? []]);
+    bind("_safe_package_native", loadPackages);
+    bind("_safe_package_preloaded", (operation, name) => transfer(async () => request("package-index", start.session, "names-" + operation, ...name === void 0 ? [] : [name])));
+    bind("_safe_package_bytes", async (url, hash) => (await fetch(url, hash)).bytes);
+    bind("_safe_package_metadata", async (url) => {
+      const result = await fetch(url, void 0, "metadata");
+      return JSON.stringify({ text: new TextDecoder().decode(result.bytes), headers: Object.fromEntries(result.headers.map(([name, value]) => [name.toLowerCase(), value])) });
+    });
+    bind("_safe_package_wheel_download", async (url, expected) => withArtifact(url, expected, void 0, async (opened, read) => {
+      const hash = pythonPackageUrlHash(url);
+      if (hash) await wheel(opened.size, read, { integrity: hash });
+      return JSON.stringify(await request("package-retain", start.session, opened.key));
+    }));
+    bind("_safe_package_wheel_metadata", async (serialized) => transfer(async () => {
+      const { source, name } = JSON.parse(serialized);
+      return wheel(source.size, (offset, length) => readArtifact("package-read-retained", source.token, offset, length), { metadata_name: name });
+    }));
+    bind("_safe_package_wheel_install", async (serialized) => transfer(async () => {
+      const { source, ...configuration } = JSON.parse(serialized);
+      await wheel(source.size, (offset, length) => readArtifact("package-read-retained", source.token, offset, length), configuration);
+    }));
+    bind("_safe_package_indexes_json", JSON.stringify(start.indexUrls ?? null));
+    bind("_safe_package_constraints_json", JSON.stringify(start.constraints ?? []));
+    bind("_safe_package_requirements_json", JSON.stringify(start.requested ?? start.requirements));
+    for (const key of ["pre", "upgrade", "forceReinstall", "legacy", "noDeps"]) {
+      bind("_safe_package_" + key, !!start[key]);
+    }
+    bind("_safe_package_restore_json", JSON.stringify(start.restore ?? []));
+    const inputRecords = start.recordCount === void 0 ? start.records?.map((row) => [row[0], row[1], row[2], [...row[3]], [...row[4]], row[5] ?? null]) : void 0;
+    const recordCount = start.recordCount ?? inputRecords?.length ?? -1;
+    const publication = start.streamManifest && installationRoot && start.restore !== void 0 ? installationRoot + "/" + pythonPublicationFile : null;
+    bind("_safe_package_publication", publication);
+    const outputRecords = [], pinned = [];
+    bind("_safe_package_record", (operation, key, value, field) => transfer(async () => {
+      if (publication && (operation === "pin" || operation === "append")) throw new Error("Expected caller-file Python publication");
+      if (operation === "pin") {
+        if (typeof key !== "string") throw new Error("Invalid Python package pin");
+        const pin = JSON.parse(key);
+        if (typeof pin !== "string") throw new Error("Invalid Python package pin");
+        pinned.push(pin);
+        return null;
+      }
+      if (operation === "start") {
+        await request("package-index", start.session, "records-start");
+        return recordCount;
+      }
+      if (operation === "append") {
+        if (typeof key !== "string") throw new Error("Invalid Python package record");
+        if (start.restore !== void 0) outputRecords.push(JSON.parse(key));
+        return null;
+      }
+      if (operation === "read" || operation === "get" || operation === "field") {
+        if (operation === "field" && (!Number.isInteger(field) || field < 0 || field > 5)) throw new Error("Invalid Python package record field");
+        const offset = value ?? 0;
+        if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid Python package record offset");
+        const ordinal = operation !== "read" ? await request("package-index", start.session, "records-get", key) : key;
+        if (ordinal === null) return offset === 0 ? "null" : "";
+        if (!Number.isSafeInteger(ordinal) || ordinal < 0 || ordinal >= recordCount) throw new Error("Invalid Python package record ordinal");
+        const chunk = start.recordCount === void 0 ? JSON.stringify(operation === "field" ? inputRecords[ordinal][field] ?? null : inputRecords[ordinal]).slice(offset, offset + 8192) : await request("package-record-read", start.session, ordinal, offset, ...operation === "field" ? [field] : []);
+        if (operation === "field" && chunk === false) return false;
+        if (typeof chunk !== "string" || chunk.length > 8192) throw new Error("Invalid Python package record chunk");
+        const last = chunk.charCodeAt(chunk.length - 1);
+        return last >= 55296 && last <= 56319 ? chunk.slice(0, -1) : chunk;
+      }
+      return request("package-index", start.session, "records-" + operation, ...key === void 0 ? [] : [key], ...value === void 0 ? [] : [value]);
+    }));
+    bind("_safe_package_uninstall_json", JSON.stringify(start.uninstall ?? null));
+    bind("_safe_package_emit", async (stream, message) => {
+      if (stream !== "stdout" && stream !== "stderr") throw new Error("Invalid package output stream");
+      const bytes = new TextEncoder().encode(message);
+      for (let offset = 0; offset < bytes.length; offset += maxTransferBytes) await request(stream, Array.from(bytes.subarray(offset, offset + maxTransferBytes)));
+    });
+    bind("_safe_package_line", async () => {
+      const bytes = [];
+      while (true) {
+        const chunk = await request("stdin", 1);
+        if (!chunk.length) {
+          if (!bytes.length) throw new Error("EOF when reading package confirmation");
+          break;
+        }
+        if (chunk[0] === 10) break;
+        bytes.push(chunk[0]);
+      }
+      return new TextDecoder().decode(Uint8Array.from(bytes));
+    });
+    const program = await loadPythonPackageProgram();
+    const installerFailure = await runtime.runPythonAsync(`
+import sys as _safe_install_sys
+from micropip.logging import setup_logging as _safe_install_logging
+_safe_install_handlers = [handler for handler in _safe_install_logging().logger.handlers if getattr(handler, 'stream', None) is _safe_install_sys.stdout]
+_safe_installer_failure = None
+try:
+ for handler in _safe_install_handlers: handler.setStream(_safe_install_sys.stderr)
+${program.split("\n").map((line) => " " + line).join("\n")}
+except BaseException:
+ import traceback
+ _safe_installer_failure = traceback.format_exc()
+finally:
+ for handler in _safe_install_handlers: handler.setStream(_safe_install_sys.stdout)
+_safe_installer_failure
+`);
+    if (typeof installerFailure === "string" && installerFailure) throw new Error(installerFailure);
+    await installing;
+    accepting = false;
+    await pending;
+    if (transportFailure) throw transportFailure.error;
+    if (publication) await request("package-commit-file", start.session);
+    else await request("package-commit", start.session, start.restore === void 0 ? pinned : { version: 3, installed: pinned, records: outputRecords });
+    if (start.uninstall) await runtime.runPythonAsync("await _safe_publish_uninstalled()");
+  } catch (error) {
+    await installing;
+    accepting = false;
+    await pending;
+    throw transportFailure ? transportFailure.error : error;
+  } finally {
+    await installing;
+    accepting = false;
+    await pending;
+    manager.downloadPackage = manager.installPackage = async () => {
+      throw new Error("Python package transport is only available during installation");
+    };
+    for (const name of installedGlobals) runtime.globals.delete(name);
+  }
+}
+
+// packages/safe-bash-command-python/src/execution.ts
+var pythonExecution = `
+import sys, os, json, runpy, traceback, types, warnings, textwrap, io, struct, linecache
+_safe_invocation = json.loads(_safe_invocation_json)
+os.environ.clear()
+os.environ.update(_safe_invocation['env'])
+_safe_args = list(_safe_invocation['args'])
+sys.orig_argv = [_safe_invocation.get('command', 'python')] + _safe_args
+_safe_exit = 0
+
+class _SafeOptionError(ValueError):
+ pass
+
+def _safe_system_exit(_error):
+ if isinstance(_error.code, int):
+  _status = int.__index__(_error.code)
+  _long_bound = 1 << (8 * struct.calcsize('@l') - 1)
+  status = (_status & 255) if -_long_bound <= _status < _long_bound else 255
+ else:
+  status = 0 if _error.code is None else 1
+ if _error.code is not None and not isinstance(_error.code, int):
+  print(_error.code, file=sys.stderr)
+ return status
+
+def _safe_launch():
+ args = list(_safe_args)
+ unbuffered = False
+ ignore_env = bool(sys.flags.ignore_environment)
+ safe_path = bool(sys.flags.safe_path)
+ native_warning_options = list(sys.warnoptions)
+ # Pyodide adds a bootstrap cwd entry even when CPython safe-path mode is set.
+ # Each execution mode below supplies its own entry after explicit PYTHONPATH.
+ sys.path[:] = [entry for entry in sys.path if entry != '']
+ warning_options = []
+ version_count = 0
+ options_terminated = False
+ while args and args[0].startswith('-') and args[0] != '-':
+  option = args.pop(0)
+  if option == '--':
+   options_terminated = True
+   break
+  if option in ('--help', '-h', '-?'):
+   print('usage: python [-uBEPOsSIbdvqR] [-W filter] [-X option] [-c code | -m module | file | -] [args ...]')
+   print('Dedicated Pyodide interpreter; stdin is noninteractive.')
+   print('-u: unbuffered binary output; -B: disable bytecode writes; -E: ignore PYTHON* settings')
+   print('-P: omit automatic unsafe sys.path entry; -W: Python warning filter')
+   print('-O/-OO, -S/-s/-I, -b/-bb, -d/-v/-q/-R: CPython startup flags')
+   print('-X: utf8, dev, warn_default_encoding, int_max_str_digits; interactive flags are unsupported.')
+   return
+  if option == '--version':
+   version_count += 1
+   continue
+  if option.startswith('--'):
+   raise _SafeOptionError('unsupported option ' + option)
+  index = 1
+  while index < len(option):
+   flag = option[index]
+   if flag in ('h', '?'):
+    args = ['--help']
+    break
+   if flag == 'V':
+    version_count += 1
+    index += 1
+    continue
+   if flag in ('c', 'm', 'W', 'X'):
+    operand = option[index + 1:] if index + 1 < len(option) else args.pop(0) if args else None
+    if operand is None:
+     raise _SafeOptionError('argument expected for -' + flag)
+    if flag in ('W', 'X'):
+     if flag == 'W': warning_options.append(operand)
+     break
+    args = ['-' + flag, operand] + args
+    break
+   elif flag in ('O', 'S', 's', 'I', 'b', 'd', 'v', 'q', 'R'):
+    pass # Applied by CPython startup configuration before bootstrap.
+   elif flag == 'u':
+    unbuffered = True
+   elif flag == 'B':
+    sys.dont_write_bytecode = True
+   elif flag == 'E':
+    ignore_env = True
+   elif flag == 'P':
+    safe_path = True
+   else:
+    raise _SafeOptionError('unsupported option -' + flag)
+   index += 1
+  if args and args[0] in ('-c', '-m'):
+   break
+ if version_count:
+  print('Python ' + (sys.version if version_count > 1 else sys.version.split()[0]))
+  return
+ if not ignore_env:
+  unbuffered = unbuffered or bool(os.environ.get('PYTHONUNBUFFERED'))
+  sys.dont_write_bytecode = sys.dont_write_bytecode or bool(os.environ.get('PYTHONDONTWRITEBYTECODE'))
+  safe_path = safe_path or bool(os.environ.get('PYTHONSAFEPATH'))
+  path = os.environ.get('PYTHONPATH')
+  if path:
+   sys.path[0:0] = [os.path.abspath(entry) for entry in path.split(os.pathsep)]
+  if os.environ.get('PYTHONWARNINGS'):
+   warning_options[0:0] = os.environ['PYTHONWARNINGS'].split(',')
+  encoding = os.environ.get('PYTHONIOENCODING')
+  if encoding:
+   name, separator, errors = encoding.partition(':')
+   for stream in (sys.stdin, sys.stdout):
+    stream.reconfigure(encoding=name or None, errors=(errors or 'strict'))
+   sys.stderr.reconfigure(encoding=name or None, errors='backslashreplace')
+ # CPython's -b/-bb filter follows environment and command-line -W filters.
+ byte_warning = ('error' if sys.flags.bytes_warning > 1 else 'default') + '::BytesWarning'
+ native_before = [value for value in native_warning_options if not (sys.flags.bytes_warning and value == byte_warning)]
+ warning_options = native_before + warning_options + ([byte_warning] if sys.flags.bytes_warning else [])
+ warnings._processoptions(warning_options)
+ sys.warnoptions[:] = warning_options
+ if unbuffered:
+  for name in ('stdout', 'stderr'):
+   stream = getattr(sys, name)
+   stream.flush()
+   encoding, errors = stream.encoding, stream.errors
+   binary = stream.detach()
+   raw = binary.detach() if hasattr(binary, 'detach') else binary
+   replacement = io.TextIOWrapper(raw, encoding=encoding, errors=errors, write_through=True)
+   setattr(sys, name, replacement)
+   setattr(sys, '__' + name + '__', replacement)
+ main = types.ModuleType('__main__')
+ main.__dict__.update(__package__=None, __spec__=None, __loader__=__import__('importlib.machinery', fromlist=['BuiltinImporter']).BuiltinImporter, __builtins__=__builtins__)
+ sys.modules['__main__'] = main
+ if not sys.flags.no_site:
+  sys.argv = [args[0]] + args[2:] if not options_terminated and args and args[0] in ('-c', '-m') else args or ['']
+  import site
+  site.addsitepackages(site.addusersitepackages(None), list(dict.fromkeys([_safe_runtime_mount, sys.prefix])))
+ if not options_terminated and args and args[0] == '-c':
+  sys.argv = ['-c'] + args[2:]
+  if not safe_path: sys.path.insert(0, '')
+  source = textwrap.dedent(args[1])
+  code = compile(source, '<string>', 'exec')
+  # CPython 3.14 retains -c source for both top-level and nested tracebacks.
+  linecache._register_code(code, source, '<string>')
+  exec(code, main.__dict__)
+ elif not options_terminated and args and args[0] == '-m':
+  sys.argv = args[1:]
+  if not safe_path: sys.path.insert(0, os.getcwd())
+  runpy._run_module_as_main(args[1], alter_argv=True)
+ elif not args or args[0] == '-':
+  sys.argv = (['-'] + args[1:]) if args else ['']
+  if not safe_path: sys.path.insert(0, '')
+  main.__file__ = '<stdin>'
+  exec(compile(sys.stdin.buffer.read(), '<stdin>', 'exec'), main.__dict__)
+ else:
+  sys.argv = args
+  # CPython makes __file__ absolute without collapsing ./ or ../ components.
+  path = args[0] if os.path.isabs(args[0]) else os.path.join(os.getcwd(), args[0])
+  importer = __import__('pkgutil').get_importer(path)
+  if importer is not None:
+   sys.path.insert(0, path)
+   runpy._run_module_as_main('__main__', alter_argv=False)
+  else:
+   if not safe_path: sys.path.insert(0, os.path.dirname(os.path.realpath(path)))
+   try:
+    with open(path, 'rb') as source:
+     code = source.read()
+   except OSError as error:
+    print("python: can't open file " + repr(path) + ': [Errno ' + str(error.errno) + '] ' + error.strerror, file=sys.stderr)
+    return 2
+   main.__file__ = path
+   main.__loader__ = __import__('importlib.machinery', fromlist=['SourceFileLoader']).SourceFileLoader('__main__', path)
+   exec(compile(code, path, 'exec'), main.__dict__)
+ return 0
+
+try:
+ _safe_exit = _safe_launch() or 0
+except SystemExit as _error:
+ _safe_exit = _safe_system_exit(_error)
+except _SafeOptionError as _error:
+ print('python: ' + str(_error), file=sys.stderr)
+ _safe_exit = 2
+except BaseException as _error:
+ # Hide bridge frames while preserving actual Python frames and chained errors.
+ _trace = _error.__traceback__
+ while _trace is not None and _trace.tb_frame.f_code.co_filename == '<exec>':
+  _trace = _trace.tb_next
+ _error.__traceback__ = _trace
+ sys.last_exc = _error
+ _safe_exit = 130 if isinstance(_error, KeyboardInterrupt) else 1
+ try:
+  sys.excepthook(type(_error), _error, _trace)
+ except SystemExit as _hook_error:
+  _safe_exit = _safe_system_exit(_hook_error)
+ except BaseException as _hook_error:
+  print('Error in sys.excepthook:', file=sys.stderr)
+  traceback.print_exception(type(_hook_error), _hook_error, _hook_error.__traceback__.tb_next)
+  print('\\nOriginal exception was:', file=sys.stderr)
+  sys.__excepthook__(type(_error), _error, _trace)
+finally:
+ for _stream in (sys.stdout, sys.stderr):
+  if _stream is not None and not getattr(_stream, 'closed', False):
+   try:
+    _stream.flush()
+   except BaseException:
+    _safe_exit = 120
+_safe_exit
+`;
+
+// packages/safe-bash-command-python/src/runtime-programs.generated.ts
+var pythonRuntimeProgramsGzip = "H4sIAAAAAAACA8U9a5PctpF/BZE+kLQoSsrlrq5WZqpiW3JUsWWXpCR33p1iYUnMDrwccAJwtDtK5b9fdTeeJGd211LlUlfWLAE0Gt2NfqGB++ej3WHcDOrdXo1yK96Jfmj5KAf16OzRhZLb3aBHZg6mZJ/kjv4sGf3by8tqy9uNVEIfLtSF6sSaNVpcciMaTfCaHR83+Ufe70VxdqGYFuNeK9YYvg59tsNejewJw25Mrpk0UpmRq1bQ0JKZUReMq47RB1bXLHvWy8uMDZrGVWbkejQ3ctzk2PQsKwomeiOo/RiC/cA7oXP6B3FMEaCGaPmV/2X7M67bjfwoWL28eoJQ2V4FjJBrP+h3NUs7IEhHqMVZczf2CcueZeyJA7DTYi1vYQLRLy8iX+Bc9X7Y61a8lr34wXY73qsXxtzV89XtKJSRgwodCyIUkOMOKsFvRyLsHugDfybEGQ87t7TCjVd8K0rmoNiO1HahzMEglPOzFavZ+QlZZWsnV0wq5satLhR8b7ZDt++xpZdmzKGZPpkKx5i8cJLk+xr2dlDE3HZQo1QgkjhNw8dRy8v9iBDzrGnWshdNk5Usa5qWtxvRNU1GJJRrtuEGRuQWdBkBoD7MiPFYj3KZ+lfHRxRFQUuZzZs1ONjjZhsq9/lBNJ4OXh2flNi5MK1rWJAxu83nfWFxjdmJltVsRoWswSbkBbDPUoL6S8PUMAa24tdq0PJKqmNSHvcpwiBC5gTaUS+3O+ib2V8Sso0RoBYap7/NDL+7RzyIX3cAW4Xt1jjFRcJctb3gOi8u1KPSWp832OFHMfKOjzw2PUHBNJfDMJpR810jbkehFe9LVAGmZL+aQV0osio0ojEjH5uW9/0lb6+BstNG15+Ywfu4jdWnJ65ISAkMWpUYum/LUQ9ZTUDKr160fYPG5tiGLZvI7JkV+sSQLi0hdzrQGkykEYqQyY8TikZZMc+E1mrIgNsIhCbm0gj20/tXWg+aJOPcdlyVLAPVZQ5mFFtLQba1XGV7xT9y2fPLXmQzFY2MrN7L7a4Xb/lWmB1vRW5G2IqittPAb5jFjI2Rn/xn+G0/b4Favjv88aPJVuwZe/H8+fPCSdXdXJ0KTMRuL7TfSS3acdCHV2rUUphYbAcrlCVD0jhZ69yQuWSGJkHgYsECM9NJjdypsypb8FOgqWRSjcUCmxCJ6tXbnz68/+vPJcu0GLlUomN+VtYJ02q5GwdtGNeC7ZXZ73DbdhnwyckYq9lgqrVBxYBM9MIdKRxyvLIqOyWAc2rkCLoT7dCJ3M1YfI48hgUKtd8KjcqJrbnsRTeXwnOcXyicH1wJUnrwy896nlkGZavVhAcO45JdHkZhYvczGnWhBlNZjnr2278v1GP2YSPYWg+fhGJOcbLN0HeGjRvBdoORt8x6FUbsuOaj6A8wYgucuVPGT03uZfv9yMef9fCraKexwBHJXla3+HXn4SSdYceTMOGfWph975UyyVcsa6GFxMO10V/eu/fw7Yb4qgQZb9ZdDWJZsvXQ98NNYw7bXqprU3/QNjKRa9txZjdPbyU7yGs5aWZb5+RGlWucbYKX9XNx5r+B/NDkGazsjLVcwZi9EWzdYVg0Gc7G4UqMG6EzigaMSPzvhJB5TPGg/4/u2rm9mFH1CxmQOyzHtTiAy5KTWSgzqYaszDrxMSszBXhkZbaXXVZmV/hfNBMWM64O+bU4IOkddrjV4aMk2CcU6U9/e/Xu9Q8//b1kWcvVoGTLeyY7oUY5HsCaa/GPvdSiY2hM7lgImCl0vogY1+LgLFaMUp5xa89Kb9nKrLW/CvCXxe2oOUDqZDvmn+QuB4lpcBwQwNpH+okjs6Kk6ZFlTteVbCv7XhrRDqozMDnBcoAcFA/CsdFhuCqnJth9cPiubEjo5qhhR+TJtM+81WZ2ZeeANwS8qJCfsKxRYN1rD+UrHEH/Y0+YHvaqy1OoTyedizDIkcAT/LIf2mug8mV/jdJTZhrky+9c2zMI9xRR5GXNAmOnORCvCvNxv+ttvoNEYCqO7AmjPkApICNSiCwU/imtKBWlRaNI1WJ/VC/OczNRV9uP/plr0Ne8N2Iy0xqHrzunWXGbBRUIYCaeyofDzuk40ACRO8K2ezOyS8G4gkHiymq1ObrrrkDbmjhw5LSB0Us+9/77Ovm+pu8u8QVN3MS8Ist7odqeG8Oa93wtvpMaXMADLAdp0Eglx6bJjejXJdPDMJYosk7k+zXmKViNX/23YPIwGPh1kCqPBvt+FEaxmv3zX35GUt92ziRE8KBtXyQVYfbVCXsIbJtaFastIyRcvsF/OJ+MWQUTn3tM5tNODcgU/yPA7ZKkAju2vHKSjEWZrczYSHBhCIgBh/Q+lLGsZgs72aYX3jdv3n/35l1+HIPpgisb6lht14rdyCB/9nYYX4MWw72RzIprCLjDrvlyyL979f2/E3kLKWLh/dD84e1f8vtw+TchR1O2e20GfSpeox6x+qMv+bCz8UbJbBob47dI4YLLu+RjTSadQVpwsAjYgstCDb89JqLx1ZUY8wwnB+0bab/3LVed1EeUn8+A2H284arrQXcBFcJnGxyBGwAJ7ryItJ1Vi1aFOXOC2WBa6YybwUl/9fbD/RfM+KUZesjDJrFFHuekYWqnoKXhlyZ3g4qzdPiVGNubLi98lt41uwMA3/toTsh1eUBeaJmeIeYLDn4IC6asSYQ4EO+nnVBZ6ZEKdLNshwTfEfvjOylxOyad/D6X6xSNOGHOmDOX4taaEbfCgrwuvxTX88ga3orbMSuTmQgC8hbD/GReu5fej8PuzWgFx/ePPJogqS72P7OIzDIKiVaL3YcEiO9qNdY33IhX+FMOKuJa2w9G5EUIFy2p6XugM621nLI6/rO8157EnLzjkI+TU3Lj5FnJAoGJ+0LdR0bEbaQ/vuL6ykQKJKyXOnein8nTlDCWhIF8O26S9JohFfb/mV6LBcJq1PwheTbr+dLI4PzS3+Cc+9TOn7nufgD7eI+sDtjRuenbcN1hU5qiBPut25J1ZkQfxOi2SXIvnRmbeydjwuhkvYOOwPy2VA2gz8ihXeKEwYPOiQkIrDC6LUj8zCgVWZJjfTszns6lJPTNaeYyBl2yy2Ho81l+5TMSLH75rNViYgmRf55Zhc1UqusoUwhcB0kjmplmglrFuy5aXHzI80EL8W0vuNrvkuKCzX6UfelF0MneqIWYyx59JSizExy9xWY4RADdhoCr+GsssNHnJNAt2aDEbXtXUnDx/OUumKdkIVlvPvM/HMsBC3fu4eV29Xk4HZMk7ACo6G0nNRn88j65dsugiYtVXKgFnnjWJnzyUuMOBb+Tph0+Cn14dPYoOnED/dz3jcuwNf0wXO93uf2O4t1QDO1cJviLmEvyx0Fd4SJAv8Op5uh0IYgkYN7Ly5KNYruDIAt+3Y43mu9KdiP4tRZrrA6BNkggQR4eTvjFLeTg3SzAKy3A7LDZyaZPD3LjU4XpiYv7Wv2Ay7PW70oP+x2d0E5zDJA3ouxCZX2PbD+un/431BSYvdbDFR8FmMGsqDbiNo8D7oX8QwYJqKxkX0HS9FyeyScvnj+nDJXE4IOrK5E/L1kvFHQpSsipFYWz01qMUovck549Zt+JXoxSXbFur+Gf2DOX6iPvZcdHYXANeBj4tN2I9hq6wgYRqjMVeyd2PT8QQDgcGW7A6nq99uuwhzMPYOsoePeSCd5umBbtoDsCDCLOLiFwEB3RswJobuBiMiazrZnzh1wfcSvNaHLbbP1xcNrZsBPKfS8ZckSqq9rypADGk/K3bicQtpeKik/iBsKxdF5upESgu3VlASfs5xI2efYcGP8C/vN7+M9/wH/+AP/5z6wAmzpJ0FESGIqu3LwLZxFviEshu+12PRE4c9gEtVDHIrtAWWwtIufX0c/tnnwW6gUEB1PtMe2fQvazg1823Jis8JA3mGj02P2uxlSdB+hDEwsdlWCA58DckVOA/5G/mfS2ShQ4L9LOck1fKtRJyL7gyLz68ecP/2vVVfXq1f+8ef8hUICxSy34tf/TxQMzLjgCdVIDqadrCpR0okw77I1ag0YUV1emZL+8+ZlBhHCw7DbP7ClpJ25L1m5kTydTrlZtK7aXQpuNpB0GEk4yeqd80vqW8J+JTthxd0vMPeRl0B0kmx8KdklQ/GfUgReKUQbl/Tho2tuz3Ekcz8MgVnsTVG2vO/gNc9QzU5djpACeBJwzzU2hPZZeMJFUQFhn3iI9tZvYRlS0vWtn9qo1mCf5yeUdScuXAeV4MCYqavY8fAplkzbuJJK8G27MMkVAIw1axEkll+Md/Lw2WxT1dLD4bidUZyGFklS2XHFqLXr1c5jL5ygQuMc/Dk9A4o93oULVWMnMtarzdxh5MqzdgG3tcL9ZcE6zLkxUR3NQJ+dv0uFixcdVyJi4NjNab66YmKwoY5/x7IjlGvbjbu9WRH9UN1qOIkfz1O23O+NKyJ6w7OJC0QKOpI2Wp/8cm7ngcsfW8iBF3yX8zueUtRJz/nxVLMsL5NfszrIuI4HydCXp/h701Gn5nkm2E+eZPkgUF6FLGxkYSn/jvrMaLPrCntTshVP2W34tOqlNvrRxUQfO5nIdg5IMI2ztSu2T/Hal4BRzqYxfbXBXp66n9aSSOSPXIZoeYaSmnWa7EqMcxXZpssfsnfgotJGXvaAqAv5xkB2LSg/MTvQ9+JoaqnpxW2+42bB2gKNkqG+s2Cvebiy8dtjuBiUUOFHenQRTCBpHqLE/sGHNuPNcM4NzocHshboaN6yXWzlWM0t3YtHY14OZMGju9ThNFyewLZkdkKmaI0Z6VUUssrnGaJfOJSMWxeAt31uHHFUi524qKFFFzyVILFFllaqYVLwjouDKm+GaUk7TFTmClCy7WcLY4Rn8uonOwj3x+eulCrRkQZYLYCTz2PZ5HrodYAvRI706j1QCrm5Jy+u4W/me0L5WvwK886kGXjls11qIT2Lm93hVAmyKo16Tk3lMssjfxy2VOzEEjerV7zccQ8jXXPZ7LXKfEnb3E5Cf1NVWdT5MVZept2O/kdMT4gmSWnKby1APAKl2uwaCXqZ/2gKTNJkdIgjyJSYrLCghgT3cSkjOaBmD7qQNSkd9sOsJmE7kweJ8DvbFjixWzkG4uZ+we/nOz22c+c8Mj0wy8kcoH/GvZSs7q6tMCzSdEf9F7iBYqZrG9MNomia+SoArtUo0rWk/dxcA4i6rVWlX8MUYkHiiMeGRyIE9JEeuy2nWoACdY8/KKYN7sybwJJ72C6463hbO9aBN1Qvl3b+4bgP7HjfnTvqCaqMP7Gv2/Mz9flJPYDkD+Jx9XUcjQie7mjcQxZJD7iZack1PbYdTOtNmoCKP1Ob+La0xrK4XpFmJm6bJJ9+tJ+Br97w40zRnS+eVdjtBnWDhwwDcXKBzt7AFbXqXtubK2ki8WEYOR80yyNA1WAPoYURVbD5Kme0pF37FFg2bT4UFsEDHMp9yDJwrziI7Y/t582IE7/1265phvTZi9N7gj3zEtCD4hFSyCY4hHMB8FMwMGtKUkBtu+31HGctdL1s+CrYReG+H4JnKwnuPCd+W99w1PXOI77jUWFDpnES9V6aE3KViW6GvBBtvBgZFZ1jKRxBtwngj+O4fRDJy/91xLTNCS8xWkqHBFfOPlg3G2XY1KLid09vu9PF4zRnGENiz8JzEaXzoEG2Hh5mAROkSkmcPCBwjJXgqMTJzRX1645PcPQW+uvQGazd7POQ6X4VYMrWMgKlLUSd+ih1cWZ1uNTAJhhU0r61WUYIWMuU4soCt9F9/8O4Scs7guQ51KJ1okrNavKQJ/S0qCxC/nt05OlpwCqLday2iHI3Nj1qmP/Xtf2QvHK69WI+2XkHLq83oSnXyI+KEycGCjC7+xuSfBVz6GZ6wF0WS/kURiyZbFDFoL6lrQOZIX+yQUhx3V4V7MM+nfmri3sJEUPN8shPOUCwTP0o9+kUVL8PHgH7x0tOkZr+PojPgydmMREfIbmEUxb08+VOuPJsI9PGkSrBiiUJ+SdujCVqY1ZFK9oMjR2jiob5MhkbDPtdDwWRm7xRLlPyXa1Izs/uUllZekp1JQp0ZaHZn4vhIJnq2b4roqCNNJn/28inkwYt3xwIeV3BF5TWhOMhfV7tH5sU5D3EhsR1PDqxF9i/iQN5XyHRMXK9k1Hns7J4S8QWxTTyv2AG1M8x8CSiEDAuDao013/djKOsk4YlAEXqxkLr1uV4Who1w90r+Yy8aPEPRaCboRxJ0GoGB8SxABImk0xepmBvpqU8tnvw+uwM/z7HRWkBypvCLxeqT3DVI7dynRCN0wksRFEiDwgHpiO7Gnzu/9dsBbnmOUPhmqsbW8zbNCmrfcByAWAyI6RzqLXlmkF6ttDBD/xHLcVknoW7mai/NRhgmbsFLkyOl9UjcobZACrwu1QlNDttj9s0eiALnx63FLDqtYkbxndkMcAVhDclYpAy4gVwdbEWEGRhn9vyfPUYJ3EOpm+jcIM56Dvf4lDCj6Cx4ZpEHXHkLSUJunNv5y5uf/TmZd0As4TG+g3wzMW8x8vMuM5EURlvi5mnPIqqbNOe2NxaUrqK3LSpkfUNKt+fby46f0RB7NGgJG1fakoLgHcgbU+KGjcPuaS8+it7LZQWXHaVma6nNyNyhxWPGey14d2BDi7YLZZmrwFKiX4l5WUsw8r/wjuQWHGhgp1DdfYlI8p6S5kJZ4CCXBrPgUegFirxq3gnefy/Gb6HggySX+mI5D6uhuqTCL7mrGqk6ASnh3NaaQJ0wqaA8mcwWT/gqcyCIhYeBegCc4XFRzda7CjrlcFOpabsiK6rLoTvAkUUC6XK/XuNilmCt4XxPDtU3EPa9+SkH2BNIKAncGHmltuQwLgFCHQoG5cMAQer5bZBNVrPbFCSZ8cadNSzByzLg4iep1gPFthStOV+X0oWWpSVk9WsSUxpyRv+kfjldQaOGEx5J0rIAJsvSxZAt9bfD3wnyY2Atb4dOfNBcmfWgty7rCkwDTUd8MbZuB/5FehjnkWNWVxo5Nn9C4jsrBHcbbPpow3cipp9y9x7Qa6TWesrAOClJM4cIz9onH2nGYFLZTFObsKKHQqH1x3AcRWaQYIHtsDv45yZmIjy9pHEjVTfc5Otdyeb7wxIxdgEUXiqOif560HOKQx1/QmxYUizN8XIsOx+2mkSwK0xkRCmMk2vAoVdCCS3bBhfhBYJk9O9IlKMZbluOCvRKEt3uO7F6y6UCc1gnAxxM0kgED55sePrCgZKffAF6AAKSAQ22Ch9Kk/Dvr9lzSvpu4YxJfppNTwv3B9oBz6AToyPKMOHTGiPxeT7KPhrl1LmmXczq+cYuZko/HVMR6aMutuYyn/TDbVNOR9tNMPuOW3X2lWSsgGKm/EXJ6P/gwmgWabjsZK68iEvc7btgtjjhr6FWOnJUIqtP2GQRSXz9nruWnFi5qmmu+uGS96ZpyiObtiYxxZvst6LNwUmDy26wSdbyttlKY6S6Ck/PJKQuWfY1gA1lagnGf4QiIwAL55NTlF35IoQdDVyBdiGZd3sfs28HZUa9b6lw0TBzUO1GD2rYQ3EhuiGWUp2EqvB2w3quBNQu0uG++CgUu9kIFcoY7QDrdWgBzyfAIbTzXV5ab3IPzbAcQNAwkmq2V7ZmBH2fnRYfJSBzL+cFl0uax71XRtt16jWx2h2QxYdTrlew+5CmjIMGD4AGTCl+nk2RylZ5/HLaXWtwu2/pDmFS4uFD5yTuvw94S9ALxR6zvwixo2c5pFK2SgeTYG0kFiWDeB4/X0plY4cunN3jnq0CPMt+WwMLckWpON7xHZbMytEwwa+ERlHkV1R31LkKaYYJbIxuIGjbinEzdHEV8WtuRoyeoNn54rb3b/BbwyTktJJx+UXu7nR93Dmpc3iARgv+zre87+9pe5dcx3lpDzI/2M4qrgYLZWQPNdW28N4pi6hgIz6Lnk4bG+6HLAkThAgfTQG+RHd6TUecu3usKcT+ycQPWlhcXjx0olrvVVvi5H/yT82hHC91dBBRkvDgFkO/tLmSHR1LyXbMJh3gCAobIQ+A1ezYAWw/dsJrZtDhhR040uBrcbiBM76YjpMKqtN0RNkFFGqHey672tJ1kunJStaOt9gR3k3MIWMLiNXnHkf09BYgIQvm41cYCuEK6vNV8TAnEXgd/J5oPxeproj6WV/HNTpHJ+5hD5fjT9aViT/h/kvcmAd7Jd7ge8WYxYh7YQWy2v/QGQ7Qj+urnOurlLyFGz9zaoIKXPJoJmyuJ3+7bh5y7X+5JqdUavfjAd6QZ4Z3hRLqOCwSTyhZpFu162lZHhntuDVzrzLggxRJxjD4TCEByMQWzRkaLp/goWwNpoXs6Sgl99rR5fAIkvPjINPkU1xPgyUk0+rMNB/pAyaTh/2IhhQUp/nMNNGXT3+aVqOvWFOJOB3SeYdmkvylvqEO4I5FPCgv6K6axJnBcDASZ/Onk1l7Qzm6OOkfagop7xwSlp7Cjq6Jc2bX6QrR8yIk6KBcgC6+xsa+sp8xGhk3n5GTs4Bi/wYmuLeD82UdGu9Z3NfyP8hiJZY/2sTHPaeHmRUEGexKTMdiwqm4qw+jbXMRntVMbQsYjRcPNRbonUd30DKPyrEA1orEkr4P4+rw80Hxq1tjorKnOE5i1xhXF7laJMNDpAvX2kmSQu70lTvoi/mZgj/PLOBsFV7HcJmzhDy+eWlf2qcFaIfaCzEtV6erM/F1A3c0dmpdJbgsr+2F2iLW33gWhEv3gGLhTVQtnTv6q/WBYpCbgov3eNAa1YpOVHDalBgQp+SOH91GrwDGhFk8vI0WeyyjZ0+rppWr9nMIV5KrB9Qa+fz+LkLCiagkJpydy7V/U9nPlASd+MQyeMfhiWVIogR3alJ9Ho/Np8hHiYjZ41fJrHlS05iejE/PzekuHrzDvTeiaRZLDc58IXhSJA/0cZG/5QBikO6sgKLvS73gZcCHGyx3a7hyvI9t1p32ioqrWc0iX+++tut4gLcUsdlY7TUUfkO64js6Av/Ox27HQrPpNLOoKJrJtrnJQL9ld8d3lghfIsAjUMfjumQITP6gEO7fGlWDZB6Nqr3zn1IXFnmPeNrJ2peg+N2xdDIIV/Vlw+bg2sRujd3KqTMTx8iuhUSm9D3dgigY/v1DI+EjUfDMq5npjSXHhnCrHYopxWuP6f09nSMperrCkfg3iWsDGEq8euqShzZ5bHHHGJRUHr2YEB6TPmUbXa47eccLVTO/DA/xJNbfO+7Ra17xSxPHnvFK+sTvd0GlmNB54fkQHKzYP7FvNIXkRBopRjY4rmTzZIsWHd8LkgZcHP+iGR25RY5FHlnbOPWX1qBFroqbeToiieHY3ctZwP3eaB1/QetOtNwN+sn7G6xm/iEO3+Qu7oKD+xoq9nQV3rGg9ytNju+k2ksIdnflBb2tR2hMHjJxD5zA20T2QZppR5AgPNDz8Oz/N4pT76MswCiXXqErAqijmIXrWXg7IEtmDtfLfyOOC9fUPxfPTvSnp75Qj/71f68uTvAZaQAA";
+
+// packages/safe-bash-command-python/src/runtime-programs.ts
+var decoded3;
+function loadPythonRuntimePrograms() {
+  return decoded3 ??= new Response(new Blob([Uint8Array.from(atob(pythonRuntimeProgramsGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).json();
+}
+
+export {
+  PythonInvocationError,
+  parsePythonInvocation,
+  pythonPackageUrlHash,
+  installPythonPackages,
+  pythonExecution,
+  loadPythonRuntimePrograms
+};