@zenfs/core 0.16.0 → 0.16.2

package/src/backends/overlay.ts

@@ -126,10 +126,10 @@ export class UnlockedOverlayFS extends FileSystem {
 		return this._deleteLog;
 	}
 
-	public restoreDeletionLog(log: string, cred: Cred): void {
+	public async restoreDeletionLog(log: string, cred: Cred): Promise<void> {
 		this._deleteLog = log;
 		this._reparseDeletionLog();
-		this.updateLog('', cred);
+		await this.updateLog('', cred);
 	}
 
 	public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
@@ -248,7 +248,7 @@ export class UnlockedOverlayFS extends FileSystem {
 
 		// if it still exists add to the delete log
 		if (await this.exists(path, cred)) {
-			this.deletePath(path, cred);
+			await this.deletePath(path, cred);
 		}
 	}
 
@@ -265,7 +265,7 @@ export class UnlockedOverlayFS extends FileSystem {
 
 		// if it still exists add to the delete log
 		if (this.existsSync(path, cred)) {
-			this.deletePath(path, cred);
+			void this.deletePath(path, cred);
 		}
 	}
 
@@ -282,7 +282,7 @@ export class UnlockedOverlayFS extends FileSystem {
 			if ((await this.readdir(path, cred)).length > 0) {
 				throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
 			} else {
-				this.deletePath(path, cred);
+				await this.deletePath(path, cred);
 			}
 		}
 	}
@@ -300,7 +300,7 @@ export class UnlockedOverlayFS extends FileSystem {
 			if (this.readdirSync(path, cred).length > 0) {
 				throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
 			} else {
-				this.deletePath(path, cred);
+				void this.deletePath(path, cred);
 			}
 		}
 	}
@@ -379,9 +379,9 @@ export class UnlockedOverlayFS extends FileSystem {
 		});
 	}
 
