@machinen/runtime 0.1.0

package/dist/mount-server-bin.js

@@ -0,0 +1,1341 @@
+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 {
+  chmod,
+  link,
+  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 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,
+  FLUSH: 25,
+  INIT: 26,
+  OPENDIR: 27,
+  READDIR: 28,
+  RELEASEDIR: 29,
+  ACCESS: 34,
+  CREATE: 35,
+  INTERRUPT: 36,
+  DESTROY: 38,
+  BATCH_FORGET: 42,
+  READDIRPLUS: 44
+};
+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_RENAME_IN_SIZE = 8;
+function readRenameIn(buf, off = 0) {
+  const dv = viewOf(buf, off, FUSE_RENAME_IN_SIZE);
+  return {
+    newdir: dv.getBigUint64(0, true)
+  };
+}
+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 log = debug("machinen:mount-server");
+var ERRNO = {
+  EPERM: 1,
+  ENOENT: 2,
+  EIO: 5,
+  EBADF: 9,
+  EACCES: 13,
+  EBUSY: 16,
+  EEXIST: 17,
+  ENOTDIR: 20,
+  EISDIR: 21,
+  EINVAL: 22,
+  EROFS: 30,
+  ENOSYS: 38,
+  ENOTEMPTY: 39,
+  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
+  };
+}
+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();
+  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;
+  });
+  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.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;
+  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)
+  });
+  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 { fh } = readReleaseIn(payloadOf(msg));
+  const entry = state.handles.get(fh);
+  if (entry && entry.kind === "file") {
+    state.handles.delete(fh);
+    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)
+  });
+  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 absPathForTraversal(state, entry);
+  if (req.valid & FATTR.SIZE) {
+    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) {
+    await chmod(abs, req.mode & 4095);
+  }
+  if (req.valid & (FATTR.ATIME | FATTR.MTIME | FATTR.ATIME_NOW | FATTR.MTIME_NOW)) {
+    const st2 = await lstat(abs);
+    const now = Date.now() / 1e3;
+    const a = req.valid & FATTR.ATIME_NOW ? now : req.valid & FATTR.ATIME ? Number(req.atime) + req.atimensec / 1e9 : st2.atimeMs / 1e3;
+    const m = req.valid & FATTR.MTIME_NOW ? now : req.valid & FATTR.MTIME ? Number(req.mtime) + req.mtimensec / 1e9 : st2.mtimeMs / 1e3;
+    await utimes(abs, a, m);
+  }
+  const st = await lstat(abs);
+  return buildResponse(
+    hdr.unique,
+    buildAttrOut({
+      attr_valid: 1n,
+      attr_valid_nsec: 0,
+      attr: statToAttr(st, hdr.nodeid)
+    })
+  );
+}
+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);
+}
+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;
+  }
+  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