sandboxedjs 0.1.48 → 0.1.50

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index_js = require('buffer/index.js');
 var pako = require('pako');
+var index_js = require('buffer/index.js');
 var sha256 = require('@noble/hashes/sha256');
 var sha512 = require('@noble/hashes/sha512');
 var sha1 = require('@noble/hashes/sha1');
@@ -21,10 +21,6 @@ var timersModule = require('timers-browserify');
 var legacyUrl = require('url/url.js');
 var legacy$1 = require('@noble/hashes/legacy');
 var hmac = require('@noble/hashes/hmac');
-var module$1 = require('module');
-var fs = require('fs');
-var path = require('path');
-var url = require('url');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -3611,10 +3607,10 @@ function builtinType({ shell, argv, io }) {
 }
 async function builtinCommand({ shell, argv, io }) {
   const args = argv.slice(1);
-  const describe2 = args.includes("-v") || args.includes("-V");
+  const describe3 = args.includes("-v") || args.includes("-V");
   const verbose = args.includes("-V");
   const rest = args.filter((a) => a !== "-v" && a !== "-V" && a !== "-p");
-  if (describe2) {
+  if (describe3) {
     let status = 0;
     for (const name of rest) {
       if (isBuiltinName(name)) {
@@ -13927,15 +13923,15 @@ var sort = defineCommand({
       const slice = fields.slice(start2, end === void 0 ? void 0 : end);
       return slice.join(separator ?? " ");
     };
-    const normalize3 = (line) => {
+    const normalize4 = (line) => {
       let value = keys.length ? fieldOf(line, keys[0]) : line;
       if (args.has("ignore-leading-blanks")) value = value.replace(/^\s+/, "");
       if (args.has("ignore-case")) value = value.toLowerCase();
       return value;
     };
     const compare = (a, b) => {
-      const x = normalize3(a);
-      const y = normalize3(b);
+      const x = normalize4(a);
+      const y = normalize4(b);
       if (args.has("numeric-sort") || args.has("general-numeric-sort")) {
         const nx = parseFloat(x) || 0;
         const ny = parseFloat(y) || 0;
@@ -15176,7 +15172,7 @@ var diff = defineCommand({
     if (a === void 0 || b === void 0) return ctx.fail("missing operand", 2);
     const { sources, ok: ok2 } = await readInputs(ctx, [a, b]);
     if (!ok2 || sources.length < 2) return 2;
-    const normalize3 = (line) => {
+    const normalize4 = (line) => {
       let value = line;
       if (args.has("ignore-all-space")) value = value.replace(/\s+/g, "");
       else if (args.has("ignore-space-change")) value = value.replace(/\s+/g, " ").trim();
@@ -15185,7 +15181,7 @@ var diff = defineCommand({
     };
     const left = splitLines(sources[0].bytes).lines;
     const right = splitLines(sources[1].bytes).lines;
-    const script = diffLines(left.map(normalize3), right.map(normalize3));
+    const script = diffLines(left.map(normalize4), right.map(normalize4));
     if (script.length === 0) return 0;
     if (args.has("brief")) {
       ctx.line(`Files ${a} and ${b} differ`);
@@ -17685,150 +17681,2315 @@ function nodeCommands() {
 // src/runtime/python.ts
 init_path();
 
-// src/runtime/emscripten-fs.ts
-init_errno();
-init_path();
-var EM_ERRNO = {
-  EPERM: 63,
-  ENOENT: 44,
-  EIO: 29,
-  EBADF: 8,
-  EACCES: 2,
-  EBUSY: 10,
-  EEXIST: 20,
-  EXDEV: 75,
-  ENODEV: 43,
-  ENOTDIR: 54,
-  EISDIR: 31,
-  EINVAL: 28,
-  ENFILE: 41,
-  EMFILE: 33,
-  ENOSPC: 51,
-  EROFS: 57,
-  ENOTEMPTY: 55,
-  ELOOP: 32,
-  ENOSYS: 52,
-  ENOTSUP: 138
+// src/runtime/python/host-abi.ts
+var SBX_HOST_ABI_VERSION = 1;
+var SBX_REQUEST_HEADER_BYTES = 16;
+var SBX_RESPONSE_HEADER_BYTES = 20;
+var Op = {
+  handshake: 0,
+  openat: 1,
+  close: 2,
+  read: 3,
+  write: 4,
+  pread: 5,
+  pwrite: 6,
+  lseek: 7,
+  fstat: 8,
+  statat: 9,
+  ftruncate: 10,
+  renameat: 11,
+  unlinkat: 12,
+  mkdirat: 13,
+  readlinkat: 14,
+  symlinkat: 15,
+  getdents: 16,
+  fsync: 17,
+  dup: 256,
+  dup2: 257,
+  get_flags: 258,
+  set_flags: 259,
+  pipe: 512,
+  poll: 768,
+  clock_gettime: 1024,
+  sleep: 1025,
+  getpid: 1280,
+  getcwd: 1281,
+  chdir: 1282,
+  environ: 1283,
+  getrandom: 1536
 };
-function emErrno(code) {
-  return EM_ERRNO[code] ?? EM_ERRNO.EIO;
+var Errno = {
+  EPERM: 1,
+  ENOENT: 2,
+  ESRCH: 3,
+  EINTR: 4,
+  EIO: 5,
+  ENXIO: 6,
+  E2BIG: 7,
+  EBADF: 9,
+  EAGAIN: 11,
+  ENOMEM: 12,
+  EACCES: 13,
+  EFAULT: 14,
+  EBUSY: 16,
+  EEXIST: 17,
+  EXDEV: 18,
+  ENODEV: 19,
+  ENOTDIR: 20,
+  EISDIR: 21,
+  EINVAL: 22,
+  ENFILE: 23,
+  EMFILE: 24,
+  ENOTTY: 25,
+  EFBIG: 27,
+  ENOSPC: 28,
+  ESPIPE: 29,
+  EROFS: 30,
+  EMLINK: 31,
+  EPIPE: 32,
+  ERANGE: 34,
+  ENAMETOOLONG: 36,
+  ENOSYS: 38,
+  ENOTEMPTY: 39,
+  ELOOP: 40,
+  ENODATA: 61,
+  EPROTO: 71,
+  EOVERFLOW: 75,
+  ETIMEDOUT: 110,
+  ECANCELED: 125,
+  EDQUOT: 122
+};
+var CAPABILITIES = ["files", "descriptors", "pipes", "readiness", "time", "identity", "entropy", "sockets", "processes", "signals", "storage", "services", "threads"];
+var OP_NAMES = Object.fromEntries(
+  Object.entries(Op).map(([name, code]) => [code, name])
+);
+Object.fromEntries(
+  Object.entries(Errno).map(([name, code]) => [code, name])
+);
+
+// src/runtime/python/manifest.ts
+var MANIFEST_FORMAT = "sandboxedjs-python-runtime";
+var MANIFEST_SCHEMA_VERSION = 1;
+var ManifestError = class extends Error {
+  code = "ERR_SBX_PYTHON_MANIFEST";
+};
+function validateManifest(value) {
+  const manifest = value;
+  if (!manifest || typeof manifest !== "object") throw new ManifestError("the Python runtime manifest is not an object");
+  if (manifest.format !== MANIFEST_FORMAT) {
+    throw new ManifestError(`not a ${MANIFEST_FORMAT} manifest (format: ${String(manifest.format)})`);
+  }
+  if (manifest.schemaVersion !== MANIFEST_SCHEMA_VERSION) {
+    throw new ManifestError(
+      `manifest schema version ${String(manifest.schemaVersion)}, this build understands ${MANIFEST_SCHEMA_VERSION}`
+    );
+  }
+  if (manifest.engine !== "cpython-wasm") {
+    throw new ManifestError(`unknown Python engine ${String(manifest.engine)}`);
+  }
+  if (!manifest.runtimeId) throw new ManifestError("the manifest has no runtimeId");
+  if (!manifest.artifacts?.moduleUrl) throw new ManifestError("the manifest names no module artifact");
+  const abi = manifest.hostAbi;
+  if (!abi || abi.name !== "sbx_host_v1") {
+    throw new ManifestError(`the runtime was built against host ABI ${String(abi?.name)}, not sbx_host_v1`);
+  }
+  if (abi.version !== SBX_HOST_ABI_VERSION) {
+    throw new ManifestError(
+      `the runtime was built against host ABI version ${abi.version}; this kernel speaks ${SBX_HOST_ABI_VERSION}`
+    );
+  }
+  if (!manifest.capabilities) throw new ManifestError("the manifest declares no capabilities");
+  return manifest;
 }
-function mountContainerFs(FS, opts) {
-  const { vfs, cred } = opts;
-  const throwErrno = (code) => {
-    throw new FS.ErrnoError(emErrno(code));
-  };
-  const translate = (e) => {
-    if (isSysError(e)) return throwErrno(e.code);
-    throw new FS.ErrnoError(emErrno("EIO"));
-  };
-  const mountRoot = opts.mountAt ? normalize(opts.mountAt) : "/";
-  const backend = {
-    /** Absolute container path for a node. */
-    realPath(node2) {
-      const parts = [];
-      let current = node2;
-      while (current && current.parent !== current) {
-        parts.unshift(current.name);
-        current = current.parent;
-      }
-      const relative2 = parts.join("/");
-      if (mountRoot === "/") return "/" + relative2;
-      return relative2 ? join(mountRoot, relative2) : mountRoot;
-    },
-    mount(_mount) {
-      return backend.createNode(null, "/", 16877 | 0, 0);
-    },
-    createNode(parent, name, mode, rdev) {
-      const node2 = FS.createNode(parent, name, mode, rdev);
-      node2.node_ops = nodeOps;
-      node2.stream_ops = streamOps;
-      return node2;
+
+// src/runtime/python/config.ts
+var bundledManifest = {
+  format: "sandboxedjs-python-runtime",
+  schemaVersion: 1,
+  runtimeId: "sbx-cpython-3.13.5-threaded-fixed",
+  engine: "cpython-wasm",
+  pythonVersion: "3.13.5",
+  profile: "threaded-fixed",
+  hostAbi: { name: "sbx_host_v1", version: 1 },
+  artifacts: {
+    moduleUrl: new URL(
+      (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)).includes("/src/runtime/python/") ? "../../../dist/python/python.js" : "./python/python.js",
+      (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))
+    ).href
+  },
+  capabilities: {
+    threads: true,
+    nativeExtensions: "fixed",
+    networking: "none",
+    processes: "none",
+    persistence: "memory"
+  }
+};
+var config = { backend: "sbx-cpython-wasm", manifest: bundledManifest };
+function setPythonBackend(options) {
+  if (options.manifest !== void 0) config.manifest = validateManifest(options.manifest);
+  if (options.workerUrl !== void 0) config.workerUrl = options.workerUrl;
+  if (options.backend !== void 0) {
+    if (options.backend === "sbx-cpython-wasm" && !config.manifest) {
+      throw new Error(
+        "the sbx-cpython-wasm backend needs a runtime manifest; pass one to configurePython({ manifest })"
+      );
     }
-  };
-  const nodeOps = {
-    getattr(node2) {
-      const path = backend.realPath(node2);
-      try {
-        const st = vfs.lstat(path);
-        return {
-          dev: st.dev,
-          ino: st.ino,
-          mode: st.mode,
-          nlink: st.nlink,
-          uid: st.uid,
-          gid: st.gid,
-          rdev: st.rdev,
-          size: st.size,
-          atime: new Date(st.atimeMs),
-          mtime: new Date(st.mtimeMs),
-          ctime: new Date(st.ctimeMs),
-          blksize: 4096,
-          blocks: Math.ceil(st.size / 512)
-        };
-      } catch (e) {
-        return translate(e);
-      }
-    },
-    setattr(node2, attr) {
-      const path = backend.realPath(node2);
-      try {
-        if (attr.mode !== void 0) {
-          vfs.chmod(path, attr.mode & 4095, cred);
-          node2.mode = attr.mode;
-        }
-        if (attr.timestamp !== void 0) vfs.utimes(path, attr.timestamp, attr.timestamp, cred);
-        if (attr.size !== void 0) {
-          vfs.truncate(path, attr.size, cred);
-          opts.onWrite?.(path);
-        }
-      } catch (e) {
-        translate(e);
-      }
-    },
-    lookup(parent, name) {
-      const path = join(backend.realPath(parent), name);
-      let mode;
-      try {
-        mode = vfs.lstat(path).mode;
-      } catch {
-        throw new FS.ErrnoError(EM_ERRNO.ENOENT);
-      }
-      return backend.createNode(parent, name, mode, 0);
-    },
-    mknod(parent, name, mode, dev) {
-      const path = join(backend.realPath(parent), name);
-      try {
-        if (FS.isDir(mode)) {
-          vfs.mkdir(path, { cred, mode: mode & 4095 });
-        } else if (FS.isFile(mode)) {
-          vfs.writeFile(path, new Uint8Array(0), { cred, mode: mode & 4095 });
-        } else {
-          return throwErrno("ENOTSUP");
-        }
-        opts.onWrite?.(path);
-      } catch (e) {
-        translate(e);
-      }
-      return backend.createNode(parent, name, mode, dev);
-    },
-    rename(oldNode, newDir, newName) {
-      const from = backend.realPath(oldNode);
-      const to = join(backend.realPath(newDir), newName);
+    config.backend = options.backend;
+  }
+}
+function pythonBackend() {
+  return config;
+}
+
+// src/kernel/open-file.ts
+var PosixError = class extends Error {
+  constructor(errno, message) {
+    super(message ?? `errno ${errno}`);
+    this.errno = errno;
+    this.name = "PosixError";
+  }
+  errno;
+};
+var O_RDONLY = 0;
+var O_WRONLY = 1;
+var O_CREAT2 = 64;
+var O_EXCL2 = 128;
+var O_TRUNC2 = 512;
+var O_APPEND = 1024;
+var O_NONBLOCK = 2048;
+var O_DIRECTORY2 = 65536;
+var O_CLOEXEC = 524288;
+function accessMode(flags) {
+  return flags & 3;
+}
+var SEEK_SET = 0;
+var SEEK_CUR = 1;
+var Inode = class {
+  constructor(ino, path, vfs, cred) {
+    this.ino = ino;
+    this.path = path;
+    this.vfs = vfs;
+    this.cred = cred;
+  }
+  ino;
+  path;
+  vfs;
+  cred;
+  detached = null;
+  refs = 0;
+  /** Read the whole file, wherever it currently lives. */
+  contents() {
+    if (this.detached) return this.detached;
+    try {
+      return this.vfs.readFile(this.path, this.cred);
+    } catch (error) {
+      throw toPosixError(error);
+    }
+  }
+  replace(data) {
+    if (this.detached) {
+      this.detached = data;
+      return;
+    }
+    try {
+      this.vfs.writeFile(this.path, data, { cred: this.cred });
+    } catch (error) {
+      throw toPosixError(error);
+    }
+  }
+  /** Called when the last name is about to be removed. */
+  detach() {
+    if (this.detached) return;
+    try {
+      this.detached = this.vfs.readFile(this.path, this.cred);
+    } catch {
+      this.detached = new Uint8Array();
+    }
+  }
+  size() {
+    return this.contents().length;
+  }
+  stat() {
+    if (this.detached) {
+      return {
+        ino: this.ino,
+        mode: 33188,
+        size: this.detached.length,
+        uid: this.cred.uid,
+        gid: this.cred.gid,
+        nlink: 0,
+        atimeMs: Date.now(),
+        mtimeMs: Date.now(),
+        ctimeMs: Date.now()
+      };
+    }
+    try {
+      const st = this.vfs.stat(this.path, { cred: this.cred });
+      return {
+        ino: st.ino,
+        mode: st.mode,
+        size: st.size,
+        uid: st.uid,
+        gid: st.gid,
+        nlink: st.nlink ?? 1,
+        atimeMs: st.atimeMs,
+        mtimeMs: st.mtimeMs,
+        ctimeMs: st.ctimeMs
+      };
+    } catch (error) {
+      throw toPosixError(error);
+    }
+  }
+};
+var FileDescription = class {
+  constructor(inode, flags) {
+    this.inode = inode;
+    this.flags = flags;
+    inode.refs += 1;
+  }
+  inode;
+  flags;
+  kind = "file";
+  offset = 0;
+  read(length) {
+    if (accessMode(this.flags) === O_WRONLY) throw new PosixError(Errno.EBADF);
+    const data = this.inode.contents();
+    const start2 = Math.min(this.offset, data.length);
+    const end = Math.min(start2 + length, data.length);
+    this.offset = end;
+    return data.slice(start2, end);
+  }
+  pread(length, offset) {
+    if (accessMode(this.flags) === O_WRONLY) throw new PosixError(Errno.EBADF);
+    const data = this.inode.contents();
+    const start2 = Math.min(offset, data.length);
+    return data.slice(start2, Math.min(start2 + length, data.length));
+  }
+  write(data) {
+    if (accessMode(this.flags) === O_RDONLY) throw new PosixError(Errno.EBADF);
+    const at = this.flags & O_APPEND ? this.inode.size() : this.offset;
+    const written = this.writeAt(data, at);
+    this.offset = at + written;
+    return written;
+  }
+  pwrite(data, offset) {
+    if (accessMode(this.flags) === O_RDONLY) throw new PosixError(Errno.EBADF);
+    return this.writeAt(data, offset);
+  }
+  writeAt(data, offset) {
+    const current = this.inode.contents();
+    const end = offset + data.length;
+    const next = new Uint8Array(Math.max(current.length, end));
+    next.set(current, 0);
+    next.set(data, offset);
+    this.inode.replace(next);
+    return data.length;
+  }
+  seek(offset, whence) {
+    const base2 = whence === SEEK_SET ? 0 : whence === SEEK_CUR ? this.offset : this.inode.size();
+    const next = base2 + offset;
+    if (next < 0) throw new PosixError(Errno.EINVAL);
+    this.offset = next;
+    return next;
+  }
+  truncate(length) {
+    const current = this.inode.contents();
+    const next = new Uint8Array(length);
+    next.set(current.subarray(0, Math.min(length, current.length)), 0);
+    this.inode.replace(next);
+  }
+  stat() {
+    return this.inode.stat();
+  }
+  readable() {
+    return true;
+  }
+  writable() {
+    return true;
+  }
+  whenReady() {
+    return Promise.resolve();
+  }
+  close() {
+    this.inode.refs -= 1;
+    if (this.inode.refs <= 0) this.inode.detached = null;
+  }
+};
+var DirectoryDescription = class {
+  constructor(path, flags, vfs, cred) {
+    this.path = path;
+    this.flags = flags;
+    this.vfs = vfs;
+    this.cred = cred;
+  }
+  path;
+  flags;
+  vfs;
+  cred;
+  kind = "dir";
+  entries = null;
+  index = 0;
+  /** Entry names, NUL-terminated, as many as fit in `length`. */
+  read(length) {
+    if (!this.entries) {
       try {
-        vfs.rename(from, to, cred);
-        opts.onWrite?.(to);
-      } catch (e) {
-        translate(e);
+        this.entries = [".", "..", ...this.vfs.readdir(this.path, this.cred)];
+      } catch (error) {
+        throw toPosixError(error);
       }
-      oldNode.name = newName;
-      oldNode.parent = newDir;
-    },
-    unlink(parent, name) {
-      const path = join(backend.realPath(parent), name);
-      try {
-        vfs.unlink(path, cred);
-        opts.onWrite?.(path);
+    }
+    const encoder9 = new TextEncoder();
+    const parts = [];
+    let total = 0;
+    while (this.index < this.entries.length) {
+      const encoded = encoder9.encode(this.entries[this.index] + "\0");
+      if (total + encoded.length > length) break;
+      parts.push(encoded);
+      total += encoded.length;
+      this.index += 1;
+    }
+    const joined = new Uint8Array(total);
+    let at = 0;
+    for (const part of parts) {
+      joined.set(part, at);
+      at += part.length;
+    }
+    return joined;
+  }
+  write() {
+    throw new PosixError(Errno.EISDIR);
+  }
+  seek(offset, whence) {
+    if (whence === SEEK_SET && offset === 0) {
+      this.index = 0;
+      return 0;
+    }
+    throw new PosixError(Errno.EINVAL);
+  }
+  stat() {
+    try {
+      const st = this.vfs.stat(this.path, { cred: this.cred });
+      return {
+        ino: st.ino,
+        mode: st.mode,
+        size: st.size,
+        uid: st.uid,
+        gid: st.gid,
+        nlink: st.nlink ?? 2,
+        atimeMs: st.atimeMs,
+        mtimeMs: st.mtimeMs,
+        ctimeMs: st.ctimeMs
+      };
+    } catch (error) {
+      throw toPosixError(error);
+    }
+  }
+  readable() {
+    return true;
+  }
+  writable() {
+    return false;
+  }
+  whenReady() {
+    return Promise.resolve();
+  }
+  close() {
+  }
+};
+var PIPE_CAPACITY = 64 * 1024;
+var PipeBuffer = class {
+  chunks = [];
+  queued = 0;
+  readers = 0;
+  writers = 0;
+  waiters = [];
+  get available() {
+    return this.queued;
+  }
+  get space() {
+    return Math.max(0, PIPE_CAPACITY - this.queued);
+  }
+  push(data) {
+    this.chunks.push(data);
+    this.queued += data.length;
+    this.wake();
+  }
+  take(length) {
+    const out = new Uint8Array(Math.min(length, this.queued));
+    let at = 0;
+    while (at < out.length) {
+      const head2 = this.chunks[0];
+      const take = Math.min(head2.length, out.length - at);
+      out.set(head2.subarray(0, take), at);
+      at += take;
+      if (take === head2.length) this.chunks.shift();
+      else this.chunks[0] = head2.subarray(take);
+    }
+    this.queued -= out.length;
+    this.wake();
+    return out;
+  }
+  /** Anything that may have changed readiness for either end. */
+  wake() {
+    const waiting = this.waiters;
+    this.waiters = [];
+    for (const resolve2 of waiting) resolve2();
+  }
+  whenReady() {
+    return new Promise((resolve2) => this.waiters.push(resolve2));
+  }
+};
+var PipeReadEnd = class {
+  constructor(buffer, flags) {
+    this.buffer = buffer;
+    this.flags = flags;
+    buffer.readers += 1;
+  }
+  buffer;
+  flags;
+  kind = "pipe";
+  read(length) {
+    if (this.buffer.available === 0) {
+      if (this.buffer.writers === 0) return new Uint8Array();
+      throw new PosixError(Errno.EAGAIN);
+    }
+    return this.buffer.take(length);
+  }
+  write() {
+    throw new PosixError(Errno.EBADF);
+  }
+  stat() {
+    return pipeStat();
+  }
+  readable() {
+    return this.buffer.available > 0 || this.buffer.writers === 0;
+  }
+  writable() {
+    return false;
+  }
+  whenReady() {
+    return this.buffer.whenReady();
+  }
+  close() {
+    this.buffer.readers -= 1;
+    this.buffer.wake();
+  }
+};
+var PipeWriteEnd = class {
+  constructor(buffer, flags) {
+    this.buffer = buffer;
+    this.flags = flags;
+    buffer.writers += 1;
+  }
+  buffer;
+  flags;
+  kind = "pipe";
+  read() {
+    throw new PosixError(Errno.EBADF);
+  }
+  write(data) {
+    if (this.buffer.readers === 0) throw new PosixError(Errno.EPIPE);
+    const space = this.buffer.space;
+    if (space === 0) throw new PosixError(Errno.EAGAIN);
+    const accepted = data.subarray(0, space);
+    this.buffer.push(accepted.slice());
+    return accepted.length;
+  }
+  stat() {
+    return pipeStat();
+  }
+  readable() {
+    return false;
+  }
+  writable() {
+    return this.buffer.space > 0 || this.buffer.readers === 0;
+  }
+  whenReady() {
+    return this.buffer.whenReady();
+  }
+  close() {
+    this.buffer.writers -= 1;
+    this.buffer.wake();
+  }
+};
+function pipeStat() {
+  const now = Date.now();
+  return { ino: 0, mode: 4480, size: 0, uid: 0, gid: 0, nlink: 1, atimeMs: now, mtimeMs: now, ctimeMs: now };
+}
+function createPipe(flags = 0) {
+  const buffer = new PipeBuffer();
+  return [new PipeReadEnd(buffer, flags | O_RDONLY), new PipeWriteEnd(buffer, flags | O_WRONLY)];
+}
+var StreamDescription = class {
+  constructor(flags, sink, isTty = false) {
+    this.flags = flags;
+    this.sink = sink;
+    this.isTty = isTty;
+  }
+  flags;
+  sink;
+  isTty;
+  kind = "stream";
+  queue = [];
+  queued = 0;
+  ended = false;
+  waiters = [];
+  /** Host side: give the guest more input. */
+  push(data) {
+    if (data.length === 0) return;
+    this.queue.push(data);
+    this.queued += data.length;
+    this.wake();
+  }
+  /** Host side: no more input will arrive. */
+  end() {
+    this.ended = true;
+    this.wake();
+  }
+  read(length) {
+    if (this.queued === 0) {
+      if (this.ended) return new Uint8Array();
+      throw new PosixError(Errno.EAGAIN);
+    }
+    const out = new Uint8Array(Math.min(length, this.queued));
+    let at = 0;
+    while (at < out.length) {
+      const head2 = this.queue[0];
+      const take = Math.min(head2.length, out.length - at);
+      out.set(head2.subarray(0, take), at);
+      at += take;
+      if (take === head2.length) this.queue.shift();
+      else this.queue[0] = head2.subarray(take);
+    }
+    this.queued -= out.length;
+    return out;
+  }
+  write(data) {
+    if (!this.sink) throw new PosixError(Errno.EBADF);
+    this.sink(data);
+    return data.length;
+  }
+  stat() {
+    const now = Date.now();
+    return {
+      ino: 0,
+      mode: this.isTty ? 8592 : 4480,
+      size: 0,
+      uid: 0,
+      gid: 0,
+      nlink: 1,
+      atimeMs: now,
+      mtimeMs: now,
+      ctimeMs: now
+    };
+  }
+  readable() {
+    return this.queued > 0 || this.ended;
+  }
+  writable() {
+    return true;
+  }
+  whenReady() {
+    return new Promise((resolve2) => this.waiters.push(resolve2));
+  }
+  close() {
+    this.wake();
+  }
+  wake() {
+    const waiting = this.waiters;
+    this.waiters = [];
+    for (const resolve2 of waiting) resolve2();
+  }
+};
+function toPosixError(error) {
+  if (error instanceof PosixError) return error;
+  const code = error?.code;
+  const message = error?.message;
+  const mapped = {
+    ENOENT: Errno.ENOENT,
+    EEXIST: Errno.EEXIST,
+    ENOTDIR: Errno.ENOTDIR,
+    EISDIR: Errno.EISDIR,
+    EACCES: Errno.EACCES,
+    EPERM: Errno.EPERM,
+    ENOTEMPTY: Errno.ENOTEMPTY,
+    EINVAL: Errno.EINVAL,
+    ELOOP: Errno.ELOOP,
+    EXDEV: Errno.EXDEV,
+    ENOSPC: Errno.ENOSPC,
+    EMFILE: Errno.EMFILE,
+    ENAMETOOLONG: Errno.ENAMETOOLONG,
+    EBADF: Errno.EBADF,
+    EPIPE: Errno.EPIPE
+  };
+  return new PosixError(code && mapped[code] ? mapped[code] : Errno.EIO, message);
+}
+var DescriptorTable = class _DescriptorTable {
+  slots = /* @__PURE__ */ new Map();
+  /** Descriptions this table shares with others, so close counts correctly. */
+  static refs = /* @__PURE__ */ new WeakMap();
+  /** Install at a chosen number, closing whatever was there. */
+  set(fd, description, cloexec = false) {
+    if (fd < 0) throw new PosixError(Errno.EBADF);
+    const existing = this.slots.get(fd);
+    if (existing) this.release(existing.description);
+    this.slots.set(fd, { description, cloexec });
+    _DescriptorTable.refs.set(description, (_DescriptorTable.refs.get(description) ?? 0) + 1);
+    return fd;
+  }
+  /** Install at the lowest free number at or above `from`. */
+  add(description, cloexec = false, from = 0) {
+    let fd = from;
+    while (this.slots.has(fd)) fd += 1;
+    return this.set(fd, description, cloexec);
+  }
+  get(fd) {
+    const slot = this.slots.get(fd);
+    if (!slot) throw new PosixError(Errno.EBADF);
+    return slot.description;
+  }
+  has(fd) {
+    return this.slots.has(fd);
+  }
+  cloexec(fd) {
+    const slot = this.slots.get(fd);
+    if (!slot) throw new PosixError(Errno.EBADF);
+    return slot.cloexec;
+  }
+  setCloexec(fd, value) {
+    const slot = this.slots.get(fd);
+    if (!slot) throw new PosixError(Errno.EBADF);
+    slot.cloexec = value;
+  }
+  /** `dup`: a second name for one description, so the offset is shared. */
+  dup(fd, from = 0) {
+    return this.add(this.get(fd), false, from);
+  }
+  dup2(fd, target) {
+    const description = this.get(fd);
+    if (fd === target) return target;
+    return this.set(target, description, false);
+  }
+  close(fd) {
+    const slot = this.slots.get(fd);
+    if (!slot) throw new PosixError(Errno.EBADF);
+    this.slots.delete(fd);
+    this.release(slot.description);
+  }
+  /** Everything a child inherits: a spawn keeps all but the close-on-exec ones. */
+  inherit() {
+    const child = new _DescriptorTable();
+    for (const [fd, slot] of this.slots) {
+      if (slot.cloexec) continue;
+      child.set(fd, slot.description, false);
+    }
+    return child;
+  }
+  /** Drop every descriptor. Every resource has an owner and a cleanup path. */
+  closeAll() {
+    for (const fd of [...this.slots.keys()]) {
+      try {
+        this.close(fd);
+      } catch {
+      }
+    }
+  }
+  get openCount() {
+    return this.slots.size;
+  }
+  release(description) {
+    const refs = (_DescriptorTable.refs.get(description) ?? 1) - 1;
+    if (refs <= 0) {
+      _DescriptorTable.refs.delete(description);
+      description.close();
+    } else {
+      _DescriptorTable.refs.set(description, refs);
+    }
+  }
+};
+var FileService = class {
+  constructor(vfs, cred) {
+    this.vfs = vfs;
+    this.cred = cred;
+  }
+  vfs;
+  cred;
+  openInodes = /* @__PURE__ */ new Map();
+  open(path, flags, mode = 438) {
+    const exists = this.vfs.lexists(path);
+    if (flags & O_CREAT2 && flags & O_EXCL2 && exists) throw new PosixError(Errno.EEXIST);
+    if (!exists) {
+      if (!(flags & O_CREAT2)) throw new PosixError(Errno.ENOENT);
+      if (accessMode(flags) === O_RDONLY) throw new PosixError(Errno.EACCES);
+      try {
+        this.vfs.writeFile(path, new Uint8Array(), { cred: this.cred, mode });
+      } catch (error) {
+        throw toPosixError(error);
+      }
+    }
+    let stat2;
+    try {
+      stat2 = this.vfs.stat(path, { cred: this.cred });
+    } catch (error) {
+      throw toPosixError(error);
+    }
+    if (stat2.isDirectory()) {
+      if (accessMode(flags) !== O_RDONLY) throw new PosixError(Errno.EISDIR);
+      return new DirectoryDescription(path, flags, this.vfs, this.cred);
+    }
+    if (flags & O_DIRECTORY2) throw new PosixError(Errno.ENOTDIR);
+    const inode = this.inodeFor(stat2.ino, path);
+    const description = new FileDescription(inode, flags);
+    if (flags & O_TRUNC2 && accessMode(flags) !== O_RDONLY) description.truncate(0);
+    return description;
+  }
+  /**
+   * Remove a name.
+   *
+   * If something still has the file open, its contents move into the open
+   * description first: POSIX guarantees a reader keeps reading, and a volume
+   * that only knows about paths cannot provide that on its own.
+   */
+  unlink(path) {
+    let ino = null;
+    try {
+      ino = this.vfs.lstat(path).ino;
+    } catch (error) {
+      throw toPosixError(error);
+    }
+    const inode = ino === null ? void 0 : this.openInodes.get(ino);
+    if (inode && inode.refs > 0 && inode.path === path) inode.detach();
+    try {
+      this.vfs.unlink(path, this.cred);
+    } catch (error) {
+      throw toPosixError(error);
+    }
+    if (inode && inode.refs <= 0) this.openInodes.delete(ino);
+  }
+  /** Rename a name. Anything already open follows the file to its new name. */
+  rename(from, to) {
+    let ino = null;
+    try {
+      ino = this.vfs.lstat(from).ino;
+    } catch {
+    }
+    try {
+      this.vfs.rename(from, to, this.cred);
+    } catch (error) {
+      throw toPosixError(error);
+    }
+    if (ino === null) return;
+    const inode = this.openInodes.get(ino);
+    if (inode) inode.path = to;
+  }
+  /** One {@link Inode} per file identity, shared by every open description. */
+  inodeFor(ino, path) {
+    const existing = this.openInodes.get(ino);
+    if (existing) {
+      existing.path = path;
+      return existing;
+    }
+    const created = new Inode(ino, path, this.vfs, this.cred);
+    this.openInodes.set(ino, created);
+    return created;
+  }
+};
+
+// src/runtime/python/protocol.ts
+var ProtocolError = class extends Error {
+  code = "ERR_SBX_ABI_PROTOCOL";
+};
+function decodeRequest(frame) {
+  if (frame.length < SBX_REQUEST_HEADER_BYTES) throw new ProtocolError("short request frame");
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const header = {
+    version: view.getUint16(0, true),
+    op: view.getUint16(2, true),
+    requestId: view.getUint32(4, true),
+    generation: view.getUint32(8, true)
+  };
+  const length = view.getUint32(12, true);
+  if (frame.length - SBX_REQUEST_HEADER_BYTES < length) {
+    throw new ProtocolError(`truncated payload for ${OP_NAMES[header.op] ?? header.op}`);
+  }
+  return {
+    header,
+    payload: frame.subarray(SBX_REQUEST_HEADER_BYTES, SBX_REQUEST_HEADER_BYTES + length)
+  };
+}
+function encodeResponse(header, status, payload) {
+  const frame = new Uint8Array(SBX_RESPONSE_HEADER_BYTES + payload.length);
+  const view = new DataView(frame.buffer);
+  view.setUint16(0, header.version, true);
+  view.setUint16(2, header.op, true);
+  view.setUint32(4, header.requestId, true);
+  view.setUint32(8, header.generation, true);
+  view.setInt32(12, status, true);
+  view.setUint32(16, payload.length, true);
+  frame.set(payload, SBX_RESPONSE_HEADER_BYTES);
+  return frame;
+}
+var Reader = class {
+  at = 0;
+  view;
+  bytes;
+  constructor(bytes2) {
+    this.bytes = bytes2;
+    this.view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+  }
+  need(count) {
+    if (this.at + count > this.bytes.length) throw new ProtocolError("payload underrun");
+    const offset = this.at;
+    this.at += count;
+    return offset;
+  }
+  i32() {
+    return this.view.getInt32(this.need(4), true);
+  }
+  u32() {
+    return this.view.getUint32(this.need(4), true);
+  }
+  i64() {
+    return Number(this.view.getBigInt64(this.need(8), true));
+  }
+  u64() {
+    return Number(this.view.getBigUint64(this.need(8), true));
+  }
+  bytes32() {
+    const length = this.u32();
+    const offset = this.need(length);
+    return this.bytes.subarray(offset, offset + length);
+  }
+  string() {
+    return new TextDecoder().decode(this.bytes32());
+  }
+  get remaining() {
+    return this.bytes.length - this.at;
+  }
+};
+var Writer = class {
+  parts = [];
+  i32(value) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setInt32(0, value, true);
+    this.parts.push(b);
+    return this;
+  }
+  u32(value) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, value >>> 0, true);
+    this.parts.push(b);
+    return this;
+  }
+  i64(value) {
+    const b = new Uint8Array(8);
+    new DataView(b.buffer).setBigInt64(0, BigInt(Math.trunc(value)), true);
+    this.parts.push(b);
+    return this;
+  }
+  u64(value) {
+    const b = new Uint8Array(8);
+    new DataView(b.buffer).setBigUint64(0, BigInt(Math.trunc(value)), true);
+    this.parts.push(b);
+    return this;
+  }
+  bytes32(value) {
+    this.u32(value.length);
+    this.parts.push(value);
+    return this;
+  }
+  string(value) {
+    return this.bytes32(new TextEncoder().encode(value));
+  }
+  finish() {
+    const total = this.parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const part of this.parts) {
+      out.set(part, at);
+      at += part.length;
+    }
+    return out;
+  }
+};
+function failure(errno) {
+  return -Math.abs(errno);
+}
+
+// src/runtime/python/syscall-server.ts
+var MAX_TRANSFER = 8 * 1024 * 1024;
+function createHostAbiServer(proc) {
+  const files = new FileService(proc.vfs, proc.cred);
+  const started = Date.now();
+  const monotonicBase = typeof performance === "object" ? performance.now() : 0;
+  return async (frame) => {
+    const { header, payload } = decodeRequest(frame);
+    if (header.version !== SBX_HOST_ABI_VERSION) {
+      return encodeResponse(header, failure(Errno.EPROTO), new Uint8Array());
+    }
+    if (header.generation !== proc.generation) {
+      return encodeResponse(header, failure(Errno.ESRCH), new Uint8Array());
+    }
+    try {
+      const { status, payload: out } = await dispatch(header, new Reader(payload));
+      return encodeResponse(header, status, out ?? new Uint8Array());
+    } catch (error) {
+      const posix = toPosixError(error);
+      return encodeResponse(header, failure(posix.errno), new Uint8Array());
+    }
+  };
+  async function dispatch(header, r) {
+    switch (header.op) {
+      case Op.handshake: {
+        const w = new Writer().u32(SBX_HOST_ABI_VERSION).u32(CAPABILITIES.length);
+        for (const capability of CAPABILITIES) {
+          w.string(capability).u32(implemented(capability) ? 1 : 0);
+        }
+        return { status: 0, payload: w.finish() };
+      }
+      /* ------------------------------------------------------------ files */
+      case Op.openat: {
+        const path = resolve2(r.string());
+        const flags = r.u32();
+        const mode = r.u32();
+        const description = files.open(path, flags, mode);
+        return { status: proc.table.add(description, (flags & O_CLOEXEC) !== 0) };
+      }
+      case Op.close: {
+        proc.table.close(r.i32());
+        return { status: 0 };
+      }
+      case Op.read: {
+        const description = proc.table.get(r.i32());
+        const length = clamp(r.u32());
+        const data = await readBlocking(description, length);
+        return { status: data.length, payload: data };
+      }
+      case Op.write: {
+        const description = proc.table.get(r.i32());
+        const data = r.bytes32();
+        const written = await writeBlocking(description, data);
+        return { status: written };
+      }
+      case Op.pread: {
+        const description = proc.table.get(r.i32());
+        const length = clamp(r.u32());
+        const offset = r.u64();
+        if (!description.pread) throw new PosixError(Errno.ESPIPE);
+        const data = description.pread(length, offset);
+        return { status: data.length, payload: data };
+      }
+      case Op.pwrite: {
+        const description = proc.table.get(r.i32());
+        const data = r.bytes32();
+        const offset = r.u64();
+        if (!description.pwrite) throw new PosixError(Errno.ESPIPE);
+        return { status: description.pwrite(data, offset) };
+      }
+      case Op.lseek: {
+        const description = proc.table.get(r.i32());
+        const offset = r.i64();
+        const whence = r.u32();
+        if (!description.seek) throw new PosixError(Errno.ESPIPE);
+        return { status: 0, payload: new Writer().i64(description.seek(offset, whence)).finish() };
+      }
+      case Op.fstat: {
+        return { status: 0, payload: encodeStat(proc.table.get(r.i32()).stat()) };
+      }
+      case Op.statat: {
+        const path = resolve2(r.string());
+        const followLinks = r.u32() !== 0;
+        try {
+          const st = followLinks ? proc.vfs.stat(path, { cred: proc.cred }) : proc.vfs.lstat(path);
+          return {
+            status: 0,
+            payload: encodeStat({
+              ino: st.ino,
+              mode: st.mode,
+              size: st.size,
+              uid: st.uid,
+              gid: st.gid,
+              nlink: st.nlink ?? 1,
+              atimeMs: st.atimeMs,
+              mtimeMs: st.mtimeMs,
+              ctimeMs: st.ctimeMs
+            })
+          };
+        } catch (error) {
+          throw toPosixError(error);
+        }
+      }
+      case Op.ftruncate: {
+        const description = proc.table.get(r.i32());
+        const length = r.u64();
+        if (!description.truncate) throw new PosixError(Errno.EINVAL);
+        description.truncate(length);
+        return { status: 0 };
+      }
+      case Op.renameat: {
+        files.rename(resolve2(r.string()), resolve2(r.string()));
+        return { status: 0 };
+      }
+      case Op.unlinkat: {
+        const path = resolve2(r.string());
+        const removeDirectory = r.u32() !== 0;
+        if (removeDirectory) {
+          try {
+            proc.vfs.rmdir(path, proc.cred);
+          } catch (error) {
+            throw toPosixError(error);
+          }
+        } else {
+          files.unlink(path);
+        }
+        return { status: 0 };
+      }
+      case Op.mkdirat: {
+        const path = resolve2(r.string());
+        const mode = r.u32();
+        try {
+          proc.vfs.mkdir(path, { mode, cred: proc.cred });
+        } catch (error) {
+          throw toPosixError(error);
+        }
+        return { status: 0 };
+      }
+      case Op.readlinkat: {
+        try {
+          const target = proc.vfs.readlink(resolve2(r.string()), proc.cred);
+          return { status: 0, payload: new Writer().string(target).finish() };
+        } catch (error) {
+          throw toPosixError(error);
+        }
+      }
+      case Op.symlinkat: {
+        const target = r.string();
+        try {
+          proc.vfs.symlink(target, resolve2(r.string()), proc.cred);
+        } catch (error) {
+          throw toPosixError(error);
+        }
+        return { status: 0 };
+      }
+      case Op.getdents: {
+        const description = proc.table.get(r.i32());
+        if (description.kind !== "dir") throw new PosixError(Errno.ENOTDIR);
+        const data = description.read(clamp(r.u32()));
+        return { status: data.length, payload: data };
+      }
+      case Op.fsync: {
+        proc.table.get(r.i32());
+        return { status: 0 };
+      }
+      /* ------------------------------------------------------ descriptors */
+      case Op.dup:
+        return { status: proc.table.dup(r.i32(), r.u32()) };
+      case Op.dup2:
+        return { status: proc.table.dup2(r.i32(), r.i32()) };
+      case Op.get_flags: {
+        const fd = r.i32();
+        const description = proc.table.get(fd);
+        return { status: 0, payload: new Writer().u32(description.flags).u32(proc.table.cloexec(fd) ? 1 : 0).finish() };
+      }
+      case Op.set_flags: {
+        const fd = r.i32();
+        const flags = r.u32();
+        const cloexec = r.u32();
+        const description = proc.table.get(fd);
+        description.flags = accessMode(description.flags) | flags & -4;
+        proc.table.setCloexec(fd, cloexec !== 0);
+        return { status: 0 };
+      }
+      /* ------------------------------------------------------------ pipes */
+      case Op.pipe: {
+        const flags = r.u32();
+        const [readEnd, writeEnd] = createPipe(flags & O_NONBLOCK);
+        const cloexec = (flags & O_CLOEXEC) !== 0;
+        const readFd = proc.table.add(readEnd, cloexec);
+        const writeFd = proc.table.add(writeEnd, cloexec);
+        return { status: 0, payload: new Writer().i32(readFd).i32(writeFd).finish() };
+      }
+      /* -------------------------------------------------------- readiness */
+      case Op.poll: {
+        const count = r.u32();
+        const requests = [];
+        for (let i = 0; i < count; i += 1) requests.push({ fd: r.i32(), events: r.u32() });
+        const timeoutMs = r.i64();
+        const ready = await poll(requests, timeoutMs);
+        const w = new Writer().u32(ready.length);
+        for (const entry of ready) w.i32(entry.fd).u32(entry.revents);
+        return { status: ready.length, payload: w.finish() };
+      }
+      /* ------------------------------------------------------------- time */
+      case Op.clock_gettime: {
+        const monotonic = r.u32() !== 0;
+        const now = monotonic ? (typeof performance === "object" ? performance.now() : Date.now() - started) - monotonicBase : Date.now();
+        const nanos = Math.round(now * 1e6);
+        return { status: 0, payload: new Writer().i64(Math.floor(nanos / 1e9)).u32(nanos % 1e9).finish() };
+      }
+      case Op.sleep: {
+        const nanos = r.u64();
+        await sleep(nanos / 1e6);
+        return { status: proc.signal.aborted ? failure(Errno.EINTR) : 0 };
+      }
+      /* --------------------------------------------------------- identity */
+      case Op.getpid: {
+        const w = new Writer().i32(proc.pid).i32(proc.ppid).u32(proc.cred.uid).u32(proc.cred.gid).u32(proc.cred.umask ?? 18);
+        return { status: 0, payload: w.finish() };
+      }
+      case Op.getcwd:
+        return { status: 0, payload: new Writer().string(proc.cwd).finish() };
+      case Op.chdir: {
+        const path = resolve2(r.string());
+        let st;
+        try {
+          st = proc.vfs.stat(path, { cred: proc.cred });
+        } catch (error) {
+          throw toPosixError(error);
+        }
+        if (!st.isDirectory()) throw new PosixError(Errno.ENOTDIR);
+        proc.cwd = path;
+        return { status: 0 };
+      }
+      case Op.environ: {
+        const joined = Object.entries(proc.env).map(([key, value]) => `${key}=${value}`).join("\0");
+        return { status: 0, payload: new Writer().string(joined).finish() };
+      }
+      /* ---------------------------------------------------------- entropy */
+      case Op.getrandom: {
+        const length = Math.min(r.u32(), 65536);
+        const bytes2 = new Uint8Array(length);
+        crypto.getRandomValues(bytes2);
+        return { status: length, payload: bytes2 };
+      }
+      default:
+        return { status: failure(Errno.ENOSYS) };
+    }
+  }
+  function implemented(capability) {
+    return ["files", "descriptors", "pipes", "readiness", "time", "identity", "entropy"].includes(capability);
+  }
+  function resolve2(path) {
+    if (path.startsWith("/")) return proc.vfs.resolvePath(path);
+    return proc.vfs.resolvePath(`${proc.cwd.replace(/\/$/, "")}/${path}`);
+  }
+  function clamp(length) {
+    return Math.min(length, MAX_TRANSFER);
+  }
+  async function readBlocking(description, length) {
+    for (; ; ) {
+      try {
+        return description.read(length);
+      } catch (error) {
+        const posix = toPosixError(error);
+        if (posix.errno !== Errno.EAGAIN || description.flags & O_NONBLOCK) throw posix;
+      }
+      await Promise.race([description.whenReady(), aborted()]);
+      if (proc.signal.aborted) throw new PosixError(Errno.EINTR);
+    }
+  }
+  async function writeBlocking(description, data) {
+    for (; ; ) {
+      try {
+        return description.write(data);
+      } catch (error) {
+        const posix = toPosixError(error);
+        if (posix.errno !== Errno.EAGAIN || description.flags & O_NONBLOCK) throw posix;
+      }
+      await Promise.race([description.whenReady(), aborted()]);
+      if (proc.signal.aborted) throw new PosixError(Errno.EINTR);
+    }
+  }
+  const POLLIN = 1;
+  const POLLOUT = 4;
+  const POLLHUP = 16;
+  async function poll(requests, timeoutMs) {
+    const deadline = timeoutMs < 0 ? Infinity : Date.now() + timeoutMs;
+    for (; ; ) {
+      const ready = [];
+      const waits = [];
+      for (const { fd, events } of requests) {
+        let description;
+        try {
+          description = proc.table.get(fd);
+        } catch {
+          ready.push({ fd, revents: POLLHUP });
+          continue;
+        }
+        let revents = 0;
+        if (events & POLLIN && description.readable()) revents |= POLLIN;
+        if (events & POLLOUT && description.writable()) revents |= POLLOUT;
+        if (revents) ready.push({ fd, revents });
+        else waits.push(description.whenReady());
+      }
+      if (ready.length > 0) return ready;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return [];
+      await Promise.race([...waits, sleep(Math.min(remaining, 50)), aborted()]);
+      if (proc.signal.aborted) throw new PosixError(Errno.EINTR);
+    }
+  }
+  function aborted() {
+    if (proc.signal.aborted) return Promise.resolve();
+    return new Promise((resolve3) => proc.signal.addEventListener("abort", () => resolve3(), { once: true }));
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, Math.max(0, ms)));
+}
+function encodeStat(st) {
+  return new Writer().u64(st.ino).u32(st.mode).u64(st.size).u32(st.uid).u32(st.gid).u32(st.nlink).i64(Math.round(st.atimeMs * 1e6)).i64(Math.round(st.mtimeMs * 1e6)).i64(Math.round(st.ctimeMs * 1e6)).finish();
+}
+
+// src/runtime/python/sync-transport.ts
+var STATE = 0;
+var LENGTH = 1;
+var MORE = 2;
+var CONTROL_WORDS = 4;
+var STATE_REQUEST = 1;
+var STATE_RESPONSE = 2;
+var STATE_CONTINUE = 3;
+var STATE_CLOSED = 4;
+function createHostTransportBuffers(windowBytes = 1 << 20) {
+  return {
+    control: new SharedArrayBuffer(CONTROL_WORDS * Int32Array.BYTES_PER_ELEMENT),
+    data: new SharedArrayBuffer(windowBytes)
+  };
+}
+function syncTransportUnavailableReason() {
+  if (typeof globalThis.crossOriginIsolated === "boolean" && !globalThis.crossOriginIsolated) {
+    return "the page is not cross-origin isolated. Serve it with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp.";
+  }
+  if (typeof SharedArrayBuffer !== "function") return "SharedArrayBuffer is unavailable in this host.";
+  if (typeof Atomics !== "object" || typeof Atomics.wait !== "function") return "Atomics.wait is unavailable in this host.";
+  return null;
+}
+var HostCallServer = class {
+  control;
+  data;
+  capacity;
+  handle;
+  onFault;
+  incoming = [];
+  outgoing = null;
+  sent = 0;
+  closed = false;
+  constructor(buffers, handle, onFault = () => {
+  }) {
+    this.control = new Int32Array(buffers.control);
+    this.data = new Uint8Array(buffers.data);
+    this.capacity = this.data.length;
+    this.handle = handle;
+    this.onFault = onFault;
+  }
+  /** Call on each wake message from the client. */
+  async pump() {
+    if (this.closed) return;
+    const state = Atomics.load(this.control, STATE);
+    if (state === STATE_REQUEST) {
+      const size = Atomics.load(this.control, LENGTH);
+      this.incoming.push(this.data.slice(0, size));
+      if (Atomics.load(this.control, MORE) === 1) {
+        this.publish(STATE_CONTINUE);
+        return;
+      }
+      const request = concat3(this.incoming);
+      this.incoming = [];
+      let response;
+      try {
+        response = await this.handle(request);
+      } catch (error) {
+        this.onFault(error);
+        this.close();
+        return;
+      }
+      if (this.closed) return;
+      this.outgoing = response;
+      this.sent = 0;
+      this.sendWindow();
+      return;
+    }
+    if (state === STATE_CONTINUE) this.sendWindow();
+  }
+  /** Release a blocked client — container teardown, or the worker being killed. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    Atomics.store(this.control, STATE, STATE_CLOSED);
+    Atomics.notify(this.control, STATE);
+  }
+  sendWindow() {
+    const payload = this.outgoing ?? new Uint8Array();
+    const size = Math.min(this.capacity, payload.length - this.sent);
+    this.data.set(payload.subarray(this.sent, this.sent + size), 0);
+    this.sent += size;
+    Atomics.store(this.control, LENGTH, size);
+    Atomics.store(this.control, MORE, this.sent < payload.length ? 1 : 0);
+    this.publish(STATE_RESPONSE);
+  }
+  publish(state) {
+    Atomics.store(this.control, STATE, state);
+    Atomics.notify(this.control, STATE);
+  }
+};
+function concat3(parts) {
+  if (parts.length === 1) return parts[0];
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const joined = new Uint8Array(total);
+  let at = 0;
+  for (const part of parts) {
+    joined.set(part, at);
+    at += part.length;
+  }
+  return joined;
+}
+
+// src/runtime/worker-host.ts
+function defaultWorkerUrl() {
+  return new URL("./worker-entry.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+}
+function hasDomWorker() {
+  return typeof Worker === "function";
+}
+async function startRuntimeWorker(options = {}) {
+  const url = options.url ?? defaultWorkerUrl();
+  const worker = hasDomWorker() ? await startDomWorker(url) : await startNodeWorker(url, options.workerData ?? {});
+  try {
+    await new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new Error("the runtime worker did not start in time")), options.timeoutMs ?? 1e4);
+      worker.onMessage((message) => {
+        if (message?.type === "sandboxedjs:ready") {
+          clearTimeout(timer);
+          resolve2();
+        }
+      });
+      worker.onError((error) => {
+        clearTimeout(timer);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  } catch (error) {
+    try {
+      await worker.terminate();
+    } catch {
+    }
+    throw error;
+  }
+  return worker;
+}
+async function startDomWorker(url) {
+  const worker = new Worker(url, { type: "module" });
+  const listeners = [];
+  const errors = [];
+  worker.addEventListener("message", (event) => {
+    for (const listener of listeners) listener(event.data);
+  });
+  worker.addEventListener("error", (event) => {
+    const detail = event.message || "the runtime worker failed to load";
+    for (const listener of errors) listener(new Error(detail));
+  });
+  return {
+    postMessage: (message) => worker.postMessage(message),
+    onMessage: (listener) => {
+      listeners.push(listener);
+    },
+    onError: (listener) => {
+      errors.push(listener);
+    },
+    terminate: () => worker.terminate()
+  };
+}
+async function startNodeWorker(url, workerData) {
+  const specifier = ["node", "worker_threads"].join(":");
+  const { Worker: NodeWorker } = await import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    specifier
+  );
+  const worker = new NodeWorker(url, { workerData });
+  return {
+    postMessage: (message) => worker.postMessage(message),
+    onMessage: (listener) => worker.on("message", listener),
+    onError: (listener) => worker.on("error", listener),
+    terminate: () => worker.terminate()
+  };
+}
+
+// src/runtime/python/supervisor.ts
+var nextGeneration = 1;
+async function startPythonProcess(options) {
+  const unavailable2 = syncTransportUnavailableReason();
+  if (unavailable2) {
+    throw new Error(`The SandboxedJs Python runtime needs blocking worker calls: ${unavailable2}`);
+  }
+  const generation = nextGeneration++;
+  const stdin = new StreamDescription(O_RDONLY, null, options.isTty);
+  const stdout = new StreamDescription(O_WRONLY, options.onStdout, options.isTty);
+  const stderr = new StreamDescription(O_WRONLY, options.onStderr, options.isTty);
+  const table = new DescriptorTable();
+  table.set(0, stdin);
+  table.set(1, stdout);
+  table.set(2, stderr);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  options.signal.addEventListener("abort", abort, { once: true });
+  const handle = createHostAbiServer({
+    pid: options.pid,
+    ppid: options.ppid,
+    generation,
+    vfs: options.vfs,
+    cred: options.cred,
+    table,
+    env: options.env,
+    cwd: options.cwd,
+    signal: controller.signal
+  });
+  const buffers = createHostTransportBuffers();
+  let fault = null;
+  const server = new HostCallServer(buffers, handle, (error) => {
+    fault = error;
+  });
+  let worker = null;
+  let settle = () => {
+  };
+  let blame = () => {
+  };
+  const finished = new Promise((resolve2, reject) => {
+    settle = resolve2;
+    blame = reject;
+  });
+  let done = false;
+  const cleanup = () => {
+    if (done) return;
+    done = true;
+    options.signal.removeEventListener("abort", abort);
+    server.close();
+    table.closeAll();
+    try {
+      worker?.terminate();
+    } catch {
+    }
+  };
+  worker = await startRuntimeWorker({ url: options.workerUrl });
+  worker.onMessage((message) => {
+    const detail = message;
+    if (detail?.type === "wake") {
+      void server.pump();
+      return;
+    }
+    if (detail?.type === "exit") {
+      cleanup();
+      settle(detail.code ?? 0);
+      return;
+    }
+    if (detail?.type === "failed") {
+      cleanup();
+      blame(new Error(detail.message ?? "the Python process failed to start"));
+    }
+  });
+  worker.onError((error) => {
+    cleanup();
+    blame(error instanceof Error ? error : new Error(String(error)));
+  });
+  controller.signal.addEventListener("abort", () => {
+    if (done) return;
+    cleanup();
+    settle(130);
+  });
+  worker.postMessage({
+    type: "start",
+    buffers,
+    generation,
+    moduleUrl: options.manifest.artifacts.moduleUrl,
+    argv: options.argv,
+    env: options.env,
+    cwd: options.cwd,
+    pid: options.pid,
+    ppid: options.ppid,
+    mounts: options.mounts,
+    isTty: options.isTty
+  });
+  return {
+    write: (data) => stdin.push(data),
+    endInput: () => stdin.end(),
+    kill: () => controller.abort(),
+    wait: async () => {
+      const code = await finished;
+      if (fault) throw fault;
+      return code;
+    }
+  };
+}
+var END_OF_CENTRAL_DIRECTORY = 101010256;
+var CENTRAL_FILE_HEADER = 33639248;
+var ZIP64_END_LOCATOR = 117853008;
+var ZIP64_END_OF_CENTRAL_DIRECTORY = 101075792;
+var ZipError = class extends Error {
+  code = "ERR_ZIP";
+};
+function readZip(archive) {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const end = findEndOfCentralDirectory(archive);
+  let entryCount = view.getUint16(end + 10, true);
+  let directoryOffset = view.getUint32(end + 16, true);
+  if (entryCount === 65535 || directoryOffset === 4294967295) {
+    const locator = findSignature(archive, ZIP64_END_LOCATOR, end);
+    if (locator < 0) throw new ZipError("zip64 archive without an end locator");
+    const zip64End = Number(view.getBigUint64(locator + 8, true));
+    if (view.getUint32(zip64End, true) !== ZIP64_END_OF_CENTRAL_DIRECTORY) {
+      throw new ZipError("zip64 end record not found where the locator says");
+    }
+    entryCount = Number(view.getBigUint64(zip64End + 32, true));
+    directoryOffset = Number(view.getBigUint64(zip64End + 48, true));
+  }
+  const entries = [];
+  let at = directoryOffset;
+  for (let i = 0; i < entryCount; i += 1) {
+    if (view.getUint32(at, true) !== CENTRAL_FILE_HEADER) {
+      throw new ZipError(`central directory entry ${i} has a bad signature`);
+    }
+    const flags = view.getUint16(at + 8, true);
+    if (flags & 1) throw new ZipError("encrypted archives are not supported");
+    const method = view.getUint16(at + 10, true);
+    const compressedSize = view.getUint32(at + 20, true);
+    const uncompressedSize = view.getUint32(at + 24, true);
+    const nameLength = view.getUint16(at + 28, true);
+    const extraLength = view.getUint16(at + 30, true);
+    const commentLength = view.getUint16(at + 32, true);
+    const externalAttributes = view.getUint32(at + 38, true);
+    const localOffset = view.getUint32(at + 42, true);
+    const name = new TextDecoder().decode(archive.subarray(at + 46, at + 46 + nameLength));
+    entries.push({
+      name,
+      /* The high 16 bits are the Unix mode when the archive was made on Unix.
+       * pip relies on it for console scripts, which have to stay executable. */
+      mode: externalAttributes >>> 16,
+      isDirectory: name.endsWith("/"),
+      data: () => extract(archive, view, localOffset, method, compressedSize, uncompressedSize, name)
+    });
+    at += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+function extract(archive, view, localOffset, method, compressedSize, uncompressedSize, name) {
+  const nameLength = view.getUint16(localOffset + 26, true);
+  const extraLength = view.getUint16(localOffset + 28, true);
+  const start2 = localOffset + 30 + nameLength + extraLength;
+  const body = archive.subarray(start2, start2 + compressedSize);
+  if (method === 0) return body.slice();
+  if (method !== 8) throw new ZipError(`${name}: unsupported compression method ${method}`);
+  const inflated = pako.inflateRaw(body);
+  if (inflated.length !== uncompressedSize) {
+    throw new ZipError(`${name}: inflated to ${inflated.length} bytes, the directory says ${uncompressedSize}`);
+  }
+  return inflated;
+}
+function findEndOfCentralDirectory(archive, view) {
+  const at = findSignature(archive, END_OF_CENTRAL_DIRECTORY, archive.length);
+  if (at < 0) throw new ZipError("not a zip archive: no end-of-central-directory record");
+  return at;
+}
+function findSignature(archive, signature, before) {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  for (let at = Math.min(before, archive.length) - 4; at >= 0; at -= 1) {
+    if (view.getUint32(at, true) === signature) return at;
+  }
+  return -1;
+}
+
+// src/runtime/python/pypi.ts
+var ACCEPTED_TAGS = ["py3-none-any", "py2.py3-none-any", "py3-none-emscripten"];
+function parseRequirement(text2) {
+  const cleaned = text2.replace(/#.*$/, "").trim();
+  if (!cleaned) return null;
+  const [head2, marker = null] = splitOnce(cleaned, ";");
+  const match2 = /^([A-Za-z0-9._-]+)\s*(\[[^\]]*\])?\s*(.*)$/.exec(head2.trim());
+  if (!match2) return null;
+  const [, name, extrasGroup = "", rest = ""] = match2;
+  const specifiers = [];
+  for (const part of rest.split(",")) {
+    const spec = /^\s*(===|==|>=|<=|!=|~=|>|<)\s*([A-Za-z0-9.*+!-]+)\s*$/.exec(part);
+    if (spec) specifiers.push({ op: spec[1], version: spec[2] });
+  }
+  return {
+    name: normalize2(name),
+    specifiers,
+    extras: extrasGroup.slice(1, -1).split(",").map((e) => e.trim()).filter(Boolean),
+    marker: marker?.trim() ?? null
+  };
+}
+function normalize2(name) {
+  return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+function markerApplies(marker, environment, extras) {
+  if (!marker) return true;
+  const evaluateClause = (clause) => {
+    const match2 = /^\s*([A-Za-z_]+)\s*(===|==|!=|>=|<=|>|<|not in|in)\s*(.+?)\s*$/.exec(clause);
+    if (!match2) return false;
+    const [, variable, op, rawValue] = match2;
+    const value = rawValue.replace(/^['"]|['"]$/g, "");
+    if (variable === "extra") {
+      const wanted = extras.includes(value);
+      return op === "==" ? wanted : op === "!=" ? !wanted : false;
+    }
+    const actual = environment[variable];
+    if (actual === void 0) return false;
+    if (op === "in") return value.includes(actual);
+    if (op === "not in") return !value.includes(actual);
+    if (variable === "python_version" || variable === "python_full_version") {
+      return compareVersions(actual, value, op);
+    }
+    return op === "==" || op === "===" ? actual === value : op === "!=" ? actual !== value : false;
+  };
+  if (marker.includes("(")) return false;
+  return marker.split(/\s+or\s+/).some((group) => group.split(/\s+and\s+/).every(evaluateClause));
+}
+function compareVersions(left, right, op) {
+  if (op === "==" || op === "===") {
+    if (right.endsWith(".*")) return left.startsWith(right.slice(0, -1));
+    return releaseOf(left).join(".") === releaseOf(right).join(".");
+  }
+  if (op === "!=") return !compareVersions(left, right, "==");
+  const order = compareRelease(releaseOf(left), releaseOf(right));
+  if (op === ">=") return order >= 0;
+  if (op === "<=") return order <= 0;
+  if (op === ">") return order > 0;
+  if (op === "<") return order < 0;
+  if (op === "~=") {
+    const bound = releaseOf(right).slice(0, -1);
+    return order >= 0 && compareRelease(releaseOf(left).slice(0, bound.length), bound) === 0;
+  }
+  return false;
+}
+function releaseOf(version) {
+  const release = /^\s*v?(\d+(?:\.\d+)*)/.exec(version.trim());
+  return release ? release[1].split(".").map(Number) : [0];
+}
+function compareRelease(left, right) {
+  for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+    const difference = (left[i] ?? 0) - (right[i] ?? 0);
+    if (difference !== 0) return difference > 0 ? 1 : -1;
+  }
+  return 0;
+}
+function isPreRelease(version) {
+  return /(a|b|rc|dev|post)\d*$/i.test(version.replace(/^\d+(\.\d+)*/, ""));
+}
+async function resolvePackageCandidates(client, requirement, environment) {
+  const index = await client.json(`https://pypi.org/pypi/${requirement.name}/json`);
+  const candidates = Object.keys(index.releases).filter((version) => requirement.specifiers.every((s) => compareVersions(version, s.version, s.op))).sort((a, b) => compareRelease(releaseOf(a), releaseOf(b)));
+  const stable = candidates.filter((version) => !isPreRelease(version));
+  const ordered = (stable.length > 0 ? stable : candidates).reverse();
+  let sawSourceOnly = false;
+  const resolved = [];
+  for (const version of ordered) {
+    const files = (index.releases[version] ?? []).filter((file3) => !file3.yanked);
+    const wheel = pickWheel(files);
+    if (wheel) {
+      resolved.push({
+        name: requirement.name,
+        version,
+        url: wheel.url,
+        filename: wheel.filename,
+        sha256: wheel.digests?.sha256 ?? "",
+        requires: []
+      });
+      continue;
+    }
+    if (files.some((file3) => file3.packagetype === "sdist")) sawSourceOnly = true;
+  }
+  if (resolved.length > 0) return resolved;
+  if (ordered.length === 0) {
+    throw new Error(
+      `no version of ${requirement.name} matches ${describe(requirement)}`
+    );
+  }
+  throw new Error(
+    sawSourceOnly ? `${requirement.name} ${ordered[0]} publishes only a source distribution, and this runtime cannot build one yet (source builds are a later milestone)` : `${requirement.name} ${ordered[0]} has no wheel this runtime can use; it needs one tagged ` + ACCEPTED_TAGS.join(" or ")
+  );
+}
+function pickWheel(files) {
+  const wheels = files.filter((file3) => file3.packagetype === "bdist_wheel");
+  for (const tag2 of ACCEPTED_TAGS) {
+    const match2 = wheels.find((file3) => file3.filename.endsWith(`-${tag2}.whl`));
+    if (match2) return match2;
+  }
+  return null;
+}
+function describe(requirement) {
+  return requirement.specifiers.length === 0 ? "any version" : requirement.specifiers.map((s) => `${s.op}${s.version}`).join(", ");
+}
+function splitOnce(text2, separator) {
+  const at = text2.indexOf(separator);
+  return at < 0 ? [text2] : [text2.slice(0, at), text2.slice(at + 1)];
+}
+
+// src/runtime/python/install.ts
+var SITE_PACKAGES = "/usr/lib/python3.13/site-packages";
+var SCRIPTS = "/usr/local/bin";
+function markerEnvironment(pythonVersion) {
+  const [major = "3", minor = "13"] = pythonVersion.split(".");
+  return {
+    python_version: `${major}.${minor}`,
+    python_full_version: pythonVersion,
+    sys_platform: "emscripten",
+    platform_system: "Emscripten",
+    platform_machine: "wasm32",
+    implementation_name: "cpython",
+    os_name: "posix"
+  };
+}
+async function installRequirements(options) {
+  const environment = markerEnvironment(options.pythonVersion);
+  const report = { installed: [], skipped: [] };
+  const queue = [];
+  for (const text2 of options.requirements) {
+    const requirement = parseRequirement(text2);
+    if (requirement) queue.push({ requirement, extras: requirement.extras });
+  }
+  const archives = /* @__PURE__ */ new Map();
+  const unavailable2 = /* @__PURE__ */ new Set();
+  const candidateCache = /* @__PURE__ */ new Map();
+  const solve = async (pending, state) => {
+    if (pending.length === 0) return state;
+    const [first, ...tail2] = pending;
+    let { requirement, extras } = first;
+    const rest = [];
+    const mergedSpecifiers = [...requirement.specifiers];
+    const mergedExtras = new Set(extras);
+    for (const item of tail2) {
+      if (item.requirement.name === requirement.name && markerApplies(item.requirement.marker, environment, item.extras)) {
+        mergedSpecifiers.push(...item.requirement.specifiers);
+        for (const extra of item.extras) mergedExtras.add(extra);
+      } else {
+        rest.push(item);
+      }
+    }
+    requirement = { ...requirement, specifiers: mergedSpecifiers };
+    extras = [...mergedExtras];
+    if (!markerApplies(requirement.marker, environment, extras)) {
+      return solve(rest, {
+        ...state,
+        skipped: [...state.skipped, { name: requirement.name, marker: requirement.marker ?? "" }]
+      });
+    }
+    const already = state.chosen.get(requirement.name);
+    if (already) {
+      const satisfied = requirement.specifiers.every(
+        (s) => compareVersions(already.version, s.version, s.op)
+      );
+      if (!satisfied) {
+        throw new Error(
+          `${requirement.name} ${already.version} is already selected but another dependency needs ` + requirement.specifiers.map((s) => `${s.op}${s.version}`).join(", ")
+        );
+      }
+      return solve(rest, state);
+    }
+    options.progress.collecting(requirement.name);
+    if (unavailable2.has(requirement.name)) {
+      throw new Error(`${requirement.name} has no wheel this runtime can use`);
+    }
+    const candidateKey = `${requirement.name}:${requirement.specifiers.map((s) => `${s.op}${s.version}`).join(",")}`;
+    let candidatePromise = candidateCache.get(candidateKey);
+    if (!candidatePromise) {
+      candidatePromise = resolvePackageCandidates(options.client, requirement);
+      candidateCache.set(candidateKey, candidatePromise);
+    }
+    let candidates;
+    try {
+      candidates = await candidatePromise;
+    } catch (error) {
+      const anyKey = `${requirement.name}:`;
+      let anyPromise = candidateCache.get(anyKey);
+      if (!anyPromise) {
+        anyPromise = resolvePackageCandidates(
+          options.client,
+          { ...requirement, specifiers: [] });
+        candidateCache.set(anyKey, anyPromise);
+      }
+      try {
+        await anyPromise;
+      } catch {
+        unavailable2.add(requirement.name);
+      }
+      throw error;
+    }
+    let failure2;
+    for (const resolved of candidates) {
+      try {
+        let entries = archives.get(resolved.url);
+        if (!entries) {
+          options.progress.downloading(resolved.name, resolved.version);
+          entries = readZip(await options.client.bytes(resolved.url));
+          archives.set(resolved.url, entries);
+        }
+        const dependencies = [];
+        const metadata = entries.find((entry) => /\.dist-info\/METADATA$/.test(entry.name));
+        if (metadata) {
+          for (const line of new TextDecoder().decode(metadata.data()).split(/\r?\n/)) {
+            if (!line.startsWith("Requires-Dist:")) continue;
+            const dependency = parseRequirement(line.slice("Requires-Dist:".length));
+            if (dependency && markerApplies(dependency.marker, environment, extras)) {
+              dependencies.push({ requirement: dependency, extras: dependency.extras });
+            }
+          }
+        }
+        const chosen = new Map(state.chosen);
+        chosen.set(requirement.name, resolved);
+        return await solve([...dependencies, ...rest], {
+          chosen,
+          staged: [...state.staged, ...stageWheel(entries, resolved)],
+          installed: [...state.installed, { name: resolved.name, version: resolved.version }],
+          skipped: state.skipped
+        });
+      } catch (error) {
+        failure2 = error;
+      }
+    }
+    throw failure2 instanceof Error ? failure2 : new Error(`could not resolve ${requirement.name}`);
+  };
+  const solved = await solve(queue, {
+    chosen: /* @__PURE__ */ new Map(),
+    staged: [],
+    installed: [],
+    skipped: []
+  });
+  report.installed = solved.installed;
+  report.skipped = solved.skipped;
+  commit(options.vfs, options.cred, solved.staged);
+  return report;
+}
+function stageWheel(entries, resolved) {
+  const staged = [];
+  for (const entry of entries) {
+    if (entry.isDirectory) continue;
+    const dataPath = /^[^/]+\.data\/(purelib|platlib|scripts)\/(.+)$/.exec(entry.name);
+    if (dataPath) {
+      const [, scheme, relative2] = dataPath;
+      staged.push({
+        path: scheme === "scripts" ? `${SCRIPTS}/${relative2}` : `${SITE_PACKAGES}/${relative2}`,
+        data: entry.data(),
+        ...scheme === "scripts" ? { mode: 493 } : {}
+      });
+      continue;
+    }
+    if (/^[^/]+\.data\//.test(entry.name)) continue;
+    staged.push({ path: `${SITE_PACKAGES}/${entry.name}`, data: entry.data() });
+  }
+  const entryPoints = entries.find((entry) => /\.dist-info\/entry_points\.txt$/.test(entry.name));
+  if (entryPoints) {
+    for (const [name, target] of consoleScripts(new TextDecoder().decode(entryPoints.data()))) {
+      staged.push({ path: `${SCRIPTS}/${name}`, data: new TextEncoder().encode(consoleLauncher(target)), mode: 493 });
+    }
+  }
+  return staged;
+}
+function commit(vfs, cred, staged) {
+  const directories = /* @__PURE__ */ new Set();
+  for (const file3 of staged) directories.add(file3.path.slice(0, file3.path.lastIndexOf("/")));
+  for (const directory2 of directories) vfs.mkdir(directory2, { recursive: true, cred });
+  for (const file3 of staged) {
+    vfs.writeFile(file3.path, file3.data, { cred, ...file3.mode === void 0 ? {} : { mode: file3.mode } });
+    if (file3.mode !== void 0) vfs.chmod(file3.path, file3.mode, cred);
+  }
+}
+function consoleScripts(text2) {
+  const result = [];
+  let section = "";
+  for (const raw of text2.split(/\r?\n/)) {
+    const line = raw.trim();
+    const heading = /^\[([^\]]+)\]$/.exec(line);
+    if (heading) {
+      section = heading[1];
+      continue;
+    }
+    if (section !== "console_scripts" || line === "" || line.startsWith("#")) continue;
+    const assignment = /^([^=\s]+)\s*=\s*([^\s;]+)(?:\s*;.*)?$/.exec(line);
+    if (assignment) result.push([assignment[1], assignment[2].replace(/\s*\[.*\]$/, "")]);
+  }
+  return result;
+}
+function consoleLauncher(target) {
+  const [module, attribute = ""] = target.split(":", 2);
+  return `#!/usr/bin/python3
+import sys
+from importlib import import_module
+entry = import_module(${JSON.stringify(module)})
+for part in ${JSON.stringify(attribute)}.split('.'):
+    if part:
+        entry = getattr(entry, part)
+raise SystemExit(entry())
+`;
+}
+
+// src/runtime/python/backend.ts
+function withSitePackages(env2) {
+  const existing = env2.PYTHONPATH;
+  return {
+    ...env2,
+    PYTHONPATH: existing ? `${SITE_PACKAGES}:${existing}` : SITE_PACKAGES,
+    /* Installed packages live on a host-mounted VFS. Rewriting hundreds of
+     * cache files on every short-lived WASM process is wasted work and can
+     * exhaust the synchronous host-call bridge during large import graphs. */
+    PYTHONDONTWRITEBYTECODE: env2.PYTHONDONTWRITEBYTECODE ?? "1"
+  };
+}
+var INTERPRETER_OWNED = /* @__PURE__ */ new Set(["lib", "dev", "proc", "usr"]);
+async function resolveWorkerUrl(explicit) {
+  if (explicit) {
+    try {
+      return new URL(explicit);
+    } catch {
+      return explicit;
+    }
+  }
+  const beside = new URL("./python-worker.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  if (beside.protocol !== "file:") return beside;
+  const [{ existsSync }, { fileURLToPath: fileURLToPath2, pathToFileURL: pathToFileURL2 }] = await Promise.all([
+    nodeBuiltin("fs"),
+    nodeBuiltin("url")
+  ]);
+  if (existsSync(fileURLToPath2(beside))) return beside;
+  const built = new URL("../../../dist/python-worker.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  if (existsSync(fileURLToPath2(built))) return pathToFileURL2(fileURLToPath2(built));
+  throw new Error(
+    "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");
+  const mounts = containerMounts(ctx);
+  const process2 = await startPythonProcess({
+    manifest,
+    workerUrl: await resolveWorkerUrl(workerUrl),
+    vfs: ctx.vfs,
+    cred: ctx.cred,
+    pid: ctx.proc.pid,
+    ppid: ctx.proc.ppid ?? 1,
+    argv,
+    env: withSitePackages(ctx.env),
+    cwd: ctx.cwd,
+    isTty: isTerminal(ctx),
+    mounts,
+    onStdout: (data) => ctx.stdout.write(data),
+    onStderr: (data) => ctx.stderr.write(data),
+    signal: ctx.signal
+  });
+  void pumpStdin(ctx, process2);
+  return process2.wait();
+}
+async function pumpStdin(ctx, proc) {
+  const stdin = ctx.stdin;
+  try {
+    for (; ; ) {
+      const chunk = await stdin.read(65536);
+      if (chunk === null || chunk.length === 0) break;
+      proc.write(chunk);
+    }
+  } catch {
+  }
+  proc.endInput();
+}
+function isTerminal(ctx) {
+  const stdin = ctx.stdin;
+  return Boolean(stdin.isTTY || stdin.interactive);
+}
+function containerMounts(ctx) {
+  const mounts = [];
+  let entries;
+  try {
+    entries = ctx.vfs.readdir("/", ctx.cred);
+  } catch {
+    return mounts;
+  }
+  for (const name of entries) {
+    if (INTERPRETER_OWNED.has(name)) continue;
+    try {
+      if (!ctx.vfs.stat(`/${name}`, { cred: ctx.cred }).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    mounts.push({ guest: `/${name}`, container: `/${name}` });
+  }
+  try {
+    if (ctx.vfs.stat(SITE_PACKAGES, { cred: ctx.cred }).isDirectory()) {
+      mounts.push({ guest: SITE_PACKAGES, container: SITE_PACKAGES });
+    }
+  } catch {
+  }
+  try {
+    if (ctx.vfs.stat(SCRIPTS, { cred: ctx.cred }).isDirectory()) {
+      mounts.push({ guest: SCRIPTS, container: SCRIPTS });
+    }
+  } catch {
+  }
+  return mounts;
+}
+
+// src/runtime/python/pip-command.ts
+var pipCommand = defineCommand({
+  name: "pip",
+  path: "/usr/bin/pip",
+  aliases: ["pip3"],
+  summary: "install Python wheels into the container's site-packages",
+  usage: "pip install [-r requirements.txt] <package>...",
+  manual: `Resolves wheels from PyPI and unpacks them into ${SITE_PACKAGES}, which
+the interpreter has on sys.path.
+
+This is not pip. It installs published wheels only: there are no source builds,
+no editable installs, no uninstall, and one site-packages rather than virtual
+environments. A package with no usable wheel is an error, never a silent skip.`,
+  async run(ctx) {
+    const [action, ...args] = ctx.args;
+    if (action === "--version" || action === "-V") {
+      ctx.line(`pip (sandboxedjs wheel installer, not pip) targeting ${SITE_PACKAGES}`);
+      return 0;
+    }
+    if (action === "list") {
+      return listInstalled(ctx);
+    }
+    if (action !== "install") {
+      ctx.line("usage: pip install [-r requirements.txt] <package>...");
+      return action === void 0 ? 1 : 0;
+    }
+    const requirements = [];
+    for (let i = 0; i < args.length; i += 1) {
+      const arg = args[i];
+      if (arg === "-r" || arg === "--requirement") {
+        const file3 = args[++i];
+        if (!file3) return ctx.fail("option -r requires a file", 2);
+        try {
+          requirements.push(
+            ...ctx.vfs.readText(ctx.path(file3), ctx.cred).split(/\r?\n/).map((line) => line.replace(/#.*$/, "").trim()).filter(Boolean)
+          );
+        } catch {
+          return ctx.fail(`could not open requirements file '${file3}'`);
+        }
+        continue;
+      }
+      if (arg.startsWith("-")) continue;
+      requirements.push(arg);
+    }
+    if (requirements.length === 0) return ctx.fail("no packages specified");
+    if (!ctx.kernel.net.outboundAllowed("https://pypi.org")) {
+      return ctx.fail(
+        "outbound network access is disabled for this container (enable with network: { allowOutbound: true })"
+      );
+    }
+    const jsonCache = /* @__PURE__ */ new Map();
+    const bytesCache = /* @__PURE__ */ new Map();
+    const client = {
+      async json(url) {
+        let pending = jsonCache.get(url);
+        if (!pending) {
+          pending = fetch(url).then((response) => {
+            if (!response.ok) throw new Error(`${url} answered ${response.status}`);
+            return response.json();
+          });
+          jsonCache.set(url, pending);
+        }
+        return pending;
+      },
+      async bytes(url) {
+        let pending = bytesCache.get(url);
+        if (!pending) {
+          pending = fetch(url).then(async (response) => {
+            if (!response.ok) throw new Error(`${url} answered ${response.status}`);
+            return new Uint8Array(await response.arrayBuffer());
+          });
+          bytesCache.set(url, pending);
+        }
+        return pending;
+      }
+    };
+    try {
+      const report = await installRequirements({
+        client,
+        vfs: ctx.vfs,
+        cred: ctx.cred,
+        requirements,
+        pythonVersion: pythonBackend().manifest?.pythonVersion ?? "3.13.5",
+        progress: {
+          collecting: (name) => ctx.line(`Collecting ${name}`),
+          downloading: () => {
+          }
+        }
+      });
+      for (const skipped of report.skipped) {
+        ctx.line(`  Skipping ${skipped.name} (marker: ${skipped.marker})`);
+      }
+      ctx.line(
+        `Successfully installed ${report.installed.map((p) => `${p.name}-${p.version}`).join(" ")}`
+      );
+      return 0;
+    } catch (error) {
+      return ctx.fail(error.message ?? String(error));
+    }
+  }
+});
+function listInstalled(ctx) {
+  let entries;
+  try {
+    entries = ctx.vfs.readdir(SITE_PACKAGES, ctx.cred);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const match2 = /^(.+)-(.+)\.dist-info$/.exec(entry);
+    if (match2) ctx.line(`${match2[1]} ${match2[2]}`);
+  }
+  return 0;
+}
+
+// src/runtime/emscripten-fs.ts
+init_errno();
+init_path();
+var EM_ERRNO = {
+  EPERM: 63,
+  ENOENT: 44,
+  EIO: 29,
+  EBADF: 8,
+  EACCES: 2,
+  EBUSY: 10,
+  EEXIST: 20,
+  EXDEV: 75,
+  ENODEV: 43,
+  ENOTDIR: 54,
+  EISDIR: 31,
+  EINVAL: 28,
+  ENFILE: 41,
+  EMFILE: 33,
+  ENOSPC: 51,
+  EROFS: 57,
+  ENOTEMPTY: 55,
+  ELOOP: 32,
+  ENOSYS: 52,
+  ENOTSUP: 138
+};
+function emErrno(code) {
+  return EM_ERRNO[code] ?? EM_ERRNO.EIO;
+}
+function mountContainerFs(FS, opts) {
+  const { vfs, cred } = opts;
+  const throwErrno = (code) => {
+    throw new FS.ErrnoError(emErrno(code));
+  };
+  const translate = (e) => {
+    if (isSysError(e)) return throwErrno(e.code);
+    throw new FS.ErrnoError(emErrno("EIO"));
+  };
+  const mountRoot = opts.mountAt ? normalize(opts.mountAt) : "/";
+  const backend = {
+    /** Absolute container path for a node. */
+    realPath(node2) {
+      const parts = [];
+      let current = node2;
+      while (current && current.parent !== current) {
+        parts.unshift(current.name);
+        current = current.parent;
+      }
+      const relative2 = parts.join("/");
+      if (mountRoot === "/") return "/" + relative2;
+      return relative2 ? join(mountRoot, relative2) : mountRoot;
+    },
+    mount(_mount) {
+      return backend.createNode(null, "/", 16877 | 0, 0);
+    },
+    createNode(parent, name, mode, rdev) {
+      const node2 = FS.createNode(parent, name, mode, rdev);
+      node2.node_ops = nodeOps;
+      node2.stream_ops = streamOps;
+      return node2;
+    }
+  };
+  const nodeOps = {
+    getattr(node2) {
+      const path = backend.realPath(node2);
+      try {
+        const st = vfs.lstat(path);
+        return {
+          dev: st.dev,
+          ino: st.ino,
+          mode: st.mode,
+          nlink: st.nlink,
+          uid: st.uid,
+          gid: st.gid,
+          rdev: st.rdev,
+          size: st.size,
+          atime: new Date(st.atimeMs),
+          mtime: new Date(st.mtimeMs),
+          ctime: new Date(st.ctimeMs),
+          blksize: 4096,
+          blocks: Math.ceil(st.size / 512)
+        };
+      } catch (e) {
+        return translate(e);
+      }
+    },
+    setattr(node2, attr) {
+      const path = backend.realPath(node2);
+      try {
+        if (attr.mode !== void 0) {
+          vfs.chmod(path, attr.mode & 4095, cred);
+          node2.mode = attr.mode;
+        }
+        if (attr.timestamp !== void 0) vfs.utimes(path, attr.timestamp, attr.timestamp, cred);
+        if (attr.size !== void 0) {
+          vfs.truncate(path, attr.size, cred);
+          opts.onWrite?.(path);
+        }
+      } catch (e) {
+        translate(e);
+      }
+    },
+    lookup(parent, name) {
+      const path = join(backend.realPath(parent), name);
+      let mode;
+      try {
+        mode = vfs.lstat(path).mode;
+      } catch {
+        throw new FS.ErrnoError(EM_ERRNO.ENOENT);
+      }
+      return backend.createNode(parent, name, mode, 0);
+    },
+    mknod(parent, name, mode, dev) {
+      const path = join(backend.realPath(parent), name);
+      try {
+        if (FS.isDir(mode)) {
+          vfs.mkdir(path, { cred, mode: mode & 4095 });
+        } else if (FS.isFile(mode)) {
+          vfs.writeFile(path, new Uint8Array(0), { cred, mode: mode & 4095 });
+        } else {
+          return throwErrno("ENOTSUP");
+        }
+        opts.onWrite?.(path);
+      } catch (e) {
+        translate(e);
+      }
+      return backend.createNode(parent, name, mode, dev);
+    },
+    rename(oldNode, newDir, newName) {
+      const from = backend.realPath(oldNode);
+      const to = join(backend.realPath(newDir), newName);
+      try {
+        vfs.rename(from, to, cred);
+        opts.onWrite?.(to);
+      } catch (e) {
+        translate(e);
+      }
+      oldNode.name = newName;
+      oldNode.parent = newDir;
+    },
+    unlink(parent, name) {
+      const path = join(backend.realPath(parent), name);
+      try {
+        vfs.unlink(path, cred);
+        opts.onWrite?.(path);
       } catch (e) {
         translate(e);
       }
@@ -18715,9 +20876,9 @@ async function resolveIndexUrl() {
   if (indexUrl) return indexUrl;
   if (!isNode2) return DEFAULT_BROWSER_INDEX_URL;
   try {
-    const { createRequire: createRequire2 } = await nodeBuiltin("module");
+    const { createRequire } = await nodeBuiltin("module");
     const path = await nodeBuiltin("path");
-    const require2 = createRequire2(path.join(process.cwd(), "index.js"));
+    const require2 = createRequire(path.join(process.cwd(), "index.js"));
     return `${path.dirname(require2.resolve("pyodide/package.json"))}/`;
   } catch {
     return void 0;
@@ -18997,6 +21158,12 @@ var micropip = defineCommand({
   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)");
@@ -19083,6 +21250,11 @@ var micropip = defineCommand({
 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 } : {}
+  });
 }
 var isPythonAvailable = isCPythonAvailable;
 var python = defineCommand({
@@ -19095,6 +21267,13 @@ var python = defineCommand({
 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, ctx.args);
+      } catch (error) {
+        return ctx.fail(error.message ?? String(error));
+      }
+    }
     const argv = ctx.args;
     let i = 0;
     let command;
@@ -19175,22 +21354,22 @@ function printHelp2(ctx) {
   ctx.line("-V     : print the Python version and exit");
 }
 function pythonCommands() {
-  return [python, micropip];
+  return usingOwnedPython() ? [python, pipCommand] : [python, micropip];
 }
 
 // src/runtime/ffmpeg.ts
 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";
 var compiled = null;
 async function loadFactory() {
-  const { createRequire: createRequire2 } = await nodeBuiltin("module");
+  const { createRequire } = await nodeBuiltin("module");
   const fs = await nodeBuiltin("fs/promises");
   const path = await nodeBuiltin("path");
-  const packageRequire = createRequire2((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  const packageRequire = createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
   let require2 = packageRequire;
   try {
     require2.resolve("@ffmpeg/core/wasm");
   } catch {
-    require2 = createRequire2(path.join(process.cwd(), "index.js"));
+    require2 = createRequire(path.join(process.cwd(), "index.js"));
   }
   const wasmPath = require2.resolve("@ffmpeg/core/wasm");
   const wasm = await fs.readFile(wasmPath);
@@ -21719,19 +23898,19 @@ var KernelChildProcess = class {
   process;
   started = false;
   cancelled = false;
-  constructor(kernel, cred, config, pid) {
+  constructor(kernel, cred, config2, pid) {
     this.stdin.interactive = true;
-    if (config.inheritStdio) this.stdin.isTTY = true;
-    if (config.stdinIgnored) this.stdin.end();
+    if (config2.inheritStdio) this.stdin.isTTY = true;
+    if (config2.stdinIgnored) this.stdin.end();
     this.stdin.onRawMode = (enabled) => this.emit("rawmode", enabled);
     this.kernel = kernel;
     this.cred = cred;
     this.pid = pid;
-    this.command = config.command;
-    this.args = config.args?.slice() ?? [];
-    this.parentPid = config.parentPid;
-    this.cwd = config.cwd ?? "/";
-    this.env = { ...config.env };
+    this.command = config2.command;
+    this.args = config2.args?.slice() ?? [];
+    this.parentPid = config2.parentPid;
+    this.cwd = config2.cwd ?? "/";
+    this.env = { ...config2.env };
   }
   on(event, listener) {
     let listeners = this.listeners.get(event);
@@ -21838,12 +24017,12 @@ var nextBridgePid = 1073741824;
 function installNodeChildProcessBridge(pod, kernel, cred) {
   const manager = pod.processManager;
   const originalSpawn = manager.spawn;
-  manager.spawn = (config) => {
-    const resolved = kernel.resolveExecutable(config.command, config.cwd ?? "/", config.env ?? {}, cred);
+  manager.spawn = (config2) => {
+    const resolved = kernel.resolveExecutable(config2.command, config2.cwd ?? "/", config2.env ?? {}, cred);
     if (resolved?.kind === "builtin") {
-      return new KernelChildProcess(kernel, cred, config, nextBridgePid++);
+      return new KernelChildProcess(kernel, cred, config2, nextBridgePid++);
     }
-    return originalSpawn.call(manager, config);
+    return originalSpawn.call(manager, config2);
   };
   return () => {
     if (manager.spawn === originalSpawn) return;
@@ -23205,14 +25384,14 @@ var AssertionError = class extends Error {
   code = "ERR_ASSERTION";
   constructor(options) {
     const generated = options.message === void 0;
-    super(options.message ?? describe(options.actual, options.expected, options.operator));
+    super(options.message ?? describe2(options.actual, options.expected, options.operator));
     this.actual = options.actual;
     this.expected = options.expected;
     this.operator = options.operator;
     this.generatedMessage = generated;
   }
 };
-function describe(actual, expected, operator) {
+function describe2(actual, expected, operator) {
   if (operator === "fail") return "Failed";
   const rendered = (value) => inspect(value, { depth: 2 });
   return `${rendered(actual)} ${operator} ${rendered(expected)}`;
@@ -24050,9 +26229,9 @@ var VirtualClientRequest = class extends streamModule4__default.default.Writable
     } catch (error) {
       clearTimeout(this.timer);
       if (this.destroyedByUser) return;
-      const failure = error instanceof Error ? error : new Error(String(error));
-      if (!("code" in failure)) Object.assign(failure, { code: "ECONNREFUSED" });
-      this.emit("error", failure);
+      const failure2 = error instanceof Error ? error : new Error(String(error));
+      if (!("code" in failure2)) Object.assign(failure2, { code: "ECONNREFUSED" });
+      this.emit("error", failure2);
     } finally {
       if (!settled) untrack();
     }
@@ -24250,17 +26429,17 @@ function toBytes2(data, encoding) {
 }
 
 // src/runtime/sync-channel.ts
-var STATE = 0;
-var LENGTH = 1;
-var MORE = 2;
-var CONTROL_WORDS = 4;
-var STATE_REQUEST = 1;
-var STATE_RESPONSE = 2;
-var STATE_CONTINUE = 3;
-var STATE_CLOSED = 4;
+var STATE2 = 0;
+var LENGTH2 = 1;
+var MORE2 = 2;
+var CONTROL_WORDS2 = 4;
+var STATE_REQUEST2 = 1;
+var STATE_RESPONSE2 = 2;
+var STATE_CONTINUE2 = 3;
+var STATE_CLOSED2 = 4;
 function createSyncChannelBuffers(capacityBytes = 1 << 20) {
   return {
-    control: new SharedArrayBuffer(CONTROL_WORDS * Int32Array.BYTES_PER_ELEMENT),
+    control: new SharedArrayBuffer(CONTROL_WORDS2 * Int32Array.BYTES_PER_ELEMENT),
     data: new SharedArrayBuffer(capacityBytes)
   };
 }
@@ -24294,15 +26473,15 @@ var SyncChannelServer = class {
   /** Call from the wake message the client sends after each chunk. */
   async pump() {
     if (this.closed) return;
-    const state = Atomics.load(this.control, STATE);
-    if (state === STATE_REQUEST) {
-      const size = Atomics.load(this.control, LENGTH);
+    const state = Atomics.load(this.control, STATE2);
+    if (state === STATE_REQUEST2) {
+      const size = Atomics.load(this.control, LENGTH2);
       this.incoming.push(this.data.slice(0, size));
-      if (Atomics.load(this.control, MORE) === 1) {
-        this.publish(STATE_CONTINUE);
+      if (Atomics.load(this.control, MORE2) === 1) {
+        this.publish(STATE_CONTINUE2);
         return;
       }
-      const request = concat3(this.incoming);
+      const request = concat4(this.incoming);
       this.incoming = [];
       let response;
       try {
@@ -24316,30 +26495,30 @@ var SyncChannelServer = class {
       this.sendChunk();
       return;
     }
-    if (state === STATE_CONTINUE) this.sendChunk();
+    if (state === STATE_CONTINUE2) this.sendChunk();
   }
   /** Release a blocked client, e.g. when the container is torn down. */
   close() {
     if (this.closed) return;
     this.closed = true;
-    Atomics.store(this.control, STATE, STATE_CLOSED);
-    Atomics.notify(this.control, STATE);
+    Atomics.store(this.control, STATE2, STATE_CLOSED2);
+    Atomics.notify(this.control, STATE2);
   }
   sendChunk() {
     const payload = this.outgoing ?? new Uint8Array();
     const size = Math.min(this.capacity, payload.length - this.sent);
     this.data.set(payload.subarray(this.sent, this.sent + size), 0);
     this.sent += size;
-    Atomics.store(this.control, LENGTH, size);
-    Atomics.store(this.control, MORE, this.sent < payload.length ? 1 : 0);
-    this.publish(STATE_RESPONSE);
+    Atomics.store(this.control, LENGTH2, size);
+    Atomics.store(this.control, MORE2, this.sent < payload.length ? 1 : 0);
+    this.publish(STATE_RESPONSE2);
   }
   publish(state) {
-    Atomics.store(this.control, STATE, state);
-    Atomics.notify(this.control, STATE);
+    Atomics.store(this.control, STATE2, state);
+    Atomics.notify(this.control, STATE2);
   }
 };
-function concat3(parts) {
+function concat4(parts) {
   if (parts.length === 1) return parts[0];
   const total = parts.reduce((sum, part) => sum + part.length, 0);
   const joined = new Uint8Array(total);
@@ -24472,13 +26651,13 @@ ${err.join("")}`),
     return child;
   };
   const exec = (command, options = {}, callback) => {
-    const [opts, cb] = normalize2(options, callback);
+    const [opts, cb] = normalize3(options, callback);
     const { file: file3, args } = throughShell(command, opts);
     return collect(start2(file3, args, { ...opts, shell: false }), opts, cb);
   };
   const execFile = (file3, args = [], options = {}, callback) => {
     const list = Array.isArray(args) ? args : [];
-    const [opts, cb] = Array.isArray(args) ? normalize2(options, callback) : normalize2(args, options);
+    const [opts, cb] = Array.isArray(args) ? normalize3(options, callback) : normalize3(args, options);
     return collect(start2(file3, list, opts), opts, cb);
   };
   return {
@@ -24550,7 +26729,7 @@ ${result.stderr}`), {
   const execSync = (command, options = {}) => orThrow(run(command, [], { ...options, shell: options.shell ?? true }), command, options);
   return { spawnSync, execFileSync, execSync };
 }
-function normalize2(options, callback) {
+function normalize3(options, callback) {
   if (typeof options === "function") return [{}, options];
   return [options ?? {}, callback];
 }
@@ -24942,7 +27121,7 @@ function createReadlineModule(defaultInput, defaultOutput = () => void 0) {
       }
     }
   }
-  const isTerminal = (options, output) => {
+  const isTerminal2 = (options, output) => {
     if (typeof options?.terminal === "boolean") return options.terminal;
     return Boolean(output?.isTTY);
   };
@@ -24952,13 +27131,13 @@ function createReadlineModule(defaultInput, defaultOutput = () => void 0) {
       const instance = new Interface(
         options.input ?? defaultInput(),
         resolvedOutput2,
-        isTerminal(options, resolvedOutput2)
+        isTerminal2(options, resolvedOutput2)
       );
       if (typeof options.prompt === "string") instance.setPrompt(options.prompt);
       return instance;
     }
     const resolvedOutput = output;
-    return new Interface(options ?? defaultInput(), resolvedOutput, isTerminal(void 0, resolvedOutput));
+    return new Interface(options ?? defaultInput(), resolvedOutput, isTerminal2(void 0, resolvedOutput));
   };
   const noop = () => {
   };
@@ -26925,44 +29104,69 @@ function ensureProcessGlobal() {
     configurable: true
   });
 }
+
+// src/runtime/rolldown-node-binding.ts
+async function loadNodeApi() {
+  const [moduleApi, fsApi, pathApi, urlApi] = await Promise.all([
+    nodeBuiltin("module"),
+    nodeBuiltin("fs"),
+    nodeBuiltin("path"),
+    nodeBuiltin("url")
+  ]);
+  return {
+    createRequire: moduleApi.createRequire,
+    existsSync: fsApi.existsSync,
+    readFileSync: fsApi.readFileSync,
+    dirname: pathApi.dirname,
+    join: pathApi.join,
+    fileURLToPath: urlApi.fileURLToPath,
+    pathToFileURL: urlApi.pathToFileURL
+  };
+}
 var BINDING_PACKAGE = "@rolldown/binding-wasm32-wasi";
 var ASYNC_WORK_POOL_SIZE = 4;
 var WORKER_FILE = "rolldown-wasi-worker.js";
 async function loadNodeRolldownMemfsBinding() {
-  const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  const node2 = await loadNodeApi();
+  const { createRequire, existsSync, readFileSync, dirname: dirname3, join: join3, fileURLToPath: fileURLToPath2, pathToFileURL: pathToFileURL2 } = node2;
+  const require2 = createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
   let packageDir;
   try {
-    packageDir = path.dirname(require2.resolve(`${BINDING_PACKAGE}/package.json`));
+    packageDir = dirname3(require2.resolve(`${BINDING_PACKAGE}/package.json`));
   } catch {
     return null;
   }
-  const fromBinding = module$1.createRequire(path.join(packageDir, "package.json"));
+  const fromBinding = createRequire(join3(packageDir, "package.json"));
   let runtime;
   let fsModuleUrl;
   let createContext2;
   try {
     runtime = fromBinding("@napi-rs/wasm-runtime");
-    fsModuleUrl = resolveSubpath(fromBinding, "@napi-rs/wasm-runtime", "./fs");
+    fsModuleUrl = resolveSubpath(node2, fromBinding, "@napi-rs/wasm-runtime", "./fs");
     ({ createContext: createContext2 } = fromBinding("@emnapi/runtime"));
   } catch {
     return null;
   }
-  const { memfs } = await import(fsModuleUrl);
-  const { Worker: Worker2 } = await import('worker_threads');
+  const { memfs } = await import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    fsModuleUrl
+  );
+  const { Worker: Worker2 } = await nodeBuiltin("worker_threads");
   const { fs: memoryFs, vol } = memfs();
   const wasi2 = new runtime.WASI({
     version: "preview1",
     fs: memoryFs,
     preopens: { "/": "/" }
   });
-  const wasmFile = fs.readFileSync(path.join(packageDir, "rolldown-binding.wasm32-wasi.wasm"));
+  const wasmFile = readFileSync(join3(packageDir, "rolldown-binding.wasm32-wasi.wasm"));
   const sharedMemory = new WebAssembly.Memory({ initial: 16384, maximum: 65536, shared: true });
   const workerPoolSize = Math.max(2, cpuCount());
   const context = createContext2({ autoDestroy: false });
   context.suppressDestroy();
-  const workerPath = resolveWorkerPath();
+  const workerPath = resolveWorkerPath(node2);
   if (!workerPath) return null;
-  const runtimeAnchor = url.pathToFileURL(path.join(packageDir, "package.json")).href;
+  const runtimeAnchor = pathToFileURL2(join3(packageDir, "package.json")).href;
   const workers = /* @__PURE__ */ new Set();
   let started = false;
   const { napiModule } = await runtime.instantiateNapiModule(wasmFile, {
@@ -27014,24 +29218,26 @@ async function loadNodeRolldownMemfsBinding() {
   for (const worker of workers) unreferenceWorker(worker);
   return { ...napiModule.exports, __fs: memoryFs, __volume: vol };
 }
-function resolveWorkerPath() {
-  const here = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+function resolveWorkerPath(node2) {
+  const { dirname: dirname3, existsSync, fileURLToPath: fileURLToPath2, join: join3 } = node2;
+  const here = dirname3(fileURLToPath2((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
   const candidates = [
-    path.join(here, WORKER_FILE),
+    join3(here, WORKER_FILE),
     /* src/runtime → dist, for a checkout that has been built. */
-    path.join(here, "..", "..", "dist", WORKER_FILE)
+    join3(here, "..", "..", "dist", WORKER_FILE)
   ];
-  return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync(candidate)) ?? null;
 }
-function resolveSubpath(require2, packageName, subpath) {
-  const packageDir = path.dirname(require2.resolve(packageName));
-  const manifest = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf8"));
+function resolveSubpath(node2, require2, packageName, subpath) {
+  const { dirname: dirname3, join: join3, pathToFileURL: pathToFileURL2, readFileSync } = node2;
+  const packageDir = dirname3(require2.resolve(packageName));
+  const manifest = JSON.parse(readFileSync(join3(packageDir, "package.json"), "utf8"));
   const entry = manifest?.exports?.[subpath];
   const target = typeof entry === "string" ? entry : entry?.import ?? entry?.default;
   if (typeof target !== "string") {
     throw new Error(`${packageName} does not export ${subpath}`);
   }
-  return url.pathToFileURL(path.join(packageDir, target)).href;
+  return pathToFileURL2(join3(packageDir, target)).href;
 }
 function cpuCount() {
   try {
@@ -27210,9 +29416,9 @@ var LocalProcess = class extends EventEmitter4__default.default {
   }
 };
 var PodChildProcess = class {
-  constructor(pid, config, launch) {
+  constructor(pid, config2, launch) {
     this.pid = pid;
-    this.config = config;
+    this.config = config2;
     this.launch = launch;
   }
   pid;
@@ -27350,15 +29556,54 @@ var LocalRuntimePod = class _LocalRuntimePod {
   instanceId = `sbx-${Math.random().toString(36).slice(2)}`;
   router = new VirtualHttpRouter();
   proxy = { activePorts: (_instanceId) => this.router.activePorts() };
+  /**
+   * Bind a port to a server that is not a JavaScript one.
+   *
+   * The request is flattened to bytes and headers before it crosses the
+   * boundary, because the far side is a different language and a Node stream
+   * object cannot go there. What comes back is a complete response; streaming
+   * is a later protocol, and pretending to stream over a buffered path would
+   * only move the surprise.
+   */
+  serveExternal(port, owner, handler) {
+    const server = new VirtualHttpServer(this.router, owner);
+    server.on("request", (request, response) => {
+      void (async () => {
+        const chunks = [];
+        for await (const chunk of request) chunks.push(chunk);
+        const body = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+        let at = 0;
+        for (const chunk of chunks) {
+          body.set(chunk, at);
+          at += chunk.length;
+        }
+        try {
+          const answer = await handler({
+            method: request.method,
+            path: request.url,
+            headers: request.headers,
+            body
+          });
+          response.writeHead(answer.statusCode, answer.headers ?? {});
+          response.end(answer.body ?? "");
+        } catch (error) {
+          response.writeHead(500, { "content-type": "text/plain" });
+          response.end(error instanceof Error ? error.message : String(error));
+        }
+      })();
+    });
+    server.listen(port);
+    return () => server.close();
+  }
   /**
    * Mutable on purpose: a container replaces `spawn` so that children resolve
    * against the kernel's PATH. Left alone, it runs `node` and reports anything
    * else as not found, which is the correct answer for a bare pod.
    */
   processManager = {
-    spawn: (config) => new PodChildProcess(
+    spawn: (config2) => new PodChildProcess(
       nextChildPid++,
-      config,
+      config2,
       (child) => this.spawn(child.command, child.args ?? [], {
         ...child.cwd ? { cwd: child.cwd } : {},
         ...child.env ? { env: child.env } : {}
@@ -27431,7 +29676,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
           if (engine?.isEvaluating) throw new ProcessExit(code);
         },
         http: { router: this.router, owner, ...this.fetch ? { fetch: this.fetch } : {} },
-        spawnChild: (config) => this.processManager.spawn(config),
+        spawnChild: (config2) => this.processManager.spawn(config2),
         ...typeof options.stdinPath === "string" ? { stdinPath: options.stdinPath } : {},
         ...options.interactiveStdin ? { interactiveStdin: true } : {},
         ...options.tty ? { tty: true } : {},
@@ -27652,10 +29897,10 @@ function serveVolume(volume) {
       }
       return encodeFrame({ ok: true, value: result });
     } catch (error) {
-      const failure = error;
+      const failure2 = error;
       return encodeFrame({
         ok: false,
-        error: { ...failure.code ? { code: failure.code } : {}, message: failure.message ?? String(error) }
+        error: { ...failure2.code ? { code: failure2.code } : {}, message: failure2.message ?? String(error) }
       });
     }
   };
@@ -27672,7 +29917,7 @@ function serveSyncSyscalls(options) {
       const result = await options.spawnChild(header.args[0]);
       return encodeFrame({ ok: true, value: result });
     } catch (error) {
-      const failure = error;
+      const failure2 = error;
       return encodeFrame({
         ok: true,
         value: {
@@ -27680,81 +29925,10 @@ function serveSyncSyscalls(options) {
           stdout: "",
           stderr: "",
           signal: null,
-          error: { ...failure.code ? { code: failure.code } : {}, message: failure.message ?? String(error) }
-        }
-      });
-    }
-  };
-}
-
-// src/runtime/worker-host.ts
-function defaultWorkerUrl() {
-  return new URL("./worker-entry.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-}
-function hasDomWorker() {
-  return typeof Worker === "function";
-}
-async function startRuntimeWorker(options = {}) {
-  const url = options.url ?? defaultWorkerUrl();
-  const worker = hasDomWorker() ? await startDomWorker(url) : await startNodeWorker(url, options.workerData ?? {});
-  try {
-    await new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => reject(new Error("the runtime worker did not start in time")), options.timeoutMs ?? 1e4);
-      worker.onMessage((message) => {
-        if (message?.type === "sandboxedjs:ready") {
-          clearTimeout(timer);
-          resolve2();
+          error: { ...failure2.code ? { code: failure2.code } : {}, message: failure2.message ?? String(error) }
         }
       });
-      worker.onError((error) => {
-        clearTimeout(timer);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      });
-    });
-  } catch (error) {
-    try {
-      await worker.terminate();
-    } catch {
     }
-    throw error;
-  }
-  return worker;
-}
-async function startDomWorker(url) {
-  const worker = new Worker(url, { type: "module" });
-  const listeners = [];
-  const errors = [];
-  worker.addEventListener("message", (event) => {
-    for (const listener of listeners) listener(event.data);
-  });
-  worker.addEventListener("error", (event) => {
-    const detail = event.message || "the runtime worker failed to load";
-    for (const listener of errors) listener(new Error(detail));
-  });
-  return {
-    postMessage: (message) => worker.postMessage(message),
-    onMessage: (listener) => {
-      listeners.push(listener);
-    },
-    onError: (listener) => {
-      errors.push(listener);
-    },
-    terminate: () => worker.terminate()
-  };
-}
-async function startNodeWorker(url, workerData) {
-  const specifier = ["node", "worker_threads"].join(":");
-  const { Worker: NodeWorker } = await import(
-    /* @vite-ignore */
-    /* webpackIgnore: true */
-    specifier
-  );
-  const worker = new NodeWorker(url, { workerData });
-  return {
-    postMessage: (message) => worker.postMessage(message),
-    onMessage: (listener) => worker.on("message", listener),
-    onError: (listener) => worker.on("error", listener),
-    terminate: () => worker.terminate()
   };
 }
 var WorkerProcess = class extends EventEmitter4__default.default {
@@ -28018,8 +30192,8 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
           ...request.inheritStdio ? { inheritStdio: true } : {}
         });
       } catch (error) {
-        const failure = error;
-        resolve2({ status: null, stdout: "", stderr: "", signal: null, error: { ...failure.code ? { code: failure.code } : {}, message: failure.message } });
+        const failure2 = error;
+        resolve2({ status: null, stdout: "", stderr: "", signal: null, error: { ...failure2.code ? { code: failure2.code } : {}, message: failure2.message } });
         return;
       }
       owned.add(handle);
@@ -28074,7 +30248,7 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
   async forward(worker, port, request, response) {
     const chunks = [];
     for await (const chunk of request) chunks.push(chunk);
-    const body = concat4(chunks);
+    const body = concat5(chunks);
     const id = this.nextRequestId++;
     const answered = new Promise((resolve2) => this.waiting.set(id, resolve2));
     worker.postMessage({
@@ -28155,7 +30329,7 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function concat4(parts) {
+function concat5(parts) {
   if (parts.length === 0) return new Uint8Array();
   if (parts.length === 1) return parts[0];
   const total = parts.reduce((sum, part) => sum + part.length, 0);
@@ -29306,6 +31480,8 @@ exports.KERNEL_NAME = KERNEL_NAME;
 exports.KERNEL_RELEASE = KERNEL_RELEASE;
 exports.Kernel = Kernel;
 exports.LocalRuntimePod = LocalRuntimePod;
+exports.MANIFEST_FORMAT = MANIFEST_FORMAT;
+exports.MANIFEST_SCHEMA_VERSION = MANIFEST_SCHEMA_VERSION;
 exports.MemoryVolume = MemoryVolume;
 exports.NODE_VERSION = NODE_VERSION;
 exports.NPM_VERSION = NPM_VERSION;
@@ -29387,6 +31563,7 @@ exports.strerror = strerror;
 exports.syncChannelSupported = syncChannelSupported;
 exports.transformEsm = transformEsm;
 exports.unameInfo = unameInfo;
+exports.validateManifest = validateManifest;
 exports.wasiCommand = wasi;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map