sandboxedjs 0.1.50 → 0.1.52

package/README.md

@@ -89,7 +89,7 @@ it alongside their model provider.
 | **Shell** | POSIX `sh` (54 builtins) — pipelines, redirection, here-docs, globbing, brace/parameter/arithmetic/command expansion, functions, `if`/`for`/`while`/`case`/`select`, job control, traps, arrays, `[[ ]]`, `(( ))` |
 | **Coreutils** | 154 programs — `ls cat cp mv rm mkdir grep sed awk find head tail sort uniq wc cut tr tee xargs chmod chown ln du df ps tar gzip base64 sha256sum diff curl wget` and the rest — plus 54 shell builtins |
 | **Node.js** | Its own module engine — `require` *and* `import`, live bindings, `exports` maps, top-level `await`, npm packages, `http`, `fs`, streams, `child_process` |
-| **Python** | CPython 3.13 (Pyodide) on the *same* filesystem, with the real standard library |
+| **Python** | Source-built CPython 3.13/WASM on the *same* filesystem, with the real standard library |
 | **WebAssembly** | A WASI (`preview1`) host — run any `wasm32-wasi` binary from clang, Rust, Zig or TinyGo as an ordinary process, on the same filesystem |
 | **FFmpeg** | `ffmpeg` and `ffprobe` (FFmpeg 5.1) reading and writing container files directly — [optional install](#video-and-audio) |
 | **`/proc`** | Live and synthesised — `ps`, `top`, `free` and `uptime` all read the same source |
@@ -391,7 +391,7 @@ your disk.
 
 ### Python
 
-Python is CPython 3.13, via Pyodide, mounted on the container's filesystem:
+Python is the bundled, source-built CPython 3.13 WebAssembly runtime mounted on the container's filesystem:
 
 ```ts
 await box.exec("python3 -c \"print(open('/etc/hostname').read())\"");
@@ -401,8 +401,10 @@ await box.exec("echo '1 2 3' | python3 -c \"import sys; print(sum(map(int, sys.s
 
 The bundled standard library includes `json`, `re`, `os`, `sys`, `math`, `random`, `hashlib`,
 `binascii`, `struct`, `time`, `collections`, `itertools`, `functools`, `asyncio` and more. It is
-Real CPython, so `sqlite3`, `dataclasses`, `decimal` and `typing` all work. Packages must be built for WebAssembly: `micropip` installs pure-Python wheels, and Pyodide's own distribution covers the rest
-(and only with outbound networking enabled).
+It is real CPython, so `sqlite3`, `dataclasses`, `decimal`, `typing`, `ssl`, and
+`asyncio` work. `pip` installs compatible wheels into the same filesystem and
+creates their `console_scripts` in `/usr/local/bin` (with outbound networking
+enabled). Native extensions still need an Emscripten-compatible build.
 
 ### WebAssembly binaries
 
@@ -701,20 +703,21 @@ Those use dynamic imports, so they only fail if you call them.
 
 ### Python in a browser
 
-Python works lazily in a browser without extra configuration. On first use,
-SandboxedJS loads the matching Pyodide runtime and assets from jsDelivr:
+Python works lazily in a browser without extra configuration. The owned CPython
+runtime and its pthread worker are shipped with the npm package:
 
 ```ts
 const box = await createContainer();
 await box.exec("python3 -c 'import sqlite3; print(sqlite3.sqlite_version)'");
 ```
 
-To self-host Pyodide or use another trusted CDN, override both URLs:
+Pyodide remains available as an explicit compatibility backend:
 
 ```ts
 import { configurePython, createContainer } from "sandboxedjs";
 
 configurePython({
+  backend: "pyodide",
   pyodideURL: "https://cdn.jsdelivr.net/pyodide/v0.28.3/full/pyodide.mjs",
   indexURL: "https://cdn.jsdelivr.net/pyodide/v0.28.3/full/",
 });
@@ -723,8 +726,8 @@ const box = await createContainer();
 await box.exec("python3 -c 'import sqlite3; print(sqlite3.sqlite_version)'");
 ```
 
-Python never falls back to a host interpreter or another runtime. A custom
-Pyodide module and its asset directory must use the same Pyodide version.
+Python never falls back to a host interpreter. When selecting the optional
+Pyodide backend, its module and asset directory must use the same version.
 
 ## Uploading files
 
@@ -972,11 +975,10 @@ Honest list of what does not work:
   now?" and run `npm install && npm run dev` from the shell instead.
 - **No `net`, `tls`, `worker_threads` or `vm`.** `http` and `https` are served by a virtual stack
   that `request()` talks to directly, so servers work; raw sockets do not.
-- **Python is CPython via Pyodide.** The standard library is the real one. A C
-  extension works only if it has been built for WebAssembly — Pyodide ships
-  many, including `numpy`, but an arbitrary wheel from PyPI will not install.
-  Starting an interpreter costs about a second and a half; one is kept per
-  container, and each program runs in its own namespace.
+- **Python is source-built CPython/WASM.** Each program gets its own interpreter
+  process worker. Pure-Python wheels install normally; native extensions must
+  be linked or published for Emscripten. Pydantic 2's `pydantic-core` is not
+  currently available, so use a Pydantic 1 constraint for FastAPI deployments.
 - **No real sockets.** HTTP servers work through the request proxy; raw TCP/UDP does not.
 - **No real processes.** Processes are cooperative async tasks: `kill -9` cannot interrupt a
   tight synchronous loop, and `SIGSTOP` only marks state.

package/dist/agent.d.cts

@@ -1,4 +1,4 @@
-import { C as Container } from './container-Dg8NwBc7.cjs';
+import { C as Container } from './container-B--ykWn3.cjs';
 import './vfs-DzEcPbMY.cjs';
 
 /**

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
-import { C as Container } from './container-DBMPLbUu.js';
+import { C as Container } from './container-BSW6jjlq.js';
 import './vfs-DzEcPbMY.js';
 
 /**

package/dist/{container-Dg8NwBc7.d.cts → container-B--ykWn3.d.cts}

@@ -1053,7 +1053,7 @@ declare class Shell {
 declare const MANIFEST_FORMAT = "sandboxedjs-python-runtime";
 declare const MANIFEST_SCHEMA_VERSION = 1;
 /** Build profiles, as defined in docs/python/architecture.md. */
-type PythonProfile = "core" | "threaded-fixed" | "threaded-dynamic";
+type PythonProfile = "core" | "threaded-fixed" | "dynamic";
 interface PythonCapabilities {
     /** Real Python threads. `core` builds have none, and must say so. */
     threads: boolean;
@@ -1101,6 +1101,54 @@ interface PythonRuntimeManifest {
  */
 declare function validateManifest(value: unknown): PythonRuntimeManifest;
 
+/**
+ * Dependency resolution for the owned Python runtime.
+ *
+ * The installer this replaces walked candidate versions and downloaded a whole
+ * wheel for each one just to read its `METADATA`. That is why it needed an
+ * arbitrary cap on how many candidates it would try: without one, discovering
+ * that a package's last forty releases all need the same unavailable native
+ * extension cost forty multi-megabyte downloads, and the install looked hung
+ * rather than failed. The cap made the symptom bearable and the cause worse --
+ * a resolution that hit it reported a limit rather than the conflict, and a
+ * legitimately deep graph failed for no reason.
+ *
+ * Three changes remove the need for it:
+ *
+ *   * Dependency metadata is read from PEP 658 sidecars, so learning what a
+ *     release requires costs a few kilobytes rather than the wheel.
+ *   * Constraints propagate. A version excluded by an already-chosen package's
+ *     requirement is never fetched at all.
+ *   * Conflicts are learned. When a set of constraints proves unsatisfiable,
+ *     the proof is recorded, so the same subtree is not re-derived once per
+ *     parent version.
+ *
+ * What bounds the work now is a deadline and a cancellation signal, which are
+ * honest limits: they say the search ran out of time, not that it ran out of
+ * an arbitrary allowance.
+ */
+
+/**
+ * One prebuilt SandboxedJs wheel, as published in a wheel index.
+ *
+ * `abiId` travels with the entry rather than being implied by the index it
+ * came from. An index served for a different interpreter build would otherwise
+ * look usable, and the wheel would fail at import rather than at resolution.
+ */
+interface PrebuiltWheel {
+    name: string;
+    version: string;
+    filename: string;
+    sha256: string;
+    abiId: string;
+    requires: string[];
+}
+interface WheelIndex {
+    /** Where `filename` is resolved against. */
+    baseUrl: string;
+    wheels: PrebuiltWheel[];
+}
+
 /**
  * Which Python backend a container uses.
  *
@@ -1178,6 +1226,14 @@ interface PythonOptions {
     manifest?: PythonRuntimeManifest;
     /** Where the built process worker is served from, for hosts that must say. */
     workerUrl?: string;
+    /**
+     * Prebuilt wheels for this runtime's native ABI, which PyPI does not carry.
+     *
+     * Either the index itself, or the base URL its `index.json` is served from.
+     * A package with a compiled extension cannot resolve without one, because
+     * no published wheel targets wasm32-emscripten.
+     */
+    wheelIndex?: WheelIndex | string | null;
 }
 declare function configurePython(options?: PythonOptions): void;
 declare const isPythonAvailable: typeof isCPythonAvailable;

package/dist/{container-DBMPLbUu.d.ts → container-BSW6jjlq.d.ts}

@@ -1053,7 +1053,7 @@ declare class Shell {
 declare const MANIFEST_FORMAT = "sandboxedjs-python-runtime";
 declare const MANIFEST_SCHEMA_VERSION = 1;
 /** Build profiles, as defined in docs/python/architecture.md. */
-type PythonProfile = "core" | "threaded-fixed" | "threaded-dynamic";
+type PythonProfile = "core" | "threaded-fixed" | "dynamic";
 interface PythonCapabilities {
     /** Real Python threads. `core` builds have none, and must say so. */
     threads: boolean;
@@ -1101,6 +1101,54 @@ interface PythonRuntimeManifest {
  */
 declare function validateManifest(value: unknown): PythonRuntimeManifest;
 
+/**
+ * Dependency resolution for the owned Python runtime.
+ *
+ * The installer this replaces walked candidate versions and downloaded a whole
+ * wheel for each one just to read its `METADATA`. That is why it needed an
+ * arbitrary cap on how many candidates it would try: without one, discovering
+ * that a package's last forty releases all need the same unavailable native
+ * extension cost forty multi-megabyte downloads, and the install looked hung
+ * rather than failed. The cap made the symptom bearable and the cause worse --
+ * a resolution that hit it reported a limit rather than the conflict, and a
+ * legitimately deep graph failed for no reason.
+ *
+ * Three changes remove the need for it:
+ *
+ *   * Dependency metadata is read from PEP 658 sidecars, so learning what a
+ *     release requires costs a few kilobytes rather than the wheel.
+ *   * Constraints propagate. A version excluded by an already-chosen package's
+ *     requirement is never fetched at all.
+ *   * Conflicts are learned. When a set of constraints proves unsatisfiable,
+ *     the proof is recorded, so the same subtree is not re-derived once per
+ *     parent version.
+ *
+ * What bounds the work now is a deadline and a cancellation signal, which are
+ * honest limits: they say the search ran out of time, not that it ran out of
+ * an arbitrary allowance.
+ */
+
+/**
+ * One prebuilt SandboxedJs wheel, as published in a wheel index.
+ *
+ * `abiId` travels with the entry rather than being implied by the index it
+ * came from. An index served for a different interpreter build would otherwise
+ * look usable, and the wheel would fail at import rather than at resolution.
+ */
+interface PrebuiltWheel {
+    name: string;
+    version: string;
+    filename: string;
+    sha256: string;
+    abiId: string;
+    requires: string[];
+}
+interface WheelIndex {
+    /** Where `filename` is resolved against. */
+    baseUrl: string;
+    wheels: PrebuiltWheel[];
+}
+
 /**
  * Which Python backend a container uses.
  *
@@ -1178,6 +1226,14 @@ interface PythonOptions {
     manifest?: PythonRuntimeManifest;
     /** Where the built process worker is served from, for hosts that must say. */
     workerUrl?: string;
+    /**
+     * Prebuilt wheels for this runtime's native ABI, which PyPI does not carry.
+     *
+     * Either the index itself, or the base URL its `index.json` is served from.
+     * A package with a compiled extension cannot resolve without one, because
+     * no published wheel targets wasm32-emscripten.
+     */
+    wheelIndex?: WheelIndex | string | null;
 }
 declare function configurePython(options?: PythonOptions): void;
 declare const isPythonAvailable: typeof isCPythonAvailable;