-	private deletePath(path: string, cred: Cred): void {
+	private async deletePath(path: string, cred: Cred): Promise<void> {
 		this._deletedFiles.add(path);
-		this.updateLog(`d${path}\n`, cred);
+		await this.updateLog(`d${path}\n`, cred);
 	}
 
 	private async updateLog(addition: string, cred: Cred) {
@@ -396,7 +396,7 @@ export class UnlockedOverlayFS extends FileSystem {
 			await log.write(encode(this._deleteLog));
 			if (this._deleteLogUpdateNeeded) {
 				this._deleteLogUpdateNeeded = false;
-				this.updateLog('', cred);
+				await this.updateLog('', cred);
 			}
 		} catch (e) {
 			this._deleteLogError = e as ErrnoError;

package/src/backends/port/fs.ts

@@ -7,8 +7,9 @@ import { File } from '../../file.js';
 import { Async, FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Stats, type FileType } from '../../stats.js';
 import { InMemory } from '../memory.js';
-import type { Backend } from '../backend.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
+import { type MountConfiguration, resolveMountConfig } from '../../config.js';
 
 type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
 type FileMethod = keyof FileMethods;
@@ -223,9 +224,15 @@ let nextFd = 0;
 
 const descriptors: Map<number, File> = new Map();
 
-type FileOrFSRequest = FSRequest | FileRequest;
+/**
+ * @internal
+ */
+export type FileOrFSRequest = FSRequest | FileRequest;
 
-async function handleRequest(port: RPC.Port, fs: FileSystem, request: FileOrFSRequest): Promise<void> {
+/**
+ * @internal
+ */
+export async function handleRequest(port: RPC.Port, fs: FileSystem, request: FileOrFSRequest): Promise<void> {
 	if (!RPC.isMessage(request)) {
 		return;
 	}
@@ -308,3 +315,11 @@ export const Port = {
 		return new PortFS(options);
 	},
 } satisfies Backend<PortFS, RPC.Options>;
+
+export async function resolveRemoteMount<T extends Backend>(port: RPC.Port, config: MountConfiguration<T>, _depth = 0): Promise<FilesystemOf<T>> {
+	const stopAndReplay = RPC.catchMessages(port);
+	const fs = await resolveMountConfig(config, _depth);
+	attachFS(port, fs);
+	stopAndReplay(fs);
+	return fs;
+}

package/src/backends/port/readme.md

@@ -26,12 +26,10 @@ await configure({
 Worker:
 
 ```ts
-import { InMemory, resolveMountConfig } from '@zenfs/core';
-import { attachFS } from '@zenfs/port';
+import { InMemory, resolveRemoteMount, attachFS } from '@zenfs/core';
 import { parentPort } from 'node:worker_threads';
 
-const tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
-attachFS(parentPort, tmpfs);
+await resolveRemoteMount(parentPort, { backend: InMemory, name: 'tmp' });
 ```
 
 If you are using using web workers, you would use `self` instead of importing `parentPort` in the worker, and would not need to import `Worker` in the main thread.
@@ -39,21 +37,18 @@ If you are using using web workers, you would use `self` instead of importing `p
 #### Using with multiple ports on the same thread
 
 ```ts
-import { InMemory, fs, resolveMountConfig } from '@zenfs/core';
-import { Port, attachFS } from '@zenfs/port';
+import { InMemory, fs, resolveMountConfig, resolveRemoteMount, Port } from '@zenfs/core';
 import { MessageChannel } from 'node:worker_threads';
 
-const { port1, port2 } = new MessageChannel();
+const { port1: localPort, port2: remotePort } = new MessageChannel();
 
-const tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
-attachFS(port2, tmpfs);
-fs.mount('/port', await resolveMountConfig({ backend: Port, port: port1 }));
-console.log('/port');
+fs.mount('/remote', await resolveRemoteMount(remotePort, { backend: InMemory, name: 'tmp' }));
+fs.mount('/port', await resolveMountConfig({ backend: Port, port: localPort }));
 
 const content = 'FS is in a port';
 
 await fs.promises.writeFile('/port/test', content);
 
-fs.readFileSync('/tmp/test', 'utf8'); // FS is in a port
+fs.readFileSync('/remote/test', 'utf8'); // FS is in a port
 await fs.promises.readFile('/port/test', 'utf8'); // FS is in a port
 ```

package/src/backends/port/rpc.ts

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Errno, ErrnoError, type ErrnoErrorJSON } from '../../error.js';
-import { PortFile, type PortFS } from './fs.js';
+import type { Backend, FilesystemOf } from '../backend.js';
+import { handleRequest, PortFile, type PortFS } from './fs.js';
+import type { FileOrFSRequest } from './fs.js';
 
 type _MessageEvent<T = any> = T | { data: T };
 
@@ -148,3 +150,16 @@ export function detach<T extends Message>(port: Port, handler: (message: T) => u
 		handler('data' in message ? message.data : message);
 	});
 }
+
+export function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<T>) => void {
+	const events: _MessageEvent[] = [];
+	const handler = events.push.bind(events);
+	attach(port, handler);
+	return function (fs: any) {
+		detach(port, handler);
+		for (const event of events) {
+			const request: FileOrFSRequest = 'data' in event ? event.data : event;
+			void handleRequest(port, fs, request);
+		}
+	};
+}

package/src/backends/store/fs.ts

@@ -535,7 +535,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 */
 	private async findINode(tx: Transaction, path: string, visited: Set<string> = new Set()): Promise<Inode> {
 		const id = await this._findINode(tx, dirname(path), basename(path), visited);
-		return this.getINode(tx, id!, path);
+		return this.getINode(tx, id, path);
 	}
 
 	/**
@@ -698,7 +698,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			await tx.commit();
 			return inode;
 		} catch (e) {
-			tx.abort();
+			await tx.abort();
 			throw e;
 		}
 	}

package/src/config.ts

@@ -55,9 +55,9 @@ export async function resolveMountConfig<T extends Backend>(config: MountConfigu
 	const { backend } = config;
 
 	if (!(await backend.isAvailable())) {
-		throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend);
+		throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend.name);
 	}
-	checkOptions(backend, config);
+	await checkOptions(backend, config);
 	const mount = (await backend.create(config)) as FilesystemOf<T>;
 	if ('_disableSync' in mount) {
 		type AsyncFS = InstanceType<ReturnType<typeof Async<new () => FilesystemOf<T>>>>;
@@ -67,7 +67,7 @@ export async function resolveMountConfig<T extends Backend>(config: MountConfigu
 	return mount;
 }
 
-type ConfigMounts = { [K in AbsolutePath]: Backend };
+export type ConfigMounts = { [K in AbsolutePath]: Backend };
 
 /**
  * Configuration

package/src/emulation/async.ts

@@ -207,12 +207,18 @@ writeFile satisfies Omit<typeof fs.writeFile, '__promisify__'>;
  * @param callback
  */
 export function appendFile(filename: fs.PathLike, data: FileContents, cb?: Callback): void;
-export function appendFile(filename: fs.PathLike, data: FileContents, options?: { encoding?: string; mode?: number | string; flag?: string }, cb?: Callback): void;
-export function appendFile(filename: fs.PathLike, data: FileContents, encoding?: string, cb?: Callback): void;
-export function appendFile(filename: fs.PathLike, data: FileContents, cbEncOpts?: any, cb: Callback = nop): void {
+export function appendFile(filename: fs.PathLike, data: FileContents, options?: fs.EncodingOption & { mode?: fs.Mode; flag?: fs.OpenMode }, cb?: Callback): void;
+export function appendFile(filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
+export function appendFile(
+	filename: fs.PathLike,
+	data: FileContents,
+	cbEncOpts?: (fs.EncodingOption & { mode?: fs.Mode; flag?: fs.OpenMode }) | Callback,
+	cb: Callback = nop
+): void {
+	const optionsOrEncoding = typeof cbEncOpts != 'function' ? cbEncOpts : undefined;
 	cb = typeof cbEncOpts === 'function' ? cbEncOpts : cb;
 	promises
-		.appendFile(filename, data, typeof cbEncOpts === 'function' ? null : cbEncOpts)
+		.appendFile(filename, data, optionsOrEncoding)
 		.then(() => cb())
 		.catch(cb);
 }
@@ -259,7 +265,7 @@ close satisfies Omit<typeof fs.close, '__promisify__'>;
  */
 export function ftruncate(fd: number, cb?: Callback): void;
 export function ftruncate(fd: number, len?: number, cb?: Callback): void;
-export function ftruncate(fd: number, lenOrCB?: any, cb: Callback = nop): void {
+export function ftruncate(fd: number, lenOrCB?: number | Callback, cb: Callback = nop): void {
 	const length = typeof lenOrCB === 'number' ? lenOrCB : 0;
 	cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
 	const file = fd2file(fd);
@@ -317,8 +323,15 @@ export function write(fd: number, buffer: Uint8Array, offset: number, length: nu
 export function write(fd: number, data: FileContents, cb?: Callback<[number, string]>): void;
 export function write(fd: number, data: FileContents, position?: number, cb?: Callback<[number, string]>): void;
 export function write(fd: number, data: FileContents, position: number | null, encoding: BufferEncoding, cb?: Callback<[number, string]>): void;
-export function write(fd: number, data: FileContents, cbPosOff?: any, cbLenEnc?: any, cbPos?: any, cb: Callback<[number, Uint8Array]> | Callback<[number, string]> = nop): void {
-	let buffer: Buffer, offset: number, length: number, position: number | undefined | null, encoding: BufferEncoding;
+export function write(
+	fd: number,
+	data: FileContents,
+	cbPosOff?: number | Callback<[number, string]> | null,
+	cbLenEnc?: number | BufferEncoding | Callback<[number, string]>,
+	cbPosEnc?: number | BufferEncoding | Callback<[number, Uint8Array]> | Callback<[number, string]>,
+	cb: Callback<[number, Uint8Array]> | Callback<[number, string]> = nop
+): void {
+	let buffer: Buffer, offset: number | undefined, length: number | undefined, position: number | undefined | null, encoding: BufferEncoding;
 	const handle = new promises.FileHandle(fd);
 	if (typeof data === 'string') {
 		// Signature 1: (fd, string, [position?, [encoding?]], cb?)
@@ -331,12 +344,12 @@ export function write(fd: number, data: FileContents, cbPosOff?: any, cbLenEnc?:
 			case 'number':
 				// (fd, string, position, encoding?, cb?)
 				position = cbPosOff;
-				encoding = typeof cbLenEnc === 'string' ? (cbLenEnc as BufferEncoding) : 'utf8';
-				cb = typeof cbPos === 'function' ? cbPos : cb;
+				encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
+				cb = typeof cbPosEnc === 'function' ? cbPosEnc : cb;
 				break;
 			default:
 				// ...try to find the callback and get out of here!
-				cb = typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPos === 'function' ? cbPos : cb;
+				cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb) as Callback<[number, Uint8Array | string]>;
 				(cb as Callback<[number, Uint8Array | string]>)(new ErrnoError(Errno.EINVAL, 'Invalid arguments.'));
 				return;
 		}
@@ -353,11 +366,11 @@ export function write(fd: number, data: FileContents, cbPosOff?: any, cbLenEnc?:
 	} else {
 		// Signature 2: (fd, buffer, offset, length, position?, cb?)
 		buffer = Buffer.from(data.buffer);
-		offset = cbPosOff;
-		length = cbLenEnc;
-		position = typeof cbPos === 'number' ? cbPos : null;
-		const _cb = typeof cbPos === 'function' ? cbPos : (cb as Callback<[number, Uint8Array]>);
-		handle
+		offset = cbPosOff as number;
+		length = cbLenEnc as number;
+		position = typeof cbPosEnc === 'number' ? cbPosEnc : null;
+		const _cb = (typeof cbPosEnc === 'function' ? cbPosEnc : cb) as Callback<[number, Uint8Array]>;
+		void handle
 			.write(buffer, offset, length, position)
 			.then(({ bytesWritten }) => _cb(undefined, bytesWritten, buffer))
 			.catch(_cb);
@@ -472,7 +485,7 @@ export function readdir(path: fs.PathLike, _options: { withFileTypes?: boolean }
 	const options = typeof _options != 'function' ? _options : {};
 	promises
 		.readdir(path, options as object)
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 		.then(entries => cb(undefined, entries as any))
 		.catch(cb);
 }
@@ -647,11 +660,11 @@ realpath satisfies Omit<typeof fs.realpath, '__promisify__' | 'native'>;
  */
 export function access(path: fs.PathLike, cb: Callback): void;
 export function access(path: fs.PathLike, mode: number, cb: Callback): void;
-export function access(path: fs.PathLike, cbMode: any, cb: Callback = nop): void {
+export function access(path: fs.PathLike, cbMode: number | Callback, cb: Callback = nop): void {
 	const mode = typeof cbMode === 'number' ? cbMode : R_OK;
 	cb = typeof cbMode === 'function' ? cbMode : cb;
 	promises
-		.access(path, typeof cbMode === 'function' ? null : cbMode)
+		.access(path, mode)
 		.then(() => cb())
 		.catch(cb);
 }

package/src/emulation/dir.ts

@@ -103,7 +103,7 @@ export class Dir implements _Dir {
 			return this._read();
 		}
 
-		this._read().then(value => cb(undefined, value));
+		void this._read().then(value => cb(undefined, value));
 	}
 
 	/**

package/src/emulation/promises.ts

@@ -164,7 +164,7 @@ export class FileHandle implements promises.FileHandle {
 	 */
 	public readableWebStream(options: promises.ReadableWebStreamOptions = {}): TReadableStream<Uint8Array> {
 		// Note: using an arrow function to preserve `this`
-		const start = async ({ close, enqueue, error }: ReadableStreamController<Uint8Array>) => {
+		const start = async (controller: ReadableStreamController<Uint8Array>) => {
 			try {
 				const chunkSize = 64 * 1024,
 					maxChunks = 1e7;
@@ -175,10 +175,10 @@ export class FileHandle implements promises.FileHandle {
 				while (bytesRead > 0) {
 					const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
 					if (!result.bytesRead) {
-						close();
+						controller.close();
 						return;
 					}
-					enqueue(result.buffer.slice(0, result.bytesRead));
+					controller.enqueue(result.buffer.slice(0, result.bytesRead));
 					position += result.bytesRead;
 					if (++i >= maxChunks) {
 						throw new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
@@ -186,11 +186,15 @@ export class FileHandle implements promises.FileHandle {
 					bytesRead = result.bytesRead;
 				}
 			} catch (e) {
-				error(e);
+				controller.error(e);
 			}
 		};
 
-		return new (globalThis as any).ReadableStream({ start, type: options.type });
+		const _gt = globalThis;
+		if (!('ReadableStream' in _gt)) {
+			throw new ErrnoError(Errno.ENOSYS, 'ReadableStream is missing on globalThis');
+		}
+		return new (_gt as { ReadableStream: new (...args: unknown[]) => TReadableStream<Uint8Array> }).ReadableStream({ start, type: options.type });
 	}
 
 	public readLines(options?: promises.CreateReadStreamOptions): ReadlineInterface {
@@ -326,6 +330,7 @@ export class FileHandle implements promises.FileHandle {
 			highWaterMark: options?.highWaterMark || 64 * 1024,
 			encoding: options!.encoding!,
 
+			// eslint-disable-next-line @typescript-eslint/no-misused-promises
 			read: async (size: number) => {
 				try {
 					const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
@@ -573,7 +578,7 @@ export async function writeFile(
 	_options?: (fs.ObjectEncodingOptions & { mode?: fs.Mode; flag?: fs.OpenMode; flush?: boolean }) | BufferEncoding | null
 ): Promise<void> {
 	const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-	await using handle = path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode);
+	await using handle = path instanceof FileHandle ? path : await open((path as fs.PathLike).toString(), options.flag, options.mode);
 
 	const _data = typeof data == 'string' ? data : data;
 	if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {

package/src/emulation/sync.ts

@@ -219,7 +219,7 @@ export function readFileSync(path: fs.PathOrFileDescriptor, _options: fs.WriteFi
 	if (!isReadable(flag)) {
 		throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
 	}
-	const data: Buffer = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), options.flag, true));
+	const data: Buffer = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
 	return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync satisfies typeof fs.readFileSync;
@@ -251,7 +251,7 @@ export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents,
 	if (!encodedData) {
 		throw new ErrnoError(Errno.EINVAL, 'Data not specified');
 	}
-	using file = _openSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), flag, options.mode, true);
+	using file = _openSync(typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true);
 	file.writeSync(encodedData, 0, encodedData.byteLength, 0);
 }
 writeFileSync satisfies typeof fs.writeFileSync;
@@ -277,7 +277,7 @@ export function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileCont
 		throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
 	}
 	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-	using file = _openSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), flag, options.mode, true);
+	using file = _openSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true);
 	file.writeSync(encodedData, 0, encodedData.byteLength);
 }
 appendFileSync satisfies typeof fs.appendFileSync;
@@ -587,6 +587,7 @@ symlinkSync satisfies typeof fs.symlinkSync;
  */
 export function readlinkSync(path: fs.PathLike, options?: fs.BufferEncodingOption): Buffer;
 export function readlinkSync(path: fs.PathLike, options: fs.EncodingOption | BufferEncoding): string;
+export function readlinkSync(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Buffer | string;
 export function readlinkSync(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Buffer | string {
 	const value: Buffer = Buffer.from(_readFileSync(path.toString(), 'r', false));
 	const encoding = typeof options == 'object' ? options?.encoding : options;
@@ -697,7 +698,7 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs
 			return lpath;
 		}
 
-		return realpathSync(mountPoint + readlinkSync(lpath));
+		return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
 	} catch (e) {
 		throw fixError(e as Error, { [resolvedPath]: lpath });
 	}

package/src/file.ts

@@ -429,8 +429,8 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	/**
 	 * Asynchronous `stat`.
 	 */
-	public async stat(): Promise<Stats> {
-		return new Stats(this.stats);
+	public stat(): Promise<Stats> {
+		return Promise.resolve(new Stats(this.stats));
 	}
 
 	/**
@@ -673,8 +673,8 @@ export class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
 	/**
 	 * Asynchronous sync. Doesn't do anything, simply calls the cb.
 	 */
-	public async sync(): Promise<void> {
-		return;
+	public sync(): Promise<void> {
+		return Promise.resolve();
 	}
 	/**
 	 * Synchronous sync. Doesn't do anything.
@@ -685,8 +685,8 @@ export class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
 	/**
 	 * Asynchronous close. Doesn't do anything, simply calls the cb.
 	 */
-	public async close(): Promise<void> {
-		return;
+	public close(): Promise<void> {
+		return Promise.resolve();
 	}
 	/**
 	 * Synchronous close. Doesn't do anything.

package/src/filesystem.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/require-await */
 import type { ExtractProperties } from 'utilium';
 import { rootCred, type Cred } from './cred.js';
 import { join } from './emulation/path.js';
@@ -490,7 +491,7 @@ export function Async<T extends typeof FileSystem>(
 		 */
 		private queue(...op: AsyncOperation) {
 			this._queue.push(op);
-			this._next();
+			void this._next();
 		}
 	}
 

package/src/inode.ts

@@ -16,7 +16,7 @@ export const size_max = 2 ** 32 - 1;
  * Room inode
  * @hidden
  */
-export const rootIno = 0n as const;
+export const rootIno = 0n;
 
 /**
  * Generates a random 32 bit integer, then converts to a hex string
@@ -36,19 +36,38 @@ export function randomIno(): Ino {
 /**
  * Offsets for inode members
  */
-enum Offset {
-	ino = 0,
-	size = 8, // offsets with a 64-bit size
-	mode = 12, // 16
-	nlink = 14, // 18
-	uid = 18, // 22
-	gid = 22, // 26
-	atime = 26, // 30
-	birthtime = 34, // 38
-	mtime = 42, // 46
-	ctime = 50, // 54
-	end = 58, // 62
-}
+const offsets = {
+	ino: 0,
+	size: 8,
+	mode: 12,
+	nlink: 14,
+	uid: 18,
+	gid: 22,
+	atime: 26,
+	birthtime: 34,
+	mtime: 42,
+	ctime: 50,
+	end: 58,
+};
+
+/**
+ *  Offsets for a 64-bit inode's members
+ * Currently unused
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const offsets_64 = {
+	ino: 0,
+	size: 8,
+	mode: 16,
+	nlink: 18,
+	uid: 22,
+	gid: 26,
+	atime: 30,
+	birthtime: 38,
+	mtime: 46,
+	ctime: 54,
+	end: 62,
+};
 
 /**
  * Generic inode definition that can easily be serialized.
@@ -64,9 +83,9 @@ export class Inode implements StatsLike {
 
 	constructor(buffer?: ArrayBufferLike) {
 		const setDefaults = !buffer;
-		buffer ??= new ArrayBuffer(Offset.end);
-		if (buffer?.byteLength < Offset.end) {
-			throw new RangeError(`Can not create an inode from a buffer less than ${Offset.end} bytes`);
+		buffer ??= new ArrayBuffer(offsets.end);
+		if (buffer?.byteLength < offsets.end) {
+			throw new RangeError(`Can not create an inode from a buffer less than ${offsets.end} bytes`);
 		}
 		this.view = new DataView(buffer);
 		this.buffer = buffer;
@@ -87,83 +106,83 @@ export class Inode implements StatsLike {
 	}
 
 	public get ino(): Ino {
-		return this.view.getBigUint64(Offset.ino, true);
+		return this.view.getBigUint64(offsets.ino, true);
 	}
 
 	public set ino(value: Ino) {
-		this.view.setBigUint64(Offset.ino, value, true);
+		this.view.setBigUint64(offsets.ino, value, true);
 	}
 
 	public get size(): number {
-		return this.view.getUint32(Offset.size, true);
+		return this.view.getUint32(offsets.size, true);
 	}
 
 	public set size(value: number) {
-		this.view.setUint32(Offset.size, value, true);
+		this.view.setUint32(offsets.size, value, true);
 	}
 
 	public get mode(): number {
-		return this.view.getUint16(Offset.mode, true);
+		return this.view.getUint16(offsets.mode, true);
 	}
 
 	public set mode(value: number) {
-		this.view.setUint16(Offset.mode, value, true);
+		this.view.setUint16(offsets.mode, value, true);
 	}
 
 	public get nlink(): number {
-		return this.view.getUint32(Offset.nlink, true);
+		return this.view.getUint32(offsets.nlink, true);
 	}
 
 	public set nlink(value: number) {
-		this.view.setUint32(Offset.nlink, value, true);
+		this.view.setUint32(offsets.nlink, value, true);
 	}
 
 	public get uid(): number {
-		return this.view.getUint32(Offset.uid, true);
+		return this.view.getUint32(offsets.uid, true);
 	}
 
 	public set uid(value: number) {
-		this.view.setUint32(Offset.uid, value, true);
+		this.view.setUint32(offsets.uid, value, true);
 	}
 
 	public get gid(): number {
-		return this.view.getUint32(Offset.gid, true);
+		return this.view.getUint32(offsets.gid, true);
 	}
 
 	public set gid(value: number) {
-		this.view.setUint32(Offset.gid, value, true);
+		this.view.setUint32(offsets.gid, value, true);
 	}
 
 	public get atimeMs(): number {
-		return this.view.getFloat64(Offset.atime, true);
+		return this.view.getFloat64(offsets.atime, true);
 	}
 
 	public set atimeMs(value: number) {
-		this.view.setFloat64(Offset.atime, value, true);
+		this.view.setFloat64(offsets.atime, value, true);
 	}
 
 	public get birthtimeMs(): number {
-		return this.view.getFloat64(Offset.birthtime, true);
+		return this.view.getFloat64(offsets.birthtime, true);
 	}
 
 	public set birthtimeMs(value: number) {
-		this.view.setFloat64(Offset.birthtime, value, true);
+		this.view.setFloat64(offsets.birthtime, value, true);
 	}
 
 	public get mtimeMs(): number {
-		return this.view.getFloat64(Offset.mtime, true);
+		return this.view.getFloat64(offsets.mtime, true);
 	}
 
 	public set mtimeMs(value: number) {
-		this.view.setFloat64(Offset.mtime, value, true);
+		this.view.setFloat64(offsets.mtime, value, true);
 	}
 
 	public get ctimeMs(): number {
-		return this.view.getFloat64(Offset.ctime, true);
+		return this.view.getFloat64(offsets.ctime, true);
 	}
 
 	public set ctimeMs(value: number) {
-		this.view.setFloat64(Offset.ctime, value, true);
+		this.view.setFloat64(offsets.ctime, value, true);
 	}
 
 	/**

package/src/polyfills.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/unbound-method
 Promise.withResolvers ??= function <T>(): PromiseWithResolvers<T> {
 	let _resolve: ((value: T | PromiseLike<T>) => void) | undefined,
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any