@componentor/fs 3.0.9 → 3.0.10

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

@@ -195,6 +195,7 @@ var VFSEngine = class {
     this.bitmap = new Uint8Array(layout.bitmapSize);
     this.handle.write(this.bitmap, { at: this.bitmapOffset });
     this.createInode("/", INODE_TYPE.DIRECTORY, DEFAULT_DIR_MODE, 0);
+    this.writeSuperblock();
     this.handle.flush();
   }
   /** Mount an existing VFS from disk — validates superblock integrity */
@@ -354,14 +355,33 @@ var VFSEngine = class {
       const off = i * INODE_SIZE;
       const type = inodeView.getUint8(off + INODE.TYPE);
       if (type === INODE_TYPE.FREE) continue;
+      if (type < INODE_TYPE.FILE || type > INODE_TYPE.SYMLINK) {
+        throw new Error(`Corrupt VFS: inode ${i} has invalid type ${type}`);
+      }
+      const pathOffset = inodeView.getUint32(off + INODE.PATH_OFFSET, true);
+      const pathLength = inodeView.getUint16(off + INODE.PATH_LENGTH, true);
+      const size = inodeView.getFloat64(off + INODE.SIZE, true);
+      const firstBlock = inodeView.getUint32(off + INODE.FIRST_BLOCK, true);
+      const blockCount = inodeView.getUint32(off + INODE.BLOCK_COUNT, true);
+      if (pathLength === 0 || pathOffset + pathLength > this.pathTableUsed) {
+        throw new Error(`Corrupt VFS: inode ${i} path out of bounds (offset=${pathOffset}, len=${pathLength}, tableUsed=${this.pathTableUsed})`);
+      }
+      if (type !== INODE_TYPE.DIRECTORY) {
+        if (size < 0 || !isFinite(size)) {
+          throw new Error(`Corrupt VFS: inode ${i} has invalid size ${size}`);
+        }
+        if (blockCount > 0 && firstBlock + blockCount > this.totalBlocks) {
+          throw new Error(`Corrupt VFS: inode ${i} data blocks out of range (first=${firstBlock}, count=${blockCount}, total=${this.totalBlocks})`);
+        }
+      }
       const inode = {
         type,
-        pathOffset: inodeView.getUint32(off + INODE.PATH_OFFSET, true),
-        pathLength: inodeView.getUint16(off + INODE.PATH_LENGTH, true),
+        pathOffset,
+        pathLength,
         mode: inodeView.getUint32(off + INODE.MODE, true),
-        size: inodeView.getFloat64(off + INODE.SIZE, true),
-        firstBlock: inodeView.getUint32(off + INODE.FIRST_BLOCK, true),
-        blockCount: inodeView.getUint32(off + INODE.BLOCK_COUNT, true),
+        size,
+        firstBlock,
+        blockCount,
         mtime: inodeView.getFloat64(off + INODE.MTIME, true),
         ctime: inodeView.getFloat64(off + INODE.CTIME, true),
         atime: inodeView.getFloat64(off + INODE.ATIME, true),
@@ -369,7 +389,15 @@ var VFSEngine = class {
         gid: inodeView.getUint32(off + INODE.GID, true)
       };
       this.inodeCache.set(i, inode);
-      const path = pathBuf ? decoder.decode(pathBuf.subarray(inode.pathOffset, inode.pathOffset + inode.pathLength)) : this.readPath(inode.pathOffset, inode.pathLength);
+      let path;
+      if (pathBuf) {
+        path = decoder.decode(pathBuf.subarray(inode.pathOffset, inode.pathOffset + inode.pathLength));
+      } else {
+        path = this.readPath(inode.pathOffset, inode.pathLength);
+      }
+      if (!path.startsWith("/") || path.includes("\0")) {
+        throw new Error(`Corrupt VFS: inode ${i} has invalid path "${path.substring(0, 50)}"`);
+      }
       this.pathIndex.set(path, i);
     }
   }
@@ -1364,6 +1392,503 @@ var VFSEngine = class {
   }
 };
 
