@jsonjoy.com/json-pack 1.21.0 → 17.59.0

package/lib/nfs/v4/server/operations/node/Nfsv4OperationsNode.js

@@ -21,23 +21,49 @@ const attributes_1 = require("../../../attributes");
 const Writer_1 = require("@jsonjoy.com/buffers/lib/Writer");
 const XdrEncoder_1 = require("../../../../../xdr/XdrEncoder");
 const XdrDecoder_1 = require("../../../../../xdr/XdrDecoder");
+/**
+ * NFS v4 Operations implementation for Node.js `fs` filesystem.
+ */
 class Nfsv4OperationsNode {
     constructor(opts) {
+        /**
+         * Lease time in seconds.
+         * Per RFC 7530 §9.5, this is the time a client has to renew its lease
+         * before the server may reclaim its state. Default is 90 seconds.
+         */
         this.leaseTime = 90;
+        /** Confirmed clients. */
         this.clients = new Map();
+        /** Clients pending SETCLIENTID_CONFIRM confirmation. */
         this.pendingClients = new Map();
+        /** Next client ID to assign. */
         this.nextClientId = 1n;
+        /** Boot stamp, identifies server instance, 16 bits. */
         this.bootStamp = Math.round(Math.random() * 0xffff);
+        /** Next stateid sequence number. */
         this.nextStateidSeqid = 1;
+        /** Map from stateid (as string key) to open file state. */
         this.openFiles = new Map();
+        /** Map from open-owner key to owner state. */
         this.openOwners = new Map();
+        /** Map from lock key to byte-range lock. */
         this.locks = new Map();
+        /** Map from lock-owner key to lock-owner state. */
         this.lockOwners = new Map();
+        /** Map from lock stateid 'other' field to lock stateid state. Per RFC 7530, one stateid per lock-owner per file. */
         this.lockStateids = new Map();
+        /**
+         * Server-wide monotonic change counter for directory change_info.
+         * Incremented on every mutating operation (RENAME, REMOVE, CREATE, etc.).
+         * Used to populate change_info4 before/after values for client cache validation.
+         */
         this.changeCounter = 0n;
+        /**
+         * Default filesystem statistics: 2TB available space, 2M available inodes.
+         */
         this.defaultFsStats = async () => {
-            const twoTB = BigInt(2 * 1024 * 1024 * 1024 * 1024);
-            const twoM = BigInt(2 * 1000 * 1000);
+            const twoTB = BigInt(2 * 1024 * 1024 * 1024 * 1024); // 2TB
+            const twoM = BigInt(2 * 1000 * 1000); // 2M inodes
             return new FilesystemStats_1.FilesystemStats(twoTB, twoTB, twoTB * 2n, twoM, twoM, twoM * 2n);
         };
         this.fs = opts.fs;
@@ -71,6 +97,15 @@ class Nfsv4OperationsNode {
     makeOpenOwnerKey(clientid, owner) {
         return `${clientid}:${Buffer.from(owner).toString('hex')}`;
     }
+    /**
+     * Validates a seqid from a client request against the owner's current seqid.
+     * Per RFC 7530 §9.1.7, the server expects seqid = last_seqid + 1 for new operations,
+     * or seqid = last_seqid for replayed requests (idempotent retry).
+     *
+     * @param requestSeqid - seqid from the client request
+     * @param ownerSeqid - current seqid stored for the owner
+     * @returns 'valid' if seqid matches expected next value, 'replay' if it matches last value, 'invalid' otherwise
+     */
     validateSeqid(requestSeqid, ownerSeqid) {
         const nextSeqid = ownerSeqid === 0xffffffff ? 1 : ownerSeqid + 1;
         if (requestSeqid === nextSeqid)
@@ -79,6 +114,12 @@ class Nfsv4OperationsNode {
             return 'replay';
         return 'invalid';
     }
+    /**
+     * Renews the lease for a client.
+     * Per RFC 7530 §9.5, any stateful operation renews the client's lease.
+     *
+     * @param clientid - The client ID whose lease should be renewed
+     */
     renewClientLease(clientid) {
         const client = this.clients.get(clientid);
         if (client) {
@@ -145,7 +186,7 @@ class Nfsv4OperationsNode {
         return this.lockStateids.get(otherKey);
     }
     hasConflictingLock(path, locktype, offset, length, ownerKey) {
-        const isWriteLock = locktype === 2;
+        const isWriteLock = locktype === 2 /* Nfsv4LockType.WRITE_LT */;
         for (const lock of this.locks.values()) {
             if (lock.path !== path)
                 continue;
@@ -153,11 +194,15 @@ class Nfsv4OperationsNode {
                 continue;
             if (lock.lockOwnerKey === ownerKey)
                 continue;
-            if (isWriteLock || lock.locktype === 2)
+            if (isWriteLock || lock.locktype === 2 /* Nfsv4LockType.WRITE_LT */)
                 return true;
         }
         return false;
     }
+    /**
+     * Establishes client ID or updates callback information.
+     * Returns a client ID and confirmation verifier for SETCLIENTID_CONFIRM.
+     */
     async SETCLIENTID(request, ctx) {
         const principal = ctx.getPrincipal();
         const verifier = request.client.verifier.data;
@@ -169,13 +214,17 @@ class Nfsv4OperationsNode {
         if (confirmedClientEntry) {
             const existingRecord = confirmedClientEntry[1];
             if (existingRecord.principal !== principal)
-                return new msg.Nfsv4SetclientidResponse(10017);
+                return new msg.Nfsv4SetclientidResponse(10017 /* Nfsv4Stat.NFS4ERR_CLID_INUSE */);
             this.pendingClients.delete(clientid);
             clientid = confirmedClientEntry[0];
             const verifierMatch = (0, cmpUint8Array_1.cmpUint8Array)(existingRecord.verifier, verifier);
             if (verifierMatch) {
+                // The client is re-registering with the same ID string and verifier.
+                // Update callback information, return existing client ID and issue
+                // new confirm verifier.
             }
             else {
+                // The client is re-registering with the same ID string but different verifier.
                 clientid = this.nextClientId++;
             }
         }
@@ -184,19 +233,23 @@ class Nfsv4OperationsNode {
             if (pendingClientEntry) {
                 const existingRecord = pendingClientEntry[1];
                 if (existingRecord.principal !== principal)
-                    return new msg.Nfsv4SetclientidResponse(10017);
+                    return new msg.Nfsv4SetclientidResponse(10017 /* Nfsv4Stat.NFS4ERR_CLID_INUSE */);
                 const verifierMatch = (0, cmpUint8Array_1.cmpUint8Array)(existingRecord.verifier, verifier);
                 if (verifierMatch && existingRecord.cache) {
+                    // The client is re-registering with the same ID string and verifier.
+                    // Return cached response.
                     return existingRecord.cache;
                 }
             }
+            // New client ID string. Create new client record.
             clientid = this.nextClientId++;
         }
         const setclientidConfirm = (0, node_crypto_1.randomBytes)(8);
         const verifierStruct = new struct.Nfsv4Verifier(setclientidConfirm);
         const body = new msg.Nfsv4SetclientidResOk(clientid, verifierStruct);
-        const response = new msg.Nfsv4SetclientidResponse(0, body);
+        const response = new msg.Nfsv4SetclientidResponse(0 /* Nfsv4Stat.NFS4_OK */, body);
         const newRecord = new ClientRecord_1.ClientRecord(principal, verifier, clientIdString, callback, callbackIdent, setclientidConfirm, response);
+        // Remove any existing pending records with same ID string.
         for (const [id, entry] of this.pendingClients.entries())
             if ((0, cmpUint8Array_1.cmpUint8Array)(entry.clientIdString, clientIdString))
                 this.pendingClients.delete(id);
@@ -204,6 +257,10 @@ class Nfsv4OperationsNode {
         this.pendingClients.set(clientid, newRecord);
         return response;
     }
+    /**
+     * Confirms a client ID established by SETCLIENTID.
+     * Transitions unconfirmed client record to confirmed state.
+     */
     async SETCLIENTID_CONFIRM(request, ctx) {
         const { clients, pendingClients } = this;
         const clientid = request.clientid;
@@ -212,14 +269,14 @@ class Nfsv4OperationsNode {
         if (!pendingRecord) {
             const confirmedRecord = this.clients.get(clientid);
             if (confirmedRecord && (0, cmpUint8Array_1.cmpUint8Array)(confirmedRecord.setclientidConfirm, setclientidConfirm))
-                return new msg.Nfsv4SetclientidConfirmResponse(0);
-            return new msg.Nfsv4SetclientidConfirmResponse(10022);
+                return new msg.Nfsv4SetclientidConfirmResponse(0 /* Nfsv4Stat.NFS4_OK */);
+            return new msg.Nfsv4SetclientidConfirmResponse(10022 /* Nfsv4Stat.NFS4ERR_STALE_CLIENTID */);
         }
         const principal = ctx.getPrincipal();
         if (pendingRecord.principal !== principal)
-            return new msg.Nfsv4SetclientidConfirmResponse(10017);
+            return new msg.Nfsv4SetclientidConfirmResponse(10017 /* Nfsv4Stat.NFS4ERR_CLID_INUSE */);
         if (!(0, cmpUint8Array_1.cmpUint8Array)(pendingRecord.setclientidConfirm, setclientidConfirm))
-            return new msg.Nfsv4SetclientidConfirmResponse(10022);
+            return new msg.Nfsv4SetclientidConfirmResponse(10022 /* Nfsv4Stat.NFS4ERR_STALE_CLIENTID */);
         const oldConfirmed = this.findClientByIdString(this.clients, pendingRecord.clientIdString);
         if (oldConfirmed) {
             const clientid2 = oldConfirmed[0];
@@ -228,6 +285,7 @@ class Nfsv4OperationsNode {
         }
         this.clients.delete(clientid);
         pendingClients.delete(clientid);
+        // Remove any existing pending records with same ID string.
         const clientIdString = pendingRecord.clientIdString;
         for (const [id, entry] of pendingClients.entries())
             if ((0, cmpUint8Array_1.cmpUint8Array)(entry.clientIdString, clientIdString))
@@ -237,49 +295,49 @@ class Nfsv4OperationsNode {
                 clients.delete(id);
         this.enforceClientLimit();
         clients.set(clientid, pendingRecord);
-        return new msg.Nfsv4SetclientidConfirmResponse(0);
+        return new msg.Nfsv4SetclientidConfirmResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async ILLEGAL(request, ctx) {
         ctx.connection.logger.log('ILLEGAL', request);
-        return new msg.Nfsv4IllegalResponse(10044);
+        return new msg.Nfsv4IllegalResponse(10044 /* Nfsv4Stat.NFS4ERR_OP_ILLEGAL */);
     }
     async PUTROOTFH(request, ctx) {
         ctx.cfh = fh_1.ROOT_FH;
-        return new msg.Nfsv4PutrootfhResponse(0);
+        return new msg.Nfsv4PutrootfhResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async PUTPUBFH(request, ctx) {
         ctx.cfh = fh_1.ROOT_FH;
-        return new msg.Nfsv4PutpubfhResponse(0);
+        return new msg.Nfsv4PutpubfhResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async PUTFH(request, ctx) {
         const fh = request.object.data;
-        if (fh.length > 128)
-            throw 10001;
+        if (fh.length > 128 /* Nfsv4Const.FHSIZE */)
+            throw 10001 /* Nfsv4Stat.NFS4ERR_BADHANDLE */;
         const valid = this.fh.validate(fh);
         if (!valid)
-            throw 10001;
+            throw 10001 /* Nfsv4Stat.NFS4ERR_BADHANDLE */;
         ctx.cfh = fh;
-        return new msg.Nfsv4PutfhResponse(0);
+        return new msg.Nfsv4PutfhResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async GETFH(request, ctx) {
         const cfh = ctx.cfh;
         if (!cfh)
-            throw 10020;
+            throw 10020 /* Nfsv4Stat.NFS4ERR_NOFILEHANDLE */;
         const fh = new struct.Nfsv4Fh(cfh);
         const body = new msg.Nfsv4GetfhResOk(fh);
-        return new msg.Nfsv4GetfhResponse(0, body);
+        return new msg.Nfsv4GetfhResponse(0 /* Nfsv4Stat.NFS4_OK */, body);
     }
     async RESTOREFH(request, ctx) {
         if (!ctx.sfh)
-            throw 10030;
+            throw 10030 /* Nfsv4Stat.NFS4ERR_RESTOREFH */;
         ctx.cfh = ctx.sfh;
-        return new msg.Nfsv4RestorefhResponse(0);
+        return new msg.Nfsv4RestorefhResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async SAVEFH(request, ctx) {
         if (!ctx.cfh)
-            throw 10020;
+            throw 10020 /* Nfsv4Stat.NFS4ERR_NOFILEHANDLE */;
         ctx.sfh = ctx.cfh;
-        return new msg.Nfsv4SavefhResponse(0);
+        return new msg.Nfsv4SavefhResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     absolutePath(path) {
         const dir = this.dir;
@@ -289,9 +347,9 @@ class Nfsv4OperationsNode {
             return path;
         const absolutePath = NodePath.join(dir, path);
         if (absolutePath.length < dir.length)
-            throw 2;
+            throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
         if (!absolutePath.startsWith(dir))
-            throw 2;
+            throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
         return absolutePath;
     }
     async LOOKUP(request, ctx) {
@@ -300,7 +358,7 @@ class Nfsv4OperationsNode {
         const currentPathAbsolute = this.absolutePath(currentPath);
         const component = request.objname;
         if (component.length === 0)
-            throw 22;
+            throw 22 /* Nfsv4Stat.NFS4ERR_INVAL */;
         const promises = this.promises;
         let stats;
         try {
@@ -308,28 +366,28 @@ class Nfsv4OperationsNode {
         }
         catch (err) {
             if ((0, util_1.isErrCode)('ENOENT', err))
-                throw 2;
-            throw 5;
+                throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
+            throw 5 /* Nfsv4Stat.NFS4ERR_IO */;
         }
         if (stats.isSymbolicLink())
-            throw 10029;
+            throw 10029 /* Nfsv4Stat.NFS4ERR_SYMLINK */;
         if (!stats.isDirectory())
-            throw 20;
+            throw 20 /* Nfsv4Stat.NFS4ERR_NOTDIR */;
         const targetAbsolutePath = NodePath.join(currentPathAbsolute, component);
         try {
             const targetStats = await promises.stat(targetAbsolutePath);
             if (!targetStats)
-                throw 2;
+                throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
         }
         catch (err) {
             if ((0, util_1.isErrCode)('ENOENT', err))
-                throw 2;
+                throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
             if ((0, util_1.isErrCode)('EACCES', err))
-                throw 13;
-            throw 5;
+                throw 13 /* Nfsv4Stat.NFS4ERR_ACCESS */;
+            throw 5 /* Nfsv4Stat.NFS4ERR_IO */;
         }
         fh.setCfh(ctx, targetAbsolutePath);
-        return new msg.Nfsv4LookupResponse(0);
+        return new msg.Nfsv4LookupResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async LOOKUPP(request, ctx) {
         const fh = this.fh;
@@ -342,16 +400,16 @@ class Nfsv4OperationsNode {
         }
         catch (err) {
             if ((0, util_1.isErrCode)('ENOENT', err))
-                throw 2;
-            throw 5;
+                throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
+            throw 5 /* Nfsv4Stat.NFS4ERR_IO */;
         }
         if (!stats.isDirectory())
-            throw 20;
+            throw 20 /* Nfsv4Stat.NFS4ERR_NOTDIR */;
         const parentAbsolutePath = NodePath.dirname(currentPathAbsolute);
         if (parentAbsolutePath.length < this.dir.length)
-            throw 2;
+            throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
         fh.setCfh(ctx, parentAbsolutePath);
-        return new msg.Nfsv4LookuppResponse(0);
+        return new msg.Nfsv4LookuppResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async GETATTR(request, ctx) {
         const currentPath = this.fh.currentPath(ctx);
@@ -378,7 +436,7 @@ class Nfsv4OperationsNode {
             }
         }
         const attrs = (0, attrs_1.encodeAttrs)(request.attrRequest, stats, currentPath, ctx.cfh, this.leaseTime, fsStats);
-        return new msg.Nfsv4GetattrResponse(0, new msg.Nfsv4GetattrResOk(attrs));
+        return new msg.Nfsv4GetattrResponse(0 /* Nfsv4Stat.NFS4_OK */, new msg.Nfsv4GetattrResOk(attrs));
     }
     async ACCESS(request, ctx) {
         const currentPath = this.fh.currentPath(ctx);
@@ -396,43 +454,43 @@ class Nfsv4OperationsNode {
         const mode = stats.mode;
         let supported = 0;
         let access = 0;
-        if (requestedAccess & 1) {
-            supported |= 1;
+        if (requestedAccess & 1 /* Nfsv4Access.ACCESS4_READ */) {
+            supported |= 1 /* Nfsv4Access.ACCESS4_READ */;
             if (mode & 0o444)
-                access |= 1;
+                access |= 1 /* Nfsv4Access.ACCESS4_READ */;
         }
-        if (requestedAccess & 2) {
-            supported |= 2;
+        if (requestedAccess & 2 /* Nfsv4Access.ACCESS4_LOOKUP */) {
+            supported |= 2 /* Nfsv4Access.ACCESS4_LOOKUP */;
             if (isDirectory && mode & 0o111)
-                access |= 2;
+                access |= 2 /* Nfsv4Access.ACCESS4_LOOKUP */;
         }
-        if (requestedAccess & 4) {
-            supported |= 4;
+        if (requestedAccess & 4 /* Nfsv4Access.ACCESS4_MODIFY */) {
+            supported |= 4 /* Nfsv4Access.ACCESS4_MODIFY */;
             if (mode & 0o222)
-                access |= 4;
+                access |= 4 /* Nfsv4Access.ACCESS4_MODIFY */;
         }
-        if (requestedAccess & 8) {
-            supported |= 8;
+        if (requestedAccess & 8 /* Nfsv4Access.ACCESS4_EXTEND */) {
+            supported |= 8 /* Nfsv4Access.ACCESS4_EXTEND */;
             if (mode & 0o222)
-                access |= 8;
+                access |= 8 /* Nfsv4Access.ACCESS4_EXTEND */;
         }
-        if (requestedAccess & 16) {
+        if (requestedAccess & 16 /* Nfsv4Access.ACCESS4_DELETE */) {
             if (!isDirectory) {
                 supported |= 0;
             }
             else {
-                supported |= 16;
+                supported |= 16 /* Nfsv4Access.ACCESS4_DELETE */;
                 if (mode & 0o222)
-                    access |= 16;
+                    access |= 16 /* Nfsv4Access.ACCESS4_DELETE */;
             }
         }
-        if (requestedAccess & 32) {
-            supported |= 32;
+        if (requestedAccess & 32 /* Nfsv4Access.ACCESS4_EXECUTE */) {
+            supported |= 32 /* Nfsv4Access.ACCESS4_EXECUTE */;
             if (!isDirectory && mode & 0o111)
-                access |= 32;
+                access |= 32 /* Nfsv4Access.ACCESS4_EXECUTE */;
         }
         const body = new msg.Nfsv4AccessResOk(supported, access);
-        return new msg.Nfsv4AccessResponse(0, body);
+        return new msg.Nfsv4AccessResponse(0 /* Nfsv4Stat.NFS4_OK */, body);
     }
     async READDIR(request, ctx) {
         const fh = this.fh;
@@ -447,7 +505,7 @@ class Nfsv4OperationsNode {
             throw (0, util_1.normalizeNodeFsError)(error, ctx.connection.logger);
         }
         if (!stats.isDirectory())
-            throw 20;
+            throw 20 /* Nfsv4Stat.NFS4ERR_NOTDIR */;
         const cookie = request.cookie;
         const requestedCookieverf = request.cookieverf.data;
         const maxcount = request.maxcount;
@@ -465,7 +523,7 @@ class Nfsv4OperationsNode {
             const view = new DataView(cookieverf.buffer);
             view.setBigUint64(0, changeTime, false);
             if (!(0, cmpUint8Array_1.cmpUint8Array)(requestedCookieverf, cookieverf))
-                throw 10027;
+                throw 10027 /* Nfsv4Stat.NFS4ERR_NOT_SAME */;
         }
         let dirents;
         try {
@@ -496,7 +554,7 @@ class Nfsv4OperationsNode {
             try {
                 entryStats = await promises.lstat(entryPath);
             }
-            catch (error) {
+            catch (_error) {
                 continue;
             }
             const entryFh = fh.encode(entryPath);
@@ -514,7 +572,7 @@ class Nfsv4OperationsNode {
         }
         const cookieverf2 = new struct.Nfsv4Verifier(cookieverf);
         const body = new msg.Nfsv4ReaddirResOk(cookieverf2, entries, eof);
-        return new msg.Nfsv4ReaddirResponse(0, body);
+        return new msg.Nfsv4ReaddirResponse(0 /* Nfsv4Stat.NFS4_OK */, body);
     }
     async OPEN(request, ctx) {
         const currentPath = this.fh.currentPath(ctx);
@@ -537,15 +595,15 @@ class Nfsv4OperationsNode {
                     previousSeqid = 0;
                 }
                 else {
-                    return new msg.Nfsv4OpenResponse(10026);
+                    return new msg.Nfsv4OpenResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
                 }
             }
             else if (seqidValidation === 'replay') {
                 replayCandidate = true;
             }
         }
-        if (request.claim.claimType !== 0) {
-            return new msg.Nfsv4OpenResponse(10004);
+        if (request.claim.claimType !== 0 /* Nfsv4OpenClaimType.CLAIM_NULL */) {
+            return new msg.Nfsv4OpenResponse(10004 /* Nfsv4Stat.NFS4ERR_NOTSUPP */);
         }
         const claimNull = request.claim.claim;
         const filename = claimNull.file;
@@ -555,16 +613,16 @@ class Nfsv4OperationsNode {
             if (ownerState.lastRequestKey === requestKey && ownerState.lastResponse) {
                 return ownerState.lastResponse;
             }
-            return new msg.Nfsv4OpenResponse(10026);
+            return new msg.Nfsv4OpenResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
         }
         ownerState.seqid = request.seqid;
         const opentype = request.openhow.opentype;
-        const isCreate = opentype === 1;
+        const isCreate = opentype === 1 /* Nfsv4OpenFlags.OPEN4_CREATE */;
         let fileExists = false;
         try {
             const stats = await this.promises.lstat(filePath);
             if (!stats.isFile()) {
-                const response = new msg.Nfsv4OpenResponse(21);
+                const response = new msg.Nfsv4OpenResponse(21 /* Nfsv4Stat.NFS4ERR_ISDIR */);
                 ownerState.lastResponse = response;
                 ownerState.lastRequestKey = requestKey;
                 return response;
@@ -574,7 +632,7 @@ class Nfsv4OperationsNode {
         catch (err) {
             if ((0, util_1.isErrCode)('ENOENT', err)) {
                 if (!isCreate) {
-                    const response = new msg.Nfsv4OpenResponse(2);
+                    const response = new msg.Nfsv4OpenResponse(2 /* Nfsv4Stat.NFS4ERR_NOENT */);
                     ownerState.lastResponse = response;
                     ownerState.lastRequestKey = requestKey;
                     return response;
@@ -590,18 +648,18 @@ class Nfsv4OperationsNode {
         }
         if (fileExists && !this.canAccessFile(filePath, request.shareAccess, request.shareDeny)) {
             ownerState.seqid = previousSeqid;
-            const response = new msg.Nfsv4OpenResponse(10015);
+            const response = new msg.Nfsv4OpenResponse(10015 /* Nfsv4Stat.NFS4ERR_SHARE_DENIED */);
             ownerState.lastResponse = response;
             ownerState.lastRequestKey = requestKey;
             return response;
         }
         let flags = 0;
-        const isWrite = (request.shareAccess & 2) !== 0;
-        const isRead = (request.shareAccess & 1) !== 0;
+        const isWrite = (request.shareAccess & 2 /* Nfsv4OpenAccess.OPEN4_SHARE_ACCESS_WRITE */) !== 0;
+        const isRead = (request.shareAccess & 1 /* Nfsv4OpenAccess.OPEN4_SHARE_ACCESS_READ */) !== 0;
         if (isCreate) {
             flags = this.fs.constants.O_CREAT;
             const createHow = request.openhow.how;
-            if (createHow && createHow.mode === 2) {
+            if (createHow && createHow.mode === 2 /* Nfsv4CreateMode.EXCLUSIVE4 */) {
                 flags |= this.fs.constants.O_EXCL;
             }
         }
@@ -627,9 +685,9 @@ class Nfsv4OperationsNode {
             const after = ++this.changeCounter;
             const cinfo = new struct.Nfsv4ChangeInfo(true, before, after);
             const attrset = new struct.Nfsv4Bitmap([]);
-            const delegation = new struct.Nfsv4OpenDelegation(0);
+            const delegation = new struct.Nfsv4OpenDelegation(0 /* Nfsv4DelegType.OPEN_DELEGATE_NONE */);
             const resok = new msg.Nfsv4OpenResOk(stateid, cinfo, 0, attrset, delegation);
-            const response = new msg.Nfsv4OpenResponse(0, resok);
+            const response = new msg.Nfsv4OpenResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
             ownerState.lastResponse = response;
             ownerState.lastRequestKey = requestKey;
             return response;
@@ -643,23 +701,23 @@ class Nfsv4OperationsNode {
         }
     }
     async OPENATTR(request, ctx) {
-        return new msg.Nfsv4OpenattrResponse(10004);
+        return new msg.Nfsv4OpenattrResponse(10004 /* Nfsv4Stat.NFS4ERR_NOTSUPP */);
     }
     async OPEN_CONFIRM(request, ctx) {
         const stateidKey = this.makeStateidKey(request.openStateid);
         const openFile = this.openFiles.get(stateidKey);
         if (!openFile)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         const ownerState = this.openOwners.get(openFile.openOwnerKey);
         if (!ownerState)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         const seqidValidation = this.validateSeqid(request.seqid, ownerState.seqid);
         if (seqidValidation === 'invalid')
-            throw 10026;
+            throw 10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */;
         if (seqidValidation === 'replay') {
             const newStateid = new struct.Nfsv4Stateid(openFile.stateid.seqid, openFile.stateid.other);
             const resok = new msg.Nfsv4OpenConfirmResOk(newStateid);
-            return new msg.Nfsv4OpenConfirmResponse(0, resok);
+            return new msg.Nfsv4OpenConfirmResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         ownerState.seqid = request.seqid;
         openFile.confirmed = true;
@@ -673,29 +731,29 @@ class Nfsv4OperationsNode {
         ownerState.opens.delete(oldKey);
         ownerState.opens.add(newKey);
         const resok = new msg.Nfsv4OpenConfirmResOk(newStateid);
-        return new msg.Nfsv4OpenConfirmResponse(0, resok);
+        return new msg.Nfsv4OpenConfirmResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
     }
     async OPEN_DOWNGRADE(request, ctx) {
         const stateidKey = this.makeStateidKey(request.openStateid);
         const openFile = this.openFiles.get(stateidKey);
         if (!openFile)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         const ownerState = this.openOwners.get(openFile.openOwnerKey);
         if (!ownerState)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         const seqidValidation = this.validateSeqid(request.seqid, ownerState.seqid);
         if (seqidValidation === 'invalid')
-            throw 10026;
+            throw 10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */;
         if (seqidValidation === 'replay') {
             const newStateid = new struct.Nfsv4Stateid(openFile.stateid.seqid, openFile.stateid.other);
             const resok = new msg.Nfsv4OpenDowngradeResOk(newStateid);
-            return new msg.Nfsv4OpenDowngradeResponse(0, resok);
+            return new msg.Nfsv4OpenDowngradeResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         ownerState.seqid = request.seqid;
         if ((request.shareAccess & ~openFile.shareAccess) !== 0)
-            throw 22;
+            throw 22 /* Nfsv4Stat.NFS4ERR_INVAL */;
         if ((request.shareDeny & ~openFile.shareDeny) !== 0)
-            throw 22;
+            throw 22 /* Nfsv4Stat.NFS4ERR_INVAL */;
         const newSeqid = this.nextStateidSeqid++;
         const newStateid = new struct.Nfsv4Stateid(newSeqid, openFile.stateid.other);
         const oldKey = stateidKey;
@@ -706,27 +764,27 @@ class Nfsv4OperationsNode {
         ownerState.opens.delete(oldKey);
         ownerState.opens.add(newKey);
         const resok = new msg.Nfsv4OpenDowngradeResOk(newStateid);
-        return new msg.Nfsv4OpenDowngradeResponse(0, resok);
+        return new msg.Nfsv4OpenDowngradeResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
     }
     async CLOSE(request, ctx) {
         const stateidKey = this.makeStateidKey(request.openStateid);
         const openFile = this.openFiles.get(stateidKey);
         if (!openFile) {
-            return new msg.Nfsv4CloseResponse(0, new msg.Nfsv4CloseResOk(request.openStateid));
+            return new msg.Nfsv4CloseResponse(0 /* Nfsv4Stat.NFS4_OK */, new msg.Nfsv4CloseResOk(request.openStateid));
         }
         const ownerState = this.openOwners.get(openFile.openOwnerKey);
         if (!ownerState) {
-            return new msg.Nfsv4CloseResponse(10025);
+            return new msg.Nfsv4CloseResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
         }
         this.renewClientLease(ownerState.clientid);
         const seqidValidation = this.validateSeqid(request.seqid, ownerState.seqid);
         if (seqidValidation === 'invalid') {
-            return new msg.Nfsv4CloseResponse(10026);
+            return new msg.Nfsv4CloseResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
         }
         if (seqidValidation === 'replay') {
             const newStateid = new struct.Nfsv4Stateid(openFile.stateid.seqid, openFile.stateid.other);
             const resok = new msg.Nfsv4CloseResOk(newStateid);
-            return new msg.Nfsv4CloseResponse(0, resok);
+            return new msg.Nfsv4CloseResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         ownerState.seqid = request.seqid;
         try {
@@ -737,7 +795,7 @@ class Nfsv4OperationsNode {
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
-            if (status !== 2) {
+            if (status !== 2 /* Nfsv4Stat.NFS4ERR_NOENT */) {
                 return new msg.Nfsv4CloseResponse(status);
             }
         }
@@ -749,7 +807,7 @@ class Nfsv4OperationsNode {
         const newSeqid = this.nextStateidSeqid++;
         const newStateid = new struct.Nfsv4Stateid(newSeqid, openFile.stateid.other);
         const resok = new msg.Nfsv4CloseResOk(newStateid);
-        return new msg.Nfsv4CloseResponse(0, resok);
+        return new msg.Nfsv4CloseResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
     }
     async SECINFO(request, ctx) {
         const currentPath = this.fh.currentPath(ctx);
@@ -760,14 +818,14 @@ class Nfsv4OperationsNode {
         }
         catch (err) {
             if ((0, util_1.isErrCode)(err, 'ENOENT')) {
-                return new msg.Nfsv4SecinfoResponse(2);
+                return new msg.Nfsv4SecinfoResponse(2 /* Nfsv4Stat.NFS4ERR_NOENT */);
             }
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
             return new msg.Nfsv4SecinfoResponse(status);
         }
         const flavors = [new struct.Nfsv4SecInfoFlavor(1)];
         const resok = new msg.Nfsv4SecinfoResOk(flavors);
-        return new msg.Nfsv4SecinfoResponse(0, resok);
+        return new msg.Nfsv4SecinfoResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
     }
     async LOCK(request, ctx) {
         const currentPath = this.fh.currentPath(ctx);
@@ -783,31 +841,31 @@ class Nfsv4OperationsNode {
                 }
             }
             if (!existingLockOwnerKey) {
-                return new msg.Nfsv4LockResponse(10025);
+                return new msg.Nfsv4LockResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
             }
             const lockOwnerState = this.lockOwners.get(existingLockOwnerKey);
             if (!lockOwnerState) {
-                return new msg.Nfsv4LockResponse(10025);
+                return new msg.Nfsv4LockResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
             }
             this.renewClientLease(lockOwnerState.clientid);
             const seqidValidation = this.validateSeqid(existingOwner.lockSeqid, lockOwnerState.seqid);
             const requestKey = this.makeLockRequestKey(existingLockOwnerKey, currentPath, locktype, offset, length, existingOwner.lockSeqid);
             if (seqidValidation === 'invalid') {
-                return new msg.Nfsv4LockResponse(10026);
+                return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
             }
             if (seqidValidation === 'replay') {
                 if (lockOwnerState.lastRequestKey !== requestKey) {
-                    return new msg.Nfsv4LockResponse(10026);
+                    return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
                 }
                 if (lockOwnerState.lastResponse)
                     return lockOwnerState.lastResponse;
-                return new msg.Nfsv4LockResponse(10026);
+                return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
             }
             lockOwnerState.seqid = existingOwner.lockSeqid;
             if (this.hasConflictingLock(currentPath, locktype, offset, length, existingLockOwnerKey)) {
                 const conflictOwner = new struct.Nfsv4LockOwner(BigInt(0), new Uint8Array());
                 const denied = new msg.Nfsv4LockResDenied(offset, length, locktype, conflictOwner);
-                return new msg.Nfsv4LockResponse(10010, undefined, denied);
+                return new msg.Nfsv4LockResponse(10010 /* Nfsv4Stat.NFS4ERR_DENIED */, undefined, denied);
             }
             const lockStateid = this.getOrCreateLockStateid(existingLockOwnerKey, currentPath);
             const stateid = lockStateid.incrementAndGetStateid();
@@ -816,7 +874,7 @@ class Nfsv4OperationsNode {
             this.locks.set(lockKey, lock);
             lockOwnerState.locks.add(lockKey);
             const resok = new msg.Nfsv4LockResOk(stateid);
-            const response = new msg.Nfsv4LockResponse(0, resok);
+            const response = new msg.Nfsv4LockResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
             lockOwnerState.lastResponse = response;
             lockOwnerState.lastRequestKey = requestKey;
             return response;
@@ -827,26 +885,26 @@ class Nfsv4OperationsNode {
         const openStateidKey = this.makeStateidKey(openToLock.openStateid);
         const openFile = this.openFiles.get(openStateidKey);
         if (!openFile) {
-            return new msg.Nfsv4LockResponse(10025);
+            return new msg.Nfsv4LockResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
         }
         const openOwnerKey = openFile.openOwnerKey;
         const openOwnerState = this.openOwners.get(openOwnerKey);
         if (!openOwnerState) {
-            return new msg.Nfsv4LockResponse(10025);
+            return new msg.Nfsv4LockResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
         }
         this.renewClientLease(lockOwnerData.clientid);
         const seqidValidation = this.validateSeqid(openToLock.openSeqid, openOwnerState.seqid);
         if (seqidValidation === 'invalid') {
-            return new msg.Nfsv4LockResponse(10026);
+            return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
         }
         if (seqidValidation === 'replay') {
-            for (const [key, lock] of this.locks.entries()) {
+            for (const [_key, lock] of this.locks.entries()) {
                 if (lock.lockOwnerKey === this.makeLockOwnerKey(lockOwnerData.clientid, lockOwnerData.owner) &&
                     lock.path === currentPath &&
                     lock.offset === offset &&
                     lock.length === length) {
                     const resok = new msg.Nfsv4LockResOk(lock.stateid);
-                    return new msg.Nfsv4LockResponse(0, resok);
+                    return new msg.Nfsv4LockResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
                 }
             }
         }
@@ -856,12 +914,12 @@ class Nfsv4OperationsNode {
         if (this.hasConflictingLock(currentPath, locktype, offset, length, lockOwnerKey)) {
             const conflictOwner = new struct.Nfsv4LockOwner(BigInt(0), new Uint8Array());
             const denied = new msg.Nfsv4LockResDenied(offset, length, locktype, conflictOwner);
-            return new msg.Nfsv4LockResponse(10010, undefined, denied);
+            return new msg.Nfsv4LockResponse(10010 /* Nfsv4Stat.NFS4ERR_DENIED */, undefined, denied);
         }
         let lockOwnerState = this.lockOwners.get(lockOwnerKey);
         if (!lockOwnerState) {
             if (openToLock.lockSeqid !== 0) {
-                return new msg.Nfsv4LockResponse(10026);
+                return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
             }
             lockOwnerState = new LockOwnerState_1.LockOwnerState(lockOwnerData.clientid, lockOwnerData.owner, 0);
             this.lockOwners.set(lockOwnerKey, lockOwnerState);
@@ -869,13 +927,13 @@ class Nfsv4OperationsNode {
         else {
             const lockSeqidValidation = this.validateSeqid(openToLock.lockSeqid, lockOwnerState.seqid);
             if (lockSeqidValidation === 'invalid') {
-                return new msg.Nfsv4LockResponse(10026);
+                return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
             }
             if (lockSeqidValidation === 'replay') {
                 if (lockOwnerState.lastRequestKey === lockRequestKey && lockOwnerState.lastResponse) {
                     return lockOwnerState.lastResponse;
                 }
-                return new msg.Nfsv4LockResponse(10026);
+                return new msg.Nfsv4LockResponse(10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */);
             }
         }
         lockOwnerState.seqid = openToLock.lockSeqid;
@@ -886,7 +944,7 @@ class Nfsv4OperationsNode {
         this.locks.set(lockKey, lock);
         lockOwnerState.locks.add(lockKey);
         const resok = new msg.Nfsv4LockResOk(stateid);
-        const response = new msg.Nfsv4LockResponse(0, resok);
+        const response = new msg.Nfsv4LockResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         lockOwnerState.lastResponse = response;
         lockOwnerState.lastRequestKey = lockRequestKey;
         return response;
@@ -898,33 +956,33 @@ class Nfsv4OperationsNode {
         if (this.hasConflictingLock(currentPath, locktype, offset, length, ownerKey)) {
             const conflictOwner = new struct.Nfsv4LockOwner(BigInt(0), new Uint8Array());
             const denied = new msg.Nfsv4LocktResDenied(offset, length, locktype, conflictOwner);
-            return new msg.Nfsv4LocktResponse(10010, denied);
+            return new msg.Nfsv4LocktResponse(10010 /* Nfsv4Stat.NFS4ERR_DENIED */, denied);
         }
-        return new msg.Nfsv4LocktResponse(0);
+        return new msg.Nfsv4LocktResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async LOCKU(request, ctx) {
         const { lockStateid, offset, length, seqid } = request;
         const lockStateidState = this.findLockStateidByOther(lockStateid.other);
         if (!lockStateidState)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         const ownerKey = lockStateidState.lockOwnerKey;
         const lockOwnerState = this.lockOwners.get(ownerKey);
         if (!lockOwnerState)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         this.renewClientLease(lockOwnerState.clientid);
         const currentPath = this.fh.currentPath(ctx);
         if (lockStateidState.path !== currentPath)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         const requestKey = this.makeLockuRequestKey(ownerKey, lockStateid, offset, length, seqid);
         const seqidValidation = this.validateSeqid(seqid, lockOwnerState.seqid);
         if (seqidValidation === 'invalid') {
-            throw 10026;
+            throw 10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */;
         }
         if (seqidValidation === 'replay') {
             if (lockOwnerState.lastRequestKey === requestKey && lockOwnerState.lastResponse) {
                 return lockOwnerState.lastResponse;
             }
-            throw 10026;
+            throw 10026 /* Nfsv4Stat.NFS4ERR_BAD_SEQID */;
         }
         lockOwnerState.seqid = seqid;
         const lockKey = this.makeLockKey(lockStateid, offset, length);
@@ -935,7 +993,7 @@ class Nfsv4OperationsNode {
         }
         const stateid = lockStateidState.incrementAndGetStateid();
         const resok = new msg.Nfsv4LockuResOk(stateid);
-        const response = new msg.Nfsv4LockuResponse(0, resok);
+        const response = new msg.Nfsv4LockuResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         lockOwnerState.lastResponse = response;
         lockOwnerState.lastRequestKey = requestKey;
         return response;
@@ -945,26 +1003,27 @@ class Nfsv4OperationsNode {
         const ownerKey = this.makeLockOwnerKey(lockOwner.clientid, lockOwner.owner);
         const lockOwnerState = this.lockOwners.get(ownerKey);
         if (!lockOwnerState)
-            throw 10025;
+            throw 10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */;
         for (const lockKey of lockOwnerState.locks)
             this.locks.delete(lockKey);
         this.lockOwners.delete(ownerKey);
-        return new msg.Nfsv4ReleaseLockOwnerResponse(0);
+        return new msg.Nfsv4ReleaseLockOwnerResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async RENEW(request, ctx) {
         const clientid = request.clientid;
         const client = this.clients.get(clientid);
         if (!client)
-            throw 10022;
-        return new msg.Nfsv4RenewResponse(0);
+            throw 10022 /* Nfsv4Stat.NFS4ERR_STALE_CLIENTID */;
+        return new msg.Nfsv4RenewResponse(0 /* Nfsv4Stat.NFS4_OK */);
     }
     async READ(request, ctx) {
         const stateidKey = this.makeStateidKey(request.stateid);
         const openFile = this.openFiles.get(stateidKey);
         if (!openFile)
-            return new msg.Nfsv4ReadResponse(10025);
+            return new msg.Nfsv4ReadResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
         const fdHandle = openFile.fd;
-        let fd = undefined;
+        // If we have an fd-like handle, use its .read; otherwise open the path
+        let fd;
         let openedHere = false;
         try {
             if (fdHandle && typeof fdHandle.read === 'function') {
@@ -979,7 +1038,7 @@ class Nfsv4OperationsNode {
             const eof = bytesRead < request.count;
             const data = buf.slice(0, bytesRead);
             const resok = new msg.Nfsv4ReadResOk(eof, data);
-            return new msg.Nfsv4ReadResponse(0, resok);
+            return new msg.Nfsv4ReadResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -990,7 +1049,8 @@ class Nfsv4OperationsNode {
                 if (openedHere && fd && typeof fd.close === 'function')
                     await fd.close();
             }
-            catch (e) {
+            catch (_e) {
+                /* ignore close errors */
             }
         }
     }
@@ -1000,7 +1060,7 @@ class Nfsv4OperationsNode {
         try {
             const target = await this.promises.readlink(currentPathAbsolute);
             const resok = new msg.Nfsv4ReadlinkResOk(target);
-            return new msg.Nfsv4ReadlinkResponse(0, resok);
+            return new msg.Nfsv4ReadlinkResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1023,7 +1083,7 @@ class Nfsv4OperationsNode {
             const after = ++this.changeCounter;
             const cinfo = new struct.Nfsv4ChangeInfo(true, before, after);
             const resok = new msg.Nfsv4RemoveResOk(cinfo);
-            return new msg.Nfsv4RemoveResponse(0, resok);
+            return new msg.Nfsv4RemoveResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1038,11 +1098,11 @@ class Nfsv4OperationsNode {
         const oldFull = NodePath.join(savedPathAbsolute, request.oldname);
         const newFull = NodePath.join(currentPathAbsolute, request.newname);
         if (oldFull.length < this.dir.length || newFull.length < this.dir.length)
-            throw 2;
+            throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
         if (!oldFull.startsWith(this.dir))
-            return new msg.Nfsv4RenameResponse(2);
+            return new msg.Nfsv4RenameResponse(2 /* Nfsv4Stat.NFS4ERR_NOENT */);
         if (!newFull.startsWith(this.dir))
-            return new msg.Nfsv4RenameResponse(2);
+            return new msg.Nfsv4RenameResponse(2 /* Nfsv4Stat.NFS4ERR_NOENT */);
         let oldPath;
         let newPath;
         try {
@@ -1050,7 +1110,7 @@ class Nfsv4OperationsNode {
             newPath = this.absolutePath(newFull);
         }
         catch (e) {
-            const status = typeof e === 'number' ? e : 2;
+            const status = typeof e === 'number' ? e : 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
             return new msg.Nfsv4RenameResponse(status);
         }
         try {
@@ -1061,11 +1121,11 @@ class Nfsv4OperationsNode {
             const sourceCinfo = new struct.Nfsv4ChangeInfo(true, before, after);
             const targetCinfo = new struct.Nfsv4ChangeInfo(true, before, after);
             const resok = new msg.Nfsv4RenameResOk(sourceCinfo, targetCinfo);
-            return new msg.Nfsv4RenameResponse(0, resok);
+            return new msg.Nfsv4RenameResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             if ((0, util_1.isErrCode)('EXDEV', err))
-                return new msg.Nfsv4RenameResponse(18);
+                return new msg.Nfsv4RenameResponse(18 /* Nfsv4Stat.NFS4ERR_XDEV */);
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
             return new msg.Nfsv4RenameResponse(status);
         }
@@ -1074,9 +1134,9 @@ class Nfsv4OperationsNode {
         const stateidKey = this.makeStateidKey(request.stateid);
         const openFile = this.openFiles.get(stateidKey);
         if (!openFile)
-            return new msg.Nfsv4WriteResponse(10025);
+            return new msg.Nfsv4WriteResponse(10025 /* Nfsv4Stat.NFS4ERR_BAD_STATEID */);
         const fdHandle = openFile.fd;
-        let fd = undefined;
+        let fd;
         let openedHere = false;
         try {
             if (fdHandle && typeof fdHandle.write === 'function') {
@@ -1088,8 +1148,10 @@ class Nfsv4OperationsNode {
             }
             const buffer = Buffer.from(request.data);
             const { bytesWritten } = await fd.write(buffer, 0, buffer.length, Number(request.offset));
-            const committed = request.stable === 0 ? 0 : 2;
-            if (request.stable === 2 || request.stable === 1) {
+            // Handle stable flag
+            const committed = request.stable === 0 /* Nfsv4StableHow.UNSTABLE4 */ ? 0 /* Nfsv4StableHow.UNSTABLE4 */ : 2 /* Nfsv4StableHow.FILE_SYNC4 */;
+            if (request.stable === 2 /* Nfsv4StableHow.FILE_SYNC4 */ || request.stable === 1 /* Nfsv4StableHow.DATA_SYNC4 */) {
+                // fd.datasync or fd.sync
                 if (typeof fd.datasync === 'function')
                     await fd.datasync();
                 else if (typeof fd.sync === 'function')
@@ -1097,7 +1159,7 @@ class Nfsv4OperationsNode {
             }
             const verifier = new struct.Nfsv4Verifier((0, node_crypto_1.randomBytes)(8));
             const resok = new msg.Nfsv4WriteResOk(bytesWritten, committed, verifier);
-            return new msg.Nfsv4WriteResponse(0, resok);
+            return new msg.Nfsv4WriteResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1108,20 +1170,22 @@ class Nfsv4OperationsNode {
                 if (openedHere && fd && typeof fd.close === 'function')
                     await fd.close();
             }
-            catch (e) {
+            catch (_e) {
+                /* ignore close errors */
             }
         }
     }
     async DELEGPURGE(request, ctx) {
-        return new msg.Nfsv4DelegpurgeResponse(10004);
+        return new msg.Nfsv4DelegpurgeResponse(10004 /* Nfsv4Stat.NFS4ERR_NOTSUPP */);
     }
     async DELEGRETURN(request, ctx) {
-        return new msg.Nfsv4DelegreturnResponse(10004);
+        return new msg.Nfsv4DelegreturnResponse(10004 /* Nfsv4Stat.NFS4ERR_NOTSUPP */);
     }
     async COMMIT(request, ctx) {
         const currentPath = this.fh.currentPath(ctx);
         const currentPathAbsolute = this.absolutePath(currentPath);
-        let fd = undefined;
+        // If there is an open file corresponding to this path, prefer that fd
+        let fd;
         for (const openFile of this.openFiles.values()) {
             if (openFile.path === currentPathAbsolute) {
                 fd = openFile.fd;
@@ -1136,6 +1200,7 @@ class Nfsv4OperationsNode {
                 await fd.sync();
             }
             else {
+                // fallback: open and fdatasync
                 const handle = await this.promises.open(currentPathAbsolute, this.fs.constants.O_RDONLY);
                 try {
                     if (typeof handle.datasync === 'function')
@@ -1147,11 +1212,13 @@ class Nfsv4OperationsNode {
                     try {
                         await handle.close();
                     }
-                    catch (e) {
+                    catch (_e) {
+                        /* ignore */
                     }
                 }
             }
-            return new msg.Nfsv4CommitResponse(0);
+            // Return OK; no specific commit verifier currently persisted
+            return new msg.Nfsv4CommitResponse(0 /* Nfsv4Stat.NFS4_OK */);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1164,27 +1231,28 @@ class Nfsv4OperationsNode {
         const name = request.objname;
         const createPath = NodePath.join(currentPathAbsolute, name);
         if (createPath.length < this.dir.length)
-            throw 2;
+            throw 2 /* Nfsv4Stat.NFS4ERR_NOENT */;
         try {
             const objType = request.objtype.type;
-            if (objType === 2) {
+            if (objType === 2 /* Nfsv4FType.NF4DIR */) {
                 let mode = 0o777;
                 try {
                     if (request.createattrs && request.createattrs.attrmask) {
                         const dec = new XdrDecoder_1.XdrDecoder();
                         dec.reader.reset(request.createattrs.attrVals);
                         const maskSet = (0, attributes_1.parseBitmask)(request.createattrs.attrmask.mask);
-                        if (maskSet.has(33)) {
+                        if (maskSet.has(33 /* Nfsv4Attr.FATTR4_MODE */)) {
                             const m = dec.readUnsignedInt();
                             mode = m & 0o7777;
                         }
                     }
                 }
-                catch (e) {
+                catch (_e) {
+                    // ignore parsing errors, fall back to default mode
                 }
                 await this.promises.mkdir(createPath, mode);
             }
-            else if (objType === 5) {
+            else if (objType === 5 /* Nfsv4FType.NF4LNK */) {
                 const linkTarget = request.objtype.objtype.linkdata;
                 await this.promises.symlink(linkTarget, createPath);
             }
@@ -1195,13 +1263,14 @@ class Nfsv4OperationsNode {
                         const dec = new XdrDecoder_1.XdrDecoder();
                         dec.reader.reset(request.createattrs.attrVals);
                         const maskSet = (0, attributes_1.parseBitmask)(request.createattrs.attrmask.mask);
-                        if (maskSet.has(33)) {
+                        if (maskSet.has(33 /* Nfsv4Attr.FATTR4_MODE */)) {
                             const m = dec.readUnsignedInt();
                             mode = m & 0o7777;
                         }
                     }
                 }
-                catch (e) {
+                catch (_e) {
+                    // ignore parsing errors, fall back to default mode
                 }
                 const fd = await this.promises.open(createPath, this.fs.constants.O_CREAT | this.fs.constants.O_EXCL | this.fs.constants.O_RDWR, mode);
                 try {
@@ -1209,7 +1278,7 @@ class Nfsv4OperationsNode {
                 }
                 catch { }
             }
-            const stats = await this.promises.stat(createPath);
+            const _stats = await this.promises.stat(createPath);
             const fh = this.fh.encode(createPath);
             ctx.cfh = fh;
             const before = this.changeCounter;
@@ -1217,7 +1286,7 @@ class Nfsv4OperationsNode {
             const cinfo = new struct.Nfsv4ChangeInfo(true, before, after);
             const attrset = new struct.Nfsv4Bitmap([]);
             const resok = new msg.Nfsv4CreateResOk(cinfo, attrset);
-            return new msg.Nfsv4CreateResponse(0, resok);
+            return new msg.Nfsv4CreateResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1234,7 +1303,7 @@ class Nfsv4OperationsNode {
             const before = this.changeCounter;
             const after = ++this.changeCounter;
             const resok = new msg.Nfsv4LinkResOk(new struct.Nfsv4ChangeInfo(true, before, after));
-            return new msg.Nfsv4LinkResponse(0, resok);
+            return new msg.Nfsv4LinkResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1247,10 +1316,13 @@ class Nfsv4OperationsNode {
         try {
             const stats = await this.promises.lstat(currentPathAbsolute);
             const fsStats = await this.fsStats();
+            // request.objAttributes is a Nfsv4Fattr: use its attrmask when asking
+            // encodeAttrs to serialize the server's current attributes and compare
+            // raw attrVals bytes.
             const attrs = (0, attrs_1.encodeAttrs)(request.objAttributes.attrmask, stats, currentPathAbsolute, ctx.cfh, this.leaseTime, fsStats);
             if ((0, cmpUint8Array_1.cmpUint8Array)(attrs.attrVals, request.objAttributes.attrVals))
-                return new msg.Nfsv4NverifyResponse(10027);
-            return new msg.Nfsv4NverifyResponse(0);
+                return new msg.Nfsv4NverifyResponse(10027 /* Nfsv4Stat.NFS4ERR_NOT_SAME */);
+            return new msg.Nfsv4NverifyResponse(0 /* Nfsv4Stat.NFS4_OK */);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1277,33 +1349,33 @@ class Nfsv4OperationsNode {
                         continue;
                     const attrNum = i * 32 + bit;
                     switch (attrNum) {
-                        case 33: {
+                        case 33 /* Nfsv4Attr.FATTR4_MODE */: {
                             const mode = dec.readUnsignedInt();
                             await this.promises.chmod(currentPathAbsolute, mode & 0o7777);
                             break;
                         }
-                        case 36: {
+                        case 36 /* Nfsv4Attr.FATTR4_OWNER */: {
                             const owner = dec.readString();
                             const parsedUid = parseInt(owner, 10);
-                            if (!isNaN(parsedUid)) {
+                            if (!Number.isNaN(parsedUid)) {
                                 uid = parsedUid;
                             }
                             break;
                         }
-                        case 37: {
+                        case 37 /* Nfsv4Attr.FATTR4_OWNER_GROUP */: {
                             const group = dec.readString();
                             const parsedGid = parseInt(group, 10);
-                            if (!isNaN(parsedGid)) {
+                            if (!Number.isNaN(parsedGid)) {
                                 gid = parsedGid;
                             }
                             break;
                         }
-                        case 4: {
+                        case 4 /* Nfsv4Attr.FATTR4_SIZE */: {
                             const size = dec.readUnsignedHyper();
                             await this.promises.truncate(currentPathAbsolute, Number(size));
                             break;
                         }
-                        case 48: {
+                        case 48 /* Nfsv4Attr.FATTR4_TIME_ACCESS_SET */: {
                             const setIt = dec.readUnsignedInt();
                             if (setIt === 1) {
                                 const seconds = Number(dec.readHyper());
@@ -1312,7 +1384,7 @@ class Nfsv4OperationsNode {
                             }
                             break;
                         }
-                        case 54: {
+                        case 54 /* Nfsv4Attr.FATTR4_TIME_MODIFY_SET */: {
                             const setIt = dec.readUnsignedInt();
                             if (setIt === 1) {
                                 const seconds = Number(dec.readHyper());
@@ -1321,35 +1393,36 @@ class Nfsv4OperationsNode {
                             }
                             break;
                         }
-                        case 19: {
+                        case 19 /* Nfsv4Attr.FATTR4_FILEHANDLE */: {
+                            // read and ignore
                             dec.readVarlenArray(() => dec.readUnsignedInt());
                             break;
                         }
-                        case 0: {
+                        case 0 /* Nfsv4Attr.FATTR4_SUPPORTED_ATTRS */: {
                             const len = dec.readUnsignedInt();
                             for (let j = 0; j < len; j++)
                                 dec.readUnsignedInt();
                             break;
                         }
-                        case 1: {
+                        case 1 /* Nfsv4Attr.FATTR4_TYPE */: {
                             dec.readUnsignedInt();
                             break;
                         }
-                        case 20:
-                        case 45:
-                        case 3: {
+                        case 20 /* Nfsv4Attr.FATTR4_FILEID */:
+                        case 45 /* Nfsv4Attr.FATTR4_SPACE_USED */:
+                        case 3 /* Nfsv4Attr.FATTR4_CHANGE */: {
                             dec.readUnsignedHyper();
                             break;
                         }
-                        case 47:
-                        case 53:
-                        case 52: {
+                        case 47 /* Nfsv4Attr.FATTR4_TIME_ACCESS */:
+                        case 53 /* Nfsv4Attr.FATTR4_TIME_MODIFY */:
+                        case 52 /* Nfsv4Attr.FATTR4_TIME_METADATA */: {
                             dec.readHyper();
                             dec.readUnsignedInt();
                             break;
                         }
                         default: {
-                            return new msg.Nfsv4SetattrResponse(10032);
+                            return new msg.Nfsv4SetattrResponse(10032 /* Nfsv4Stat.NFS4ERR_ATTRNOTSUPP */);
                         }
                     }
                 }
@@ -1369,10 +1442,11 @@ class Nfsv4OperationsNode {
             const stats = await this.promises.lstat(currentPathAbsolute);
             const fh = this.fh.encode(currentPath);
             const fsStats = await this.fsStats();
-            const returnMask = new struct.Nfsv4Bitmap((0, attributes_1.attrNumsToBitmap)([33, 4]));
-            const fattr = (0, attrs_1.encodeAttrs)(returnMask, stats, currentPath, fh, this.leaseTime, fsStats);
+            // Return updated mode and size attributes
+            const returnMask = new struct.Nfsv4Bitmap((0, attributes_1.attrNumsToBitmap)([33 /* Nfsv4Attr.FATTR4_MODE */, 4 /* Nfsv4Attr.FATTR4_SIZE */]));
+            const _fattr = (0, attrs_1.encodeAttrs)(returnMask, stats, currentPath, fh, this.leaseTime, fsStats);
             const resok = new msg.Nfsv4SetattrResOk(returnMask);
-            return new msg.Nfsv4SetattrResponse(0, resok);
+            return new msg.Nfsv4SetattrResponse(0 /* Nfsv4Stat.NFS4_OK */, resok);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);
@@ -1387,8 +1461,8 @@ class Nfsv4OperationsNode {
             const fsStats = await this.fsStats();
             const attrs = (0, attrs_1.encodeAttrs)(request.objAttributes.attrmask, stats, currentPath, ctx.cfh, this.leaseTime, fsStats);
             if ((0, cmpUint8Array_1.cmpUint8Array)(attrs.attrVals, request.objAttributes.attrVals))
-                return new msg.Nfsv4VerifyResponse(0);
-            return new msg.Nfsv4VerifyResponse(10027);
+                return new msg.Nfsv4VerifyResponse(0 /* Nfsv4Stat.NFS4_OK */);
+            return new msg.Nfsv4VerifyResponse(10027 /* Nfsv4Stat.NFS4ERR_NOT_SAME */);
         }
         catch (err) {
             const status = (0, util_1.normalizeNodeFsError)(err, ctx.connection.logger);