@k13engineering/linux-fuse 0.0.1 → 0.0.2

package/dist/lib/protocol.js

@@ -0,0 +1,3783 @@
+/* eslint-disable max-statements, complexity */
+
+import {
+  decodeCString,
+  decodeCStringPair,
+  fuseAccessInParser,
+  fuseAttrOutParser,
+  fuseBatchForgetInParser,
+  fuseBmapInParser,
+  fuseBmapOutParser,
+  fuseCreateInParser,
+  fuseEntryOutParser,
+  fuseFallocateInParser,
+  fuseFsyncInParser,
+  fuseFlushInParser,
+  fuseForgetInParser,
+  fuseForgetOneParser,
+  fuseGetattrInParser,
+  fuseGetxattrInParser,
+  fuseGetxattrOutParser,
+  fuseInitInParser,
+  fuseInitOutParser,
+  fuseInterruptInParser,
+  fuseIoctlInParser,
+  fuseIoctlOutParser,
+  fuseLinkInParser,
+  fuseLkInParser,
+  fuseLkOutParser,
+  fuseMkdirInParser,
+  fuseMknodInParser,
+  fuseOpenInParser,
+  fuseOpenOutParser,
+  fusePollInParser,
+  fusePollOutParser,
+  fuseReadInParser,
+  fuseReleaseInParser,
+  fuseRename2InParser,
+  fuseRenameInParser,
+  fuseSetattrInParser,
+  fuseSetxattrInParser,
+  fuseStatfsOutParser,
+  fuseWriteInParser,
+  fuseWriteOutParser,
+} from "./abi.js";
+import { FOPEN_DIRECT_IO, FOPEN_KEEP_CACHE, FOPEN_NONSEEKABLE, FUSE_GETATTR_FH, opcode } from "./constants.js";
+/*import type { TParsedMessageFromKernel, TParsedMessageToKernel } from "./message.ts";*/
+
+/*type TRequesterInfo = {
+  uid: bigint;
+  gid: bigint;
+  pid: bigint;
+};*/
+
+/*type TOpenFlagsToKernel = {
+  directIo: boolean;
+  keepCache: boolean;
+  nonSeekable: boolean;
+};*/
+
+/*type TFuseAttr = {
+  ino: bigint;
+  mode: bigint;
+  nlink: bigint;
+  uid: bigint;
+  gid: bigint;
+  rdev: bigint;
+  size: bigint;
+  blksize: bigint;
+  blocks: bigint;
+  atimeNsec: bigint;
+  mtimeNsec: bigint;
+  ctimeNsec: bigint;
+};*/
+
+/*type TFuseEntry = {
+  nodeId: bigint;
+  generation: bigint;
+  entryValidNsec: bigint;
+  attrValidNsec: bigint;
+  attr: TFuseAttr;
+};*/
+
+/*type TFuseXAttrResult = {
+  data: Uint8Array;
+} | {
+  size: bigint;
+};*/
+
+/*type TFuseRequest = {
+  unique: bigint;
+  requester: TRequesterInfo;
+} & ({
+  opcode: "INIT";
+  major: bigint;
+  minor: bigint;
+} | {
+  opcode: "FORGET";
+  nodeId: bigint;
+  lookupCount: bigint;
+} | {
+  opcode: "BATCH_FORGET";
+  forgets: Array<{
+    nodeId: bigint;
+    lookupCount: bigint;
+  }>;
+} | {
+  opcode: "GETATTR";
+  getattrMode: "node";
+  nodeId: bigint;
+} | {
+  opcode: "GETATTR";
+  getattrMode: "fileHandle";
+  fh: bigint;
+} | {
+  opcode: "LISTXATTR";
+  nodeId: bigint;
+  size: bigint;
+} | {
+  opcode: "GETXATTR";
+  nodeId: bigint;
+  size: bigint;
+  name: string;
+} | {
+  opcode: "SETATTR";
+  nodeId: bigint;
+  valid: bigint;
+  fh: bigint;
+  size: bigint;
+  lockOwner: bigint;
+  atimeNsec: bigint;
+  mtimeNsec: bigint;
+  ctimeNsec: bigint;
+  mode: bigint;
+  uid: bigint;
+  gid: bigint;
+} | {
+  opcode: "READLINK";
+  nodeId: bigint;
+} | {
+  opcode: "SYMLINK";
+  parentNodeId: bigint;
+  name: string;
+  target: string;
+} | {
+  opcode: "MKNOD";
+  parentNodeId: bigint;
+  name: string;
+  mode: bigint;
+  rdev: bigint;
+  umask: bigint;
+} | {
+  opcode: "MKDIR";
+  parentNodeId: bigint;
+  name: string;
+  mode: bigint;
+  umask: bigint;
+} | {
+  opcode: "UNLINK";
+  parentNodeId: bigint;
+  name: string;
+} | {
+  opcode: "RMDIR";
+  parentNodeId: bigint;
+  name: string;
+} | {
+  opcode: "RENAME";
+  parentNodeId: bigint;
+  newParentNodeId: bigint;
+  oldName: string;
+  newName: string;
+  flags: bigint;
+} | {
+  opcode: "LINK";
+  oldNodeId: bigint;
+  newParentNodeId: bigint;
+  name: string;
+} | {
+  opcode: "OPENDIR";
+  nodeId: bigint;
+  flags: bigint;
+} | {
+  opcode: "READDIR";
+  nodeId: bigint;
+  fh: bigint;
+  offset: bigint;
+  size: bigint;
+  readFlags: bigint;
+  lockOwner: bigint;
+  flags: bigint;
+} | {
+  opcode: "RELEASE";
+  nodeId: bigint;
+  fh: bigint;
+  flags: bigint;
+  releaseFlags: bigint;
+  lockOwner: bigint;
+} | {
+  opcode: "RELEASEDIR";
+  nodeId: bigint;
+  fh: bigint;
+  flags: bigint;
+  releaseFlags: bigint;
+  lockOwner: bigint;
+} | {
+  opcode: "FSYNCDIR";
+  nodeId: bigint;
+  fh: bigint;
+  fsyncFlags: bigint;
+} | {
+  opcode: "STATFS";
+} | {
+  opcode: "LOOKUP";
+  parentNodeId: bigint;
+  name: string;
+} | {
+  opcode: "OPEN",
+  nodeId: bigint;
+  flags: bigint;
+} | {
+  opcode: "READ";
+  nodeId: bigint;
+  fh: bigint;
+  offset: bigint;
+  size: bigint;
+  readFlags: bigint;
+  lockOwner: bigint;
+} | {
+  opcode: "WRITE";
+  nodeId: bigint;
+  fh: bigint;
+  offset: bigint;
+  data: Uint8Array;
+  writeFlags: bigint;
+  lockOwner: bigint;
+} | {
+  opcode: "FLUSH";
+  nodeId: bigint;
+  fh: bigint;
+  lockOwner: bigint;
+} | {
+  opcode: "FSYNC";
+  nodeId: bigint;
+  fh: bigint;
+  fsyncFlags: bigint;
+} | {
+  opcode: "ACCESS";
+  nodeId: bigint;
+  mask: bigint;
+} | {
+  opcode: "SETXATTR";
+  nodeId: bigint;
+  name: string;
+  data: Uint8Array;
+  flags: bigint;
+  setxattrFlags: bigint;
+} | {
+  opcode: "REMOVEXATTR";
+  nodeId: bigint;
+  name: string;
+} | {
+  opcode: "CREATE";
+  parentNodeId: bigint;
+  name: string;
+  flags: bigint;
+  mode: bigint;
+  umask: bigint;
+} | {
+  opcode: "DESTROY";
+} | {
+  opcode: "GETLK";
+  nodeId: bigint;
+  fh: bigint;
+  owner: bigint;
+  lockStart: bigint;
+  lockEnd: bigint;
+  lockType: bigint;
+  lockPid: bigint;
+  lkFlags: bigint;
+} | {
+  opcode: "SETLK";
+  nodeId: bigint;
+  fh: bigint;
+  owner: bigint;
+  lockStart: bigint;
+  lockEnd: bigint;
+  lockType: bigint;
+  lockPid: bigint;
+  lkFlags: bigint;
+} | {
+  opcode: "SETLKW";
+  nodeId: bigint;
+  fh: bigint;
+  owner: bigint;
+  lockStart: bigint;
+  lockEnd: bigint;
+  lockType: bigint;
+  lockPid: bigint;
+  lkFlags: bigint;
+} | {
+  opcode: "INTERRUPT";
+  targetUnique: bigint;
+} | {
+  opcode: "BMAP";
+  nodeId: bigint;
+  block: bigint;
+  blocksize: bigint;
+} | {
+  opcode: "IOCTL";
+  nodeId: bigint;
+  fh: bigint;
+  flags: bigint;
+  cmd: bigint;
+  arg: bigint;
+  inData: Uint8Array;
+  outSize: bigint;
+} | {
+  opcode: "POLL";
+  nodeId: bigint;
+  fh: bigint;
+  kh: bigint;
+  flags: bigint;
+  events: bigint;
+} | {
+  opcode: "NOTIFY_REPLY";
+  data: Uint8Array;
+} | {
+  opcode: "FALLOCATE";
+  nodeId: bigint;
+  fh: bigint;
+  offset: bigint;
+  length: bigint;
+  mode: bigint;
+} | {
+  opcode: "READDIRPLUS";
+  nodeId: bigint;
+  fh: bigint;
+  offset: bigint;
+  size: bigint;
+  readFlags: bigint;
+  lockOwner: bigint;
+  flags: bigint;
+});*/
+
+
+/*type TFuseResponse = {
+  forOpcode: "INIT";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "INIT";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    major: bigint,
+    minor: bigint,
+    maxReadahead: bigint,
+    flags: bigint,
+    maxBackground: bigint,
+    congestionThreshold: bigint,
+    maxWrite: bigint,
+    timeGran: bigint,
+    maxPages: bigint,
+    mapAlignment: bigint,
+    flags2: bigint,
+    maxStackDepth: bigint,
+    requestTimeout: bigint,
+  };
+} | {
+  forOpcode: "GETATTR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "GETATTR";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    attrValidNsec: bigint;
+    attr: TFuseAttr
+  };
+} | {
+  forOpcode: "SETATTR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SETATTR";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    attrValidNsec: bigint;
+    attr: TFuseAttr;
+  };
+} | {
+  forOpcode: "LISTXATTR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "LISTXATTR";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseXAttrResult;
+} | {
+  forOpcode: "GETXATTR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "GETXATTR";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseXAttrResult;
+} | {
+  forOpcode: "READLINK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "READLINK";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    target: string;
+  };
+} | {
+  forOpcode: "MKNOD";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "MKNOD";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry;
+} | {
+  forOpcode: "OPENDIR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "OPENDIR";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    fh: bigint;
+    openFlagsToKernel: TOpenFlagsToKernel;
+  };
+} | {
+  forOpcode: "READDIR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "READDIR";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    data: Uint8Array;
+  };
+} | {
+  forOpcode: "RELEASEDIR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "RELEASEDIR";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "FSYNCDIR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "FSYNCDIR";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "RELEASE";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "RELEASE";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "STATFS";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "STATFS";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    blocks: bigint;
+    bfree: bigint;
+    bavail: bigint;
+    files: bigint;
+    ffree: bigint;
+    bsize: bigint;
+    namelen: bigint;
+    frsize: bigint;
+  }
+} | {
+  forOpcode: "LOOKUP";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "LOOKUP";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry;
+} | {
+  forOpcode: "SYMLINK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SYMLINK";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry;
+} | {
+  forOpcode: "MKDIR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "MKDIR";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry;
+} | {
+  forOpcode: "LINK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "LINK";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry;
+} | {
+  forOpcode: "UNLINK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "UNLINK";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "RMDIR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "RMDIR";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "RENAME";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "RENAME";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "OPEN";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "OPEN";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    fh: bigint;
+    openFlagsToKernel: TOpenFlagsToKernel;
+  }
+} | {
+  forOpcode: "READ";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "READ";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    data: Uint8Array;
+  }
+} | {
+  forOpcode: "WRITE";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "WRITE";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    bytesWritten: bigint;
+  }
+} | {
+  forOpcode: "FLUSH";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "FLUSH";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "FSYNC";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "FSYNC";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "ACCESS";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "ACCESS";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "SETXATTR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SETXATTR";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "REMOVEXATTR";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "REMOVEXATTR";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "CREATE";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "CREATE";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry & {
+    fh: bigint;
+    openFlagsToKernel: TOpenFlagsToKernel;
+  };
+} | {
+  forOpcode: "DESTROY";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "DESTROY";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "GETLK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "GETLK";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    lockStart: bigint;
+    lockEnd: bigint;
+    lockType: bigint;
+    lockPid: bigint;
+  };
+} | {
+  forOpcode: "SETLK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SETLK";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "SETLKW";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SETLKW";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "BMAP";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "BMAP";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    block: bigint;
+  };
+} | {
+  forOpcode: "IOCTL";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "IOCTL";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    ioctlResult: bigint;
+    flags: bigint;
+    data: Uint8Array;
+  };
+} | {
+  forOpcode: "POLL";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "POLL";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    revents: bigint;
+  };
+} | {
+  forOpcode: "FALLOCATE";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "FALLOCATE";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "READDIRPLUS";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "READDIRPLUS";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    data: Uint8Array;
+  };
+};*/
+
+/*type TGenericInterpretResult<T> = {
+  error: Error;
+  interpreted: undefined;
+} | {
+  error: undefined;
+  interpreted: T;
+};*/
+
+const hasFlag = ({ bitmask, flag }/*: { bitmask: bigint; flag: bigint }*/)/*: boolean*/ => {
+  return (bitmask & flag) === flag;
+};
+
+const fuseAttrToPayloadValue = ({ attr }/*: { attr: TFuseAttr }*/) => {
+  return {
+    ino: attr.ino,
+    mode: attr.mode,
+    nlink: attr.nlink,
+    uid: attr.uid,
+    gid: attr.gid,
+    rdev: attr.rdev,
+    size: attr.size,
+    blksize: attr.blksize,
+    blocks: attr.blocks,
+    atime: attr.atimeNsec / 1_000_000_000n,
+    atimensec: attr.atimeNsec % 1_000_000_000n,
+    mtime: attr.mtimeNsec / 1_000_000_000n,
+    mtimensec: attr.mtimeNsec % 1_000_000_000n,
+    ctime: attr.ctimeNsec / 1_000_000_000n,
+    ctimensec: attr.ctimeNsec % 1_000_000_000n,
+    padding: 0n,
+  };
+};
+
+const payloadValueToFuseAttr = ({ attr }/*: { attr: ReturnType<typeof fuseAttrOutParser.parse>["attr"] }*/)/*: TFuseAttr*/ => {
+  return {
+    ino: attr.ino,
+    mode: attr.mode,
+    nlink: attr.nlink,
+    uid: attr.uid,
+    gid: attr.gid,
+    rdev: attr.rdev,
+    size: attr.size,
+    blksize: attr.blksize,
+    blocks: attr.blocks,
+    atimeNsec: attr.atime * 1_000_000_000n + attr.atimensec,
+    mtimeNsec: attr.mtime * 1_000_000_000n + attr.mtimensec,
+    ctimeNsec: attr.ctime * 1_000_000_000n + attr.ctimensec,
+  };
+};
+
+const openFlagsToKernelToBitmask = ({ openFlagsToKernel }/*: { openFlagsToKernel: TOpenFlagsToKernel }*/)/*: bigint*/ => {
+  let bitmask = 0n;
+
+  if (openFlagsToKernel.directIo) {
+    bitmask |= FOPEN_DIRECT_IO;
+  }
+
+  if (openFlagsToKernel.keepCache) {
+    bitmask |= FOPEN_KEEP_CACHE;
+  }
+
+  if (openFlagsToKernel.nonSeekable) {
+    bitmask |= FOPEN_NONSEEKABLE;
+  }
+
+  return bitmask;
+};
+
+const openFlagsToKernelFromBitmask = ({ bitmask }/*: { bitmask: bigint }*/)/*: TOpenFlagsToKernel*/ => {
+  return {
+    directIo: hasFlag({ bitmask, flag: FOPEN_DIRECT_IO }),
+    keepCache: hasFlag({ bitmask, flag: FOPEN_KEEP_CACHE }),
+    nonSeekable: hasFlag({ bitmask, flag: FOPEN_NONSEEKABLE }),
+  };
+};
+
+const encodeAttrPayload = (
+  { unique, result }/*: {
+    unique: bigint;
+    forOpcode: "GETATTR" | "SETATTR";
+    result: { attrValidNsec: bigint; attr: TFuseAttr };
+  }*/,
+)/*: Extract<TParsedMessageToKernel, { header: { unique: bigint } }>*/ => {
+  const payload = fuseAttrOutParser.format({
+    value: {
+      dummy: 0n,
+      attr_valid: result.attrValidNsec / 1_000_000_000n,
+      attr_valid_nsec: result.attrValidNsec % 1_000_000_000n,
+      attr: fuseAttrToPayloadValue({ attr: result.attr }),
+    }
+  });
+
+  return {
+    header: {
+      unique,
+      error: 0n,
+    },
+    payload,
+  };
+};
+
+const interpretAttrPayload = /*<TForOpcode extends "GETATTR" | "SETATTR">*/(
+  { unique, forOpcode, payload }/*: { unique: bigint; forOpcode: TForOpcode; payload: Uint8Array }*/
+)/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: TForOpcode }>>*/ => {
+  if (payload.length !== fuseAttrOutParser.size) {
+    return {
+      error: new Error(
+        `Invalid payload size for ${forOpcode} response. Expected ${fuseAttrOutParser.size} bytes, got ${payload.length} bytes.`
+      ),
+      interpreted: undefined,
+    };
+  }
+
+  const parsed = fuseAttrOutParser.parse({ data: payload });
+
+  return {
+    error: undefined,
+    interpreted: {
+      forOpcode,
+      unique,
+      errorCode: undefined,
+      result: {
+        attrValidNsec: parsed.attr_valid * 1_000_000_000n + parsed.attr_valid_nsec,
+        attr: payloadValueToFuseAttr({ attr: parsed.attr }),
+      }
+    } /*as Extract<TFuseResponse, { forOpcode: TForOpcode }>*/,
+  };
+};
+
+const encodeEntryPayload = (
+  { unique, result }/*: {
+    unique: bigint;
+    forOpcode: "LOOKUP" | "SYMLINK" | "MKNOD" | "MKDIR" | "LINK";
+    result: TFuseEntry;
+  }*/,
+)/*: TParsedMessageToKernel*/ => {
+  const payload = fuseEntryOutParser.format({
+    value: {
+      nodeid: result.nodeId,
+      generation: result.generation,
+      entry_valid: result.entryValidNsec / 1_000_000_000n,
+      attr_valid: result.attrValidNsec / 1_000_000_000n,
+      entry_valid_nsec: result.entryValidNsec % 1_000_000_000n,
+      attr_valid_nsec: result.attrValidNsec % 1_000_000_000n,
+      attr: fuseAttrToPayloadValue({ attr: result.attr }),
+    }
+  });
+
+  return {
+    header: {
+      unique,
+      error: 0n,
+    },
+    payload,
+  };
+};
+
+const interpretEntryPayload = /*<TForOpcode extends "LOOKUP" | "SYMLINK" | "MKNOD" | "MKDIR" | "LINK">*/(
+  { unique, forOpcode, payload }/*: { unique: bigint; forOpcode: TForOpcode; payload: Uint8Array }*/
+)/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: TForOpcode }>>*/ => {
+  if (payload.length !== fuseEntryOutParser.size) {
+    return {
+      error: new Error(
+        `Invalid payload size for ${forOpcode} response. Expected ${fuseEntryOutParser.size} bytes, got ${payload.length} bytes.`
+      ),
+      interpreted: undefined,
+    };
+  }
+
+  const parsed = fuseEntryOutParser.parse({ data: payload });
+
+  return {
+    error: undefined,
+    interpreted: {
+      forOpcode,
+      unique,
+      errorCode: undefined,
+      result: {
+        nodeId: parsed.nodeid,
+        generation: parsed.generation,
+        entryValidNsec: parsed.entry_valid * 1_000_000_000n + parsed.entry_valid_nsec,
+        attrValidNsec: parsed.attr_valid * 1_000_000_000n + parsed.attr_valid_nsec,
+        attr: payloadValueToFuseAttr({ attr: parsed.attr }),
+      },
+    } /*as Extract<TFuseResponse, { forOpcode: TForOpcode }>*/,
+  };
+};
+
+const encodeOpenPayload = (
+  { unique, result }/*: { unique: bigint; result: { fh: bigint; openFlagsToKernel: TOpenFlagsToKernel } }*/
+)/*: TParsedMessageToKernel*/ => {
+  const payload = fuseOpenOutParser.format({
+    value: {
+      fh: result.fh,
+      open_flags: openFlagsToKernelToBitmask({ openFlagsToKernel: result.openFlagsToKernel }),
+      backing_id: 0n,
+    }
+  });
+
+  return {
+    header: {
+      unique,
+      error: 0n,
+    },
+    payload,
+  };
+};
+
+const interpretOpenPayload = /*<TForOpcode extends "OPEN" | "OPENDIR">*/(
+  { unique, forOpcode, payload }/*: { unique: bigint; forOpcode: TForOpcode; payload: Uint8Array }*/
+)/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: TForOpcode }>>*/ => {
+  if (payload.length !== fuseOpenOutParser.size) {
+    return {
+      error: new Error(
+        `Invalid payload size for ${forOpcode} response. Expected ${fuseOpenOutParser.size} bytes, got ${payload.length} bytes.`
+      ),
+      interpreted: undefined,
+    };
+  }
+
+  const parsed = fuseOpenOutParser.parse({ data: payload });
+
+  return {
+    error: undefined,
+    interpreted: {
+      forOpcode,
+      unique,
+      errorCode: undefined,
+      result: {
+        fh: parsed.fh,
+        openFlagsToKernel: openFlagsToKernelFromBitmask({ bitmask: parsed.open_flags }),
+      }
+    } /*as Extract<TFuseResponse, { forOpcode: TForOpcode }>*/,
+  };
+};
+
+const encodeEmptyPayload = ({ unique }/*: { unique: bigint }*/)/*: TParsedMessageToKernel*/ => {
+  return {
+    header: {
+      unique,
+      error: 0n,
+    },
+    payload: new Uint8Array(0),
+  };
+};
+
+const interpretEmptyPayload = /*<T extends Extract<TFuseResponse, { result: Record<string, never> }>["forOpcode"]>*/(
+  { unique, forOpcode }/*: { unique: bigint; forOpcode: T }*/,
+)/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: T }>>*/ => {
+  return {
+    error: undefined,
+    interpreted: {
+      forOpcode,
+      unique,
+      errorCode: undefined,
+      result: {},
+    } /*as Extract<TFuseResponse, { forOpcode: T }>*/,
+  };
+};
+
+const encodeXAttrPayload = ({ unique, result }/*: { unique: bigint; result: TFuseXAttrResult }*/)/*: TParsedMessageToKernel*/ => {
+  const payload = "size" in result
+    ? fuseGetxattrOutParser.format({ value: { size: result.size, padding: 0n } })
+    : result.data;
+
+  return {
+    header: {
+      unique,
+      error: 0n,
+    },
+    payload,
+  };
+};
+
+const interpretXAttrPayload = /*<TForOpcode extends "GETXATTR" | "LISTXATTR">*/(
+  { unique, forOpcode, payload, requestedSize }/*:
+  { unique: bigint; forOpcode: TForOpcode; payload: Uint8Array; requestedSize: bigint }*/
+)/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: TForOpcode }>>*/ => {
+  if (requestedSize === 0n) {
+    if (payload.length !== fuseGetxattrOutParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for ${forOpcode} size response. Expected ${fuseGetxattrOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseGetxattrOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode,
+        unique,
+        errorCode: undefined,
+        result: { size: parsed.size },
+      } /*as Extract<TFuseResponse, { forOpcode: TForOpcode }>*/,
+    };
+  }
+
+  return {
+    error: undefined,
+    interpreted: {
+      forOpcode,
+      unique,
+      errorCode: undefined,
+      result: { data: payload },
+    } /*as Extract<TFuseResponse, { forOpcode: TForOpcode }>*/,
+  };
+};
+
+const createMessageFromKernelInterpreter = () => {
+
+  /*type TInterpretFunc<T extends string> = (
+    args: { unique: bigint, nodeId: bigint, requester: TRequesterInfo, payload: Uint8Array }
+  ) => TGenericInterpretResult<Extract<TFuseRequest, { opcode: T }>>;*/
+
+  const interpretInit/*: TInterpretFunc<"INIT">*/ = ({ unique, requester, payload }) => {
+
+    if (payload.length !== fuseInitInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for INIT request. Expected ${fuseInitInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { major, minor } = fuseInitInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "INIT",
+        major,
+        minor,
+      }
+    };
+  };
+
+  const interpretGetAttr/*: TInterpretFunc<"GETATTR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseGetattrInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for GETATTR request. Expected ${fuseGetattrInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { getattr_flags, fh } = fuseGetattrInParser.parse({ data: payload });
+
+    if (hasFlag({ bitmask: getattr_flags, flag: FUSE_GETATTR_FH })) {
+      return {
+        error: undefined,
+        interpreted: {
+          unique,
+          requester,
+          opcode: "GETATTR",
+          getattrMode: "fileHandle",
+          fh,
+        }
+      };
+    }
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "GETATTR",
+        getattrMode: "node",
+        nodeId,
+      }
+    };
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-underscore-dangle
+  const _interpretListXAttr/*: TInterpretFunc<"LISTXATTR">*/ = ({ unique, nodeId, requester }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "LISTXATTR",
+        nodeId,
+        size: 0n,
+      }
+    };
+  };
+
+  const interpretForget/*: TInterpretFunc<"FORGET">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseForgetInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for FORGET request. Expected ${fuseForgetInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { nlookup } = fuseForgetInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "FORGET",
+        nodeId,
+        lookupCount: nlookup,
+      }
+    };
+  };
+
+  const interpretBatchForget/*: TInterpretFunc<"BATCH_FORGET">*/ = ({ unique, requester, payload }) => {
+    if (payload.length < fuseBatchForgetInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for BATCH_FORGET request. ` +
+          `Expected at least ${fuseBatchForgetInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const header = fuseBatchForgetInParser.parse({ data: payload.subarray(0, fuseBatchForgetInParser.size) });
+    const count = Number(header.count);
+    const expectedSize = fuseBatchForgetInParser.size + (count * fuseForgetOneParser.size);
+    if (payload.length !== expectedSize) {
+      return {
+        error: new Error(`Invalid payload size for BATCH_FORGET request. Expected ${expectedSize} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    let forgets/*: Array<{ nodeId: bigint; lookupCount: bigint }>*/ = [];
+    for (let index = 0; index < count; index += 1) {
+      const start = fuseBatchForgetInParser.size + (index * fuseForgetOneParser.size);
+      const parsed = fuseForgetOneParser.parse({ data: payload.subarray(start, start + fuseForgetOneParser.size) });
+      forgets = [...forgets, {
+        nodeId: parsed.nodeid,
+        lookupCount: parsed.nlookup,
+      }];
+    }
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "BATCH_FORGET",
+        forgets,
+      }
+    };
+  };
+
+  const interpretListXAttrRequest/*: TInterpretFunc<"LISTXATTR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseGetxattrInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for LISTXATTR request. Expected ${fuseGetxattrInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { size } = fuseGetxattrInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "LISTXATTR",
+        nodeId,
+        size,
+      }
+    };
+  };
+
+  const interpretGetXAttr/*: TInterpretFunc<"GETXATTR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseGetxattrInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for GETXATTR request. Expected at least ${fuseGetxattrInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { size } = fuseGetxattrInParser.parse({ data: payload.subarray(0, fuseGetxattrInParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "GETXATTR",
+        nodeId,
+        size,
+        name: decodeCString(payload.subarray(fuseGetxattrInParser.size)),
+      }
+    };
+  };
+
+  const interpretSetAttr/*: TInterpretFunc<"SETATTR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseSetattrInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for SETATTR request. Expected ${fuseSetattrInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseSetattrInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "SETATTR",
+        nodeId,
+        valid: parsed.valid,
+        fh: parsed.fh,
+        size: parsed.size,
+        lockOwner: parsed.lock_owner,
+        atimeNsec: parsed.atime * 1_000_000_000n + parsed.atimensec,
+        mtimeNsec: parsed.mtime * 1_000_000_000n + parsed.mtimensec,
+        ctimeNsec: parsed.ctime * 1_000_000_000n + parsed.ctimensec,
+        mode: parsed.mode,
+        uid: parsed.uid,
+        gid: parsed.gid,
+      }
+    };
+  };
+
+  const interpretReadLink/*: TInterpretFunc<"READLINK">*/ = ({ unique, nodeId, requester }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "READLINK",
+        nodeId,
+      }
+    };
+  };
+
+  const interpretSymlink/*: TInterpretFunc<"SYMLINK">*/ = ({ unique, nodeId, requester, payload }) => {
+    const { first: name, second: target } = decodeCStringPair(payload);
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "SYMLINK",
+        parentNodeId: nodeId,
+        name,
+        target,
+      }
+    };
+  };
+
+  const interpretMknod/*: TInterpretFunc<"MKNOD">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseMknodInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for MKNOD request. Expected at least ${fuseMknodInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { mode, rdev, umask } = fuseMknodInParser.parse({ data: payload.subarray(0, fuseMknodInParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "MKNOD",
+        parentNodeId: nodeId,
+        name: decodeCString(payload.subarray(fuseMknodInParser.size)),
+        mode,
+        rdev,
+        umask,
+      }
+    };
+  };
+
+  const interpretMkdir/*: TInterpretFunc<"MKDIR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseMkdirInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for MKDIR request. Expected at least ${fuseMkdirInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { mode, umask } = fuseMkdirInParser.parse({ data: payload.subarray(0, fuseMkdirInParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "MKDIR",
+        parentNodeId: nodeId,
+        name: decodeCString(payload.subarray(fuseMkdirInParser.size)),
+        mode,
+        umask,
+      }
+    };
+  };
+
+  const interpretUnlink/*: TInterpretFunc<"UNLINK">*/ = ({ unique, nodeId, requester, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "UNLINK",
+        parentNodeId: nodeId,
+        name: decodeCString(payload),
+      }
+    };
+  };
+
+  const interpretRmDir/*: TInterpretFunc<"RMDIR">*/ = ({ unique, nodeId, requester, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "RMDIR",
+        parentNodeId: nodeId,
+        name: decodeCString(payload),
+      }
+    };
+  };
+
+  const interpretRename = (
+    { unique, nodeId, requester, payload, supportsFlags }/*:
+    { unique: bigint; nodeId: bigint; requester: TRequesterInfo; payload: Uint8Array; supportsFlags: boolean }*/
+  )/*: TGenericInterpretResult<Extract<TFuseRequest, { opcode: "RENAME" }>>*/ => {
+    const headerSize = supportsFlags ? fuseRename2InParser.size : fuseRenameInParser.size;
+    if (payload.length < headerSize) {
+      return {
+        error: new Error(
+          `Invalid payload size for ${supportsFlags ? "RENAME2" : "RENAME"} request. ` +
+          `Expected at least ${headerSize} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { newdir, flags } = supportsFlags
+      ? fuseRename2InParser.parse({ data: payload.subarray(0, fuseRename2InParser.size) })
+      : { ...fuseRenameInParser.parse({ data: payload.subarray(0, fuseRenameInParser.size) }), flags: 0n };
+    const { first: oldName, second: newName } = decodeCStringPair(payload.subarray(headerSize));
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "RENAME",
+        parentNodeId: nodeId,
+        newParentNodeId: newdir,
+        oldName,
+        newName,
+        flags,
+      }
+    };
+  };
+
+  const interpretOpenDir/*: TInterpretFunc<"OPENDIR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseOpenInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for OPENDIR request. Expected ${fuseOpenInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { flags } = fuseOpenInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "OPENDIR",
+        nodeId,
+        flags,
+      }
+    };
+  };
+
+  const interpretLink/*: TInterpretFunc<"LINK">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseLinkInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for LINK request. Expected at least ${fuseLinkInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { oldnodeid } = fuseLinkInParser.parse({ data: payload.subarray(0, fuseLinkInParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "LINK",
+        oldNodeId: oldnodeid,
+        newParentNodeId: nodeId,
+        name: decodeCString(payload.subarray(fuseLinkInParser.size)),
+      }
+    };
+  };
+
+  const interpretReadDir/*: TInterpretFunc<"READDIR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseReadInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for READDIR request. Expected ${fuseReadInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, offset, size, flags, lock_owner, read_flags } = fuseReadInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "READDIR",
+        nodeId,
+        fh,
+        offset,
+        size,
+        flags,
+        lockOwner: lock_owner,
+        readFlags: read_flags,
+      }
+    };
+  };
+
+  const interpretReleaseDir/*: TInterpretFunc<"RELEASEDIR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseReleaseInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for RELEASEDIR request. Expected ${fuseReleaseInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, flags, release_flags, lock_owner } = fuseReleaseInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "RELEASEDIR",
+        nodeId,
+        fh,
+        flags,
+        releaseFlags: release_flags,
+        lockOwner: lock_owner,
+      }
+    };
+  };
+
+  const interpretRelease/*: TInterpretFunc<"RELEASE">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseReleaseInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for RELEASE request. Expected ${fuseReleaseInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, flags, release_flags, lock_owner } = fuseReleaseInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "RELEASE",
+        nodeId,
+        fh,
+        flags,
+        releaseFlags: release_flags,
+        lockOwner: lock_owner,
+      }
+    };
+  };
+
+  const interpretStatFs/*: TInterpretFunc<"STATFS">*/ = ({ unique, requester }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "STATFS",
+      }
+    };
+  };
+
+  const interpretLookup/*: TInterpretFunc<"LOOKUP">*/ = ({ unique, nodeId, requester, payload }) => {
+    const name = decodeCString(payload);
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "LOOKUP",
+        parentNodeId: nodeId,
+        name,
+      }
+    };
+  };
+
+  const interpretOpen/*: TInterpretFunc<"OPEN">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseOpenInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for OPEN request. Expected ${fuseOpenInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { flags } = fuseOpenInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "OPEN",
+        nodeId,
+        flags,
+      }
+    };
+  };
+
+  const interpretRead/*: TInterpretFunc<"READ">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseReadInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for READ request. Expected ${fuseReadInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, offset, size, lock_owner, read_flags } = fuseReadInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "READ",
+        nodeId,
+        fh,
+        offset,
+        size,
+        lockOwner: lock_owner,
+        readFlags: read_flags,
+      }
+    };
+  };
+
+  const interpretWrite/*: TInterpretFunc<"WRITE">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseWriteInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for WRITE request. Expected at least ${fuseWriteInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, offset, write_flags, lock_owner } = fuseWriteInParser.parse({ data: payload.subarray(0, fuseWriteInParser.size) });
+    const data = payload.subarray(fuseWriteInParser.size);
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "WRITE",
+        nodeId,
+        fh,
+        offset,
+        data,
+        writeFlags: write_flags,
+        lockOwner: lock_owner,
+      }
+    };
+  };
+
+  const interpretFlush/*: TInterpretFunc<"FLUSH">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseFlushInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for FLUSH request. Expected ${fuseFlushInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, lock_owner } = fuseFlushInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "FLUSH",
+        nodeId,
+        fh,
+        lockOwner: lock_owner,
+      }
+    };
+  };
+
+  const interpretFsync = (
+    { unique, nodeId, requester, payload, forOpcode }/*:
+    { unique: bigint; nodeId: bigint; requester: TRequesterInfo; payload: Uint8Array; forOpcode: "FSYNC" | "FSYNCDIR" }*/
+  )/*: TGenericInterpretResult<Extract<TFuseRequest, { opcode: typeof forOpcode }>>*/ => {
+    if (payload.length !== fuseFsyncInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for ${forOpcode} request. Expected ${fuseFsyncInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, fsync_flags } = fuseFsyncInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: forOpcode,
+        nodeId,
+        fh,
+        fsyncFlags: fsync_flags,
+      } /*as Extract<TFuseRequest, { opcode: typeof forOpcode }>*/,
+    };
+  };
+
+  const interpretAccess/*: TInterpretFunc<"ACCESS">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseAccessInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for ACCESS request. Expected ${fuseAccessInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { mask } = fuseAccessInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "ACCESS",
+        nodeId,
+        mask,
+      }
+    };
+  };
+
+  const interpretSetXAttr/*: TInterpretFunc<"SETXATTR">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseSetxattrInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for SETXATTR request. Expected at least ${fuseSetxattrInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { size, flags, setxattr_flags } = fuseSetxattrInParser.parse({ data: payload.subarray(0, fuseSetxattrInParser.size) });
+    const trailing = payload.subarray(fuseSetxattrInParser.size);
+    const nameTerminator = trailing.indexOf(0);
+    if (nameTerminator === -1) {
+      return {
+        error: new Error("Invalid payload for SETXATTR request. Expected a nul-terminated attribute name."),
+        interpreted: undefined,
+      };
+    }
+
+    const name = decodeCString(trailing);
+    const data = trailing.subarray(nameTerminator + 1);
+    if (BigInt(data.length) !== size) {
+      return {
+        error: new Error(`Invalid payload size for SETXATTR request data. Expected ${size} bytes, got ${data.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "SETXATTR",
+        nodeId,
+        name,
+        data,
+        flags,
+        setxattrFlags: setxattr_flags,
+      }
+    };
+  };
+
+  const interpretRemoveXAttr/*: TInterpretFunc<"REMOVEXATTR">*/ = ({ unique, nodeId, requester, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "REMOVEXATTR",
+        nodeId,
+        name: decodeCString(payload),
+      }
+    };
+  };
+
+  const interpretCreate/*: TInterpretFunc<"CREATE">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseCreateInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for CREATE request. Expected at least ${fuseCreateInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { flags, mode, umask } = fuseCreateInParser.parse({ data: payload.subarray(0, fuseCreateInParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "CREATE",
+        parentNodeId: nodeId,
+        name: decodeCString(payload.subarray(fuseCreateInParser.size)),
+        flags,
+        mode,
+        umask,
+      }
+    };
+  };
+
+  const interpretDestroy/*: TInterpretFunc<"DESTROY">*/ = ({ unique, requester }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "DESTROY",
+      }
+    };
+  };
+
+  const interpretLk = (
+    { unique, nodeId, requester, payload, forOpcode }/*:
+    { unique: bigint; nodeId: bigint; requester: TRequesterInfo; payload: Uint8Array; forOpcode: "GETLK" | "SETLK" | "SETLKW" }*/
+  )/*: TGenericInterpretResult<Extract<TFuseRequest, { opcode: typeof forOpcode }>>*/ => {
+    if (payload.length !== fuseLkInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for ${forOpcode} request. Expected ${fuseLkInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, owner, lk, lk_flags } = fuseLkInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: forOpcode,
+        nodeId,
+        fh,
+        owner,
+        lockStart: lk.start,
+        lockEnd: lk.end,
+        lockType: lk.type,
+        lockPid: lk.pid,
+        lkFlags: lk_flags,
+      } /*as Extract<TFuseRequest, { opcode: typeof forOpcode }>*/,
+    };
+  };
+
+  const interpretInterrupt/*: TInterpretFunc<"INTERRUPT">*/ = ({ unique, requester, payload }) => {
+    if (payload.length !== fuseInterruptInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for INTERRUPT request. Expected ${fuseInterruptInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseInterruptInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "INTERRUPT",
+        targetUnique: parsed.unique,
+      }
+    };
+  };
+
+  const interpretBmap/*: TInterpretFunc<"BMAP">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseBmapInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for BMAP request. Expected ${fuseBmapInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { block, blocksize } = fuseBmapInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "BMAP",
+        nodeId,
+        block,
+        blocksize,
+      }
+    };
+  };
+
+  const interpretIoctl/*: TInterpretFunc<"IOCTL">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseIoctlInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for IOCTL request. Expected at least ${fuseIoctlInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, flags, cmd, arg, out_size } = fuseIoctlInParser.parse({ data: payload.subarray(0, fuseIoctlInParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "IOCTL",
+        nodeId,
+        fh,
+        flags,
+        cmd,
+        arg,
+        inData: payload.subarray(fuseIoctlInParser.size),
+        outSize: out_size,
+      }
+    };
+  };
+
+  const interpretPoll/*: TInterpretFunc<"POLL">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fusePollInParser.size) {
+      return {
+        error: new Error(`Invalid payload size for POLL request. Expected ${fusePollInParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, kh, flags, events } = fusePollInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "POLL",
+        nodeId,
+        fh,
+        kh,
+        flags,
+        events,
+      }
+    };
+  };
+
+  const interpretNotifyReply/*: TInterpretFunc<"NOTIFY_REPLY">*/ = ({ unique, requester, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "NOTIFY_REPLY",
+        data: payload,
+      }
+    };
+  };
+
+  const interpretFallocate/*: TInterpretFunc<"FALLOCATE">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseFallocateInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for FALLOCATE request. Expected ${fuseFallocateInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, offset, length, mode } = fuseFallocateInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "FALLOCATE",
+        nodeId,
+        fh,
+        offset,
+        length,
+        mode,
+      }
+    };
+  };
+
+  const interpretReadDirPlus/*: TInterpretFunc<"READDIRPLUS">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseReadInParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for READDIRPLUS request. Expected ${fuseReadInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, offset, size, flags, lock_owner, read_flags } = fuseReadInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "READDIRPLUS",
+        nodeId,
+        fh,
+        offset,
+        size,
+        flags,
+        lockOwner: lock_owner,
+        readFlags: read_flags,
+      }
+    };
+  };
+
+  const interpretMessageFromKernel = (
+    { parsedMessageFromKernel }/*: { parsedMessageFromKernel: TParsedMessageFromKernel }*/
+  )/*: TGenericInterpretResult<TFuseRequest>*/ => {
+
+    const unique = parsedMessageFromKernel.header.unique;
+    const nodeId = parsedMessageFromKernel.header.nodeid;
+    const requester = {
+      uid: parsedMessageFromKernel.header.uid,
+      gid: parsedMessageFromKernel.header.gid,
+      pid: parsedMessageFromKernel.header.pid,
+    };
+
+    switch (parsedMessageFromKernel.header.opcode) {
+    case BigInt(opcode.INIT): {
+      return interpretInit({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.FORGET): {
+      return interpretForget({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.BATCH_FORGET): {
+      return interpretBatchForget({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.GETATTR): {
+      return interpretGetAttr({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.SETATTR): {
+      return interpretSetAttr({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.LISTXATTR): {
+      return interpretListXAttrRequest({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.GETXATTR): {
+      return interpretGetXAttr({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.READLINK): {
+      return interpretReadLink({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.SYMLINK): {
+      return interpretSymlink({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.MKNOD): {
+      return interpretMknod({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.MKDIR): {
+      return interpretMkdir({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.UNLINK): {
+      return interpretUnlink({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.RMDIR): {
+      return interpretRmDir({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.RENAME): {
+      return interpretRename({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        supportsFlags: false,
+      });
+    }
+
+    case BigInt(opcode.RENAME2): {
+      return interpretRename({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        supportsFlags: true,
+      });
+    }
+
+    case BigInt(opcode.OPENDIR): {
+      return interpretOpenDir({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.LINK): {
+      return interpretLink({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.READDIR): {
+      return interpretReadDir({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.RELEASE): {
+      return interpretRelease({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.RELEASEDIR): {
+      return interpretReleaseDir({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.FSYNCDIR): {
+      return interpretFsync({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        forOpcode: "FSYNCDIR",
+      });
+    }
+
+    case BigInt(opcode.STATFS): {
+      return interpretStatFs({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.LOOKUP): {
+      return interpretLookup({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.OPEN): {
+      return interpretOpen({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.READ): {
+      return interpretRead({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.WRITE): {
+      return interpretWrite({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.FLUSH): {
+      return interpretFlush({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.FSYNC): {
+      return interpretFsync({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        forOpcode: "FSYNC",
+      });
+    }
+
+    case BigInt(opcode.ACCESS): {
+      return interpretAccess({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.SETXATTR): {
+      return interpretSetXAttr({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.REMOVEXATTR): {
+      return interpretRemoveXAttr({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.CREATE): {
+      return interpretCreate({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.DESTROY): {
+      return interpretDestroy({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.GETLK): {
+      return interpretLk({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        forOpcode: "GETLK",
+      });
+    }
+
+    case BigInt(opcode.SETLK): {
+      return interpretLk({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        forOpcode: "SETLK",
+      });
+    }
+
+    case BigInt(opcode.SETLKW): {
+      return interpretLk({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+        forOpcode: "SETLKW",
+      });
+    }
+
+    case BigInt(opcode.INTERRUPT): {
+      return interpretInterrupt({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.BMAP): {
+      return interpretBmap({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.IOCTL): {
+      return interpretIoctl({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.POLL): {
+      return interpretPoll({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.NOTIFY_REPLY): {
+      return interpretNotifyReply({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.FALLOCATE): {
+      return interpretFallocate({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.READDIRPLUS): {
+      return interpretReadDirPlus({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    default: {
+      break;
+    }
+    }
+
+    return {
+      error: new Error(`Unsupported opcode: ${parsedMessageFromKernel.header.opcode}`),
+      interpreted: undefined,
+    };
+  };
+
+  return {
+    interpretMessageFromKernel,
+  };
+};
+
+
+const createMessageToKernelInterpreter = () => {
+
+  /*type TInterpretFunc<T extends string> = (
+    args: { unique: bigint, payload: Uint8Array }
+  ) => TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: T }>>;*/
+
+  const encodeInitResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "INIT", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+
+    const initResult = response.result;
+
+    const initResultPayload = fuseInitOutParser.format({
+      value: {
+        major: initResult.major,
+        minor: initResult.minor,
+        max_readahead: initResult.maxReadahead,
+        flags: initResult.flags,
+        max_background: initResult.maxBackground,
+        congestion_threshold: initResult.congestionThreshold,
+        max_write: initResult.maxWrite,
+        time_gran: initResult.timeGran,
+        max_pages: initResult.maxPages,
+        map_alignment: initResult.mapAlignment,
+        flags2: initResult.flags2,
+        max_stack_depth: initResult.maxStackDepth,
+        request_timeout: initResult.requestTimeout,
+        unused: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n],
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: initResultPayload,
+    };
+  };
+
+  const encodeGetAttrResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "GETATTR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeAttrPayload({ unique: response.unique, forOpcode: "GETATTR", result: response.result });
+  };
+
+  const encodeSetAttrResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SETATTR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeAttrPayload({ unique: response.unique, forOpcode: "SETATTR", result: response.result });
+  };
+
+  const encodeOpenDirResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "OPENDIR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeOpenPayload({ unique: response.unique, result: response.result });
+  };
+
+  const encodeReadDirResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "READDIR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: response.result.data,
+    };
+  };
+
+  const encodeReleaseDirResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "RELEASEDIR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeReleaseResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "RELEASE", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeOpenResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "OPEN", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeOpenPayload({ unique: response.unique, result: response.result });
+  };
+
+  const encodeReadResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "READ", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: response.result.data,
+    };
+  };
+
+  const encodeWriteResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "WRITE", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const writeResultPayload = fuseWriteOutParser.format({
+      value: {
+        size: response.result.bytesWritten,
+        padding: 0n,
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: writeResultPayload,
+    };
+  };
+
+  const encodeLookupResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "LOOKUP", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEntryPayload({ unique: response.unique, forOpcode: "LOOKUP", result: response.result });
+  };
+
+  const encodeSymlinkResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SYMLINK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEntryPayload({ unique: response.unique, forOpcode: "SYMLINK", result: response.result });
+  };
+
+  const encodeMkdirResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "MKDIR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEntryPayload({ unique: response.unique, forOpcode: "MKDIR", result: response.result });
+  };
+
+  const encodeStatFsResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "STATFS", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const statFsResult = response.result;
+
+    const statFsResultPayload = fuseStatfsOutParser.format({
+      value: {
+        st: {
+          blocks: statFsResult.blocks,
+          bfree: statFsResult.bfree,
+          bavail: statFsResult.bavail,
+          files: statFsResult.files,
+          ffree: statFsResult.ffree,
+          bsize: statFsResult.bsize,
+          namelen: statFsResult.namelen,
+          frsize: statFsResult.frsize,
+          padding: 0n,
+          spare: [0n, 0n, 0n, 0n, 0n, 0n],
+        }
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: statFsResultPayload,
+    };
+  };
+
+  const encodeGetXAttrResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "GETXATTR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeXAttrPayload({ unique: response.unique, result: response.result });
+  };
+
+  const encodeListXAttrResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "LISTXATTR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeXAttrPayload({ unique: response.unique, result: response.result });
+  };
+
+  const encodeReadLinkResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "READLINK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: new TextEncoder().encode(response.result.target),
+    };
+  };
+
+  const encodeUnlinkResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "UNLINK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeRmDirResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "RMDIR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeRenameResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "RENAME", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeFsyncResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "FSYNC", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeSetXAttrResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SETXATTR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeRemoveXAttrResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "REMOVEXATTR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeMknodResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "MKNOD", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEntryPayload({ unique: response.unique, forOpcode: "MKNOD", result: response.result });
+  };
+
+  const encodeLinkResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "LINK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEntryPayload({ unique: response.unique, forOpcode: "LINK", result: response.result });
+  };
+
+  const encodeFsyncDirResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "FSYNCDIR", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeFlushResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "FLUSH", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeAccessResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "ACCESS", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeCreateResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "CREATE", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const entryPayload = fuseEntryOutParser.format({
+      value: {
+        nodeid: response.result.nodeId,
+        generation: response.result.generation,
+        entry_valid: response.result.entryValidNsec / 1_000_000_000n,
+        attr_valid: response.result.attrValidNsec / 1_000_000_000n,
+        entry_valid_nsec: response.result.entryValidNsec % 1_000_000_000n,
+        attr_valid_nsec: response.result.attrValidNsec % 1_000_000_000n,
+        attr: fuseAttrToPayloadValue({ attr: response.result.attr }),
+      }
+    });
+    const openPayload = fuseOpenOutParser.format({
+      value: {
+        fh: response.result.fh,
+        open_flags: openFlagsToKernelToBitmask({ openFlagsToKernel: response.result.openFlagsToKernel }),
+        backing_id: 0n,
+      }
+    });
+
+    const payload = new Uint8Array(entryPayload.length + openPayload.length);
+    payload.set(entryPayload, 0);
+    payload.set(openPayload, entryPayload.length);
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodeDestroyResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "DESTROY", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeGetLkResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "GETLK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const payload = fuseLkOutParser.format({
+      value: {
+        lk: {
+          start: response.result.lockStart,
+          end: response.result.lockEnd,
+          type: response.result.lockType,
+          pid: response.result.lockPid,
+        },
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodeSetLkResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SETLK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeSetLkWResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SETLKW", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeBmapResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "BMAP", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const payload = fuseBmapOutParser.format({
+      value: {
+        block: response.result.block,
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodeIoctlResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "IOCTL", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const headerPayload = fuseIoctlOutParser.format({
+      value: {
+        result: response.result.ioctlResult,
+        flags: response.result.flags,
+        in_iovs: 0n,
+        out_iovs: 0n,
+      }
+    });
+
+    const payload = new Uint8Array(headerPayload.length + response.result.data.length);
+    payload.set(headerPayload, 0);
+    payload.set(response.result.data, headerPayload.length);
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodePollResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "POLL", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const payload = fusePollOutParser.format({
+      value: {
+        revents: response.result.revents,
+        padding: 0n,
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodeFallocateResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "FALLOCATE", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeReadDirPlusResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "READDIRPLUS", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload: response.result.data,
+    };
+  };
+
+  const encodeMessageToKernel = ({ response }/*: { response: TFuseResponse }*/)/*: TParsedMessageToKernel*/ => {
+
+    if (response.errorCode !== undefined) {
+
+      if (response.errorCode > 0) {
+        throw Error(`fuse expects error codes to be negative numbers. Got ${response.errorCode}`);
+      }
+
+      return {
+        header: {
+          unique: response.unique,
+          error: BigInt(response.errorCode),
+        },
+        payload: new Uint8Array(0),
+      };
+    }
+
+    switch (response.forOpcode) {
+    case "INIT": {
+      return encodeInitResponse({ response });
+    }
+
+    case "GETATTR": {
+      return encodeGetAttrResponse({ response });
+    }
+
+    case "SETATTR": {
+      return encodeSetAttrResponse({ response });
+    }
+
+    case "LISTXATTR": {
+      return encodeListXAttrResponse({ response });
+    }
+
+    case "GETXATTR": {
+      return encodeGetXAttrResponse({ response });
+    }
+
+    case "READLINK": {
+      return encodeReadLinkResponse({ response });
+    }
+
+    case "MKNOD": {
+      return encodeMknodResponse({ response });
+    }
+
+    case "OPENDIR": {
+      return encodeOpenDirResponse({ response });
+    }
+
+    case "READDIR": {
+      return encodeReadDirResponse({ response });
+    }
+
+    case "RELEASEDIR": {
+      return encodeReleaseDirResponse({ response });
+    }
+
+    case "FSYNCDIR": {
+      return encodeFsyncDirResponse({ response });
+    }
+
+    case "RELEASE": {
+      return encodeReleaseResponse({ response });
+    }
+
+    case "STATFS": {
+      return encodeStatFsResponse({ response });
+    }
+
+    case "LOOKUP": {
+      return encodeLookupResponse({ response });
+    }
+
+    case "SYMLINK": {
+      return encodeSymlinkResponse({ response });
+    }
+
+    case "MKDIR": {
+      return encodeMkdirResponse({ response });
+    }
+
+    case "LINK": {
+      return encodeLinkResponse({ response });
+    }
+
+    case "UNLINK": {
+      return encodeUnlinkResponse({ response });
+    }
+
+    case "RMDIR": {
+      return encodeRmDirResponse({ response });
+    }
+
+    case "RENAME": {
+      return encodeRenameResponse({ response });
+    }
+
+    case "OPEN": {
+      return encodeOpenResponse({ response });
+    }
+
+    case "READ": {
+      return encodeReadResponse({ response });
+    }
+
+    case "WRITE": {
+      return encodeWriteResponse({ response });
+    }
+
+    case "FLUSH": {
+      return encodeFlushResponse({ response });
+    }
+
+    case "FSYNC": {
+      return encodeFsyncResponse({ response });
+    }
+
+    case "ACCESS": {
+      return encodeAccessResponse({ response });
+    }
+
+    case "SETXATTR": {
+      return encodeSetXAttrResponse({ response });
+    }
+
+    case "REMOVEXATTR": {
+      return encodeRemoveXAttrResponse({ response });
+    }
+
+    case "CREATE": {
+      return encodeCreateResponse({ response });
+    }
+
+    case "DESTROY": {
+      return encodeDestroyResponse({ response });
+    }
+
+    case "GETLK": {
+      return encodeGetLkResponse({ response });
+    }
+
+    case "SETLK": {
+      return encodeSetLkResponse({ response });
+    }
+
+    case "SETLKW": {
+      return encodeSetLkWResponse({ response });
+    }
+
+    case "BMAP": {
+      return encodeBmapResponse({ response });
+    }
+
+    case "IOCTL": {
+      return encodeIoctlResponse({ response });
+    }
+
+    case "POLL": {
+      return encodePollResponse({ response });
+    }
+
+    case "FALLOCATE": {
+      return encodeFallocateResponse({ response });
+    }
+
+    case "READDIRPLUS": {
+      return encodeReadDirPlusResponse({ response });
+    }
+
+    default: {
+      // @ts-expect-error exhaustiveness check
+      throw new Error(`Unsupported opcode: ${response.forOpcode}`);
+    }
+    }
+  };
+
+  const interpretInitResponse/*: TInterpretFunc<"INIT">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseInitOutParser.size) {
+      return {
+        error: new Error(`Invalid payload size for INIT response. Expected ${fuseInitOutParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const initResult = fuseInitOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "INIT",
+        unique,
+        errorCode: undefined,
+        result: {
+          major: initResult.major,
+          minor: initResult.minor,
+          maxReadahead: initResult.max_readahead,
+          flags: initResult.flags,
+          maxBackground: initResult.max_background,
+          congestionThreshold: initResult.congestion_threshold,
+          maxWrite: initResult.max_write,
+          timeGran: initResult.time_gran,
+          maxPages: initResult.max_pages,
+          mapAlignment: initResult.map_alignment,
+          flags2: initResult.flags2,
+          maxStackDepth: initResult.max_stack_depth,
+          requestTimeout: initResult.request_timeout,
+        }
+      }
+    };
+  };
+
+  const interpretGetAttrResponse/*: TInterpretFunc<"GETATTR">*/ = ({ unique, payload }) => {
+    return interpretAttrPayload({ unique, forOpcode: "GETATTR", payload });
+  };
+
+  const interpretSetAttrResponse/*: TInterpretFunc<"SETATTR">*/ = ({ unique, payload }) => {
+    return interpretAttrPayload({ unique, forOpcode: "SETATTR", payload });
+  };
+
+  const interpretOpenDirResponse/*: TInterpretFunc<"OPENDIR">*/ = ({ unique, payload }) => {
+    return interpretOpenPayload({ unique, forOpcode: "OPENDIR", payload });
+  };
+
+  const interpretReadDirResponse/*: TInterpretFunc<"READDIR">*/ = ({ unique, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "READDIR",
+        unique,
+        errorCode: undefined,
+        result: {
+          data: payload,
+        }
+      }
+    };
+  };
+
+  const interpretReleaseDirResponse/*: TInterpretFunc<"RELEASEDIR">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "RELEASEDIR" });
+  };
+
+  const interpretReleaseResponse/*: TInterpretFunc<"RELEASE">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "RELEASE" });
+  };
+
+  const interpretLookupResponse/*: TInterpretFunc<"LOOKUP">*/ = ({ unique, payload }) => {
+    return interpretEntryPayload({ unique, forOpcode: "LOOKUP", payload });
+  };
+
+  const interpretSymlinkResponse/*: TInterpretFunc<"SYMLINK">*/ = ({ unique, payload }) => {
+    return interpretEntryPayload({ unique, forOpcode: "SYMLINK", payload });
+  };
+
+  const interpretMknodResponse/*: TInterpretFunc<"MKNOD">*/ = ({ unique, payload }) => {
+    return interpretEntryPayload({ unique, forOpcode: "MKNOD", payload });
+  };
+
+  const interpretMkdirResponse/*: TInterpretFunc<"MKDIR">*/ = ({ unique, payload }) => {
+    return interpretEntryPayload({ unique, forOpcode: "MKDIR", payload });
+  };
+
+  const interpretLinkResponse/*: TInterpretFunc<"LINK">*/ = ({ unique, payload }) => {
+    return interpretEntryPayload({ unique, forOpcode: "LINK", payload });
+  };
+
+  const interpretOpenResponse/*: TInterpretFunc<"OPEN">*/ = ({ unique, payload }) => {
+    return interpretOpenPayload({ unique, forOpcode: "OPEN", payload });
+  };
+
+  const interpretReadResponse/*: TInterpretFunc<"READ">*/ = ({ unique, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "READ",
+        unique,
+        errorCode: undefined,
+        result: {
+          data: payload,
+        }
+      }
+    };
+  };
+
+  const interpretWriteResponse/*: TInterpretFunc<"WRITE">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseWriteOutParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for WRITE response. Expected ${fuseWriteOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const writeResult = fuseWriteOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "WRITE",
+        unique,
+        errorCode: undefined,
+        result: {
+          bytesWritten: writeResult.size,
+        }
+      }
+    };
+  };
+
+  const interpretGetXAttrResponse = (
+    { unique, payload, request }/*:
+    { unique: bigint; payload: Uint8Array; request: Extract<TFuseRequest, { opcode: "GETXATTR" }> }*/
+  )/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: "GETXATTR" }>>*/ => {
+    return interpretXAttrPayload({ unique, forOpcode: "GETXATTR", payload, requestedSize: request.size });
+  };
+
+  const interpretListXAttrResponse = (
+    { unique, payload, request }/*:
+    { unique: bigint; payload: Uint8Array; request: Extract<TFuseRequest, { opcode: "LISTXATTR" }> }*/
+  )/*: TGenericInterpretResult<Extract<TFuseResponse, { forOpcode: "LISTXATTR" }>>*/ => {
+    return interpretXAttrPayload({ unique, forOpcode: "LISTXATTR", payload, requestedSize: request.size });
+  };
+
+  const interpretReadLinkResponse/*: TInterpretFunc<"READLINK">*/ = ({ unique, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "READLINK",
+        unique,
+        errorCode: undefined,
+        result: {
+          target: new TextDecoder().decode(payload),
+        }
+      }
+    };
+  };
+
+  const interpretUnlinkResponse/*: TInterpretFunc<"UNLINK">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "UNLINK" });
+  };
+
+  const interpretRmDirResponse/*: TInterpretFunc<"RMDIR">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "RMDIR" });
+  };
+
+  const interpretRenameResponse/*: TInterpretFunc<"RENAME">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "RENAME" });
+  };
+
+  const interpretFlushResponse/*: TInterpretFunc<"FLUSH">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "FLUSH" });
+  };
+
+  const interpretFsyncResponse/*: TInterpretFunc<"FSYNC">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "FSYNC" });
+  };
+
+  const interpretAccessResponse/*: TInterpretFunc<"ACCESS">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "ACCESS" });
+  };
+
+  const interpretSetXAttrResponse/*: TInterpretFunc<"SETXATTR">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "SETXATTR" });
+  };
+
+  const interpretRemoveXAttrResponse/*: TInterpretFunc<"REMOVEXATTR">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "REMOVEXATTR" });
+  };
+
+  const interpretFsyncDirResponse/*: TInterpretFunc<"FSYNCDIR">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "FSYNCDIR" });
+  };
+
+  const interpretCreateResponse/*: TInterpretFunc<"CREATE">*/ = ({ unique, payload }) => {
+    const expectedSize = fuseEntryOutParser.size + fuseOpenOutParser.size;
+    if (payload.length !== expectedSize) {
+      return {
+        error: new Error(`Invalid payload size for CREATE response. Expected ${expectedSize} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const entry = fuseEntryOutParser.parse({ data: payload.subarray(0, fuseEntryOutParser.size) });
+    const open = fuseOpenOutParser.parse({ data: payload.subarray(fuseEntryOutParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "CREATE",
+        unique,
+        errorCode: undefined,
+        result: {
+          nodeId: entry.nodeid,
+          generation: entry.generation,
+          entryValidNsec: entry.entry_valid * 1_000_000_000n + entry.entry_valid_nsec,
+          attrValidNsec: entry.attr_valid * 1_000_000_000n + entry.attr_valid_nsec,
+          attr: payloadValueToFuseAttr({ attr: entry.attr }),
+          fh: open.fh,
+          openFlagsToKernel: openFlagsToKernelFromBitmask({ bitmask: open.open_flags }),
+        }
+      }
+    };
+  };
+
+  const interpretDestroyResponse/*: TInterpretFunc<"DESTROY">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "DESTROY" });
+  };
+
+  const interpretGetLkResponse/*: TInterpretFunc<"GETLK">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseLkOutParser.size) {
+      return {
+        error: new Error(`Invalid payload size for GETLK response. Expected ${fuseLkOutParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseLkOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "GETLK",
+        unique,
+        errorCode: undefined,
+        result: {
+          lockStart: parsed.lk.start,
+          lockEnd: parsed.lk.end,
+          lockType: parsed.lk.type,
+          lockPid: parsed.lk.pid,
+        }
+      }
+    };
+  };
+
+  const interpretSetLkResponse/*: TInterpretFunc<"SETLK">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "SETLK" });
+  };
+
+  const interpretSetLkWResponse/*: TInterpretFunc<"SETLKW">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "SETLKW" });
+  };
+
+  const interpretBmapResponse/*: TInterpretFunc<"BMAP">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseBmapOutParser.size) {
+      return {
+        error: new Error(`Invalid payload size for BMAP response. Expected ${fuseBmapOutParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseBmapOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "BMAP",
+        unique,
+        errorCode: undefined,
+        result: {
+          block: parsed.block,
+        }
+      }
+    };
+  };
+
+  const interpretIoctlResponse/*: TInterpretFunc<"IOCTL">*/ = ({ unique, payload }) => {
+    if (payload.length < fuseIoctlOutParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for IOCTL response. Expected at least ${fuseIoctlOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseIoctlOutParser.parse({ data: payload.subarray(0, fuseIoctlOutParser.size) });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "IOCTL",
+        unique,
+        errorCode: undefined,
+        result: {
+          ioctlResult: parsed.result,
+          flags: parsed.flags,
+          data: payload.subarray(fuseIoctlOutParser.size),
+        }
+      }
+    };
+  };
+
+  const interpretPollResponse/*: TInterpretFunc<"POLL">*/ = ({ unique, payload }) => {
+    if (payload.length !== fusePollOutParser.size) {
+      return {
+        error: new Error(`Invalid payload size for POLL response. Expected ${fusePollOutParser.size} bytes, got ${payload.length} bytes.`),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fusePollOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "POLL",
+        unique,
+        errorCode: undefined,
+        result: {
+          revents: parsed.revents,
+        }
+      }
+    };
+  };
+
+  const interpretFallocateResponse/*: TInterpretFunc<"FALLOCATE">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "FALLOCATE" });
+  };
+
+  const interpretReadDirPlusResponse/*: TInterpretFunc<"READDIRPLUS">*/ = ({ unique, payload }) => {
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "READDIRPLUS",
+        unique,
+        errorCode: undefined,
+        result: {
+          data: payload,
+        }
+      }
+    };
+  };
+
+  const interpretStatFsResponse/*: TInterpretFunc<"STATFS">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseStatfsOutParser.size) {
+      return {
+        error: new Error(
+          `Invalid payload size for STATFS response. Expected ${fuseStatfsOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const statFsResult = fuseStatfsOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "STATFS",
+        unique,
+        errorCode: undefined,
+        result: {
+          blocks: statFsResult.st.blocks,
+          bfree: statFsResult.st.bfree,
+          bavail: statFsResult.st.bavail,
+          files: statFsResult.st.files,
+          ffree: statFsResult.st.ffree,
+          bsize: statFsResult.st.bsize,
+          namelen: statFsResult.st.namelen,
+          frsize: statFsResult.st.frsize,
+        }
+      }
+    };
+  };
+
+  const interpretMessageToKernel = (
+    { request, parsedMessageToKernel }/*: { request: TFuseRequest, parsedMessageToKernel: TParsedMessageToKernel }*/
+  )/*: TGenericInterpretResult<TFuseResponse>*/ => {
+
+    const unique = parsedMessageToKernel.header.unique;
+    const forOpcode = request.opcode /*as TFuseResponse["forOpcode"]*/;
+
+    if (parsedMessageToKernel.header.error !== 0n) {
+      return {
+        error: undefined,
+        interpreted: {
+          forOpcode,
+          unique,
+          errorCode: Number(parsedMessageToKernel.header.error),
+          result: undefined,
+        } /*as Extract<TFuseResponse, { forOpcode: typeof forOpcode; errorCode: number }>*/,
+      };
+    }
+
+    switch (forOpcode) {
+    case "INIT": {
+      return interpretInitResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "GETATTR": {
+      return interpretGetAttrResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SETATTR": {
+      return interpretSetAttrResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "LISTXATTR": {
+      return interpretListXAttrResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+        request: request /*as Extract<TFuseRequest, { opcode: "LISTXATTR" }>*/,
+      });
+    }
+
+    case "GETXATTR": {
+      return interpretGetXAttrResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+        request: request /*as Extract<TFuseRequest, { opcode: "GETXATTR" }>*/,
+      });
+    }
+
+    case "READLINK": {
+      return interpretReadLinkResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "MKNOD": {
+      return interpretMknodResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "OPENDIR": {
+      return interpretOpenDirResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "READDIR": {
+      return interpretReadDirResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "RELEASEDIR": {
+      return interpretReleaseDirResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "FSYNCDIR": {
+      return interpretFsyncDirResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "RELEASE": {
+      return interpretReleaseResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "STATFS": {
+      return interpretStatFsResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "LOOKUP": {
+      return interpretLookupResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SYMLINK": {
+      return interpretSymlinkResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "LINK": {
+      return interpretLinkResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "MKDIR": {
+      return interpretMkdirResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "UNLINK": {
+      return interpretUnlinkResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "RMDIR": {
+      return interpretRmDirResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "RENAME": {
+      return interpretRenameResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "OPEN": {
+      return interpretOpenResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "READ": {
+      return interpretReadResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "WRITE": {
+      return interpretWriteResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "FLUSH": {
+      return interpretFlushResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "FSYNC": {
+      return interpretFsyncResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "ACCESS": {
+      return interpretAccessResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SETXATTR": {
+      return interpretSetXAttrResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "REMOVEXATTR": {
+      return interpretRemoveXAttrResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "CREATE": {
+      return interpretCreateResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "DESTROY": {
+      return interpretDestroyResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "GETLK": {
+      return interpretGetLkResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SETLK": {
+      return interpretSetLkResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SETLKW": {
+      return interpretSetLkWResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "BMAP": {
+      return interpretBmapResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "IOCTL": {
+      return interpretIoctlResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "POLL": {
+      return interpretPollResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "FALLOCATE": {
+      return interpretFallocateResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "READDIRPLUS": {
+      return interpretReadDirPlusResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    default: {
+      throw Error(`unsupported opcode for interpretation: ${forOpcode}`);
+    }
+    }
+  };
+
+  return {
+    encodeMessageToKernel,
+    interpretMessageToKernel,
+  };
+};
+
+export {
+  createMessageFromKernelInterpreter,
+  createMessageToKernelInterpreter,
+};
+
+/*export type {
+  TFuseRequest,
+  TFuseResponse,
+};*/