+// src/opfs-engine.ts
+var encoder2 = new TextEncoder();
+var TYPE_FILE = 1;
+var TYPE_DIRECTORY = 2;
+var OK = 0;
+var ENOENT = 1;
+var EEXIST = 2;
+var ENOTEMPTY = 5;
+var EINVAL = 7;
+var EBADF = 8;
+var OPFSEngine = class {
+  rootDir;
+  fdTable = /* @__PURE__ */ new Map();
+  nextFd = 3;
+  nextIno = 1;
+  processUid = 0;
+  processGid = 0;
+  async init(rootDir, opts) {
+    this.rootDir = rootDir;
+    this.processUid = opts?.uid ?? 0;
+    this.processGid = opts?.gid ?? 0;
+  }
+  cleanupTab(_tabId) {
+    for (const [fd, entry] of this.fdTable) {
+      try {
+        entry.handle.close();
+      } catch {
+      }
+      this.fdTable.delete(fd);
+    }
+  }
+  getPathForFd(fd) {
+    return this.fdTable.get(fd)?.path ?? null;
+  }
+  // ========== Path helpers ==========
+  normalizePath(path) {
+    if (!path.startsWith("/")) path = "/" + path;
+    while (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+    const parts = path.split("/");
+    const resolved = [];
+    for (const part of parts) {
+      if (part === "" || part === ".") continue;
+      if (part === "..") {
+        resolved.pop();
+        continue;
+      }
+      resolved.push(part);
+    }
+    return "/" + resolved.join("/");
+  }
+  /** Navigate to the parent directory of a path, returning the parent handle and child name. */
+  async navigateToParent(path) {
+    const parts = path.split("/").filter(Boolean);
+    if (parts.length === 0) return null;
+    const name = parts.pop();
+    let dir = this.rootDir;
+    for (const part of parts) {
+      try {
+        dir = await dir.getDirectoryHandle(part);
+      } catch {
+        return null;
+      }
+    }
+    return { dir, name };
+  }
+  /** Navigate to a directory by path. */
+  async navigateToDir(path) {
+    if (path === "/") return this.rootDir;
+    const parts = path.split("/").filter(Boolean);
+    let dir = this.rootDir;
+    for (const part of parts) {
+      try {
+        dir = await dir.getDirectoryHandle(part);
+      } catch {
+        return null;
+      }
+    }
+    return dir;
+  }
+  /** Get a file or directory handle for a path. */
+  async getEntry(path) {
+    if (path === "/") return { handle: this.rootDir, kind: "directory" };
+    const nav = await this.navigateToParent(path);
+    if (!nav) return null;
+    try {
+      return { handle: await nav.dir.getFileHandle(nav.name), kind: "file" };
+    } catch {
+      try {
+        return { handle: await nav.dir.getDirectoryHandle(nav.name), kind: "directory" };
+      } catch {
+        return null;
+      }
+    }
+  }
+  /** Ensure all parent directories exist (recursive mkdir for parents). */
+  async ensureParent(path) {
+    const parts = path.split("/").filter(Boolean);
+    parts.pop();
+    let dir = this.rootDir;
+    for (const part of parts) {
+      try {
+        dir = await dir.getDirectoryHandle(part, { create: true });
+      } catch {
+        return null;
+      }
+    }
+    return dir;
+  }
+  encodeStat(kind, size, mtime, ino) {
+    const buf = new Uint8Array(49);
+    const view = new DataView(buf.buffer);
+    view.setUint8(0, kind === "file" ? TYPE_FILE : TYPE_DIRECTORY);
+    view.setUint32(1, kind === "file" ? 33188 : 16877, true);
+    view.setFloat64(5, size, true);
+    view.setFloat64(13, mtime, true);
+    view.setFloat64(21, mtime, true);
+    view.setFloat64(29, mtime, true);
+    view.setUint32(37, this.processUid, true);
+    view.setUint32(41, this.processGid, true);
+    view.setUint32(45, ino, true);
+    return buf;
+  }
+  // ========== FS Operations ==========
+  async read(path) {
+    path = this.normalizePath(path);
+    const nav = await this.navigateToParent(path);
+    if (!nav) return { status: ENOENT, data: null };
+    try {
+      const fh = await nav.dir.getFileHandle(nav.name);
+      const file = await fh.getFile();
+      return { status: OK, data: new Uint8Array(await file.arrayBuffer()) };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async write(path, data, _flags) {
+    path = this.normalizePath(path);
+    const parentDir = await this.ensureParent(path);
+    if (!parentDir) return { status: ENOENT, data: null };
+    const name = path.split("/").filter(Boolean).pop();
+    try {
+      const fh = await parentDir.getFileHandle(name, { create: true });
+      const sh = await fh.createSyncAccessHandle();
+      try {
+        sh.truncate(0);
+        if (data.byteLength > 0) sh.write(data, { at: 0 });
+        sh.flush();
+      } finally {
+        sh.close();
+      }
+      return { status: OK, data: null };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async append(path, data) {
+    path = this.normalizePath(path);
+    const parentDir = await this.ensureParent(path);
+    if (!parentDir) return { status: ENOENT, data: null };
+    const name = path.split("/").filter(Boolean).pop();
+    try {
+      const fh = await parentDir.getFileHandle(name, { create: true });
+      const sh = await fh.createSyncAccessHandle();
+      try {
+        const size = sh.getSize();
+        sh.write(data, { at: size });
+        sh.flush();
+      } finally {
+        sh.close();
+      }
+      return { status: OK, data: null };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async unlink(path) {
+    path = this.normalizePath(path);
+    const nav = await this.navigateToParent(path);
+    if (!nav) return { status: ENOENT, data: null };
+    try {
+      await nav.dir.getFileHandle(nav.name);
+      await nav.dir.removeEntry(nav.name);
+      return { status: OK, data: null };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async stat(path) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    if (!entry) return { status: ENOENT, data: null };
+    if (entry.kind === "file") {
+      const file = await entry.handle.getFile();
+      return { status: OK, data: this.encodeStat("file", file.size, file.lastModified, this.nextIno++) };
+    }
+    return { status: OK, data: this.encodeStat("directory", 0, Date.now(), this.nextIno++) };
+  }
+  async lstat(path) {
+    return this.stat(path);
+  }
+  async mkdir(path, flags = 0) {
+    path = this.normalizePath(path);
+    const recursive = (flags & 1) !== 0;
+    if (recursive) {
+      const parts = path.split("/").filter(Boolean);
+      let dir = this.rootDir;
+      for (const part of parts) {
+        dir = await dir.getDirectoryHandle(part, { create: true });
+      }
+      return { status: OK, data: encoder2.encode(path) };
+    }
+    const nav = await this.navigateToParent(path);
+    if (!nav) return { status: ENOENT, data: null };
+    try {
+      try {
+        await nav.dir.getDirectoryHandle(nav.name);
+        return { status: EEXIST, data: null };
+      } catch {
+      }
+      await nav.dir.getDirectoryHandle(nav.name, { create: true });
+      return { status: OK, data: encoder2.encode(path) };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async rmdir(path, flags = 0) {
+    path = this.normalizePath(path);
+    if (path === "/") return { status: EINVAL, data: null };
+    const recursive = (flags & 1) !== 0;
+    const nav = await this.navigateToParent(path);
+    if (!nav) return { status: ENOENT, data: null };
+    try {
+      await nav.dir.getDirectoryHandle(nav.name);
+      await nav.dir.removeEntry(nav.name, { recursive });
+      return { status: OK, data: null };
+    } catch (err) {
+      if (err.name === "InvalidModificationError") return { status: ENOTEMPTY, data: null };
+      return { status: ENOENT, data: null };
+    }
+  }
+  async readdir(path, flags = 0) {
+    path = this.normalizePath(path);
+    const dir = await this.navigateToDir(path);
+    if (!dir) return { status: ENOENT, data: null };
+    const withFileTypes = (flags & 1) !== 0;
+    const entries = [];
+    for await (const [name, handle] of dir.entries()) {
+      entries.push({ name, kind: handle.kind });
+    }
+    if (withFileTypes) {
+      let totalSize2 = 4;
+      const encoded = [];
+      for (const e of entries) {
+        const nameBytes = encoder2.encode(e.name);
+        encoded.push({ nameBytes, type: e.kind === "file" ? TYPE_FILE : TYPE_DIRECTORY });
+        totalSize2 += 2 + nameBytes.byteLength + 1;
+      }
+      const buf2 = new Uint8Array(totalSize2);
+      const view2 = new DataView(buf2.buffer);
+      view2.setUint32(0, encoded.length, true);
+      let offset2 = 4;
+      for (const e of encoded) {
+        view2.setUint16(offset2, e.nameBytes.byteLength, true);
+        offset2 += 2;
+        buf2.set(e.nameBytes, offset2);
+        offset2 += e.nameBytes.byteLength;
+        buf2[offset2++] = e.type;
+      }
+      return { status: OK, data: buf2 };
+    }
+    let totalSize = 4;
+    const nameEntries = [];
+    for (const e of entries) {
+      const nameBytes = encoder2.encode(e.name);
+      nameEntries.push(nameBytes);
+      totalSize += 2 + nameBytes.byteLength;
+    }
+    const buf = new Uint8Array(totalSize);
+    const view = new DataView(buf.buffer);
+    view.setUint32(0, nameEntries.length, true);
+    let offset = 4;
+    for (const nameBytes of nameEntries) {
+      view.setUint16(offset, nameBytes.byteLength, true);
+      offset += 2;
+      buf.set(nameBytes, offset);
+      offset += nameBytes.byteLength;
+    }
+    return { status: OK, data: buf };
+  }
+  async rename(oldPath, newPath) {
+    oldPath = this.normalizePath(oldPath);
+    newPath = this.normalizePath(newPath);
+    const entry = await this.getEntry(oldPath);
+    if (!entry) return { status: ENOENT, data: null };
+    if (entry.kind === "file") {
+      const fh = entry.handle;
+      const file = await fh.getFile();
+      const data = new Uint8Array(await file.arrayBuffer());
+      const writeResult = await this.write(newPath, data);
+      if (writeResult.status !== OK) return writeResult;
+      await this.unlink(oldPath);
+    } else {
+      await this.mkdir(newPath, 1);
+      await this.copyDirectoryContents(oldPath, newPath);
+      await this.rmdir(oldPath, 1);
+    }
+    return { status: OK, data: null };
+  }
+  async copyDirectoryContents(srcPath, dstPath) {
+    const srcDir = await this.navigateToDir(srcPath);
+    if (!srcDir) return;
+    for await (const [name, handle] of srcDir.entries()) {
+      const srcChild = srcPath === "/" ? `/${name}` : `${srcPath}/${name}`;
+      const dstChild = dstPath === "/" ? `/${name}` : `${dstPath}/${name}`;
+      if (handle.kind === "directory") {
+        await this.mkdir(dstChild, 1);
+        await this.copyDirectoryContents(srcChild, dstChild);
+      } else {
+        const file = await handle.getFile();
+        const data = new Uint8Array(await file.arrayBuffer());
+        await this.write(dstChild, data);
+      }
+    }
+  }
+  async exists(path) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    return { status: OK, data: new Uint8Array([entry ? 1 : 0]) };
+  }
+  async truncate(path, len) {
+    path = this.normalizePath(path);
+    const nav = await this.navigateToParent(path);
+    if (!nav) return { status: ENOENT, data: null };
+    try {
+      const fh = await nav.dir.getFileHandle(nav.name);
+      const sh = await fh.createSyncAccessHandle();
+      try {
+        sh.truncate(len);
+        sh.flush();
+      } finally {
+        sh.close();
+      }
+      return { status: OK, data: null };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async copy(src, dest, _flags) {
+    src = this.normalizePath(src);
+    dest = this.normalizePath(dest);
+    const readResult = await this.read(src);
+    if (readResult.status !== OK) return readResult;
+    return this.write(dest, readResult.data ?? new Uint8Array(0));
+  }
+  async access(path, _mode) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    if (!entry) return { status: ENOENT, data: null };
+    return { status: OK, data: null };
+  }
+  async realpath(path) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    if (!entry) return { status: ENOENT, data: null };
+    return { status: OK, data: encoder2.encode(path) };
+  }
+  // OPFS doesn't support permissions — these are no-ops
+  async chmod(path, _mode) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    if (!entry) return { status: ENOENT, data: null };
+    return { status: OK, data: null };
+  }
+  async chown(path, _uid, _gid) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    if (!entry) return { status: ENOENT, data: null };
+    return { status: OK, data: null };
+  }
+  async utimes(path, _atime, _mtime) {
+    path = this.normalizePath(path);
+    const entry = await this.getEntry(path);
+    if (!entry) return { status: ENOENT, data: null };
+    return { status: OK, data: null };
+  }
+  // OPFS has no symlinks or hard links
+  async symlink(_target, _linkPath) {
+    return { status: EINVAL, data: null };
+  }
+  async readlink(_path) {
+    return { status: EINVAL, data: null };
+  }
+  async link(existingPath, newPath) {
+    return this.copy(existingPath, newPath);
+  }
+  // ========== File descriptor operations ==========
+  async open(path, flags, _tabId) {
+    path = this.normalizePath(path);
+    const hasCreate = (flags & 64) !== 0;
+    const hasTrunc = (flags & 512) !== 0;
+    const hasExcl = (flags & 128) !== 0;
+    const parentDir = await this.ensureParent(path);
+    if (!parentDir) return { status: ENOENT, data: null };
+    const name = path.split("/").filter(Boolean).pop();
+    try {
+      let exists = true;
+      try {
+        await parentDir.getFileHandle(name);
+      } catch {
+        exists = false;
+      }
+      if (!exists && !hasCreate) return { status: ENOENT, data: null };
+      if (exists && hasExcl && hasCreate) return { status: EEXIST, data: null };
+      const fh = await parentDir.getFileHandle(name, { create: hasCreate });
+      const sh = await fh.createSyncAccessHandle();
+      if (hasTrunc) {
+        sh.truncate(0);
+        sh.flush();
+      }
+      const fd = this.nextFd++;
+      this.fdTable.set(fd, { handle: sh, path, position: 0, flags });
+      const buf = new Uint8Array(4);
+      new DataView(buf.buffer).setUint32(0, fd, true);
+      return { status: OK, data: buf };
+    } catch {
+      return { status: ENOENT, data: null };
+    }
+  }
+  async close(fd) {
+    const entry = this.fdTable.get(fd);
+    if (!entry) return { status: EBADF, data: null };
+    try {
+      entry.handle.close();
+    } catch {
+    }
+    this.fdTable.delete(fd);
+    return { status: OK, data: null };
+  }
+  async fread(fd, length, position) {
+    const entry = this.fdTable.get(fd);
+    if (!entry) return { status: EBADF, data: null };
+    const pos = position ?? entry.position;
+    const size = entry.handle.getSize();
+    const readLen = Math.min(length, size - pos);
+    if (readLen <= 0) return { status: OK, data: new Uint8Array(0) };
+    const buf = new Uint8Array(readLen);
+    entry.handle.read(buf, { at: pos });
+    if (position === null) {
+      entry.position += readLen;
+    }
+    return { status: OK, data: buf };
+  }
+  async fwrite(fd, data, position) {
+    const entry = this.fdTable.get(fd);
+    if (!entry) return { status: EBADF, data: null };
+    const isAppend = (entry.flags & 1024) !== 0;
+    const pos = isAppend ? entry.handle.getSize() : position ?? entry.position;
+    entry.handle.write(data, { at: pos });
+    if (position === null) {
+      entry.position = pos + data.byteLength;
+    }
+    const buf = new Uint8Array(4);
+    new DataView(buf.buffer).setUint32(0, data.byteLength, true);
+    return { status: OK, data: buf };
+  }
+  async fstat(fd) {
+    const entry = this.fdTable.get(fd);
+    if (!entry) return { status: EBADF, data: null };
+    const size = entry.handle.getSize();
+    return { status: OK, data: this.encodeStat("file", size, Date.now(), fd) };
+  }
+  async ftruncate(fd, len = 0) {
+    const entry = this.fdTable.get(fd);
+    if (!entry) return { status: EBADF, data: null };
+    entry.handle.truncate(len);
+    entry.handle.flush();
+    return { status: OK, data: null };
+  }
+  async fsync() {
+    for (const [, entry] of this.fdTable) {
+      try {
+        entry.handle.flush();
+      } catch {
+      }
+    }
+    return { status: OK, data: null };
+  }
+  async opendir(path, _tabId) {
+    return this.readdir(path, 1);
+  }
+  async mkdtemp(prefix) {
+    const random = Math.random().toString(36).substring(2, 8);
+    const path = this.normalizePath(prefix + random);
+    return this.mkdir(path, 1);
+  }
+};
+
 // src/protocol/opcodes.ts
 var OP = {
   READ: 1,
@@ -1422,7 +1947,7 @@ var SIGNAL = {
   CHUNK: 3,
   CHUNK_ACK: 4
 };
-var encoder2 = new TextEncoder();
+var encoder3 = new TextEncoder();
 var decoder2 = new TextDecoder();
 function decodeRequest(buf) {
   const view = new DataView(buf);
@@ -1454,6 +1979,8 @@ function decodeSecondPath(data) {
 
 // src/workers/sync-relay.worker.ts
 var engine = new VFSEngine();
+var opfsEngine = null;
+var opfsMode = false;
 var leaderInitialized = false;
 var readySent = false;
 var debug = false;
@@ -1481,7 +2008,7 @@ function yieldToEventLoop() {
   });
 }
 function registerClientPort(clientTabId, port) {
-  port.onmessage = (e) => {
+  port.onmessage = async (e) => {
     if (e.data.buffer instanceof ArrayBuffer) {
       if (leaderLoopRunning) {
         portQueue.push({
@@ -1491,10 +2018,10 @@ function registerClientPort(clientTabId, port) {
           buffer: e.data.buffer
         });
       } else {
-        const result = handleRequest(clientTabId, e.data.buffer);
+        const result = opfsMode ? await handleRequestOPFS(clientTabId, e.data.buffer) : handleRequest(clientTabId, e.data.buffer);
         const response = encodeResponse(result.status, result.data);
         port.postMessage({ id: e.data.id, buffer: response }, [response]);
-        if (result._op !== void 0) notifyOPFSSync(result._op, result._path, result._newPath);
+        if (!opfsMode && result._op !== void 0) notifyOPFSSync(result._op, result._path, result._newPath);
       }
     }
   };
@@ -1507,7 +2034,11 @@ function removeClientPort(clientTabId) {
     port.close();
     clientPorts.delete(clientTabId);
   }
-  engine.cleanupTab(clientTabId);
+  if (opfsMode) {
+    opfsEngine?.cleanupTab(clientTabId);
+  } else {
+    engine.cleanupTab(clientTabId);
+  }
 }
 function drainPortQueue() {
   while (portQueue.length > 0) {
@@ -1518,6 +2049,14 @@ function drainPortQueue() {
     if (result._op !== void 0) notifyOPFSSync(result._op, result._path, result._newPath);
   }
 }
+async function drainPortQueueAsync() {
+  while (portQueue.length > 0) {
+    const msg = portQueue.shift();
+    const result = await handleRequestOPFS(msg.tabId, msg.buffer);
+    const response = encodeResponse(result.status, result.data);
+    msg.port.postMessage({ id: msg.id, buffer: response }, [response]);
+  }
+}
 var leaderPort = null;
 var pendingResolve = null;
 var asyncRelayPort = null;
@@ -1815,6 +2354,178 @@ function handleRequest(reqTabId, buffer) {
   }
   return ret;
 }
+async function handleRequestOPFS(reqTabId, buffer) {
+  const oe = opfsEngine;
+  const { op, flags, path, data } = decodeRequest(buffer);
+  let result;
+  let syncPath;
+  let syncNewPath;
+  switch (op) {
+    case OP.READ:
+      result = await oe.read(path);
+      break;
+    case OP.WRITE:
+      result = await oe.write(path, data ?? new Uint8Array(0), flags);
+      syncPath = path;
+      break;
+    case OP.APPEND:
+      result = await oe.append(path, data ?? new Uint8Array(0));
+      syncPath = path;
+      break;
+    case OP.UNLINK:
+      result = await oe.unlink(path);
+      syncPath = path;
+      break;
+    case OP.STAT:
+      result = await oe.stat(path);
+      break;
+    case OP.LSTAT:
+      result = await oe.lstat(path);
+      break;
+    case OP.MKDIR:
+      result = await oe.mkdir(path, flags);
+      syncPath = path;
+      break;
+    case OP.RMDIR:
+      result = await oe.rmdir(path, flags);
+      syncPath = path;
+      break;
+    case OP.READDIR:
+      result = await oe.readdir(path, flags);
+      break;
+    case OP.RENAME: {
+      const newPath = data ? decodeSecondPath(data) : "";
+      result = await oe.rename(path, newPath);
+      syncPath = path;
+      syncNewPath = newPath;
+      break;
+    }
+    case OP.EXISTS:
+      result = await oe.exists(path);
+      break;
+    case OP.TRUNCATE: {
+      const len = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
+      result = await oe.truncate(path, len);
+      syncPath = path;
+      break;
+    }
+    case OP.COPY: {
+      const destPath = data ? decodeSecondPath(data) : "";
+      result = await oe.copy(path, destPath, flags);
+      syncPath = destPath;
+      break;
+    }
+    case OP.ACCESS:
+      result = await oe.access(path, flags);
+      break;
+    case OP.REALPATH:
+      result = await oe.realpath(path);
+      break;
+    case OP.CHMOD: {
+      const chmodMode = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
+      result = await oe.chmod(path, chmodMode);
+      break;
+    }
+    case OP.CHOWN: {
+      if (!data || data.byteLength < 8) {
+        result = { status: 7 };
+        break;
+      }
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      result = await oe.chown(path, dv.getUint32(0, true), dv.getUint32(4, true));
+      break;
+    }
+    case OP.UTIMES: {
+      if (!data || data.byteLength < 16) {
+        result = { status: 7 };
+        break;
+      }
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      result = await oe.utimes(path, dv.getFloat64(0, true), dv.getFloat64(8, true));
+      break;
+    }
+    case OP.SYMLINK: {
+      const target = data ? new TextDecoder().decode(data) : "";
+      result = await oe.symlink(target, path);
+      break;
+    }
+    case OP.READLINK:
+      result = await oe.readlink(path);
+      break;
+    case OP.LINK: {
+      const newPath = data ? decodeSecondPath(data) : "";
+      result = await oe.link(path, newPath);
+      syncPath = newPath;
+      break;
+    }
+    case OP.OPEN:
+      result = await oe.open(path, flags, reqTabId);
+      break;
+    case OP.CLOSE: {
+      const fd = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
+      result = await oe.close(fd);
+      break;
+    }
+    case OP.FREAD: {
+      if (!data || data.byteLength < 12) {
+        result = { status: 7 };
+        break;
+      }
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      result = await oe.fread(dv.getUint32(0, true), dv.getUint32(4, true), dv.getInt32(8, true) === -1 ? null : dv.getInt32(8, true));
+      break;
+    }
+    case OP.FWRITE: {
+      if (!data || data.byteLength < 8) {
+        result = { status: 7 };
+        break;
+      }
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      const fd = dv.getUint32(0, true);
+      const pos = dv.getInt32(4, true);
+      result = await oe.fwrite(fd, data.subarray(8), pos === -1 ? null : pos);
+      syncPath = oe.getPathForFd(fd) ?? void 0;
+      break;
+    }
+    case OP.FSTAT: {
+      const fd = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
+      result = await oe.fstat(fd);
+      break;
+    }
+    case OP.FTRUNCATE: {
+      if (!data || data.byteLength < 8) {
+        result = { status: 7 };
+        break;
+      }
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      result = await oe.ftruncate(dv.getUint32(0, true), dv.getUint32(4, true));
+      syncPath = oe.getPathForFd(dv.getUint32(0, true)) ?? void 0;
+      break;
+    }
+    case OP.FSYNC:
+      result = await oe.fsync();
+      break;
+    case OP.OPENDIR:
+      result = await oe.opendir(path, reqTabId);
+      break;
+    case OP.MKDTEMP:
+      result = await oe.mkdtemp(path);
+      if (result.status === 0 && result.data) {
+        syncPath = new TextDecoder().decode(result.data instanceof Uint8Array ? result.data : new Uint8Array(0));
+      }
+      break;
+    default:
+      result = { status: 7 };
+  }
+  const ret = {
+    status: result.status,
+    data: result.data instanceof Uint8Array ? result.data : void 0
+  };
+  if (result.status === 0 && syncPath) {
+    broadcastWatch(op, syncPath, syncNewPath);
+  }
+  return ret;
+}
 function readPayload(targetSab, targetCtrl) {
   const totalLenView = new BigUint64Array(targetSab, SAB_OFFSETS.TOTAL_LEN, 1);
   const maxChunk = targetSab.byteLength - HEADER_SIZE;
@@ -1943,6 +2654,54 @@ async function leaderLoop() {
     }
   }
 }
+async function leaderLoopOPFS() {
+  leaderLoopRunning = true;
+  while (true) {
+    let processed = true;
+    let tightOps = 0;
+    while (processed) {
+      processed = false;
+      if (++tightOps >= 100) {
+        tightOps = 0;
+        await yieldToEventLoop();
+      }
+      if (Atomics.load(ctrl, 0) === SIGNAL.REQUEST) {
+        const payload = readPayload(sab, ctrl);
+        const reqResult = await handleRequestOPFS(tabId, payload.buffer);
+        writeDirectResponse(sab, ctrl, reqResult.status, reqResult.data);
+        const waitResult = Atomics.wait(ctrl, 0, SIGNAL.RESPONSE, 10);
+        if (waitResult === "timed-out") {
+          Atomics.store(ctrl, 0, SIGNAL.IDLE);
+        }
+        processed = true;
+        continue;
+      }
+      if (asyncCtrl && Atomics.load(asyncCtrl, 0) === SIGNAL.REQUEST) {
+        const payload = readPayload(asyncSab, asyncCtrl);
+        const asyncResult = await handleRequestOPFS(tabId, payload.buffer);
+        writeDirectResponse(asyncSab, asyncCtrl, asyncResult.status, asyncResult.data);
+        const waitResult = Atomics.wait(asyncCtrl, 0, SIGNAL.RESPONSE, 10);
+        if (waitResult === "timed-out") {
+          Atomics.store(asyncCtrl, 0, SIGNAL.IDLE);
+        }
+        processed = true;
+        continue;
+      }
+      if (portQueue.length > 0) {
+        await drainPortQueueAsync();
+        processed = true;
+        continue;
+      }
+    }
+    await yieldToEventLoop();
+    if (clientPorts.size === 0) {
+      const currentSignal = Atomics.load(ctrl, 0);
+      if (currentSignal !== SIGNAL.REQUEST) {
+        Atomics.wait(ctrl, 0, currentSignal, 50);
+      }
+    }
+  }
+}
 async function followerLoop() {
   while (true) {
     if (Atomics.load(ctrl, 0) === SIGNAL.REQUEST) {
@@ -2012,6 +2771,23 @@ async function initEngine(config) {
   }
   watchBc = new BroadcastChannel(`${config.ns}-watch`);
 }
+async function initOPFSEngine(config) {
+  debug = config.debug ?? false;
+  opfsMode = true;
+  let rootDir = await navigator.storage.getDirectory();
+  if (config.root && config.root !== "/") {
+    const segments = config.root.split("/").filter(Boolean);
+    for (const segment of segments) {
+      rootDir = await rootDir.getDirectoryHandle(segment, { create: true });
+    }
+  }
+  opfsEngine = new OPFSEngine();
+  await opfsEngine.init(rootDir, {
+    uid: config.uid,
+    gid: config.gid
+  });
+  watchBc = new BroadcastChannel(`${config.ns}-watch`);
+}
 function broadcastWatch(op, path, newPath) {
   if (!watchBc) return;
   let eventType;
@@ -2136,13 +2912,13 @@ self.onmessage = async (e) => {
     const port = msg.port ?? e.ports[0];
     if (port) {
       asyncRelayPort = port;
-      port.onmessage = (ev) => {
+      port.onmessage = async (ev) => {
         if (ev.data.buffer instanceof ArrayBuffer) {
           if (leaderInitialized) {
-            const result = handleRequest(tabId || "nosab", ev.data.buffer);
+            const result = opfsMode ? await handleRequestOPFS(tabId || "nosab", ev.data.buffer) : handleRequest(tabId || "nosab", ev.data.buffer);
             const response = encodeResponse(result.status, result.data);
             port.postMessage({ id: ev.data.id, buffer: response }, [response]);
-            if (result._op !== void 0) notifyOPFSSync(result._op, result._path, result._newPath);
+            if (!opfsMode && result._op !== void 0) notifyOPFSSync(result._op, result._path, result._newPath);
           } else if (leaderPort) {
             const buf = ev.data.buffer;
             leaderPort.postMessage({ id: ev.data.id, tabId, buffer: buf }, [buf]);
@@ -2191,6 +2967,44 @@ self.onmessage = async (e) => {
     }
     return;
   }
+  if (msg.type === "init-opfs") {
+    leaderInitialized = true;
+    readySent = false;
+    tabId = msg.tabId;
+    const hasSAB = msg.sab != null;
+    if (hasSAB) {
+      sab = msg.sab;
+      readySab = msg.readySab;
+      ctrl = new Int32Array(sab, 0, 8);
+      readySignal = new Int32Array(readySab, 0, 1);
+    }
+    if (msg.asyncSab) {
+      asyncSab = msg.asyncSab;
+      asyncCtrl = new Int32Array(msg.asyncSab, 0, 8);
+    }
+    try {
+      await initOPFSEngine(msg.config);
+    } catch (err) {
+      leaderInitialized = false;
+      self.postMessage({
+        type: "init-failed",
+        error: err.message
+      });
+      return;
+    }
+    if (!readySent) {
+      readySent = true;
+      if (hasSAB) {
+        Atomics.store(readySignal, 0, 1);
+        Atomics.notify(readySignal, 0);
+      }
+      self.postMessage({ type: "ready", mode: "opfs" });
+    }
+    if (hasSAB) {
+      leaderLoopOPFS();
+    }
+    return;
+  }
   if (msg.type === "init-follower") {
     tabId = msg.tabId;
     const hasSAB = msg.sab != null;