@componentor/fs 2.0.12 → 3.0.1

package/dist/index.js

@@ -4,266 +4,476 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/path.ts
-var path_exports = {};
-__export(path_exports, {
-  basename: () => basename,
-  default: () => path_default,
-  delimiter: () => delimiter,
-  dirname: () => dirname,
-  extname: () => extname,
-  format: () => format,
-  isAbsolute: () => isAbsolute,
-  join: () => join,
-  normalize: () => normalize,
-  parse: () => parse,
-  posix: () => posix,
-  relative: () => relative,
-  resolve: () => resolve,
-  sep: () => sep
-});
-var sep = "/";
-var delimiter = ":";
-function normalize(p) {
-  if (p.length === 0) return ".";
-  const isAbsolute2 = p.charCodeAt(0) === 47;
-  const trailingSlash = p.charCodeAt(p.length - 1) === 47;
-  const segments = p.split("/");
-  const result = [];
-  for (const segment of segments) {
-    if (segment === "" || segment === ".") {
-      continue;
-    }
-    if (segment === "..") {
-      if (result.length > 0 && result[result.length - 1] !== "..") {
-        result.pop();
-      } else if (!isAbsolute2) {
-        result.push("..");
-      }
-    } else {
-      result.push(segment);
-    }
-  }
-  let normalized = result.join("/");
-  if (isAbsolute2) {
-    normalized = "/" + normalized;
-  }
-  if (trailingSlash && normalized.length > 1) {
-    normalized += "/";
-  }
-  return normalized || (isAbsolute2 ? "/" : ".");
+// src/protocol/opcodes.ts
+var OP = {
+  READ: 1,
+  WRITE: 2,
+  UNLINK: 3,
+  STAT: 4,
+  LSTAT: 5,
+  MKDIR: 6,
+  RMDIR: 7,
+  READDIR: 8,
+  RENAME: 9,
+  EXISTS: 10,
+  TRUNCATE: 11,
+  APPEND: 12,
+  COPY: 13,
+  ACCESS: 14,
+  REALPATH: 15,
+  CHMOD: 16,
+  CHOWN: 17,
+  UTIMES: 18,
+  SYMLINK: 19,
+  READLINK: 20,
+  LINK: 21,
+  OPEN: 22,
+  CLOSE: 23,
+  FREAD: 24,
+  FWRITE: 25,
+  FSTAT: 26,
+  FTRUNCATE: 27,
+  FSYNC: 28,
+  OPENDIR: 29,
+  MKDTEMP: 30
+};
+var SAB_OFFSETS = {
+  // Int32 - bytes in this chunk
+  TOTAL_LEN: 16,
+  // Int32 - reserved
+  HEADER_SIZE: 32
+  // Data payload starts here
+};
+var SIGNAL = {
+  IDLE: 0,
+  REQUEST: 1,
+  RESPONSE: 2,
+  CHUNK: 3,
+  CHUNK_ACK: 4
+};
+var encoder = new TextEncoder();
+new TextDecoder();
+function encodeRequest(op, path, flags = 0, data) {
+  const pathBytes = encoder.encode(path);
+  const dataLen = data ? data.byteLength : 0;
+  const totalLen = 16 + pathBytes.byteLength + dataLen;
+  const buf = new ArrayBuffer(totalLen);
+  const view = new DataView(buf);
+  view.setUint32(0, op, true);
+  view.setUint32(4, flags, true);
+  view.setUint32(8, pathBytes.byteLength, true);
+  view.setUint32(12, dataLen, true);
+  const bytes = new Uint8Array(buf);
+  bytes.set(pathBytes, 16);
+  if (data) {
+    bytes.set(data, 16 + pathBytes.byteLength);
+  }
+  return buf;
 }
-function join(...paths) {
-  if (paths.length === 0) return ".";
-  let joined;
-  for (const path of paths) {
-    if (path.length > 0) {
-      if (joined === void 0) {
-        joined = path;
-      } else {
-        joined += "/" + path;
-      }
-    }
-  }
-  if (joined === void 0) return ".";
-  return normalize(joined);
+function decodeResponse(buf) {
+  const view = new DataView(buf);
+  const status = view.getUint32(0, true);
+  const dataLen = view.getUint32(4, true);
+  const data = dataLen > 0 ? new Uint8Array(buf, 8, dataLen) : null;
+  return { status, data };
 }
-function resolve(...paths) {
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    const path = i >= 0 ? paths[i] : "/";
-    if (path == null || path.length === 0) continue;
-    resolvedPath = resolvedPath ? path + "/" + resolvedPath : path;
-    resolvedAbsolute = path.charCodeAt(0) === 47;
-  }
-  resolvedPath = normalize(resolvedPath);
-  if (resolvedPath.length > 1 && resolvedPath.endsWith("/")) {
-    resolvedPath = resolvedPath.slice(0, -1);
-  }
-  if (resolvedAbsolute) {
-    return resolvedPath.length > 0 ? resolvedPath : "/";
+function encodeTwoPathRequest(op, path1, path2, flags = 0) {
+  const path2Bytes = encoder.encode(path2);
+  const payload = new Uint8Array(4 + path2Bytes.byteLength);
+  const pv = new DataView(payload.buffer);
+  pv.setUint32(0, path2Bytes.byteLength, true);
+  payload.set(path2Bytes, 4);
+  return encodeRequest(op, path1, flags, payload);
+}
+
+// src/errors.ts
+var FSError = class extends Error {
+  code;
+  errno;
+  syscall;
+  path;
+  constructor(code, errno, message, syscall, path) {
+    super(message);
+    this.name = "FSError";
+    this.code = code;
+    this.errno = errno;
+    this.syscall = syscall;
+    this.path = path;
   }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+var ErrorCodes = {
+  ENOENT: -2,
+  EEXIST: -17,
+  EISDIR: -21,
+  ENOTDIR: -20,
+  ENOTEMPTY: -39,
+  EACCES: -13,
+  EBADF: -9,
+  EINVAL: -22,
+  EMFILE: -24,
+  ENOSPC: -28,
+  EPERM: -1,
+  ENOSYS: -38,
+  ELOOP: -40
+};
+var STATUS_TO_CODE = {
+  0: "OK",
+  1: "ENOENT",
+  2: "EEXIST",
+  3: "EISDIR",
+  4: "ENOTDIR",
+  5: "ENOTEMPTY",
+  6: "EACCES",
+  7: "EINVAL",
+  8: "EBADF",
+  9: "ELOOP",
+  10: "ENOSPC"
+};
+function createError(code, syscall, path) {
+  const errno = ErrorCodes[code] ?? -1;
+  const messages = {
+    ENOENT: "no such file or directory",
+    EEXIST: "file already exists",
+    EISDIR: "illegal operation on a directory",
+    ENOTDIR: "not a directory",
+    ENOTEMPTY: "directory not empty",
+    EACCES: "permission denied",
+    EINVAL: "invalid argument",
+    EBADF: "bad file descriptor",
+    ELOOP: "too many symbolic links encountered",
+    ENOSPC: "no space left on device"
+  };
+  const msg = messages[code] ?? "unknown error";
+  return new FSError(code, errno, `${code}: ${msg}, ${syscall} '${path}'`, syscall, path);
 }
-function isAbsolute(p) {
-  return p.length > 0 && p.charCodeAt(0) === 47;
+function statusToError(status, syscall, path) {
+  const code = STATUS_TO_CODE[status] ?? "EINVAL";
+  return createError(code, syscall, path);
 }
-function dirname(p) {
-  if (p.length === 0) return ".";
-  const hasRoot = p.charCodeAt(0) === 47;
-  let end = -1;
-  let matchedSlash = true;
-  for (let i = p.length - 1; i >= 1; --i) {
-    if (p.charCodeAt(i) === 47) {
-      if (!matchedSlash) {
-        end = i;
-        break;
-      }
-    } else {
-      matchedSlash = false;
-    }
-  }
-  if (end === -1) return hasRoot ? "/" : ".";
-  if (hasRoot && end === 1) return "//";
-  return p.slice(0, end);
+
+// src/methods/readFile.ts
+var decoder2 = new TextDecoder();
+function readFileSync(syncRequest, filePath, options) {
+  const encoding = typeof options === "string" ? options : options?.encoding;
+  const buf = encodeRequest(OP.READ, filePath);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "read", filePath);
+  const result = data ?? new Uint8Array(0);
+  if (encoding) return decoder2.decode(result);
+  return result;
 }
-function basename(p, ext) {
-  let start = 0;
-  let end = -1;
-  let matchedSlash = true;
-  for (let i = p.length - 1; i >= 0; --i) {
-    if (p.charCodeAt(i) === 47) {
-      if (!matchedSlash) {
-        start = i + 1;
-        break;
-      }
-    } else if (end === -1) {
-      matchedSlash = false;
-      end = i + 1;
-    }
-  }
-  if (end === -1) return "";
-  const base = p.slice(start, end);
-  if (ext && base.endsWith(ext)) {
-    return base.slice(0, base.length - ext.length);
-  }
-  return base;
+async function readFile(asyncRequest, filePath, options) {
+  const encoding = typeof options === "string" ? options : options?.encoding;
+  const { status, data } = await asyncRequest(OP.READ, filePath);
+  if (status !== 0) throw statusToError(status, "read", filePath);
+  const result = data ?? new Uint8Array(0);
+  if (encoding) return decoder2.decode(result);
+  return result;
 }
-function extname(p) {
-  let startDot = -1;
-  let startPart = 0;
-  let end = -1;
-  let matchedSlash = true;
-  let preDotState = 0;
-  for (let i = p.length - 1; i >= 0; --i) {
-    const code = p.charCodeAt(i);
-    if (code === 47) {
-      if (!matchedSlash) {
-        startPart = i + 1;
-        break;
-      }
-      continue;
-    }
-    if (end === -1) {
-      matchedSlash = false;
-      end = i + 1;
-    }
-    if (code === 46) {
-      if (startDot === -1) {
-        startDot = i;
-      } else if (preDotState !== 1) {
-        preDotState = 1;
-      }
-    } else if (startDot !== -1) {
-      preDotState = -1;
-    }
-  }
-  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-    return "";
-  }
-  return p.slice(startDot, end);
+
+// src/methods/writeFile.ts
+var encoder2 = new TextEncoder();
+function writeFileSync(syncRequest, filePath, data, options) {
+  const opts = typeof options === "string" ? { } : options;
+  const encoded = typeof data === "string" ? encoder2.encode(data) : data;
+  const flags = opts?.flush === true ? 1 : 0;
+  const buf = encodeRequest(OP.WRITE, filePath, flags, encoded);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "write", filePath);
 }
-function relative(from, to) {
-  if (from === to) return "";
-  from = resolve(from);
-  to = resolve(to);
-  if (from === to) return "";
-  const fromParts = from.split("/").filter(Boolean);
-  const toParts = to.split("/").filter(Boolean);
-  let commonLength = 0;
-  const minLength = Math.min(fromParts.length, toParts.length);
-  for (let i = 0; i < minLength; i++) {
-    if (fromParts[i] === toParts[i]) {
-      commonLength++;
-    } else {
-      break;
+async function writeFile(asyncRequest, filePath, data, options) {
+  const opts = typeof options === "string" ? { } : options;
+  const flags = opts?.flush === true ? 1 : 0;
+  const encoded = typeof data === "string" ? encoder2.encode(data) : data;
+  const { status } = await asyncRequest(OP.WRITE, filePath, flags, encoded);
+  if (status !== 0) throw statusToError(status, "write", filePath);
+}
+
+// src/methods/appendFile.ts
+var encoder3 = new TextEncoder();
+function appendFileSync(syncRequest, filePath, data, options) {
+  const encoded = typeof data === "string" ? encoder3.encode(data) : data;
+  const buf = encodeRequest(OP.APPEND, filePath, 0, encoded);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "appendFile", filePath);
+}
+async function appendFile(asyncRequest, filePath, data, options) {
+  const encoded = typeof data === "string" ? encoder3.encode(data) : data;
+  const { status } = await asyncRequest(OP.APPEND, filePath, 0, encoded);
+  if (status !== 0) throw statusToError(status, "appendFile", filePath);
+}
+
+// src/methods/exists.ts
+function existsSync(syncRequest, filePath) {
+  const buf = encodeRequest(OP.EXISTS, filePath);
+  const { data } = syncRequest(buf);
+  return data ? data[0] === 1 : false;
+}
+async function exists(asyncRequest, filePath) {
+  const { data } = await asyncRequest(OP.EXISTS, filePath);
+  return data ? data[0] === 1 : false;
+}
+
+// src/methods/mkdir.ts
+var decoder3 = new TextDecoder();
+function mkdirSync(syncRequest, filePath, options) {
+  const opts = typeof options === "number" ? { } : options;
+  const flags = opts?.recursive ? 1 : 0;
+  const buf = encodeRequest(OP.MKDIR, filePath, flags);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "mkdir", filePath);
+  return data ? decoder3.decode(data) : void 0;
+}
+async function mkdir(asyncRequest, filePath, options) {
+  const opts = typeof options === "number" ? { } : options;
+  const flags = opts?.recursive ? 1 : 0;
+  const { status, data } = await asyncRequest(OP.MKDIR, filePath, flags);
+  if (status !== 0) throw statusToError(status, "mkdir", filePath);
+  return data ? decoder3.decode(data) : void 0;
+}
+
+// src/methods/rmdir.ts
+function rmdirSync(syncRequest, filePath, options) {
+  const flags = options?.recursive ? 1 : 0;
+  const buf = encodeRequest(OP.RMDIR, filePath, flags);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "rmdir", filePath);
+}
+async function rmdir(asyncRequest, filePath, options) {
+  const flags = options?.recursive ? 1 : 0;
+  const { status } = await asyncRequest(OP.RMDIR, filePath, flags);
+  if (status !== 0) throw statusToError(status, "rmdir", filePath);
+}
+
+// src/methods/rm.ts
+function rmSync(syncRequest, filePath, options) {
+  const flags = (options?.recursive ? 1 : 0) | (options?.force ? 2 : 0);
+  const buf = encodeRequest(OP.UNLINK, filePath, flags);
+  const { status } = syncRequest(buf);
+  if (status === 3) {
+    const rmdirBuf = encodeRequest(OP.RMDIR, filePath, flags);
+    const rmdirResult = syncRequest(rmdirBuf);
+    if (rmdirResult.status !== 0) {
+      if (options?.force && rmdirResult.status === 1) return;
+      throw statusToError(rmdirResult.status, "rm", filePath);
     }
+    return;
   }
-  const upCount = fromParts.length - commonLength;
-  const relativeParts = [];
-  for (let i = 0; i < upCount; i++) {
-    relativeParts.push("..");
-  }
-  for (let i = commonLength; i < toParts.length; i++) {
-    relativeParts.push(toParts[i]);
+  if (status !== 0) {
+    if (options?.force && status === 1) return;
+    throw statusToError(status, "rm", filePath);
   }
-  return relativeParts.join("/") || ".";
 }
-function parse(p) {
-  const ret = { root: "", dir: "", base: "", ext: "", name: "" };
-  if (p.length === 0) return ret;
-  const isAbsolutePath = p.charCodeAt(0) === 47;
-  if (isAbsolutePath) {
-    ret.root = "/";
-  }
-  let start = 0;
-  let end = -1;
-  let startDot = -1;
-  let matchedSlash = true;
-  let preDotState = 0;
-  for (let i = p.length - 1; i >= 0; --i) {
-    const code = p.charCodeAt(i);
-    if (code === 47) {
-      if (!matchedSlash) {
-        start = i + 1;
-        break;
-      }
-      continue;
-    }
-    if (end === -1) {
-      matchedSlash = false;
-      end = i + 1;
-    }
-    if (code === 46) {
-      if (startDot === -1) {
-        startDot = i;
-      } else if (preDotState !== 1) {
-        preDotState = 1;
-      }
-    } else if (startDot !== -1) {
-      preDotState = -1;
+async function rm(asyncRequest, filePath, options) {
+  const flags = (options?.recursive ? 1 : 0) | (options?.force ? 2 : 0);
+  const { status } = await asyncRequest(OP.UNLINK, filePath, flags);
+  if (status === 3) {
+    const { status: s2 } = await asyncRequest(OP.RMDIR, filePath, flags);
+    if (s2 !== 0) {
+      if (options?.force && s2 === 1) return;
+      throw statusToError(s2, "rm", filePath);
     }
+    return;
   }
-  if (end !== -1) {
-    if (startDot === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === start + 1) {
-      ret.base = p.slice(start, end);
-      ret.name = ret.base;
-    } else {
-      ret.name = p.slice(start, startDot);
-      ret.base = p.slice(start, end);
-      ret.ext = p.slice(startDot, end);
-    }
+  if (status !== 0) {
+    if (options?.force && status === 1) return;
+    throw statusToError(status, "rm", filePath);
   }
-  if (start > 0) {
-    ret.dir = p.slice(0, start - 1);
-  } else if (isAbsolutePath) {
-    ret.dir = "/";
-  }
-  return ret;
-}
-function format(pathObject) {
-  const dir = pathObject.dir || pathObject.root || "";
-  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
-  if (!dir) return base;
-  if (dir === pathObject.root) return dir + base;
-  return dir + "/" + base;
-}
-var posix = {
-  sep,
-  delimiter,
-  normalize,
-  join,
-  resolve,
-  isAbsolute,
-  dirname,
-  basename,
-  extname,
-  relative,
-  parse,
-  format
+}
+
+// src/methods/unlink.ts
+function unlinkSync(syncRequest, filePath) {
+  const buf = encodeRequest(OP.UNLINK, filePath);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "unlink", filePath);
+}
+async function unlink(asyncRequest, filePath) {
+  const { status } = await asyncRequest(OP.UNLINK, filePath);
+  if (status !== 0) throw statusToError(status, "unlink", filePath);
+}
+
+// src/vfs/layout.ts
+var INODE_TYPE = {
+  FILE: 1,
+  DIRECTORY: 2,
+  SYMLINK: 3
 };
-var path_default = posix;
+
+// src/stats.ts
+function decodeStats(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const type = view.getUint8(0);
+  const mode = view.getUint32(1, true);
+  const size = view.getFloat64(5, true);
+  const mtimeMs = view.getFloat64(13, true);
+  const ctimeMs = view.getFloat64(21, true);
+  const atimeMs = view.getFloat64(29, true);
+  const uid = view.getUint32(37, true);
+  const gid = view.getUint32(41, true);
+  const ino = view.getUint32(45, true);
+  const isFile = type === INODE_TYPE.FILE;
+  const isDirectory = type === INODE_TYPE.DIRECTORY;
+  const isSymlink = type === INODE_TYPE.SYMLINK;
+  return {
+    isFile: () => isFile,
+    isDirectory: () => isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => isSymlink,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: 0,
+    ino,
+    mode,
+    nlink: 1,
+    uid,
+    gid,
+    rdev: 0,
+    size,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+    atimeMs,
+    mtimeMs,
+    ctimeMs,
+    birthtimeMs: ctimeMs,
+    atime: new Date(atimeMs),
+    mtime: new Date(mtimeMs),
+    ctime: new Date(ctimeMs),
+    birthtime: new Date(ctimeMs)
+  };
+}
+function decodeDirents(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const count = view.getUint32(0, true);
+  const decoder8 = new TextDecoder();
+  const entries = [];
+  let offset = 4;
+  for (let i = 0; i < count; i++) {
+    const nameLen = view.getUint16(offset, true);
+    offset += 2;
+    const name = decoder8.decode(data.subarray(offset, offset + nameLen));
+    offset += nameLen;
+    const type = data[offset++];
+    const isFile = type === INODE_TYPE.FILE;
+    const isDirectory = type === INODE_TYPE.DIRECTORY;
+    const isSymlink = type === INODE_TYPE.SYMLINK;
+    entries.push({
+      name,
+      isFile: () => isFile,
+      isDirectory: () => isDirectory,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => isSymlink,
+      isFIFO: () => false,
+      isSocket: () => false
+    });
+  }
+  return entries;
+}
+function decodeNames(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const count = view.getUint32(0, true);
+  const decoder8 = new TextDecoder();
+  const names = [];
+  let offset = 4;
+  for (let i = 0; i < count; i++) {
+    const nameLen = view.getUint16(offset, true);
+    offset += 2;
+    names.push(decoder8.decode(data.subarray(offset, offset + nameLen)));
+    offset += nameLen;
+  }
+  return names;
+}
+
+// src/methods/readdir.ts
+function readdirSync(syncRequest, filePath, options) {
+  const opts = typeof options === "string" ? { } : options;
+  const flags = opts?.withFileTypes ? 1 : 0;
+  const buf = encodeRequest(OP.READDIR, filePath, flags);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "readdir", filePath);
+  if (!data) return [];
+  return opts?.withFileTypes ? decodeDirents(data) : decodeNames(data);
+}
+async function readdir(asyncRequest, filePath, options) {
+  const opts = typeof options === "string" ? { } : options;
+  const flags = opts?.withFileTypes ? 1 : 0;
+  const { status, data } = await asyncRequest(OP.READDIR, filePath, flags);
+  if (status !== 0) throw statusToError(status, "readdir", filePath);
+  if (!data) return [];
+  return opts?.withFileTypes ? decodeDirents(data) : decodeNames(data);
+}
+
+// src/methods/stat.ts
+function statSync(syncRequest, filePath) {
+  const buf = encodeRequest(OP.STAT, filePath);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "stat", filePath);
+  return decodeStats(data);
+}
+function lstatSync(syncRequest, filePath) {
+  const buf = encodeRequest(OP.LSTAT, filePath);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "lstat", filePath);
+  return decodeStats(data);
+}
+async function stat(asyncRequest, filePath) {
+  const { status, data } = await asyncRequest(OP.STAT, filePath);
+  if (status !== 0) throw statusToError(status, "stat", filePath);
+  return decodeStats(data);
+}
+async function lstat(asyncRequest, filePath) {
+  const { status, data } = await asyncRequest(OP.LSTAT, filePath);
+  if (status !== 0) throw statusToError(status, "lstat", filePath);
+  return decodeStats(data);
+}
+
+// src/methods/rename.ts
+var encoder4 = new TextEncoder();
+function renameSync(syncRequest, oldPath, newPath) {
+  const buf = encodeTwoPathRequest(OP.RENAME, oldPath, newPath);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "rename", oldPath);
+}
+async function rename(asyncRequest, oldPath, newPath) {
+  const path2Bytes = encoder4.encode(newPath);
+  const payload = new Uint8Array(4 + path2Bytes.byteLength);
+  new DataView(payload.buffer).setUint32(0, path2Bytes.byteLength, true);
+  payload.set(path2Bytes, 4);
+  const { status } = await asyncRequest(OP.RENAME, oldPath, 0, payload);
+  if (status !== 0) throw statusToError(status, "rename", oldPath);
+}
+
+// src/methods/copyFile.ts
+var encoder5 = new TextEncoder();
+function copyFileSync(syncRequest, src, dest, mode) {
+  const buf = encodeTwoPathRequest(OP.COPY, src, dest, mode ?? 0);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "copyFile", src);
+}
+async function copyFile(asyncRequest, src, dest, mode) {
+  const path2Bytes = encoder5.encode(dest);
+  const payload = new Uint8Array(4 + path2Bytes.byteLength);
+  new DataView(payload.buffer).setUint32(0, path2Bytes.byteLength, true);
+  payload.set(path2Bytes, 4);
+  const { status } = await asyncRequest(OP.COPY, src, mode ?? 0, payload);
+  if (status !== 0) throw statusToError(status, "copyFile", src);
+}
+
+// src/methods/truncate.ts
+function truncateSync(syncRequest, filePath, len = 0) {
+  const lenBuf = new Uint8Array(4);
+  new DataView(lenBuf.buffer).setUint32(0, len, true);
+  const buf = encodeRequest(OP.TRUNCATE, filePath, 0, lenBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "truncate", filePath);
+}
+async function truncate(asyncRequest, filePath, len) {
+  const lenBuf = new Uint8Array(4);
+  new DataView(lenBuf.buffer).setUint32(0, len ?? 0, true);
+  const { status } = await asyncRequest(OP.TRUNCATE, filePath, 0, lenBuf);
+  if (status !== 0) throw statusToError(status, "truncate", filePath);
+}
 
 // src/constants.ts
 var constants = {
@@ -309,2486 +519,1164 @@ var constants = {
   S_IXOTH: 1
 };
 
-// src/errors.ts
-var FSError = class _FSError extends Error {
-  code;
-  errno;
-  syscall;
-  path;
-  constructor(code, errno, message, syscall, path) {
-    super(message);
-    this.name = "FSError";
-    this.code = code;
-    this.errno = errno;
-    this.syscall = syscall;
-    this.path = path;
-    const ErrorWithCapture = Error;
-    if (ErrorWithCapture.captureStackTrace) {
-      ErrorWithCapture.captureStackTrace(this, _FSError);
-    }
-  }
-};
-var ErrorCodes = {
-  ENOENT: -2,
-  EEXIST: -17,
-  EISDIR: -21,
-  ENOTDIR: -20,
-  ENOTEMPTY: -39,
-  EACCES: -13,
-  EINVAL: -22,
-  ENOSPC: -28};
-function createENOENT(syscall, path) {
-  return new FSError(
-    "ENOENT",
-    ErrorCodes.ENOENT,
-    `ENOENT: no such file or directory, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function createEEXIST(syscall, path) {
-  return new FSError(
-    "EEXIST",
-    ErrorCodes.EEXIST,
-    `EEXIST: file already exists, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function createEISDIR(syscall, path) {
-  return new FSError(
-    "EISDIR",
-    ErrorCodes.EISDIR,
-    `EISDIR: illegal operation on a directory, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function createENOTDIR(syscall, path) {
-  return new FSError(
-    "ENOTDIR",
-    ErrorCodes.ENOTDIR,
-    `ENOTDIR: not a directory, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function createENOTEMPTY(syscall, path) {
-  return new FSError(
-    "ENOTEMPTY",
-    ErrorCodes.ENOTEMPTY,
-    `ENOTEMPTY: directory not empty, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function createEACCES(syscall, path) {
-  return new FSError(
-    "EACCES",
-    ErrorCodes.EACCES,
-    `EACCES: permission denied, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function createEINVAL(syscall, path) {
-  return new FSError(
-    "EINVAL",
-    ErrorCodes.EINVAL,
-    `EINVAL: invalid argument, ${syscall} '${path}'`,
-    syscall,
-    path
-  );
-}
-function mapErrorCode(errorName, syscall, path) {
-  switch (errorName) {
-    case "NotFoundError":
-      return createENOENT(syscall, path);
-    case "NotAllowedError":
-      return createEACCES(syscall, path);
-    case "TypeMismatchError":
-      return createENOTDIR(syscall, path);
-    case "InvalidModificationError":
-      return createENOTEMPTY(syscall, path);
-    case "QuotaExceededError":
-      return new FSError("ENOSPC", ErrorCodes.ENOSPC, `ENOSPC: no space left on device, ${syscall} '${path}'`, syscall, path);
-    default:
-      return new FSError("EINVAL", ErrorCodes.EINVAL, `${errorName}: ${syscall} '${path}'`, syscall, path);
-  }
+// src/methods/access.ts
+function accessSync(syncRequest, filePath, mode = constants.F_OK) {
+  const buf = encodeRequest(OP.ACCESS, filePath, mode);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "access", filePath);
 }
-
-// src/filesystem.ts
-var isWorkerContext = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
-var KERNEL_SOURCE = `
-const LOCK_NAME = 'opfs_fs_lock';
-let messageQueue = [];
-let isReady = false;
-let cachedRoot = null;
-const dirCache = new Map();
-
-// Sync handle cache - MAJOR performance optimization (2-5x speedup)
-// Uses readwrite-unsafe mode when available (no exclusive lock, allows external access)
-// Falls back to readwrite with debounced release for older browsers
-const syncHandleCache = new Map();
-const MAX_HANDLES = 100;
-
-// Track if readwrite-unsafe mode is supported (detected on first use)
-let unsafeModeSupported = null;
-
-// Debug tracing - set via 'setDebug' message
-let debugTrace = false;
-function trace(...args) {
-  if (debugTrace) console.log('[OPFS-T2]', ...args);
+async function access(asyncRequest, filePath, mode) {
+  const { status } = await asyncRequest(OP.ACCESS, filePath, mode ?? 0);
+  if (status !== 0) throw statusToError(status, "access", filePath);
 }
 
-// Handle release timing
-// - Legacy mode (readwrite): 100ms delay (handles block, release ASAP)
-// - Unsafe mode (readwrite-unsafe): 500ms delay (handles don't block each other,
-//   but DO block external tools using default mode like OPFS Explorer)
-let releaseTimer = null;
-const LEGACY_RELEASE_DELAY = 100;
-const UNSAFE_RELEASE_DELAY = 500;
-
-function scheduleHandleRelease() {
-  if (releaseTimer) return; // Already scheduled
-
-  const delay = unsafeModeSupported ? UNSAFE_RELEASE_DELAY : LEGACY_RELEASE_DELAY;
-
-  releaseTimer = setTimeout(() => {
-    releaseTimer = null;
-    const count = syncHandleCache.size;
-    if (count === 0) return;
-
-    for (const h of syncHandleCache.values()) {
-      try { h.flush(); h.close(); } catch {}
-    }
-    syncHandleCache.clear();
-    trace('Released ' + count + ' handles (' + (unsafeModeSupported ? 'unsafe' : 'legacy') + ' mode, ' + delay + 'ms delay)');
-  }, delay);
+// src/methods/realpath.ts
+var decoder4 = new TextDecoder();
+function realpathSync(syncRequest, filePath) {
+  const buf = encodeRequest(OP.REALPATH, filePath);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "realpath", filePath);
+  return decoder4.decode(data);
 }
-
-async function getSyncHandle(filePath, create) {
-  const cached = syncHandleCache.get(filePath);
-  if (cached) {
-    trace('Handle cache HIT: ' + filePath);
-    return cached;
-  }
-
-  // Evict oldest handles if cache is full
-  if (syncHandleCache.size >= MAX_HANDLES) {
-    const keys = Array.from(syncHandleCache.keys()).slice(0, 10);
-    trace('LRU evicting ' + keys.length + ' handles');
-    for (const key of keys) {
-      const h = syncHandleCache.get(key);
-      if (h) { try { h.close(); } catch {} syncHandleCache.delete(key); }
-    }
-  }
-
-  const fh = await getFileHandle(filePath, create);
-
-  // Try readwrite-unsafe mode first (no exclusive lock, Chrome 121+)
-  let access;
-  if (unsafeModeSupported === null) {
-    // First time - detect support
-    try {
-      access = await fh.createSyncAccessHandle({ mode: 'readwrite-unsafe' });
-      unsafeModeSupported = true;
-      trace('readwrite-unsafe mode SUPPORTED - handles won\\'t block');
-    } catch {
-      // Not supported, use default mode
-      access = await fh.createSyncAccessHandle();
-      unsafeModeSupported = false;
-      trace('readwrite-unsafe mode NOT supported - using legacy mode');
-    }
-  } else if (unsafeModeSupported) {
-    access = await fh.createSyncAccessHandle({ mode: 'readwrite-unsafe' });
-  } else {
-    access = await fh.createSyncAccessHandle();
-  }
-
-  syncHandleCache.set(filePath, access);
-  trace('Handle ACQUIRED: ' + filePath + ' (cache size: ' + syncHandleCache.size + ')');
-  return access;
+async function realpath(asyncRequest, filePath) {
+  const { status, data } = await asyncRequest(OP.REALPATH, filePath);
+  if (status !== 0) throw statusToError(status, "realpath", filePath);
+  return decoder4.decode(data);
 }
 
-function closeSyncHandle(filePath) {
-  const h = syncHandleCache.get(filePath);
-  if (h) {
-    try { h.close(); } catch {}
-    syncHandleCache.delete(filePath);
-    trace('Handle RELEASED: ' + filePath);
-  }
+// src/methods/chmod.ts
+function chmodSync(syncRequest, filePath, mode) {
+  const modeBuf = new Uint8Array(4);
+  new DataView(modeBuf.buffer).setUint32(0, mode, true);
+  const buf = encodeRequest(OP.CHMOD, filePath, 0, modeBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "chmod", filePath);
 }
-
-function closeHandlesUnder(prefix) {
-  for (const [p, h] of syncHandleCache) {
-    if (p === prefix || p.startsWith(prefix + '/')) {
-      try { h.close(); } catch {}
-      syncHandleCache.delete(p);
-    }
-  }
+async function chmod(asyncRequest, filePath, mode) {
+  const modeBuf = new Uint8Array(4);
+  new DataView(modeBuf.buffer).setUint32(0, mode, true);
+  const { status } = await asyncRequest(OP.CHMOD, filePath, 0, modeBuf);
+  if (status !== 0) throw statusToError(status, "chmod", filePath);
 }
 
-// Clear directory cache entries for a path and all descendants
-function clearDirCacheUnder(filePath) {
-  // Convert to cache key format (no leading slash)
-  const prefix = parsePath(filePath).join('/');
-  if (!prefix) {
-    // Root directory - clear everything
-    dirCache.clear();
-    return;
-  }
-  for (const key of dirCache.keys()) {
-    if (key === prefix || key.startsWith(prefix + '/')) {
-      dirCache.delete(key);
-    }
-  }
+// src/methods/chown.ts
+function chownSync(syncRequest, filePath, uid, gid) {
+  const ownerBuf = new Uint8Array(8);
+  const dv = new DataView(ownerBuf.buffer);
+  dv.setUint32(0, uid, true);
+  dv.setUint32(4, gid, true);
+  const buf = encodeRequest(OP.CHOWN, filePath, 0, ownerBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "chown", filePath);
 }
-
-async function getRoot() {
-  if (!cachedRoot) {
-    cachedRoot = await navigator.storage.getDirectory();
-  }
-  return cachedRoot;
+async function chown(asyncRequest, filePath, uid, gid) {
+  const buf = new Uint8Array(8);
+  const dv = new DataView(buf.buffer);
+  dv.setUint32(0, uid, true);
+  dv.setUint32(4, gid, true);
+  const { status } = await asyncRequest(OP.CHOWN, filePath, 0, buf);
+  if (status !== 0) throw statusToError(status, "chown", filePath);
 }
 
-function parsePath(filePath) {
-  return filePath.split('/').filter(Boolean);
+// src/methods/utimes.ts
+function utimesSync(syncRequest, filePath, atime, mtime) {
+  const timesBuf = new Uint8Array(16);
+  const dv = new DataView(timesBuf.buffer);
+  dv.setFloat64(0, typeof atime === "number" ? atime : atime.getTime(), true);
+  dv.setFloat64(8, typeof mtime === "number" ? mtime : mtime.getTime(), true);
+  const buf = encodeRequest(OP.UTIMES, filePath, 0, timesBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "utimes", filePath);
 }
-
-async function getDirectoryHandle(parts, create = false) {
-  if (parts.length === 0) return getRoot();
-
-  const cacheKey = parts.join('/');
-  if (dirCache.has(cacheKey)) {
-    return dirCache.get(cacheKey);
-  }
-
-  let curr = await getRoot();
-  let pathSoFar = '';
-
-  for (const part of parts) {
-    pathSoFar += (pathSoFar ? '/' : '') + part;
-
-    if (dirCache.has(pathSoFar)) {
-      curr = dirCache.get(pathSoFar);
-    } else {
-      curr = await curr.getDirectoryHandle(part, { create });
-      dirCache.set(pathSoFar, curr);
-    }
-  }
-
-  return curr;
+async function utimes(asyncRequest, filePath, atime, mtime) {
+  const buf = new Uint8Array(16);
+  const dv = new DataView(buf.buffer);
+  dv.setFloat64(0, typeof atime === "number" ? atime : atime.getTime(), true);
+  dv.setFloat64(8, typeof mtime === "number" ? mtime : mtime.getTime(), true);
+  const { status } = await asyncRequest(OP.UTIMES, filePath, 0, buf);
+  if (status !== 0) throw statusToError(status, "utimes", filePath);
 }
 
-async function getFileHandle(filePath, create = false) {
-  const parts = parsePath(filePath);
-  const fileName = parts.pop();
-  if (!fileName) throw new Error('Invalid file path');
-  const dir = parts.length > 0 ? await getDirectoryHandle(parts, create) : await getRoot();
-  return await dir.getFileHandle(fileName, { create });
+// src/methods/symlink.ts
+var encoder6 = new TextEncoder();
+var decoder5 = new TextDecoder();
+function symlinkSync(syncRequest, target, linkPath) {
+  const targetBytes = encoder6.encode(target);
+  const buf = encodeRequest(OP.SYMLINK, linkPath, 0, targetBytes);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "symlink", linkPath);
 }
-
-async function getParentAndName(filePath) {
-  const parts = parsePath(filePath);
-  const name = parts.pop();
-  if (!name) throw new Error('Invalid path');
-  const parent = parts.length > 0 ? await getDirectoryHandle(parts, false) : await getRoot();
-  return { parent, name };
+function readlinkSync(syncRequest, filePath) {
+  const buf = encodeRequest(OP.READLINK, filePath);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "readlink", filePath);
+  return decoder5.decode(data);
 }
-
-async function handleRead(filePath, payload) {
-  const access = await getSyncHandle(filePath, false);
-  const size = access.getSize();
-  const offset = payload?.offset || 0;
-  const len = payload?.len || (size - offset);
-  const buf = new Uint8Array(len);
-  const bytesRead = access.read(buf, { at: offset });
-  return { data: buf.slice(0, bytesRead) };
+async function symlink(asyncRequest, target, linkPath) {
+  const targetBytes = encoder6.encode(target);
+  const { status } = await asyncRequest(OP.SYMLINK, linkPath, 0, targetBytes);
+  if (status !== 0) throw statusToError(status, "symlink", linkPath);
 }
-
-// Non-blocking read using getFile() - does NOT lock the file
-// Use this for HMR scenarios where external tools need to modify files
-async function handleReadAsync(filePath, payload) {
-  const parts = parsePath(filePath);
-  const fileName = parts.pop();
-  if (!fileName) throw new Error('Invalid file path');
-  const dir = parts.length > 0 ? await getDirectoryHandle(parts, false) : await getRoot();
-  const fh = await dir.getFileHandle(fileName);
-  const file = await fh.getFile();
-
-  const offset = payload?.offset || 0;
-  const len = payload?.len || (file.size - offset);
-
-  if (offset === 0 && len === file.size) {
-    // Fast path: read entire file
-    const buf = new Uint8Array(await file.arrayBuffer());
-    return { data: buf };
-  }
-
-  // Partial read using slice
-  const slice = file.slice(offset, offset + len);
-  const buf = new Uint8Array(await slice.arrayBuffer());
-  return { data: buf };
+async function readlink(asyncRequest, filePath) {
+  const { status, data } = await asyncRequest(OP.READLINK, filePath);
+  if (status !== 0) throw statusToError(status, "readlink", filePath);
+  return decoder5.decode(data);
 }
 
-// Force release a file handle - allows external tools to modify the file
-function handleReleaseHandle(filePath) {
-  closeSyncHandle(filePath);
-  return { success: true };
+// src/methods/link.ts
+var encoder7 = new TextEncoder();
+function linkSync(syncRequest, existingPath, newPath) {
+  const buf = encodeTwoPathRequest(OP.LINK, existingPath, newPath);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "link", existingPath);
 }
-
-// Force release ALL file handles - use before HMR notifications
-function handleReleaseAllHandles() {
-  for (const h of syncHandleCache.values()) {
-    try { h.close(); } catch {}
-  }
-  syncHandleCache.clear();
-  return { success: true };
+async function link(asyncRequest, existingPath, newPath) {
+  const path2Bytes = encoder7.encode(newPath);
+  const payload = new Uint8Array(4 + path2Bytes.byteLength);
+  new DataView(payload.buffer).setUint32(0, path2Bytes.byteLength, true);
+  payload.set(path2Bytes, 4);
+  const { status } = await asyncRequest(OP.LINK, existingPath, 0, payload);
+  if (status !== 0) throw statusToError(status, "link", existingPath);
 }
 
-async function handleWrite(filePath, payload) {
-  const access = await getSyncHandle(filePath, true);
-  if (payload?.data) {
-    const offset = payload.offset ?? 0;
-    if (offset === 0) access.truncate(0);
-    access.write(payload.data, { at: offset });
-    if (payload?.flush !== false) access.flush();
-  }
-  return { success: true };
+// src/methods/mkdtemp.ts
+var decoder6 = new TextDecoder();
+function mkdtempSync(syncRequest, prefix) {
+  const buf = encodeRequest(OP.MKDTEMP, prefix);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "mkdtemp", prefix);
+  return decoder6.decode(data);
+}
+async function mkdtemp(asyncRequest, prefix) {
+  const { status, data } = await asyncRequest(OP.MKDTEMP, prefix);
+  if (status !== 0) throw statusToError(status, "mkdtemp", prefix);
+  return decoder6.decode(data);
 }
 
-async function handleAppend(filePath, payload) {
-  const access = await getSyncHandle(filePath, true);
-  if (payload?.data) {
-    const size = access.getSize();
-    access.write(payload.data, { at: size });
-    if (payload?.flush !== false) access.flush();
+// src/methods/open.ts
+var encoder8 = new TextEncoder();
+var decoder7 = new TextDecoder();
+function parseFlags(flags) {
+  switch (flags) {
+    case "r":
+      return constants.O_RDONLY;
+    case "r+":
+      return constants.O_RDWR;
+    case "w":
+      return constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC;
+    case "w+":
+      return constants.O_RDWR | constants.O_CREAT | constants.O_TRUNC;
+    case "a":
+      return constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND;
+    case "a+":
+      return constants.O_RDWR | constants.O_CREAT | constants.O_APPEND;
+    case "wx":
+      return constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_EXCL;
+    case "wx+":
+      return constants.O_RDWR | constants.O_CREAT | constants.O_TRUNC | constants.O_EXCL;
+    case "ax":
+      return constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_EXCL;
+    case "ax+":
+      return constants.O_RDWR | constants.O_CREAT | constants.O_APPEND | constants.O_EXCL;
+    default:
+      return constants.O_RDONLY;
   }
-  return { success: true };
 }
-
-async function handleTruncate(filePath, payload) {
-  const access = await getSyncHandle(filePath, false);
-  access.truncate(payload?.len ?? 0);
-  access.flush();
-  return { success: true };
+function openSync(syncRequest, filePath, flags = "r", _mode) {
+  const numFlags = typeof flags === "string" ? parseFlags(flags) : flags;
+  const buf = encodeRequest(OP.OPEN, filePath, numFlags);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "open", filePath);
+  return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true);
 }
-
-async function handleStat(filePath) {
-  const parts = parsePath(filePath);
-  // Node.js compatible stat shape: mode 33188 = file (0o100644), 16877 = dir (0o40755)
-  if (parts.length === 0) {
-    return { size: 0, mtimeMs: Date.now(), mode: 16877, type: 'directory' };
-  }
-  const name = parts.pop();
-  const parent = parts.length > 0 ? await getDirectoryHandle(parts, false) : await getRoot();
-  try {
-    const fh = await parent.getFileHandle(name);
-    // Use getFile() for metadata - faster than createSyncAccessHandle
-    const file = await fh.getFile();
-    return { size: file.size, mtimeMs: file.lastModified, mode: 33188, type: 'file' };
-  } catch {
-    try {
-      await parent.getDirectoryHandle(name);
-      return { size: 0, mtimeMs: Date.now(), mode: 16877, type: 'directory' };
-    } catch {
-      throw new Error('NotFoundError');
-    }
-  }
+function closeSync(syncRequest, fd) {
+  const fdBuf = new Uint8Array(4);
+  new DataView(fdBuf.buffer).setUint32(0, fd, true);
+  const buf = encodeRequest(OP.CLOSE, "", 0, fdBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "close", String(fd));
 }
-
-async function handleExists(filePath) {
-  try {
-    await handleStat(filePath);
-    return { exists: true };
-  } catch {
-    return { exists: false };
-  }
+function readSync(syncRequest, fd, buffer, offset = 0, length = buffer.byteLength, position = null) {
+  const fdBuf = new Uint8Array(12);
+  const dv = new DataView(fdBuf.buffer);
+  dv.setUint32(0, fd, true);
+  dv.setUint32(4, length, true);
+  dv.setInt32(8, position ?? -1, true);
+  const buf = encodeRequest(OP.FREAD, "", 0, fdBuf);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "read", String(fd));
+  if (data) {
+    buffer.set(data.subarray(0, Math.min(data.byteLength, length)), offset);
+    return data.byteLength;
+  }
+  return 0;
 }
-
-async function handleMkdir(filePath, payload) {
-  const parts = parsePath(filePath);
-  if (payload?.recursive) {
-    let curr = await getRoot();
-    for (const part of parts) {
-      curr = await curr.getDirectoryHandle(part, { create: true });
-    }
-  } else {
-    const name = parts.pop();
-    if (!name) throw new Error('Invalid path');
-    const parent = parts.length > 0 ? await getDirectoryHandle(parts, false) : await getRoot();
-    await parent.getDirectoryHandle(name, { create: true });
-  }
-  return { success: true };
+function writeSyncFd(syncRequest, fd, buffer, offset = 0, length = buffer.byteLength, position = null) {
+  const writeData = buffer.subarray(offset, offset + length);
+  const fdBuf = new Uint8Array(8 + writeData.byteLength);
+  const dv = new DataView(fdBuf.buffer);
+  dv.setUint32(0, fd, true);
+  dv.setInt32(4, position ?? -1, true);
+  fdBuf.set(writeData, 8);
+  const buf = encodeRequest(OP.FWRITE, "", 0, fdBuf);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "write", String(fd));
+  return data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
 }
-
-async function handleRmdir(filePath, payload) {
-  closeHandlesUnder(filePath); // Close all cached file handles under this directory
-  clearDirCacheUnder(filePath); // Clear stale directory cache entries
-  const { parent, name } = await getParentAndName(filePath);
-  if (payload?.recursive) {
-    await parent.removeEntry(name, { recursive: true });
-  } else {
-    const dir = await parent.getDirectoryHandle(name);
-    const entries = dir.entries();
-    const first = await entries.next();
-    if (!first.done) {
-      const e = new Error('InvalidModificationError');
-      e.name = 'InvalidModificationError';
-      throw e;
-    }
-    await parent.removeEntry(name);
-  }
-  return { success: true };
+function fstatSync(syncRequest, fd) {
+  const fdBuf = new Uint8Array(4);
+  new DataView(fdBuf.buffer).setUint32(0, fd, true);
+  const buf = encodeRequest(OP.FSTAT, "", 0, fdBuf);
+  const { status, data } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "fstat", String(fd));
+  return decodeStats(data);
 }
-
-async function handleUnlink(filePath) {
-  closeSyncHandle(filePath); // Close cached handle before deleting
-  const { parent, name } = await getParentAndName(filePath);
-  await parent.removeEntry(name);
-  return { success: true };
+function ftruncateSync(syncRequest, fd, len = 0) {
+  const fdBuf = new Uint8Array(8);
+  const dv = new DataView(fdBuf.buffer);
+  dv.setUint32(0, fd, true);
+  dv.setUint32(4, len, true);
+  const buf = encodeRequest(OP.FTRUNCATE, "", 0, fdBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "ftruncate", String(fd));
 }
-
-async function handleReaddir(filePath) {
-  const parts = parsePath(filePath);
-  const dir = parts.length > 0 ? await getDirectoryHandle(parts, false) : await getRoot();
-  const entries = [];
-  for await (const [name] of dir.entries()) {
-    entries.push(name);
-  }
-  return { entries };
+function fdatasyncSync(syncRequest, fd) {
+  const buf = encodeRequest(OP.FSYNC, "");
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "fdatasync", String(fd));
+}
+async function open(asyncRequest, filePath, flags, _mode) {
+  const numFlags = typeof flags === "string" ? parseFlags(flags ?? "r") : flags ?? 0;
+  const { status, data } = await asyncRequest(OP.OPEN, filePath, numFlags);
+  if (status !== 0) throw statusToError(status, "open", filePath);
+  const fd = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true);
+  return createFileHandle(fd, asyncRequest);
+}
+function createFileHandle(fd, asyncRequest) {
+  return {
+    fd,
+    async read(buffer, offset = 0, length = buffer.byteLength, position = null) {
+      const { status, data } = await asyncRequest(OP.FREAD, "", 0, null, void 0, { fd, length, position: position ?? -1 });
+      if (status !== 0) throw statusToError(status, "read", String(fd));
+      const bytesRead = data ? data.byteLength : 0;
+      if (data) buffer.set(data.subarray(0, Math.min(bytesRead, length)), offset);
+      return { bytesRead, buffer };
+    },
+    async write(buffer, offset = 0, length = buffer.byteLength, position = null) {
+      const writeData = buffer.subarray(offset, offset + length);
+      const { status, data } = await asyncRequest(OP.FWRITE, "", 0, null, void 0, { fd, data: writeData, position: position ?? -1 });
+      if (status !== 0) throw statusToError(status, "write", String(fd));
+      const bytesWritten = data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
+      return { bytesWritten, buffer };
+    },
+    async readFile(options) {
+      const encoding = typeof options === "string" ? options : options?.encoding;
+      const { status, data } = await asyncRequest(OP.FREAD, "", 0, null, void 0, { fd, length: Number.MAX_SAFE_INTEGER, position: 0 });
+      if (status !== 0) throw statusToError(status, "read", String(fd));
+      const result = data ?? new Uint8Array(0);
+      if (encoding) return decoder7.decode(result);
+      return result;
+    },
+    async writeFile(data, _options) {
+      const encoded = typeof data === "string" ? encoder8.encode(data) : data;
+      const { status } = await asyncRequest(OP.FWRITE, "", 0, null, void 0, { fd, data: encoded, position: 0 });
+      if (status !== 0) throw statusToError(status, "write", String(fd));
+    },
+    async truncate(len = 0) {
+      const { status } = await asyncRequest(OP.FTRUNCATE, "", 0, null, void 0, { fd, length: len });
+      if (status !== 0) throw statusToError(status, "ftruncate", String(fd));
+    },
+    async stat() {
+      const { status, data } = await asyncRequest(OP.FSTAT, "", 0, null, void 0, { fd });
+      if (status !== 0) throw statusToError(status, "fstat", String(fd));
+      return decodeStats(data);
+    },
+    async sync() {
+      await asyncRequest(OP.FSYNC, "");
+    },
+    async datasync() {
+      await asyncRequest(OP.FSYNC, "");
+    },
+    async close() {
+      const { status } = await asyncRequest(OP.CLOSE, "", 0, null, void 0, { fd });
+      if (status !== 0) throw statusToError(status, "close", String(fd));
+    }
+  };
 }
 
-async function handleRename(oldPath, payload) {
-  if (!payload?.newPath) throw new Error('newPath required');
-  const newPath = payload.newPath;
-
-  // Close cached handles for old path (file will be deleted)
-  closeSyncHandle(oldPath);
-  closeHandlesUnder(oldPath); // For directory renames
-  clearDirCacheUnder(oldPath); // Clear stale directory cache entries
-
-  const oldParts = parsePath(oldPath);
-  const newParts = parsePath(newPath);
-  const oldName = oldParts.pop();
-  const newName = newParts.pop();
-  const oldParent = oldParts.length > 0 ? await getDirectoryHandle(oldParts, false) : await getRoot();
-  const newParent = newParts.length > 0 ? await getDirectoryHandle(newParts, true) : await getRoot();
-
-  try {
-    const fh = await oldParent.getFileHandle(oldName);
-    const file = await fh.getFile();
-    const data = new Uint8Array(await file.arrayBuffer());
-
-    // Use cached handle for new file
-    const access = await getSyncHandle(newPath, true);
-    access.truncate(0);
-    access.write(data, { at: 0 });
-    access.flush();
+// src/methods/opendir.ts
+async function opendir(asyncRequest, filePath) {
+  const { status, data } = await asyncRequest(OP.OPENDIR, filePath);
+  if (status !== 0) throw statusToError(status, "opendir", filePath);
+  const fd = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true);
+  let entries = null;
+  let index = 0;
+  const loadEntries = async () => {
+    if (entries === null) {
+      entries = await readdir(asyncRequest, filePath, { withFileTypes: true });
+    }
+  };
+  return {
+    path: filePath,
+    async read() {
+      await loadEntries();
+      if (index >= entries.length) return null;
+      return entries[index++];
+    },
+    async close() {
+      const { status: status2 } = await asyncRequest(OP.CLOSE, "", 0, null, void 0, { fd });
+      if (status2 !== 0) throw statusToError(status2, "close", String(fd));
+    },
+    async *[Symbol.asyncIterator]() {
+      await loadEntries();
+      for (const entry of entries) {
+        yield entry;
+      }
+    }
+  };
+}
 
-    await oldParent.removeEntry(oldName);
-    return { success: true };
-  } catch {
-    const oldDir = await oldParent.getDirectoryHandle(oldName);
-    async function copyDir(src, dst, dstPath) {
-      for await (const [name, handle] of src.entries()) {
-        if (handle.kind === 'file') {
-          const srcFile = await handle.getFile();
-          const data = new Uint8Array(await srcFile.arrayBuffer());
-          const filePath = dstPath + '/' + name;
-          const access = await getSyncHandle(filePath, true);
-          access.truncate(0);
-          access.write(data, { at: 0 });
-          access.flush();
-        } else {
-          const newSubDir = await dst.getDirectoryHandle(name, { create: true });
-          await copyDir(handle, newSubDir, dstPath + '/' + name);
-        }
+// src/path.ts
+var path_exports = {};
+__export(path_exports, {
+  basename: () => basename,
+  delimiter: () => delimiter,
+  dirname: () => dirname,
+  extname: () => extname,
+  format: () => format,
+  isAbsolute: () => isAbsolute,
+  join: () => join,
+  normalize: () => normalize,
+  parse: () => parse,
+  relative: () => relative,
+  resolve: () => resolve,
+  sep: () => sep
+});
+var sep = "/";
+var delimiter = ":";
+function normalize(p) {
+  if (p.length === 0) return ".";
+  const isAbsolute2 = p.charCodeAt(0) === 47;
+  const segments = p.split("/");
+  const result = [];
+  for (const seg of segments) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        result.pop();
+      } else if (!isAbsolute2) {
+        result.push("..");
       }
+    } else {
+      result.push(seg);
     }
-    const newDir = await newParent.getDirectoryHandle(newName, { create: true });
-    await copyDir(oldDir, newDir, newPath);
-    await oldParent.removeEntry(oldName, { recursive: true });
-    return { success: true };
   }
+  let out = result.join("/");
+  if (isAbsolute2) out = "/" + out;
+  return out || (isAbsolute2 ? "/" : ".");
 }
-
-async function handleCopy(srcPath, payload) {
-  if (!payload?.newPath) throw new Error('newPath required');
-  const dstPath = payload.newPath;
-  const srcParts = parsePath(srcPath);
-  const srcName = srcParts.pop();
-  const srcParent = srcParts.length > 0 ? await getDirectoryHandle(srcParts, false) : await getRoot();
-  const srcFh = await srcParent.getFileHandle(srcName);
-  const srcFile = await srcFh.getFile();
-  const data = new Uint8Array(await srcFile.arrayBuffer());
-
-  // Use cached handle for destination
-  const access = await getSyncHandle(dstPath, true);
-  access.truncate(0);
-  access.write(data, { at: 0 });
-  access.flush();
-  return { success: true };
+function join(...paths) {
+  return normalize(paths.filter(Boolean).join("/"));
 }
-
-function handleFlush() {
-  // Flush all cached sync handles
-  for (const [, handle] of syncHandleCache) {
-    try { handle.flush(); } catch {}
-  }
-  return { success: true };
+function resolve(...paths) {
+  let resolved = "";
+  for (let i = paths.length - 1; i >= 0; i--) {
+    const p = paths[i];
+    if (!p) continue;
+    resolved = p + (resolved ? "/" + resolved : "");
+    if (p.charCodeAt(0) === 47) break;
+  }
+  return normalize(resolved || "/");
 }
-
-function handlePurge() {
-  if (releaseTimer) {
-    clearTimeout(releaseTimer);
-    releaseTimer = null;
-  }
-  for (const handle of syncHandleCache.values()) {
-    try { handle.flush(); handle.close(); } catch {}
-  }
-  syncHandleCache.clear();
-  dirCache.clear();
-  cachedRoot = null;
-  return { success: true };
+function dirname(p) {
+  if (p.length === 0) return ".";
+  const i = p.lastIndexOf("/");
+  if (i < 0) return ".";
+  if (i === 0) return "/";
+  return p.substring(0, i);
 }
-
-async function processMessage(msg) {
-  const { type, path, payload } = msg;
-  switch (type) {
-    case 'read': return handleRead(path, payload);
-    case 'readAsync': return handleReadAsync(path, payload);
-    case 'write': return handleWrite(path, payload);
-    case 'append': return handleAppend(path, payload);
-    case 'truncate': return handleTruncate(path, payload);
-    case 'stat': return handleStat(path);
-    case 'exists': return handleExists(path);
-    case 'mkdir': return handleMkdir(path, payload);
-    case 'rmdir': return handleRmdir(path, payload);
-    case 'unlink': return handleUnlink(path);
-    case 'readdir': return handleReaddir(path);
-    case 'rename': return handleRename(path, payload);
-    case 'copy': return handleCopy(path, payload);
-    case 'flush': return handleFlush();
-    case 'purge': return handlePurge();
-    case 'releaseHandle': return handleReleaseHandle(path);
-    case 'releaseAllHandles': return handleReleaseAllHandles();
-    case 'setDebug':
-      debugTrace = !!payload?.enabled;
-      trace('Debug tracing ' + (debugTrace ? 'ENABLED' : 'DISABLED') + ', unsafeMode: ' + unsafeModeSupported);
-      return { success: true, debugTrace, unsafeModeSupported, cacheSize: syncHandleCache.size };
-    default: throw new Error('Unknown operation: ' + type);
+function basename(p, ext) {
+  let base = p;
+  const i = p.lastIndexOf("/");
+  if (i >= 0) base = p.substring(i + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.substring(0, base.length - ext.length);
   }
+  return base;
 }
-
-function sendAtomicsResponse(result, payload) {
-  const ctrl = payload.ctrl;
-  if (result.data && payload.dataBuffer) {
-    const view = new Uint8Array(payload.dataBuffer);
-    view.set(result.data);
-    Atomics.store(ctrl, 0, result.data.length);
-  } else if (result.entries && payload.resultBuffer) {
-    const json = JSON.stringify(result);
-    const encoded = new TextEncoder().encode(json);
-    const view = new Uint8Array(payload.resultBuffer);
-    view.set(encoded);
-    Atomics.store(ctrl, 0, encoded.length);
-  } else if (result.success) {
-    Atomics.store(ctrl, 0, 1);
-  } else if (result.exists !== undefined) {
-    Atomics.store(ctrl, 0, result.exists ? 1 : 0);
-  } else if (result.isFile !== undefined) {
-    if (payload.resultBuffer) {
-      const json = JSON.stringify(result);
-      const encoded = new TextEncoder().encode(json);
-      const view = new Uint8Array(payload.resultBuffer);
-      view.set(encoded);
-      Atomics.store(ctrl, 0, encoded.length);
-    } else {
-      Atomics.store(ctrl, 0, result.size || 0);
-    }
-  }
-  Atomics.notify(ctrl, 0);
+function extname(p) {
+  const base = basename(p);
+  const i = base.lastIndexOf(".");
+  if (i <= 0) return "";
+  return base.substring(i);
 }
-
-// Handle incoming messages
-async function handleMessage(msg) {
-  const { id, payload } = msg;
-  try {
-    const result = await processMessage(msg);
-    if (payload?.ctrl) {
-      sendAtomicsResponse(result, payload);
-    } else {
-      // Use Transferable for data to avoid copying
-      if (result.data) {
-        const buffer = result.data.buffer;
-        self.postMessage({ id, result }, [buffer]);
-      } else {
-        self.postMessage({ id, result });
-      }
-    }
-  } catch (e) {
-    const error = e instanceof Error ? e : new Error(String(e));
-    // Use error name if it's a specific DOM exception, otherwise use message
-    // (handleStat throws new Error('NotFoundError') where message contains the type)
-    const errorName = error.name || 'Error';
-    const errorCode = errorName !== 'Error' ? errorName : (error.message || 'Error');
-    if (payload?.ctrl) {
-      Atomics.store(payload.ctrl, 0, -1);
-      Atomics.notify(payload.ctrl, 0);
-    } else {
-      self.postMessage({ id, error: errorCode, code: errorCode });
-    }
-  } finally {
-    // Schedule handle release (debounced - waits 100ms after last operation)
-    scheduleHandleRelease();
-  }
+function isAbsolute(p) {
+  return p.length > 0 && p.charCodeAt(0) === 47;
 }
-
-// Process queued messages after ready
-function processQueue() {
-  while (messageQueue.length > 0) {
-    const msg = messageQueue.shift();
-    handleMessage(msg); // Process concurrently - don't wait
-  }
+function relative(from, to) {
+  const fromParts = resolve(from).split("/").filter(Boolean);
+  const toParts = resolve(to).split("/").filter(Boolean);
+  let common = 0;
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++;
+  }
+  const ups = fromParts.length - common;
+  const result = [...Array(ups).fill(".."), ...toParts.slice(common)];
+  return result.join("/") || ".";
 }
-
-// Handle messages concurrently - each operation proceeds independently
-// This is better than a queue with concurrency limit because:
-// 1. If one operation hangs, others can still complete
-// 2. Small files don't get blocked behind large files
-// 3. The Web Locks API already handles per-file serialization
-self.onmessage = (event) => {
-  messageQueue.push(event.data);
-  if (isReady) {
-    processQueue();
-  }
-};
-
-// Signal ready after a timeout to ensure main thread handler is set
-setTimeout(() => {
-  isReady = true;
-  processQueue();
-  self.postMessage({ type: 'ready' });
-}, 10);
-`;
-function createStats(result) {
-  const isFile = result.type ? result.type === "file" : result.isFile ?? false;
-  const isDir = result.type ? result.type === "directory" : result.isDirectory ?? false;
-  const mtimeMs = result.mtimeMs ?? result.mtime ?? Date.now();
-  const size = result.size ?? 0;
-  const mode = result.mode ?? (isDir ? 16877 : 33188);
-  return {
-    isFile: () => isFile,
-    isDirectory: () => isDir,
-    isBlockDevice: () => false,
-    isCharacterDevice: () => false,
-    isSymbolicLink: () => false,
-    isFIFO: () => false,
-    isSocket: () => false,
-    dev: 0,
-    ino: 0,
-    mode,
-    nlink: 1,
-    uid: 0,
-    gid: 0,
-    rdev: 0,
-    size,
-    blksize: 4096,
-    blocks: Math.ceil(size / 512),
-    atimeMs: mtimeMs,
-    mtimeMs,
-    ctimeMs: mtimeMs,
-    birthtimeMs: mtimeMs,
-    atime: new Date(mtimeMs),
-    mtime: new Date(mtimeMs),
-    ctime: new Date(mtimeMs),
-    birthtime: new Date(mtimeMs)
-  };
+function parse(p) {
+  const dir = dirname(p);
+  const base = basename(p);
+  const ext = extname(p);
+  const name = ext ? base.substring(0, base.length - ext.length) : base;
+  const root = isAbsolute(p) ? "/" : "";
+  return { root, dir, base, ext, name };
 }
-function createDirent(name, isDir) {
-  return {
-    name,
-    isFile: () => !isDir,
-    isDirectory: () => isDir,
-    isBlockDevice: () => false,
-    isCharacterDevice: () => false,
-    isSymbolicLink: () => false,
-    isFIFO: () => false,
-    isSocket: () => false
+function format(obj) {
+  const dir = obj.dir || obj.root || "";
+  const base = obj.base || (obj.name || "") + (obj.ext || "");
+  return dir ? dir === "/" ? "/" + base : dir + "/" + base : base;
+}
+
+// src/methods/watch.ts
+function watch(_filePath, _options, _listener) {
+  const interval = setInterval(() => {
+  }, 1e3);
+  const watcher = {
+    close: () => clearInterval(interval),
+    ref: () => watcher,
+    unref: () => watcher
   };
+  return watcher;
 }
-function generateId() {
-  return Math.random().toString(36).substring(2, 15);
-}
-function encodeData(data, _encoding) {
-  if (typeof data === "string") {
-    return new TextEncoder().encode(data);
-  }
-  if (data instanceof Uint8Array) {
-    return data;
-  }
-  if (data instanceof ArrayBuffer) {
-    return new Uint8Array(data);
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  return new TextEncoder().encode(String(data ?? ""));
-}
-function decodeData(data, encoding) {
-  if (encoding === "utf8" || encoding === "utf-8") {
-    return new TextDecoder().decode(data);
-  }
-  return data;
-}
-var OPFSFileSystem = class _OPFSFileSystem {
-  worker = null;
-  pending = /* @__PURE__ */ new Map();
-  initialized = false;
-  initPromise = null;
-  // File descriptor table for openSync/readSync/writeSync/closeSync
-  fdTable = /* @__PURE__ */ new Map();
-  nextFd = 3;
-  // Start at 3 (0=stdin, 1=stdout, 2=stderr)
-  // Stat cache - reduces FS traffic by 30-50% for git operations
-  statCache = /* @__PURE__ */ new Map();
-  constructor() {
-    this.initWorker();
-  }
-  // Invalidate stat cache for a path (and parent for directory operations)
-  invalidateStat(filePath) {
-    const absPath = normalize(resolve(filePath));
-    this.statCache.delete(absPath);
-    const parent = dirname(absPath);
-    if (parent !== absPath) {
-      this.statCache.delete(parent);
+async function* watchAsync(asyncRequest, filePath, options) {
+  let lastMtime = 0;
+  const signal = options?.signal;
+  while (!signal?.aborted) {
+    try {
+      const s = await stat(asyncRequest, filePath);
+      if (s.mtimeMs !== lastMtime) {
+        if (lastMtime !== 0) {
+          yield { eventType: "change", filename: basename(filePath) };
+        }
+        lastMtime = s.mtimeMs;
+      }
+    } catch {
+      yield { eventType: "rename", filename: basename(filePath) };
+      return;
     }
+    await new Promise((r) => setTimeout(r, 100));
   }
-  // Invalidate all stats under a directory (for recursive operations)
-  invalidateStatsUnder(dirPath) {
-    const prefix = normalize(resolve(dirPath));
-    for (const key of this.statCache.keys()) {
-      if (key === prefix || key.startsWith(prefix + "/")) {
-        this.statCache.delete(key);
-      }
+}
+
+// src/filesystem.ts
+var encoder9 = new TextEncoder();
+var DEFAULT_SAB_SIZE = 2 * 1024 * 1024;
+var HEADER_SIZE = SAB_OFFSETS.HEADER_SIZE;
+var _canAtomicsWait = typeof globalThis.WorkerGlobalScope !== "undefined";
+function spinWait(arr, index, value) {
+  if (_canAtomicsWait) {
+    Atomics.wait(arr, index, value);
+  } else {
+    while (Atomics.load(arr, index) === value) {
     }
   }
-  async initWorker() {
-    if (this.initialized) return;
-    if (this.initPromise) return this.initPromise;
-    this.initPromise = (async () => {
-      const blob = new Blob([KERNEL_SOURCE], { type: "application/javascript" });
-      this.worker = new Worker(URL.createObjectURL(blob));
-      const readyPromise = new Promise((resolve2) => {
-        this.worker.onmessage = (event) => {
-          const { id, result, error, code, type: msgType } = event.data;
-          if (msgType === "ready") {
-            resolve2();
-            return;
-          }
-          const pending = this.pending.get(id);
-          if (pending) {
-            this.pending.delete(id);
-            if (error) {
-              const errCode = code || "Error";
-              if (errCode === "NotFoundError" || errCode === "NotAllowedError" || errCode === "TypeMismatchError" || errCode === "InvalidModificationError" || errCode === "QuotaExceededError") {
-                pending.reject(mapErrorCode(errCode, pending.type, pending.path));
-              } else {
-                pending.reject(new FSError(errCode, -1, `${error}: ${pending.type} '${pending.path}'`));
-              }
-            } else if (result) {
-              pending.resolve(result);
-            }
-          }
-        };
+}
+var VFSFileSystem = class {
+  // SAB for sync communication with sync relay worker (null when SAB unavailable)
+  sab;
+  ctrl;
+  readySab;
+  readySignal;
+  // SAB for async-relay ↔ sync-relay communication
+  asyncSab;
+  // Whether SharedArrayBuffer is available (crossOriginIsolated)
+  hasSAB = typeof SharedArrayBuffer !== "undefined";
+  // Workers
+  syncWorker;
+  asyncWorker;
+  // Async request tracking
+  asyncCallId = 0;
+  asyncPending = /* @__PURE__ */ new Map();
+  // Ready promise for async callers
+  readyPromise;
+  resolveReady;
+  isReady = false;
+  // Config
+  config;
+  tabId;
+  // Service worker registration for multi-tab port transfer
+  swReg = null;
+  isFollower = false;
+  holdingLeaderLock = false;
+  brokerInitialized = false;
+  leaderChangeBc = null;
+  // Bound request functions for method delegation
+  _sync = (buf) => this.syncRequest(buf);
+  _async = (op, p, flags, data, path2, fdArgs) => this.asyncRequest(op, p, flags, data, path2, fdArgs);
+  // Promises API namespace
+  promises;
+  constructor(config = {}) {
+    this.config = {
+      root: config.root ?? "/",
+      opfsSync: config.opfsSync ?? true,
+      opfsSyncRoot: config.opfsSyncRoot,
+      uid: config.uid ?? 0,
+      gid: config.gid ?? 0,
+      umask: config.umask ?? 18,
+      strictPermissions: config.strictPermissions ?? false,
+      sabSize: config.sabSize ?? DEFAULT_SAB_SIZE,
+      debug: config.debug ?? false
+    };
+    this.tabId = crypto.randomUUID();
+    this.readyPromise = new Promise((resolve2) => {
+      this.resolveReady = resolve2;
+    });
+    this.promises = new VFSPromises(this._async);
+    this.bootstrap();
+  }
+  /** Spawn workers and establish communication */
+  bootstrap() {
+    const sabSize = this.config.sabSize;
+    if (this.hasSAB) {
+      this.sab = new SharedArrayBuffer(sabSize);
+      this.readySab = new SharedArrayBuffer(4);
+      this.asyncSab = new SharedArrayBuffer(sabSize);
+      this.ctrl = new Int32Array(this.sab, 0, 8);
+      this.readySignal = new Int32Array(this.readySab, 0, 1);
+    }
+    this.syncWorker = this.spawnWorker("sync-relay");
+    this.asyncWorker = this.spawnWorker("async-relay");
+    this.syncWorker.onmessage = (e) => {
+      const msg = e.data;
+      if (msg.type === "ready") {
+        this.isReady = true;
+        this.resolveReady();
+        if (!this.isFollower) {
+          this.initLeaderBroker();
+        }
+      } else if (msg.type === "init-failed") {
+        if (this.holdingLeaderLock) {
+          setTimeout(() => this.sendLeaderInit(), 500);
+        } else if (!("locks" in navigator)) {
+          this.startAsFollower();
+        }
+      }
+    };
+    this.asyncWorker.onmessage = (e) => {
+      const msg = e.data;
+      if (msg.type === "response") {
+        const pending = this.asyncPending.get(msg.callId);
+        if (pending) {
+          this.asyncPending.delete(msg.callId);
+          pending.resolve({ status: msg.status, data: msg.data });
+        }
+      }
+    };
+    if (this.hasSAB) {
+      this.asyncWorker.postMessage({
+        type: "init-leader",
+        asyncSab: this.asyncSab,
+        wakeSab: this.sab
       });
-      await readyPromise;
-      this.initialized = true;
-    })();
-    return this.initPromise;
-  }
-  // Async call to worker - uses fast createSyncAccessHandle internally
-  async asyncCall(type, filePath, payload) {
-    await this.initWorker();
-    if (!this.worker) {
-      throw new Error("Worker not initialized");
-    }
-    const absPath = resolve(filePath);
-    const id = generateId();
-    return new Promise((resolve2, reject) => {
-      this.pending.set(id, { resolve: resolve2, reject, path: absPath, type });
-      const msg = {
-        id,
-        type,
-        path: absPath,
-        payload
-      };
-      if (payload?.data instanceof Uint8Array) {
-        const clone = new Uint8Array(payload.data);
-        const newPayload = { ...payload, data: clone };
-        this.worker.postMessage({ ...msg, payload: newPayload }, [clone.buffer]);
+    } else {
+      const mc = new MessageChannel();
+      this.asyncWorker.postMessage(
+        { type: "init-port", port: mc.port1 },
+        [mc.port1]
+      );
+      this.syncWorker.postMessage(
+        { type: "async-port", port: mc.port2 },
+        [mc.port2]
+      );
+    }
+    this.acquireLeaderLock();
+  }
+  /** Use Web Locks API for leader election. The tab that acquires the lock is
+   *  the leader; all others become followers. When the leader dies, the browser
+   *  releases the lock and the next waiting tab is promoted. */
+  acquireLeaderLock() {
+    if (!("locks" in navigator)) {
+      this.startAsLeader();
+      return;
+    }
+    let decided = false;
+    navigator.locks.request("vfs-leader", { ifAvailable: true }, async (lock) => {
+      if (decided) return;
+      decided = true;
+      if (lock) {
+        this.holdingLeaderLock = true;
+        this.startAsLeader();
+        await new Promise(() => {
+        });
       } else {
-        this.worker.postMessage(msg);
+        this.startAsFollower();
+        this.waitForLeaderLock();
       }
     });
   }
-  // Kernel worker for Tier 1 sync operations (loaded from URL, not blob)
-  syncKernel = null;
-  syncKernelReady = false;
-  /**
-   * Initialize sync operations with a kernel worker loaded from URL.
-   * Required for Tier 1 (SharedArrayBuffer + Atomics) to work in nested Workers.
-   * @param kernelUrl URL to the kernel.js file (defaults to '/kernel.js')
-   */
-  async initSync(kernelUrl = "/kernel.js") {
-    if (this.syncKernelReady) return;
-    this.syncKernel = new Worker(kernelUrl, { type: "module" });
-    await new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => reject(new Error("Kernel init timeout")), 1e4);
-      this.syncKernel.onmessage = (e) => {
-        if (e.data?.type === "ready") {
-          clearTimeout(timeout);
-          this.syncKernelReady = true;
-          resolve2();
-        }
-      };
-      this.syncKernel.onerror = (e) => {
-        clearTimeout(timeout);
-        reject(new Error(`Kernel error: ${e.message}`));
-      };
+  /** Queue for leader takeover when the current leader's lock is released */
+  waitForLeaderLock() {
+    if (!("locks" in navigator)) return;
+    navigator.locks.request("vfs-leader", async () => {
+      console.log("[VFS] Leader lock acquired \u2014 promoting to leader");
+      this.holdingLeaderLock = true;
+      this.promoteToLeader();
+      await new Promise(() => {
+      });
     });
   }
-  // Tier 1: SharedArrayBuffer + Atomics via kernel worker
-  // Data is transferred via SharedArrayBuffer (zero-copy)
-  // Synchronization via Atomics.wait/notify
-  // Buffer sizes for Tier 1 communication
-  static META_SIZE = 1024 * 64;
-  // 64KB for metadata/results
-  static DEFAULT_DATA_SIZE = 1024 * 1024 * 10;
-  // 10MB default buffer
-  static MAX_CHUNK_SIZE = 1024 * 1024 * 10;
-  // 10MB max per chunk
-  // Reusable SharedArrayBuffer pool to prevent memory leaks
-  // SharedArrayBuffers are expensive to allocate and don't get GC'd quickly
-  syncBufferPool = null;
-  getSyncBuffers(requiredDataSize) {
-    if (this.syncBufferPool && this.syncBufferPool.dataSize >= requiredDataSize) {
-      return {
-        ctrlBuffer: this.syncBufferPool.ctrl,
-        ctrl: new Int32Array(this.syncBufferPool.ctrl),
-        metaBuffer: this.syncBufferPool.meta,
-        dataBuffer: this.syncBufferPool.data
-      };
-    }
-    const dataSize = Math.max(
-      _OPFSFileSystem.DEFAULT_DATA_SIZE,
-      Math.min(requiredDataSize + 1024, 1024 * 1024 * 64)
-      // Up to 64MB
-    );
-    const ctrlBuffer = new SharedArrayBuffer(4);
-    const metaBuffer = new SharedArrayBuffer(_OPFSFileSystem.META_SIZE);
-    const dataBuffer = new SharedArrayBuffer(dataSize);
-    this.syncBufferPool = {
-      ctrl: ctrlBuffer,
-      meta: metaBuffer,
-      data: dataBuffer,
-      dataSize
-    };
-    return {
-      ctrlBuffer,
-      ctrl: new Int32Array(ctrlBuffer),
-      metaBuffer,
-      dataBuffer
+  /** Send init-leader message to sync-relay worker */
+  sendLeaderInit() {
+    this.syncWorker.postMessage({
+      type: "init-leader",
+      sab: this.hasSAB ? this.sab : null,
+      readySab: this.hasSAB ? this.readySab : null,
+      asyncSab: this.hasSAB ? this.asyncSab : null,
+      tabId: this.tabId,
+      config: {
+        root: this.config.root,
+        opfsSync: this.config.opfsSync,
+        opfsSyncRoot: this.config.opfsSyncRoot,
+        uid: this.config.uid,
+        gid: this.config.gid,
+        umask: this.config.umask,
+        strictPermissions: this.config.strictPermissions,
+        debug: this.config.debug
+      }
+    });
+  }
+  /** Start as leader — tell sync-relay to init VFS engine + OPFS handle */
+  startAsLeader() {
+    this.isFollower = false;
+    this.sendLeaderInit();
+  }
+  /** Start as follower — connect to leader via service worker port brokering */
+  startAsFollower() {
+    this.isFollower = true;
+    this.syncWorker.postMessage({
+      type: "init-follower",
+      sab: this.hasSAB ? this.sab : null,
+      readySab: this.hasSAB ? this.readySab : null,
+      asyncSab: this.hasSAB ? this.asyncSab : null,
+      tabId: this.tabId
+    });
+    this.connectToLeader();
+    this.leaderChangeBc = new BroadcastChannel("vfs-leader-change");
+    this.leaderChangeBc.onmessage = () => {
+      if (this.isFollower) {
+        console.log("[VFS] Leader changed \u2014 reconnecting");
+        this.connectToLeader();
+      }
     };
   }
-  syncCallTier1(type, filePath, payload) {
-    if (!this.syncKernel || !this.syncKernelReady) {
-      throw new Error("Sync kernel not initialized. Call initSync() first.");
-    }
-    const absPath = normalize(resolve(filePath));
-    const data = payload?.data instanceof Uint8Array ? payload.data : null;
-    const dataSize = data?.length ?? 0;
-    if (type === "write" && data && dataSize > _OPFSFileSystem.MAX_CHUNK_SIZE) {
-      return this.syncCallTier1Chunked(absPath, data);
-    }
-    const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(dataSize);
-    Atomics.store(ctrl, 0, 0);
-    let dataLength = 0;
-    if (data) {
-      const view = new Uint8Array(dataBuffer);
-      view.set(data);
-      dataLength = data.length;
-    }
-    this.syncKernel.postMessage({
-      type,
-      path: absPath,
-      ctrlBuffer,
-      metaBuffer,
-      dataBuffer,
-      dataLength,
-      payload: payload ? { ...payload, data: void 0 } : void 0
+  /** Send a new port to sync-relay for connecting to the current leader */
+  connectToLeader() {
+    const mc = new MessageChannel();
+    this.syncWorker.postMessage(
+      { type: "leader-port", port: mc.port1 },
+      [mc.port1]
+    );
+    this.getServiceWorker().then((sw) => {
+      sw.postMessage({ type: "transfer-port", tabId: this.tabId }, [mc.port2]);
+    }).catch((err) => {
+      console.error("[VFS] Failed to connect to leader:", err.message);
+      mc.port2.close();
     });
-    const waitResult = Atomics.wait(ctrl, 0, 0, 3e4);
-    if (waitResult === "timed-out") {
-      throw new Error("Operation timed out");
-    }
-    const status = Atomics.load(ctrl, 0);
-    if (status === -1) {
-      const metaView = new Uint8Array(metaBuffer);
-      let end = metaView.indexOf(0);
-      if (end === -1) end = _OPFSFileSystem.META_SIZE;
-      const errorMsg = new TextDecoder().decode(metaView.slice(0, end));
-      throw mapErrorCode(errorMsg || "Error", type, absPath);
-    }
-    if (status === -2) {
-      throw createENOENT(type, absPath);
+  }
+  /** Register the VFS service worker and return the active SW */
+  async getServiceWorker() {
+    if (!this.swReg) {
+      const swUrl = new URL("./workers/service.worker.js", import.meta.url);
+      this.swReg = await navigator.serviceWorker.register(swUrl.href, { type: "module" });
     }
-    if (type === "read") {
-      const bytesRead = status;
-      const bufferSize = dataBuffer.byteLength;
-      if (bytesRead === bufferSize) {
-        const stat = this.syncStatTier1(absPath);
-        if (stat && stat.size > bytesRead) {
-          return this.syncCallTier1ChunkedRead(absPath, stat.size);
+    const reg = this.swReg;
+    if (reg.active) return reg.active;
+    const sw = reg.installing || reg.waiting;
+    if (!sw) throw new Error("No service worker found");
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        sw.removeEventListener("statechange", onState);
+        reject(new Error("Service worker activation timeout"));
+      }, 5e3);
+      const onState = () => {
+        if (sw.state === "activated") {
+          clearTimeout(timer);
+          sw.removeEventListener("statechange", onState);
+          resolve2(sw);
+        } else if (sw.state === "redundant") {
+          clearTimeout(timer);
+          sw.removeEventListener("statechange", onState);
+          reject(new Error("SW redundant"));
         }
-      }
-      const dataView = new Uint8Array(dataBuffer);
-      return { data: dataView.slice(0, bytesRead) };
-    }
-    if (type === "stat") {
-      const view = new DataView(metaBuffer);
-      const typeVal = view.getUint8(0);
-      return {
-        type: typeVal === 0 ? "file" : "directory",
-        mode: view.getUint32(4, true),
-        size: view.getFloat64(8, true),
-        mtimeMs: view.getFloat64(16, true)
       };
-    }
-    if (type === "readdir") {
-      const view = new DataView(metaBuffer);
-      const bytes = new Uint8Array(metaBuffer);
-      const count = view.getUint32(0, true);
-      const entries = [];
-      let offset = 4;
-      for (let i = 0; i < count; i++) {
-        const len = view.getUint16(offset, true);
-        offset += 2;
-        const name = new TextDecoder().decode(bytes.slice(offset, offset + len));
-        entries.push(name);
-        offset += len;
-      }
-      return { entries };
-    }
-    if (type === "exists") {
-      return { exists: status === 1 };
-    }
-    return { success: status === 1 };
-  }
-  // Mutex for async operations to prevent buffer reuse race conditions
-  // Multiple concurrent Atomics.waitAsync calls would share the same buffer pool,
-  // causing data corruption when operations complete out of order
-  asyncOperationPromise = Promise.resolve();
-  // Async version of syncCallTier1 using Atomics.waitAsync (works on main thread)
-  // This allows the main thread to use the fast SharedArrayBuffer path without blocking
-  // IMPORTANT: Operations are serialized to prevent buffer reuse race conditions
-  async syncCallTier1Async(type, filePath, payload) {
-    const previousOp = this.asyncOperationPromise;
-    let resolveCurrentOp;
-    this.asyncOperationPromise = new Promise((resolve2) => {
-      resolveCurrentOp = resolve2;
+      sw.addEventListener("statechange", onState);
+      onState();
     });
-    try {
-      await previousOp;
-      return await this.syncCallTier1AsyncImpl(type, filePath, payload);
-    } finally {
-      resolveCurrentOp();
-    }
   }
-  // Implementation of async Tier 1 call (called after serialization)
-  async syncCallTier1AsyncImpl(type, filePath, payload) {
-    if (!this.syncKernel || !this.syncKernelReady) {
-      throw new Error("Sync kernel not initialized. Call initSync() first.");
-    }
-    const absPath = normalize(resolve(filePath));
-    const data = payload?.data instanceof Uint8Array ? payload.data : null;
-    const dataSize = data?.length ?? 0;
-    if (type === "write" && data && dataSize > _OPFSFileSystem.MAX_CHUNK_SIZE) {
-      return this.syncCallTier1ChunkedAsync(absPath, data);
-    }
-    const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(dataSize);
-    Atomics.store(ctrl, 0, 0);
-    let dataLength = 0;
-    if (data) {
-      const view = new Uint8Array(dataBuffer);
-      view.set(data);
-      dataLength = data.length;
-    }
-    this.syncKernel.postMessage({
-      type,
-      path: absPath,
-      ctrlBuffer,
-      metaBuffer,
-      dataBuffer,
-      dataLength,
-      payload: payload ? { ...payload, data: void 0 } : void 0
-    });
-    const waitResult = await Atomics.waitAsync(ctrl, 0, 0, 3e4).value;
-    if (waitResult === "timed-out") {
-      throw new Error("Operation timed out");
-    }
-    const status = Atomics.load(ctrl, 0);
-    if (status === -1) {
-      const metaView = new Uint8Array(metaBuffer);
-      let end = metaView.indexOf(0);
-      if (end === -1) end = _OPFSFileSystem.META_SIZE;
-      const errorMsg = new TextDecoder().decode(metaView.slice(0, end));
-      throw mapErrorCode(errorMsg || "Error", type, absPath);
-    }
-    if (status === -2) {
-      throw createENOENT(type, absPath);
-    }
-    if (type === "read") {
-      const bytesRead = status;
-      const bufferSize = dataBuffer.byteLength;
-      if (bytesRead === bufferSize) {
-        const stat = await this.syncStatTier1Async(absPath);
-        if (stat && stat.size > bytesRead) {
-          return this.syncCallTier1ChunkedReadAsync(absPath, stat.size);
+  /** Register as leader with SW broker (receives follower ports via control channel) */
+  initLeaderBroker() {
+    if (this.brokerInitialized) return;
+    this.brokerInitialized = true;
+    this.getServiceWorker().then((sw) => {
+      const mc = new MessageChannel();
+      sw.postMessage({ type: "register-server" }, [mc.port2]);
+      mc.port1.onmessage = (event) => {
+        if (event.data.type === "client-port") {
+          const clientPort = event.ports[0];
+          if (clientPort) {
+            this.syncWorker.postMessage(
+              { type: "client-port", tabId: event.data.tabId, port: clientPort },
+              [clientPort]
+            );
+          }
         }
-      }
-      const dataView = new Uint8Array(dataBuffer);
-      return { data: dataView.slice(0, bytesRead) };
-    }
-    if (type === "stat") {
-      const view = new DataView(metaBuffer);
-      const typeVal = view.getUint8(0);
-      return {
-        type: typeVal === 0 ? "file" : "directory",
-        mode: view.getUint32(4, true),
-        size: view.getFloat64(8, true),
-        mtimeMs: view.getFloat64(16, true)
       };
-    }
-    if (type === "readdir") {
-      const view = new DataView(metaBuffer);
-      const bytes = new Uint8Array(metaBuffer);
-      const count = view.getUint32(0, true);
-      const entries = [];
-      let offset = 4;
-      for (let i = 0; i < count; i++) {
-        const len = view.getUint16(offset, true);
-        offset += 2;
-        const name = new TextDecoder().decode(bytes.slice(offset, offset + len));
-        entries.push(name);
-        offset += len;
-      }
-      return { entries };
-    }
-    if (type === "exists") {
-      return { exists: status === 1 };
-    }
-    return { success: status === 1 };
-  }
-  // Async stat helper for main thread
-  // NOTE: Called from within syncCallTier1AsyncImpl, so uses impl directly to avoid deadlock
-  async syncStatTier1Async(absPath) {
-    try {
-      const result = await this.syncCallTier1AsyncImpl("stat", absPath);
-      return { size: result.size };
-    } catch {
-      return null;
-    }
+      mc.port1.start();
+      const bc = new BroadcastChannel("vfs-leader-change");
+      bc.postMessage({ type: "leader-changed" });
+      bc.close();
+    }).catch((err) => {
+      console.warn("[VFS] SW broker unavailable, single-tab only:", err.message);
+    });
   }
-  // Async chunked write for main thread
-  async syncCallTier1ChunkedAsync(absPath, data) {
-    const totalSize = data.length;
-    let offset = 0;
-    while (offset < totalSize) {
-      const remaining = totalSize - offset;
-      const currentChunkSize = Math.min(remaining, _OPFSFileSystem.MAX_CHUNK_SIZE);
-      const chunk = data.subarray(offset, offset + currentChunkSize);
-      const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(currentChunkSize);
-      Atomics.store(ctrl, 0, 0);
-      const view = new Uint8Array(dataBuffer);
-      view.set(chunk);
-      const isFirstChunk = offset === 0;
-      this.syncKernel.postMessage({
-        type: isFirstChunk ? "write" : "append",
-        path: absPath,
-        ctrlBuffer,
-        metaBuffer,
-        dataBuffer,
-        dataLength: currentChunkSize,
-        payload: { flush: false }
-      });
-      const waitResult = await Atomics.waitAsync(ctrl, 0, 0, 3e4).value;
-      if (waitResult === "timed-out") {
-        throw new Error("Chunked write timed out");
+  /** Promote from follower to leader (after leader tab dies and lock is acquired) */
+  promoteToLeader() {
+    this.isFollower = false;
+    this.isReady = false;
+    this.brokerInitialized = false;
+    if (this.leaderChangeBc) {
+      this.leaderChangeBc.close();
+      this.leaderChangeBc = null;
+    }
+    this.readyPromise = new Promise((resolve2) => {
+      this.resolveReady = resolve2;
+    });
+    this.syncWorker.terminate();
+    this.asyncWorker.terminate();
+    const sabSize = this.config.sabSize;
+    if (this.hasSAB) {
+      this.sab = new SharedArrayBuffer(sabSize);
+      this.readySab = new SharedArrayBuffer(4);
+      this.asyncSab = new SharedArrayBuffer(sabSize);
+      this.ctrl = new Int32Array(this.sab, 0, 8);
+      this.readySignal = new Int32Array(this.readySab, 0, 1);
+    }
+    this.syncWorker = this.spawnWorker("sync-relay");
+    this.asyncWorker = this.spawnWorker("async-relay");
+    this.syncWorker.onmessage = (e) => {
+      const msg = e.data;
+      if (msg.type === "ready") {
+        this.isReady = true;
+        this.resolveReady();
+        this.initLeaderBroker();
+      } else if (msg.type === "init-failed") {
+        console.warn("[VFS] Promotion: OPFS handle still busy, retrying...");
+        setTimeout(() => this.sendLeaderInit(), 500);
       }
-      const status = Atomics.load(ctrl, 0);
-      if (status === -1 || status === -2) {
-        throw createENOENT("write", absPath);
+    };
+    this.asyncWorker.onmessage = (e) => {
+      const msg = e.data;
+      if (msg.type === "response") {
+        const pending = this.asyncPending.get(msg.callId);
+        if (pending) {
+          this.asyncPending.delete(msg.callId);
+          pending.resolve({ status: msg.status, data: msg.data });
+        }
       }
-      offset += currentChunkSize;
-    }
-    return { success: true };
-  }
-  // Async chunked read for main thread
-  async syncCallTier1ChunkedReadAsync(absPath, totalSize) {
-    const result = new Uint8Array(totalSize);
-    let offset = 0;
-    while (offset < totalSize) {
-      const remaining = totalSize - offset;
-      const currentChunkSize = Math.min(remaining, _OPFSFileSystem.MAX_CHUNK_SIZE);
-      const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(currentChunkSize);
-      Atomics.store(ctrl, 0, 0);
-      this.syncKernel.postMessage({
-        type: "readChunk",
-        path: absPath,
-        ctrlBuffer,
-        metaBuffer,
-        dataBuffer,
-        dataLength: 0,
-        payload: { offset, length: currentChunkSize }
+    };
+    if (this.hasSAB) {
+      this.asyncWorker.postMessage({
+        type: "init-leader",
+        asyncSab: this.asyncSab,
+        wakeSab: this.sab
       });
-      const waitResult = await Atomics.waitAsync(ctrl, 0, 0, 3e4).value;
-      if (waitResult === "timed-out") {
-        throw new Error("Chunked read timed out");
-      }
-      const status = Atomics.load(ctrl, 0);
-      if (status === -1 || status === -2) {
-        throw createENOENT("read", absPath);
+    } else {
+      const mc = new MessageChannel();
+      this.asyncWorker.postMessage(
+        { type: "init-port", port: mc.port1 },
+        [mc.port1]
+      );
+      this.syncWorker.postMessage(
+        { type: "async-port", port: mc.port2 },
+        [mc.port2]
+      );
+    }
+    this.sendLeaderInit();
+  }
+  /** Spawn an inline worker from bundled code */
+  spawnWorker(name) {
+    const workerUrl = new URL(`./workers/${name}.worker.js`, import.meta.url);
+    return new Worker(workerUrl, { type: "module" });
+  }
+  // ========== Sync operation primitives ==========
+  /** Block until workers are ready */
+  ensureReady() {
+    if (this.isReady) return;
+    if (!this.hasSAB) {
+      throw new Error("Sync API requires crossOriginIsolated (COOP/COEP headers). Use the promises API instead.");
+    }
+    if (Atomics.load(this.readySignal, 0) === 1) {
+      this.isReady = true;
+      return;
+    }
+    spinWait(this.readySignal, 0, 0);
+    this.isReady = true;
+  }
+  /** Send a sync request via SAB and wait for response */
+  syncRequest(requestBuf) {
+    this.ensureReady();
+    const t0 = this.config.debug ? performance.now() : 0;
+    const maxChunk = this.sab.byteLength - HEADER_SIZE;
+    const requestBytes = new Uint8Array(requestBuf);
+    const totalLenView = new BigUint64Array(this.sab, SAB_OFFSETS.TOTAL_LEN, 1);
+    if (requestBytes.byteLength <= maxChunk) {
+      new Uint8Array(this.sab, HEADER_SIZE, requestBytes.byteLength).set(requestBytes);
+      Atomics.store(this.ctrl, 3, requestBytes.byteLength);
+      Atomics.store(totalLenView, 0, BigInt(requestBytes.byteLength));
+      Atomics.store(this.ctrl, 0, SIGNAL.REQUEST);
+      Atomics.notify(this.ctrl, 0);
+    } else {
+      let sent = 0;
+      while (sent < requestBytes.byteLength) {
+        const chunkSize = Math.min(maxChunk, requestBytes.byteLength - sent);
+        new Uint8Array(this.sab, HEADER_SIZE, chunkSize).set(
+          requestBytes.subarray(sent, sent + chunkSize)
+        );
+        Atomics.store(this.ctrl, 3, chunkSize);
+        Atomics.store(totalLenView, 0, BigInt(requestBytes.byteLength));
+        Atomics.store(this.ctrl, 6, Math.floor(sent / maxChunk));
+        if (sent === 0) {
+          Atomics.store(this.ctrl, 0, SIGNAL.REQUEST);
+        } else {
+          Atomics.store(this.ctrl, 0, SIGNAL.CHUNK);
+        }
+        Atomics.notify(this.ctrl, 0);
+        sent += chunkSize;
+        if (sent < requestBytes.byteLength) {
+          spinWait(this.ctrl, 0, sent === chunkSize ? SIGNAL.REQUEST : SIGNAL.CHUNK);
+        }
       }
-      const bytesRead = status;
-      const dataView = new Uint8Array(dataBuffer);
-      result.set(dataView.subarray(0, bytesRead), offset);
-      offset += bytesRead;
     }
-    return { data: result };
-  }
-  // Chunked write for files larger than MAX_CHUNK_SIZE
-  syncCallTier1Chunked(absPath, data) {
-    const totalSize = data.length;
-    const chunkSize = _OPFSFileSystem.MAX_CHUNK_SIZE;
-    const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(chunkSize);
-    const dataView = new Uint8Array(dataBuffer);
-    let offset = 0;
-    while (offset < totalSize) {
-      const remaining = totalSize - offset;
-      const currentChunkSize = Math.min(chunkSize, remaining);
-      const chunk = data.subarray(offset, offset + currentChunkSize);
-      Atomics.store(ctrl, 0, 0);
-      dataView.set(chunk);
-      this.syncKernel.postMessage({
-        type: "write",
-        path: absPath,
-        ctrlBuffer,
-        metaBuffer,
-        dataBuffer,
-        dataLength: currentChunkSize,
-        payload: { offset }
-        // Kernel writes at this offset
-      });
-      const waitResult = Atomics.wait(ctrl, 0, 0, 6e4);
-      if (waitResult === "timed-out") {
-        throw new Error(`Chunked write timed out at offset ${offset}`);
-      }
-      const status = Atomics.load(ctrl, 0);
-      if (status === -1) {
-        const metaView = new Uint8Array(metaBuffer);
-        let end = metaView.indexOf(0);
-        if (end === -1) end = _OPFSFileSystem.META_SIZE;
-        const errorMsg = new TextDecoder().decode(metaView.slice(0, end));
-        throw mapErrorCode(errorMsg || "Error", "write", absPath);
-      }
-      if (status === -2) {
-        throw createENOENT("write", absPath);
+    spinWait(this.ctrl, 0, SIGNAL.REQUEST);
+    const signal = Atomics.load(this.ctrl, 0);
+    const respChunkLen = Atomics.load(this.ctrl, 3);
+    const respTotalLen = Number(Atomics.load(totalLenView, 0));
+    let responseBytes;
+    if (signal === SIGNAL.RESPONSE && respTotalLen <= maxChunk) {
+      responseBytes = new Uint8Array(this.sab, HEADER_SIZE, respChunkLen).slice();
+    } else {
+      responseBytes = new Uint8Array(respTotalLen);
+      let received = 0;
+      const firstLen = respChunkLen;
+      responseBytes.set(new Uint8Array(this.sab, HEADER_SIZE, firstLen), 0);
+      received += firstLen;
+      while (received < respTotalLen) {
+        Atomics.store(this.ctrl, 0, SIGNAL.CHUNK_ACK);
+        Atomics.notify(this.ctrl, 0);
+        spinWait(this.ctrl, 0, SIGNAL.CHUNK_ACK);
+        const nextLen = Atomics.load(this.ctrl, 3);
+        responseBytes.set(new Uint8Array(this.sab, HEADER_SIZE, nextLen), received);
+        received += nextLen;
       }
-      offset += currentChunkSize;
     }
-    return { success: true };
-  }
-  // Chunked read for files larger than buffer size
-  syncCallTier1ChunkedRead(absPath, totalSize) {
-    const chunkSize = _OPFSFileSystem.MAX_CHUNK_SIZE;
-    const result = new Uint8Array(totalSize);
-    const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(chunkSize);
-    let offset = 0;
-    while (offset < totalSize) {
-      const remaining = totalSize - offset;
-      const currentChunkSize = Math.min(chunkSize, remaining);
-      Atomics.store(ctrl, 0, 0);
-      this.syncKernel.postMessage({
-        type: "read",
-        path: absPath,
-        ctrlBuffer,
-        metaBuffer,
-        dataBuffer,
-        dataLength: 0,
-        payload: { offset, len: currentChunkSize }
+    Atomics.store(this.ctrl, 0, SIGNAL.IDLE);
+    const result = decodeResponse(responseBytes.buffer);
+    if (this.config.debug) {
+      const t1 = performance.now();
+      console.log(`[syncRequest] size=${requestBuf.byteLength} roundTrip=${(t1 - t0).toFixed(3)}ms`);
+    }
+    return result;
+  }
+  // ========== Async operation primitive ==========
+  asyncRequest(op, filePath, flags, data, path2, fdArgs) {
+    return this.readyPromise.then(() => {
+      return new Promise((resolve2, reject) => {
+        const callId = this.asyncCallId++;
+        this.asyncPending.set(callId, { resolve: resolve2, reject });
+        this.asyncWorker.postMessage({
+          type: "request",
+          callId,
+          op,
+          path: filePath,
+          flags: flags ?? 0,
+          data: data instanceof Uint8Array ? data : typeof data === "string" ? data : null,
+          path2,
+          fdArgs
+        });
       });
-      const waitResult = Atomics.wait(ctrl, 0, 0, 6e4);
-      if (waitResult === "timed-out") {
-        throw new Error(`Chunked read timed out at offset ${offset}`);
-      }
-      const status = Atomics.load(ctrl, 0);
-      if (status === -1) {
-        const metaView = new Uint8Array(metaBuffer);
-        let end = metaView.indexOf(0);
-        if (end === -1) end = _OPFSFileSystem.META_SIZE;
-        const errorMsg = new TextDecoder().decode(metaView.slice(0, end));
-        throw mapErrorCode(errorMsg || "Error", "read", absPath);
-      }
-      if (status === -2) {
-        throw createENOENT("read", absPath);
-      }
-      const bytesRead = status;
-      const dataView = new Uint8Array(dataBuffer, 0, bytesRead);
-      result.set(dataView, offset);
-      offset += bytesRead;
-      if (bytesRead < currentChunkSize) {
-        break;
-      }
-    }
-    return { data: result.subarray(0, offset) };
-  }
-  // Get file size via stat (used for chunked reads)
-  syncStatTier1(absPath) {
-    const { ctrlBuffer, ctrl, metaBuffer, dataBuffer } = this.getSyncBuffers(1024);
-    Atomics.store(ctrl, 0, 0);
-    this.syncKernel.postMessage({
-      type: "stat",
-      path: absPath,
-      ctrlBuffer,
-      metaBuffer,
-      dataBuffer,
-      dataLength: 0
     });
-    const waitResult = Atomics.wait(ctrl, 0, 0, 1e4);
-    if (waitResult === "timed-out") {
-      return null;
-    }
-    const status = Atomics.load(ctrl, 0);
-    if (status <= 0) {
-      return null;
-    }
-    const view = new DataView(metaBuffer);
-    return { size: view.getFloat64(8, true) };
-  }
-  syncCall(type, filePath, payload) {
-    if (isWorkerContext && typeof SharedArrayBuffer !== "undefined" && this.syncKernelReady) {
-      return this.syncCallTier1(type, filePath, payload);
-    }
-    throw new Error(
-      `Sync operations require crossOriginIsolated environment (COOP/COEP headers) and initSync() to be called. Current state: crossOriginIsolated=${typeof crossOriginIsolated !== "undefined" ? crossOriginIsolated : "N/A"}, isWorkerContext=${isWorkerContext}, syncKernelReady=${this.syncKernelReady}. Use fs.promises.* for async operations that work everywhere.`
-    );
   }
-  // --- Synchronous API (Node.js fs compatible) ---
+  // ========== Sync API ==========
   readFileSync(filePath, options) {
-    const encoding = typeof options === "string" ? options : options?.encoding;
-    const result = this.syncCall("read", filePath);
-    if (!result.data) throw createENOENT("read", filePath);
-    return decodeData(result.data, encoding);
+    return readFileSync(this._sync, filePath, options);
   }
   writeFileSync(filePath, data, options) {
-    const opts = typeof options === "string" ? { encoding: options } : options;
-    const encoded = encodeData(data, opts?.encoding);
-    this.syncCall("write", filePath, { data: encoded, flush: opts?.flush });
-    this.invalidateStat(filePath);
+    writeFileSync(this._sync, filePath, data, options);
   }
   appendFileSync(filePath, data, options) {
-    typeof options === "string" ? options : options?.encoding;
-    const encoded = encodeData(data);
-    this.syncCall("append", filePath, { data: encoded });
-    this.invalidateStat(filePath);
+    appendFileSync(this._sync, filePath, data);
   }
   existsSync(filePath) {
-    try {
-      const result = this.syncCall("exists", filePath);
-      return result.exists ?? false;
-    } catch {
-      return false;
-    }
+    return existsSync(this._sync, filePath);
   }
   mkdirSync(filePath, options) {
-    const recursive = typeof options === "object" ? options?.recursive : false;
-    this.syncCall("mkdir", filePath, { recursive });
-    this.invalidateStat(filePath);
-    return recursive ? filePath : void 0;
+    return mkdirSync(this._sync, filePath, options);
   }
   rmdirSync(filePath, options) {
-    this.syncCall("rmdir", filePath, { recursive: options?.recursive });
-    if (options?.recursive) {
-      this.invalidateStatsUnder(filePath);
-    } else {
-      this.invalidateStat(filePath);
-    }
+    rmdirSync(this._sync, filePath, options);
   }
   rmSync(filePath, options) {
-    try {
-      const result = this.syncCall("stat", filePath);
-      try {
-        if (result.isDirectory || result.type === "directory") {
-          this.syncCall("rmdir", filePath, { recursive: options?.recursive });
-          if (options?.recursive) {
-            this.invalidateStatsUnder(filePath);
-          } else {
-            this.invalidateStat(filePath);
-          }
-        } else {
-          this.syncCall("unlink", filePath);
-          this.invalidateStat(filePath);
-        }
-      } catch (e) {
-        if (!options?.force) throw e;
-      }
-    } catch (e) {
-      if (!options?.force) throw e;
-    }
+    rmSync(this._sync, filePath, options);
   }
   unlinkSync(filePath) {
-    this.syncCall("unlink", filePath);
-    this.invalidateStat(filePath);
+    unlinkSync(this._sync, filePath);
   }
   readdirSync(filePath, options) {
-    const result = this.syncCall("readdir", filePath);
-    const entries = result.entries || [];
-    const opts = typeof options === "object" ? options : { };
-    if (opts?.withFileTypes) {
-      return entries.map((name) => {
-        try {
-          const stat = this.syncCall("stat", join(filePath, name));
-          const isDir = stat.type === "directory" || stat.isDirectory === true;
-          return createDirent(name, isDir);
-        } catch {
-          return createDirent(name, false);
-        }
-      });
-    }
-    return entries;
+    return readdirSync(this._sync, filePath, options);
   }
   statSync(filePath) {
-    const absPath = normalize(resolve(filePath));
-    const cached = this.statCache.get(absPath);
-    if (cached) return cached;
-    const result = this.syncCall("stat", filePath);
-    if (result.type === void 0 && result.isFile === void 0 && result.isDirectory === void 0) {
-      throw createENOENT("stat", filePath);
-    }
-    const stats = createStats(result);
-    this.statCache.set(absPath, stats);
-    return stats;
+    return statSync(this._sync, filePath);
   }
   lstatSync(filePath) {
-    const stats = this.statSync(filePath);
-    if (stats.isFile() && this.isSymlinkSync(filePath)) {
-      return this.createSymlinkStats(stats);
-    }
-    return stats;
-  }
-  /**
-   * Create stats object for a symlink file.
-   */
-  createSymlinkStats(baseStats) {
-    return {
-      ...baseStats,
-      isFile: () => false,
-      isSymbolicLink: () => true,
-      // Symlink mode: 0o120777 (41471 decimal)
-      mode: 41471
-    };
+    return lstatSync(this._sync, filePath);
   }
   renameSync(oldPath, newPath) {
-    this.syncCall("rename", oldPath, { newPath });
-    this.invalidateStat(oldPath);
-    this.invalidateStat(newPath);
-  }
-  copyFileSync(src, dest) {
-    this.syncCall("copy", src, { newPath: dest });
-    this.invalidateStat(dest);
-  }
-  truncateSync(filePath, len = 0) {
-    this.syncCall("truncate", filePath, { len });
-    this.invalidateStat(filePath);
-  }
-  /**
-   * Flush all pending writes to storage.
-   * Use this after writes with { flush: false } to ensure data is persisted.
-   */
-  flushSync() {
-    this.syncCall("flush", "/");
-  }
-  /**
-   * Alias for flushSync() - matches Node.js fdatasync behavior
-   */
-  fdatasyncSync() {
-    this.flushSync();
-  }
-  /**
-   * Purge all kernel caches (sync handles, directory handles).
-   * Use between major operations to ensure clean state.
-   */
-  purgeSync() {
-    this.syncCall("purge", "/");
-    this.statCache.clear();
-  }
-  /**
-   * Enable or disable debug tracing for handle operations.
-   * When enabled, logs handle cache hits, acquisitions, releases, and mode information.
-   * @param enabled - Whether to enable debug tracing
-   * @returns Debug state information including unsafeModeSupported and cache size
-   */
-  setDebugSync(enabled) {
-    return this.syncCall("setDebug", "/", { enabled });
-  }
-  /**
-   * Enable or disable debug tracing for handle operations (async version).
-   * When enabled, logs handle cache hits, acquisitions, releases, and mode information.
-   * @param enabled - Whether to enable debug tracing
-   * @returns Debug state information including unsafeModeSupported and cache size
-   */
-  async setDebug(enabled) {
-    return this.asyncCall("setDebug", "/", { enabled });
-  }
-  accessSync(filePath, _mode) {
-    const exists = this.existsSync(filePath);
-    if (!exists) {
-      throw createENOENT("access", filePath);
-    }
+    renameSync(this._sync, oldPath, newPath);
   }
-  // --- Low-level File Descriptor API ---
-  // For efficient packfile access (read specific offsets without loading entire file)
-  openSync(filePath, flags = "r") {
-    const flagNum = typeof flags === "string" ? this.parseFlags(flags) : flags;
-    const isReadOnly = (flagNum & constants.O_WRONLY) === 0 && (flagNum & constants.O_RDWR) === 0;
-    if (isReadOnly && !this.existsSync(filePath)) {
-      throw createENOENT("open", filePath);
-    }
-    const fd = this.nextFd++;
-    this.fdTable.set(fd, {
-      path: normalize(resolve(filePath)),
-      flags: flagNum,
-      position: 0
-    });
-    return fd;
+  copyFileSync(src, dest, mode) {
+    copyFileSync(this._sync, src, dest, mode);
   }
-  closeSync(fd) {
-    if (!this.fdTable.has(fd)) {
-      throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-    }
-    this.fdTable.delete(fd);
+  truncateSync(filePath, len) {
+    truncateSync(this._sync, filePath, len);
   }
-  readSync(fd, buffer, offset, length, position) {
-    const entry = this.fdTable.get(fd);
-    if (!entry) {
-      throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-    }
-    const readPos = position !== null ? position : entry.position;
-    const result = this.syncCall("read", entry.path, { offset: readPos, len: length });
-    if (!result.data) {
-      return 0;
-    }
-    const bytesRead = Math.min(result.data.length, length);
-    buffer.set(result.data.subarray(0, bytesRead), offset);
-    if (position === null) {
-      entry.position += bytesRead;
-    }
-    return bytesRead;
+  accessSync(filePath, mode) {
+    accessSync(this._sync, filePath, mode);
   }
-  writeSync(fd, buffer, offset, length, position) {
-    const entry = this.fdTable.get(fd);
-    if (!entry) {
-      throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-    }
-    const writePos = position !== null ? position : entry.position;
-    const data = buffer.subarray(offset, offset + length);
-    this.syncCall("write", entry.path, {
-      data,
-      offset: writePos,
-      truncate: false
-    });
-    this.invalidateStat(entry.path);
-    if (position === null) {
-      entry.position += length;
-    }
-    return length;
+  realpathSync(filePath) {
+    return realpathSync(this._sync, filePath);
   }
-  fstatSync(fd) {
-    const entry = this.fdTable.get(fd);
-    if (!entry) {
-      throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-    }
-    return this.statSync(entry.path);
+  chmodSync(filePath, mode) {
+    chmodSync(this._sync, filePath, mode);
   }
-  ftruncateSync(fd, len = 0) {
-    const entry = this.fdTable.get(fd);
-    if (!entry) {
-      throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-    }
-    this.truncateSync(entry.path, len);
+  chownSync(filePath, uid, gid) {
+    chownSync(this._sync, filePath, uid, gid);
   }
-  /**
-   * Resolve a path to an absolute path.
-   * OPFS doesn't support symlinks, so this just normalizes the path.
-   */
-  realpathSync(filePath) {
-    this.accessSync(filePath);
-    return normalize(resolve(filePath));
-  }
-  /**
-   * Change file mode (no-op in OPFS - permissions not supported).
-   */
-  chmodSync(_filePath, _mode) {
-  }
-  /**
-   * Change file owner (no-op in OPFS - ownership not supported).
-   */
-  chownSync(_filePath, _uid, _gid) {
-  }
-  /**
-   * Change file timestamps (no-op in OPFS - timestamps are read-only).
-   */
-  utimesSync(_filePath, _atime, _mtime) {
-  }
-  // Magic prefix for symlink files - must be unique enough to not appear in regular files
-  static SYMLINK_MAGIC = "OPFS_SYMLINK_V1:";
-  /**
-   * Create a symbolic link.
-   * Emulated by storing target path in a special file format.
-   */
-  symlinkSync(target, filePath, _type) {
-    const content = _OPFSFileSystem.SYMLINK_MAGIC + target;
-    this.writeFileSync(filePath, content);
-  }
-  /**
-   * Read a symbolic link target.
-   */
-  readlinkSync(filePath) {
-    const content = this.readFileSync(filePath, { encoding: "utf8" });
-    if (!content.startsWith(_OPFSFileSystem.SYMLINK_MAGIC)) {
-      throw new FSError("EINVAL", -22, `EINVAL: invalid argument, readlink '${filePath}'`, "readlink", filePath);
-    }
-    return content.slice(_OPFSFileSystem.SYMLINK_MAGIC.length);
+  utimesSync(filePath, atime, mtime) {
+    utimesSync(this._sync, filePath, atime, mtime);
   }
-  /**
-   * Check if a file is a symlink (sync).
-   */
-  isSymlinkSync(filePath) {
-    try {
-      const content = this.readFileSync(filePath, { encoding: "utf8" });
-      return content.startsWith(_OPFSFileSystem.SYMLINK_MAGIC);
-    } catch {
-      return false;
-    }
+  symlinkSync(target, linkPath) {
+    symlinkSync(this._sync, target, linkPath);
   }
-  /**
-   * Check if a file is a symlink (async).
-   */
-  async isSymlinkAsync(filePath) {
-    try {
-      const content = await this.promises.readFile(filePath, { encoding: "utf8" });
-      return content.startsWith(_OPFSFileSystem.SYMLINK_MAGIC);
-    } catch {
-      return false;
-    }
+  readlinkSync(filePath) {
+    return readlinkSync(this._sync, filePath);
   }
-  /**
-   * Create a hard link.
-   * Emulated by copying the file (true hard links not supported in OPFS).
-   */
   linkSync(existingPath, newPath) {
-    this.copyFileSync(existingPath, newPath);
-  }
-  parseFlags(flags) {
-    switch (flags) {
-      case "r":
-        return constants.O_RDONLY;
-      case "r+":
-        return constants.O_RDWR;
-      case "w":
-        return constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC;
-      case "w+":
-        return constants.O_RDWR | constants.O_CREAT | constants.O_TRUNC;
-      case "a":
-        return constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND;
-      case "a+":
-        return constants.O_RDWR | constants.O_CREAT | constants.O_APPEND;
-      default:
-        return constants.O_RDONLY;
-    }
+    linkSync(this._sync, existingPath, newPath);
   }
-  // --- Async Promises API ---
-  // When Tier 1 sync kernel is available, use it for better performance (wrapped in Promise)
-  // Otherwise fall back to async worker
-  // Operations NOT implemented in the sync kernel - must use async worker
-  static ASYNC_ONLY_OPS = /* @__PURE__ */ new Set([
-    "releaseAllHandles",
-    "releaseHandle"
-  ]);
-  // Helper: Use sync kernel if available (in worker context), otherwise async worker
-  async fastCall(type, filePath, payload) {
-    if (this.syncKernelReady && !_OPFSFileSystem.ASYNC_ONLY_OPS.has(type)) {
-      if (isWorkerContext) {
-        return Promise.resolve(this.syncCallTier1(type, filePath, payload));
-      } else {
-        return this.syncCallTier1Async(type, filePath, payload);
-      }
-    }
-    return this.asyncCall(type, filePath, payload);
+  mkdtempSync(prefix) {
+    return mkdtempSync(this._sync, prefix);
   }
-  promises = {
-    readFile: async (filePath, options) => {
-      if (!filePath) {
-        throw createENOENT("read", filePath || "");
-      }
-      const encoding = typeof options === "string" ? options : options?.encoding;
-      if (this.syncKernelReady) {
-        if (isWorkerContext) {
-          const result2 = this.syncCallTier1("read", filePath);
-          if (!result2.data) throw createENOENT("read", filePath);
-          return decodeData(result2.data, encoding);
-        } else {
-          const result2 = await this.syncCallTier1Async("read", filePath);
-          if (!result2.data) throw createENOENT("read", filePath);
-          return decodeData(result2.data, encoding);
-        }
-      }
-      const result = await this.asyncCall("read", filePath);
-      if (!result.data) throw createENOENT("read", filePath);
-      return decodeData(result.data, encoding);
-    },
-    writeFile: async (filePath, data, options) => {
-      const opts = typeof options === "string" ? { encoding: options } : options;
-      const encoded = encodeData(data, opts?.encoding);
-      await this.fastCall("write", filePath, { data: encoded, flush: opts?.flush });
-      this.invalidateStat(filePath);
-    },
-    appendFile: async (filePath, data, options) => {
-      const opts = typeof options === "string" ? { encoding: options } : options;
-      const encoded = encodeData(data, opts?.encoding);
-      await this.fastCall("append", filePath, { data: encoded, flush: opts?.flush });
-      this.invalidateStat(filePath);
-    },
-    mkdir: async (filePath, options) => {
-      const recursive = typeof options === "object" ? options?.recursive : false;
-      await this.fastCall("mkdir", filePath, { recursive });
-      return recursive ? filePath : void 0;
-    },
-    rmdir: async (filePath, options) => {
-      await this.fastCall("rmdir", filePath, { recursive: options?.recursive });
-    },
-    rm: async (filePath, options) => {
-      try {
-        const result = await this.fastCall("stat", filePath);
-        try {
-          if (result.isDirectory || result.type === "directory") {
-            await this.fastCall("rmdir", filePath, { recursive: options?.recursive });
-            if (options?.recursive) {
-              this.invalidateStatsUnder(filePath);
-            } else {
-              this.invalidateStat(filePath);
-            }
-          } else {
-            await this.fastCall("unlink", filePath);
-            this.invalidateStat(filePath);
-          }
-        } catch (e) {
-          if (!options?.force) throw e;
-        }
-      } catch (e) {
-        if (!options?.force) throw e;
-      }
-    },
-    unlink: async (filePath) => {
-      await this.fastCall("unlink", filePath);
-    },
-    readdir: async (filePath, options) => {
-      const result = await this.fastCall("readdir", filePath);
-      const entries = result.entries || [];
-      const opts = typeof options === "object" ? options : { };
-      if (opts?.withFileTypes) {
-        const dirents = [];
-        for (const name of entries) {
-          try {
-            const stat = await this.fastCall("stat", join(filePath, name));
-            const isDir = stat.type === "directory" || stat.isDirectory === true;
-            dirents.push(createDirent(name, isDir));
-          } catch {
-            dirents.push(createDirent(name, false));
-          }
-        }
-        return dirents;
-      }
-      return entries;
-    },
-    stat: async (filePath) => {
-      const result = await this.fastCall("stat", filePath);
-      return createStats(result);
-    },
-    access: async (filePath, _mode) => {
-      const result = await this.fastCall("exists", filePath);
-      if (!result.exists) {
-        throw createENOENT("access", filePath);
-      }
-    },
-    rename: async (oldFilePath, newFilePath) => {
-      await this.fastCall("rename", oldFilePath, { newPath: resolve(newFilePath) });
-    },
-    copyFile: async (srcPath, destPath) => {
-      await this.fastCall("copy", srcPath, { newPath: resolve(destPath) });
-    },
-    truncate: async (filePath, len = 0) => {
-      await this.fastCall("truncate", filePath, { len });
-      this.invalidateStat(filePath);
-    },
-    lstat: async (filePath) => {
-      const result = await this.fastCall("stat", filePath);
-      const stats = createStats(result);
-      if (stats.isFile()) {
-        const isSymlink = await this.isSymlinkAsync(filePath);
-        if (isSymlink) {
-          return this.createSymlinkStats(stats);
-        }
-      }
-      return stats;
-    },
-    realpath: async (filePath) => {
-      await this.promises.access(filePath);
-      return normalize(resolve(filePath));
-    },
-    exists: async (filePath) => {
-      try {
-        const result = await this.fastCall("exists", filePath);
-        return result.exists ?? false;
-      } catch {
-        return false;
-      }
-    },
-    chmod: async (_filePath, _mode) => {
-    },
-    chown: async (_filePath, _uid, _gid) => {
-    },
-    utimes: async (_filePath, _atime, _mtime) => {
-    },
-    symlink: async (target, filePath, _type) => {
-      const content = _OPFSFileSystem.SYMLINK_MAGIC + target;
-      await this.promises.writeFile(filePath, content);
-    },
-    readlink: async (filePath) => {
-      const content = await this.promises.readFile(filePath, { encoding: "utf8" });
-      if (!content.startsWith(_OPFSFileSystem.SYMLINK_MAGIC)) {
-        throw new FSError("EINVAL", -22, `EINVAL: invalid argument, readlink '${filePath}'`, "readlink", filePath);
-      }
-      return content.slice(_OPFSFileSystem.SYMLINK_MAGIC.length);
-    },
-    link: async (existingPath, newPath) => {
-      await this.promises.copyFile(existingPath, newPath);
-    },
-    open: async (filePath, flags = "r", _mode) => {
-      const flagNum = typeof flags === "string" ? this.parseFlags(flags) : flags;
-      const isReadOnly = (flagNum & constants.O_WRONLY) === 0 && (flagNum & constants.O_RDWR) === 0;
-      if (isReadOnly) {
-        const exists = await this.promises.exists(filePath);
-        if (!exists) {
-          throw createENOENT("open", filePath);
-        }
-      }
-      const fd = this.nextFd++;
-      this.fdTable.set(fd, {
-        path: normalize(resolve(filePath)),
-        flags: flagNum,
-        position: 0
-      });
-      return this.createFileHandle(fd, filePath);
-    },
-    opendir: async (dirPath) => {
-      return this.createDir(dirPath);
-    },
-    mkdtemp: async (prefix) => {
-      const suffix = Math.random().toString(36).substring(2, 8);
-      const tmpDir = `${prefix}${suffix}`;
-      await this.promises.mkdir(tmpDir, { recursive: true });
-      return tmpDir;
-    },
-    watch: (filePath, options) => {
-      return this.createAsyncWatcher(filePath, options);
-    },
-    /**
-     * Flush all pending writes to storage.
-     * Use after writes with { flush: false } to ensure data is persisted.
-     */
-    flush: async () => {
-      await this.fastCall("flush", "/");
-    },
-    /**
-     * Purge all kernel caches.
-     * Use between major operations to ensure clean state.
-     */
-    purge: async () => {
-      await this.fastCall("purge", "/");
-      this.statCache.clear();
-    }
-  };
-  /**
-   * Async flush - use after promises.writeFile with { flush: false }
-   */
-  async flush() {
-    await this.fastCall("flush", "/");
+  // ---- File descriptor sync methods ----
+  openSync(filePath, flags = "r", mode) {
+    return openSync(this._sync, filePath, flags);
   }
-  /**
-   * Async purge - clears all kernel caches
-   */
-  async purge() {
-    await this.fastCall("purge", "/");
-    this.statCache.clear();
-  }
-  /**
-   * Release all cached file handles.
-   * Call this before expecting external tools (OPFS Explorer, browser console, etc.)
-   * to modify files. This allows external access without waiting for the idle timeout.
-   * Unlike purge(), this only releases file handles without clearing directory caches.
-   */
-  async releaseAllHandles() {
-    await this.fastCall("releaseAllHandles", "/");
-  }
-  /**
-   * Release a specific file's handle.
-   * Use this when you know a specific file needs to be externally modified.
-   */
-  async releaseHandle(filePath) {
-    await this.fastCall("releaseHandle", filePath);
-  }
-  // Constants
-  constants = constants;
-  // --- FileHandle Implementation ---
-  createFileHandle(fd, filePath) {
-    const self2 = this;
-    const absPath = normalize(resolve(filePath));
-    return {
-      fd,
-      async read(buffer, offset = 0, length, position = null) {
-        const len = length ?? buffer.length - offset;
-        const entry = self2.fdTable.get(fd);
-        if (!entry) throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-        const readPos = position !== null ? position : entry.position;
-        const result = await self2.fastCall("read", absPath, { offset: readPos, len });
-        if (!result.data) {
-          return { bytesRead: 0, buffer };
-        }
-        const bytesRead = Math.min(result.data.length, len);
-        buffer.set(result.data.subarray(0, bytesRead), offset);
-        if (position === null) {
-          entry.position += bytesRead;
-        }
-        return { bytesRead, buffer };
-      },
-      async write(buffer, offset = 0, length, position = null) {
-        const len = length ?? buffer.length - offset;
-        const entry = self2.fdTable.get(fd);
-        if (!entry) throw new FSError("EBADF", -9, `bad file descriptor: ${fd}`);
-        const writePos = position !== null ? position : entry.position;
-        const data = buffer.subarray(offset, offset + len);
-        await self2.fastCall("write", absPath, { data, offset: writePos, truncate: false });
-        self2.invalidateStat(absPath);
-        if (position === null) {
-          entry.position += len;
-        }
-        return { bytesWritten: len, buffer };
-      },
-      async readFile(options) {
-        return self2.promises.readFile(absPath, options);
-      },
-      async writeFile(data, options) {
-        return self2.promises.writeFile(absPath, data, options);
-      },
-      async truncate(len = 0) {
-        await self2.fastCall("truncate", absPath, { len });
-        self2.invalidateStat(absPath);
-      },
-      async stat() {
-        return self2.promises.stat(absPath);
-      },
-      async sync() {
-        await self2.fastCall("flush", "/");
-      },
-      async datasync() {
-        await self2.fastCall("flush", "/");
-      },
-      async close() {
-        self2.fdTable.delete(fd);
-      }
-    };
+  closeSync(fd) {
+    closeSync(this._sync, fd);
   }
-  // --- Dir Implementation ---
-  createDir(dirPath) {
-    const self2 = this;
-    const absPath = normalize(resolve(dirPath));
-    let entries = null;
-    let index = 0;
-    let closed = false;
-    const loadEntries = async () => {
-      if (entries === null) {
-        const result = await self2.fastCall("readdir", absPath);
-        entries = result.entries || [];
-      }
-    };
-    const dir = {
-      path: absPath,
-      async read() {
-        if (closed) throw new FSError("EBADF", -9, "Directory handle was closed");
-        await loadEntries();
-        if (index >= entries.length) return null;
-        const name = entries[index++];
-        try {
-          const stat = await self2.fastCall("stat", join(absPath, name));
-          const isDir = stat.type === "directory" || stat.isDirectory === true;
-          return createDirent(name, isDir);
-        } catch {
-          return createDirent(name, false);
-        }
-      },
-      async close() {
-        closed = true;
-        entries = null;
-      },
-      [Symbol.asyncIterator]() {
-        const iterator = {
-          next: async () => {
-            const dirent = await dir.read();
-            if (dirent === null) {
-              return { done: true, value: void 0 };
-            }
-            return { done: false, value: dirent };
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        return iterator;
-      }
-    };
-    return dir;
-  }
-  // --- Watch Implementation (Native FileSystemObserver with polling fallback) ---
-  watchedFiles = /* @__PURE__ */ new Map();
-  // Check if native FileSystemObserver is available
-  static hasNativeObserver = typeof globalThis.FileSystemObserver !== "undefined";
-  // Get OPFS directory handle for a path
-  async getDirectoryHandle(dirPath, create = false) {
-    const parts = dirPath.split("/").filter(Boolean);
-    let current = await navigator.storage.getDirectory();
-    for (const part of parts) {
-      current = await current.getDirectoryHandle(part, { create });
-    }
-    return current;
-  }
-  // Get OPFS file handle for a path
-  async getFileHandle(filePath, create = false) {
-    const parts = filePath.split("/").filter(Boolean);
-    const fileName = parts.pop();
-    if (!fileName) throw new Error("Invalid file path");
-    let current = await navigator.storage.getDirectory();
-    for (const part of parts) {
-      current = await current.getDirectoryHandle(part, { create });
-    }
-    return current.getFileHandle(fileName, { create });
-  }
-  // Convert FileSystemObserver change type to Node.js event type
-  mapChangeType(type) {
-    switch (type) {
-      case "appeared":
-      case "disappeared":
-      case "moved":
-        return "rename";
-      case "modified":
-        return "change";
-      default:
-        return "change";
-    }
+  readSync(fd, buffer, offset = 0, length = buffer.byteLength, position = null) {
+    return readSync(this._sync, fd, buffer, offset, length, position);
   }
-  createAsyncWatcher(filePath, options) {
-    const absPath = normalize(resolve(filePath));
-    if (_OPFSFileSystem.hasNativeObserver) {
-      return this.createNativeAsyncWatcher(absPath, options);
-    }
-    return this.createPollingAsyncWatcher(absPath, options);
-  }
-  createNativeAsyncWatcher(absPath, options) {
-    const self2 = this;
-    return {
-      [Symbol.asyncIterator]() {
-        const eventQueue = [];
-        let resolveNext = null;
-        let observer = null;
-        let aborted = false;
-        let initialized = false;
-        if (options?.signal) {
-          options.signal.addEventListener("abort", () => {
-            aborted = true;
-            observer?.disconnect();
-            if (resolveNext) {
-              resolveNext({ done: true, value: void 0 });
-              resolveNext = null;
-            }
-          });
-        }
-        const callback = (records) => {
-          for (const record of records) {
-            if (record.type === "errored" || record.type === "unknown") continue;
-            const filename = record.relativePathComponents.length > 0 ? record.relativePathComponents[record.relativePathComponents.length - 1] : basename(absPath);
-            const event = {
-              eventType: self2.mapChangeType(record.type),
-              filename
-            };
-            if (resolveNext) {
-              resolveNext({ done: false, value: event });
-              resolveNext = null;
-            } else {
-              eventQueue.push(event);
-            }
-          }
-        };
-        const init = async () => {
-          if (initialized) return;
-          initialized = true;
-          try {
-            observer = new globalThis.FileSystemObserver(callback);
-            const stat = await self2.promises.stat(absPath);
-            const handle = stat.isDirectory() ? await self2.getDirectoryHandle(absPath) : await self2.getFileHandle(absPath);
-            await observer.observe(handle, { recursive: options?.recursive });
-          } catch (e) {
-            aborted = true;
-          }
-        };
-        const iterator = {
-          async next() {
-            if (aborted) {
-              return { done: true, value: void 0 };
-            }
-            await init();
-            if (aborted) {
-              return { done: true, value: void 0 };
-            }
-            if (eventQueue.length > 0) {
-              return { done: false, value: eventQueue.shift() };
-            }
-            return new Promise((resolve2) => {
-              resolveNext = resolve2;
-            });
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        return iterator;
-      }
-    };
+  writeSync(fd, buffer, offset = 0, length = buffer.byteLength, position = null) {
+    return writeSyncFd(this._sync, fd, buffer, offset, length, position);
   }
-  createPollingAsyncWatcher(absPath, options) {
-    const self2 = this;
-    const interval = 1e3;
-    return {
-      [Symbol.asyncIterator]() {
-        let lastMtimeMs = null;
-        let lastEntries = null;
-        let aborted = false;
-        let pollTimeout = null;
-        if (options?.signal) {
-          options.signal.addEventListener("abort", () => {
-            aborted = true;
-            if (pollTimeout) clearTimeout(pollTimeout);
-          });
-        }
-        const checkForChanges = async () => {
-          if (aborted) return null;
-          try {
-            const stat = await self2.promises.stat(absPath);
-            if (stat.isDirectory()) {
-              const entries = await self2.promises.readdir(absPath);
-              const currentEntries = new Set(entries);
-              if (lastEntries === null) {
-                lastEntries = currentEntries;
-                return null;
-              }
-              for (const entry of currentEntries) {
-                if (!lastEntries.has(entry)) {
-                  lastEntries = currentEntries;
-                  return { eventType: "rename", filename: entry };
-                }
-              }
-              for (const entry of lastEntries) {
-                if (!currentEntries.has(entry)) {
-                  lastEntries = currentEntries;
-                  return { eventType: "rename", filename: entry };
-                }
-              }
-              lastEntries = currentEntries;
-            } else {
-              if (lastMtimeMs === null) {
-                lastMtimeMs = stat.mtimeMs;
-                return null;
-              }
-              if (stat.mtimeMs !== lastMtimeMs) {
-                lastMtimeMs = stat.mtimeMs;
-                return { eventType: "change", filename: basename(absPath) };
-              }
-            }
-          } catch {
-            if (lastMtimeMs !== null || lastEntries !== null) {
-              lastMtimeMs = null;
-              lastEntries = null;
-              return { eventType: "rename", filename: basename(absPath) };
-            }
-          }
-          return null;
-        };
-        const iterator = {
-          async next() {
-            if (aborted) {
-              return { done: true, value: void 0 };
-            }
-            while (!aborted) {
-              const event = await checkForChanges();
-              if (event) {
-                return { done: false, value: event };
-              }
-              await new Promise((resolve2) => {
-                pollTimeout = setTimeout(resolve2, interval);
-              });
-            }
-            return { done: true, value: void 0 };
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        return iterator;
-      }
-    };
+  fstatSync(fd) {
+    return fstatSync(this._sync, fd);
   }
-  /**
-   * Watch a file or directory for changes.
-   * Uses native FileSystemObserver when available, falls back to polling.
-   */
-  watch(filePath, options = {}, listener) {
-    const absPath = normalize(resolve(filePath));
-    const opts = typeof options === "function" ? {} : options;
-    const cb = typeof options === "function" ? options : listener;
-    if (_OPFSFileSystem.hasNativeObserver) {
-      return this.createNativeWatcher(absPath, opts, cb);
-    }
-    return this.createPollingWatcher(absPath, cb);
-  }
-  createNativeWatcher(absPath, opts, cb) {
-    const self2 = this;
-    let observer = null;
-    let closed = false;
-    const callback = async (records) => {
-      if (closed) return;
-      await self2.releaseAllHandles();
-      for (const record of records) {
-        if (record.type === "errored" || record.type === "unknown") continue;
-        const filename = record.relativePathComponents.length > 0 ? record.relativePathComponents[record.relativePathComponents.length - 1] : basename(absPath);
-        cb?.(self2.mapChangeType(record.type), filename);
-      }
-    };
-    (async () => {
-      if (closed) return;
-      try {
-        observer = new globalThis.FileSystemObserver(callback);
-        const stat = await self2.promises.stat(absPath);
-        const handle = stat.isDirectory() ? await self2.getDirectoryHandle(absPath) : await self2.getFileHandle(absPath);
-        await observer.observe(handle, { recursive: opts.recursive });
-      } catch {
-      }
-    })();
-    const watcher = {
-      close: () => {
-        closed = true;
-        observer?.disconnect();
-      },
-      ref: () => watcher,
-      unref: () => watcher
-    };
-    return watcher;
-  }
-  createPollingWatcher(absPath, cb) {
-    const interval = 1e3;
-    let lastMtimeMs = null;
-    let lastEntries = null;
-    let closed = false;
-    const poll = async () => {
-      if (closed) return;
-      try {
-        const stat = await this.promises.stat(absPath);
-        if (stat.isDirectory()) {
-          const entries = await this.promises.readdir(absPath);
-          const currentEntries = new Set(entries);
-          if (lastEntries !== null) {
-            let hasChanges = false;
-            const added = [];
-            const removed = [];
-            for (const entry of currentEntries) {
-              if (!lastEntries.has(entry)) {
-                added.push(entry);
-                hasChanges = true;
-              }
-            }
-            for (const entry of lastEntries) {
-              if (!currentEntries.has(entry)) {
-                removed.push(entry);
-                hasChanges = true;
-              }
-            }
-            if (hasChanges) {
-              await this.releaseAllHandles();
-              for (const entry of added) cb?.("rename", entry);
-              for (const entry of removed) cb?.("rename", entry);
-            }
-          }
-          lastEntries = currentEntries;
-        } else {
-          if (lastMtimeMs !== null && stat.mtimeMs !== lastMtimeMs) {
-            await this.releaseAllHandles();
-            cb?.("change", basename(absPath));
-          }
-          lastMtimeMs = stat.mtimeMs;
-        }
-      } catch {
-        if (lastMtimeMs !== null || lastEntries !== null) {
-          await this.releaseAllHandles();
-          cb?.("rename", basename(absPath));
-          lastMtimeMs = null;
-          lastEntries = null;
-        }
-      }
-    };
-    const intervalId = setInterval(poll, interval);
-    poll();
-    const watcher = {
-      close: () => {
-        closed = true;
-        clearInterval(intervalId);
-      },
-      ref: () => watcher,
-      unref: () => watcher
-    };
-    return watcher;
-  }
-  /**
-   * Watch a file for changes using native FileSystemObserver or stat polling.
-   */
-  watchFile(filePath, options = {}, listener) {
-    const absPath = normalize(resolve(filePath));
-    const opts = typeof options === "function" ? {} : options;
-    const cb = typeof options === "function" ? options : listener;
-    const interval = opts.interval ?? 5007;
-    let lastStat = null;
-    let observer;
-    const poll = async () => {
-      try {
-        const stat = await this.promises.stat(absPath);
-        if (lastStat !== null) {
-          if (stat.mtimeMs !== lastStat.mtimeMs || stat.size !== lastStat.size) {
-            await this.releaseAllHandles();
-            cb?.(stat, lastStat);
-          }
-        }
-        lastStat = stat;
-      } catch {
-        const emptyStat = createStats({ type: "file", size: 0, mtimeMs: 0, mode: 0 });
-        if (lastStat !== null) {
-          await this.releaseAllHandles();
-          cb?.(emptyStat, lastStat);
-        }
-        lastStat = emptyStat;
-      }
-    };
-    if (_OPFSFileSystem.hasNativeObserver && cb) {
-      const self2 = this;
-      const observerCallback = async () => {
-        await self2.releaseAllHandles();
-        try {
-          const stat = await self2.promises.stat(absPath);
-          if (lastStat !== null && (stat.mtimeMs !== lastStat.mtimeMs || stat.size !== lastStat.size)) {
-            cb(stat, lastStat);
-          }
-          lastStat = stat;
-        } catch {
-          const emptyStat = createStats({ type: "file", size: 0, mtimeMs: 0, mode: 0 });
-          if (lastStat !== null) {
-            cb(emptyStat, lastStat);
-          }
-          lastStat = emptyStat;
-        }
-      };
-      (async () => {
-        try {
-          lastStat = await self2.promises.stat(absPath);
-          observer = new globalThis.FileSystemObserver(observerCallback);
-          const handle = await self2.getFileHandle(absPath);
-          await observer.observe(handle);
-        } catch {
-          if (!this.watchedFiles.get(absPath)?.interval) {
-            const entry = this.watchedFiles.get(absPath);
-            if (entry) {
-              entry.interval = setInterval(poll, interval);
-            }
-          }
-        }
-      })();
-      if (!this.watchedFiles.has(absPath)) {
-        this.watchedFiles.set(absPath, {
-          observer,
-          listeners: /* @__PURE__ */ new Set(),
-          lastStat: null
-        });
-      }
-      this.watchedFiles.get(absPath).listeners.add(cb);
-    } else {
-      if (!this.watchedFiles.has(absPath)) {
-        this.watchedFiles.set(absPath, {
-          interval: setInterval(poll, interval),
-          listeners: /* @__PURE__ */ new Set(),
-          lastStat: null
-        });
-      }
-      if (cb) this.watchedFiles.get(absPath).listeners.add(cb);
-      poll();
-    }
-    const watcher = {
-      ref: () => watcher,
-      unref: () => watcher
-    };
-    return watcher;
+  ftruncateSync(fd, len) {
+    ftruncateSync(this._sync, fd, len);
+  }
+  fdatasyncSync(fd) {
+    fdatasyncSync(this._sync, fd);
+  }
+  // ---- Watch methods ----
+  watch(filePath, options, listener) {
+    return watch();
+  }
+  watchFile(filePath, optionsOrListener, listener) {
   }
-  /**
-   * Stop watching a file.
-   */
   unwatchFile(filePath, listener) {
-    const absPath = normalize(resolve(filePath));
-    const entry = this.watchedFiles.get(absPath);
-    if (entry) {
-      if (listener) {
-        entry.listeners.delete(listener);
-        if (entry.listeners.size === 0) {
-          if (entry.interval) clearInterval(entry.interval);
-          if (entry.observer) entry.observer.disconnect();
-          this.watchedFiles.delete(absPath);
-        }
-      } else {
-        if (entry.interval) clearInterval(entry.interval);
-        if (entry.observer) entry.observer.disconnect();
-        this.watchedFiles.delete(absPath);
-      }
-    }
   }
-  // --- Stream Implementation ---
-  /**
-   * Create a readable stream for a file.
-   */
+  // ---- Stream methods ----
   createReadStream(filePath, options) {
-    const opts = typeof options === "string" ? { } : options ?? {};
-    const absPath = normalize(resolve(filePath));
-    const start = opts.start ?? 0;
-    const end = opts.end;
-    const highWaterMark = opts.highWaterMark ?? 64 * 1024;
+    const opts = typeof options === "string" ? { } : options;
+    const start = opts?.start ?? 0;
+    const end = opts?.end;
+    const highWaterMark = opts?.highWaterMark ?? 64 * 1024;
     let position = start;
-    let closed = false;
-    const self2 = this;
     return new ReadableStream({
-      async pull(controller) {
-        if (closed) {
-          controller.close();
-          return;
-        }
+      pull: async (controller) => {
         try {
-          const maxRead = end !== void 0 ? Math.min(highWaterMark, end - position + 1) : highWaterMark;
-          if (maxRead <= 0) {
+          const readLen = end !== void 0 ? Math.min(highWaterMark, end - position + 1) : highWaterMark;
+          if (readLen <= 0) {
             controller.close();
-            closed = true;
             return;
           }
-          const result = await self2.fastCall("read", absPath, { offset: position, len: maxRead });
-          if (!result.data || result.data.length === 0) {
+          const result = await this.promises.readFile(filePath);
+          const data = result instanceof Uint8Array ? result : encoder9.encode(result);
+          const chunk = data.subarray(position, position + readLen);
+          if (chunk.byteLength === 0) {
             controller.close();
-            closed = true;
             return;
           }
-          controller.enqueue(result.data);
-          position += result.data.length;
+          controller.enqueue(chunk);
+          position += chunk.byteLength;
           if (end !== void 0 && position > end) {
             controller.close();
-            closed = true;
           }
-        } catch (e) {
-          controller.error(e);
-          closed = true;
+        } catch (err) {
+          controller.error(err);
         }
-      },
-      cancel() {
-        closed = true;
       }
     });
   }
-  /**
-   * Create a writable stream for a file.
-   */
   createWriteStream(filePath, options) {
-    const opts = typeof options === "string" ? { } : options ?? {};
-    const absPath = normalize(resolve(filePath));
-    const start = opts.start ?? 0;
-    const shouldFlush = opts.flush !== false;
-    let position = start;
+    const opts = typeof options === "string" ? { } : options;
+    let position = opts?.start ?? 0;
     let initialized = false;
-    const self2 = this;
     return new WritableStream({
-      async write(chunk) {
-        if (!initialized && start === 0) {
-          await self2.fastCall("write", absPath, { data: chunk, offset: 0, flush: false });
-          position = chunk.length;
-          initialized = true;
-        } else {
-          await self2.fastCall("write", absPath, { data: chunk, offset: position, truncate: false, flush: false });
-          position += chunk.length;
+      write: async (chunk) => {
+        if (!initialized) {
+          if (opts?.flags !== "a" && opts?.flags !== "a+") {
+            await this.promises.writeFile(filePath, new Uint8Array(0));
+          }
           initialized = true;
         }
-        self2.invalidateStat(absPath);
+        await this.promises.appendFile(filePath, chunk);
+        position += chunk.byteLength;
       },
-      async close() {
-        if (shouldFlush) {
-          await self2.fastCall("flush", "/");
+      close: async () => {
+        if (opts?.flush) {
+          await this.promises.flush();
         }
-      },
-      async abort() {
       }
     });
   }
-  // --- Sync methods for opendir and mkdtemp ---
-  /**
-   * Open a directory for iteration (sync).
-   */
-  opendirSync(dirPath) {
-    return this.createDir(dirPath);
+  // ---- Utility methods ----
+  flushSync() {
+    const buf = encodeRequest(OP.FSYNC, "");
+    this.syncRequest(buf);
   }
-  /**
-   * Create a unique temporary directory (sync).
-   */
-  mkdtempSync(prefix) {
-    const suffix = Math.random().toString(36).substring(2, 8);
-    const tmpDir = `${prefix}${suffix}`;
-    this.mkdirSync(tmpDir, { recursive: true });
-    return tmpDir;
+  purgeSync() {
+  }
+  /** Async init helper — avoid blocking main thread */
+  init() {
+    return this.readyPromise;
+  }
+};
+var VFSPromises = class {
+  _async;
+  constructor(asyncRequest) {
+    this._async = asyncRequest;
+  }
+  readFile(filePath, options) {
+    return readFile(this._async, filePath, options);
+  }
+  writeFile(filePath, data, options) {
+    return writeFile(this._async, filePath, data, options);
+  }
+  appendFile(filePath, data, options) {
+    return appendFile(this._async, filePath, data);
+  }
+  mkdir(filePath, options) {
+    return mkdir(this._async, filePath, options);
+  }
+  rmdir(filePath, options) {
+    return rmdir(this._async, filePath, options);
+  }
+  rm(filePath, options) {
+    return rm(this._async, filePath, options);
+  }
+  unlink(filePath) {
+    return unlink(this._async, filePath);
+  }
+  readdir(filePath, options) {
+    return readdir(this._async, filePath, options);
+  }
+  stat(filePath) {
+    return stat(this._async, filePath);
+  }
+  lstat(filePath) {
+    return lstat(this._async, filePath);
+  }
+  access(filePath, mode) {
+    return access(this._async, filePath, mode);
+  }
+  rename(oldPath, newPath) {
+    return rename(this._async, oldPath, newPath);
+  }
+  copyFile(src, dest, mode) {
+    return copyFile(this._async, src, dest, mode);
+  }
+  truncate(filePath, len) {
+    return truncate(this._async, filePath, len);
+  }
+  realpath(filePath) {
+    return realpath(this._async, filePath);
+  }
+  exists(filePath) {
+    return exists(this._async, filePath);
+  }
+  chmod(filePath, mode) {
+    return chmod(this._async, filePath, mode);
+  }
+  chown(filePath, uid, gid) {
+    return chown(this._async, filePath, uid, gid);
+  }
+  utimes(filePath, atime, mtime) {
+    return utimes(this._async, filePath, atime, mtime);
+  }
+  symlink(target, linkPath) {
+    return symlink(this._async, target, linkPath);
+  }
+  readlink(filePath) {
+    return readlink(this._async, filePath);
+  }
+  link(existingPath, newPath) {
+    return link(this._async, existingPath, newPath);
+  }
+  open(filePath, flags, mode) {
+    return open(this._async, filePath, flags);
+  }
+  opendir(filePath) {
+    return opendir(this._async, filePath);
+  }
+  mkdtemp(prefix) {
+    return mkdtemp(this._async, prefix);
+  }
+  async *watch(filePath, options) {
+    yield* watchAsync(this._async, filePath, options);
+  }
+  async flush() {
+    await this._async(OP.FSYNC, "");
+  }
+  async purge() {
   }
 };
 
 // src/index.ts
-var fs = new OPFSFileSystem();
-var index_default = fs;
+function createFS(config) {
+  return new VFSFileSystem(config);
+}
+var _defaultFS;
+function getDefaultFS() {
+  if (!_defaultFS) _defaultFS = new VFSFileSystem();
+  return _defaultFS;
+}
+function init() {
+  return getDefaultFS().init();
+}
 
-export { FSError, OPFSFileSystem, constants, createEACCES, createEEXIST, createEINVAL, createEISDIR, createENOENT, createENOTDIR, createENOTEMPTY, index_default as default, fs, mapErrorCode, path_exports as path };
+export { FSError, VFSFileSystem, constants, createError, createFS, getDefaultFS, init, path_exports as path, statusToError };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map