sandboxedjs 0.1.44 → 0.1.46

package/dist/worker-entry.js

@@ -27141,8 +27141,17 @@ var VirtualIncomingMessage = class extends import_stream_browserify2.default.Rea
   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();
@@ -27248,6 +27257,80 @@ var VirtualServerResponse = class extends import_stream_browserify2.default.Writ
     return this;
   }
 };
+var VirtualSocket = class extends import_stream_browserify2.default.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 import_events.default {
   constructor(router, owner, listener) {
     super();
@@ -27347,6 +27430,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 import_stream_browserify2.default.Readable {
   constructor(statusCode, statusMessage, headers, body) {
@@ -30766,6 +30876,13 @@ async function run(port, start) {
       finish(137);
     }
     if (message?.type === "http-request") void answer(port, router, message);
+    if (message?.type === "ws-open") openSocket(port, router, message);
+    if (message?.type === "ws-data") sockets.get(Number(message.id))?.send(new Uint8Array(message.data));
+    if (message?.type === "ws-close") {
+      const id = Number(message.id);
+      sockets.get(id)?.close();
+      sockets.delete(id);
+    }
   });
   engine = new CommonJsEngine(volume, {
     cwd: start.cwd,
@@ -30795,6 +30912,21 @@ async function settle(router, owner, core, killed) {
     await new Promise((resolve2) => setTimeout(resolve2, busy ? 5 : 0));
   }
 }
+var sockets = /* @__PURE__ */ new Map();
+function openSocket(port, router, message) {
+  const opened = router.connect(message.port, message.init, {
+    data: (bytes2) => port.postMessage({ type: "ws-data", id: message.id, data: bytes2 }),
+    close: () => {
+      sockets.delete(message.id);
+      port.postMessage({ type: "ws-close", id: message.id });
+    }
+  });
+  if (!opened) {
+    port.postMessage({ type: "ws-close", id: message.id });
+    return;
+  }
+  sockets.set(message.id, opened);
+}
 async function answer(port, router, message) {
   try {
     const response = await router.request(message.port, message.init);