sandboxedjs 0.1.26 → 0.1.27

package/README.md

@@ -577,8 +577,8 @@ its kill signal.
 
 ## Running in a browser
 
-This package targets Node today, and that is what is tested. If your goal is a browser IDE, here
-is exactly where things stand.
+The same `createContainer()` API runs under Node and in modern browsers. Browser execution is
+tested under Vite 8; the remaining browser-specific limits are listed below.
 
 **Done — the package no longer hard-depends on Node at import time.** Compression and hashing
 resolve their implementation at call time (`node:zlib`/`node:crypto` on Node,
@@ -607,7 +607,24 @@ $ node -p process.version  v22.12.0
 $ cat /etc/os-release    SandboxedJS 1.0 (sandbox)
 ```
 
-**Not done — three things stand between this and a browser IDE.**
+**Vite 8 works through Rolldown's official WASI binding.** Because that binding uses shared
+WebAssembly memory and workers, the page must be cross-origin isolated. For example:
+
+```ts
+// vite.config.ts
+export default {
+  server: { headers: {
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Embedder-Policy": "require-corp",
+  } },
+};
+```
+
+Production hosting must return the same two headers. Without them SandboxedJS reports a direct
+configuration error when Vite/Rolldown starts. The compiler is loaded only when an installed
+project actually contains Rolldown, so ordinary container boot does not pay its WASM startup cost.
+
+**Not done — these things still stand between this and a complete browser IDE.**
 
 - *A service worker.* A preview iframe needs a real URL, and giving it one means a worker on your
   own origin that intercepts requests and routes them into the container. `request()` works
@@ -617,11 +634,10 @@ $ cat /etc/os-release    SandboxedJS 1.0 (sandbox)
 - *Worker isolation.* The runtime executes in whichever realm you boot it from, which in a browser
   is the main thread — so a long build blocks the UI, and container code can reach page globals.
   `comlink` is a dependency in anticipation of this and is not used yet.
-- *esbuild.* The runtime cannot execute any build of esbuild itself: one dlopens a compiled addon,
+- *esbuild-dependent tools.* The runtime cannot execute any build of esbuild itself: one dlopens a compiled addon,
   the other drives a Go program through facilities the sandbox does not have. On Node it borrows
-  the host's `esbuild-wasm`, which is why Vite's dev server works there. In a browser there is
-  nothing to borrow, so anything routed through esbuild fails until esbuild-wasm runs *inside*
-  the sandbox.
+  the host's `esbuild-wasm`. Vite 8's Rolldown path works in a browser, but tools which call
+  esbuild directly still fail until esbuild-wasm runs *inside* the sandbox.
 
 Vite prints two warnings about `util` being externalized. They come from `readable-stream`, which
 declares `"util": false` for browsers and falls back on its own; nothing in this package imports
@@ -637,7 +653,6 @@ built on `fetch`, `acorn`, `resolve.exports`, `@noble/hashes` and `pako`.
 - `copyIn()` / `copyOut()` — they read and write the host filesystem, which does not exist.
 - `expose()` — it opens a real `node:http` listener. Use `request()` to reach an in-container
   server instead of a host port.
-- `python3` — see below.
 - The `sandboxedjs` CLI, obviously.
 
 Those use dynamic imports, so they only fail if you call them.
@@ -750,9 +765,11 @@ Honest list of what does not work:
 - **Compiled native addons.** A `.node` file cannot be loaded, so a package that ships one has to
   have a JavaScript or WebAssembly build to fall back on. `rollup` and `esbuild` do, and the
   runtime redirects those two names to `@rollup/wasm-node` and `esbuild-wasm` automatically when
-  they are installed. **Vite 8 does not work** for this reason: it builds on Rolldown, whose only
-  sandbox-viable binding needs WASI and `worker_threads`. Vite 7 runs, dev server included, as do
-  Express, Koa, Fastify-style apps and plain `http` servers.
+  they are installed. Vite 8 is supported through Rolldown's official WASI build (with the browser
+  isolation headers above). Express, Koa, Fastify-style apps and plain `http` servers also run.
+- **Concurrent browser Rolldown projects need distinct absolute working directories.** The
+  official binding owns one WASI memfs per page; SandboxedJS mirrors each project into it before
+  startup. Two live projects using the same path such as `/workspace` can overwrite that mirror.
 - **`child_process` is asynchronous only.** `spawn`, `exec` and `execFile` run through the kernel,
   so a child sees the same filesystem and coreutils as the shell. `execSync`, `spawnSync` and
   `execFileSync` throw `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`: blocking the JavaScript thread on

package/dist/index.cjs

@@ -6823,7 +6823,7 @@ var NetworkStack = class {
     }
     return [...out.values()].sort((a, b) => a.port - b.port);
   }
-  /** Ports Nodepod's proxy has registered for this instance. */
+  /** Ports the pod's proxy has registered for this instance. */
   knownPodPorts() {
     try {
       return this.pod.proxy.activePorts(this.pod.instanceId) ?? [];
@@ -18180,7 +18180,33 @@ function ffmpegCommands() {
   return [ffmpeg, ffprobe];
 }
 var platformBuffer = globalThis.Buffer;
-var Buffer2 = platformBuffer ?? index_js.Buffer;
+var Buffer2 = platformBuffer ?? addBase64UrlSupport(index_js.Buffer);
+function addBase64UrlSupport(BufferClass) {
+  const target = BufferClass;
+  if (target.__sandboxedBase64Url) return BufferClass;
+  Object.defineProperty(target, "__sandboxedBase64Url", { value: true });
+  const from = target.from.bind(target);
+  target.from = (value, encodingOrOffset, length) => from(value, normalizeEncoding(encodingOrOffset), length);
+  const byteLength = target.byteLength.bind(target);
+  target.byteLength = (value, encoding) => byteLength(value, normalizeEncoding(encoding));
+  const isEncoding = target.isEncoding?.bind(target);
+  if (isEncoding) target.isEncoding = (encoding) => encoding.toLowerCase() === "base64url" || isEncoding(encoding);
+  const toString = target.prototype.toString;
+  target.prototype.toString = function(encoding, start2, end) {
+    if (encoding?.toLowerCase() !== "base64url") return toString.call(this, encoding, start2, end);
+    return toString.call(this, "base64", start2, end).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  };
+  const write = target.prototype.write;
+  target.prototype.write = function(...args) {
+    const index = typeof args[1] === "string" ? 1 : typeof args[2] === "string" ? 2 : 3;
+    if (typeof args[index] === "string") args[index] = normalizeEncoding(args[index]);
+    return write.apply(this, args);
+  };
+  return BufferClass;
+}
+function normalizeEncoding(value) {
+  return typeof value === "string" && value.toLowerCase() === "base64url" ? "base64" : value;
+}
 
 // src/pkg/clean-installer.ts
 init_path();
@@ -18222,6 +18248,9 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
     const version = resolveVersion(metadata, range);
     const manifest = metadata.versions[version];
     if (!manifest) throw new Error(`No matching version found for ${name}@${range}`);
+    if (!supportsPlatform(manifest)) {
+      throw new Error(`${name}@${version} is not compatible with linux/x64/glibc`);
+    }
     const identity = `${name}@${version}`;
     const target = join(modulesRoot, name);
     const installed2 = this.tryReadJson(join(target, "package.json"));
@@ -18316,6 +18345,15 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
     }
   }
 };
+function supportsPlatform(manifest) {
+  return !manifest.main?.endsWith(".node") && platformListAllows(manifest.os, "linux") && platformListAllows(manifest.cpu, "x64") && platformListAllows(manifest.libc, "glibc");
+}
+function platformListAllows(values, current) {
+  if (!values?.length) return true;
+  if (values.includes(`!${current}`)) return false;
+  const positive = values.filter((value) => !value.startsWith("!"));
+  return positive.length === 0 || positive.includes(current) || positive.includes("any");
+}
 function resolveVersion(metadata, range) {
   const tag2 = metadata["dist-tags"]?.[range];
   if (tag2) return tag2;
@@ -22276,6 +22314,7 @@ function createCoreModules(options) {
     globals,
     process: processObject,
     pendingHandles: timers.pending,
+    pendingUnrefed: timers.pendingUnrefed,
     writeStdin: (data) => {
       if (options.interactiveStdin) stdin.write(data);
     },
@@ -22871,33 +22910,78 @@ var ERRNO_CONSTANTS = {
 };
 function createTrackedTimers() {
   const live = /* @__PURE__ */ new Set();
-  const track = (handle, repeating) => {
+  const unrefed = /* @__PURE__ */ new Set();
+  const states = /* @__PURE__ */ new WeakMap();
+  const track = (native) => {
+    const state = { native, active: true, referenced: true };
+    const handle = {
+      ref() {
+        state.referenced = true;
+        unrefed.delete(handle);
+        if (state.active) live.add(handle);
+        state.native?.ref?.();
+        return handle;
+      },
+      unref() {
+        state.referenced = false;
+        live.delete(handle);
+        if (state.active) unrefed.add(handle);
+        state.native?.unref?.();
+        return handle;
+      },
+      hasRef: () => state.referenced,
+      refresh() {
+        state.native?.refresh?.();
+        return handle;
+      },
+      [Symbol.toPrimitive]: () => Number(state.native)
+    };
+    states.set(handle, state);
     live.add(handle);
     return handle;
   };
+  const complete = (handle) => {
+    const state = states.get(handle);
+    if (state) state.active = false;
+    live.delete(handle);
+    unrefed.delete(handle);
+  };
   const setTimeoutTracked = (fn, delay, ...args) => {
-    const handle = setTimeout(
+    let handle;
+    const native = setTimeout(
       (...inner) => {
-        live.delete(handle);
+        complete(handle);
         fn(...inner);
       },
       delay,
       ...args
     );
-    live.add(handle);
+    handle = track(native);
     return handle;
   };
   const setIntervalTracked = (fn, delay, ...args) => track(setInterval(fn, delay, ...args));
   const hostSetImmediate = globalThis.setImmediate;
   const setImmediateTracked = (fn, ...args) => {
-    const handle = hostSetImmediate ? hostSetImmediate((...inner) => {
-      live.delete(handle);
+    if (!hostSetImmediate) return setTimeoutTracked(fn, 0, ...args);
+    let handle;
+    const native = hostSetImmediate((...inner) => {
+      complete(handle);
       fn(...inner);
-    }, ...args) : setTimeoutTracked(fn, 0, ...args);
-    live.add(handle);
+    }, ...args);
+    handle = track(native);
     return handle;
   };
   const clear2 = (handle, native) => {
+    if (typeof handle === "object" && handle !== null) {
+      const state = states.get(handle);
+      if (state) {
+        state.active = false;
+        live.delete(handle);
+        unrefed.delete(handle);
+        native(state.native);
+        return;
+      }
+    }
     live.delete(handle);
     native(handle);
   };
@@ -22910,7 +22994,8 @@ function createTrackedTimers() {
       clearInterval: (handle) => clear2(handle, clearInterval),
       clearImmediate: (handle) => clear2(handle, globalThis.clearImmediate ?? clearTimeout)
     },
-    pending: () => live.size
+    pending: () => live.size,
+    pendingUnrefed: () => unrefed.size
   };
 }
 function createTimerPromises() {
@@ -23432,7 +23517,26 @@ function ensureProcessGlobal() {
   });
 }
 
+// src/runtime/host-rolldown.ts
+async function loadHostRolldownBinding() {
+  if (typeof window !== "undefined" && globalThis.crossOriginIsolated !== true) {
+    throw new Error(
+      "Vite 8/Rolldown requires cross-origin isolation. Serve the app with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp headers."
+    );
+  }
+  try {
+    const loaded = await import('@rolldown/binding-wasm32-wasi');
+    return "__fs" in loaded ? { ...loaded } : loaded.default ?? loaded;
+  } catch (error) {
+    if (typeof process !== "undefined" && process.env?.SANDBOXEDJS_DEBUG) {
+      console.error("[sandboxedjs] Rolldown WASI binding unavailable:", error);
+    }
+    throw new Error("The optional Rolldown WASI binding could not be loaded.", { cause: error });
+  }
+}
+
 // src/runtime/local-runtime-pod.ts
+init_path();
 var WASM_ALIASES = {
   esbuild: "esbuild-wasm",
   rollup: "@rollup/wasm-node"
@@ -23683,6 +23787,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
   aliases;
   modules;
   esbuild;
+  rolldownBinding;
   constructor(options) {
     ensureProcessGlobal();
     this.workdir = options.workdir ?? "/";
@@ -23716,6 +23821,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
     const env2 = { ...this.env, ...isRecord(options.env) ? options.env : {} };
     const owner = `${this.instanceId}:${Math.random().toString(36).slice(2)}`;
     return new LocalProcess(async (proc) => {
+      await this.prepareRolldown(cwd, env2);
       const untrack = trackProcess(proc);
       let requestedExit = 0;
       let engine;
@@ -23752,7 +23858,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
       });
       try {
         await engine.run(script);
-        await this.settle(owner, core.pendingHandles, core.readingStdin);
+        await this.settle(owner, core.pendingHandles, core.pendingUnrefed, core.readingStdin);
         if (this.router.activePorts(owner).length) {
           await proc.waitForKill();
           return 137;
@@ -23764,6 +23870,25 @@ var LocalRuntimePod = class _LocalRuntimePod {
       }
     });
   }
+  /**
+   * Rolldown's JavaScript API synchronously requires its compiled binding.
+   * When a project contains Rolldown, preload the official WASI build in the
+   * host and expose it through the module override table before evaluation.
+   * Keeping this demand-driven avoids adding WASM startup cost to ordinary
+   * shells and Node programs.
+   */
+  async prepareRolldown(cwd, env2) {
+    const specifier = "@rolldown/binding-wasm32-wasi";
+    if (!this.modules[specifier] && packageInstalled(this.volume, cwd, "rolldown")) {
+      this.rolldownBinding ??= loadHostRolldownBinding();
+      const binding = await this.rolldownBinding;
+      if (binding) this.modules[specifier] = binding;
+    }
+    if (this.modules[specifier]) {
+      syncRolldownFileSystem(this.modules[specifier], this.volume, cwd);
+      env2.NAPI_RS_FORCE_WASI ??= "true";
+    }
+  }
   /**
    * Wait until the process has either started serving or genuinely run out of
    * work.
@@ -23779,11 +23904,17 @@ var LocalRuntimePod = class _LocalRuntimePod {
    * A plain script that has genuinely finished falls straight through both,
    * costing a handful of empty turns.
    */
-  async settle(owner, pendingHandles, readingStdin) {
+  async settle(owner, pendingHandles, pendingUnrefed, readingStdin) {
     for (let turn = 0; turn < DRAIN_TURNS; turn++) {
       if (this.router.activePorts(owner).length) return;
       await new Promise((resolve2) => setTimeout(resolve2, 0));
     }
+    if (pendingHandles() === 0 && pendingUnrefed() > 0 && !readingStdin()) {
+      const deadline = Date.now() + 1e3;
+      while (!this.router.activePorts(owner).length && Date.now() < deadline) {
+        await new Promise((resolve2) => setTimeout(resolve2, 5));
+      }
+    }
     while (!this.router.activePorts(owner).length && (pendingHandles() > 0 || readingStdin())) {
       await new Promise((resolve2) => setTimeout(resolve2, 5));
     }
@@ -23836,6 +23967,60 @@ function formatError(error) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function packageInstalled(volume, cwd, wanted) {
+  for (let dir3 = clean(cwd); ; dir3 = dirname(dir3)) {
+    if (packageTreeContains(volume, join(dir3, "node_modules"), wanted, /* @__PURE__ */ new Set())) return true;
+    if (dir3 === "/") return false;
+  }
+}
+function packageTreeContains(volume, modulesRoot, wanted, visited) {
+  if (visited.has(modulesRoot) || !directory(volume, modulesRoot)) return false;
+  visited.add(modulesRoot);
+  if (directory(volume, join(modulesRoot, wanted))) return true;
+  for (const entry of volume.readdirSync(modulesRoot)) {
+    if (entry === ".bin") continue;
+    const first = join(modulesRoot, entry);
+    const packages = entry.startsWith("@") && directory(volume, first) ? volume.readdirSync(first).map((name) => join(first, name)) : [first];
+    for (const root of packages) {
+      if (directory(volume, root) && packageTreeContains(volume, join(root, "node_modules"), wanted, visited)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function directory(volume, path) {
+  try {
+    return volume.lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function syncRolldownFileSystem(binding, volume, root) {
+  const fs = binding?.__fs;
+  if (!fs?.mkdirSync || !fs?.writeFileSync) return;
+  try {
+    fs.rmSync?.(root, { recursive: true, force: true });
+  } catch {
+  }
+  const copy = (path) => {
+    const stat2 = volume.lstatSync(path);
+    if (stat2.isDirectory()) {
+      fs.mkdirSync(path, { recursive: true });
+      for (const name of volume.readdirSync(path)) copy(join(path, name));
+    } else if (stat2.isSymbolicLink()) {
+      fs.mkdirSync(dirname(path), { recursive: true });
+      try {
+        fs.symlinkSync(volume.readlinkSync(path), path);
+      } catch {
+      }
+    } else if (!path.endsWith(".node")) {
+      fs.mkdirSync(dirname(path), { recursive: true });
+      fs.writeFileSync(path, volume.readFileSync(path));
+    }
+  };
+  copy(clean(root));
+}
 
 // src/container/container.ts
 var Container = class _Container {
@@ -24179,7 +24364,7 @@ var Container = class _Container {
   /**
    * Deliver a request whose body is bytes, without letting them become text.
    *
-   * Nodepod's public `request()` runs the body through `toString("utf8")` on
+   * A RuntimePod's public `request()` may run the body through `toString("utf8")` on
    * its way in, so anything above `0x7f` is replaced: a five-byte payload
    * containing `0x89` and `0xff` arrives as nine. That silently destroys every
    * upload — an image or a video reaches the server the wrong size and no
@@ -24281,7 +24466,7 @@ var Container = class _Container {
   assertActive() {
     if (this.disposed) throw new Error("container has been disposed");
   }
-  /** Tear down every process and release the Nodepod instance. */
+  /** Tear down every process and release the runtime pod. */
   dispose() {
     if (this.disposed) return;
     this.disposed = true;