sandboxedjs 0.1.76 → 0.1.77

package/dist/index.cjs

@@ -7819,7 +7819,7 @@ fi
 `;
 var MOTD = `Welcome to SandboxedJS \u2014 a Linux-like container running inside Node.js.
 
- * Node.js, npm and CPython (Pyodide) are preinstalled.
+ * Node.js, npm and CPython are preinstalled.
  * The filesystem is virtual: nothing here touches your host.
  * Run 'help' for the list of built-in commands.
 
@@ -19745,9 +19745,6 @@ function nodeCommands() {
   return [node, nodeVersionFile];
 }
 
-// src/python/python.ts
-init_path();
-
 // src/python/host-abi.ts
 var SBX_HOST_ABI_VERSION = 1;
 var SBX_REQUEST_HEADER_BYTES = 16;
@@ -20218,7 +20215,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.76"};
+  version: "0.1.77"};
 
 // src/python/config.ts
 function runtimeModuleUrl() {
@@ -20250,11 +20247,15 @@ var embeddedWheels = {
   "pydantic_core-2.23.2-cp313-cp313-emscripten_5_0_6_wasm32.whl": pydantic_core_2_23_2_cp313_cp313_emscripten_5_0_6_wasm32_default,
   "pydantic_core-2.46.5-cp313-cp313-emscripten_5_0_6_wasm32.whl": pydantic_core_2_46_5_cp313_cp313_emscripten_5_0_6_wasm32_default
 };
-var bundledWheelIndex = {
-  baseUrl: new URL("./wheels", runtimeModuleUrl()).href,
-  wheels: wheels_default.wheels,
-  files: embeddedWheels
-};
+function wheelIndexFor(moduleUrl) {
+  return {
+    baseUrl: new URL("./wheels", moduleUrl).href,
+    wheels: wheels_default.wheels,
+    files: embeddedWheels
+  };
+}
+var bundledWheelIndex = wheelIndexFor(runtimeModuleUrl());
+var wheelIndexIsExplicit = false;
 var config = {
   backend: "sbx-cpython-wasm",
   manifest: bundledManifest,
@@ -20269,9 +20270,17 @@ var config = {
   buildFromSource: typeof process !== "undefined" && Boolean(process.versions?.node) && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)).startsWith("file:")
 };
 function setPythonBackend(options) {
-  if (options.wheelIndex !== void 0) config.wheelIndex = options.wheelIndex;
+  if (options.wheelIndex !== void 0) {
+    config.wheelIndex = options.wheelIndex;
+    wheelIndexIsExplicit = true;
+  }
   if (options.buildFromSource !== void 0) config.buildFromSource = options.buildFromSource;
-  if (options.manifest !== void 0) config.manifest = validateManifest(options.manifest);
+  if (options.manifest !== void 0) {
+    config.manifest = validateManifest(options.manifest);
+    if (!wheelIndexIsExplicit) {
+      config.wheelIndex = wheelIndexFor(config.manifest.artifacts.moduleUrl);
+    }
+  }
   if (options.workerUrl !== void 0) config.workerUrl = options.workerUrl;
   if (options.backend !== void 0) {
     if (options.backend === "sbx-cpython-wasm" && !config.manifest) {
@@ -22789,6 +22798,7 @@ async function installRequirements(options) {
     }
     options.progress.downloading(distribution.name, distribution.version);
     const bytes2 = await options.client.bytes(distribution.url, { timeoutMs: 12e4 });
+    requireArchive(distribution, bytes2);
     verifyDigest(distribution, bytes2);
     staged.push(...stageWheel(readZip(bytes2)));
     installed2.push({ name: distribution.name, version: distribution.version });
@@ -22796,6 +22806,14 @@ async function installRequirements(options) {
   commit(options.vfs, options.cred, staged);
   return { installed: installed2, skipped: solved.skipped };
 }
+function requireArchive(distribution, bytes2) {
+  if (bytes2.length > 1 && bytes2[0] === 80 && bytes2[1] === 75) return;
+  const opening = new TextDecoder().decode(bytes2.subarray(0, 80)).replace(/\s+/g, " ").trim();
+  const looksLikeMarkup = /^<!doctype|^<html/i.test(opening);
+  throw new Error(
+    `${distribution.filename} did not arrive as a wheel from ${distribution.url}: ` + (looksLikeMarkup ? "the server answered with an HTML page, which usually means the wheel is not published at that address and the server returned its index page instead" : `expected a zip archive, got ${bytes2.length} bytes beginning ${JSON.stringify(opening)}`)
+  );
+}
 function verifyDigest(distribution, bytes2) {
   if (!distribution.sha256) {
     throw new Error(
@@ -23080,9 +23098,6 @@ async function resolveWorkerUrl(explicit) {
     "the SandboxedJs Python process worker has not been built; run `npm run build` in the package, or pass configurePython({ workerUrl })."
   );
 }
-function usingOwnedPython() {
-  return pythonBackend().backend === "sbx-cpython-wasm";
-}
 async function runOwnedPython(ctx, argv) {
   const { manifest, workerUrl } = pythonBackend();
   if (!manifest) throw new Error("no Python runtime manifest is configured");
@@ -23571,6 +23586,75 @@ function listInstalled(ctx) {
   return 0;
 }
 
+// src/python/python.ts
+var PYTHON_VERSION = "3.13";
+function configurePython(options = {}) {
+  setPythonBackend({
+    ...options.backend !== void 0 ? { backend: options.backend } : {},
+    ...options.manifest !== void 0 ? { manifest: options.manifest } : {},
+    ...options.workerUrl !== void 0 ? { workerUrl: options.workerUrl } : {},
+    ...options.wheelIndex !== void 0 ? { wheelIndex: options.wheelIndex } : {},
+    ...options.buildFromSource !== void 0 ? { buildFromSource: options.buildFromSource } : {}
+  });
+}
+async function isPythonAvailable() {
+  return pythonBackend().manifest !== null;
+}
+function withTopLevelAwait(source) {
+  if (!/\bawait\b/.test(source)) return source;
+  return `import ast as _sbx_ast, inspect as _sbx_inspect
+_sbx_src = ${JSON.stringify(source)}
+try:
+    _sbx_code = compile(_sbx_src, "<string>", "exec")
+except SyntaxError:
+    _sbx_code = compile(_sbx_src, "<string>", "exec", _sbx_ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
+_sbx_async = bool(_sbx_code.co_flags & _sbx_inspect.CO_COROUTINE)
+_sbx_globals = globals()
+for _sbx_name in ("_sbx_ast", "_sbx_inspect", "_sbx_src", "_sbx_name"):
+    _sbx_globals.pop(_sbx_name, None)
+if _sbx_async:
+    import asyncio as _sbx_asyncio
+    _sbx_asyncio.run(eval(_sbx_code, _sbx_globals))
+else:
+    exec(_sbx_code, _sbx_globals)
+`;
+}
+function withTopLevelAwaitArgs(args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-c") {
+      if (i + 1 >= args.length) return args;
+      const rewritten = withTopLevelAwait(args[i + 1]);
+      if (rewritten === args[i + 1]) return args;
+      const copy = [...args];
+      copy[i + 1] = rewritten;
+      return copy;
+    }
+    if (arg === "-m" || !arg.startsWith("-") || arg === "-") return args;
+  }
+  return args;
+}
+var python = defineCommand({
+  name: "python3",
+  path: "/usr/bin/python3",
+  aliases: ["python"],
+  summary: "run CPython",
+  usage: "python3 [-c command | -m module | script.py] [arguments]",
+  manual: `CPython built for WebAssembly, one interpreter per process. Scripts
+use the container's virtual filesystem, modules in /workspace are importable,
+and packages are installed with pip.`,
+  async run(ctx) {
+    try {
+      return await runOwnedPython(ctx, withTopLevelAwaitArgs(ctx.args));
+    } catch (error) {
+      return ctx.fail(error.message ?? String(error));
+    }
+  }
+});
+function pythonCommands() {
+  return [python, pipCommand];
+}
+
 // src/fs/emscripten-fs.ts
 init_errno();
 init_path();
@@ -23826,1301 +23910,6 @@ function mountContainerFs(FS, opts) {
   }
 }
 
-// src/python/cpython.ts
-init_binary();
-
-// src/python/python-syscalls.ts
-var EMPTY = new Uint8Array(0);
-function createStdinHost(ctx) {
-  let pending = EMPTY;
-  let eof = false;
-  const take = (size) => {
-    const n = Math.min(size, pending.length);
-    const out = pending.subarray(0, n);
-    pending = pending.subarray(n);
-    return out;
-  };
-  return {
-    /**
-     * Drain a non-interactive stdin up front.
-     *
-     * A pipe ends, so reading it eagerly costs nothing and leaves every read
-     * answerable without suspending — which is what keeps piped input working
-     * on hosts with no stack-switching. A terminal never ends, so priming one
-     * would hang before the program had printed its prompt.
-     */
-    async prime() {
-      if (ctx.stdin.isTTY || ctx.stdin.interactive) return;
-      try {
-        pending = await ctx.stdin.readAll();
-      } catch {
-        pending = EMPTY;
-      }
-      eof = true;
-    },
-    buffered(size) {
-      if (pending.length > 0) return take(size);
-      return eof ? EMPTY : void 0;
-    },
-    async read(size) {
-      if (pending.length > 0) return take(size);
-      if (eof) return EMPTY;
-      const chunk = await ctx.stdin.read(size);
-      if (chunk === null || chunk.length === 0) {
-        eof = true;
-        return EMPTY;
-      }
-      pending = chunk;
-      return take(size);
-    },
-    isatty() {
-      return Boolean(ctx.stdin.isTTY);
-    }
-  };
-}
-var BRIDGE_PY = `
-import builtins, io, sys
-import _sbx_host as _host
-from pyodide.ffi import can_run_sync, run_sync
-
-
-def _to_bytes(value):
-    if value is None:
-        return b""
-    to_bytes = getattr(value, "to_bytes", None)
-    if to_bytes is not None:
-        return to_bytes()
-    return bytes(value.to_py())
-
-
-class _SbxStdin(io.RawIOBase):
-    """The container's standard input, as a blocking raw stream."""
-
-    def readable(self):
-        return True
-
-    def fileno(self):
-        return 0
-
-    def isatty(self):
-        return bool(_host.isatty())
-
-    def readinto(self, target):
-        want = len(target)
-        if want == 0:
-            return 0
-        ready = _host.buffered(want)
-        if ready is None:
-            if not can_run_sync():
-                raise OSError(
-                    "this host cannot wait for interactive input: WebAssembly "
-                    "stack switching (JSPI) is unavailable. Pipe the input in, "
-                    "or use a browser or Node build that supports it."
-                )
-            ready = run_sync(_host.read(want))
-        data = _to_bytes(ready)
-        target[: len(data)] = data
-        return len(data)
-
-
-def _install():
-    stdin = io.TextIOWrapper(
-        io.BufferedReader(_SbxStdin()), encoding="utf-8", errors="replace", line_buffering=True
-    )
-    sys.stdin = stdin
-    sys.__stdin__ = stdin
-
-    def input(prompt=""):
-        # CPython writes the prompt to stdout and strips exactly one trailing
-        # newline; anything else changes what a program reads back.
-        if prompt != "":
-            sys.stdout.write(str(prompt))
-            sys.stdout.flush()
-        line = sys.stdin.readline()
-        if not line:
-            raise EOFError("EOF when reading a line")
-        if line.endswith("\\n"):
-            line = line[:-1]
-        if line.endswith("\\r"):
-            line = line[:-1]
-        return line
-
-    builtins.input = input
-
-
-_install()
-`;
-var PROCESS_PY = `
-import io, os, shlex, subprocess, sys
-import _sbx_host as _host
-from pyodide.ffi import can_run_sync, run_sync
-
-_PIPE = subprocess.PIPE
-_DEVNULL = subprocess.DEVNULL
-_STDOUT = subprocess.STDOUT
-
-
-def _argv_for(args, shell):
-    if shell:
-        line = args if isinstance(args, str) else " ".join(str(a) for a in args)
-        return ["sh", "-c", line]
-    if isinstance(args, (str, bytes)):
-        return shlex.split(args if isinstance(args, str) else args.decode())
-    return [str(a) for a in args]
-
-
-def _require_blocking(what):
-    if not can_run_sync():
-        raise OSError(
-            "cannot " + what + " on this host: WebAssembly stack switching "
-            "(JSPI) is unavailable."
-        )
-
-
-def _to_bytes_result(value):
-    if value is None:
-        return b""
-    to_bytes = getattr(value, "to_bytes", None)
-    return to_bytes() if to_bytes is not None else bytes(value.to_py())
-
-
-class _ChildReader(io.RawIOBase):
-    """One of a running child's output streams.
-
-    Reads suspend only for as long as the child takes to produce the next
-    bytes, so \`for line in p.stdout\` follows a child that is still running
-    instead of waiting for it to exit.
-    """
-
-    def __init__(self, child_id, which):
-        self._id = child_id
-        self._which = which
-
-    def readable(self):
-        return True
-
-    def readinto(self, target):
-        want = len(target)
-        if want == 0:
-            return 0
-        _require_blocking("read from a child process")
-        data = _to_bytes_result(run_sync(_host.proc_read(self._id, self._which, want)))
-        target[: len(data)] = data
-        return len(data)
-
-
-class _ChildWriter(io.RawIOBase):
-    """A running child's standard input."""
-
-    def __init__(self, child_id):
-        self._id = child_id
-
-    def writable(self):
-        return True
-
-    def write(self, data):
-        if isinstance(data, str):
-            text = data
-        else:
-            text = bytes(data).decode("utf-8", "replace")
-        _host.proc_write(self._id, text)
-        return len(data)
-
-    def close(self):
-        if not self.closed:
-            _host.proc_close_stdin(self._id)
-        super().close()
-
-
-class SbxPopen:
-    """A child process, run through the container's kernel.
-
-    The child is a real, live process: it starts when \`Popen\` is constructed
-    and runs on the host's event loop while Python carries on. The parent only
-    suspends when it actually reads, waits, or communicates \u2014 which is what
-    makes streaming from a long-running child work rather than deadlocking on
-    a single interpreter stack.
-    """
-
-    def __init__(self, args, bufsize=-1, executable=None, stdin=None, stdout=None,
-                 stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None,
-                 env=None, universal_newlines=None, startupinfo=None, creationflags=0,
-                 restore_signals=True, start_new_session=False, pass_fds=(), *,
-                 text=None, encoding=None, errors=None, **kwargs):
-        self.args = args
-        self.returncode = None
-        self._text = bool(text or encoding or errors or universal_newlines)
-        self._encoding = encoding or "utf-8"
-        self._errors = errors or "replace"
-        self._merge_err = stderr == _STDOUT
-        self._closed = False
-
-        argv = _argv_for(args, shell)
-        env_map = None if env is None else {str(k): str(v) for k, v in dict(env).items()}
-        self._id = _host.proc_start(
-            argv, None if cwd is None else str(cwd), env_map, self._merge_err
-        )
-        self.pid = int(_host.proc_pid(self._id))
-
-        self.stdin = self._wrap_writer() if stdin == _PIPE else None
-        self.stdout = self._wrap_reader(1) if stdout == _PIPE else None
-        # When merged there is only one stream, and it is stream 1.
-        self.stderr = self._wrap_reader(2) if stderr == _PIPE and not self._merge_err else None
-
-        # Output nobody captured belongs on the parent's own streams, or a
-        # program's diagnostics would vanish rather than being seen.
-        self._drain_out = stdout is None
-        self._drain_err = stderr is None and not self._merge_err
-
-    def _wrap_reader(self, which):
-        raw = io.BufferedReader(_ChildReader(self._id, which))
-        if self._text:
-            return io.TextIOWrapper(raw, encoding=self._encoding, errors=self._errors)
-        return raw
-
-    def _wrap_writer(self):
-        raw = io.BufferedWriter(_ChildWriter(self._id))
-        if self._text:
-            return io.TextIOWrapper(raw, encoding=self._encoding, errors=self._errors)
-        return raw
-
-    def _read_all(self, which):
-        _require_blocking("read from a child process")
-        parts = []
-        while True:
-            chunk = _to_bytes_result(run_sync(_host.proc_read(self._id, which, 65536)))
-            if not chunk:
-                break
-            parts.append(chunk)
-        return b"".join(parts)
-
-    def _decode(self, raw):
-        return raw.decode(self._encoding, self._errors) if self._text else raw
-
-    def communicate(self, input=None, timeout=None):
-        if input is not None and self.stdin is not None:
-            if isinstance(input, bytes):
-                input = input.decode(self._encoding, "replace")
-            self.stdin.write(input)
-        if self.stdin is not None:
-            try:
-                self.stdin.close()
-            except Exception:
-                pass
-
-        out = self.stdout.read() if self.stdout is not None else None
-        err = self.stderr.read() if self.stderr is not None else None
-        self.wait()
-        self._flush_uncaptured()
-        return out, err
-
-    def _flush_uncaptured(self):
-        if self._drain_out:
-            text = self._decode_raw(self._read_all(1))
-            if text:
-                sys.stdout.write(text)
-        if self._drain_err:
-            text = self._decode_raw(self._read_all(2))
-            if text:
-                sys.stderr.write(text)
-        self._drain_out = False
-        self._drain_err = False
-
-    def _decode_raw(self, raw):
-        return raw.decode(self._encoding, "replace")
-
-    def poll(self):
-        code = _host.proc_poll(self._id)
-        if code is not None:
-            self.returncode = int(code)
-        return self.returncode
-
-    def wait(self, timeout=None):
-        _require_blocking("wait for a child process")
-        self.returncode = int(run_sync(_host.proc_wait(self._id)))
-        return self.returncode
-
-    def kill(self):
-        self.send_signal("SIGKILL")
-
-    def terminate(self):
-        self.send_signal("SIGTERM")
-
-    def send_signal(self, sig):
-        _host.proc_kill(self._id, sig if isinstance(sig, str) else "SIGTERM")
-
-    def __del__(self):
-        try:
-            _host.proc_release(self._id)
-        except Exception:
-            pass
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        if self.stdin is not None:
-            try:
-                self.stdin.close()
-            except Exception:
-                pass
-        self.wait()
-        self._flush_uncaptured()
-        for stream in (self.stdout, self.stderr):
-            if stream is not None:
-                try:
-                    stream.close()
-                except Exception:
-                    pass
-        # The host holds the process and its pipes until it is told the child
-        # is finished with; a loop spawning children would otherwise keep every
-        # one of them alive. Safe here only because the child has been waited
-        # for and everything anyone wanted has been read.
-        _host.proc_release(self._id)
-        return False
-
-
-def _system(command):
-    with SbxPopen(command, shell=True) as child:
-        pass
-    # os.system returns a wait status, not an exit code.
-    return (child.returncode or 0) << 8
-
-
-def _popen(command, mode="r", buffering=-1):
-    if "w" in mode:
-        raise OSError("os.popen with mode 'w' is not supported in this container")
-    child = SbxPopen(command, shell=True, stdout=_PIPE, text=True)
-    stream = child.stdout
-    inner = stream.close
-
-    def close():
-        inner()
-        code = child.wait()
-        return None if code == 0 else code << 8
-
-    stream.close = close
-    return stream
-
-
-def _install_processes():
-    subprocess.Popen = SbxPopen
-    os.system = _system
-    os.popen = _popen
-
-
-_install_processes()
-`;
-var ASYNCIO_PY = `
-import asyncio
-from pyodide.ffi import can_run_sync, run_sync
-
-_orig_run = asyncio.run
-
-
-def _run(main, *, debug=None, loop_factory=None):
-    if not asyncio.iscoroutine(main) and not asyncio.isfuture(main):
-        raise ValueError("a coroutine was expected, got {!r}".format(main))
-    if not can_run_sync():
-        # No stack switching: the original at least raises a comprehensible
-        # error rather than this shim inventing a new one.
-        return _orig_run(main, debug=debug, loop_factory=loop_factory)
-    return run_sync(main)
-
-
-def _run_until_complete(self, future):
-    if not can_run_sync():
-        raise RuntimeError(
-            "cannot wait for a coroutine on this host: WebAssembly stack "
-            "switching (JSPI) is unavailable."
-        )
-    return run_sync(future)
-
-
-async def _create_server(self, *args, **kwargs):
-    # Pyodide's loop raises a bare NotImplementedError from deep inside
-    # asyncio, which tells a reader nothing about why their server will not
-    # start. Naming the limit is the least this can do until the container can
-    # route connections to Python.
-    raise NotImplementedError(
-        "this container cannot yet accept network connections from Python: "
-        "asyncio's create_server is not implemented on Pyodide's event loop, "
-        "so an ASGI/WSGI server such as uvicorn will install and import but "
-        "not bind a port. Outbound requests do work."
-    )
-
-
-def _install_asyncio():
-    asyncio.run = _run
-    asyncio.runners.run = _run
-    loop_type = type(asyncio.get_event_loop())
-    loop_type.run_until_complete = _run_until_complete
-    loop_type.create_server = _create_server
-
-
-_install_asyncio()
-`;
-var NETWORK_PY = `
-import builtins, email.message, io, sys, urllib.error, urllib.request, urllib.response
-import _sbx_host as _host
-from pyodide.ffi import can_run_sync, run_sync
-
-
-def _fetch(request):
-    if not can_run_sync():
-        raise urllib.error.URLError(
-            "cannot make a request on this host: WebAssembly stack switching "
-            "(JSPI) is unavailable."
-        )
-    body = request.data
-    if isinstance(body, str):
-        body = body.encode()
-    try:
-        result = run_sync(
-            _host.http(
-                request.full_url,
-                request.get_method(),
-                [[k, v] for k, v in request.header_items()],
-                body,
-            )
-        )
-    except Exception as error:
-        raise urllib.error.URLError(str(error)) from None
-
-    headers = email.message.Message()
-    for pair in result.headers.to_py():
-        headers[str(pair[0])] = str(pair[1])
-    payload = result.body.to_bytes()
-    response = urllib.response.addinfourl(
-        io.BytesIO(payload), headers, str(result.url), int(result.status)
-    )
-    response.msg = str(result.statusText)
-    return response
-
-
-class _SbxHTTPHandler(urllib.request.HTTPHandler):
-    """Both schemes, from one handler.
-
-    Pyodide builds urllib without \`ssl\`, so \`HTTPSHandler\` does not exist to
-    subclass \u2014 and https is the scheme most callers actually want. Serving
-    both from a subclass of the one handler that does exist keeps
-    \`build_opener\` treating this as a replacement rather than stacking it
-    alongside the original.
-    """
-
-    def http_open(self, request):
-        return _fetch(request)
-
-    def https_open(self, request):
-        return _fetch(request)
-
-    https_request = urllib.request.HTTPHandler.do_request_
-
-
-def _raw_fetch(url, method, headers, body):
-    """One request, through the container's network path."""
-    if not can_run_sync():
-        raise urllib.error.URLError(
-            "cannot make a request on this host: WebAssembly stack switching "
-            "(JSPI) is unavailable."
-        )
-    if isinstance(body, str):
-        body = body.encode()
-    result = run_sync(
-        _host.http(url, method, [[str(k), str(v)] for k, v in dict(headers).items()], body)
-    )
-    return {
-        "status": int(result.status),
-        "reason": str(result.statusText),
-        "headers": [(str(p[0]), str(p[1])) for p in result.headers.to_py()],
-        "body": result.body.to_bytes(),
-        "url": str(result.url),
-    }
-
-
-# \u2500\u2500 Routing third-party HTTP stacks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-#
-# A library that brings its own transport does not go through urllib, and in
-# Pyodide several of them reach JavaScript's fetch directly \u2014 which leaves the
-# container's network policy behind entirely. They cannot all be patched at
-# boot either, because pip installs them later.
-#
-# So: adapters are registered by module name and applied the moment that module
-# is first imported, whenever that happens. Supporting another stack is a small
-# function registered here, not a change to the machinery.
-
-_ADAPTERS = {}
-
-
-def _register_adapter(name):
-    def decorate(fn):
-        _ADAPTERS[name] = fn
-        return fn
-
-    return decorate
-
-
-def _apply_adapter(name):
-    fn = _ADAPTERS.pop(name, None)
-    if fn is None:
-        return
-    try:
-        fn()
-    except Exception:
-        # A stack we cannot adapt must not stop the import that triggered it.
-        pass
-
-
-def _install_import_hook():
-    real_import = builtins.__import__
-
-    def hooked(name, globals=None, locals=None, fromlist=(), level=0):
-        module = real_import(name, globals, locals, fromlist, level)
-        root = name.split(".")[0] if level == 0 else None
-        if root in _ADAPTERS:
-            _apply_adapter(root)
-        return module
-
-    builtins.__import__ = hooked
-
-
-@_register_adapter("requests")
-def _adapt_requests():
-    """Replace the transport, not the API.
-
-    \`HTTPAdapter.send\` is the single seam every requests call passes through,
-    below sessions, redirects, cookies and retries and above the urllib3
-    transport that would otherwise reach the network on its own. Replacing it
-    leaves everything callers actually use intact.
-    """
-    import requests
-    from requests.adapters import HTTPAdapter
-    from requests.structures import CaseInsensitiveDict
-
-    native_send = HTTPAdapter.send
-
-    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
-        if not can_run_sync():
-            # Without stack switching this transport cannot run at all. Falling
-            # back to the library's own is better than breaking requests on
-            # such a host \u2014 but the container's network policy is not the part
-            # that degrades, so a forbidden host is still refused.
-            if not _host.policy_allows(request.url):
-                raise requests.exceptions.ConnectionError(
-                    "outbound network access is disabled for this container "
-                    "(enable with network: { allowOutbound: true })"
-                )
-            return native_send(self, request, stream, timeout, verify, cert, proxies)
-        try:
-            result = _raw_fetch(request.url, request.method, request.headers, request.body)
-        except Exception as error:
-            raise requests.exceptions.ConnectionError(str(error)) from None
-        response = requests.Response()
-        response.status_code = result["status"]
-        response.reason = result["reason"]
-        response.headers = CaseInsensitiveDict(result["headers"])
-        response.url = result["url"]
-        response.request = request
-        response.raw = io.BytesIO(result["body"])
-        response.encoding = requests.utils.get_encoding_from_headers(response.headers)
-        return response
-
-    HTTPAdapter.send = send
-
-
-def _install_network():
-    urllib.request.HTTPHandler = _SbxHTTPHandler
-    urllib.request.HTTPSHandler = _SbxHTTPHandler
-    urllib.request.install_opener(urllib.request.build_opener(_SbxHTTPHandler))
-    _install_import_hook()
-    for already_imported in [n for n in _ADAPTERS if n in sys.modules]:
-        _apply_adapter(already_imported)
-
-
-_install_network()
-`;
-async function httpForPython(slot, url, method, headers, body) {
-  const current = slot.current;
-  if (!current) throw new Error("no program is bound");
-  const result = await performRequest(current.ctx, new URL(url), {
-    method,
-    headers: Object.fromEntries(headers),
-    ...body ? { body } : {}
-  });
-  return {
-    status: result.status,
-    statusText: result.statusText,
-    headers: Object.entries(result.headers),
-    body: result.body,
-    url: result.url
-  };
-}
-async function resuming(py, slot, work) {
-  const parent = slot.current;
-  try {
-    return await work();
-  } finally {
-    if (parent && slot.current !== parent) bindProgram(py, parent);
-  }
-}
-function installSyscallBridge(py) {
-  const slot = py.__sbxSlot ??= { current: null };
-  const children = /* @__PURE__ */ new Map();
-  let lastChildId = 0;
-  py.registerJsModule("_sbx_host", {
-    /* Not `?.` and `??`: `buffered` returns undefined to mean "you will have
-     * to wait", and a nullish default would quietly turn that into end-of-file —
-     * which is exactly the silent EOF this bridge exists to remove. */
-    buffered: (size) => slot.current ? slot.current.stdin.buffered(size) : EMPTY,
-    read: (size) => slot.current ? slot.current.stdin.read(size) : Promise.resolve(EMPTY),
-    isatty: () => slot.current?.stdin.isatty() ?? false,
-    proc_start: (argv, cwd, env2, merge) => {
-      const current = slot.current;
-      if (!current) throw new Error("no program is bound");
-      const { ctx } = current;
-      const stdin = new Pipe();
-      stdin.interactive = true;
-      const stdout = new Pipe();
-      const stderr = merge ? stdout : new Pipe();
-      const proc = ctx.kernel.spawn(argv, {
-        cwd: cwd ?? ctx.cwd,
-        env: env2 ?? ctx.env,
-        cred: ctx.cred,
-        stdin,
-        stdout,
-        stderr
-      });
-      void proc.wait().then(() => {
-        stdout.end();
-        if (stderr !== stdout) stderr.end();
-      });
-      const id = ++lastChildId;
-      children.set(id, { proc, stdin, stdout, stderr });
-      return id;
-    },
-    proc_read: (id, which2, size) => {
-      const child = children.get(id);
-      if (!child) return Promise.resolve(EMPTY);
-      const pipe = which2 === 2 ? child.stderr : child.stdout;
-      return resuming(py, slot, async () => await pipe.read(size) ?? EMPTY);
-    },
-    proc_write: (id, text2) => {
-      children.get(id)?.stdin.write(text2);
-    },
-    proc_close_stdin: (id) => {
-      children.get(id)?.stdin.end();
-    },
-    /* Non-blocking on purpose: `poll()` must be able to say "still running". */
-    proc_poll: (id) => children.get(id)?.proc.exitCode ?? void 0,
-    proc_pid: (id) => children.get(id)?.proc.pid ?? 0,
-    proc_wait: (id) => {
-      const child = children.get(id);
-      if (!child) return Promise.resolve(0);
-      return resuming(py, slot, () => child.proc.wait());
-    },
-    proc_kill: (id, signal) => {
-      const child = children.get(id);
-      if (!child) return;
-      const current = slot.current;
-      current?.ctx.kernel.procs.signal(child.proc.pid, signal);
-    },
-    proc_release: (id) => {
-      children.delete(id);
-    },
-    http: (url, method, headers, body) => resuming(py, slot, () => httpForPython(slot, url, method, headers, body)),
-    /* So Python can enforce the container's policy even on a host where it
-     * cannot route the request itself. */
-    policy_allows: (url) => {
-      const current = slot.current;
-      if (!current) return false;
-      const net = current.ctx.kernel.net;
-      try {
-        return net.isLocal(new URL(url).hostname) || net.outboundAllowed(url);
-      } catch {
-        return false;
-      }
-    }
-  });
-  py.runPython(BRIDGE_PY);
-  py.runPython(PROCESS_PY);
-  py.runPython(NETWORK_PY);
-  py.runPython(ASYNCIO_PY);
-}
-function bindProgram(py, binding) {
-  py.__sbxSlot.current = binding;
-  const { ctx, stdin } = binding;
-  const decoder9 = new TextDecoder();
-  py.setStdout({
-    write: (buffer) => (ctx.write(decoder9.decode(buffer)), buffer.length)
-  });
-  py.setStderr({
-    write: (buffer) => (ctx.stderr.write(decoder9.decode(buffer)), buffer.length)
-  });
-  py.setStdin({
-    read: (buffer) => {
-      const ready = stdin.buffered(buffer.length);
-      if (!ready || ready.length === 0) return 0;
-      buffer.set(ready);
-      return ready.length;
-    }
-  });
-}
-
-// src/python/cpython.ts
-var RESERVED_FOR_INTERPRETER = /* @__PURE__ */ new Set(["lib", "dev", "proc"]);
-var pyodideModule = null;
-var indexUrl;
-var moduleUrl;
-var DEFAULT_BROWSER_INDEX_URL = "https://cdn.jsdelivr.net/pyodide/v0.28.3/full/";
-var isNode3 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-function configureCPython(options = {}) {
-  if (options.indexURL !== void 0) indexUrl = options.indexURL;
-  if (options.moduleURL !== void 0) {
-    moduleUrl = options.moduleURL;
-    pyodideModule = null;
-  }
-}
-function importPyodide() {
-  if (!pyodideModule) {
-    if (moduleUrl) {
-      pyodideModule = import(
-        /* @vite-ignore */
-        /* webpackIgnore: true */
-        moduleUrl
-      );
-    } else if (isNode3) {
-      pyodideModule = nodeOnlyModule("pyodide");
-    } else {
-      pyodideModule = import(
-        /* @vite-ignore */
-        /* webpackIgnore: true */
-        `${DEFAULT_BROWSER_INDEX_URL}pyodide.mjs`
-      );
-    }
-  }
-  return pyodideModule;
-}
-async function resolveIndexUrl() {
-  if (indexUrl) return indexUrl;
-  if (!isNode3) return DEFAULT_BROWSER_INDEX_URL;
-  try {
-    const { createRequire } = await nodeBuiltin("module");
-    const path = await nodeBuiltin("path");
-    const require2 = createRequire(path.join(process.cwd(), "index.js"));
-    return `${path.dirname(require2.resolve("pyodide/package.json"))}/`;
-  } catch {
-    return void 0;
-  }
-}
-async function isCPythonAvailable() {
-  try {
-    await importPyodide();
-    return true;
-  } catch {
-    return false;
-  }
-}
-var interpreters = /* @__PURE__ */ new WeakMap();
-async function interpreterFor(ctx) {
-  const existing = interpreters.get(ctx.vfs);
-  if (existing) return existing;
-  const starting = (async () => {
-    const { loadPyodide } = await importPyodide();
-    const resolved = await resolveIndexUrl();
-    const py = await loadPyodide({
-      ...resolved ? { indexURL: resolved } : {},
-      /* Output is rebound per program; these only catch anything printed
-       * while the interpreter is still starting. */
-      stdout: () => {
-      },
-      stderr: () => {
-      }
-    });
-    mountContainerDirs(py, ctx);
-    installRunner(py);
-    installSyscallBridge(py);
-    return py;
-  })();
-  interpreters.set(ctx.vfs, starting);
-  try {
-    return await starting;
-  } catch (error) {
-    interpreters.delete(ctx.vfs);
-    throw error;
-  }
-}
-function installRunner(py) {
-  py.__sbxRun = py.runPython(`
-from pyodide.code import eval_code_async
-
-async def __sbx_run(source, scope):
-    try:
-        await eval_code_async(source, globals=scope)
-        return 0
-    except SystemExit as exit:
-        code = exit.code
-        if code is None:
-            return 0
-        return code if isinstance(code, int) else 1
-
-__sbx_run
-`);
-}
-function mountContainerDirs(py, ctx) {
-  const mounted = py.__sbxMounted ??= /* @__PURE__ */ new Set();
-  let entries;
-  try {
-    entries = ctx.vfs.readdirWithTypes("/", ctx.cred);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.kind !== "directory") continue;
-    if (RESERVED_FOR_INTERPRETER.has(entry.name)) continue;
-    if (mounted.has(entry.name)) continue;
-    try {
-      mountContainerFs(py.FS, {
-        vfs: ctx.vfs,
-        cred: ctx.cred,
-        mountAt: `/${entry.name}`
-      });
-      mounted.add(entry.name);
-    } catch {
-    }
-  }
-}
-function bootstrap(py, ctx, argv, scriptDir) {
-  const paths = [
-    ...scriptDir ? [scriptDir] : [""],
-    "/workspace",
-    "/usr/lib/python3",
-    "/usr/lib/python3/site-packages",
-    "/usr/local/lib/python3/site-packages"
-  ];
-  py.runPython(`
-import sys, os, importlib
-sys.argv[:] = ${JSON.stringify(argv)}
-for __p in reversed(${JSON.stringify(paths)}):
-    if __p and __p not in sys.path:
-        sys.path.insert(0, __p)
-    elif __p == "" and "" not in sys.path:
-        sys.path.insert(0, "")
-try:
-    del __p
-except NameError:
-    pass
-os.environ.clear()
-os.environ.update(${JSON.stringify(ctx.env)})
-importlib.invalidate_caches()
-`);
-  try {
-    py.FS.chdir(ctx.cwd);
-  } catch {
-  }
-}
-function reportError(ctx, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const systemExit = /SystemExit:?\s*(-?\d+)?/.exec(message);
-  if (systemExit) {
-    return systemExit[1] !== void 0 ? Number(systemExit[1]) & 255 : 0;
-  }
-  if (/KeyboardInterrupt/.test(message)) {
-    ctx.stderr.write("KeyboardInterrupt\n");
-    return 130;
-  }
-  const text2 = message.replace(/^PythonError:\s*/, "");
-  ctx.stderr.write(text2.endsWith("\n") ? text2 : `${text2}
-`);
-  return 1;
-}
-async function runCPythonProgram(ctx, source, argv, scriptDir = null) {
-  let py;
-  try {
-    py = await interpreterFor(ctx);
-  } catch (error) {
-    ctx.stderr.write(
-      `python3: CPython is unavailable in this host (${error instanceof Error ? error.message : String(error)})
-`
-    );
-    return { exitCode: 127 };
-  }
-  mountContainerDirs(py, ctx);
-  try {
-    await py.loadPackagesFromImports(source, {
-      messageCallback: () => {
-      },
-      errorCallback: () => {
-      }
-    });
-  } catch {
-  }
-  const stdinHost = createStdinHost(ctx);
-  await stdinHost.prime();
-  bindProgram(py, { ctx, stdin: stdinHost });
-  try {
-    bootstrap(py, ctx, argv, scriptDir);
-  } catch (error) {
-    return { exitCode: reportError(ctx, error) };
-  }
-  const globals = py.globals.get("dict")();
-  try {
-    globals.set("__name__", "__main__");
-    const exitCode = await py.__sbxRun(source, globals);
-    return { exitCode: Number(exitCode) & 255 };
-  } catch (error) {
-    return { exitCode: reportError(ctx, error) };
-  } finally {
-    try {
-      globals.destroy();
-    } catch {
-    }
-  }
-}
-async function cpythonVersion(ctx) {
-  try {
-    const py = await interpreterFor(ctx);
-    return String(py.runPython("import sys; sys.version.split()[0]"));
-  } catch {
-    return null;
-  }
-}
-async function runCPythonRepl(ctx) {
-  let py;
-  try {
-    py = await interpreterFor(ctx);
-  } catch (error) {
-    ctx.stderr.write(`python3: Pyodide is unavailable (${error instanceof Error ? error.message : String(error)})
-`);
-    return 127;
-  }
-  mountContainerDirs(py, ctx);
-  bootstrap(py, ctx, [""], null);
-  bindProgram(py, { ctx, stdin: createStdinHost(ctx) });
-  ctx.line(`Python ${String(py.runPython("import sys; sys.version.split()[0]"))} (Pyodide)`);
-  ctx.line('Type "help()" for more information.');
-  let source = "";
-  for (; ; ) {
-    ctx.write(source ? "... " : ">>> ");
-    const line = await ctx.stdin.readLine();
-    if (line === null) {
-      ctx.line("");
-      break;
-    }
-    if (!source && ["exit()", "quit()"].includes(line.trim())) break;
-    source += `${source ? "\n" : ""}${line}`;
-    if (/[:\\]\s*$/.test(line) || source.includes("\n") && line.trim() !== "" && /^\s+/.test(line)) continue;
-    try {
-      await py.runPythonAsync(source);
-    } catch (error) {
-      reportError(ctx, error);
-    }
-    source = "";
-  }
-  return 0;
-}
-var PIP_PY = `
-import json, re
-
-import micropip
-
-_MISSING = re.compile(r"Can't find a pure Python 3 wheel for '([^']+)'")
-_EXTRAS = re.compile(r"^\\s*([A-Za-z0-9._-]+)\\s*\\[([^\\]]+)\\](.*)$")
-
-
-def _name_of(spec):
-    return re.split(r"[\\[<>=!~;\\s]", spec.strip(), 1)[0]
-
-
-def _installed_version(name):
-    try:
-        found = micropip.list()[name.replace("_", "-").lower()]
-        return getattr(found, "version", None)
-    except Exception:
-        return None
-
-
-async def _install_one(spec):
-    """Install one requirement, retrying without extras if they are impossible."""
-    attempt = spec
-    dropped = None
-    while True:
-        try:
-            await micropip.install(attempt)
-        except ValueError as error:
-            message = str(error)
-            missing = _MISSING.findall(message)
-            extras = _EXTRAS.match(attempt)
-            if missing and extras and dropped is None:
-                dropped = [e.strip() for e in extras.group(2).split(",")]
-                attempt = extras.group(1) + extras.group(3)
-                continue
-            return {
-                "spec": spec, "ok": False, "missing": missing,
-                "reason": message.strip().split("\\n")[0],
-            }
-        except Exception as error:
-            return {"spec": spec, "ok": False, "missing": [], "reason": str(error).strip().split("\\n")[0]}
-
-        name = _name_of(attempt)
-        return {
-            "spec": spec, "ok": True, "name": name,
-            "version": _installed_version(name), "dropped": dropped,
-        }
-
-
-async def __sbx_pip(specs_json):
-    results = []
-    for spec in json.loads(specs_json):
-        try:
-            results.append(await _install_one(spec))
-        except Exception as error:
-            results.append({"spec": spec, "ok": False, "missing": [], "reason": str(error)})
-    return json.dumps(results)
-
-__sbx_pip
-`;
-var micropip = defineCommand({
-  name: "micropip",
-  path: "/usr/bin/micropip",
-  aliases: ["pip", "pip3"],
-  summary: "install Python packages into the running interpreter",
-  usage: "micropip install <package>...",
-  async run(ctx) {
-    if (usingOwnedPython()) {
-      ctx.warn(
-        "pip here is micropip, which installs into the Pyodide interpreter \u2014 not the source-built CPython this container is running, so the packages would not be importable.\nRun the container with the pyodide backend if you need micropip, or wait for venv and pip support on the owned runtime (see docs/python/release-gates.md, M4)."
-      );
-      return 1;
-    }
-    const [action, ...args] = ctx.args;
-    if (action === "--version" || action === "-V") {
-      ctx.line("pip (micropip, Pyodide)");
-      return 0;
-    }
-    if (action !== "install") {
-      ctx.line("usage: pip install [-r requirements.txt] <package>...");
-      return action === void 0 ? 1 : 0;
-    }
-    const packages = args.filter((arg) => !arg.startsWith("-"));
-    const requirementIndex = args.findIndex((arg) => arg === "-r" || arg === "--requirement");
-    if (requirementIndex >= 0) {
-      const file3 = args[requirementIndex + 1];
-      if (!file3) {
-        ctx.stderr.write("pip: option -r requires a file\n");
-        return 2;
-      }
-      try {
-        packages.splice(packages.indexOf(file3), 1);
-        packages.push(...ctx.vfs.readText(ctx.path(file3), ctx.cred).split(/\r?\n/).map((line) => line.replace(/#.*$/, "").trim()).filter(Boolean));
-      } catch {
-        ctx.stderr.write(`pip: could not open requirements file '${file3}'
-`);
-        return 1;
-      }
-    }
-    if (packages.length === 0) {
-      ctx.stderr.write("pip: no packages specified\n");
-      return 1;
-    }
-    if (!ctx.kernel.net.outboundAllowed("https://pypi.org")) {
-      ctx.stderr.write(
-        "pip: outbound network access is disabled for this container (enable with network: { allowOutbound: true })\n"
-      );
-      return 1;
-    }
-    let py;
-    try {
-      py = await interpreterFor(ctx);
-    } catch {
-      ctx.stderr.write("pip: Pyodide is unavailable in this host\n");
-      return 127;
-    }
-    let outcomes;
-    try {
-      await py.loadPackage("micropip");
-      for (const name of packages) ctx.line(`Collecting ${name}`);
-      const install2 = py.runPython(PIP_PY);
-      outcomes = JSON.parse(String(await install2(JSON.stringify(packages))));
-    } catch (error) {
-      ctx.stderr.write(
-        `pip: installation failed: ${error instanceof Error ? error.message : String(error)}
-`
-      );
-      return 1;
-    }
-    const installed2 = [];
-    for (const outcome of outcomes) {
-      if (outcome.ok) {
-        installed2.push(
-          outcome.version ? `${outcome.name}-${outcome.version}` : String(outcome.name)
-        );
-        if (outcome.dropped?.length) {
-          ctx.stderr.write(
-            `  WARNING: ${outcome.name}: the ${outcome.dropped.map((extra) => `'${extra}'`).join(", ")} extra needs native code with no WebAssembly build; installed ${outcome.name} without it
-`
-          );
-        }
-        continue;
-      }
-      const missing = outcome.missing ?? [];
-      ctx.stderr.write(
-        missing.length > 0 ? `ERROR: could not install ${outcome.spec}: no WebAssembly build exists for ${missing.map((name) => name.split(/[<>=!~;\s]/)[0]).join(", ")}
-` : `ERROR: could not install ${outcome.spec}: ${outcome.reason ?? "unknown error"}
-`
-      );
-    }
-    if (installed2.length > 0) ctx.line(`Successfully installed ${installed2.join(" ")}`);
-    return outcomes.every((outcome) => outcome.ok) ? 0 : 1;
-  }
-});
-
-// src/python/python.ts
-var PYTHON_VERSION = "3.13";
-function configurePython(options = {}) {
-  configureCPython({ indexURL: options.indexURL, moduleURL: options.pyodideURL });
-  setPythonBackend({
-    ...options.backend !== void 0 ? { backend: options.backend } : {},
-    ...options.manifest !== void 0 ? { manifest: options.manifest } : {},
-    ...options.workerUrl !== void 0 ? { workerUrl: options.workerUrl } : {},
-    ...options.wheelIndex !== void 0 ? { wheelIndex: options.wheelIndex } : {},
-    ...options.buildFromSource !== void 0 ? { buildFromSource: options.buildFromSource } : {}
-  });
-}
-var isPythonAvailable = isCPythonAvailable;
-var python = defineCommand({
-  name: "python3",
-  path: "/usr/bin/python3",
-  aliases: ["python"],
-  summary: "run Python using CPython (Pyodide)",
-  usage: "python3 [-c command | -m module | script.py] [arguments]",
-  manual: `Python is CPython compiled to WebAssembly by Pyodide. Scripts use
-the container's virtual filesystem, modules in /workspace are importable, and
-compatible packages can be installed with pip (micropip).`,
-  async run(ctx) {
-    if (usingOwnedPython()) {
-      try {
-        return await runOwnedPython(ctx, withTopLevelAwaitArgs(ctx.args));
-      } catch (error) {
-        return ctx.fail(error.message ?? String(error));
-      }
-    }
-    const argv = ctx.args;
-    let i = 0;
-    let command;
-    let moduleName;
-    let script;
-    for (; i < argv.length; i++) {
-      const arg = argv[i];
-      if (arg === "-V" || arg === "--version") {
-        ctx.line(`Python ${await cpythonVersion(ctx) ?? PYTHON_VERSION}`);
-        return 0;
-      }
-      if (arg === "-h" || arg === "--help") {
-        printHelp2(ctx);
-        return 0;
-      }
-      if (arg === "-c") {
-        command = argv[++i] ?? "";
-        i++;
-        break;
-      }
-      if (arg === "-m") {
-        moduleName = argv[++i] ?? "";
-        i++;
-        break;
-      }
-      if (arg === "-") {
-        script = "-";
-        i++;
-        break;
-      }
-      if (["-i", "-u", "-B", "-E", "-s", "-S", "-O"].includes(arg)) continue;
-      if (arg.startsWith("-")) continue;
-      script = arg;
-      i++;
-      break;
-    }
-    const rest = argv.slice(i);
-    if (command !== void 0) {
-      return (await runCPythonProgram(ctx, withTopLevelAwait(command), ["-c", ...rest], null)).exitCode;
-    }
-    if (moduleName !== void 0) {
-      const program = `
-import runpy, sys
-sys.argv = ${JSON.stringify([moduleName, ...rest])}
-try:
-    runpy.run_module(${JSON.stringify(moduleName)}, run_name="__main__", alter_sys=True)
-except ImportError:
-    print("/usr/bin/python3: No module named " + ${JSON.stringify(moduleName)}, file=sys.stderr)
-    raise SystemExit(1)
-`;
-      return (await runCPythonProgram(ctx, program, [moduleName, ...rest], null)).exitCode;
-    }
-    if (script === void 0) {
-      if (ctx.stdin.isTTY) return runCPythonRepl(ctx);
-      const source2 = new TextDecoder().decode(await ctx.stdin.readAll());
-      return source2.trim() ? (await runCPythonProgram(ctx, source2, ["", ...rest])).exitCode : 0;
-    }
-    if (script === "-") {
-      const source2 = new TextDecoder().decode(await ctx.stdin.readAll());
-      return (await runCPythonProgram(ctx, source2, ["-", ...rest])).exitCode;
-    }
-    const abs = ctx.path(script);
-    let source;
-    try {
-      source = ctx.vfs.readText(abs, ctx.cred);
-    } catch {
-      ctx.stderr.write(`${ctx.name}: can't open file '${abs}': [Errno 2] No such file or directory
-`);
-      return 2;
-    }
-    return (await runCPythonProgram(ctx, source, [abs, ...rest], dirname(abs))).exitCode;
-  }
-});
-function withTopLevelAwait(source) {
-  if (!/\bawait\b/.test(source)) return source;
-  return `import ast as _sbx_ast, inspect as _sbx_inspect
-_sbx_src = ${JSON.stringify(source)}
-try:
-    _sbx_code = compile(_sbx_src, "<string>", "exec")
-except SyntaxError:
-    _sbx_code = compile(_sbx_src, "<string>", "exec", _sbx_ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
-_sbx_async = bool(_sbx_code.co_flags & _sbx_inspect.CO_COROUTINE)
-_sbx_globals = globals()
-for _sbx_name in ("_sbx_ast", "_sbx_inspect", "_sbx_src", "_sbx_name"):
-    _sbx_globals.pop(_sbx_name, None)
-if _sbx_async:
-    import asyncio as _sbx_asyncio
-    _sbx_asyncio.run(eval(_sbx_code, _sbx_globals))
-else:
-    exec(_sbx_code, _sbx_globals)
-`;
-}
-function withTopLevelAwaitArgs(args) {
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "-c") {
-      if (i + 1 >= args.length) return args;
-      const rewritten = withTopLevelAwait(args[i + 1]);
-      if (rewritten === args[i + 1]) return args;
-      const copy = [...args];
-      copy[i + 1] = rewritten;
-      return copy;
-    }
-    if (arg === "-m" || !arg.startsWith("-") || arg === "-") return args;
-  }
-  return args;
-}
-function printHelp2(ctx) {
-  ctx.line("usage: python3 [option] ... [-c cmd | -m mod | file | -] [arg] ...");
-  ctx.line("-c cmd : program passed in as string");
-  ctx.line("-m mod : run library module as a script");
-  ctx.line("-V     : print the Python version and exit");
-}
-function pythonCommands() {
-  return usingOwnedPython() ? [python, pipCommand] : [python, micropip];
-}
-
 // src/tools/ffmpeg.ts
 init_binary();
 var INSTALL_HINT = "ffmpeg is not installed in this container.\nThe FFmpeg runtime ships separately because it is a ~31MB WebAssembly build:\n  npm install @ffmpeg/core";
@@ -25812,8 +24601,8 @@ function renameShadowedExports(source) {
     for (const [key, value] of Object.entries(node2)) {
       if (key === "type" || key === "start" || key === "end" || skip.includes(key)) continue;
       if (Array.isArray(value)) {
-        for (const item of value) if (isNode4(item)) visit(item, childScope);
-      } else if (isNode4(value)) {
+        for (const item of value) if (isNode3(item)) visit(item, childScope);
+      } else if (isNode3(value)) {
         visit(value, childScope);
       }
     }
@@ -25837,9 +24626,9 @@ function blockNames2(body) {
       for (const declarator of node2.declarations) {
         collectPattern2(declarator.id, names);
       }
-    } else if (node2.type === "ClassDeclaration" && isNode4(node2.id)) {
+    } else if (node2.type === "ClassDeclaration" && isNode3(node2.id)) {
       names.add(node2.id.name);
-    } else if (node2.type === "FunctionDeclaration" && isNode4(node2.id)) {
+    } else if (node2.type === "FunctionDeclaration" && isNode3(node2.id)) {
       names.add(node2.id.name);
     }
   }
@@ -25850,10 +24639,10 @@ function collectVars2(nodes, names) {
     for (const item of nodes) collectVars2(item, names);
     return;
   }
-  if (!isNode4(nodes)) return;
+  if (!isNode3(nodes)) return;
   const node2 = nodes;
   if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
-    if (isNode4(node2.id)) names.add(node2.id.name);
+    if (isNode3(node2.id)) names.add(node2.id.name);
     return;
   }
   if (node2.type === "VariableDeclaration" && node2.kind === "var") {
@@ -25867,7 +24656,7 @@ function collectVars2(nodes, names) {
   }
 }
 function collectPattern2(node2, names) {
-  if (!isNode4(node2)) return;
+  if (!isNode3(node2)) return;
   switch (node2.type) {
     case "Identifier":
       names.add(node2.name);
@@ -25891,7 +24680,7 @@ function collectPattern2(node2, names) {
   }
 }
 function isExports(value) {
-  return isNode4(value) && value.type === "Identifier" && value.name === NAME;
+  return isNode3(value) && value.type === "Identifier" && value.name === NAME;
 }
 function freshName(source) {
   let name = "__sandboxedjs_exports";
@@ -25899,7 +24688,7 @@ function freshName(source) {
   while (source.includes(name)) name = `__sandboxedjs_exports${++suffix}`;
   return name;
 }
-function isNode4(value) {
+function isNode3(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
 }
 var NOTHING2 = [];
@@ -26430,7 +25219,7 @@ var apt = defineCommand({
     const provided = {
       nodejs: { version: NODE_VERSION.replace(/^v/, ""), description: "Node.js event-based server-side JavaScript engine" },
       npm: { version: NPM_VERSION, description: "package manager for Node.js" },
-      python3: { version: PYTHON_VERSION, description: "CPython interpreter powered by Pyodide" },
+      python3: { version: PYTHON_VERSION, description: "CPython interpreter" },
       "python3-pip": { version: "24.0", description: "Python package installer" },
       coreutils: { version: "9.4", description: "GNU core utilities" },
       grep: { version: "3.11", description: "GNU grep, egrep and fgrep" },
@@ -26534,7 +25323,7 @@ var dpkg = defineCommand({
       ctx.line("||/ Name           Version      Architecture Description");
       ctx.line("+++-==============-============-============-=================================");
       ctx.line(`ii  nodejs         ${NODE_VERSION.replace(/^v/, "").padEnd(12)} amd64        Node.js JavaScript runtime`);
-      ctx.line(`ii  python3        ${PYTHON_VERSION.padEnd(12)} wasm32       CPython (Pyodide) interpreter`);
+      ctx.line(`ii  python3        ${PYTHON_VERSION.padEnd(12)} wasm32       CPython interpreter`);
       return 0;
     }
     ctx.line("dpkg 1.22.6 (amd64)");
@@ -35504,7 +34293,6 @@ exports.braceExpand = braceExpand;
 exports.buildRootfs = buildRootfs;
 exports.builtinNames = builtinNames;
 exports.captureStdio = captureStdio;
-exports.configureCPython = configureCPython;
 exports.configurePython = configurePython;
 exports.containerTarget = containerTarget;
 exports.createChildProcessModule = createChildProcessModule;
@@ -35536,7 +34324,6 @@ exports.inspectElf = inspectElf;
 exports.installUserland = installUserland;
 exports.installWasmCommands = installWasmCommands;
 exports.isBuiltinName = isBuiltinName;
-exports.isCPythonAvailable = isCPythonAvailable;
 exports.isElfBinary = isElfBinary;
 exports.isPythonAvailable = isPythonAvailable;
 exports.isSysError = isSysError;