sandboxedjs 0.1.45 → 0.1.47

package/dist/index.js

@@ -20301,6 +20301,8 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
   fetcher;
   metadata = /* @__PURE__ */ new Map();
   tarballs = /* @__PURE__ */ new Map();
+  /** Single-version manifests, for the fields the packument omits. */
+  details = /* @__PURE__ */ new Map();
   forCwd(cwd) {
     return new _CleanPackageInstaller(this.volume, { ...this.options, cwd });
   }
@@ -20326,10 +20328,17 @@ 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}`;
+    if (!supportsPlatform(manifest)) throw new IncompatiblePlatform(identity, "");
+    if (manifest.os?.length || manifest.cpu?.length) {
+      const detail = await this.platformDetail(name, version);
+      if (!platformListAllows(detail.libc, PLATFORM.libc)) {
+        throw new IncompatiblePlatform(identity, ` (needs ${detail.libc?.join(", ")})`);
+      }
+      if (detail.main?.endsWith(".node")) {
+        throw new IncompatiblePlatform(identity, " (native addon; this runtime cannot dlopen)");
+      }
+    }
     const target = join(modulesRoot, name);
     const installed2 = this.tryReadJson(join(target, "package.json"));
     if (installed2?.version === version) return installed2;
@@ -20351,11 +20360,44 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
       try {
         await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
       } catch (error) {
+        if (error instanceof IncompatiblePlatform) continue;
         options.onProgress?.(`Skipped optional ${dependency}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
     return manifest;
   }
+  /**
+   * The `libc` and `main` fields, which the abbreviated packument leaves out.
+   *
+   * Fetched per version rather than as a full packument: the single-version
+   * document is a few kilobytes, while the full one for a popular package runs
+   * to megabytes. Only packages that already declare `os` or `cpu` ask for it,
+   * so an ordinary install of pure-JavaScript dependencies makes no extra
+   * requests at all — it is the prebuilt binaries, a handful per project, that
+   * need the answer.
+   *
+   * A failure here is not fatal. Being unable to read `libc` puts the check
+   * back where it was before this existed, which is worth strictly less than
+   * being right and strictly more than refusing to install.
+   */
+  async platformDetail(name, version) {
+    const key = `${name}@${version}`;
+    let request = this.details.get(key);
+    if (!request) {
+      request = (async () => {
+        try {
+          const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name);
+          const response = await this.fetcher(`${this.registry}/${encoded}/${version}`);
+          if (!response.ok) return {};
+          return await response.json();
+        } catch {
+          return {};
+        }
+      })();
+      this.details.set(key, request);
+    }
+    return request;
+  }
   async getMetadata(name) {
     let request = this.metadata.get(name);
     if (!request) {
@@ -20423,8 +20465,15 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
     }
   }
 };
