@volter/tabnode 0.5.44 → 0.5.46

package/dist/assets/{runtime-worker-CSaX_wiK.js → runtime-worker-DuSugZ3P.js}

@@ -8686,6 +8686,26 @@ function createFsBindings(Bytes = () => Buffer$9) {
           if (position === null || position === void 0 || position < 0) file.position = end + slice.length;
           return slice.length;
         }
+        if (typeof tree2.writeAtSync === "function") {
+          const at22 = position === null || position === void 0 || position < 0 ? file.position : position;
+          tree2.writeAtSync(file.path, slice, at22);
+          if (file.cached !== void 0 && slice.length > 0) {
+            const cached = file.cached;
+            const length2 = Math.max(cached.length, at22 + slice.length);
+            let room = file.room;
+            if (!room || cached.buffer !== room.buffer || cached.byteOffset !== 0 || room.byteLength < length2) {
+              room = new Uint8Array(Math.max(length2, cached.length * 2, 4096));
+              room.set(cached, 0);
+            } else if (at22 > cached.length) {
+              room.fill(0, cached.length, at22);
+            }
+            room.set(slice, at22);
+            file.cached = room.subarray(0, length2);
+            file.room = room;
+          }
+          if (position === null || position === void 0 || position < 0) file.position = at22 + 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);
@@ -31445,6 +31465,8 @@ class VirtualFS {
     if (existed && existing.type === "file") {
       existing.content = content;
       existing.mtime = Date.now();
+      existing.room = void 0;
+      existing.lent = true;
     } else {
       parent.children.set(basename, {
         type: "file",
@@ -31730,6 +31752,7 @@ class VirtualFS {
     if (encoding === "utf8" || encoding === "utf-8") {
       return this.decoder.decode(content);
     }
+    node.lent = true;
     return content;
   }
   /**
@@ -31779,6 +31802,55 @@ class VirtualFS {
     this.notifyWatchers(normalized, "change");
     if ((_a3 = this.eventListeners.get("change")) == null ? void 0 : _a3.size) this.emit("change", normalized, this.decoder.decode(node.content));
   }
+  /**
+   * Bytes written into a file at `position`, as a disk takes them: a gap past
+   * the end reads as zeros, and the file grows in its own buffer as an append
+   * grows it. A database rewrites its log and its pages a page at a time;
+   * writing the whole file again for each page copied Postgres's 16 MB
+   * write-ahead log at every commit. A tree that keeps its files elsewhere
+   * (its own writeFileSync) is written through its own read and write unless
+   * it answers this itself.
+   */
+  writeAtSync(path2, data2, position) {
+    var _a3;
+    if (this.writeFileSync !== VirtualFS.prototype.writeFileSync) {
+      const existing = this.existsSync(path2) ? this.readFileSync(path2) : new Uint8Array(0);
+      if (data2.byteLength === 0 && this.existsSync(path2)) return;
+      const whole = new Uint8Array(Math.max(existing.byteLength, position + data2.byteLength));
+      whole.set(existing, 0);
+      whole.set(data2, position);
+      this.writeFileSync(path2, whole);
+      return;
+    }
+    const normalized = this.normalizePath(path2);
+    const node = this.getNode(normalized);
+    if (!node) {
+      const whole = new Uint8Array(position + data2.byteLength);
+      whole.set(data2, position);
+      this.writeFileSyncInternal(normalized, whole, true);
+      return;
+    }
+    if (node.type !== "file") throw createNodeError("EISDIR", "open", path2);
+    this.assertWritable(normalized, "open");
+    if (data2.byteLength === 0) return;
+    const current3 = node.content ?? new Uint8Array(0);
+    const length = Math.max(current3.byteLength, position + data2.byteLength);
+    const held = node;
+    let room = held.room;
+    if (!room || held.lent || current3.buffer !== room.buffer || current3.byteOffset !== 0 || room.byteLength < length) {
+      room = new Uint8Array(Math.max(length, current3.byteLength * 2, 4096));
+      room.set(current3, 0);
+      held.lent = false;
+    } else if (position > current3.byteLength) {
+      room.fill(0, current3.byteLength, position);
+    }
+    room.set(data2, position);
+    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
    */
@@ -79994,10 +80066,28 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
     }
     return loadModule(resolved).exports;
   };
-  require2.resolve = (id2) => {
+  require2.resolve = (id2, options2) => {
     if (id2 === "fs" || id2 === "process" || id2.startsWith("node:") || builtinModules$1.includes(id2)) {
       return id2;
     }
+    if (options2 && options2.paths !== void 0) {
+      if (!Array.isArray(options2.paths)) {
+        throw Object.assign(new TypeError(`The property 'options.paths' must be an Array. Received ${String(options2.paths)}`), { code: "ERR_INVALID_ARG_VALUE" });
+      }
+      options2.paths.forEach((from, index2) => {
+        if (typeof from !== "string") throw Object.assign(new TypeError(`The "paths[${index2}]" argument must be of type string. Received ${typeof from}`), { code: "ERR_INVALID_ARG_TYPE" });
+      });
+      const requireStack = parentModule && typeof parentModule.filename === "string" ? [parentModule.filename] : [];
+      for (const from of options2.paths) {
+        try {
+          return resolveModule(id2, resolve(process2.cwd(), from));
+        } catch {
+        }
+      }
+      throw Object.assign(new Error(`Cannot find module '${id2}'${requireStack.length ? `
+Require stack:
+- ${requireStack.join("\n- ")}` : ""}`), { code: "MODULE_NOT_FOUND", requireStack });
+    }
     return resolveModule(id2, currentDir);
   };
   require2.cache = moduleCache;

package/dist/index.mjs

@@ -8814,6 +8814,26 @@ function createFsBindings(Bytes = () => Buffer$9) {
           if (position === null || position === void 0 || position < 0) file.position = end + slice.length;
           return slice.length;
         }
+        if (typeof tree2.writeAtSync === "function") {
+          const at22 = position === null || position === void 0 || position < 0 ? file.position : position;
+          tree2.writeAtSync(file.path, slice, at22);
+          if (file.cached !== void 0 && slice.length > 0) {
+            const cached = file.cached;
+            const length2 = Math.max(cached.length, at22 + slice.length);
+            let room = file.room;
+            if (!room || cached.buffer !== room.buffer || cached.byteOffset !== 0 || room.byteLength < length2) {
+              room = new Uint8Array(Math.max(length2, cached.length * 2, 4096));
+              room.set(cached, 0);
+            } else if (at22 > cached.length) {
+              room.fill(0, cached.length, at22);
+            }
+            room.set(slice, at22);
+            file.cached = room.subarray(0, length2);
+            file.room = room;
+          }
+          if (position === null || position === void 0 || position < 0) file.position = at22 + 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);
@@ -31599,6 +31619,8 @@ class VirtualFS {
     if (existed && existing.type === "file") {
       existing.content = content;
       existing.mtime = Date.now();
+      existing.room = void 0;
+      existing.lent = true;
     } else {
       parent.children.set(basename2, {
         type: "file",
@@ -31884,6 +31906,7 @@ class VirtualFS {
     if (encoding === "utf8" || encoding === "utf-8") {
       return this.decoder.decode(content);
     }
+    node.lent = true;
     return content;
   }
   /**
@@ -31933,6 +31956,55 @@ class VirtualFS {
     this.notifyWatchers(normalized, "change");
     if ((_a2 = this.eventListeners.get("change")) == null ? void 0 : _a2.size) this.emit("change", normalized, this.decoder.decode(node.content));
   }
+  /**
+   * Bytes written into a file at `position`, as a disk takes them: a gap past
+   * the end reads as zeros, and the file grows in its own buffer as an append
+   * grows it. A database rewrites its log and its pages a page at a time;
+   * writing the whole file again for each page copied Postgres's 16 MB
+   * write-ahead log at every commit. A tree that keeps its files elsewhere
+   * (its own writeFileSync) is written through its own read and write unless
+   * it answers this itself.
+   */
+  writeAtSync(path2, data2, position) {
+    var _a2;
+    if (this.writeFileSync !== VirtualFS.prototype.writeFileSync) {
+      const existing = this.existsSync(path2) ? this.readFileSync(path2) : new Uint8Array(0);
+      if (data2.byteLength === 0 && this.existsSync(path2)) return;
+      const whole = new Uint8Array(Math.max(existing.byteLength, position + data2.byteLength));
+      whole.set(existing, 0);
+      whole.set(data2, position);
+      this.writeFileSync(path2, whole);
+      return;
+    }
+    const normalized = this.normalizePath(path2);
+    const node = this.getNode(normalized);
+    if (!node) {
+      const whole = new Uint8Array(position + data2.byteLength);
+      whole.set(data2, position);
+      this.writeFileSyncInternal(normalized, whole, true);
+      return;
+    }
+    if (node.type !== "file") throw createNodeError("EISDIR", "open", path2);
+    this.assertWritable(normalized, "open");
+    if (data2.byteLength === 0) return;
+    const current3 = node.content ?? new Uint8Array(0);
+    const length = Math.max(current3.byteLength, position + data2.byteLength);
+    const held = node;
+    let room = held.room;
+    if (!room || held.lent || current3.buffer !== room.buffer || current3.byteOffset !== 0 || room.byteLength < length) {
+      room = new Uint8Array(Math.max(length, current3.byteLength * 2, 4096));
+      room.set(current3, 0);
+      held.lent = false;
+    } else if (position > current3.byteLength) {
+      room.fill(0, current3.byteLength, position);
+    }
+    room.set(data2, position);
+    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
    */
@@ -39655,10 +39727,28 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
     }
     return loadModule(resolved).exports;
   };
-  require2.resolve = (id) => {
+  require2.resolve = (id, options2) => {
     if (id === "fs" || id === "process" || id.startsWith("node:") || builtinModules$1.includes(id)) {
       return id;
     }
+    if (options2 && options2.paths !== void 0) {
+      if (!Array.isArray(options2.paths)) {
+        throw Object.assign(new TypeError(`The property 'options.paths' must be an Array. Received ${String(options2.paths)}`), { code: "ERR_INVALID_ARG_VALUE" });
+      }
+      options2.paths.forEach((from, index2) => {
+        if (typeof from !== "string") throw Object.assign(new TypeError(`The "paths[${index2}]" argument must be of type string. Received ${typeof from}`), { code: "ERR_INVALID_ARG_TYPE" });
+      });
+      const requireStack = parentModule && typeof parentModule.filename === "string" ? [parentModule.filename] : [];
+      for (const from of options2.paths) {
+        try {
+          return resolveModule(id, resolve(process2.cwd(), from));
+        } catch {
+        }
+      }
+      throw Object.assign(new Error(`Cannot find module '${id}'${requireStack.length ? `
+Require stack:
+- ${requireStack.join("\n- ")}` : ""}`), { code: "MODULE_NOT_FOUND", requireStack });
+    }
     return resolveModule(id, currentDir);
   };
   require2.cache = moduleCache;
@@ -40338,7 +40428,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-CSaX_wiK.js",
+        "/assets/runtime-worker-DuSugZ3P.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/virtual-fs.d.ts

@@ -204,6 +204,16 @@ export declare class VirtualFS {
      * read and write unless it answers appends itself.
      */
     appendFileSync(path: string, data: string | Uint8Array): void;
+    /**
+     * Bytes written into a file at `position`, as a disk takes them: a gap past
+     * the end reads as zeros, and the file grows in its own buffer as an append
+     * grows it. A database rewrites its log and its pages a page at a time;
+     * writing the whole file again for each page copied Postgres's 16 MB
+     * write-ahead log at every commit. A tree that keeps its files elsewhere
+     * (its own writeFileSync) is written through its own read and write unless
+     * it answers this itself.
+     */
+    writeAtSync(path: string, data: Uint8Array, position: number): void;
     /**
      * Create directory, optionally with recursive parent creation
      */

package/package.json

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

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

@@ -630,6 +630,30 @@ const fsBinding = {
         if (position === null || position === undefined || position < 0) file.position = end + slice.length;
         return slice.length;
       }
+      // A write elsewhere in the file goes where it lands, when the tree takes one: a database's page or log
+      // record costs its own bytes, not the file's (Postgres's commits wrote its whole 16 MB log again).
+      if (typeof (tree as { writeAtSync?: unknown }).writeAtSync === 'function') {
+        const at = position === null || position === undefined || position < 0 ? file.position : position;
+        (tree as { writeAtSync(path: string, data: Uint8Array, position: number): void }).writeAtSync(file.path, slice, at);
+        // This descriptor's copy takes the same bytes, in a buffer of its own with room, as an append's does: a
+        // read after the write is answered from it rather than by reading the whole file again.
+        if (file.cached !== undefined && slice.length > 0) {
+          const cached = file.cached;
+          const length = Math.max(cached.length, at + slice.length);
+          let room = file.room;
+          if (!room || cached.buffer !== room.buffer || cached.byteOffset !== 0 || room.byteLength < length) {
+            room = new Uint8Array(Math.max(length, cached.length * 2, 4096));
+            room.set(cached, 0);
+          } else if (at > cached.length) {
+            room.fill(0, cached.length, at);
+          }
+          room.set(slice, at);
+          file.cached = room.subarray(0, length);
+          file.room = room;
+        }
+        if (position === null || position === undefined || position < 0) file.position = at + 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

@@ -2410,10 +2410,28 @@ function createRequire(
     return loadModule(resolved).exports;
   };
 
-  require.resolve = (id: string): string => {
+  require.resolve = (id: string, options?: { paths?: unknown }): string => {
     if (id === 'fs' || id === 'process' || id.startsWith('node:') || moduleShim.builtinModules.includes(id)) {
       return id;
     }
+    // Node's `options.paths`: each directory, in order, is where the lookup starts, as if the request came from a
+    // module there, and the first that resolves wins. The option was ignored and every lookup started at the caller,
+    // so a module installed in one tree could not find a package another tree holds (a World's injector resolving
+    // the application's own Prisma adapter from the application's directory). Node 12.
+    if (options && options.paths !== undefined) {
+      if (!Array.isArray(options.paths)) {
+        throw Object.assign(new TypeError(`The property 'options.paths' must be an Array. Received ${String(options.paths)}`), { code: 'ERR_INVALID_ARG_VALUE' });
+      }
+      options.paths.forEach((from, index) => {
+        if (typeof from !== 'string') throw Object.assign(new TypeError(`The "paths[${index}]" argument must be of type string. Received ${typeof from}`), { code: 'ERR_INVALID_ARG_TYPE' });
+      });
+      // A relative entry is the process's working directory's, as Node's Module._resolveFilename makes it.
+      const requireStack = parentModule && typeof parentModule.filename === 'string' ? [parentModule.filename] : [];
+      for (const from of options.paths as string[]) {
+        try { return resolveModule(id, pathShim.resolve(process.cwd(), from)); } catch { /* the next directory */ }
+      }
+      throw Object.assign(new Error(`Cannot find module '${id}'${requireStack.length ? `\nRequire stack:\n- ${requireStack.join('\n- ')}` : ''}`), { code: 'MODULE_NOT_FOUND', requireStack });
+    }
     return resolveModule(id, currentDir);
   };
 

package/src/virtual-fs.ts

@@ -324,6 +324,9 @@ export class VirtualFS {
     if (existed && existing!.type === 'file') {
       existing!.content = content;
       existing!.mtime = Date.now();
+      // the caller's bytes, which it may still hold: never written in place
+      (existing as FSNode & { room?: Uint8Array; lent?: boolean }).room = undefined;
+      (existing as FSNode & { lent?: boolean }).lent = true;
     } else {
       parent.children!.set(basename, {
         type: 'file',
@@ -646,6 +649,10 @@ export class VirtualFS {
       return this.decoder.decode(content);
     }
 
+    // The bytes are handed out as they are, so a caller (a copy, a read
+    // stream's chunk) may hold them: a later write into the file does not
+    // change them in place (writeAtSync), it moves the file to bytes of its own.
+    (node as FSNode & { lent?: boolean }).lent = true;
     return content;
   }
 
@@ -698,6 +705,58 @@ export class VirtualFS {
     if (this.eventListeners.get('change')?.size) this.emit('change', normalized, this.decoder.decode(node.content));
   }
 
+  /**
+   * Bytes written into a file at `position`, as a disk takes them: a gap past
+   * the end reads as zeros, and the file grows in its own buffer as an append
+   * grows it. A database rewrites its log and its pages a page at a time;
+   * writing the whole file again for each page copied Postgres's 16 MB
+   * write-ahead log at every commit. A tree that keeps its files elsewhere
+   * (its own writeFileSync) is written through its own read and write unless
+   * it answers this itself.
+   */
+  writeAtSync(path: string, data: Uint8Array, position: number): void {
+    if (this.writeFileSync !== VirtualFS.prototype.writeFileSync) {
+      const existing = this.existsSync(path) ? this.readFileSync(path) as Uint8Array : new Uint8Array(0);
+      if (data.byteLength === 0 && this.existsSync(path)) return;
+      const whole = new Uint8Array(Math.max(existing.byteLength, position + data.byteLength));
+      whole.set(existing, 0);
+      whole.set(data, position);
+      this.writeFileSync(path, whole);
+      return;
+    }
+    const normalized = this.normalizePath(path);
+    const node = this.getNode(normalized);
+    if (!node) {
+      const whole = new Uint8Array(position + data.byteLength);
+      whole.set(data, position);
+      this.writeFileSyncInternal(normalized, whole, true);
+      return;
+    }
+    if (node.type !== 'file') throw createNodeError('EISDIR', 'open', path);
+    this.assertWritable(normalized, 'open');
+    // Node's write of no bytes changes nothing, past the end included
+    if (data.byteLength === 0) return;
+    const current = node.content ?? new Uint8Array(0);
+    const length = Math.max(current.byteLength, position + data.byteLength);
+    const held = node as FSNode & { room?: Uint8Array; lent?: boolean };
+    let room = held.room;
+    // Written in place only into bytes the file owns and nobody else holds: a copy made from the file
+    // (writeFileSync(dest, readFileSync(src))) or a read's result shares them, and would change with it.
+    if (!room || held.lent || current.buffer !== room.buffer || current.byteOffset !== 0 || room.byteLength < length) {
+      room = new Uint8Array(Math.max(length, current.byteLength * 2, 4096));
+      room.set(current, 0);
+      held.lent = false;
+    } else if (position > current.byteLength) {
+      room.fill(0, current.byteLength, position);
+    }
+    room.set(data, position);
+    node.content = room.subarray(0, length);
+    (node as FSNode & { room?: Uint8Array }).room = room;
+    node.mtime = Date.now();
+    this.notifyWatchers(normalized, 'change');
+    if (this.eventListeners.get('change')?.size) this.emit('change', normalized, this.decoder.decode(node.content));
+  }
+
   /**
    * Create directory, optionally with recursive parent creation
    */