@poe-platform/safe-fs 0.1.511 → 0.1.513

package/dist/safe-fs/fs/quota/index.js

@@ -1,5 +1,6 @@
 import { FsError } from "../../contracts/errors.js";
-import { openRetainedReadFile, quotaCapabilities, retainedReadCapabilities } from "../capabilities.js";
+import { finishCleanup } from "../../contracts/cleanup.js";
+import { openRetainedReadFile, openRetainedResizeFile, quotaCapabilities, retainedReadCapabilities, retainedResizeCapabilities } from "../capabilities.js";
 import { admitDirectoryEntries } from "../directory-admission.js";
 export class FileSystemQuotaError extends Error {
     maxBytes;
@@ -9,8 +10,25 @@ export class FileSystemQuotaError extends Error {
         this.name = "FileSystemQuotaError";
     }
 }
-async function usedBytes(fs, limits, options, change) {
+function completeIdentity(stat) {
+    return (typeof stat.identityScope === "symbol" || typeof stat.identityScope === "object" && stat.identityScope !== null)
+        && [stat.dev, stat.ino].every(value => typeof value === "number" && Number.isSafeInteger(value) && value >= 0);
+}
+function namespaceMetadata(metadata, signal) {
+    if (!signal)
+        return metadata;
+    return new Promise((resolve, reject) => {
+        const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+        signal.addEventListener("abort", abort, { once: true });
+        metadata.then(value => { signal.removeEventListener("abort", abort); resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(error); });
+        if (signal.aborted)
+            abort();
+    });
+}
+async function usedBytes(fs, limits, options, change, retained = change?.retained === true) {
     let total = 0;
+    let retainedTotal = 0n;
+    let shrinkCredited = false;
     let possibleAliases = 0;
     let remaining = limits.maxScanEntries;
     const pending = [{ path: "/", depth: 0 }];
@@ -20,7 +38,8 @@ async function usedBytes(fs, limits, options, change) {
         if (!directory)
             break;
         const signal = options?.signal;
-        const entries = await fs.readdir(directory.path, { ...options, ...(signal ? { signal } : {}), maxEntries: remaining });
+        const listing = fs.readdir(directory.path, { ...options, ...(signal ? { signal } : {}), maxEntries: remaining });
+        const entries = await (retained ? namespaceMetadata(listing, signal) : listing);
         options?.signal?.throwIfAborted();
         const count = entries.length;
         admitDirectoryEntries(count, remaining, directory.path);
@@ -41,7 +60,32 @@ async function usedBytes(fs, limits, options, change) {
                 pending.push({ path, depth });
             }
             else {
-                const stat = await fs.lstat(path, options);
+                const metadata = fs.lstat(path, options);
+                const stat = await (retained ? namespaceMetadata(metadata, signal) : metadata);
+                if (retained) {
+                    options?.signal?.throwIfAborted();
+                    if (!Number.isSafeInteger(stat.size) || stat.size < 0)
+                        throw new FsError("EIO", { syscall: "lstat", path, message: "invalid quota entry size" });
+                    retainedTotal += BigInt(stat.size);
+                    if (!change || stat.type !== "file")
+                        continue;
+                    const known = completeIdentity(stat);
+                    const same = known && change.stat.identityScope === stat.identityScope && change.stat.dev === stat.dev && change.stat.ino === stat.ino;
+                    const nextBytes = change.stat.size + change.delta;
+                    if (same) {
+                        possibleAliases++;
+                        retainedTotal += BigInt(Math.max(0, nextBytes - stat.size));
+                        if (!shrinkCredited && change.delta < 0) {
+                            retainedTotal -= BigInt(Math.max(0, Math.min(stat.size, change.stat.size) - nextBytes));
+                            shrinkCredited = true;
+                        }
+                    }
+                    else if (!known) {
+                        possibleAliases++;
+                        retainedTotal += BigInt(Math.max(0, change.delta, nextBytes - stat.size));
+                    }
+                    continue;
+                }
                 total += stat.size;
                 if (!change || stat.type !== "file")
                     continue;
@@ -66,6 +110,11 @@ async function usedBytes(fs, limits, options, change) {
             }
         }
     }
+    if (retained) {
+        if (change && possibleAliases === 0)
+            retainedTotal += BigInt(Math.max(0, change.delta));
+        return Number(retainedTotal);
+    }
     if (change && possibleAliases === 0)
         total += Math.max(0, change.delta);
     return total;
@@ -98,6 +147,24 @@ export function withFileSystemQuota(fs, options) {
         queue = result.catch(() => undefined);
         return result;
     };
+    const resizeBackend = new Proxy(Object.create(fs), {
+        get(_target, property) {
+            const original = Reflect.get(fs, property);
+            if (property === "openResizeFile" && typeof original === "function")
+                return async (path, resizeOptions) => {
+                    resizeOptions.signal?.throwIfAborted();
+                    if (resizeOptions.create) {
+                        const total = await usedBytes(fs, scanLimits, resizeOptions, undefined, true);
+                        resizeOptions.signal?.throwIfAborted();
+                        if (total > options.maxBytes)
+                            throw new FileSystemQuotaError(options.maxBytes);
+                    }
+                    resizeOptions.signal?.throwIfAborted();
+                    return Reflect.apply(original, fs, [path, resizeOptions]);
+                };
+            return typeof original === "function" ? original.bind(fs) : original;
+        },
+    });
     const assertDelta = async (path, nextBytes, fsOptions) => {
         fsOptions?.signal?.throwIfAborted();
         let current;
@@ -116,6 +183,75 @@ export function withFileSystemQuota(fs, options) {
             throw new FileSystemQuotaError(options.maxBytes);
     };
     const mutations = {
+        openResizeFile(path, resizeOptions = {}) {
+            return mutate(async () => {
+                let retained;
+                try {
+                    retained = await openRetainedResizeFile(resizeBackend, path, resizeOptions);
+                    const pinned = { ...await retained.stat(resizeOptions) };
+                    resizeOptions.signal?.throwIfAborted();
+                    if (pinned.type !== "file" || !completeIdentity(pinned))
+                        throw new FsError("ENOTSUP", { syscall: "openResizeFile", path, message: "quota requires complete retained file identity" });
+                    if (!Number.isSafeInteger(pinned.size) || pinned.size < 0)
+                        throw new FsError("EIO", { syscall: "stat", path, message: "invalid retained file size" });
+                    const handle = retained;
+                    const seekEnd = handle.seekEnd;
+                    resizeOptions.signal?.throwIfAborted();
+                    let pending = Promise.resolve();
+                    let closing;
+                    const admit = (operation, operationOptions) => {
+                        if (closing)
+                            return Promise.reject(new FsError("EBADF", { path }));
+                        const result = mutate(async () => {
+                            operationOptions?.signal?.throwIfAborted();
+                            const value = await operation();
+                            operationOptions?.signal?.throwIfAborted();
+                            return value;
+                        });
+                        pending = result.catch(() => undefined);
+                        return result;
+                    };
+                    const current = async (operationOptions) => {
+                        const stat = { ...await handle.stat(operationOptions) };
+                        operationOptions?.signal?.throwIfAborted();
+                        if (stat.type !== "file" || !completeIdentity(stat) || stat.identityScope !== pinned.identityScope || stat.dev !== pinned.dev || stat.ino !== pinned.ino
+                            || !Number.isSafeInteger(stat.size) || stat.size < 0)
+                            throw new FsError("EIO", { syscall: "stat", path, message: "invalid retained quota identity or size" });
+                        return stat;
+                    };
+                    return {
+                        stat(operationOptions) { return admit(() => current(operationOptions), operationOptions); },
+                        ...(typeof seekEnd === "function" ? {
+                            seekEnd(operationOptions) {
+                                return admit(() => Reflect.apply(seekEnd, handle, [operationOptions]), operationOptions);
+                            },
+                        } : {}),
+                        truncate(length, operationOptions) {
+                            return admit(async () => {
+                                if (!Number.isSafeInteger(length) || length < 0)
+                                    throw new FsError("EINVAL", { syscall: "truncate", path });
+                                const stat = await current(operationOptions);
+                                const projected = await usedBytes(fs, scanLimits, operationOptions, { path, stat, delta: length - stat.size, retained: true });
+                                operationOptions?.signal?.throwIfAborted();
+                                if (projected > options.maxBytes)
+                                    throw new FileSystemQuotaError(options.maxBytes);
+                                await handle.truncate(length, operationOptions);
+                            }, operationOptions);
+                        },
+                        close() {
+                            closing ??= pending.then(() => handle.close());
+                            return closing;
+                        },
+                    };
+                }
+                catch (error) {
+                    if (retained)
+                        await finishCleanup(() => retained.close(), true);
+                    resizeOptions.signal?.throwIfAborted();
+                    throw error;
+                }
+            });
+        },
         writeFile(path, data, writeOptions) {
             return mutate(async () => {
                 const append = writeOptions?.flag === "a" || writeOptions?.flag === "ax";
@@ -183,11 +319,11 @@ export function withFileSystemQuota(fs, options) {
             if (property === "canonicalizeMissingTarget")
                 return undefined;
             if (property === "capabilities")
-                return quotaCapabilities(retainedReadCapabilities(fs));
+                return quotaCapabilities(retainedResizeCapabilities(fs, retainedReadCapabilities(fs)));
             if (property === "capabilitiesFor")
                 return async (path, fsOptions) => {
                     const capabilities = await fs.capabilitiesFor?.(path, fsOptions) ?? fs.capabilities;
-                    return quotaCapabilities(retainedReadCapabilities(fs, capabilities));
+                    return quotaCapabilities(retainedResizeCapabilities(fs, retainedReadCapabilities(fs, capabilities)));
                 };
             if (property === "openReadFile")
                 return (path, fsOptions = {}) => openRetainedReadFile(fs, path, fsOptions);

package/dist/safe-fs/fs/readonly/index.d.ts

@@ -1,11 +1,11 @@
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileResizeHandle, FileStat, OpenReadFileOptions, OpenResizeFileOptions, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export declare class ReadOnlyFileSystem implements FileSystem {
     #private;
     constructor(filesystem: FileSystem);
     get capabilities(): FileSystemCapabilities;
-    capabilitiesFor(path: string, options?: FsOptions): Promise<FileSystemCapabilities>;
-    openReadFile(path: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").FileReadHandle>;
+    capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
+    openReadFile(path: string, options?: OpenReadFileOptions): Promise<import("../../contracts/filesystem.js").FileReadHandle>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
@@ -29,5 +29,6 @@ export declare class ReadOnlyFileSystem implements FileSystem {
     chmod(path: string, _mode: number, _options?: FsOptions): Promise<void>;
     utimes(path: string, _atimeMs: number, _mtimeMs: number, _options?: FsOptions): Promise<void>;
     truncate(path: string, _length?: number, _options?: FsOptions): Promise<void>;
+    openResizeFile(path: string, options?: OpenResizeFileOptions): Promise<FileResizeHandle>;
 }
 export declare function createReadOnlyFileSystem(filesystem: FileSystem): ReadOnlyFileSystem;

package/dist/safe-fs/fs/readonly/index.js

@@ -4,14 +4,16 @@ import { readBytes } from "../../contracts/io.js";
 import { compareEntries, registerEntryView } from "../mount/comparison.js";
 import { openRetainedReadFile, readOnlyCapabilities, retainedReadCapabilities } from "../capabilities.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
+import { pathNamespace, readOnlyPathNamespace } from "../path-namespace.js";
 function readOnly(syscall, path, dest) {
     throw new FsError("EROFS", { syscall, path, ...(dest === undefined ? {} : { dest }) });
 }
 function snapshotStat(stat) {
-    const { type, size, allocatedBytes, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, identityScope, ino, dev, nlink, uid, gid } = stat;
+    const { type, size, allocatedBytes, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, identityScope, ino, dev, nlink, uid, gid } = stat;
     return {
         type, size, mode, mtimeMs, atimeMs, ctimeMs,
         ...(allocatedBytes === undefined ? {} : { allocatedBytes }),
+        ...(preferredIoBlockSize === undefined ? {} : { preferredIoBlockSize }),
         ...(birthtimeMs === undefined ? {} : { birthtimeMs }),
         ...(identityScope === undefined ? {} : { identityScope }),
         ...(ino === undefined ? {} : { ino }),
@@ -26,6 +28,10 @@ export class ReadOnlyFileSystem {
     #capabilities;
     constructor(filesystem) {
         this.#filesystem = filesystem;
+        if (Reflect.has(filesystem, pathNamespace))
+            Object.defineProperty(this, pathNamespace, {
+                get: () => readOnlyPathNamespace(Reflect.get(filesystem, pathNamespace)),
+            });
         registerEntryView(this, async (path) => ({ filesystem: this.#filesystem, path, readOnly: true }));
         const streamingRead = typeof filesystem.readStream === "function" ? filesystem.capabilities.streamingRead : false;
         this.#capabilities = readOnlyCapabilities({
@@ -45,6 +51,9 @@ export class ReadOnlyFileSystem {
         return this.#capabilities;
     }
     async capabilitiesFor(path, options) {
+        options?.signal?.throwIfAborted();
+        if (options?.create !== undefined)
+            readOnly("capabilitiesFor", path);
         const capabilities = await this.#filesystem.capabilitiesFor?.(path, options) ?? this.#filesystem.capabilities;
         return readOnlyCapabilities(retainedReadCapabilities(this.#filesystem, capabilities));
     }
@@ -138,6 +147,10 @@ export class ReadOnlyFileSystem {
     async truncate(path, _length, _options) {
         readOnly("truncate", path);
     }
+    async openResizeFile(path, options = {}) {
+        options.signal?.throwIfAborted();
+        readOnly("openResizeFile", path);
+    }
 }
 export function createReadOnlyFileSystem(filesystem) {
     return new ReadOnlyFileSystem(filesystem);

package/dist/safe-fs/fs/real/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, OpenReadFileOptions, OpenResizeFileOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
 export interface RealFileSystemOptions {
     /** An existing, absolute host directory. It is never created implicitly. */
     readonly root: string;
@@ -69,7 +69,8 @@ export declare class RealFileSystem implements FileSystem {
     chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
     utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
     truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
-    openReadFile(path: string, options?: FsOptions): Promise<FileReadHandle>;
+    openResizeFile(path: string, options?: OpenResizeFileOptions): Promise<FileResizeHandle>;
+    openReadFile(path: string, options?: OpenReadFileOptions): Promise<FileReadHandle>;
     readStream(path: string, options?: ReadStreamOptions): ByteSource;
     writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
 }

package/dist/safe-fs/fs/real/index.js

@@ -3,6 +3,7 @@ import * as native from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { nativeAllocatedBytes } from "./allocation.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
+import { callNativeSeekEnd, loadNativeSeekBinding } from "../../node/native-seek.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 import { FsError, collectBytes, isErrnoCode, toByteSource, toFsError, validatePath, } from "../../contracts/index.js";
 function fileType(stats) {
@@ -16,9 +17,11 @@ function fileType(stats) {
 }
 function fileStat(stats) {
     const allocatedBytes = nativeAllocatedBytes(stats.blocks, process.platform);
+    const preferredIoBlockSize = stats.blksize;
     return {
         type: fileType(stats), size: stats.size, mode: stats.mode,
         ...(allocatedBytes === undefined ? {} : { allocatedBytes }),
+        ...(Number.isSafeInteger(preferredIoBlockSize) && preferredIoBlockSize > 0 ? { preferredIoBlockSize } : {}),
         atimeMs: stats.atimeMs, mtimeMs: stats.mtimeMs, ctimeMs: stats.ctimeMs,
         birthtimeMs: stats.birthtimeMs, ino: stats.ino, dev: stats.dev,
         ...(Number.isSafeInteger(stats.dev) && stats.dev >= 0 && Number.isSafeInteger(stats.ino) && stats.ino >= 0
@@ -87,7 +90,7 @@ export class RealFileSystem {
         rename: true, atomicRenameNoReplace: false, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
         streamingAppend: true, randomAccessWrite: true,
         readOnly: false, symlinks: true, hardlinks: true, permissions: true,
-        timestamps: true, atomicRename: true, streamingRead: true, streamingWrite: true, retainedRead: true,
+        timestamps: true, atomicRename: true, streamingRead: true, streamingWrite: true, retainedRead: true, retainedResize: true,
     });
     configuredRoot;
     rootPromise;
@@ -136,7 +139,13 @@ export class RealFileSystem {
         while (pending.length > 0) {
             options.signal?.throwIfAborted();
             const { name: component, fromLink } = pending.shift();
-            if (component === "" || component === ".")
+            if (component === "")
+                continue;
+            if ((component === "." || component === "..") && !options.checkTarget) {
+                await native.lstat(`${current}/.`);
+                options.signal?.throwIfAborted();
+            }
+            if (component === ".")
                 continue;
             if (component === "..") {
                 if (current === root) {
@@ -148,6 +157,11 @@ export class RealFileSystem {
                 }
                 continue;
             }
+            if (options.createFile && pending.length > 0 && pending.every((part) => part.name === "")) {
+                await native.lstat(`${current}/.`);
+                options.signal?.throwIfAborted();
+                throw new FsError("EISDIR");
+            }
             const candidate = join(current, component);
             let stats;
             try {
@@ -476,20 +490,23 @@ export class RealFileSystem {
             }
         });
     }
-    async openReadFile(path, options = {}) {
+    async openResizeFile(path, options = {}) {
         options.signal?.throwIfAborted();
         const assertStock = () => {
-            const unsupported = () => { throw new FsError("ENOTSUP", { syscall: "openReadFile", path }); };
+            const unsupported = () => { throw new FsError("ENOTSUP", { syscall: "openResizeFile", path }); };
             if (Object.getPrototypeOf(this) !== RealFileSystem.prototype)
                 unsupported();
-            for (const name of ["openReadFile", "readFile", "readStream", "stat", "lstat", "realpath", "access",
+            for (const name of ["openResizeFile", "truncate", "writeFile", "writeStream", "appendFile", "stat", "lstat", "realpath", "access",
                 "root", "absoluteTarget", "walk", "path"]) {
                 const descriptor = Object.getOwnPropertyDescriptor(this, name)
                     ?? Object.getOwnPropertyDescriptor(RealFileSystem.prototype, name);
                 if (!descriptor || !("value" in descriptor) || descriptor.value !== realImplementation[name]?.value)
                     unsupported();
             }
-            if (Object.getOwnPropertyDescriptor(this, "capabilities")?.value?.retainedRead !== true)
+            const capabilities = Object.getOwnPropertyDescriptor(this, "capabilities")?.value;
+            if (capabilities?.readOnly === true)
+                throw new FsError("EROFS", { syscall: "openResizeFile", path });
+            if (capabilities?.retainedResize !== true)
                 unsupported();
         };
         assertStock();
@@ -497,10 +514,19 @@ export class RealFileSystem {
             ? new FsError(nativeError(error).code, { syscall, path }) : error;
         let resource;
         try {
-            const target = await this.path(path, options);
+            if (options.mode !== undefined)
+                integer(options.mode);
+            if (options.create !== undefined && typeof options.create !== "boolean")
+                throw new FsError("EINVAL");
+            const target = await this.path(path, {
+                ...options, ...(options.create === true ? { missing: "final" } : {}),
+                deferTrailingSeparator: true, createFile: options.create === true,
+            });
             options.signal?.throwIfAborted();
             assertStock();
-            resource = await native.open(target, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            const flags = constants.O_WRONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+                | (options.create === true ? constants.O_CREAT : 0);
+            resource = await native.open(target, flags, options.mode ?? 0o666);
             options.signal?.throwIfAborted();
             const stats = await resource.stat();
             options.signal?.throwIfAborted();
@@ -513,6 +539,127 @@ export class RealFileSystem {
         catch (error) {
             await finishCleanup(async () => { await resource?.close(); }, true);
             options.signal?.throwIfAborted();
+            throw failure(error, "openResizeFile");
+        }
+        const handle = resource;
+        const pending = new Set();
+        let accepting = true;
+        let closing;
+        const assertOpen = (options, syscall) => {
+            options.signal?.throwIfAborted();
+            if (!accepting)
+                throw new FsError("EBADF", { syscall, path });
+        };
+        const perform = async (options, syscall, action) => {
+            assertOpen(options, syscall);
+            let settled;
+            const admitted = new Promise(resolve => { settled = resolve; });
+            pending.add(admitted);
+            try {
+                const value = await action();
+                options.signal?.throwIfAborted();
+                return value;
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                throw failure(error, syscall);
+            }
+            finally {
+                pending.delete(admitted);
+                settled();
+            }
+        };
+        return {
+            stat(options = {}) {
+                return perform(options, "fstat", async () => fileStat(await handle.stat()));
+            },
+            async truncate(length, options = {}) {
+                assertOpen(options, "ftruncate");
+                try {
+                    integer(length);
+                }
+                catch (error) {
+                    throw failure(error, "ftruncate");
+                }
+                return perform(options, "ftruncate", async () => { await handle.truncate(length); });
+            },
+            async seekEnd(options = {}) {
+                const signal = options.signal;
+                const operationOptions = signal === undefined ? {} : { signal };
+                assertOpen(operationOptions, "lseek");
+                try {
+                    const binding = await loadNativeSeekBinding(signal);
+                    assertOpen(operationOptions, "lseek");
+                    const seek = binding.seekEnd;
+                    assertOpen(operationOptions, "lseek");
+                    if (typeof seek !== "function")
+                        throw new FsError("EIO");
+                    const descriptor = handle.fd;
+                    assertOpen(operationOptions, "lseek");
+                    return await perform(operationOptions, "lseek", () => callNativeSeekEnd(binding, seek, descriptor));
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    throw failure(error, "lseek");
+                }
+            },
+            close() {
+                accepting = false;
+                closing ??= Promise.all([...pending]).then(async () => {
+                    try {
+                        await handle.close();
+                    }
+                    catch (error) {
+                        throw failure(error, "close");
+                    }
+                });
+                return closing;
+            },
+        };
+    }
+    async openReadFile(path, options = {}) {
+        const signal = options.signal;
+        signal?.throwIfAborted();
+        const assertStock = () => {
+            const unsupported = () => { throw new FsError("ENOTSUP", { syscall: "openReadFile", path }); };
+            if (Object.getPrototypeOf(this) !== RealFileSystem.prototype)
+                unsupported();
+            for (const name of ["openReadFile", "readFile", "readStream", "stat", "lstat", "realpath", "access",
+                "root", "absoluteTarget", "walk", "path"]) {
+                const descriptor = Object.getOwnPropertyDescriptor(this, name)
+                    ?? Object.getOwnPropertyDescriptor(RealFileSystem.prototype, name);
+                if (!descriptor || !("value" in descriptor) || descriptor.value !== realImplementation[name]?.value)
+                    unsupported();
+            }
+            if (Object.getOwnPropertyDescriptor(this, "capabilities")?.value?.retainedRead !== true)
+                unsupported();
+        };
+        assertStock();
+        const failure = (error, syscall) => error
+            ? new FsError(nativeError(error).code, { syscall, path }) : error;
+        let resource;
+        let directory = false;
+        try {
+            const allowDirectory = options.allowDirectory === true;
+            signal?.throwIfAborted();
+            const target = await this.path(path, signal === undefined ? {} : { signal });
+            signal?.throwIfAborted();
+            assertStock();
+            resource = await native.open(target, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            signal?.throwIfAborted();
+            const stats = await resource.stat();
+            signal?.throwIfAborted();
+            assertStock();
+            directory = stats.isDirectory();
+            if (directory && !allowDirectory)
+                throw new FsError("EISDIR");
+            if (!directory && !stats.isFile())
+                throw new FsError("ENOTSUP");
+            signal?.throwIfAborted();
+        }
+        catch (error) {
+            await finishCleanup(async () => { await resource?.close(); }, true);
+            signal?.throwIfAborted();
             throw failure(error, "openReadFile");
         }
         const handle = resource;
@@ -558,6 +705,8 @@ export class RealFileSystem {
                 }
                 if (maxBytes > Number.MAX_SAFE_INTEGER - position)
                     throw new FsError("EINVAL", { syscall: "read", path });
+                if (directory)
+                    throw new FsError("EISDIR", { syscall: "read", path });
                 return perform(options, "read", async () => {
                     let bytes;
                     try {
@@ -572,6 +721,26 @@ export class RealFileSystem {
                     return bytes.slice(0, bytesRead);
                 });
             },
+            async seekEnd(options = {}) {
+                const signal = options.signal;
+                const operationOptions = signal === undefined ? {} : { signal };
+                assertOpen(operationOptions, "lseek");
+                try {
+                    const binding = await loadNativeSeekBinding(signal);
+                    assertOpen(operationOptions, "lseek");
+                    const seek = binding.seekEnd;
+                    assertOpen(operationOptions, "lseek");
+                    if (typeof seek !== "function")
+                        throw new FsError("EIO");
+                    const descriptor = handle.fd;
+                    assertOpen(operationOptions, "lseek");
+                    return await perform(operationOptions, "lseek", () => callNativeSeekEnd(binding, seek, descriptor));
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    throw failure(error, "lseek");
+                }
+            },
             close() {
                 accepting = false;
                 closing ??= Promise.all([...pending]).then(async () => {