@machinen/runtime 0.2.0 → 0.3.1

package/dist/mount-server-bin.js

@@ -1,2065 +0,0 @@
-import {
-  MountError,
-  isMachinenError
-} from "./chunk-6SP6T537.js";
-
-// src/mount-server-bin.ts
-import { renameSync, writeFileSync, unlinkSync } from "fs";
-
-// src/mount-server.ts
-import { createServer } from "net";
-import { execFile as execFileCb } from "child_process";
-import {
-  chmod,
-  lchmod,
-  lchown,
-  link,
-  lutimes,
-  mkdir,
-  open as fsOpen,
-  lstat,
-  readdir,
-  readlink,
-  realpath as realpath2,
-  rename,
-  rmdir,
-  statfs,
-  symlink,
-  truncate,
-  unlink,
-  utimes
-} from "fs/promises";
-import { constants as fsConstants } from "fs";
-import { join as join2 } from "path";
-import { promisify } from "util";
-import debug from "debug";
-
-// src/mount-resolver.ts
-import { realpath } from "fs/promises";
-import { basename, dirname, isAbsolute, join, resolve, sep } from "path";
-async function resolveUnderRoot(rootAbs, guestRelative, opts = {}) {
-  const mustExist = opts.mustExist ?? true;
-  if (!isAbsolute(rootAbs)) {
-    throw new MountError("MOUNT_PATH_INVALID", `mount root must be absolute: ${rootAbs}`);
-  }
-  if (guestRelative.includes("\0")) {
-    throw new MountError("MOUNT_PATH_INVALID", "null byte in guest path");
-  }
-  const rootReal = await realpath(rootAbs);
-  const relStripped = guestRelative.replace(/^\/+/, "");
-  const joined = resolve(rootReal, relStripped);
-  try {
-    const targetReal = await realpath(joined);
-    assertContained(targetReal, rootReal);
-    return targetReal;
-  } catch (err) {
-    const errno = err.code;
-    if (errno !== "ENOENT" || mustExist) {
-      throw err;
-    }
-  }
-  const parentReal = await realpath(dirname(joined));
-  assertContained(parentReal, rootReal);
-  return join(parentReal, basename(joined));
-}
-function assertContained(targetReal, rootReal) {
-  if (targetReal === rootReal) {
-    return;
-  }
-  if (targetReal.startsWith(rootReal + sep)) {
-    return;
-  }
-  throw new MountError(
-    "MOUNT_PATH_ESCAPE",
-    `path escapes mount root: ${targetReal} is not under ${rootReal}`
-  );
-}
-
-// src/mount-fuse-protocol.ts
-var FUSE_KERNEL_VERSION = 7;
-var FUSE_KERNEL_MINOR_VERSION = 31;
-var FUSE_OP = {
-  LOOKUP: 1,
-  FORGET: 2,
-  GETATTR: 3,
-  SETATTR: 4,
-  READLINK: 5,
-  SYMLINK: 6,
-  MKDIR: 9,
-  UNLINK: 10,
-  RMDIR: 11,
-  RENAME: 12,
-  LINK: 13,
-  OPEN: 14,
-  READ: 15,
-  WRITE: 16,
-  STATFS: 17,
-  RELEASE: 18,
-  FSYNC: 20,
-  SETXATTR: 21,
-  GETXATTR: 22,
-  LISTXATTR: 23,
-  REMOVEXATTR: 24,
-  FLUSH: 25,
-  INIT: 26,
-  OPENDIR: 27,
-  READDIR: 28,
-  RELEASEDIR: 29,
-  FSYNCDIR: 30,
-  GETLK: 31,
-  SETLK: 32,
-  SETLKW: 33,
-  ACCESS: 34,
-  CREATE: 35,
-  INTERRUPT: 36,
-  DESTROY: 38,
-  BATCH_FORGET: 42,
-  FALLOCATE: 43,
-  READDIRPLUS: 44,
-  LSEEK: 46,
-  COPY_FILE_RANGE: 47
-};
-var F_LCK = {
-  RDLCK: 0,
-  WRLCK: 1,
-  UNLCK: 2
-};
-var FUSE_LK_FLAGS = {
-  FLOCK: 1 << 0
-};
-var FATTR = {
-  MODE: 1 << 0,
-  UID: 1 << 1,
-  GID: 1 << 2,
-  SIZE: 1 << 3,
-  ATIME: 1 << 4,
-  MTIME: 1 << 5,
-  FH: 1 << 6,
-  ATIME_NOW: 1 << 7,
-  MTIME_NOW: 1 << 8,
-  LOCKOWNER: 1 << 9,
-  CTIME: 1 << 10
-};
-var FUSE_CAP = {
-  ASYNC_READ: 1 << 0,
-  POSIX_LOCKS: 1 << 1,
-  EXPORT_SUPPORT: 1 << 4,
-  BIG_WRITES: 1 << 5,
-  DONT_MASK: 1 << 6,
-  SPLICE_WRITE: 1 << 7,
-  SPLICE_MOVE: 1 << 8,
-  SPLICE_READ: 1 << 9,
-  FLOCK_LOCKS: 1 << 10,
-  HAS_IOCTL_DIR: 1 << 11,
-  AUTO_INVAL_DATA: 1 << 12,
-  DO_READDIRPLUS: 1 << 13,
-  READDIRPLUS_AUTO: 1 << 14,
-  ASYNC_DIO: 1 << 15,
-  WRITEBACK_CACHE: 1 << 16,
-  NO_OPEN_SUPPORT: 1 << 17,
-  PARALLEL_DIROPS: 1 << 18,
-  HANDLE_KILLPRIV: 1 << 19,
-  POSIX_ACL: 1 << 20,
-  ABORT_ERROR: 1 << 21,
-  MAX_PAGES: 1 << 22,
-  CACHE_SYMLINKS: 1 << 23,
-  NO_OPENDIR_SUPPORT: 1 << 24
-};
-var FUSE_IN_HEADER_SIZE = 40;
-var FUSE_OUT_HEADER_SIZE = 16;
-function readInHeader(buf, offset = 0) {
-  const dv = viewOf(buf, offset, FUSE_IN_HEADER_SIZE);
-  return {
-    len: dv.getUint32(0, true),
-    opcode: dv.getUint32(4, true),
-    unique: dv.getBigUint64(8, true),
-    nodeid: dv.getBigUint64(16, true),
-    uid: dv.getUint32(24, true),
-    gid: dv.getUint32(28, true),
-    pid: dv.getUint32(32, true)
-    // padding at offset 36
-  };
-}
-function writeOutHeader(buf, offset, payloadLen, error, unique) {
-  const dv = viewOf(buf, offset, FUSE_OUT_HEADER_SIZE);
-  dv.setUint32(0, FUSE_OUT_HEADER_SIZE + payloadLen, true);
-  dv.setInt32(4, error, true);
-  dv.setBigUint64(8, unique, true);
-}
-function buildErrorResponse(unique, error) {
-  const buf = new Uint8Array(FUSE_OUT_HEADER_SIZE);
-  writeOutHeader(buf, 0, 0, error, unique);
-  return buf;
-}
-function buildResponse(unique, payload) {
-  const buf = new Uint8Array(FUSE_OUT_HEADER_SIZE + payload.length);
-  writeOutHeader(buf, 0, payload.length, 0, unique);
-  buf.set(payload, FUSE_OUT_HEADER_SIZE);
-  return buf;
-}
-var FUSE_ATTR_SIZE = 88;
-function writeAttr(buf, offset, a) {
-  const dv = viewOf(buf, offset, FUSE_ATTR_SIZE);
-  dv.setBigUint64(0, a.ino, true);
-  dv.setBigUint64(8, a.size, true);
-  dv.setBigUint64(16, a.blocks, true);
-  dv.setBigUint64(24, a.atime, true);
-  dv.setBigUint64(32, a.mtime, true);
-  dv.setBigUint64(40, a.ctime, true);
-  dv.setUint32(48, a.atimensec, true);
-  dv.setUint32(52, a.mtimensec, true);
-  dv.setUint32(56, a.ctimensec, true);
-  dv.setUint32(60, a.mode, true);
-  dv.setUint32(64, a.nlink, true);
-  dv.setUint32(68, a.uid, true);
-  dv.setUint32(72, a.gid, true);
-  dv.setUint32(76, a.rdev, true);
-  dv.setUint32(80, a.blksize, true);
-  dv.setUint32(84, a.flags, true);
-}
-var FUSE_ENTRY_OUT_SIZE = 40 + FUSE_ATTR_SIZE;
-function buildEntryOut(e) {
-  const buf = new Uint8Array(FUSE_ENTRY_OUT_SIZE);
-  const dv = viewOf(buf, 0, 40);
-  dv.setBigUint64(0, e.nodeid, true);
-  dv.setBigUint64(8, e.generation, true);
-  dv.setBigUint64(16, e.entry_valid, true);
-  dv.setBigUint64(24, e.attr_valid, true);
-  dv.setUint32(32, e.entry_valid_nsec, true);
-  dv.setUint32(36, e.attr_valid_nsec, true);
-  writeAttr(buf, 40, e.attr);
-  return buf;
-}
-var FUSE_ATTR_OUT_SIZE = 16 + FUSE_ATTR_SIZE;
-function buildAttrOut(a) {
-  const buf = new Uint8Array(FUSE_ATTR_OUT_SIZE);
-  const dv = viewOf(buf, 0, 16);
-  dv.setBigUint64(0, a.attr_valid, true);
-  dv.setUint32(8, a.attr_valid_nsec, true);
-  writeAttr(buf, 16, a.attr);
-  return buf;
-}
-var FUSE_KSTATFS_SIZE = 80;
-function buildKstatfs(s) {
-  const buf = new Uint8Array(FUSE_KSTATFS_SIZE);
-  const dv = viewOf(buf, 0, FUSE_KSTATFS_SIZE);
-  dv.setBigUint64(0, s.blocks, true);
-  dv.setBigUint64(8, s.bfree, true);
-  dv.setBigUint64(16, s.bavail, true);
-  dv.setBigUint64(24, s.files, true);
-  dv.setBigUint64(32, s.ffree, true);
-  dv.setUint32(40, s.bsize, true);
-  dv.setUint32(44, s.namelen, true);
-  dv.setUint32(48, s.frsize, true);
-  return buf;
-}
-var FUSE_INIT_OUT_SIZE = 64;
-function readInitIn(buf, offset = 0) {
-  const dv = viewOf(buf, offset, Math.min(buf.length - offset, 24));
-  const major = dv.getUint32(0, true);
-  const minor = dv.getUint32(4, true);
-  const hasExtended = buf.length - offset >= 20;
-  return {
-    major,
-    minor,
-    max_readahead: hasExtended ? dv.getUint32(8, true) : 0,
-    flags: hasExtended ? dv.getUint32(12, true) : 0,
-    flags2: hasExtended && dv.byteLength >= 20 ? dv.getUint32(16, true) : 0
-  };
-}
-function buildInitOut(o) {
-  const buf = new Uint8Array(FUSE_INIT_OUT_SIZE);
-  const dv = viewOf(buf, 0, FUSE_INIT_OUT_SIZE);
-  dv.setUint32(0, o.major, true);
-  dv.setUint32(4, o.minor, true);
-  dv.setUint32(8, o.max_readahead, true);
-  dv.setUint32(12, o.flags, true);
-  dv.setUint16(16, o.max_background, true);
-  dv.setUint16(18, o.congestion_threshold, true);
-  dv.setUint32(20, o.max_write, true);
-  dv.setUint32(24, o.time_gran, true);
-  dv.setUint16(28, o.max_pages, true);
-  dv.setUint16(30, o.map_alignment, true);
-  dv.setUint32(32, o.flags2, true);
-  return buf;
-}
-function readForgetIn(buf, offset = 0) {
-  const dv = viewOf(buf, offset, 8);
-  return { nlookup: dv.getBigUint64(0, true) };
-}
-function readBatchForgetIn(buf, offset = 0) {
-  const dv = viewOf(buf, offset, 8);
-  const count = dv.getUint32(0, true);
-  const entries = [];
-  for (let i = 0; i < count; i++) {
-    const entryOffset = offset + 8 + i * 16;
-    const entryDv = viewOf(buf, entryOffset, 16);
-    entries.push({
-      nodeid: entryDv.getBigUint64(0, true),
-      nlookup: entryDv.getBigUint64(8, true)
-    });
-  }
-  return { count, entries };
-}
-function readOpenIn(buf, offset = 0) {
-  const dv = viewOf(buf, offset, 8);
-  return {
-    flags: dv.getUint32(0, true),
-    open_flags: dv.getUint32(4, true)
-  };
-}
-function buildOpenOut(o) {
-  const buf = new Uint8Array(16);
-  const dv = viewOf(buf, 0, 16);
-  dv.setBigUint64(0, o.fh, true);
-  dv.setUint32(8, o.open_flags, true);
-  return buf;
-}
-function readReadIn(buf, off = 0) {
-  const dv = viewOf(buf, off, 40);
-  return {
-    fh: dv.getBigUint64(0, true),
-    offset: dv.getBigUint64(8, true),
-    size: dv.getUint32(16, true),
-    read_flags: dv.getUint32(20, true),
-    lock_owner: dv.getBigUint64(24, true),
-    flags: dv.getUint32(32, true)
-    // padding at 36
-  };
-}
-function readReleaseIn(buf, offset = 0) {
-  const dv = viewOf(buf, offset, 24);
-  return {
-    fh: dv.getBigUint64(0, true),
-    flags: dv.getUint32(8, true),
-    release_flags: dv.getUint32(12, true),
-    lock_owner: dv.getBigUint64(16, true)
-  };
-}
-function buildDirent(params) {
-  const nameBytes = new TextEncoder().encode(params.name);
-  const paddedNameLen = nameBytes.length + 7 & ~7;
-  const buf = new Uint8Array(24 + paddedNameLen);
-  const dv = viewOf(buf, 0, 24);
-  dv.setBigUint64(0, params.ino, true);
-  dv.setBigUint64(8, params.off, true);
-  dv.setUint32(16, nameBytes.length, true);
-  dv.setUint32(20, params.type, true);
-  buf.set(nameBytes, 24);
-  return buf;
-}
-var DT = {
-  UNKNOWN: 0,
-  FIFO: 1,
-  CHR: 2,
-  DIR: 4,
-  BLK: 6,
-  REG: 8,
-  LNK: 10,
-  SOCK: 12
-};
-var FUSE_WRITE_IN_SIZE = 40;
-function readWriteIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_WRITE_IN_SIZE);
-  return {
-    fh: dv.getBigUint64(0, true),
-    offset: dv.getBigUint64(8, true),
-    size: dv.getUint32(16, true),
-    write_flags: dv.getUint32(20, true),
-    lock_owner: dv.getBigUint64(24, true),
-    flags: dv.getUint32(32, true)
-    // padding at 36
-  };
-}
-function buildWriteOut(o) {
-  const buf = new Uint8Array(8);
-  const dv = viewOf(buf, 0, 8);
-  dv.setUint32(0, o.size, true);
-  return buf;
-}
-var FUSE_CREATE_IN_SIZE = 16;
-function readCreateIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_CREATE_IN_SIZE);
-  return {
-    flags: dv.getUint32(0, true),
-    mode: dv.getUint32(4, true),
-    umask: dv.getUint32(8, true),
-    open_flags: dv.getUint32(12, true)
-  };
-}
-function buildCreateOut(entry, open) {
-  const entryBuf = buildEntryOut(entry);
-  const openBuf = buildOpenOut(open);
-  const out = new Uint8Array(entryBuf.length + openBuf.length);
-  out.set(entryBuf, 0);
-  out.set(openBuf, entryBuf.length);
-  return out;
-}
-var FUSE_SETATTR_IN_SIZE = 88;
-function readSetattrIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_SETATTR_IN_SIZE);
-  return {
-    valid: dv.getUint32(0, true),
-    // padding at 4
-    fh: dv.getBigUint64(8, true),
-    size: dv.getBigUint64(16, true),
-    lock_owner: dv.getBigUint64(24, true),
-    atime: dv.getBigUint64(32, true),
-    mtime: dv.getBigUint64(40, true),
-    ctime: dv.getBigUint64(48, true),
-    atimensec: dv.getUint32(56, true),
-    mtimensec: dv.getUint32(60, true),
-    ctimensec: dv.getUint32(64, true),
-    mode: dv.getUint32(68, true),
-    // unused4 at 72
-    uid: dv.getUint32(76, true),
-    gid: dv.getUint32(80, true)
-    // unused5 at 84
-  };
-}
-var FUSE_MKDIR_IN_SIZE = 8;
-function readMkdirIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_MKDIR_IN_SIZE);
-  return {
-    mode: dv.getUint32(0, true),
-    umask: dv.getUint32(4, true)
-  };
-}
-var FUSE_LINK_IN_SIZE = 8;
-function readLinkIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_LINK_IN_SIZE);
-  return {
-    oldnodeid: dv.getBigUint64(0, true)
-  };
-}
-var FUSE_FALLOCATE_IN_SIZE = 32;
-function readFallocateIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_FALLOCATE_IN_SIZE);
-  return {
-    fh: dv.getBigUint64(0, true),
-    offset: dv.getBigUint64(8, true),
-    length: dv.getBigUint64(16, true),
-    mode: dv.getUint32(24, true)
-    // padding at 28
-  };
-}
-var FALLOC_FL = {
-  KEEP_SIZE: 1,
-  PUNCH_HOLE: 2,
-  COLLAPSE_RANGE: 8,
-  ZERO_RANGE: 16,
-  INSERT_RANGE: 32
-};
-var FUSE_LSEEK_IN_SIZE = 24;
-function readLseekIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_LSEEK_IN_SIZE);
-  return {
-    fh: dv.getBigUint64(0, true),
-    offset: dv.getBigUint64(8, true),
-    whence: dv.getUint32(16, true)
-    // padding at 20
-  };
-}
-function buildLseekOut(o) {
-  const buf = new Uint8Array(8);
-  new DataView(buf.buffer).setBigUint64(0, o.offset, true);
-  return buf;
-}
-var SEEK = {
-  SET: 0,
-  CUR: 1,
-  END: 2,
-  DATA: 3,
-  HOLE: 4
-};
-var FUSE_COPY_FILE_RANGE_IN_SIZE = 56;
-function readCopyFileRangeIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_COPY_FILE_RANGE_IN_SIZE);
-  return {
-    fh_in: dv.getBigUint64(0, true),
-    off_in: dv.getBigUint64(8, true),
-    nodeid_out: dv.getBigUint64(16, true),
-    fh_out: dv.getBigUint64(24, true),
-    off_out: dv.getBigUint64(32, true),
-    len: dv.getBigUint64(40, true),
-    flags: dv.getBigUint64(48, true)
-  };
-}
-var FUSE_RENAME_IN_SIZE = 8;
-function readRenameIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_RENAME_IN_SIZE);
-  return {
-    newdir: dv.getBigUint64(0, true)
-  };
-}
-var FUSE_FILE_LOCK_SIZE = 24;
-function readFileLock(buf, offset) {
-  const dv = viewOf(buf, offset, FUSE_FILE_LOCK_SIZE);
-  return {
-    start: dv.getBigUint64(0, true),
-    end: dv.getBigUint64(8, true),
-    type: dv.getUint32(16, true),
-    pid: dv.getUint32(20, true)
-  };
-}
-function writeFileLock(buf, offset, lk) {
-  const dv = viewOf(buf, offset, FUSE_FILE_LOCK_SIZE);
-  dv.setBigUint64(0, lk.start, true);
-  dv.setBigUint64(8, lk.end, true);
-  dv.setUint32(16, lk.type, true);
-  dv.setUint32(20, lk.pid, true);
-}
-var FUSE_LK_IN_SIZE = 48;
-function readLkIn(buf, offset = 0) {
-  const dv = viewOf(buf, offset, FUSE_LK_IN_SIZE);
-  return {
-    fh: dv.getBigUint64(0, true),
-    owner: dv.getBigUint64(8, true),
-    lk: readFileLock(buf, offset + 16),
-    lk_flags: dv.getUint32(40, true)
-    // padding at offset 44
-  };
-}
-var FUSE_LK_OUT_SIZE = FUSE_FILE_LOCK_SIZE;
-function buildLkOut(lk) {
-  const buf = new Uint8Array(FUSE_LK_OUT_SIZE);
-  writeFileLock(buf, 0, lk);
-  return buf;
-}
-var FUSE_SETXATTR_IN_SIZE = 8;
-function readSetxattrIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_SETXATTR_IN_SIZE);
-  return {
-    size: dv.getUint32(0, true),
-    flags: dv.getUint32(4, true)
-  };
-}
-var XATTR = {
-  CREATE: 1,
-  REPLACE: 2
-};
-var FUSE_GETXATTR_IN_SIZE = 8;
-function readGetxattrIn(buf, off = 0) {
-  const dv = viewOf(buf, off, FUSE_GETXATTR_IN_SIZE);
-  return {
-    size: dv.getUint32(0, true)
-    // padding at offset 4
-  };
-}
-var FUSE_GETXATTR_OUT_SIZE = 8;
-function buildGetxattrOut(size) {
-  const buf = new Uint8Array(FUSE_GETXATTR_OUT_SIZE);
-  new DataView(buf.buffer).setUint32(0, size, true);
-  return buf;
-}
-function viewOf(buf, offset, len) {
-  if (offset < 0 || len < 0 || offset + len > buf.length) {
-    throw new Error(
-      `FUSE buffer underflow: need ${len} bytes at offset ${offset}, have ${buf.length}`
-    );
-  }
-  return new DataView(buf.buffer, buf.byteOffset + offset, len);
-}
-function payloadOf(message) {
-  if (message.length < FUSE_IN_HEADER_SIZE) {
-    throw new Error(`FUSE message too short: ${message.length} < header ${FUSE_IN_HEADER_SIZE}`);
-  }
-  return message.subarray(FUSE_IN_HEADER_SIZE);
-}
-
-// src/mount-server.ts
-var execFile = promisify(execFileCb);
-var log = debug("machinen:mount-server");
-var ERRNO = {
-  EPERM: 1,
-  ENOENT: 2,
-  EINTR: 4,
-  EIO: 5,
-  ENXIO: 6,
-  EBADF: 9,
-  EAGAIN: 11,
-  EACCES: 13,
-  EBUSY: 16,
-  EEXIST: 17,
-  ENOTDIR: 20,
-  EISDIR: 21,
-  EINVAL: 22,
-  ERANGE: 34,
-  EROFS: 30,
-  ENOSYS: 38,
-  ENOTEMPTY: 39,
-  // "Attribute not found" — Linux errno for getxattr/removexattr on a
-  // name that doesn't exist. macOS calls the same condition ENOATTR
-  // (errno 93) and our shell-out translates it to ENODATA on the wire.
-  ENODATA: 61,
-  // ENOTSUP / EOPNOTSUPP share value 95 on Linux. Some macOS-host
-  // ops (lchmod on filesystems without symlink-mode support, lutimes
-  // on older APFS) throw ENOTSUP; pass it through verbatim so tar
-  // and friends see a soft failure rather than the EIO catch-all.
-  ENOTSUP: 95,
-  ESTALE: 116
-};
-async function serveLiveMount(udsPath, opts) {
-  const state = createState(opts.rootAbs, opts.mode ?? "rw");
-  const server = createServer((sock) => void handleConnection(sock, state));
-  await new Promise((done, fail) => {
-    server.once("error", fail);
-    server.listen(udsPath, () => {
-      server.off("error", fail);
-      done();
-    });
-  });
-  log("listening udsPath=%s rootAbs=%s mode=%s", udsPath, opts.rootAbs, state.mode);
-  return {
-    stop: () => shutdown(server, state),
-    bytesServedOnPagesImg: () => state.bytesServedOnPagesImg
-  };
-}
-function createState(rootAbs, mode) {
-  const inodes = /* @__PURE__ */ new Map();
-  inodes.set(1n, { relPath: "", nlookup: Number.POSITIVE_INFINITY });
-  return {
-    rootAbs,
-    mode,
-    inodes,
-    nextInode: 2n,
-    handles: /* @__PURE__ */ new Map(),
-    nextHandle: 1n,
-    socket: null,
-    bytesServedOnPagesImg: 0,
-    locks: /* @__PURE__ */ new Map(),
-    lockWaiters: []
-  };
-}
-var PAGES_IMG_RE = /(?:^|\/)pages-\d+\.img$/;
-function isPagesImgPath(relPath) {
-  return PAGES_IMG_RE.test(relPath);
-}
-async function shutdown(server, state) {
-  state.socket?.destroy();
-  state.socket = null;
-  for (const [, entry] of state.handles) {
-    if (entry.kind === "file") {
-      await entry.fh.close().catch(() => {
-      });
-    }
-  }
-  state.handles.clear();
-  cancelAllWaiters(state);
-  state.locks.clear();
-  await new Promise((done) => server.close(() => done()));
-}
-async function handleConnection(sock, state) {
-  if (state.socket) {
-    sock.destroy();
-    return;
-  }
-  state.socket = sock;
-  sock.on("close", () => {
-    state.socket = null;
-    cancelAllWaiters(state);
-    state.locks.clear();
-  });
-  sock.on("error", (err) => log("socket error: %s", err.message));
-  try {
-    for await (const msg of readFrames(sock)) {
-      void dispatch(msg, state, sock);
-    }
-  } catch (err) {
-    log("frame read error: %s", err.message);
-    sock.destroy();
-  }
-}
-async function* readFrames(sock) {
-  let pending = Buffer.alloc(0);
-  for await (const chunk of sock) {
-    pending = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, chunk]);
-    while (pending.length >= 4) {
-      const len = pending.readUInt32LE(0);
-      if (len < FUSE_IN_HEADER_SIZE) {
-        throw new Error(`FUSE framing: len ${len} below header size ${FUSE_IN_HEADER_SIZE}`);
-      }
-      if (pending.length < len) {
-        break;
-      }
-      yield new Uint8Array(pending.buffer, pending.byteOffset, len).slice();
-      pending = pending.subarray(len);
-    }
-  }
-  if (pending.length > 0) {
-    throw new Error(`FUSE framing: ${pending.length} trailing bytes after EOF`);
-  }
-}
-async function dispatch(msg, state, sock) {
-  const hdr = readInHeader(msg);
-  log("op=%d nodeid=%s unique=%s len=%d", hdr.opcode, hdr.nodeid, hdr.unique, hdr.len);
-  let reply;
-  try {
-    reply = await handle(hdr, msg, state);
-  } catch (err) {
-    const errno = mapErrorToErrno(err);
-    log("op=%d \u2192 errno %d (%s)", hdr.opcode, errno, err.message);
-    reply = buildErrorResponse(hdr.unique, errno);
-  }
-  if (reply && !sock.destroyed) {
-    sock.write(reply);
-  }
-}
-async function handle(hdr, msg, state) {
-  switch (hdr.opcode) {
-    case FUSE_OP.INIT:
-      return onInit(hdr, msg);
-    case FUSE_OP.DESTROY:
-      return buildErrorResponse(hdr.unique, 0);
-    case FUSE_OP.INTERRUPT:
-      return null;
-    // no reply ever
-    case FUSE_OP.FORGET:
-      onForget(hdr, msg, state);
-      return null;
-    case FUSE_OP.BATCH_FORGET:
-      onBatchForget(msg, state);
-      return null;
-    case FUSE_OP.LOOKUP:
-      return await onLookup(hdr, msg, state);
-    case FUSE_OP.GETATTR:
-      return await onGetattr(hdr, state);
-    case FUSE_OP.READLINK:
-      return await onReadlink(hdr, state);
-    case FUSE_OP.SYMLINK:
-      return await onSymlink(hdr, msg, state);
-    case FUSE_OP.LINK:
-      return await onLink(hdr, msg, state);
-    case FUSE_OP.SETATTR:
-      return await onSetattr(hdr, msg, state);
-    case FUSE_OP.STATFS:
-      return await onStatfs(hdr, state);
-    case FUSE_OP.OPEN:
-      return await onOpen(hdr, msg, state);
-    case FUSE_OP.READ:
-      return await onRead(hdr, msg, state);
-    case FUSE_OP.WRITE:
-      return await onWrite(hdr, msg, state);
-    case FUSE_OP.CREATE:
-      return await onCreate(hdr, msg, state);
-    case FUSE_OP.MKDIR:
-      return await onMkdir(hdr, msg, state);
-    case FUSE_OP.RMDIR:
-      return await onRmdir(hdr, msg, state);
-    case FUSE_OP.UNLINK:
-      return await onUnlink(hdr, msg, state);
-    case FUSE_OP.RENAME:
-      return await onRename(hdr, msg, state);
-    case FUSE_OP.RELEASE:
-      return await onRelease(hdr, msg, state);
-    case FUSE_OP.OPENDIR:
-      return await onOpendir(hdr, state);
-    case FUSE_OP.READDIR:
-      return await onReaddir(hdr, msg, state);
-    case FUSE_OP.RELEASEDIR:
-      return onReleasedir(hdr, msg, state);
-    case FUSE_OP.FSYNC:
-      return await onFsync(hdr, msg, state);
-    case FUSE_OP.FSYNCDIR:
-      return await onFsyncdir(hdr, msg, state);
-    case FUSE_OP.FALLOCATE:
-      return await onFallocate(hdr, msg, state);
-    case FUSE_OP.LSEEK:
-      return await onLseek(hdr, msg, state);
-    case FUSE_OP.COPY_FILE_RANGE:
-      return await onCopyFileRange(hdr, msg, state);
-    case FUSE_OP.SETXATTR:
-      return await onSetxattr(hdr, msg, state);
-    case FUSE_OP.GETXATTR:
-      return await onGetxattr(hdr, msg, state);
-    case FUSE_OP.LISTXATTR:
-      return await onListxattr(hdr, msg, state);
-    case FUSE_OP.REMOVEXATTR:
-      return await onRemovexattr(hdr, msg, state);
-    case FUSE_OP.GETLK:
-      return onGetlk(hdr, msg, state);
-    case FUSE_OP.SETLK:
-      return onSetlk(hdr, msg, state);
-    case FUSE_OP.SETLKW:
-      return await onSetlkw(hdr, msg, state);
-    case FUSE_OP.FLUSH:
-    case FUSE_OP.ACCESS:
-      return buildErrorResponse(hdr.unique, 0);
-    default:
-      return buildErrorResponse(hdr.unique, -ERRNO.ENOSYS);
-  }
-}
-function onInit(hdr, msg) {
-  const init = readInitIn(payloadOf(msg));
-  const minor = Math.min(init.minor, FUSE_KERNEL_MINOR_VERSION);
-  const supported = FUSE_CAP.ASYNC_READ | FUSE_CAP.BIG_WRITES | FUSE_CAP.EXPORT_SUPPORT | FUSE_CAP.MAX_PAGES | FUSE_CAP.PARALLEL_DIROPS | FUSE_CAP.POSIX_LOCKS;
-  const flags = init.flags & supported;
-  const out = buildInitOut({
-    major: FUSE_KERNEL_VERSION,
-    minor,
-    max_readahead: init.max_readahead,
-    flags,
-    max_background: 16,
-    congestion_threshold: 12,
-    max_write: 131072,
-    time_gran: 1,
-    max_pages: 32,
-    // 128 KiB / 4 KiB page
-    map_alignment: 0,
-    flags2: 0
-  });
-  return buildResponse(hdr.unique, out);
-}
-function onForget(hdr, msg, state) {
-  const { nlookup } = readForgetIn(payloadOf(msg));
-  decrefInode(state, hdr.nodeid, Number(nlookup));
-}
-function onBatchForget(msg, state) {
-  const { entries } = readBatchForgetIn(payloadOf(msg));
-  for (const e of entries) {
-    decrefInode(state, e.nodeid, Number(e.nlookup));
-  }
-}
-async function onLookup(hdr, msg, state) {
-  const body = payloadOf(msg);
-  const name = decodeName(body);
-  validateName(name);
-  const parent = requireInode(state, hdr.nodeid);
-  const parentAbs = await absPathForTraversal(state, parent);
-  const childAbs = join2(parentAbs, name);
-  const childRel = joinRel(parent.relPath, name);
-  const st = await lstat(childAbs);
-  const ino = bindInode(state, childRel);
-  return buildResponse(
-    hdr.unique,
-    buildEntryOut({
-      nodeid: ino,
-      generation: 0n,
-      entry_valid: 1n,
-      attr_valid: 1n,
-      entry_valid_nsec: 0,
-      attr_valid_nsec: 0,
-      attr: statToAttr(st, ino)
-    })
-  );
-}
-async function onGetattr(hdr, state) {
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  const st = await lstat(abs);
-  return buildResponse(
-    hdr.unique,
-    buildAttrOut({
-      attr_valid: 1n,
-      attr_valid_nsec: 0,
-      attr: statToAttr(st, hdr.nodeid)
-    })
-  );
-}
-async function onReadlink(hdr, state) {
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  const target = await readlink(abs);
-  return buildResponse(hdr.unique, new TextEncoder().encode(target));
-}
-async function onStatfs(hdr, state) {
-  try {
-    const s = await statfs(state.rootAbs);
-    return buildResponse(
-      hdr.unique,
-      buildKstatfs({
-        blocks: BigInt(s.blocks),
-        bfree: BigInt(s.bfree),
-        bavail: BigInt(s.bavail),
-        files: BigInt(s.files),
-        ffree: BigInt(s.ffree),
-        bsize: s.bsize,
-        namelen: 255,
-        frsize: s.bsize
-      })
-    );
-  } catch {
-    return buildResponse(
-      hdr.unique,
-      buildKstatfs({
-        blocks: 1000000n,
-        bfree: 500000n,
-        bavail: 500000n,
-        files: 100000n,
-        ffree: 99000n,
-        bsize: 4096,
-        namelen: 255,
-        frsize: 4096
-      })
-    );
-  }
-}
-async function onOpen(hdr, msg, state) {
-  const req = readOpenIn(payloadOf(msg));
-  const accessMode = req.flags & 3;
-  if (accessMode !== 0 && state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForTraversal(state, entry);
-  const fh = await fsOpen(abs, linuxOpenFlagsToNode(req.flags));
-  const id = state.nextHandle++;
-  state.handles.set(id, {
-    kind: "file",
-    fh,
-    lazyPagesContrib: isPagesImgPath(entry.relPath),
-    nodeid: hdr.nodeid
-  });
-  return buildResponse(hdr.unique, buildOpenOut({ fh: id, open_flags: 0 }));
-}
-async function onRead(hdr, msg, state) {
-  const req = readReadIn(payloadOf(msg));
-  const handle2 = state.handles.get(req.fh);
-  if (!handle2 || handle2.kind !== "file") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  const buf = Buffer.alloc(req.size);
-  const { bytesRead } = await handle2.fh.read(buf, 0, req.size, Number(req.offset));
-  if (handle2.lazyPagesContrib && bytesRead > 0) {
-    state.bytesServedOnPagesImg += bytesRead;
-  }
-  return buildResponse(hdr.unique, new Uint8Array(buf.buffer, buf.byteOffset, bytesRead));
-}
-async function onRelease(hdr, msg, state) {
-  const rel = readReleaseIn(payloadOf(msg));
-  const entry = state.handles.get(rel.fh);
-  if (entry && entry.kind === "file") {
-    state.handles.delete(rel.fh);
-    dropLocksFor(state, entry.nodeid, rel.lock_owner);
-    await entry.fh.close().catch(() => {
-    });
-  }
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onOpendir(hdr, state) {
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForTraversal(state, entry);
-  const names = await readdir(abs);
-  const packed = [];
-  for (const name of names) {
-    try {
-      const st = await lstat(join2(abs, name));
-      packed.push(
-        buildDirent({
-          // ino in READDIR is informational. We use the host ino so
-          // the kernel can short-circuit LOOKUPs; if the guest does
-          // LOOKUP anyway we'll allocate our own then.
-          ino: BigInt(st.ino),
-          off: BigInt(packed.length + 1),
-          type: modeToDT(st.mode),
-          name
-        })
-      );
-    } catch (err) {
-      log("opendir: skip %s: %s", name, err.message);
-    }
-  }
-  const id = state.nextHandle++;
-  state.handles.set(id, { kind: "dir", entries: packed });
-  return buildResponse(hdr.unique, buildOpenOut({ fh: id, open_flags: 0 }));
-}
-async function onReaddir(hdr, msg, state) {
-  const req = readReadIn(payloadOf(msg));
-  const entry = state.handles.get(req.fh);
-  if (!entry || entry.kind !== "dir") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  const startIdx = Number(req.offset);
-  let total = 0;
-  const picked = [];
-  for (let i = startIdx; i < entry.entries.length; i++) {
-    const e = entry.entries[i];
-    if (total + e.length > req.size) {
-      break;
-    }
-    picked.push(e);
-    total += e.length;
-  }
-  const payload = concatBuffers(picked, total);
-  return buildResponse(hdr.unique, payload);
-}
-function onReleasedir(hdr, msg, state) {
-  const { fh } = readReleaseIn(payloadOf(msg));
-  state.handles.delete(fh);
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onWrite(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const req = readWriteIn(body);
-  const data = body.subarray(FUSE_WRITE_IN_SIZE, FUSE_WRITE_IN_SIZE + req.size);
-  const handle2 = state.handles.get(req.fh);
-  if (!handle2 || handle2.kind !== "file") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  const buf = Buffer.from(data.buffer, data.byteOffset, data.length);
-  const { bytesWritten } = await handle2.fh.write(buf, 0, data.length, Number(req.offset));
-  return buildResponse(hdr.unique, buildWriteOut({ size: bytesWritten }));
-}
-async function onCreate(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const req = readCreateIn(body);
-  const name = decodeName(body.subarray(16));
-  validateName(name);
-  const parent = requireInode(state, hdr.nodeid);
-  const parentAbs = await absPathForTraversal(state, parent);
-  const childAbs = join2(parentAbs, name);
-  const childRel = joinRel(parent.relPath, name);
-  const nodeFlags = linuxOpenFlagsToNode(req.flags) | fsConstants.O_CREAT;
-  const fh = await fsOpen(childAbs, nodeFlags, req.mode);
-  const st = await fh.stat();
-  const ino = bindInode(state, childRel);
-  const id = state.nextHandle++;
-  state.handles.set(id, {
-    kind: "file",
-    fh,
-    lazyPagesContrib: isPagesImgPath(childRel),
-    nodeid: ino
-  });
-  return buildResponse(
-    hdr.unique,
-    buildCreateOut(
-      {
-        nodeid: ino,
-        generation: 0n,
-        entry_valid: 1n,
-        attr_valid: 1n,
-        entry_valid_nsec: 0,
-        attr_valid_nsec: 0,
-        attr: statToAttr(st, ino)
-      },
-      { fh: id, open_flags: 0 }
-    )
-  );
-}
-async function onSymlink(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const firstNul = body.indexOf(0);
-  if (firstNul < 0) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const name = decodeName(body.subarray(0, firstNul));
-  validateName(name);
-  const targetEnd = body.indexOf(0, firstNul + 1);
-  const target = decodeName(body.subarray(firstNul + 1, targetEnd < 0 ? body.length : targetEnd));
-  if (target === "" || target.includes("\0")) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const parent = requireInode(state, hdr.nodeid);
-  const parentAbs = await absPathForTraversal(state, parent);
-  const childAbs = join2(parentAbs, name);
-  const childRel = joinRel(parent.relPath, name);
-  await symlink(target, childAbs);
-  const st = await lstat(childAbs);
-  const ino = bindInode(state, childRel);
-  return buildResponse(
-    hdr.unique,
-    buildEntryOut({
-      nodeid: ino,
-      generation: 0n,
-      entry_valid: 1n,
-      attr_valid: 1n,
-      entry_valid_nsec: 0,
-      attr_valid_nsec: 0,
-      attr: statToAttr(st, ino)
-    })
-  );
-}
-async function onLink(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const req = readLinkIn(body);
-  const name = decodeName(body.subarray(8));
-  validateName(name);
-  const oldEntry = requireInode(state, req.oldnodeid);
-  const parent = requireInode(state, hdr.nodeid);
-  const oldAbs = await absPathForLstat(state, oldEntry);
-  const parentAbs = await absPathForTraversal(state, parent);
-  const childAbs = join2(parentAbs, name);
-  const childRel = joinRel(parent.relPath, name);
-  await link(oldAbs, childAbs);
-  const st = await lstat(childAbs);
-  const ino = bindInode(state, childRel);
-  return buildResponse(
-    hdr.unique,
-    buildEntryOut({
-      nodeid: ino,
-      generation: 0n,
-      entry_valid: 1n,
-      attr_valid: 1n,
-      entry_valid_nsec: 0,
-      attr_valid_nsec: 0,
-      attr: statToAttr(st, ino)
-    })
-  );
-}
-async function onMkdir(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const req = readMkdirIn(body);
-  const name = decodeName(body.subarray(8));
-  validateName(name);
-  const parent = requireInode(state, hdr.nodeid);
-  const parentAbs = await absPathForTraversal(state, parent);
-  const childAbs = join2(parentAbs, name);
-  const childRel = joinRel(parent.relPath, name);
-  await mkdir(childAbs, { mode: req.mode & 4095 });
-  const st = await lstat(childAbs);
-  const ino = bindInode(state, childRel);
-  return buildResponse(
-    hdr.unique,
-    buildEntryOut({
-      nodeid: ino,
-      generation: 0n,
-      entry_valid: 1n,
-      attr_valid: 1n,
-      entry_valid_nsec: 0,
-      attr_valid_nsec: 0,
-      attr: statToAttr(st, ino)
-    })
-  );
-}
-async function onRmdir(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const name = decodeName(payloadOf(msg));
-  validateName(name);
-  const parent = requireInode(state, hdr.nodeid);
-  const parentAbs = await absPathForTraversal(state, parent);
-  await rmdir(join2(parentAbs, name));
-  forgetByRelPath(state, joinRel(parent.relPath, name));
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onUnlink(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const name = decodeName(payloadOf(msg));
-  validateName(name);
-  const parent = requireInode(state, hdr.nodeid);
-  const parentAbs = await absPathForTraversal(state, parent);
-  await unlink(join2(parentAbs, name));
-  forgetByRelPath(state, joinRel(parent.relPath, name));
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onRename(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const req = readRenameIn(body);
-  const after = body.subarray(8);
-  const firstNul = after.indexOf(0);
-  if (firstNul < 0) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const oldName = decodeName(after.subarray(0, firstNul));
-  const newName = decodeName(after.subarray(firstNul + 1));
-  validateName(oldName);
-  validateName(newName);
-  const oldParent = requireInode(state, hdr.nodeid);
-  const newParent = requireInode(state, req.newdir);
-  const oldParentAbs = await absPathForTraversal(state, oldParent);
-  const newParentAbs = await absPathForTraversal(state, newParent);
-  await rename(join2(oldParentAbs, oldName), join2(newParentAbs, newName));
-  forgetByRelPath(state, joinRel(oldParent.relPath, oldName));
-  forgetByRelPath(state, joinRel(newParent.relPath, newName));
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onSetattr(hdr, msg, state) {
-  const req = readSetattrIn(payloadOf(msg));
-  const isMutating = (req.valid & (FATTR.MODE | FATTR.SIZE | FATTR.ATIME | FATTR.MTIME | FATTR.CTIME | FATTR.ATIME_NOW | FATTR.MTIME_NOW | FATTR.UID | FATTR.GID)) !== 0;
-  if (isMutating && state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  const st0 = await lstat(abs);
-  const isSymlink = (st0.mode & 61440) === 40960;
-  if (req.valid & FATTR.SIZE) {
-    if (isSymlink) {
-      return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-    }
-    if (req.valid & FATTR.FH) {
-      const handle2 = state.handles.get(req.fh);
-      if (!handle2 || handle2.kind !== "file") {
-        return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-      }
-      await handle2.fh.truncate(Number(req.size));
-    } else {
-      await truncate(abs, Number(req.size));
-    }
-  }
-  if (req.valid & FATTR.MODE) {
-    const mode = req.mode & 4095;
-    if (isSymlink) {
-      try {
-        await lchmod(abs, mode);
-      } catch (err) {
-        if (!isUnsupportedFsErr(err)) {
-          throw err;
-        }
-      }
-    } else {
-      await chmod(abs, mode);
-    }
-  }
-  if (req.valid & (FATTR.ATIME | FATTR.MTIME | FATTR.ATIME_NOW | FATTR.MTIME_NOW)) {
-    const now = Date.now() / 1e3;
-    const a = req.valid & FATTR.ATIME_NOW ? now : req.valid & FATTR.ATIME ? Number(req.atime) + req.atimensec / 1e9 : st0.atimeMs / 1e3;
-    const m = req.valid & FATTR.MTIME_NOW ? now : req.valid & FATTR.MTIME ? Number(req.mtime) + req.mtimensec / 1e9 : st0.mtimeMs / 1e3;
-    if (isSymlink) {
-      await lutimes(abs, a, m);
-    } else {
-      await utimes(abs, a, m);
-    }
-  }
-  if (req.valid & (FATTR.UID | FATTR.GID)) {
-    if (isSymlink) {
-      try {
-        await lchown(abs, req.uid, req.gid);
-      } catch (err) {
-        const code = err.code;
-        if (code !== "EPERM" && code !== "ENOSYS" && !isUnsupportedFsErr(err)) {
-          throw err;
-        }
-      }
-    }
-  }
-  const st = await lstat(abs);
-  return buildResponse(
-    hdr.unique,
-    buildAttrOut({
-      attr_valid: 1n,
-      attr_valid_nsec: 0,
-      attr: statToAttr(st, hdr.nodeid)
-    })
-  );
-}
-function isUnsupportedFsErr(err) {
-  const code = err?.code;
-  return code === "ENOTSUP" || code === "EOPNOTSUPP" || code === "ENOSYS";
-}
-async function onFsync(hdr, msg, state) {
-  const body = payloadOf(msg);
-  if (body.length < 8) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const dv = new DataView(body.buffer, body.byteOffset, body.length);
-  const fh = dv.getBigUint64(0, true);
-  const handle2 = state.handles.get(fh);
-  if (!handle2 || handle2.kind !== "file") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  await handle2.fh.sync();
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onFsyncdir(hdr, msg, state) {
-  const body = payloadOf(msg);
-  if (body.length < 8) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const dv = new DataView(body.buffer, body.byteOffset, body.length);
-  const fh = dv.getBigUint64(0, true);
-  const handle2 = state.handles.get(fh);
-  if (!handle2 || handle2.kind !== "dir") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForTraversal(state, entry);
-  const dirFh = await fsOpen(abs, fsConstants.O_RDONLY);
-  try {
-    await dirFh.sync();
-  } finally {
-    await dirFh.close().catch(() => {
-    });
-  }
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onFallocate(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const req = readFallocateIn(payloadOf(msg));
-  const handle2 = state.handles.get(req.fh);
-  if (!handle2 || handle2.kind !== "file") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  const unsupported = FALLOC_FL.PUNCH_HOLE | FALLOC_FL.COLLAPSE_RANGE | FALLOC_FL.ZERO_RANGE | FALLOC_FL.INSERT_RANGE;
-  if (req.mode & unsupported) {
-    return buildErrorResponse(hdr.unique, -ERRNO.ENOSYS);
-  }
-  if (!(req.mode & FALLOC_FL.KEEP_SIZE)) {
-    const target = Number(req.offset + req.length);
-    const st = await handle2.fh.stat();
-    if (target > st.size) {
-      await handle2.fh.truncate(target);
-    }
-  }
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onLseek(hdr, msg, state) {
-  const req = readLseekIn(payloadOf(msg));
-  const handle2 = state.handles.get(req.fh);
-  if (!handle2 || handle2.kind !== "file") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  let resolved;
-  switch (req.whence) {
-    case SEEK.SET:
-      resolved = req.offset;
-      break;
-    case SEEK.CUR:
-      resolved = req.offset;
-      break;
-    case SEEK.END: {
-      const st = await handle2.fh.stat();
-      resolved = BigInt(st.size) + req.offset;
-      break;
-    }
-    case SEEK.HOLE:
-    case SEEK.DATA:
-      return buildErrorResponse(hdr.unique, -ERRNO.ENOSYS);
-    default:
-      return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  if (resolved < 0n) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  return buildResponse(hdr.unique, buildLseekOut({ offset: resolved }));
-}
-var COPY_FILE_RANGE_CHUNK = 1 << 20;
-async function onCopyFileRange(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const req = readCopyFileRangeIn(payloadOf(msg));
-  if (req.flags !== 0n) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const src = state.handles.get(req.fh_in);
-  const dst = state.handles.get(req.fh_out);
-  if (!src || src.kind !== "file" || !dst || dst.kind !== "file") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EBADF);
-  }
-  let copied = 0;
-  let srcOff = Number(req.off_in);
-  let dstOff = Number(req.off_out);
-  const total = Number(req.len);
-  const buf = Buffer.allocUnsafe(Math.min(total, COPY_FILE_RANGE_CHUNK));
-  while (copied < total) {
-    const want = Math.min(total - copied, buf.length);
-    const { bytesRead } = await src.fh.read(buf, 0, want, srcOff);
-    if (bytesRead === 0) {
-      break;
-    }
-    const { bytesWritten } = await dst.fh.write(buf, 0, bytesRead, dstOff);
-    copied += bytesWritten;
-    srcOff += bytesRead;
-    dstOff += bytesWritten;
-    if (bytesWritten < bytesRead) {
-      break;
-    }
-  }
-  return buildResponse(hdr.unique, buildWriteOut({ size: copied }));
-}
-var IS_DARWIN = process.platform === "darwin";
-function isXattrError(e) {
-  return typeof e === "object" && e !== null && "errno" in e && typeof e.errno === "number";
-}
-function decodeXattrStderr(stderr) {
-  if (/no such (xattr|attribute)|no data available/i.test(stderr)) {
-    return ERRNO.ENODATA;
-  }
-  if (/operation not permitted|permission denied/i.test(stderr)) {
-    return ERRNO.EACCES;
-  }
-  if (/not supported|operation not supported/i.test(stderr)) {
-    return ERRNO.ENOTSUP;
-  }
-  if (/file name too long|argument list too long/i.test(stderr)) {
-    return ERRNO.EINVAL;
-  }
-  return ERRNO.EIO;
-}
-function xattrErrorFromExec(err) {
-  const e = err;
-  if (e.code === "ENOENT") {
-    return { errno: ERRNO.ENOTSUP };
-  }
-  const stderr = typeof e.stderr === "string" ? e.stderr : e.stderr?.toString("utf8") ?? "";
-  return { errno: decodeXattrStderr(stderr) };
-}
-async function hostGetxattr(absPath, name) {
-  try {
-    if (IS_DARWIN) {
-      const { stdout: stdout2 } = await execFile("xattr", ["-p", "-s", "-x", name, absPath], {
-        encoding: "utf8"
-      });
-      return Buffer.from(stdout2.replace(/\s+/g, ""), "hex");
-    }
-    const { stdout } = await execFile(
-      "getfattr",
-      ["--no-dereference", "--absolute-names", "--only-values", "-n", name, absPath],
-      { encoding: "buffer" }
-    );
-    return stdout;
-  } catch (err) {
-    const xe = xattrErrorFromExec(err);
-    if (xe.errno === ERRNO.ENODATA) {
-      return null;
-    }
-    throw xe;
-  }
-}
-async function hostXattrExists(absPath, name) {
-  return await hostGetxattr(absPath, name) !== null;
-}
-async function hostSetxattr(absPath, name, value) {
-  try {
-    if (IS_DARWIN) {
-      const hex = Buffer.from(value.buffer, value.byteOffset, value.length).toString("hex");
-      await execFile("xattr", ["-w", "-s", "-x", name, hex, absPath]);
-      return;
-    }
-    const b64 = Buffer.from(value.buffer, value.byteOffset, value.length).toString("base64");
-    await execFile("setfattr", ["--no-dereference", "-n", name, "-v", `0s${b64}`, absPath]);
-  } catch (err) {
-    throw xattrErrorFromExec(err);
-  }
-}
-async function hostListxattr(absPath) {
-  try {
-    if (IS_DARWIN) {
-      const { stdout: stdout2 } = await execFile("xattr", ["-s", absPath], { encoding: "utf8" });
-      return stdout2.split("\n").filter((n) => n.length > 0);
-    }
-    const { stdout } = await execFile(
-      "getfattr",
-      ["--no-dereference", "--absolute-names", "--match=.", absPath],
-      { encoding: "utf8" }
-    );
-    return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
-  } catch (err) {
-    const xe = xattrErrorFromExec(err);
-    if (xe.errno === ERRNO.ENODATA) {
-      return [];
-    }
-    throw xe;
-  }
-}
-async function hostRemovexattr(absPath, name) {
-  try {
-    if (IS_DARWIN) {
-      await execFile("xattr", ["-d", "-s", name, absPath]);
-      return;
-    }
-    await execFile("setfattr", ["--no-dereference", "-x", name, absPath]);
-  } catch (err) {
-    throw xattrErrorFromExec(err);
-  }
-}
-function packListxattrNames(names) {
-  const encoded = names.map((n) => Buffer.from(`${n}\0`, "utf8"));
-  const total = encoded.reduce((sum, b) => sum + b.length, 0);
-  const out = new Uint8Array(total);
-  let cursor = 0;
-  for (const b of encoded) {
-    out.set(b, cursor);
-    cursor += b.length;
-  }
-  return out;
-}
-async function onSetxattr(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const body = payloadOf(msg);
-  const req = readSetxattrIn(body);
-  const after = body.subarray(FUSE_SETXATTR_IN_SIZE);
-  const nulAt = after.indexOf(0);
-  if (nulAt < 0) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const name = new TextDecoder("utf-8", { fatal: false }).decode(after.subarray(0, nulAt));
-  if (name === "" || name.length > 255) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const valueStart = nulAt + 1;
-  if (valueStart + req.size > after.length) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const value = after.subarray(valueStart, valueStart + req.size);
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  if (req.flags & XATTR.CREATE && await hostXattrExists(abs, name)) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EEXIST);
-  }
-  if (req.flags & XATTR.REPLACE && !await hostXattrExists(abs, name)) {
-    return buildErrorResponse(hdr.unique, -ERRNO.ENODATA);
-  }
-  try {
-    await hostSetxattr(abs, name, value);
-  } catch (err) {
-    if (isXattrError(err)) {
-      return buildErrorResponse(hdr.unique, -err.errno);
-    }
-    throw err;
-  }
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onGetxattr(hdr, msg, state) {
-  const body = payloadOf(msg);
-  const req = readGetxattrIn(body);
-  const after = body.subarray(8);
-  const nulAt = after.indexOf(0);
-  if (nulAt < 0) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const name = new TextDecoder("utf-8", { fatal: false }).decode(after.subarray(0, nulAt));
-  if (name === "" || name.length > 255) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  let value;
-  try {
-    value = await hostGetxattr(abs, name);
-  } catch (err) {
-    if (isXattrError(err)) {
-      return buildErrorResponse(hdr.unique, -err.errno);
-    }
-    throw err;
-  }
-  if (value === null) {
-    return buildErrorResponse(hdr.unique, -ERRNO.ENODATA);
-  }
-  if (req.size === 0) {
-    return buildResponse(hdr.unique, buildGetxattrOut(value.length));
-  }
-  if (value.length > req.size) {
-    return buildErrorResponse(hdr.unique, -ERRNO.ERANGE);
-  }
-  return buildResponse(hdr.unique, new Uint8Array(value.buffer, value.byteOffset, value.length));
-}
-async function onListxattr(hdr, msg, state) {
-  const req = readGetxattrIn(payloadOf(msg));
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  let names;
-  try {
-    names = await hostListxattr(abs);
-  } catch (err) {
-    if (isXattrError(err)) {
-      return buildErrorResponse(hdr.unique, -err.errno);
-    }
-    throw err;
-  }
-  const packed = packListxattrNames(names);
-  if (req.size === 0) {
-    return buildResponse(hdr.unique, buildGetxattrOut(packed.length));
-  }
-  if (packed.length > req.size) {
-    return buildErrorResponse(hdr.unique, -ERRNO.ERANGE);
-  }
-  return buildResponse(hdr.unique, packed);
-}
-async function onRemovexattr(hdr, msg, state) {
-  if (state.mode === "ro") {
-    return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
-  }
-  const name = decodeName(payloadOf(msg));
-  if (name === "" || name.length > 255) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForLstat(state, entry);
-  try {
-    await hostRemovexattr(abs, name);
-  } catch (err) {
-    if (isXattrError(err)) {
-      return buildErrorResponse(hdr.unique, -err.errno);
-    }
-    throw err;
-  }
-  return buildErrorResponse(hdr.unique, 0);
-}
-function rangeFromLkIn(lk, owner) {
-  if (lk.type !== F_LCK.RDLCK && lk.type !== F_LCK.WRLCK) {
-    return null;
-  }
-  return { start: lk.start, end: lk.end, type: lk.type, owner, pid: lk.pid };
-}
-function rangesOverlap(a, b) {
-  return a.start <= b.end && b.start <= a.end;
-}
-function findConflict(state, nodeid, req) {
-  const ranges = state.locks.get(nodeid);
-  if (!ranges) {
-    return null;
-  }
-  for (const r of ranges) {
-    if (r.owner === req.owner) {
-      continue;
-    }
-    if (!rangesOverlap(r, req)) {
-      continue;
-    }
-    if (req.type === F_LCK.WRLCK || r.type === F_LCK.WRLCK) {
-      return r;
-    }
-  }
-  return null;
-}
-function addLock(state, nodeid, req) {
-  let ranges = state.locks.get(nodeid);
-  if (!ranges) {
-    ranges = [];
-    state.locks.set(nodeid, ranges);
-  }
-  let merged = { ...req };
-  const kept = [];
-  for (const r of ranges) {
-    if (r.owner !== merged.owner || !rangesOverlap(r, merged)) {
-      kept.push(r);
-      continue;
-    }
-    if (r.type === merged.type) {
-      const start = r.start < merged.start ? r.start : merged.start;
-      const end = r.end > merged.end ? r.end : merged.end;
-      merged = { ...merged, start, end };
-    }
-  }
-  kept.push(merged);
-  state.locks.set(nodeid, kept);
-}
-function removeLockRange(state, nodeid, owner, req) {
-  const ranges = state.locks.get(nodeid);
-  if (!ranges) {
-    return;
-  }
-  const out = [];
-  for (const r of ranges) {
-    if (r.owner !== owner || !rangesOverlap(r, req)) {
-      out.push(r);
-      continue;
-    }
-    if (r.start < req.start) {
-      out.push({ ...r, end: req.start - 1n });
-    }
-    if (r.end > req.end) {
-      out.push({ ...r, start: req.end + 1n });
-    }
-  }
-  if (out.length === 0) {
-    state.locks.delete(nodeid);
-  } else {
-    state.locks.set(nodeid, out);
-  }
-}
-function dropLocksFor(state, nodeid, owner) {
-  const ranges = state.locks.get(nodeid);
-  if (!ranges) {
-    return;
-  }
-  const out = ranges.filter((r) => r.owner !== owner);
-  if (out.length === 0) {
-    state.locks.delete(nodeid);
-  } else {
-    state.locks.set(nodeid, out);
-  }
-  wakeWaiters(state);
-}
-function wakeWaiters(state) {
-  for (; ; ) {
-    const idx = state.lockWaiters.findIndex(
-      (w2) => findConflict(state, w2.nodeid, w2.request) === null
-    );
-    if (idx < 0) {
-      return;
-    }
-    const [w] = state.lockWaiters.splice(idx, 1);
-    if (!w) {
-      return;
-    }
-    addLock(state, w.nodeid, w.request);
-    w.resolve();
-  }
-}
-function cancelAllWaiters(state) {
-  const waiters = state.lockWaiters;
-  state.lockWaiters = [];
-  for (const w of waiters) {
-    w.cancel();
-  }
-}
-function onGetlk(hdr, msg, state) {
-  const req = readLkIn(payloadOf(msg));
-  const probe = rangeFromLkIn(req.lk, req.owner);
-  if (!probe) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  const conflict = findConflict(state, hdr.nodeid, probe);
-  if (!conflict) {
-    return buildResponse(
-      hdr.unique,
-      buildLkOut({ start: req.lk.start, end: req.lk.end, type: F_LCK.UNLCK, pid: 0 })
-    );
-  }
-  return buildResponse(
-    hdr.unique,
-    buildLkOut({
-      start: conflict.start,
-      end: conflict.end,
-      type: conflict.type,
-      pid: conflict.pid
-    })
-  );
-}
-function onSetlk(hdr, msg, state) {
-  const req = readLkIn(payloadOf(msg));
-  if (req.lk.type === F_LCK.UNLCK) {
-    removeLockRange(state, hdr.nodeid, req.owner, { start: req.lk.start, end: req.lk.end });
-    wakeWaiters(state);
-    return buildErrorResponse(hdr.unique, 0);
-  }
-  const want = rangeFromLkIn(req.lk, req.owner);
-  if (!want) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  if (findConflict(state, hdr.nodeid, want)) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EAGAIN);
-  }
-  addLock(state, hdr.nodeid, want);
-  return buildErrorResponse(hdr.unique, 0);
-}
-async function onSetlkw(hdr, msg, state) {
-  const req = readLkIn(payloadOf(msg));
-  if (req.lk.type === F_LCK.UNLCK) {
-    removeLockRange(state, hdr.nodeid, req.owner, { start: req.lk.start, end: req.lk.end });
-    wakeWaiters(state);
-    return buildErrorResponse(hdr.unique, 0);
-  }
-  const want = rangeFromLkIn(req.lk, req.owner);
-  if (!want) {
-    return buildErrorResponse(hdr.unique, -ERRNO.EINVAL);
-  }
-  if (!findConflict(state, hdr.nodeid, want)) {
-    addLock(state, hdr.nodeid, want);
-    return buildErrorResponse(hdr.unique, 0);
-  }
-  return await new Promise((done) => {
-    const waiter = {
-      nodeid: hdr.nodeid,
-      request: want,
-      resolve: () => done(buildErrorResponse(hdr.unique, 0)),
-      cancel: () => done(buildErrorResponse(hdr.unique, -ERRNO.EINTR))
-    };
-    state.lockWaiters.push(waiter);
-  });
-}
-function decodeName(body) {
-  const nulAt = body.indexOf(0);
-  const end = nulAt >= 0 ? nulAt : body.length;
-  return new TextDecoder("utf-8", { fatal: false }).decode(body.subarray(0, end));
-}
-function validateName(name) {
-  if (name === "" || name === "." || name === ".." || name.includes("/") || name.includes("\0")) {
-    const err = new Error(`invalid FUSE name: ${JSON.stringify(name)}`);
-    err.code = "EINVAL";
-    throw err;
-  }
-}
-function joinRel(parentRel, name) {
-  if (parentRel === "") {
-    return name;
-  }
-  return `${parentRel}/${name}`;
-}
-function requireInode(state, ino) {
-  const e = state.inodes.get(ino);
-  if (!e) {
-    const err = new Error(`stale inode ${ino}`);
-    err.code = "ESTALE";
-    throw err;
-  }
-  return e;
-}
-async function absPathForTraversal(state, entry) {
-  if (entry.relPath === "") {
-    return await realpath2(state.rootAbs);
-  }
-  return await resolveUnderRoot(state.rootAbs, entry.relPath);
-}
-async function absPathForLstat(state, entry) {
-  if (entry.relPath === "") {
-    return await realpath2(state.rootAbs);
-  }
-  const slashAt = entry.relPath.lastIndexOf("/");
-  const parentRel = slashAt < 0 ? "" : entry.relPath.slice(0, slashAt);
-  const baseName = slashAt < 0 ? entry.relPath : entry.relPath.slice(slashAt + 1);
-  const parentAbs = parentRel === "" ? await realpath2(state.rootAbs) : await resolveUnderRoot(state.rootAbs, parentRel);
-  return join2(parentAbs, baseName);
-}
-function bindInode(state, relPath) {
-  for (const [ino2, e] of state.inodes) {
-    if (e.relPath === relPath) {
-      if (e.nlookup !== Number.POSITIVE_INFINITY) {
-        e.nlookup++;
-      }
-      return ino2;
-    }
-  }
-  const ino = state.nextInode++;
-  state.inodes.set(ino, { relPath, nlookup: 1 });
-  return ino;
-}
-function decrefInode(state, ino, n) {
-  const e = state.inodes.get(ino);
-  if (!e) {
-    return;
-  }
-  if (e.nlookup === Number.POSITIVE_INFINITY) {
-    return;
-  }
-  e.nlookup -= n;
-  if (e.nlookup <= 0) {
-    state.inodes.delete(ino);
-  }
-}
-function forgetByRelPath(state, relPath) {
-  for (const [ino, e] of state.inodes) {
-    if (e.relPath === relPath) {
-      state.inodes.delete(ino);
-      return;
-    }
-  }
-}
-function linuxOpenFlagsToNode(flags) {
-  const LINUX_O_WRONLY = 1;
-  const LINUX_O_RDWR = 2;
-  const LINUX_O_TRUNC = 512;
-  const LINUX_O_APPEND = 1024;
-  const accessMode = flags & 3;
-  let out;
-  if (accessMode === LINUX_O_WRONLY) {
-    out = fsConstants.O_WRONLY;
-  } else if (accessMode === LINUX_O_RDWR) {
-    out = fsConstants.O_RDWR;
-  } else {
-    out = fsConstants.O_RDONLY;
-  }
-  if (flags & LINUX_O_TRUNC) {
-    out |= fsConstants.O_TRUNC;
-  }
-  if (flags & LINUX_O_APPEND) {
-    out |= fsConstants.O_APPEND;
-  }
-  return out;
-}
-function statToAttr(st, ino) {
-  const atime = BigInt(Math.floor(st.atimeMs / 1e3));
-  const mtime = BigInt(Math.floor(st.mtimeMs / 1e3));
-  const ctime = BigInt(Math.floor(st.ctimeMs / 1e3));
-  return {
-    ino,
-    size: BigInt(st.size),
-    blocks: BigInt(st.blocks ?? 0),
-    atime,
-    mtime,
-    ctime,
-    atimensec: Math.floor(st.atimeMs % 1e3 * 1e6),
-    mtimensec: Math.floor(st.mtimeMs % 1e3 * 1e6),
-    ctimensec: Math.floor(st.ctimeMs % 1e3 * 1e6),
-    mode: st.mode,
-    nlink: st.nlink,
-    uid: st.uid,
-    gid: st.gid,
-    rdev: st.rdev,
-    blksize: st.blksize,
-    flags: 0
-  };
-}
-function modeToDT(mode) {
-  const type = mode & 61440;
-  switch (type) {
-    case 16384:
-      return DT.DIR;
-    case 32768:
-      return DT.REG;
-    case 40960:
-      return DT.LNK;
-    case 8192:
-      return DT.CHR;
-    case 24576:
-      return DT.BLK;
-    case 4096:
-      return DT.FIFO;
-    case 49152:
-      return DT.SOCK;
-    default:
-      return DT.UNKNOWN;
-  }
-}
-function concatBuffers(parts, total) {
-  const out = new Uint8Array(total);
-  let cursor = 0;
-  for (const p of parts) {
-    out.set(p, cursor);
-    cursor += p.length;
-  }
-  return out;
-}
-function mapErrorToErrno(err) {
-  if (isMachinenError(err) && err instanceof MountError) {
-    return -ERRNO.ENOENT;
-  }
-  const code = err?.code;
-  if (!code) {
-    return -ERRNO.EIO;
-  }
-  if (code === "EOPNOTSUPP") {
-    return -ERRNO.ENOTSUP;
-  }
-  const key = code;
-  if (key in ERRNO) {
-    return -ERRNO[key];
-  }
-  return -ERRNO.EIO;
-}
-
-// src/mount-server-bin.ts
-function parseArgs(argv) {
-  const out = {};
-  for (let i = 0; i < argv.length; i++) {
-    const flag = argv[i];
-    const value = argv[i + 1];
-    if (value === void 0) {
-      throw new Error(`missing value for ${flag}`);
-    }
-    switch (flag) {
-      case "--uds":
-        out.uds = value;
-        i++;
-        break;
-      case "--root":
-        out.root = value;
-        i++;
-        break;
-      case "--mode":
-        if (value !== "ro" && value !== "rw") {
-          throw new Error(`--mode must be 'ro' or 'rw' (got '${value}')`);
-        }
-        out.mode = value;
-        i++;
-        break;
-      case "--stats":
-        out.stats = value;
-        i++;
-        break;
-      default:
-        throw new Error(`unknown flag '${flag}'`);
-    }
-  }
-  for (const key of ["uds", "root", "mode", "stats"]) {
-    if (out[key] === void 0) {
-      throw new Error(`missing required --${key}`);
-    }
-  }
-  return out;
-}
-function writeStatsAtomic(path, snapshot) {
-  const tmp = `${path}.tmp.${process.pid}`;
-  writeFileSync(tmp, JSON.stringify(snapshot));
-  renameSync(tmp, path);
-}
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-  const handle2 = await serveLiveMount(args.uds, {
-    rootAbs: args.root,
-    mode: args.mode
-  });
-  writeStatsAtomic(args.stats, {
-    bytesServedOnPagesImg: 0,
-    updatedAtMs: Date.now()
-  });
-  let lastPublished = 0;
-  const ticker = setInterval(() => {
-    const cur = handle2.bytesServedOnPagesImg();
-    if (cur === lastPublished) {
-      return;
-    }
-    lastPublished = cur;
-    try {
-      writeStatsAtomic(args.stats, {
-        bytesServedOnPagesImg: cur,
-        updatedAtMs: Date.now()
-      });
-    } catch {
-    }
-  }, 250);
-  ticker.unref();
-  let shuttingDown = false;
-  const shutdown2 = async (signal) => {
-    if (shuttingDown) {
-      return;
-    }
-    shuttingDown = true;
-    clearInterval(ticker);
-    try {
-      writeStatsAtomic(args.stats, {
-        bytesServedOnPagesImg: handle2.bytesServedOnPagesImg(),
-        updatedAtMs: Date.now()
-      });
-    } catch {
-    }
-    try {
-      await handle2.stop();
-    } catch {
-    }
-    try {
-      unlinkSync(args.stats);
-    } catch {
-    }
-    process.exit(signal === "SIGTERM" ? 0 : 128 + (signalToNumber(signal) ?? 15));
-  };
-  process.on("SIGTERM", () => void shutdown2("SIGTERM"));
-  process.on("SIGINT", () => void shutdown2("SIGINT"));
-  process.on("SIGHUP", () => void shutdown2("SIGHUP"));
-}
-function signalToNumber(signal) {
-  switch (signal) {
-    case "SIGTERM":
-      return 15;
-    case "SIGINT":
-      return 2;
-    case "SIGHUP":
-      return 1;
-    default:
-      return void 0;
-  }
-}
-main().catch((err) => {
-  process.stderr.write(`mount-server-bin: ${err instanceof Error ? err.message : String(err)}
-`);
-  process.exit(1);
-});
-//# sourceMappingURL=mount-server-bin.js.map