+var PLATFORM = { os: "linux", cpu: "x64", libc: "glibc" };
+var IncompatiblePlatform = class extends Error {
+  constructor(identity, detail) {
+    super(`${identity} is not compatible with ${PLATFORM.os}/${PLATFORM.cpu}/${PLATFORM.libc}${detail}`);
+    this.name = "IncompatiblePlatform";
+  }
+};
 function supportsPlatform(manifest) {
-  return !manifest.main?.endsWith(".node") && platformListAllows(manifest.os, "linux") && platformListAllows(manifest.cpu, "x64") && platformListAllows(manifest.libc, "glibc");
+  return platformListAllows(manifest.os, PLATFORM.os) && platformListAllows(manifest.cpu, PLATFORM.cpu) && platformListAllows(manifest.libc, PLATFORM.libc);
 }
 function platformListAllows(values, current) {
   if (!values?.length) return true;
@@ -23472,8 +23521,17 @@ var VirtualIncomingMessage = class extends streamModule4.Readable {
   httpVersionMajor = 1;
   httpVersionMinor = 1;
   complete = true;
+  /*
+   * Mutable, and `connection` a getter over it, because an upgraded request
+   * carries a real socket rather than the stub. `emit("upgrade", req, socket)`
+   * hands the same object to both places, and a library that reaches it as
+   * `req.socket` — rather than through the argument — has to find the one it
+   * can actually write to.
+   */
   socket = socketStub();
-  connection = this.socket;
+  get connection() {
+    return this.socket;
+  }
   constructor(init) {
     super();
     this.method = (init.method ?? "GET").toUpperCase();
@@ -23579,6 +23637,80 @@ var VirtualServerResponse = class extends streamModule4.Writable {
     return this;
   }
 };
+var VirtualSocket = class extends streamModule4.Duplex {
+  remoteAddress = "127.0.0.1";
+  remotePort = 0;
+  localAddress = "127.0.0.1";
+  localPort = 0;
+  encrypted = false;
+  bufferSize = 0;
+  peer;
+  /** Set once the peer is told, so `end()` then `destroy()` reports once. */
+  hungUp = false;
+  constructor(peer) {
+    super({ allowHalfOpen: false });
+    this.peer = peer;
+  }
+  _read() {
+  }
+  _write(chunk, encoding, callback) {
+    const bytes2 = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk, encoding);
+    try {
+      this.peer?.data(new Uint8Array(bytes2));
+      callback();
+    } catch (error) {
+      callback(error);
+    }
+  }
+  _final(callback) {
+    this.hangUp();
+    callback();
+  }
+  _destroy(error, callback) {
+    this.hangUp();
+    callback(error);
+  }
+  hangUp() {
+    if (this.hungUp) return;
+    this.hungUp = true;
+    try {
+      this.peer?.close();
+    } catch {
+    }
+    this.peer = null;
+  }
+  /** Bytes arriving from the far end. */
+  deliver(bytes2) {
+    if (this.destroyed || this.hungUp) return;
+    this.push(Buffer2.from(bytes2));
+  }
+  /** The far end went away; let the server's stream end cleanly. */
+  peerClosed() {
+    if (this.destroyed) return;
+    this.push(null);
+  }
+  /* The parts of `net.Socket` a WebSocket library reaches for. None of them
+   * mean anything without a kernel, but every one of them is called. */
+  setNoDelay() {
+    return this;
+  }
+  setKeepAlive() {
+    return this;
+  }
+  setTimeout(_milliseconds, callback) {
+    if (callback) this.once("timeout", callback);
+    return this;
+  }
+  destroySoon() {
+    this.end();
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+};
 var VirtualHttpServer = class extends EventEmitter4 {
   constructor(router, owner, listener) {
     super();
@@ -23678,6 +23810,33 @@ var VirtualHttpRouter = class {
       return { statusCode: 500, statusMessage: "Internal Server Error", headers: {}, body: error instanceof Error ? error.message : String(error) };
     }
   }
+  /**
+   * Open a connection that leaves HTTP behind — a WebSocket, in practice.
+   *
+   * The counterpart to {@link request}, and the thing whose absence made a dev
+   * server look broken. Every Node WebSocket library is built the same way: it
+   * hands `http.Server` an `upgrade` listener and waits. Nothing here ever
+   * emitted one, so `ws` sat holding a server that could not receive a single
+   * connection, and Vite lost the channel it uses to tell a page to reload —
+   * which is the only way it can recover after re-optimizing dependencies.
+   *
+   * Null means there is nothing to connect to: no server on the port, or a
+   * server that never asked for upgrades. Both are refusals the caller should
+   * report rather than wait out.
+   */
+  connect(port, init, peer) {
+    const item = this.servers.get(port);
+    if (!item) return null;
+    if (item.server.listenerCount("upgrade") === 0) return null;
+    const request = new VirtualIncomingMessage(init);
+    const socket = new VirtualSocket(peer);
+    request.socket = socket;
+    item.server.emit("upgrade", request, socket, Buffer2.alloc(0));
+    return {
+      send: (bytes2) => socket.deliver(bytes2),
+      close: () => socket.peerClosed()
+    };
+  }
 };
 var VirtualClientResponse = class extends streamModule4.Readable {
   constructor(statusCode, statusMessage, headers, body) {
@@ -27194,6 +27353,9 @@ var LocalRuntimePod = class _LocalRuntimePod {
   async request(_port, _init = {}) {
     return this.router.request(_port, _init);
   }
+  connect(port, init, peer) {
+    return this.router.connect(port, init, peer);
+  }
   snapshot() {
     this.assertActive();
     return this.volume.snapshot();
@@ -27629,6 +27791,15 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
         case "http-response":
           this.settleProxied(Number(message.id), message.response);
           return;
+        case "ws-data":
+          this.upgraded.get(Number(message.id))?.write(new Uint8Array(message.data));
+          return;
+        case "ws-close": {
+          const socket = this.upgraded.get(Number(message.id));
+          this.upgraded.delete(Number(message.id));
+          socket?.end();
+          return;
+        }
         case "child-start":
           this.startChild(worker, children, message, ownedChildren);
           return;
@@ -27717,6 +27888,8 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
   // ── HTTP servers living on another thread ─────────────────────────────────
   proxies = /* @__PURE__ */ new Map();
   waiting = /* @__PURE__ */ new Map();
+  /** Upgraded connections, by the id the Worker knows them as. */
+  upgraded = /* @__PURE__ */ new Map();
   nextRequestId = 1;
   /**
    * Register a stand-in for a server that is actually running in the Worker.
@@ -27729,6 +27902,9 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     const server = new VirtualHttpServer(this.router, owner, (request, response) => {
       void this.forward(worker, port, request, response);
     });
+    server.on("upgrade", (request, socket) => {
+      this.upgrade(worker, port, request, socket);
+    });
     try {
       server.listen(port);
       this.proxies.set(port, server);
@@ -27759,6 +27935,33 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     response.writeHead(Number(result.statusCode ?? 200), String(result.statusMessage ?? ""), result.headers ?? {});
     response.end(result.body ?? new Uint8Array());
   }
+  /**
+   * Tunnel one upgraded connection to the server that actually holds the port.
+   *
+   * Unlike {@link forward} there is no reply to wait for: both ends write
+   * whenever they have something, until one of them stops. The id is what ties
+   * the two directions together across the Worker boundary.
+   */
+  upgrade(worker, port, request, socket) {
+    const id = this.nextRequestId++;
+    this.upgraded.set(id, socket);
+    socket.on("data", (chunk) => {
+      const bytes2 = new Uint8Array(chunk);
+      worker.postMessage({ type: "ws-data", id, data: bytes2 });
+    });
+    const drop = () => {
+      if (!this.upgraded.delete(id)) return;
+      worker.postMessage({ type: "ws-close", id });
+    };
+    socket.on("close", drop);
+    socket.on("error", drop);
+    worker.postMessage({
+      type: "ws-open",
+      id,
+      port,
+      init: { method: request.method, path: request.url, headers: request.headers }
+    });
+  }
   settleProxied(id, response) {
     const resolve2 = this.waiting.get(id);
     if (!resolve2) return;
@@ -27771,6 +27974,10 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
       server.close();
       this.proxies.delete(port);
     }
+    for (const [id, socket] of [...this.upgraded]) {
+      this.upgraded.delete(id);
+      socket.destroy();
+    }
   }
   teardown() {
     for (const { worker, server } of [...this.live]) {
@@ -28144,6 +28351,29 @@ var Container = class _Container {
       }
     };
   }
+  /**
+   * Open a connection to a server inside the container that upgrades out of
+   * HTTP — in practice, a WebSocket.
+   *
+   * The counterpart to {@link request}, and the thing a dev server needs that
+   * a request cannot provide. Bytes go in with `send`, come back through
+   * `peer.data`, and neither side interprets them: the container runs whatever
+   * WebSocket library the program chose, and the caller is responsible for
+   * speaking the protocol it answers with.
+   *
+   * Null means there is nothing to talk to — no server on the port, or one
+   * that never registered an `upgrade` handler. Both are worth reporting
+   * rather than waiting out, because neither resolves on its own.
+   */
+  connect(port, init = {}, peer) {
+    this.assertActive();
+    if (!this.pod.connect) return null;
+    return this.pod.connect(
+      port,
+      { method: init.method ?? "GET", path: init.path ?? "/", headers: init.headers ?? {} },
+      peer
+    );
+  }
   /**
    * Deliver a request whose body is bytes, without letting them become text.
    *
@@ -28715,6 +28945,12 @@ init_arith();
 init_expand();
 init_builtins();
 
+// src/preview/ws-client.ts
+var WS_OPEN = "sandboxedjs:ws-open";
+var WS_DATA = "sandboxedjs:ws-data";
+var WS_CLOSE = "sandboxedjs:ws-close";
+var WS_ERROR = "sandboxedjs:ws-error";
+
 // src/preview/register.ts
 function serveContainerOn(port, box) {
   port.onmessage = async (event) => {
@@ -28800,7 +29036,7 @@ async function createPreview(box, options = {}) {
     channel = new MessageChannel();
     serveContainerOn(channel.port1, box);
     const target = registration.active ?? worker;
-    target.postMessage({ type: "sandboxedjs:connect" }, [channel.port2]);
+    target.postMessage({ type: "sandboxedjs:connect", injectSockets: options.websocket !== false }, [channel.port2]);
   };
   const onWorkerMessage = (event) => {
     const type = event.data?.type;
@@ -28809,6 +29045,56 @@ async function createPreview(box, options = {}) {
   };
   navigator.serviceWorker.addEventListener("message", onWorkerMessage);
   connect();
+  const sockets = /* @__PURE__ */ new Map();
+  const onFrameMessage = (event) => {
+    if (event.origin !== location.origin || !event.source) return;
+    const data = event.data;
+    if (!data || typeof data !== "object") return;
+    if (data.type !== WS_OPEN && data.type !== WS_DATA && data.type !== WS_CLOSE) return;
+    const source = event.source;
+    const id = Number(data.id);
+    const reply = (message, transfer = []) => source.postMessage(message, location.origin, transfer);
+    if (data.type === WS_OPEN) {
+      let table2 = sockets.get(source);
+      if (!table2) sockets.set(source, table2 = /* @__PURE__ */ new Map());
+      let opened = null;
+      try {
+        opened = box.connect(
+          Number(data.port),
+          { method: "GET", path: data.path ?? "/", headers: data.headers ?? {} },
+          {
+            data: (bytes2) => {
+              const carrier = bytes2.slice().buffer;
+              reply({ type: WS_DATA, id, data: carrier }, [carrier]);
+            },
+            close: () => {
+              table2.delete(id);
+              reply({ type: WS_CLOSE, id });
+            }
+          }
+        );
+      } catch (error) {
+        opened = null;
+        reply({ type: WS_ERROR, id, message: error instanceof Error ? error.message : String(error) });
+        return;
+      }
+      if (!opened) {
+        reply({ type: WS_ERROR, id, message: `Nothing is accepting WebSocket connections on port ${data.port}.` });
+        return;
+      }
+      table2.set(id, opened);
+      return;
+    }
+    const table = sockets.get(source);
+    const socket = table?.get(id);
+    if (!socket) return;
+    if (data.type === WS_DATA) socket.send(new Uint8Array(data.data));
+    else {
+      socket.close();
+      table.delete(id);
+    }
+  };
+  if (typeof window !== "undefined") window.addEventListener("message", onFrameMessage);
   const base2 = registration.scope.replace(/\/$/, "");
   const urlFor = (port) => `${base2}/__sbx__/${port}/`;
   return {
@@ -28822,6 +29108,9 @@ async function createPreview(box, options = {}) {
     },
     dispose: async () => {
       navigator.serviceWorker.removeEventListener("message", onWorkerMessage);
+      if (typeof window !== "undefined") window.removeEventListener("message", onFrameMessage);
+      for (const table of sockets.values()) for (const socket of table.values()) socket.close();
+      sockets.clear();
       channel?.port1.close();
       channel = null;
       await registration.unregister();