@volter/tabnode 0.5.33 → 0.5.35

package/dist/__sw__.js

@@ -289,7 +289,7 @@ function handleMainMessage(host, event) {
 /**
  * Send request to main thread and wait for response
  */
-async function sendRequest(host, port, method, url, headers, body) {
+async function sendRequest(host, port, method, url, headers, body, destination = '') {
   DEBUG && console.log('[SW] sendRequest called, host:', !!host, 'url:', url);
 
   if (!host) {
@@ -312,7 +312,7 @@ async function sendRequest(host, port, method, url, headers, body) {
     host.port.postMessage({
       type: 'request',
       id,
-      data: { port, method, url, headers, body },
+      data: { port, method, url, headers, body, destination },
     });
   });
 }
@@ -321,7 +321,7 @@ async function sendRequest(host, port, method, url, headers, body) {
  * Send streaming request to main thread
  * Returns a ReadableStream that receives chunks from main thread
  */
-async function sendStreamingRequest(host, port, method, url, headers, body) {
+async function sendStreamingRequest(host, port, method, url, headers, body, destination = '') {
   DEBUG && console.log('[SW] sendStreamingRequest called, url:', url);
 
   if (!host) {
@@ -351,7 +351,7 @@ async function sendStreamingRequest(host, port, method, url, headers, body) {
       host.port.postMessage({
         type: 'request',
         id,
-        data: { port, method, url, headers, body, streaming: true },
+        data: { port, method, url, headers, body, streaming: true, destination },
       });
     },
     cancel() {
@@ -365,7 +365,7 @@ async function sendStreamingRequest(host, port, method, url, headers, body) {
 // A Node HTTP producer must stop when its consumer stops reading and must
 // observe disconnect. One pull credit bounds the service-worker response queue;
 // this protocol requires a paired host bridge and is negotiated per port.
-async function sendControlledRequest(host, port, method, url, headers, body, signal) {
+async function sendControlledRequest(host, port, method, url, headers, body, signal, destination = '') {
   if (!host) throw new Error('Service Worker not initialized');
   if (signal.aborted) throw signal.reason;
   const channel = host.port;
@@ -450,7 +450,7 @@ async function sendControlledRequest(host, port, method, url, headers, body, sig
   signal.addEventListener('abort', abort, { once: true });
   try {
     channel.postMessage({ type: 'request', id,
-      data: { port, method, url, headers, body, streaming: true, flowControl: 1 } });
+      data: { port, method, url, headers, body, streaming: true, flowControl: 1, destination } });
     if (signal.aborted) abort();
     const head = await headersPromise;
     const noBody = method === 'HEAD' || [204, 205, 304].includes(head.statusCode);
@@ -775,7 +775,7 @@ async function handleVirtualRequest(request, port, path, rooted = false) {
     if (registration) {
       if (host.flowControlledPorts.get(port) !== registration || host.port !== registration.channel || hosts.get(host.id) !== host)
         throw new Error('Virtual server registration changed during upload');
-      return await sendControlledRequest(host, port, request.method, path, headers, body, request.signal);
+      return await sendControlledRequest(host, port, request.method, path, headers, body, request.signal, request.destination);
     }
 
     // Legacy peers retain their old selection until they negotiate flow control.
@@ -783,12 +783,12 @@ async function handleVirtualRequest(request, port, path, rooted = false) {
 
     if (isStreamingCandidate) {
       DEBUG && console.log('[SW] Using streaming mode for:', path);
-      return handleStreamingRequest(host, port, request.method, path, headers, body);
+      return handleStreamingRequest(host, port, request.method, path, headers, body, request.destination);
     }
     DEBUG && console.log('[SW] Using non-streaming mode for:', request.method, path);
 
     // Send to main thread
-    const response = await sendRequest(host, port, request.method, path, headers, body);
+    const response = await sendRequest(host, port, request.method, path, headers, body, request.destination);
 
     DEBUG && console.log('[SW] Got response from main thread:', {
       statusCode: response.statusCode,
@@ -853,8 +853,8 @@ async function handleVirtualRequest(request, port, path, rooted = false) {
 /**
  * Handle a streaming request
  */
-async function handleStreamingRequest(host, port, method, path, headers, body) {
-  const { stream, headersPromise, id } = await sendStreamingRequest(host, port, method, path, headers, body);
+async function handleStreamingRequest(host, port, method, path, headers, body, destination = '') {
+  const { stream, headersPromise, id } = await sendStreamingRequest(host, port, method, path, headers, body, destination);
 
   // Wait for headers to arrive
   const responseData = await headersPromise;

package/dist/assets/{runtime-worker-b9-COQEP.js → runtime-worker-DEgP1CYS.js}

@@ -8639,6 +8639,7 @@ function createFsBindings(Bytes = () => Buffer$9) {
     // ---- writing ------------------------------------------------------------
     writeBuffer(fd2, buffer2, offset2, length, position, req) {
       return answer(req, () => {
+        var _a3;
         const stream = handleForFd(fd2);
         if (stream instanceof LibuvStreamWrap) {
           if (position !== null && position !== void 0 && position >= 0) throw createNodeError$1("ESPIPE", "write", String(fd2));
@@ -8651,6 +8652,23 @@ function createFsBindings(Bytes = () => Buffer$9) {
         if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "write", file.path);
         const tree2 = file.tree;
         const slice = buffer2.subarray(offset2, offset2 + length);
+        const held = ((_a3 = file.cached) == null ? void 0 : _a3.length) ?? (tree2.existsSync(file.path) ? tree2.statSync(file.path).size : 0);
+        const end = (file.flags & flagBits().append) !== 0 ? held : position === null || position === void 0 || position < 0 ? file.position : position;
+        if (end === held && typeof tree2.appendFileSync === "function") {
+          tree2.appendFileSync(file.path, slice);
+          if (file.cached !== void 0) {
+            let room = file.room;
+            if (!room || file.cached.buffer !== room.buffer || file.cached.byteOffset !== 0 || room.byteLength < held + slice.length) {
+              room = new Uint8Array(Math.max(held + slice.length, held * 2, 4096));
+              room.set(file.cached, 0);
+            }
+            room.set(slice, held);
+            file.cached = room.subarray(0, held + slice.length);
+            file.room = room;
+          }
+          if (position === null || position === void 0 || position < 0) file.position = end + slice.length;
+          return slice.length;
+        }
         const existing = file.cached ?? (tree2.existsSync(file.path) ? tree2.readFileSync(file.path) : new Uint8Array(0));
         const at3 = (file.flags & flagBits().append) !== 0 ? existing.length : position === null || position === void 0 || position < 0 ? file.position : position;
         const size = Math.max(existing.length, at3 + slice.length);
@@ -31697,6 +31715,47 @@ class VirtualFS {
   writeFileSync(path2, data2) {
     this.writeFileSyncInternal(path2, data2, true);
   }
+  /**
+   * Adds bytes at a file's end, creating it. A file grown a piece at a time
+   * (a write stream's chunks) is kept in a buffer with room to grow, so an
+   * append copies only what it adds: writing the whole file again for each
+   * 1 KB chunk of a 50 MB file copied about a terabyte. A tree that keeps its
+   * files elsewhere (its own writeFileSync) is appended to through its own
+   * read and write unless it answers appends itself.
+   */
+  appendFileSync(path2, data2) {
+    var _a3;
+    const bytes2 = typeof data2 === "string" ? this.encoder.encode(data2) : data2;
+    if (this.writeFileSync !== VirtualFS.prototype.writeFileSync) {
+      const existing = this.existsSync(path2) ? this.readFileSync(path2) : new Uint8Array(0);
+      const whole = new Uint8Array(existing.byteLength + bytes2.byteLength);
+      whole.set(existing, 0);
+      whole.set(bytes2, existing.byteLength);
+      this.writeFileSync(path2, whole);
+      return;
+    }
+    const normalized = this.normalizePath(path2);
+    const node = this.getNode(normalized);
+    if (!node) {
+      this.writeFileSyncInternal(normalized, bytes2.slice(), true);
+      return;
+    }
+    if (node.type !== "file") throw createNodeError("EISDIR", "open", path2);
+    this.assertWritable(normalized, "open");
+    const current3 = node.content ?? new Uint8Array(0);
+    const length = current3.byteLength + bytes2.byteLength;
+    let room = node.room;
+    if (!room || current3.buffer !== room.buffer || current3.byteOffset !== 0 || room.byteLength < length) {
+      room = new Uint8Array(Math.max(length, current3.byteLength * 2, 4096));
+      room.set(current3, 0);
+    }
+    room.set(bytes2, current3.byteLength);
+    node.content = room.subarray(0, length);
+    node.room = room;
+    node.mtime = Date.now();
+    this.notifyWatchers(normalized, "change");
+    if ((_a3 = this.eventListeners.get("change")) == null ? void 0 : _a3.size) this.emit("change", normalized, this.decoder.decode(node.content));
+  }
   /**
    * Create directory, optionally with recursive parent creation
    */

package/dist/index.mjs

@@ -8767,6 +8767,7 @@ function createFsBindings(Bytes = () => Buffer$9) {
     // ---- writing ------------------------------------------------------------
     writeBuffer(fd, buffer2, offset2, length, position, req) {
       return answer(req, () => {
+        var _a2;
         const stream = handleForFd(fd);
         if (stream instanceof LibuvStreamWrap) {
           if (position !== null && position !== void 0 && position >= 0) throw createNodeError$1("ESPIPE", "write", String(fd));
@@ -8779,6 +8780,23 @@ function createFsBindings(Bytes = () => Buffer$9) {
         if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "write", file.path);
         const tree2 = file.tree;
         const slice = buffer2.subarray(offset2, offset2 + length);
+        const held = ((_a2 = file.cached) == null ? void 0 : _a2.length) ?? (tree2.existsSync(file.path) ? tree2.statSync(file.path).size : 0);
+        const end = (file.flags & flagBits().append) !== 0 ? held : position === null || position === void 0 || position < 0 ? file.position : position;
+        if (end === held && typeof tree2.appendFileSync === "function") {
+          tree2.appendFileSync(file.path, slice);
+          if (file.cached !== void 0) {
+            let room = file.room;
+            if (!room || file.cached.buffer !== room.buffer || file.cached.byteOffset !== 0 || room.byteLength < held + slice.length) {
+              room = new Uint8Array(Math.max(held + slice.length, held * 2, 4096));
+              room.set(file.cached, 0);
+            }
+            room.set(slice, held);
+            file.cached = room.subarray(0, held + slice.length);
+            file.room = room;
+          }
+          if (position === null || position === void 0 || position < 0) file.position = end + slice.length;
+          return slice.length;
+        }
         const existing = file.cached ?? (tree2.existsSync(file.path) ? tree2.readFileSync(file.path) : new Uint8Array(0));
         const at2 = (file.flags & flagBits().append) !== 0 ? existing.length : position === null || position === void 0 || position < 0 ? file.position : position;
         const size = Math.max(existing.length, at2 + slice.length);
@@ -21284,10 +21302,17 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply = Function.prototype.apply;
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = functionApply;
+var $apply$1 = requireFunctionApply();
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -21407,7 +21432,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = functionApply;
+var $apply = requireFunctionApply();
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -22048,7 +22073,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = functionApply;
+  var $apply2 = requireFunctionApply();
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -31844,6 +31869,47 @@ class VirtualFS {
   writeFileSync(path2, data2) {
     this.writeFileSyncInternal(path2, data2, true);
   }
+  /**
+   * Adds bytes at a file's end, creating it. A file grown a piece at a time
+   * (a write stream's chunks) is kept in a buffer with room to grow, so an
+   * append copies only what it adds: writing the whole file again for each
+   * 1 KB chunk of a 50 MB file copied about a terabyte. A tree that keeps its
+   * files elsewhere (its own writeFileSync) is appended to through its own
+   * read and write unless it answers appends itself.
+   */
+  appendFileSync(path2, data2) {
+    var _a2;
+    const bytes2 = typeof data2 === "string" ? this.encoder.encode(data2) : data2;
+    if (this.writeFileSync !== VirtualFS.prototype.writeFileSync) {
+      const existing = this.existsSync(path2) ? this.readFileSync(path2) : new Uint8Array(0);
+      const whole = new Uint8Array(existing.byteLength + bytes2.byteLength);
+      whole.set(existing, 0);
+      whole.set(bytes2, existing.byteLength);
+      this.writeFileSync(path2, whole);
+      return;
+    }
+    const normalized = this.normalizePath(path2);
+    const node = this.getNode(normalized);
+    if (!node) {
+      this.writeFileSyncInternal(normalized, bytes2.slice(), true);
+      return;
+    }
+    if (node.type !== "file") throw createNodeError("EISDIR", "open", path2);
+    this.assertWritable(normalized, "open");
+    const current3 = node.content ?? new Uint8Array(0);
+    const length = current3.byteLength + bytes2.byteLength;
+    let room = node.room;
+    if (!room || current3.buffer !== room.buffer || current3.byteOffset !== 0 || room.byteLength < length) {
+      room = new Uint8Array(Math.max(length, current3.byteLength * 2, 4096));
+      room.set(current3, 0);
+    }
+    room.set(bytes2, current3.byteLength);
+    node.content = room.subarray(0, length);
+    node.room = room;
+    node.mtime = Date.now();
+    this.notifyWatchers(normalized, "change");
+    if ((_a2 = this.eventListeners.get("change")) == null ? void 0 : _a2.size) this.emit("change", normalized, this.decoder.decode(node.content));
+  }
   /**
    * Create directory, optionally with recursive parent creation
    */
@@ -40227,7 +40293,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-b9-COQEP.js",
+        "/assets/runtime-worker-DEgP1CYS.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/runtime.d.ts

@@ -14,7 +14,8 @@ export { pendingGuestTimers, stopGuestTimers } from './guest-timers';
  * playwright-core's, measured in a tab, against 0.9 s under Node on the same
  * machine. The image carries each body under the hash of the file it was made
  * from, in this directory of the tab's filesystem, and the loader takes it in
- * place of the passes when the file it read hashes to one.
+ * place of the passes when the file it read hashes to one. A body the loader
+ * prepares for a file the image has none for is kept there the same way.
  */
 export declare const PREPARED_MODULES_DIR = "/.tabnode/prepared";
 /** The name a prepared body goes under: the hash of the file as read, and how it is compiled. Undefined for a file no body is prepared for. */

package/dist/virtual-fs.d.ts

@@ -195,6 +195,15 @@ export declare class VirtualFS {
      * Write data to file, creating parent directories as needed
      */
     writeFileSync(path: string, data: string | Uint8Array): void;
+    /**
+     * Adds bytes at a file's end, creating it. A file grown a piece at a time
+     * (a write stream's chunks) is kept in a buffer with room to grow, so an
+     * append copies only what it adds: writing the whole file again for each
+     * 1 KB chunk of a 50 MB file copied about a terabyte. A tree that keeps its
+     * files elsewhere (its own writeFileSync) is appended to through its own
+     * read and write unless it answers appends itself.
+     */
+    appendFileSync(path: string, data: string | Uint8Array): void;
     /**
      * Create directory, optionally with recursive parent creation
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.33",
+  "version": "0.5.35",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/node-lib/binding/fs.ts

@@ -157,6 +157,8 @@ interface OpenFile {
    * it could send ready.
    */
   cached?: Uint8Array;
+  /** The buffer `cached` views when writes have grown it a piece at a time. */
+  room?: Uint8Array;
 }
 
 /** Every descriptor this engine has open, and the next number to hand out. */
@@ -606,6 +608,28 @@ const fsBinding = {
       if ((file.flags & 3) === 0) throw createNodeError('EBADF', 'write', file.path);
       const tree = file.tree;
       const slice = buffer.subarray(offset, offset + length);
+      // A write at the file's end is an append: the tree is given only the
+      // bytes it adds, and this descriptor's copy grows in a buffer with room.
+      // Writing the whole file again for each chunk made a 50 MB stream of
+      // 1 KB writes copy about a terabyte.
+      const held = file.cached?.length ?? (tree.existsSync(file.path) ? tree.statSync(file.path).size : 0);
+      const end = (file.flags & flagBits().append) !== 0 ? held
+        : position === null || position === undefined || position < 0 ? file.position : position;
+      if (end === held && typeof (tree as { appendFileSync?: unknown }).appendFileSync === 'function') {
+        (tree as { appendFileSync(path: string, data: Uint8Array): void }).appendFileSync(file.path, slice);
+        if (file.cached !== undefined) {
+          let room = file.room;
+          if (!room || file.cached.buffer !== room.buffer || file.cached.byteOffset !== 0 || room.byteLength < held + slice.length) {
+            room = new Uint8Array(Math.max(held + slice.length, held * 2, 4096));
+            room.set(file.cached, 0);
+          }
+          room.set(slice, held);
+          file.cached = room.subarray(0, held + slice.length);
+          file.room = room;
+        }
+        if (position === null || position === undefined || position < 0) file.position = end + slice.length;
+        return slice.length;
+      }
       const existing = file.cached ?? (tree.existsSync(file.path) ? tree.readFileSync(file.path) as Uint8Array : new Uint8Array(0));
       const at = (file.flags & flagBits().append) !== 0 ? existing.length
         : position === null || position === undefined || position < 0 ? file.position : position;

package/src/runtime.ts

@@ -587,7 +587,8 @@ function __substratePrepareBody(rawCode: string, resolvedPath: string, format: s
  * playwright-core's, measured in a tab, against 0.9 s under Node on the same
  * machine. The image carries each body under the hash of the file it was made
  * from, in this directory of the tab's filesystem, and the loader takes it in
- * place of the passes when the file it read hashes to one.
+ * place of the passes when the file it read hashes to one. A body the loader
+ * prepares for a file the image has none for is kept there the same way.
  */
 export const PREPARED_MODULES_DIR = '/.tabnode/prepared';
 const PREPARED_MODULES_FORMAT = 'tabnode-prepared-2';

package/src/virtual-fs.ts

@@ -656,6 +656,48 @@ export class VirtualFS {
     this.writeFileSyncInternal(path, data, true);
   }
 
+  /**
+   * Adds bytes at a file's end, creating it. A file grown a piece at a time
+   * (a write stream's chunks) is kept in a buffer with room to grow, so an
+   * append copies only what it adds: writing the whole file again for each
+   * 1 KB chunk of a 50 MB file copied about a terabyte. A tree that keeps its
+   * files elsewhere (its own writeFileSync) is appended to through its own
+   * read and write unless it answers appends itself.
+   */
+  appendFileSync(path: string, data: string | Uint8Array): void {
+    const bytes = typeof data === 'string' ? this.encoder.encode(data) : data;
+    if (this.writeFileSync !== VirtualFS.prototype.writeFileSync) {
+      const existing = this.existsSync(path) ? this.readFileSync(path) as Uint8Array : new Uint8Array(0);
+      const whole = new Uint8Array(existing.byteLength + bytes.byteLength);
+      whole.set(existing, 0);
+      whole.set(bytes, existing.byteLength);
+      this.writeFileSync(path, whole);
+      return;
+    }
+    const normalized = this.normalizePath(path);
+    const node = this.getNode(normalized);
+    if (!node) {
+      this.writeFileSyncInternal(normalized, bytes.slice(), true);
+      return;
+    }
+    if (node.type !== 'file') throw createNodeError('EISDIR', 'open', path);
+    this.assertWritable(normalized, 'open');
+    const current = node.content ?? new Uint8Array(0);
+    const length = current.byteLength + bytes.byteLength;
+    let room = (node as FSNode & { room?: Uint8Array }).room;
+    if (!room || current.buffer !== room.buffer || current.byteOffset !== 0 || room.byteLength < length) {
+      room = new Uint8Array(Math.max(length, current.byteLength * 2, 4096));
+      room.set(current, 0);
+    }
+    room.set(bytes, current.byteLength);
+    node.content = room.subarray(0, length);
+    (node as FSNode & { room?: Uint8Array }).room = room;
+    node.mtime = Date.now();
+    this.notifyWatchers(normalized, 'change');
+    // The change event carries the file's text; it is made only for a listener.
+    if (this.eventListeners.get('change')?.size) this.emit('change', normalized, this.decoder.decode(node.content));
+  }
+
   /**
    * Create directory, optionally with recursive parent creation
    */