@k13engineering/linux-fuse 0.0.4 → 0.0.5

package/dist/lib/protocol.js

@@ -8,6 +8,7 @@ import {
   fuseBatchForgetInParser,
   fuseBmapInParser,
   fuseBmapOutParser,
+  fuseCopyFileRangeInParser,
   fuseCreateInParser,
   fuseEntryOutParser,
   fuseFallocateInParser,
@@ -26,6 +27,8 @@ import {
   fuseLinkInParser,
   fuseLkInParser,
   fuseLkOutParser,
+  fuseLseekInParser,
+  fuseLseekOutParser,
   fuseMkdirInParser,
   fuseMknodInParser,
   fuseOpenInParser,
@@ -34,11 +37,17 @@ import {
   fusePollOutParser,
   fuseReadInParser,
   fuseReleaseInParser,
+  fuseRemovemappingInParser,
+  fuseRemovemappingOneParser,
   fuseRename2InParser,
   fuseRenameInParser,
   fuseSetattrInParser,
+  fuseSetupmappingInParser,
   fuseSetxattrInParser,
   fuseStatfsOutParser,
+  fuseStatxInParser,
+  fuseStatxOutParser,
+  fuseSyncfsInParser,
   fuseWriteInParser,
   fuseWriteOutParser,
 } from "./abi.js";
@@ -101,6 +110,33 @@ import {
   size: bigint;
 };*/
 
+/*type TFuseSxTime = {
+  sec: bigint;
+  nsec: bigint;
+};*/
+
+/*type TFuseStatx = {
+  mask: bigint;
+  blksize: bigint;
+  attributes: bigint;
+  nlink: bigint;
+  uid: bigint;
+  gid: bigint;
+  mode: bigint;
+  ino: bigint;
+  size: bigint;
+  blocks: bigint;
+  attributesMask: bigint;
+  atime: TFuseSxTime;
+  btime: TFuseSxTime;
+  ctime: TFuseSxTime;
+  mtime: TFuseSxTime;
+  rdevMajor: bigint;
+  rdevMinor: bigint;
+  devMajor: bigint;
+  devMinor: bigint;
+};*/
+
 /*type TFuseRequest = {
   unique: bigint;
   requester: TRequesterInfo;
@@ -353,6 +389,54 @@ import {
   readFlags: bigint;
   lockOwner: bigint;
   flags: bigint;
+} | {
+  opcode: "LSEEK";
+  nodeId: bigint;
+  fh: bigint;
+  offset: bigint;
+  whence: bigint;
+} | {
+  opcode: "COPY_FILE_RANGE";
+  nodeId: bigint;
+  fhIn: bigint;
+  offIn: bigint;
+  nodeIdOut: bigint;
+  fhOut: bigint;
+  offOut: bigint;
+  len: bigint;
+  flags: bigint;
+} | {
+  opcode: "SETUPMAPPING";
+  nodeId: bigint;
+  fh: bigint;
+  foffset: bigint;
+  len: bigint;
+  flags: bigint;
+  moffset: bigint;
+} | {
+  opcode: "REMOVEMAPPING";
+  nodeId: bigint;
+  mappings: Array<{
+    moffset: bigint;
+    len: bigint;
+  }>;
+} | {
+  opcode: "SYNCFS";
+  nodeId: bigint;
+} | {
+  opcode: "TMPFILE";
+  parentNodeId: bigint;
+  name: string;
+  flags: bigint;
+  mode: bigint;
+  umask: bigint;
+} | {
+  opcode: "STATX";
+  nodeId: bigint;
+  getattrFlags: bigint;
+  fh: bigint;
+  sxFlags: bigint;
+  sxMask: bigint;
 });*/
 
 
@@ -797,6 +881,87 @@ import {
   result: {
     data: Uint8Array;
   };
+} | {
+  forOpcode: "LSEEK";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "LSEEK";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    offset: bigint;
+  };
+} | {
+  forOpcode: "COPY_FILE_RANGE";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "COPY_FILE_RANGE";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    bytesWritten: bigint;
+  };
+} | {
+  forOpcode: "SETUPMAPPING";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SETUPMAPPING";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "REMOVEMAPPING";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "REMOVEMAPPING";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "SYNCFS";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "SYNCFS";
+  unique: bigint;
+  errorCode: undefined;
+  result: Record<string, never>;
+} | {
+  forOpcode: "TMPFILE";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "TMPFILE";
+  unique: bigint;
+  errorCode: undefined;
+  result: TFuseEntry & {
+    fh: bigint;
+    openFlagsToKernel: TOpenFlagsToKernel;
+  };
+} | {
+  forOpcode: "STATX";
+  unique: bigint;
+  errorCode: number;
+  result: undefined;
+} | {
+  forOpcode: "STATX";
+  unique: bigint;
+  errorCode: undefined;
+  result: {
+    attrValidNsec: bigint;
+    flags: bigint;
+    stat: TFuseStatx;
+  };
 };*/
 
 /*type TGenericInterpretResult<T> = {
@@ -2083,6 +2248,210 @@ const createMessageFromKernelInterpreter = () => {
     };
   };
 
+  const interpretLseek/*: TInterpretFunc<"LSEEK">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseLseekInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for LSEEK request. Expected ${fuseLseekInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, offset, whence } = fuseLseekInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "LSEEK",
+        nodeId,
+        fh,
+        offset,
+        whence,
+      }
+    };
+  };
+
+  const interpretCopyFileRange/*: TInterpretFunc<"COPY_FILE_RANGE">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseCopyFileRangeInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for COPY_FILE_RANGE request. Expected ${fuseCopyFileRangeInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh_in, off_in, nodeid_out, fh_out, off_out, len, flags } = fuseCopyFileRangeInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "COPY_FILE_RANGE",
+        nodeId,
+        fhIn: fh_in,
+        offIn: off_in,
+        nodeIdOut: nodeid_out,
+        fhOut: fh_out,
+        offOut: off_out,
+        len,
+        flags,
+      }
+    };
+  };
+
+  const interpretSetupMapping/*: TInterpretFunc<"SETUPMAPPING">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseSetupmappingInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for SETUPMAPPING request. Expected ${fuseSetupmappingInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { fh, foffset, len, flags, moffset } = fuseSetupmappingInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "SETUPMAPPING",
+        nodeId,
+        fh,
+        foffset,
+        len,
+        flags,
+        moffset,
+      }
+    };
+  };
+
+  const interpretRemoveMapping/*: TInterpretFunc<"REMOVEMAPPING">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseRemovemappingInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for REMOVEMAPPING request. ` +
+          `Expected at least ${fuseRemovemappingInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const header = fuseRemovemappingInParser.parse({ data: payload.subarray(0, fuseRemovemappingInParser.size) });
+    const count = Number(header.count);
+    const expectedSize = fuseRemovemappingInParser.size + (count * fuseRemovemappingOneParser.size);
+    if (payload.length !== expectedSize) {
+      return {
+        error: Error(
+          `Invalid payload size for REMOVEMAPPING request. Expected ${expectedSize} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    let mappings/*: Array<{ moffset: bigint; len: bigint }>*/ = [];
+    for (let index = 0; index < count; index += 1) {
+      const start = fuseRemovemappingInParser.size + (index * fuseRemovemappingOneParser.size);
+      const parsed = fuseRemovemappingOneParser.parse({ data: payload.subarray(start, start + fuseRemovemappingOneParser.size) });
+      mappings = [...mappings, {
+        moffset: parsed.moffset,
+        len: parsed.len,
+      }];
+    }
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "REMOVEMAPPING",
+        nodeId,
+        mappings,
+      }
+    };
+  };
+
+  const interpretSyncFs/*: TInterpretFunc<"SYNCFS">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseSyncfsInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for SYNCFS request. Expected ${fuseSyncfsInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "SYNCFS",
+        nodeId,
+      }
+    };
+  };
+
+  const interpretTmpFile/*: TInterpretFunc<"TMPFILE">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length < fuseCreateInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for TMPFILE 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: "TMPFILE",
+        parentNodeId: nodeId,
+        name: decodeCString(payload.subarray(fuseCreateInParser.size)),
+        flags,
+        mode,
+        umask,
+      }
+    };
+  };
+
+  const interpretStatx/*: TInterpretFunc<"STATX">*/ = ({ unique, nodeId, requester, payload }) => {
+    if (payload.length !== fuseStatxInParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for STATX request. Expected ${fuseStatxInParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const { getattr_flags, fh, sx_flags, sx_mask } = fuseStatxInParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        unique,
+        requester,
+        opcode: "STATX",
+        nodeId,
+        getattrFlags: getattr_flags,
+        fh,
+        sxFlags: sx_flags,
+        sxMask: sx_mask,
+      }
+    };
+  };
+
   const interpretMessageFromKernel = (
     { parsedMessageFromKernel }/*: { parsedMessageFromKernel: TParsedMessageFromKernel }*/
   )/*: TGenericInterpretResult<TFuseRequest>*/ => {
@@ -2490,10 +2859,73 @@ const createMessageFromKernelInterpreter = () => {
       });
     }
 
