@componentor/fs 3.0.2 → 3.0.4

package/dist/workers/sync-relay.worker.js

@@ -168,6 +168,13 @@ var VFSEngine = class {
       this.mount();
     }
   }
+  /** Release the sync access handle (call on fatal error or shutdown) */
+  closeHandle() {
+    try {
+      this.handle?.close();
+    } catch (_) {
+    }
+  }
   /** Format a fresh VFS */
   format() {
     const layout = calculateLayout(DEFAULT_INODE_COUNT, DEFAULT_BLOCK_SIZE, INITIAL_DATA_BLOCKS);
@@ -190,28 +197,78 @@ var VFSEngine = class {
     this.createInode("/", INODE_TYPE.DIRECTORY, DEFAULT_DIR_MODE, 0);
     this.handle.flush();
   }
-  /** Mount an existing VFS from disk */
+  /** Mount an existing VFS from disk — validates superblock integrity */
   mount() {
+    const fileSize = this.handle.getSize();
+    if (fileSize < SUPERBLOCK.SIZE) {
+      throw new Error(`Corrupt VFS: file too small (${fileSize} bytes, need at least ${SUPERBLOCK.SIZE})`);
+    }
     this.handle.read(this.superblockBuf, { at: 0 });
     const v = this.superblockView;
     const magic = v.getUint32(SUPERBLOCK.MAGIC, true);
     if (magic !== VFS_MAGIC) {
-      throw new Error(`Invalid VFS: bad magic 0x${magic.toString(16)}`);
-    }
-    this.inodeCount = v.getUint32(SUPERBLOCK.INODE_COUNT, true);
-    this.blockSize = v.getUint32(SUPERBLOCK.BLOCK_SIZE, true);
-    this.totalBlocks = v.getUint32(SUPERBLOCK.TOTAL_BLOCKS, true);
-    this.freeBlocks = v.getUint32(SUPERBLOCK.FREE_BLOCKS, true);
-    this.inodeTableOffset = v.getFloat64(SUPERBLOCK.INODE_OFFSET, true);
-    this.pathTableOffset = v.getFloat64(SUPERBLOCK.PATH_OFFSET, true);
-    this.dataOffset = v.getFloat64(SUPERBLOCK.DATA_OFFSET, true);
-    this.bitmapOffset = v.getFloat64(SUPERBLOCK.BITMAP_OFFSET, true);
-    this.pathTableUsed = v.getUint32(SUPERBLOCK.PATH_USED, true);
-    this.pathTableSize = this.bitmapOffset - this.pathTableOffset;
+      throw new Error(`Corrupt VFS: bad magic 0x${magic.toString(16)} (expected 0x${VFS_MAGIC.toString(16)})`);
+    }
+    const version = v.getUint32(SUPERBLOCK.VERSION, true);
+    if (version !== VFS_VERSION) {
+      throw new Error(`Corrupt VFS: unsupported version ${version} (expected ${VFS_VERSION})`);
+    }
+    const inodeCount = v.getUint32(SUPERBLOCK.INODE_COUNT, true);
+    const blockSize = v.getUint32(SUPERBLOCK.BLOCK_SIZE, true);
+    const totalBlocks = v.getUint32(SUPERBLOCK.TOTAL_BLOCKS, true);
+    const freeBlocks = v.getUint32(SUPERBLOCK.FREE_BLOCKS, true);
+    const inodeTableOffset = v.getFloat64(SUPERBLOCK.INODE_OFFSET, true);
+    const pathTableOffset = v.getFloat64(SUPERBLOCK.PATH_OFFSET, true);
+    const dataOffset = v.getFloat64(SUPERBLOCK.DATA_OFFSET, true);
+    const bitmapOffset = v.getFloat64(SUPERBLOCK.BITMAP_OFFSET, true);
+    const pathUsed = v.getUint32(SUPERBLOCK.PATH_USED, true);
+    if (blockSize === 0 || (blockSize & blockSize - 1) !== 0) {
+      throw new Error(`Corrupt VFS: invalid block size ${blockSize} (must be power of 2)`);
+    }
+    if (inodeCount === 0) {
+      throw new Error("Corrupt VFS: inode count is 0");
+    }
+    if (freeBlocks > totalBlocks) {
+      throw new Error(`Corrupt VFS: free blocks (${freeBlocks}) exceeds total blocks (${totalBlocks})`);
+    }
+    if (inodeTableOffset !== SUPERBLOCK.SIZE) {
+      throw new Error(`Corrupt VFS: inode table offset ${inodeTableOffset} (expected ${SUPERBLOCK.SIZE})`);
+    }
+    const expectedPathOffset = inodeTableOffset + inodeCount * INODE_SIZE;
+    if (pathTableOffset !== expectedPathOffset) {
+      throw new Error(`Corrupt VFS: path table offset ${pathTableOffset} (expected ${expectedPathOffset})`);
+    }
+    if (bitmapOffset <= pathTableOffset) {
+      throw new Error(`Corrupt VFS: bitmap offset ${bitmapOffset} must be after path table ${pathTableOffset}`);
+    }
+    if (dataOffset <= bitmapOffset) {
+      throw new Error(`Corrupt VFS: data offset ${dataOffset} must be after bitmap ${bitmapOffset}`);
+    }
+    const pathTableSize = bitmapOffset - pathTableOffset;
+    if (pathUsed > pathTableSize) {
+      throw new Error(`Corrupt VFS: path used (${pathUsed}) exceeds path table size (${pathTableSize})`);
+    }
+    const expectedMinSize = dataOffset + totalBlocks * blockSize;
+    if (fileSize < expectedMinSize) {
+      throw new Error(`Corrupt VFS: file size ${fileSize} too small for layout (need ${expectedMinSize})`);
+    }
+    this.inodeCount = inodeCount;
+    this.blockSize = blockSize;
+    this.totalBlocks = totalBlocks;
+    this.freeBlocks = freeBlocks;
+    this.inodeTableOffset = inodeTableOffset;
+    this.pathTableOffset = pathTableOffset;
+    this.dataOffset = dataOffset;
+    this.bitmapOffset = bitmapOffset;
+    this.pathTableUsed = pathUsed;
+    this.pathTableSize = pathTableSize;
     const bitmapSize = Math.ceil(this.totalBlocks / 8);
     this.bitmap = new Uint8Array(bitmapSize);
     this.handle.read(this.bitmap, { at: this.bitmapOffset });
     this.rebuildIndex();
+    if (!this.pathIndex.has("/")) {
+      throw new Error('Corrupt VFS: root directory "/" not found in inode table');
+    }
   }
   writeSuperblock() {
     const v = this.superblockView;
@@ -1222,6 +1279,24 @@ var VFSEngine = class {
     const data = inode.size > 0 ? this.readData(inode.firstBlock, inode.blockCount, inode.size) : new Uint8Array(0);
     return { type: inode.type, data, mtime: inode.mtime };
   }
+  /** Export all files/dirs/symlinks from the VFS */
+  exportAll() {
+    const result = [];
+    for (const [path, idx] of this.pathIndex) {
+      const inode = this.readInode(idx);
+      let data = null;
+      if (inode.type === INODE_TYPE.FILE || inode.type === INODE_TYPE.SYMLINK) {
+        data = inode.size > 0 ? this.readData(inode.firstBlock, inode.blockCount, inode.size) : new Uint8Array(0);
+      }
+      result.push({ path, type: inode.type, data, mode: inode.mode, mtime: inode.mtime });
+    }
+    result.sort((a, b) => {
+      if (a.type === INODE_TYPE.DIRECTORY && b.type !== INODE_TYPE.DIRECTORY) return -1;
+      if (a.type !== INODE_TYPE.DIRECTORY && b.type === INODE_TYPE.DIRECTORY) return 1;
+      return a.path.localeCompare(b.path);
+    });
+    return result;
+  }
   flush() {
     this.handle.flush();
   }
@@ -1324,6 +1399,7 @@ var leaderLoopRunning = false;
 var opfsSyncPort = null;
 var opfsSyncEnabled = false;
 var suppressPaths = /* @__PURE__ */ new Set();
+var watchBc = null;
 var sab;
 var ctrl;
 var readySab;
@@ -1450,21 +1526,21 @@ function handleRequest(reqTabId, buffer) {
       break;
     case OP.WRITE:
       result = engine.write(path, data ?? new Uint8Array(0), flags);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
       break;
     case OP.APPEND:
       result = engine.append(path, data ?? new Uint8Array(0));
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
       break;
     case OP.UNLINK:
       result = engine.unlink(path);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
@@ -1477,14 +1553,14 @@ function handleRequest(reqTabId, buffer) {
       break;
     case OP.MKDIR:
       result = engine.mkdir(path, flags);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
       break;
     case OP.RMDIR:
       result = engine.rmdir(path, flags);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
@@ -1495,7 +1571,7 @@ function handleRequest(reqTabId, buffer) {
     case OP.RENAME: {
       const newPath = data ? decodeSecondPath(data) : "";
       result = engine.rename(path, newPath);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
         syncNewPath = newPath;
@@ -1508,7 +1584,7 @@ function handleRequest(reqTabId, buffer) {
     case OP.TRUNCATE: {
       const len = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
       result = engine.truncate(path, len);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
@@ -1517,7 +1593,7 @@ function handleRequest(reqTabId, buffer) {
     case OP.COPY: {
       const destPath = data ? decodeSecondPath(data) : "";
       result = engine.copy(path, destPath, flags);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = destPath;
       }
@@ -1532,6 +1608,10 @@ function handleRequest(reqTabId, buffer) {
     case OP.CHMOD: {
       const chmodMode = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
       result = engine.chmod(path, chmodMode);
+      if (result.status === 0) {
+        syncOp = op;
+        syncPath = path;
+      }
       break;
     }
     case OP.CHOWN: {
@@ -1543,6 +1623,10 @@ function handleRequest(reqTabId, buffer) {
       const uid = dv.getUint32(0, true);
       const gid = dv.getUint32(4, true);
       result = engine.chown(path, uid, gid);
+      if (result.status === 0) {
+        syncOp = op;
+        syncPath = path;
+      }
       break;
     }
     case OP.UTIMES: {
@@ -1554,12 +1638,16 @@ function handleRequest(reqTabId, buffer) {
       const atime = dv.getFloat64(0, true);
       const mtime = dv.getFloat64(8, true);
       result = engine.utimes(path, atime, mtime);
+      if (result.status === 0) {
+        syncOp = op;
+        syncPath = path;
+      }
       break;
     }
     case OP.SYMLINK: {
       const target = data ? new TextDecoder().decode(data) : "";
       result = engine.symlink(target, path);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = path;
       }
@@ -1571,7 +1659,7 @@ function handleRequest(reqTabId, buffer) {
     case OP.LINK: {
       const newPath = data ? decodeSecondPath(data) : "";
       result = engine.link(path, newPath);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = newPath;
       }
@@ -1607,7 +1695,7 @@ function handleRequest(reqTabId, buffer) {
       const pos = dv.getInt32(4, true);
       const writeData = data.subarray(8);
       result = engine.fwrite(fd, writeData, pos === -1 ? null : pos);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = engine.getPathForFd(fd) ?? void 0;
       }
@@ -1627,7 +1715,7 @@ function handleRequest(reqTabId, buffer) {
       const fd = dv.getUint32(0, true);
       const len = dv.getUint32(4, true);
       result = engine.ftruncate(fd, len);
-      if (opfsSyncEnabled && result.status === 0) {
+      if (result.status === 0) {
         syncOp = op;
         syncPath = engine.getPathForFd(fd) ?? void 0;
       }
@@ -1641,7 +1729,7 @@ function handleRequest(reqTabId, buffer) {
       break;
     case OP.MKDTEMP:
       result = engine.mkdtemp(path);
-      if (opfsSyncEnabled && result.status === 0 && result.data) {
+      if (result.status === 0 && result.data) {
         syncOp = op;
         syncPath = new TextDecoder().decode(result.data instanceof Uint8Array ? result.data : new Uint8Array(0));
       }
@@ -1661,6 +1749,7 @@ function handleRequest(reqTabId, buffer) {
     ret._op = syncOp;
     ret._path = syncPath;
     ret._newPath = syncNewPath;
+    broadcastWatch(syncOp, syncPath, syncNewPath);
   }
   return ret;
 }
@@ -1831,13 +1920,21 @@ async function initEngine(config) {
   }
   const vfsFileHandle = await rootDir.getFileHandle(".vfs.bin", { create: true });
   const vfsHandle = await vfsFileHandle.createSyncAccessHandle();
-  engine.init(vfsHandle, {
-    uid: config.uid,
-    gid: config.gid,
-    umask: config.umask,
-    strictPermissions: config.strictPermissions,
-    debug: config.debug
-  });
+  try {
+    engine.init(vfsHandle, {
+      uid: config.uid,
+      gid: config.gid,
+      umask: config.umask,
+      strictPermissions: config.strictPermissions,
+      debug: config.debug
+    });
+  } catch (err) {
+    try {
+      vfsHandle.close();
+    } catch (_) {
+    }
+    throw err;
+  }
   if (config.opfsSync) {
     opfsSyncEnabled = true;
     const mc = new MessageChannel();
@@ -1851,6 +1948,39 @@ async function initEngine(config) {
       [mc.port2]
     );
   }
+  watchBc = new BroadcastChannel("vfs-watch");
+}
+function broadcastWatch(op, path, newPath) {
+  if (!watchBc) return;
+  let eventType;
+  switch (op) {
+    case OP.WRITE:
+    case OP.APPEND:
+    case OP.TRUNCATE:
+    case OP.FWRITE:
+    case OP.FTRUNCATE:
+    case OP.CHMOD:
+    case OP.CHOWN:
+    case OP.UTIMES:
+      eventType = "change";
+      break;
+    case OP.UNLINK:
+    case OP.RMDIR:
+    case OP.RENAME:
+    case OP.MKDIR:
+    case OP.MKDTEMP:
+    case OP.SYMLINK:
+    case OP.LINK:
+    case OP.COPY:
+      eventType = "rename";
+      break;
+    default:
+      return;
+  }
+  watchBc.postMessage({ eventType, path });
+  if (op === OP.RENAME && newPath) {
+    watchBc.postMessage({ eventType: "rename", path: newPath });
+  }
 }
 function notifyOPFSSync(op, path, newPath) {
   if (!opfsSyncPort) return;
@@ -1910,6 +2040,7 @@ function handleExternalChange(msg) {
     case "external-write": {
       suppressPaths.add(msg.path);
       const result = engine.write(msg.path, new Uint8Array(msg.data), 0);
+      if (result.status === 0) broadcastWatch(OP.WRITE, msg.path);
       console.log("[sync-relay] external-write:", msg.path, `${msg.data?.byteLength ?? 0}B`, `status=${result.status}`);
       break;
     }
@@ -1918,8 +2049,10 @@ function handleExternalChange(msg) {
       const result = engine.unlink(msg.path);
       if (result.status !== 0) {
         const rmdirResult = engine.rmdir(msg.path, 1);
+        if (rmdirResult.status === 0) broadcastWatch(OP.RMDIR, msg.path);
         console.log("[sync-relay] external-delete (rmdir):", msg.path, `status=${rmdirResult.status}`);
       } else {
+        broadcastWatch(OP.UNLINK, msg.path);
         console.log("[sync-relay] external-delete:", msg.path, `status=${result.status}`);
       }
       break;
@@ -1929,6 +2062,7 @@ function handleExternalChange(msg) {
       if (msg.newPath) {
         suppressPaths.add(msg.newPath);
         const result = engine.rename(msg.path, msg.newPath);
+        if (result.status === 0) broadcastWatch(OP.RENAME, msg.path, msg.newPath);
         console.log("[sync-relay] external-rename:", msg.path, "\u2192", msg.newPath, `status=${result.status}`);
       }
       break;