@machinen/runtime 0.1.1 → 0.2.0

package/dist/mount-server-bin.js

@@ -8,9 +8,13 @@ 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,
@@ -27,6 +31,7 @@ import {
 } 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
@@ -91,17 +96,36 @@ var FUSE_OP = {
   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,
-  READDIRPLUS: 44
+  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,
@@ -408,6 +432,59 @@ function readLinkIn(buf, off = 0) {
     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);
@@ -415,6 +492,66 @@ function readRenameIn(buf, off = 0) {
     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(
@@ -431,21 +568,35 @@ function payloadOf(message) {
 }
 
 // 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) {
@@ -475,7 +626,9 @@ function createState(rootAbs, mode) {
     handles: /* @__PURE__ */ new Map(),
     nextHandle: 1n,
     socket: null,
-    bytesServedOnPagesImg: 0
+    bytesServedOnPagesImg: 0,
+    locks: /* @__PURE__ */ new Map(),
+    lockWaiters: []
   };
 }
 var PAGES_IMG_RE = /(?:^|\/)pages-\d+\.img$/;
@@ -492,6 +645,8 @@ async function shutdown(server, state) {
     }
   }
   state.handles.clear();
+  cancelAllWaiters(state);
+  state.locks.clear();
   await new Promise((done) => server.close(() => done()));
 }
 async function handleConnection(sock, state) {
@@ -502,6 +657,8 @@ async function handleConnection(sock, state) {
   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 {
@@ -603,6 +760,28 @@ async function handle(hdr, msg, state) {
       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);
@@ -613,7 +792,7 @@ async function handle(hdr, msg, state) {
 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 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,
@@ -728,7 +907,8 @@ async function onOpen(hdr, msg, state) {
   state.handles.set(id, {
     kind: "file",
     fh,
-    lazyPagesContrib: isPagesImgPath(entry.relPath)
+    lazyPagesContrib: isPagesImgPath(entry.relPath),
+    nodeid: hdr.nodeid
   });
   return buildResponse(hdr.unique, buildOpenOut({ fh: id, open_flags: 0 }));
 }
@@ -746,10 +926,11 @@ async function onRead(hdr, msg, state) {
   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);
+  const rel = readReleaseIn(payloadOf(msg));
+  const entry = state.handles.get(rel.fh);
   if (entry && entry.kind === "file") {
-    state.handles.delete(fh);
+    state.handles.delete(rel.fh);
+    dropLocksFor(state, entry.nodeid, rel.lock_owner);
     await entry.fh.close().catch(() => {
     });
   }
@@ -842,7 +1023,8 @@ async function onCreate(hdr, msg, state) {
   state.handles.set(id, {
     kind: "file",
     fh,
-    lazyPagesContrib: isPagesImgPath(childRel)
+    lazyPagesContrib: isPagesImgPath(childRel),
+    nodeid: ino
   });
   return buildResponse(
     hdr.unique,
@@ -1009,8 +1191,13 @@ async function onSetattr(hdr, msg, state) {
     return buildErrorResponse(hdr.unique, -ERRNO.EROFS);
   }
   const entry = requireInode(state, hdr.nodeid);
-  const abs = await absPathForTraversal(state, entry);
+  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") {
@@ -1022,14 +1209,40 @@ async function onSetattr(hdr, msg, state) {
     }
   }
   if (req.valid & FATTR.MODE) {
-    await chmod(abs, req.mode & 4095);
+    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 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 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(
@@ -1041,6 +1254,10 @@ async function onSetattr(hdr, msg, state) {
     })
   );
 }
+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) {
@@ -1055,6 +1272,510 @@ async function onFsync(hdr, msg, state) {
   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;
@@ -1215,6 +1936,9 @@ function mapErrorToErrno(err) {
   if (!code) {
     return -ERRNO.EIO;
   }
+  if (code === "EOPNOTSUPP") {
+    return -ERRNO.ENOTSUP;
+  }
   const key = code;
   if (key in ERRNO) {
     return -ERRNO[key];