-    default: {
-      break;
-    }
-    }
+    case BigInt(opcode.LSEEK): {
+      return interpretLseek({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.COPY_FILE_RANGE): {
+      return interpretCopyFileRange({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.SETUPMAPPING): {
+      return interpretSetupMapping({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.REMOVEMAPPING): {
+      return interpretRemoveMapping({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.SYNCFS): {
+      return interpretSyncFs({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.TMPFILE): {
+      return interpretTmpFile({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    case BigInt(opcode.STATX): {
+      return interpretStatx({
+        unique,
+        nodeId,
+        requester,
+        payload: parsedMessageFromKernel.payload,
+      });
+    }
+
+    default: {
+      break;
+    }
+    }
 
     return {
       error: Error(`Unsupported opcode: ${parsedMessageFromKernel.header.opcode}`),
@@ -2921,6 +3353,144 @@ const createMessageToKernelInterpreter = () => {
     };
   };
 
+  const encodeLseekResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "LSEEK", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const payload = fuseLseekOutParser.format({
+      value: {
+        offset: response.result.offset,
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodeCopyFileRangeResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "COPY_FILE_RANGE", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const payload = fuseWriteOutParser.format({
+      value: {
+        size: response.result.bytesWritten,
+        padding: 0n,
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
+  const encodeSetupMappingResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SETUPMAPPING", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeRemoveMappingResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "REMOVEMAPPING", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeSyncFsResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "SYNCFS", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    return encodeEmptyPayload({ unique: response.unique });
+  };
+
+  const encodeTmpFileResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "TMPFILE", 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 fuseStatxToPayloadValue = ({ stat }/*: { stat: TFuseStatx }*/) => {
+    return {
+      mask: stat.mask,
+      blksize: stat.blksize,
+      attributes: stat.attributes,
+      nlink: stat.nlink,
+      uid: stat.uid,
+      gid: stat.gid,
+      mode: stat.mode,
+      __spare0: [0n],
+      ino: stat.ino,
+      size: stat.size,
+      blocks: stat.blocks,
+      attributes_mask: stat.attributesMask,
+      atime: { tv_sec: stat.atime.sec, tv_nsec: stat.atime.nsec, __reserved: 0n },
+      btime: { tv_sec: stat.btime.sec, tv_nsec: stat.btime.nsec, __reserved: 0n },
+      ctime: { tv_sec: stat.ctime.sec, tv_nsec: stat.ctime.nsec, __reserved: 0n },
+      mtime: { tv_sec: stat.mtime.sec, tv_nsec: stat.mtime.nsec, __reserved: 0n },
+      rdev_major: stat.rdevMajor,
+      rdev_minor: stat.rdevMinor,
+      dev_major: stat.devMajor,
+      dev_minor: stat.devMinor,
+      __spare2: [0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n],
+    };
+  };
+
+  const encodeStatxResponse = (
+    { response }/*: { response: Extract<TFuseResponse, { forOpcode: "STATX", errorCode: undefined }> }*/
+  )/*: TParsedMessageToKernel*/ => {
+    const payload = fuseStatxOutParser.format({
+      value: {
+        attr_valid: response.result.attrValidNsec / 1_000_000_000n,
+        attr_valid_nsec: response.result.attrValidNsec % 1_000_000_000n,
+        flags: response.result.flags,
+        spare: [0n, 0n],
+        stat: fuseStatxToPayloadValue({ stat: response.result.stat }),
+      }
+    });
+
+    return {
+      header: {
+        unique: response.unique,
+        error: 0n,
+      },
+      payload,
+    };
+  };
+
   const encodeMessageToKernel = ({ response }/*: { response: TFuseResponse }*/)/*: TParsedMessageToKernel*/ => {
 
     if (response.errorCode !== undefined) {
@@ -3091,6 +3661,34 @@ const createMessageToKernelInterpreter = () => {
       return encodeReadDirPlusResponse({ response });
     }
 
+    case "LSEEK": {
+      return encodeLseekResponse({ response });
+    }
+
+    case "COPY_FILE_RANGE": {
+      return encodeCopyFileRangeResponse({ response });
+    }
+
+    case "SETUPMAPPING": {
+      return encodeSetupMappingResponse({ response });
+    }
+
+    case "REMOVEMAPPING": {
+      return encodeRemoveMappingResponse({ response });
+    }
+
+    case "SYNCFS": {
+      return encodeSyncFsResponse({ response });
+    }
+
+    case "TMPFILE": {
+      return encodeTmpFileResponse({ response });
+    }
+
+    case "STATX": {
+      return encodeStatxResponse({ response });
+    }
+
     default: {
       // @ts-expect-error exhaustiveness check
       throw Error(`Unsupported opcode: ${response.forOpcode}`);
@@ -3454,6 +4052,150 @@ const createMessageToKernelInterpreter = () => {
     };
   };
 
+  const interpretLseekResponse/*: TInterpretFunc<"LSEEK">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseLseekOutParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for LSEEK response. Expected ${fuseLseekOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseLseekOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "LSEEK",
+        unique,
+        errorCode: undefined,
+        result: {
+          offset: parsed.offset,
+        }
+      }
+    };
+  };
+
+  const interpretCopyFileRangeResponse/*: TInterpretFunc<"COPY_FILE_RANGE">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseWriteOutParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for COPY_FILE_RANGE response. Expected ${fuseWriteOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseWriteOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "COPY_FILE_RANGE",
+        unique,
+        errorCode: undefined,
+        result: {
+          bytesWritten: parsed.size,
+        }
+      }
+    };
+  };
+
+  const interpretSetupMappingResponse/*: TInterpretFunc<"SETUPMAPPING">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "SETUPMAPPING" });
+  };
+
+  const interpretRemoveMappingResponse/*: TInterpretFunc<"REMOVEMAPPING">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "REMOVEMAPPING" });
+  };
+
+  const interpretSyncFsResponse/*: TInterpretFunc<"SYNCFS">*/ = ({ unique }) => {
+    return interpretEmptyPayload({ unique, forOpcode: "SYNCFS" });
+  };
+
+  const interpretTmpFileResponse/*: TInterpretFunc<"TMPFILE">*/ = ({ unique, payload }) => {
+    const expectedSize = fuseEntryOutParser.size + fuseOpenOutParser.size;
+    if (payload.length !== expectedSize) {
+      return {
+        error: Error(`Invalid payload size for TMPFILE 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: "TMPFILE",
+        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 payloadValueToFuseStatx = ({ stat }/*: { stat: ReturnType<typeof fuseStatxOutParser.parse>["stat"] }*/)/*: TFuseStatx*/ => {
+    return {
+      mask: stat.mask,
+      blksize: stat.blksize,
+      attributes: stat.attributes,
+      nlink: stat.nlink,
+      uid: stat.uid,
+      gid: stat.gid,
+      mode: stat.mode,
+      ino: stat.ino,
+      size: stat.size,
+      blocks: stat.blocks,
+      attributesMask: stat.attributes_mask,
+      atime: { sec: stat.atime.tv_sec, nsec: stat.atime.tv_nsec },
+      btime: { sec: stat.btime.tv_sec, nsec: stat.btime.tv_nsec },
+      ctime: { sec: stat.ctime.tv_sec, nsec: stat.ctime.tv_nsec },
+      mtime: { sec: stat.mtime.tv_sec, nsec: stat.mtime.tv_nsec },
+      rdevMajor: stat.rdev_major,
+      rdevMinor: stat.rdev_minor,
+      devMajor: stat.dev_major,
+      devMinor: stat.dev_minor,
+    };
+  };
+
+  const interpretStatxResponse/*: TInterpretFunc<"STATX">*/ = ({ unique, payload }) => {
+    if (payload.length !== fuseStatxOutParser.size) {
+      return {
+        error: Error(
+          `Invalid payload size for STATX response. Expected ${fuseStatxOutParser.size} bytes, got ${payload.length} bytes.`
+        ),
+        interpreted: undefined,
+      };
+    }
+
+    const parsed = fuseStatxOutParser.parse({ data: payload });
+
+    return {
+      error: undefined,
+      interpreted: {
+        forOpcode: "STATX",
+        unique,
+        errorCode: undefined,
+        result: {
+          attrValidNsec: parsed.attr_valid * 1_000_000_000n + parsed.attr_valid_nsec,
+          flags: parsed.flags,
+          stat: payloadValueToFuseStatx({ stat: parsed.stat }),
+        }
+      }
+    };
+  };
+
   const interpretStatFsResponse/*: TInterpretFunc<"STATFS">*/ = ({ unique, payload }) => {
     if (payload.length !== fuseStatfsOutParser.size) {
       return {
@@ -3774,6 +4516,55 @@ const createMessageToKernelInterpreter = () => {
       });
     }
 
+    case "LSEEK": {
+      return interpretLseekResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "COPY_FILE_RANGE": {
+      return interpretCopyFileRangeResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SETUPMAPPING": {
+      return interpretSetupMappingResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "REMOVEMAPPING": {
+      return interpretRemoveMappingResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "SYNCFS": {
+      return interpretSyncFsResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "TMPFILE": {
+      return interpretTmpFileResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
+    case "STATX": {
+      return interpretStatxResponse({
+        unique,
+        payload: parsedMessageToKernel.payload,
+      });
+    }
+
     default: {
       throw Error(`unsupported opcode for interpretation: ${forOpcode}`);
     }
@@ -3794,4 +4585,6 @@ export {
 /*export type {
   TFuseRequest,
   TFuseResponse,
+  TFuseStatx,
+  TFuseSxTime,
 };*/