@volter/tabnode 0.3.0 → 0.3.1

package/dist/assets/{runtime-worker-BcDCBbhG.js → runtime-worker-CUO9SNFs.js}

@@ -7913,11 +7913,11 @@ function answerFilesystem(method, args) {
   return answer2.apply(hostVfs, plain) ?? null;
 }
 const inodes = /* @__PURE__ */ new Map();
-let nextInode = 1;
+let nextInode$1 = 1;
 function inodeOf(path2) {
   let inode = inodes.get(path2);
   if (inode === void 0) {
-    inode = nextInode++;
+    inode = nextInode$1++;
     inodes.set(path2, inode);
   }
   return inode;
@@ -9431,6 +9431,8 @@ const fsBinding = {
       if ((flags & bits.excl) !== 0 && (flags & bits.create) !== 0 && exists) throw createNodeError$1("EEXIST", "open", name);
       if (!exists) {
         if ((flags & bits.create) === 0) throw createNodeError$1("ENOENT", "open", name);
+        const parent = name.slice(0, name.lastIndexOf("/")) || "/";
+        if (!tree2.statSync(parent).isDirectory()) throw createNodeError$1("ENOTDIR", "open", name);
         tree2.writeFileSync(name, "");
       } else if ((flags & bits.truncate) !== 0) {
         tree2.writeFileSync(name, "");
@@ -9443,6 +9445,7 @@ const fsBinding = {
   },
   close(fd2, req) {
     return answer(req, () => {
+      fileFor(fd2);
       openFiles.delete(fd2);
       return void 0;
     });
@@ -9451,6 +9454,7 @@ const fsBinding = {
   read(fd2, buffer2, offset2, length, position, req) {
     return answer(req, () => {
       const file = fileFor(fd2);
+      if ((file.flags & 3) === 1) throw createNodeError$1("EBADF", "read", file.path);
       if (file.cached === void 0) file.cached = file.tree.readFileSync(file.path);
       const bytes2 = file.cached;
       const from = position === null || position === void 0 || position < 0 ? file.position : position;
@@ -9473,17 +9477,27 @@ const fsBinding = {
     });
   },
   /** Node's fast path for `readFile` with an encoding it can decode itself. */
-  readFileUtf8(path2, _flags) {
-    return vfs$1().readFileSync(asPath(path2), "utf8");
+  readFileUtf8(path2, flags) {
+    const owned = typeof path2 !== "number";
+    const fd2 = owned ? fsBinding.open(path2, flags, 438) : path2;
+    try {
+      const file = fileFor(fd2);
+      const bytes2 = new Uint8Array(file.tree.statSync(file.path).size);
+      const length = fsBinding.read(fd2, bytes2, 0, bytes2.length, -1);
+      return new TextDecoder().decode(bytes2.subarray(0, length));
+    } finally {
+      if (owned) fsBinding.close(fd2);
+    }
   },
   // ---- writing ------------------------------------------------------------
   writeBuffer(fd2, buffer2, offset2, length, position, req) {
     return answer(req, () => {
       const file = fileFor(fd2);
+      if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "write", file.path);
       const tree2 = file.tree;
       const slice = buffer2.subarray(offset2, offset2 + length);
       const existing = file.cached ?? (tree2.existsSync(file.path) ? tree2.readFileSync(file.path) : new Uint8Array(0));
-      const at3 = position === null || position === void 0 || position < 0 ? file.position : position;
+      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);
       const next2 = new Uint8Array(size);
       next2.set(existing, 0);
@@ -9513,15 +9527,14 @@ const fsBinding = {
     const bytes2 = encoding === "utf8" || encoding === void 0 || encoding === "utf-8" ? new TextEncoder().encode(value) : Uint8Array.from(value, (character) => character.charCodeAt(0) & 255);
     return fsBinding.writeBuffer(fd2, bytes2, 0, bytes2.length, position ?? null, req);
   },
-  writeFileUtf8(path2, data2, flags, _mode) {
-    const tree2 = vfs$1();
-    const name = asPath(path2);
-    if ((flags & flagBits().append) !== 0 && tree2.existsSync(name)) {
-      const existing = tree2.readFileSync(name, "utf8");
-      tree2.writeFileSync(name, existing + data2);
-      return void 0;
+  writeFileUtf8(path2, data2, flags, mode) {
+    const owned = typeof path2 !== "number";
+    const fd2 = owned ? fsBinding.open(path2, flags, mode) : path2;
+    try {
+      fsBinding.writeString(fd2, data2, null, "utf8");
+    } finally {
+      if (owned) fsBinding.close(fd2);
     }
-    tree2.writeFileSync(name, data2);
     return void 0;
   },
   // ---- metadata -----------------------------------------------------------
@@ -9802,6 +9815,7 @@ const fsBinding = {
   ftruncate(fd2, length, req) {
     return answer(req, () => {
       const file = fileFor(fd2);
+      if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "ftruncate", file.path);
       const tree2 = file.tree;
       const bytes2 = file.cached ?? tree2.readFileSync(file.path);
       const next2 = new Uint8Array(length);
@@ -26098,6 +26112,16 @@ lazyExport("stream", "pipeline");
 lazyExport("stream", "finished");
 lazyModule("stream/promises");
 const streamPromisesModule = lazyModule("stream/promises");
+const nodeInodes = /* @__PURE__ */ new WeakMap();
+let nextInode = 1;
+function inodeFor(node) {
+  let inode = nodeInodes.get(node);
+  if (inode === void 0) {
+    inode = nextInode++;
+    nodeInodes.set(node, inode);
+  }
+  return inode;
+}
 function createNodeError(code2, syscall, path2, message) {
   const errno = {
     ENOENT: -2,
@@ -26414,7 +26438,7 @@ class VirtualFS {
       uid: 1e3,
       gid: 1e3,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: Math.ceil(size / 512)
@@ -26453,7 +26477,7 @@ class VirtualFS {
       uid: 1e3,
       gid: 1e3,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: 0

package/dist/index.mjs

@@ -7626,11 +7626,11 @@ function answerFilesystem(method, args) {
   return answer2.apply(hostVfs, plain) ?? null;
 }
 const inodes = /* @__PURE__ */ new Map();
-let nextInode = 1;
+let nextInode$1 = 1;
 function inodeOf(path2) {
   let inode = inodes.get(path2);
   if (inode === void 0) {
-    inode = nextInode++;
+    inode = nextInode$1++;
     inodes.set(path2, inode);
   }
   return inode;
@@ -9144,6 +9144,8 @@ const fsBinding = {
       if ((flags & bits.excl) !== 0 && (flags & bits.create) !== 0 && exists) throw createNodeError$1("EEXIST", "open", name);
       if (!exists) {
         if ((flags & bits.create) === 0) throw createNodeError$1("ENOENT", "open", name);
+        const parent = name.slice(0, name.lastIndexOf("/")) || "/";
+        if (!tree2.statSync(parent).isDirectory()) throw createNodeError$1("ENOTDIR", "open", name);
         tree2.writeFileSync(name, "");
       } else if ((flags & bits.truncate) !== 0) {
         tree2.writeFileSync(name, "");
@@ -9156,6 +9158,7 @@ const fsBinding = {
   },
   close(fd, req) {
     return answer(req, () => {
+      fileFor(fd);
       openFiles.delete(fd);
       return void 0;
     });
@@ -9164,6 +9167,7 @@ const fsBinding = {
   read(fd, buffer2, offset2, length, position, req) {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 1) throw createNodeError$1("EBADF", "read", file.path);
       if (file.cached === void 0) file.cached = file.tree.readFileSync(file.path);
       const bytes2 = file.cached;
       const from = position === null || position === void 0 || position < 0 ? file.position : position;
@@ -9186,17 +9190,27 @@ const fsBinding = {
     });
   },
   /** Node's fast path for `readFile` with an encoding it can decode itself. */
-  readFileUtf8(path2, _flags) {
-    return vfs().readFileSync(asPath(path2), "utf8");
+  readFileUtf8(path2, flags) {
+    const owned = typeof path2 !== "number";
+    const fd = owned ? fsBinding.open(path2, flags, 438) : path2;
+    try {
+      const file = fileFor(fd);
+      const bytes2 = new Uint8Array(file.tree.statSync(file.path).size);
+      const length = fsBinding.read(fd, bytes2, 0, bytes2.length, -1);
+      return new TextDecoder().decode(bytes2.subarray(0, length));
+    } finally {
+      if (owned) fsBinding.close(fd);
+    }
   },
   // ---- writing ------------------------------------------------------------
   writeBuffer(fd, buffer2, offset2, length, position, req) {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "write", file.path);
       const tree2 = file.tree;
       const slice = buffer2.subarray(offset2, offset2 + length);
       const existing = file.cached ?? (tree2.existsSync(file.path) ? tree2.readFileSync(file.path) : new Uint8Array(0));
-      const at2 = position === null || position === void 0 || position < 0 ? file.position : position;
+      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);
       const next = new Uint8Array(size);
       next.set(existing, 0);
@@ -9226,15 +9240,14 @@ const fsBinding = {
     const bytes2 = encoding === "utf8" || encoding === void 0 || encoding === "utf-8" ? new TextEncoder().encode(value) : Uint8Array.from(value, (character) => character.charCodeAt(0) & 255);
     return fsBinding.writeBuffer(fd, bytes2, 0, bytes2.length, position ?? null, req);
   },
-  writeFileUtf8(path2, data2, flags, _mode) {
-    const tree2 = vfs();
-    const name = asPath(path2);
-    if ((flags & flagBits().append) !== 0 && tree2.existsSync(name)) {
-      const existing = tree2.readFileSync(name, "utf8");
-      tree2.writeFileSync(name, existing + data2);
-      return void 0;
+  writeFileUtf8(path2, data2, flags, mode) {
+    const owned = typeof path2 !== "number";
+    const fd = owned ? fsBinding.open(path2, flags, mode) : path2;
+    try {
+      fsBinding.writeString(fd, data2, null, "utf8");
+    } finally {
+      if (owned) fsBinding.close(fd);
     }
-    tree2.writeFileSync(name, data2);
     return void 0;
   },
   // ---- metadata -----------------------------------------------------------
@@ -9515,6 +9528,7 @@ const fsBinding = {
   ftruncate(fd, length, req) {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "ftruncate", file.path);
       const tree2 = file.tree;
       const bytes2 = file.cached ?? tree2.readFileSync(file.path);
       const next = new Uint8Array(length);
@@ -25831,6 +25845,16 @@ lazyExport("stream", "pipeline");
 lazyExport("stream", "finished");
 lazyModule("stream/promises");
 const streamPromisesModule = lazyModule("stream/promises");
+const nodeInodes = /* @__PURE__ */ new WeakMap();
+let nextInode = 1;
+function inodeFor(node) {
+  let inode = nodeInodes.get(node);
+  if (inode === void 0) {
+    inode = nextInode++;
+    nodeInodes.set(node, inode);
+  }
+  return inode;
+}
 function createNodeError(code2, syscall, path2, message) {
   const errno = {
     ENOENT: -2,
@@ -26147,7 +26171,7 @@ class VirtualFS {
       uid: 1e3,
       gid: 1e3,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: Math.ceil(size / 512)
@@ -26186,7 +26210,7 @@ class VirtualFS {
       uid: 1e3,
       gid: 1e3,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: 0
@@ -33786,7 +33810,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-BcDCBbhG.js",
+        "/assets/runtime-worker-CUO9SNFs.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/node-lib/binding/fs.d.ts

@@ -95,11 +95,11 @@ export declare const fsBinding: {
     read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number, req?: FSReq): number | undefined;
     readBuffers(fd: number, buffers: Uint8Array[], position: number, req?: FSReq): number | undefined;
     /** Node's fast path for `readFile` with an encoding it can decode itself. */
-    readFileUtf8(path: unknown, _flags: number): string;
+    readFileUtf8(path: unknown, flags: number): string;
     writeBuffer(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, req?: FSReq): number | undefined;
     writeBuffers(fd: number, buffers: Uint8Array[], position: number | null, req?: FSReq): number | undefined;
     writeString(fd: number, value: string, position: number | null, encoding: string | undefined, req?: FSReq): number | undefined;
-    writeFileUtf8(path: unknown, data: string, flags: number, _mode: number): undefined;
+    writeFileUtf8(path: unknown, data: string, flags: number, mode: number): undefined;
     stat(path: unknown, bigint: boolean, req?: FSReq, throwIfNoEntry?: boolean): Float64Array | BigInt64Array | undefined;
     lstat(path: unknown, bigint: boolean, req?: FSReq, throwIfNoEntry?: boolean): Float64Array | BigInt64Array | undefined;
     fstat(fd: number, bigint: boolean, req?: FSReq): Float64Array | BigInt64Array | undefined;

package/package.json

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

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

@@ -469,6 +469,9 @@ export const fsBinding = {
       if ((flags & bits.excl) !== 0 && (flags & bits.create) !== 0 && exists) throw createNodeError('EEXIST', 'open', name);
       if (!exists) {
         if ((flags & bits.create) === 0) throw createNodeError('ENOENT', 'open', name);
+        // VirtualFS writes create parents for image loading; open(2) does not.
+        const parent = name.slice(0, name.lastIndexOf('/')) || '/';
+        if (!tree.statSync(parent).isDirectory()) throw createNodeError('ENOTDIR', 'open', name);
         tree.writeFileSync(name, '');
       } else if ((flags & bits.truncate) !== 0) {
         tree.writeFileSync(name, '');
@@ -481,13 +484,14 @@ export const fsBinding = {
   },
 
   close(fd: number, req?: FSReq): undefined {
-    return answer(req, () => { openFiles.delete(fd); return undefined; });
+    return answer(req, () => { fileFor(fd); openFiles.delete(fd); return undefined; });
   },
 
   // ---- reading ------------------------------------------------------------
   read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number, req?: FSReq): number | undefined {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 1) throw createNodeError('EBADF', 'read', file.path);
       if (file.cached === undefined) file.cached = file.tree.readFileSync(file.path) as Uint8Array;
       const bytes = file.cached;
       const from = position === null || position === undefined || position < 0 ? file.position : position;
@@ -512,18 +516,27 @@ export const fsBinding = {
   },
 
   /** Node's fast path for `readFile` with an encoding it can decode itself. */
-  readFileUtf8(path: unknown, _flags: number): string {
-    return vfs().readFileSync(asPath(path), 'utf8') as string;
+  readFileUtf8(path: unknown, flags: number): string {
+    const owned = typeof path !== 'number';
+    const fd = owned ? fsBinding.open(path, flags, 0o666) as number : path as number;
+    try {
+      const file = fileFor(fd);
+      const bytes = new Uint8Array(file.tree.statSync(file.path).size);
+      const length = fsBinding.read(fd, bytes, 0, bytes.length, -1) as number;
+      return new TextDecoder().decode(bytes.subarray(0, length));
+    } finally { if (owned) fsBinding.close(fd); }
   },
 
   // ---- writing ------------------------------------------------------------
   writeBuffer(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, req?: FSReq): number | undefined {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 0) throw createNodeError('EBADF', 'write', file.path);
       const tree = file.tree;
       const slice = buffer.subarray(offset, offset + length);
       const existing = file.cached ?? (tree.existsSync(file.path) ? tree.readFileSync(file.path) as Uint8Array : new Uint8Array(0));
-      const at = position === null || position === undefined || position < 0 ? file.position : position;
+      const at = (file.flags & flagBits().append) !== 0 ? existing.length
+        : position === null || position === undefined || position < 0 ? file.position : position;
       const size = Math.max(existing.length, at + slice.length);
       const next = new Uint8Array(size);
       next.set(existing, 0);
@@ -553,15 +566,13 @@ export const fsBinding = {
     return fsBinding.writeBuffer(fd, bytes, 0, bytes.length, position ?? null, req);
   },
 
-  writeFileUtf8(path: unknown, data: string, flags: number, _mode: number): undefined {
-    const tree = vfs();
-    const name = asPath(path);
-    if ((flags & flagBits().append) !== 0 && tree.existsSync(name)) {
-      const existing = tree.readFileSync(name, 'utf8') as string;
-      tree.writeFileSync(name, existing + data);
-      return undefined;
-    }
-    tree.writeFileSync(name, data);
+  writeFileUtf8(path: unknown, data: string, flags: number, mode: number): undefined {
+    // Node's UTF-8 fast path accepts a path OR an already-open descriptor.
+    // Reuse open/write so flags, offsets and errors match the buffer path.
+    const owned = typeof path !== 'number';
+    const fd = owned ? fsBinding.open(path, flags, mode) as number : path as number;
+    try { fsBinding.writeString(fd, data, null, 'utf8'); }
+    finally { if (owned) fsBinding.close(fd); }
     return undefined;
   },
 
@@ -843,6 +854,7 @@ export const fsBinding = {
   ftruncate(fd: number, length: number, req?: FSReq): undefined {
     return answer(req, () => {
       const file = fileFor(fd);
+      if ((file.flags & 3) === 0) throw createNodeError('EBADF', 'ftruncate', file.path);
       const tree = file.tree;
       const bytes = file.cached ?? (tree.readFileSync(file.path) as Uint8Array);
       const next = new Uint8Array(length);

package/src/virtual-fs.ts

@@ -45,6 +45,17 @@ export interface FSNode {
   atime?: number;
 }
 
+// Identity belongs to the node, so writes and renames preserve it while an
+// unlink followed by recreation receives a different inode. Weak keys do not
+// retain deleted trees, and snapshots receive new identities when restored.
+const nodeInodes = new WeakMap<FSNode, number>();
+let nextInode = 1;
+function inodeFor(node: FSNode): number {
+  let inode = nodeInodes.get(node);
+  if (inode === undefined) { inode = nextInode++; nodeInodes.set(node, inode); }
+  return inode;
+}
+
 // Simple EventEmitter for VFS change notifications
 type VFSChangeListener = (path: string, content: string) => void;
 type VFSDeleteListener = (path: string) => void;
@@ -491,7 +502,7 @@ export class VirtualFS {
       uid: 1000,
       gid: 1000,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: Math.ceil(size / 512),
@@ -531,7 +542,7 @@ export class VirtualFS {
       uid: 1000,
       gid: 1000,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: 0