@jsonjoy.com/json-pack 1.19.0 → 1.21.0

package/lib/nfs/v4/client/Nfsv4FsClient.js

@@ -0,0 +1,812 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nfsv4FsClient = void 0;
+const tslib_1 = require("tslib");
+const builder_1 = require("../builder");
+const structs = tslib_1.__importStar(require("../structs"));
+const Writer_1 = require("@jsonjoy.com/buffers/lib/Writer");
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const XdrEncoder_1 = require("../../../xdr/XdrEncoder");
+const XdrDecoder_1 = require("../../../xdr/XdrDecoder");
+const NfsFsStats_1 = require("./NfsFsStats");
+const NfsFsDir_1 = require("./NfsFsDir");
+const NfsFsDirent_1 = require("./NfsFsDirent");
+const NfsFsFileHandle_1 = require("./NfsFsFileHandle");
+class Nfsv4FsClient {
+    constructor(fs) {
+        this.fs = fs;
+        this.openOwnerSeqids = new Map();
+        this.defaultOpenOwnerId = new Uint8Array([1, 2, 3, 4]);
+        this.closeStateid = async (openOwner, stateid) => {
+            const key = this.makeOpenOwnerKey(openOwner);
+            const previousSeqid = this.openOwnerSeqids.get(key);
+            const seqid = this.nextOpenOwnerSeqid(openOwner);
+            const response = await this.fs.compound([builder_1.nfs.CLOSE(seqid, stateid)]);
+            if (response.status !== 0) {
+                if (previousSeqid !== undefined) {
+                    this.openOwnerSeqids.set(key, previousSeqid);
+                }
+                else {
+                    this.openOwnerSeqids.delete(key);
+                }
+                throw new Error(`Failed to close file: ${response.status}`);
+            }
+        };
+        this.readFile = async (id, options) => {
+            const encoding = typeof options === 'string' ? options : options?.encoding;
+            const path = typeof id === 'string' ? id : id.toString();
+            const parts = this.parsePath(path);
+            const operations = this.navigateToParent(parts);
+            const filename = parts[parts.length - 1];
+            const openOwner = this.createDefaultOpenOwner();
+            const claim = builder_1.nfs.OpenClaimNull(filename);
+            const openSeqid = this.nextOpenOwnerSeqid(openOwner);
+            operations.push(builder_1.nfs.OPEN(openSeqid, 1, 0, openOwner, builder_1.nfs.OpenHowNoCreate(), claim));
+            const openResponse = await this.fs.compound(operations);
+            if (openResponse.status !== 0) {
+                throw new Error(`Failed to open file: ${openResponse.status}`);
+            }
+            const openRes = openResponse.resarray[openResponse.resarray.length - 1];
+            if (openRes.status !== 0 || !openRes.resok) {
+                throw new Error(`Failed to open file: ${openRes.status}`);
+            }
+            const stateid = openRes.resok.stateid;
+            const chunks = [];
+            let offset = BigInt(0);
+            const chunkSize = 65536;
+            try {
+                while (true) {
+                    const readResponse = await this.fs.compound([builder_1.nfs.READ(offset, chunkSize, stateid)]);
+                    if (readResponse.status !== 0) {
+                        throw new Error(`Failed to read file: ${readResponse.status}`);
+                    }
+                    const readRes = readResponse.resarray[0];
+                    if (readRes.status !== 0 || !readRes.resok) {
+                        throw new Error(`Failed to read file: ${readRes.status}`);
+                    }
+                    if (readRes.resok.data.length > 0) {
+                        chunks.push(readRes.resok.data);
+                        offset += BigInt(readRes.resok.data.length);
+                    }
+                    if (readRes.resok.eof)
+                        break;
+                }
+            }
+            finally {
+                await this.closeStateid(openOwner, stateid);
+            }
+            const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+            const result = new Uint8Array(totalLength);
+            let position = 0;
+            for (const chunk of chunks) {
+                result.set(chunk, position);
+                position += chunk.length;
+            }
+            return this.decodeData(result, encoding);
+        };
+        this.writeFile = async (id, data, options) => {
+            const path = typeof id === 'string' ? id : id.toString();
+            const parts = this.parsePath(path);
+            const operations = this.navigateToParent(parts);
+            const filename = parts[parts.length - 1];
+            const openOwner = this.createDefaultOpenOwner();
+            const claim = builder_1.nfs.OpenClaimNull(filename);
+            const openSeqid = this.nextOpenOwnerSeqid(openOwner);
+            operations.push(builder_1.nfs.OPEN(openSeqid, 2, 0, openOwner, builder_1.nfs.OpenHowCreateUnchecked(), claim));
+            const writer = new Writer_1.Writer(16);
+            const xdr = new XdrEncoder_1.XdrEncoder(writer);
+            xdr.writeUnsignedHyper(BigInt(0));
+            const attrVals = writer.flush();
+            const truncateAttrs = builder_1.nfs.Fattr([4], attrVals);
+            const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
+            operations.push(builder_1.nfs.SETATTR(stateid, truncateAttrs));
+            const openResponse = await this.fs.compound(operations);
+            if (openResponse.status !== 0) {
+                throw new Error(`Failed to open file: ${openResponse.status}`);
+            }
+            const openRes = openResponse.resarray[openResponse.resarray.length - 2];
+            if (openRes.status !== 0 || !openRes.resok) {
+                throw new Error(`Failed to open file: ${openRes.status}`);
+            }
+            const openStateid = openRes.resok.stateid;
+            const buffer = this.encodeData(data);
+            const chunkSize = 65536;
+            try {
+                let offset = BigInt(0);
+                for (let i = 0; i < buffer.length; i += chunkSize) {
+                    const chunk = buffer.slice(i, Math.min(i + chunkSize, buffer.length));
+                    const writeResponse = await this.fs.compound([
+                        builder_1.nfs.WRITE(openStateid, offset, 2, chunk),
+                    ]);
+                    if (writeResponse.status !== 0) {
+                        throw new Error(`Failed to write file: ${writeResponse.status}`);
+                    }
+                    const writeRes = writeResponse.resarray[0];
+                    if (writeRes.status !== 0 || !writeRes.resok) {
+                        throw new Error(`Failed to write file: ${writeRes.status}`);
+                    }
+                    offset += BigInt(writeRes.resok.count);
+                }
+            }
+            finally {
+                await this.closeStateid(openOwner, openStateid);
+            }
+        };
+        this.stat = async (path, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            const attrNums = [
+                1,
+                4,
+                20,
+                33,
+                35,
+                45,
+                47,
+                53,
+                52,
+            ];
+            const attrMask = this.attrNumsToBitmap(attrNums);
+            operations.push(builder_1.nfs.GETATTR(attrMask));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to stat file: ${response.status}`);
+            }
+            const getattrRes = response.resarray[response.resarray.length - 1];
+            if (getattrRes.status !== 0 || !getattrRes.resok) {
+                throw new Error(`Failed to get attributes: ${getattrRes.status}`);
+            }
+            const fattr = getattrRes.resok.objAttributes;
+            const reader = new Reader_1.Reader();
+            reader.reset(fattr.attrVals);
+            const xdr = new XdrDecoder_1.XdrDecoder(reader);
+            let fileType = 1;
+            let size = 0;
+            let fileid = 0;
+            let mode = 0;
+            let nlink = 1;
+            let spaceUsed = 0;
+            let atime = new Date(0);
+            let mtime = new Date(0);
+            let ctime = new Date(0);
+            const returnedMask = fattr.attrmask.mask;
+            for (let i = 0; i < returnedMask.length; i++) {
+                const word = returnedMask[i];
+                if (!word)
+                    continue;
+                for (let bit = 0; bit < 32; bit++) {
+                    if (!(word & (1 << bit)))
+                        continue;
+                    const attrNum = i * 32 + bit;
+                    switch (attrNum) {
+                        case 1:
+                            fileType = xdr.readUnsignedInt();
+                            break;
+                        case 4:
+                            size = Number(xdr.readUnsignedHyper());
+                            break;
+                        case 20:
+                            fileid = Number(xdr.readUnsignedHyper());
+                            break;
+                        case 33:
+                            mode = xdr.readUnsignedInt();
+                            break;
+                        case 35:
+                            nlink = xdr.readUnsignedInt();
+                            break;
+                        case 45:
+                            spaceUsed = Number(xdr.readUnsignedHyper());
+                            break;
+                        case 47: {
+                            const seconds = Number(xdr.readHyper());
+                            const nseconds = xdr.readUnsignedInt();
+                            atime = new Date(seconds * 1000 + nseconds / 1000000);
+                            break;
+                        }
+                        case 53: {
+                            const seconds = Number(xdr.readHyper());
+                            const nseconds = xdr.readUnsignedInt();
+                            mtime = new Date(seconds * 1000 + nseconds / 1000000);
+                            break;
+                        }
+                        case 52: {
+                            const seconds = Number(xdr.readHyper());
+                            const nseconds = xdr.readUnsignedInt();
+                            ctime = new Date(seconds * 1000 + nseconds / 1000000);
+                            break;
+                        }
+                    }
+                }
+            }
+            const blocks = Math.ceil(spaceUsed / 512);
+            return new NfsFsStats_1.NfsFsStats(0, 0, 0, 4096, fileid, size, blocks, atime, mtime, ctime, mtime, atime.getTime(), mtime.getTime(), ctime.getTime(), mtime.getTime(), 0, mode, nlink, fileType);
+        };
+        this.lstat = async (path, options) => {
+            return this.stat(path, options);
+        };
+        this.mkdir = async (path, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            if (parts.length === 0) {
+                throw new Error('Cannot create root directory');
+            }
+            const operations = this.navigateToParent(parts);
+            const dirname = parts[parts.length - 1];
+            const createType = builder_1.nfs.CreateTypeDir();
+            const emptyAttrs = builder_1.nfs.Fattr([], new Uint8Array(0));
+            operations.push(builder_1.nfs.CREATE(createType, dirname, emptyAttrs));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to create directory: ${response.status}`);
+            }
+            const createRes = response.resarray[response.resarray.length - 1];
+            if (createRes.status !== 0) {
+                throw new Error(`Failed to create directory: ${createRes.status}`);
+            }
+            return undefined;
+        };
+        this.readdir = async (path, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const withFileTypes = typeof options === 'object' && options?.withFileTypes;
+            const encoding = typeof options === 'string' ? options : options?.encoding;
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            const attrNums = withFileTypes ? [1] : [];
+            const attrMask = this.attrNumsToBitmap(attrNums);
+            operations.push(builder_1.nfs.READDIR(attrMask));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to read directory: ${response.status}`);
+            }
+            const readdirRes = response.resarray[response.resarray.length - 1];
+            if (readdirRes.status !== 0 || !readdirRes.resok) {
+                throw new Error(`Failed to read directory: ${readdirRes.status}`);
+            }
+            const entries = [];
+            const dirents = [];
+            const entryList = readdirRes.resok.entries;
+            for (let i = 0; i < entryList.length; i++) {
+                const entry = entryList[i];
+                const name = entry.name;
+                if (withFileTypes) {
+                    const fattr = entry.attrs;
+                    const reader = new Reader_1.Reader();
+                    reader.reset(fattr.attrVals);
+                    const xdr = new XdrDecoder_1.XdrDecoder(reader);
+                    let fileType = 1;
+                    const returnedMask = fattr.attrmask.mask;
+                    for (let i = 0; i < returnedMask.length; i++) {
+                        const word = returnedMask[i];
+                        if (!word)
+                            continue;
+                        for (let bit = 0; bit < 32; bit++) {
+                            if (!(word & (1 << bit)))
+                                continue;
+                            const attrNum = i * 32 + bit;
+                            if (attrNum === 1) {
+                                fileType = xdr.readUnsignedInt();
+                            }
+                        }
+                    }
+                    dirents.push(new NfsFsDirent_1.NfsFsDirent(name, fileType));
+                }
+                else {
+                    entries.push(name);
+                }
+            }
+            if (withFileTypes) {
+                return dirents;
+            }
+            if (encoding && encoding !== 'utf8') {
+                return entries.map((name) => Buffer.from(name, 'utf8'));
+            }
+            return entries;
+        };
+        this.appendFile = async (path, data, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToParent(parts);
+            const filename = parts[parts.length - 1];
+            const openOwner = this.createDefaultOpenOwner();
+            const claim = builder_1.nfs.OpenClaimNull(filename);
+            const openSeqid = this.nextOpenOwnerSeqid(openOwner);
+            operations.push(builder_1.nfs.OPEN(openSeqid, 2, 0, openOwner, builder_1.nfs.OpenHowNoCreate(), claim));
+            const attrNums = [4];
+            const attrMask = this.attrNumsToBitmap(attrNums);
+            operations.push(builder_1.nfs.GETATTR(attrMask));
+            const openResponse = await this.fs.compound(operations);
+            if (openResponse.status !== 0) {
+                throw new Error(`Failed to open file: ${openResponse.status}`);
+            }
+            const openRes = openResponse.resarray[openResponse.resarray.length - 2];
+            if (openRes.status !== 0 || !openRes.resok) {
+                throw new Error(`Failed to open file: ${openRes.status}`);
+            }
+            const getattrRes = openResponse.resarray[openResponse.resarray.length - 1];
+            if (getattrRes.status !== 0 || !getattrRes.resok) {
+                throw new Error(`Failed to get attributes: ${getattrRes.status}`);
+            }
+            const fattr = getattrRes.resok.objAttributes;
+            const reader = new Reader_1.Reader();
+            reader.reset(fattr.attrVals);
+            const xdr = new XdrDecoder_1.XdrDecoder(reader);
+            const currentSize = Number(xdr.readUnsignedHyper());
+            const openStateid = openRes.resok.stateid;
+            const buffer = this.encodeData(data);
+            const chunkSize = 65536;
+            try {
+                let offset = BigInt(currentSize);
+                for (let i = 0; i < buffer.length; i += chunkSize) {
+                    const chunk = buffer.slice(i, Math.min(i + chunkSize, buffer.length));
+                    const writeResponse = await this.fs.compound([
+                        builder_1.nfs.WRITE(openStateid, offset, 2, chunk),
+                    ]);
+                    if (writeResponse.status !== 0) {
+                        throw new Error(`Failed to write file: ${writeResponse.status}`);
+                    }
+                    const writeRes = writeResponse.resarray[0];
+                    if (writeRes.status !== 0 || !writeRes.resok) {
+                        throw new Error(`Failed to write file: ${writeRes.status}`);
+                    }
+                    offset += BigInt(writeRes.resok.count);
+                }
+            }
+            finally {
+                await this.closeStateid(openOwner, openStateid);
+            }
+        };
+        this.truncate = async (path, len = 0) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            const writer = new Writer_1.Writer(16);
+            const xdr = new XdrEncoder_1.XdrEncoder(writer);
+            xdr.writeUnsignedHyper(BigInt(len));
+            const attrVals = writer.flush();
+            const sizeAttrs = builder_1.nfs.Fattr([4], attrVals);
+            const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
+            operations.push(builder_1.nfs.SETATTR(stateid, sizeAttrs));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to truncate file: ${response.status}`);
+            }
+            const setattrRes = response.resarray[response.resarray.length - 1];
+            if (setattrRes.status !== 0) {
+                throw new Error(`Failed to truncate file: ${setattrRes.status}`);
+            }
+        };
+        this.unlink = async (path) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            if (parts.length === 0) {
+                throw new Error('Cannot unlink root directory');
+            }
+            const operations = this.navigateToParent(parts);
+            const filename = parts[parts.length - 1];
+            operations.push(builder_1.nfs.REMOVE(filename));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to unlink file: ${response.status}`);
+            }
+            const removeRes = response.resarray[response.resarray.length - 1];
+            if (removeRes.status !== 0) {
+                throw new Error(`Failed to unlink file: ${removeRes.status}`);
+            }
+        };
+        this.rmdir = async (path, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            if (parts.length === 0) {
+                throw new Error('Cannot remove root directory');
+            }
+            const operations = this.navigateToParent(parts);
+            const dirname = parts[parts.length - 1];
+            operations.push(builder_1.nfs.REMOVE(dirname));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to remove directory: ${response.status}`);
+            }
+            const removeRes = response.resarray[response.resarray.length - 1];
+            if (removeRes.status !== 0) {
+                throw new Error(`Failed to remove directory: ${removeRes.status}`);
+            }
+        };
+        this.rm = async (path, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            if (parts.length === 0) {
+                throw new Error('Cannot remove root directory');
+            }
+            const force = options?.force ?? false;
+            const recursive = options?.recursive ?? false;
+            if (recursive) {
+                try {
+                    const stats = await this.stat(path);
+                    if (stats.isDirectory()) {
+                        const entries = await this.readdir(path);
+                        for (const entry of entries) {
+                            const entryPath = pathStr + '/' + entry;
+                            await this.rm(entryPath, options);
+                        }
+                    }
+                }
+                catch (err) {
+                    if (!force)
+                        throw err;
+                    return;
+                }
+            }
+            try {
+                const operations = this.navigateToParent(parts);
+                const name = parts[parts.length - 1];
+                operations.push(builder_1.nfs.REMOVE(name));
+                const response = await this.fs.compound(operations);
+                if (response.status !== 0) {
+                    if (!force)
+                        throw new Error(`Failed to remove: ${response.status}`);
+                    return;
+                }
+                const removeRes = response.resarray[response.resarray.length - 1];
+                if (removeRes.status !== 0) {
+                    if (!force)
+                        throw new Error(`Failed to remove: ${removeRes.status}`);
+                }
+            }
+            catch (err) {
+                if (!force)
+                    throw err;
+            }
+        };
+        this.access = async (path, mode = 0) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            let accessMask = 0;
+            if (mode === 0) {
+                accessMask = 1;
+            }
+            else {
+                if (mode & 4)
+                    accessMask |= 1;
+                if (mode & 2)
+                    accessMask |= 4;
+                if (mode & 1)
+                    accessMask |= 32;
+            }
+            operations.push(builder_1.nfs.ACCESS(accessMask));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Access denied: ${response.status}`);
+            }
+            const accessRes = response.resarray[response.resarray.length - 1];
+            if (accessRes.status !== 0) {
+                throw new Error(`Access denied: ${accessRes.status}`);
+            }
+        };
+        this.rename = async (oldPath, newPath) => {
+            const oldPathStr = typeof oldPath === 'string' ? oldPath : oldPath.toString();
+            const newPathStr = typeof newPath === 'string' ? newPath : newPath.toString();
+            const oldParts = this.parsePath(oldPathStr);
+            const newParts = this.parsePath(newPathStr);
+            if (oldParts.length === 0 || newParts.length === 0) {
+                throw new Error('Cannot rename root directory');
+            }
+            const operations = [];
+            operations.push(builder_1.nfs.PUTROOTFH());
+            for (const part of oldParts.slice(0, -1)) {
+                operations.push(builder_1.nfs.LOOKUP(part));
+            }
+            operations.push(builder_1.nfs.SAVEFH());
+            operations.push(builder_1.nfs.PUTROOTFH());
+            for (const part of newParts.slice(0, -1)) {
+                operations.push(builder_1.nfs.LOOKUP(part));
+            }
+            const oldname = oldParts[oldParts.length - 1];
+            const newname = newParts[newParts.length - 1];
+            operations.push(builder_1.nfs.RENAME(oldname, newname));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to rename: ${response.status}`);
+            }
+            const renameRes = response.resarray[response.resarray.length - 1];
+            if (renameRes.status !== 0) {
+                throw new Error(`Failed to rename: ${renameRes.status}`);
+            }
+        };
+        this.copyFile = async (src, dest, flags) => {
+            const data = await this.readFile(src);
+            await this.writeFile(dest, data);
+        };
+        this.realpath = async (path, options) => {
+            const encoding = typeof options === 'string' ? options : options?.encoding;
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const normalized = '/' + this.parsePath(pathStr).join('/');
+            if (!encoding || encoding === 'utf8') {
+                return normalized;
+            }
+            return Buffer.from(normalized, 'utf8');
+        };
+        this.link = async (existingPath, newPath) => {
+            const existingPathStr = typeof existingPath === 'string' ? existingPath : existingPath.toString();
+            const newPathStr = typeof newPath === 'string' ? newPath : newPath.toString();
+            const existingParts = this.parsePath(existingPathStr);
+            const newParts = this.parsePath(newPathStr);
+            if (newParts.length === 0) {
+                throw new Error('Cannot create link at root');
+            }
+            const operations = this.navigateToPath(existingParts);
+            operations.push(builder_1.nfs.SAVEFH());
+            operations.push(builder_1.nfs.PUTROOTFH());
+            for (const part of newParts.slice(0, -1)) {
+                operations.push(builder_1.nfs.LOOKUP(part));
+            }
+            const newname = newParts[newParts.length - 1];
+            operations.push(builder_1.nfs.LINK(newname));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to create link: ${response.status}`);
+            }
+            const linkRes = response.resarray[response.resarray.length - 1];
+            if (linkRes.status !== 0) {
+                throw new Error(`Failed to create link: ${linkRes.status}`);
+            }
+        };
+        this.symlink = async (target, path, type) => {
+            const targetStr = typeof target === 'string' ? target : target.toString();
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            if (parts.length === 0) {
+                throw new Error('Cannot create symlink at root');
+            }
+            const operations = this.navigateToParent(parts);
+            const linkname = parts[parts.length - 1];
+            const createType = new structs.Nfsv4CreateType(5, new structs.Nfsv4CreateTypeLink(targetStr));
+            const emptyAttrs = builder_1.nfs.Fattr([], new Uint8Array(0));
+            operations.push(builder_1.nfs.CREATE(createType, linkname, emptyAttrs));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to create symlink: ${response.status}`);
+            }
+            const createRes = response.resarray[response.resarray.length - 1];
+            if (createRes.status !== 0) {
+                throw new Error(`Failed to create symlink: ${createRes.status}`);
+            }
+        };
+        this.utimes = async (path, atime, mtime) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            const atimeMs = typeof atime === 'number' ? atime : atime instanceof Date ? atime.getTime() : Date.now();
+            const mtimeMs = typeof mtime === 'number' ? mtime : mtime instanceof Date ? mtime.getTime() : Date.now();
+            const writer = new Writer_1.Writer(64);
+            const xdr = new XdrEncoder_1.XdrEncoder(writer);
+            xdr.writeUnsignedInt(1);
+            xdr.writeHyper(BigInt(Math.floor(atimeMs / 1000)));
+            xdr.writeUnsignedInt((atimeMs % 1000) * 1000000);
+            xdr.writeUnsignedInt(1);
+            xdr.writeHyper(BigInt(Math.floor(mtimeMs / 1000)));
+            xdr.writeUnsignedInt((mtimeMs % 1000) * 1000000);
+            const attrVals = writer.flush();
+            const timeAttrs = builder_1.nfs.Fattr([48, 54], attrVals);
+            const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
+            operations.push(builder_1.nfs.SETATTR(stateid, timeAttrs));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to set times: ${response.status}`);
+            }
+            const setattrRes = response.resarray[response.resarray.length - 1];
+            if (setattrRes.status !== 0) {
+                throw new Error(`Failed to set times: ${setattrRes.status}`);
+            }
+        };
+        this.readlink = async (path, options) => {
+            const encoding = typeof options === 'string' ? options : options?.encoding;
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            operations.push(builder_1.nfs.READLINK());
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to read link: ${response.status}`);
+            }
+            const readlinkRes = response.resarray[response.resarray.length - 1];
+            if (readlinkRes.status !== 0 || !readlinkRes.resok) {
+                throw new Error(`Failed to read link: ${readlinkRes.status}`);
+            }
+            if (!encoding || encoding === 'utf8') {
+                return readlinkRes.resok.link;
+            }
+            return Buffer.from(readlinkRes.resok.link, 'utf8');
+        };
+        this.opendir = async (path, options) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            return new NfsFsDir_1.NfsFsDir(pathStr, this.fs, operations);
+        };
+        this.mkdtemp = async (prefix, options) => {
+            const encoding = typeof options === 'string' ? options : options?.encoding;
+            const randomSuffix = Math.random().toString(36).substring(2, 8);
+            const dirName = prefix + randomSuffix;
+            await this.mkdir(dirName);
+            if (!encoding || encoding === 'utf8')
+                return dirName;
+            return Buffer.from(dirName, 'utf8');
+        };
+        this.chmod = async (path, mode) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            const modeValue = typeof mode === 'number' ? mode : parseInt(mode.toString(), 8);
+            const writer = new Writer_1.Writer(8);
+            const xdr = new XdrEncoder_1.XdrEncoder(writer);
+            xdr.writeUnsignedInt(modeValue);
+            const attrVals = writer.flush();
+            const attrs = builder_1.nfs.Fattr([33], attrVals);
+            const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
+            operations.push(builder_1.nfs.SETATTR(stateid, attrs));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to chmod: ${response.status}`);
+            }
+            const setattrRes = response.resarray[response.resarray.length - 1];
+            if (setattrRes.status !== 0) {
+                throw new Error(`Failed to chmod: ${setattrRes.status}`);
+            }
+        };
+        this.chown = async (path, uid, gid) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToPath(parts);
+            const writer = new Writer_1.Writer(64);
+            const xdr = new XdrEncoder_1.XdrEncoder(writer);
+            xdr.writeStr(uid.toString());
+            xdr.writeStr(gid.toString());
+            const attrVals = writer.flush();
+            const attrs = builder_1.nfs.Fattr([36, 37], attrVals);
+            const stateid = builder_1.nfs.Stateid(0, new Uint8Array(12));
+            operations.push(builder_1.nfs.SETATTR(stateid, attrs));
+            const response = await this.fs.compound(operations);
+            if (response.status !== 0) {
+                throw new Error(`Failed to chown: ${response.status}`);
+            }
+            const setattrRes = response.resarray[response.resarray.length - 1];
+            if (setattrRes.status !== 0) {
+                throw new Error(`Failed to chown: ${setattrRes.status}`);
+            }
+        };
+        this.lchmod = async (path, mode) => {
+            return this.chmod(path, mode);
+        };
+        this.lchown = async (path, uid, gid) => {
+            return this.chown(path, uid, gid);
+        };
+        this.lutimes = async (path, atime, mtime) => {
+            return this.utimes(path, atime, mtime);
+        };
+        this.open = async (path, flags, mode) => {
+            const pathStr = typeof path === 'string' ? path : path.toString();
+            const parts = this.parsePath(pathStr);
+            const operations = this.navigateToParent(parts);
+            const filename = parts[parts.length - 1];
+            const openOwner = this.createDefaultOpenOwner();
+            const claim = builder_1.nfs.OpenClaimNull(filename);
+            let access = 1;
+            const openSeqid = this.nextOpenOwnerSeqid(openOwner);
+            if (typeof flags === 'string') {
+                if (flags.includes('r') && flags.includes('+')) {
+                    access = 3;
+                }
+                else if (flags.includes('w') || flags.includes('a')) {
+                    access = 2;
+                    if (flags.includes('+')) {
+                        access = 3;
+                    }
+                }
+            }
+            else if (typeof flags === 'number') {
+                const O_RDONLY = 0;
+                const O_WRONLY = 1;
+                const O_RDWR = 2;
+                const O_ACCMODE = 3;
+                const accessMode = flags & O_ACCMODE;
+                switch (accessMode) {
+                    case O_RDONLY:
+                        access = 1;
+                        break;
+                    case O_WRONLY:
+                        access = 2;
+                        break;
+                    case O_RDWR:
+                        access = 3;
+                        break;
+                }
+            }
+            operations.push(builder_1.nfs.OPEN(openSeqid, access, 0, openOwner, builder_1.nfs.OpenHowNoCreate(), claim));
+            const openResponse = await this.fs.compound(operations);
+            if (openResponse.status !== 0) {
+                throw new Error(`Failed to open file: ${openResponse.status}`);
+            }
+            const openRes = openResponse.resarray[openResponse.resarray.length - 1];
+            if (openRes.status !== 0 || !openRes.resok) {
+                throw new Error(`Failed to open file: ${openRes.status}`);
+            }
+            const stateid = openRes.resok.stateid;
+            const fd = Math.floor(Math.random() * 1000000);
+            return new NfsFsFileHandle_1.NfsFsFileHandle(fd, pathStr, this, stateid, openOwner);
+        };
+        this.statfs = (path, options) => {
+            throw new Error('Not implemented.');
+        };
+        this.watch = (filename, options) => {
+            throw new Error('Not implemented.');
+        };
+        this.glob = (pattern, options) => {
+            throw new Error('Not implemented.');
+        };
+    }
+    makeOpenOwnerKey(owner) {
+        return `${owner.clientid}:${Buffer.from(owner.owner).toString('hex')}`;
+    }
+    nextOpenOwnerSeqid(owner) {
+        const key = this.makeOpenOwnerKey(owner);
+        const last = this.openOwnerSeqids.get(key);
+        const next = last === undefined ? 0 : last === 0xffffffff ? 1 : (last + 1) >>> 0;
+        this.openOwnerSeqids.set(key, next);
+        return next;
+    }
+    createDefaultOpenOwner() {
+        return builder_1.nfs.OpenOwner(BigInt(1), new Uint8Array(this.defaultOpenOwnerId));
+    }
+    attrNumsToBitmap(attrNums) {
+        const bitmap = [];
+        for (const attrNum of attrNums) {
+            const wordIndex = Math.floor(attrNum / 32);
+            const bitIndex = attrNum % 32;
+            while (bitmap.length <= wordIndex) {
+                bitmap.push(0);
+            }
+            bitmap[wordIndex] |= 1 << bitIndex;
+        }
+        return bitmap;
+    }
+    parsePath(path) {
+        const normalized = path.replace(/^\/+/, '').replace(/\/+$/, '');
+        if (!normalized)
+            return [];
+        return normalized.split('/').filter((part) => part.length > 0);
+    }
+    navigateToParent(parts) {
+        const operations = [builder_1.nfs.PUTROOTFH()];
+        for (const part of parts.slice(0, -1)) {
+            operations.push(builder_1.nfs.LOOKUP(part));
+        }
+        return operations;
+    }
+    navigateToPath(parts) {
+        const operations = [builder_1.nfs.PUTROOTFH()];
+        for (const part of parts) {
+            operations.push(builder_1.nfs.LOOKUP(part));
+        }
+        return operations;
+    }
+    encodeData(data) {
+        if (data instanceof Uint8Array)
+            return data;
+        if (data instanceof ArrayBuffer)
+            return new Uint8Array(data);
+        if (typeof data === 'string')
+            return new TextEncoder().encode(data);
+        if (Buffer.isBuffer(data))
+            return new Uint8Array(data);
+        throw new Error('Unsupported data type');
+    }
+    decodeData(data, encoding) {
+        if (!encoding || encoding === 'buffer')
+            return Buffer.from(data);
+        return new TextDecoder(encoding).decode(data);
+    }
+}
+exports.Nfsv4FsClient = Nfsv4FsClient;
+//# sourceMappingURL=Nfsv4FsClient.js.map