@volter/tabnode 0.5.32 → 0.5.34

package/dist/assets/{runtime-worker-g2I0tMiC.js → runtime-worker-DsSAHE2C.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);
@@ -21136,17 +21154,10 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply;
-var hasRequiredFunctionApply;
-function requireFunctionApply() {
-  if (hasRequiredFunctionApply) return functionApply;
-  hasRequiredFunctionApply = 1;
-  functionApply = Function.prototype.apply;
-  return functionApply;
-}
+var functionApply = Function.prototype.apply;
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = requireFunctionApply();
+var $apply$1 = functionApply;
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -21266,7 +21277,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = requireFunctionApply();
+var $apply = functionApply;
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -21907,7 +21918,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = requireFunctionApply();
+  var $apply2 = functionApply;
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -31697,6 +31708,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
    */
@@ -79675,9 +79727,7 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
       if (prepared) {
         const body = __substrateScopeGlobalCalls(prepareModuleCode(rawCode, resolvedPath));
         try {
-          const partial = `${prepared}.${process2.pid}.partial`;
-          vfs2.writeFileSync(partial, body);
-          vfs2.renameSync(partial, prepared);
+          vfs2.writeFileSync(prepared, body);
         } catch {
         }
         runModuleBody(module, body, resolvedPath, dirname$1, true);

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);
@@ -31851,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
    */
@@ -39336,9 +39395,7 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
       if (prepared) {
         const body = __substrateScopeGlobalCalls(prepareModuleCode(rawCode, resolvedPath));
         try {
-          const partial = `${prepared}.${process2.pid}.partial`;
-          vfs2.writeFileSync(partial, body);
-          vfs2.renameSync(partial, prepared);
+          vfs2.writeFileSync(prepared, body);
         } catch {
         }
         runModuleBody(module, body, resolvedPath, dirname$1, true);
@@ -40236,7 +40293,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-g2I0tMiC.js",
+        "/assets/runtime-worker-DsSAHE2C.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.32",
+  "version": "0.5.34",
   "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';
@@ -2003,11 +2004,11 @@ function createRequire(
       // playwright-core afresh, 28 s each, measured in a tab.
       if (prepared) {
         const body = __substrateScopeGlobalCalls(prepareModuleCode(rawCode, resolvedPath));
-        try {
-          const partial = `${prepared}.${process.pid}.partial`;
-          vfs.writeFileSync(partial, body);
-          vfs.renameSync(partial, prepared);
-        } catch { /* a process that may not write there prepares its own */ }
+        // One write is one step of the tab's filesystem, so no reader sees
+        // half a body; a rename after it failed in a forked process's realm
+        // and left the half-named file behind.
+        try { vfs.writeFileSync(prepared, body); }
+        catch { /* a process that may not write there prepares its own */ }
         runModuleBody(module, body, resolvedPath, dirname, true);
         return module;
       }

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
    */