toolcraft 0.0.749 → 0.0.751

package/node_modules/@poe-code/safe-fs/dist/fs/quota/index.d.ts

@@ -0,0 +1,12 @@
+import type { FileSystem } from "../../contracts/filesystem.js";
+export interface FileSystemQuotaOptions {
+    readonly maxBytes: number;
+    readonly maxScanEntries?: number;
+    readonly maxScanDepth?: number;
+}
+export declare class FileSystemQuotaError extends Error {
+    readonly maxBytes: number;
+    readonly code = "ENOSPC";
+    constructor(maxBytes: number);
+}
+export declare function withFileSystemQuota(fs: FileSystem, options: FileSystemQuotaOptions): FileSystem;

package/node_modules/@poe-code/safe-fs/dist/fs/quota/index.js

@@ -0,0 +1,520 @@
+import { FsError } from "../../contracts/errors.js";
+import { finishCleanup } from "../../contracts/cleanup.js";
+import { openRetainedReadFile, openRetainedResizeFile, quotaCapabilities, retainedReadCapabilities, retainedResizeCapabilities } from "../capabilities.js";
+import { admitDirectoryEntries } from "../directory-admission.js";
+import { forwardFileDescriptor, openFileDescriptor } from "../descriptor.js";
+export class FileSystemQuotaError extends Error {
+    maxBytes;
+    code = "ENOSPC";
+    constructor(maxBytes) {
+        super(`Filesystem quota exceeded (${maxBytes} bytes)`);
+        this.maxBytes = maxBytes;
+        this.name = "FileSystemQuotaError";
+    }
+}
+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 scanUsedBytes(fs, limits, options, changeInput, retained = typeof changeInput !== "function" && changeInput?.retained === true) {
+    let change = typeof changeInput === "function" ? undefined : changeInput;
+    let prepare = typeof changeInput === "function" ? changeInput : undefined;
+    let total = 0;
+    let retainedTotal = 0n;
+    let shrinkCredited = false;
+    let possibleAliases = 0;
+    let remaining = limits.maxScanEntries;
+    const pending = [{ path: "/", depth: 0 }];
+    while (pending.length) {
+        options?.signal?.throwIfAborted();
+        const directory = pending.pop();
+        if (!directory)
+            break;
+        const signal = options?.signal;
+        const listing = fs.readdir(directory.path, { ...options, ...(signal ? { signal } : {}), ...(remaining === Infinity ? {} : { maxEntries: remaining }) });
+        const entries = await (retained ? namespaceMetadata(listing, signal) : listing);
+        options?.signal?.throwIfAborted();
+        const count = entries.length;
+        admitDirectoryEntries(count, remaining, directory.path);
+        remaining -= count;
+        if (prepare) {
+            change = await prepare();
+            prepare = undefined;
+        }
+        if (change?.stat.type === "directory") {
+            const stat = await fs.stat(directory.path, options);
+            const comparable = completeIdentity(stat) && completeIdentity(change.stat);
+            const comparison = comparable
+                ? stat.identityScope === change.stat.identityScope && stat.dev === change.stat.dev && stat.ino === change.stat.ino ? "same" : "distinct"
+                : fs.compareEntry ? await fs.compareEntry(change.path, fs, directory.path, options) : "unknown";
+            options?.signal?.throwIfAborted();
+            if (comparison !== "same" && comparison !== "distinct" && comparison !== "unknown")
+                throw new FsError("EIO", { syscall: "compareEntry", path: change.path });
+            if (comparison !== "distinct") {
+                total += Math.max(0, change.delta);
+                possibleAliases++;
+            }
+        }
+        let processed = 0;
+        for (const entry of entries) {
+            options?.signal?.throwIfAborted();
+            if (processed >= count) {
+                admitDirectoryEntries(1, remaining, directory.path);
+                remaining--;
+            }
+            processed++;
+            const path = `${directory.path === "/" ? "" : directory.path}/${entry.name}`;
+            if (entry.type === "directory") {
+                const depth = directory.depth + 1;
+                if (depth > limits.maxScanDepth)
+                    throw new FsError("EFBIG", { syscall: "readdir", path, message: "quota scan depth limit exceeded" });
+                pending.push({ path, depth });
+            }
+            else {
+                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 || change.stat.type !== "file" || 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 || change.stat.type !== "file" || stat.type !== "file")
+                    continue;
+                const scope = change.stat.identityScope;
+                const comparable = [scope, stat.identityScope].every(value => typeof value === "symbol" || typeof value === "object" && value !== null)
+                    && [change.stat.dev, change.stat.ino, stat.dev, stat.ino].every(value => typeof value === "number" && Number.isSafeInteger(value) && value >= 0);
+                const compare = comparable ? undefined : fs.compareEntry;
+                const comparison = comparable
+                    ? scope === stat.identityScope && change.stat.dev === stat.dev && change.stat.ino === stat.ino ? "same" : "distinct"
+                    : compare === undefined ? "unknown" : await compare.call(fs, change.path, fs, path, options);
+                options?.signal?.throwIfAborted();
+                if (comparison !== "same" && comparison !== "distinct" && comparison !== "unknown")
+                    throw new FsError("EIO", { syscall: "compareEntry", path: change.path, dest: path, message: "invalid entry comparison" });
+                if (comparison === "same") {
+                    total += change.delta;
+                    possibleAliases++;
+                }
+                else if (comparison !== "distinct") {
+                    total += Math.max(0, change.delta);
+                    possibleAliases++;
+                }
+            }
+        }
+    }
+    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;
+}
+async function existingBytes(fs, path, options) {
+    try {
+        const stat = await fs.stat(path, options);
+        return stat.type === "directory" ? 0 : stat.size;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return 0;
+        throw error;
+    }
+}
+export function withFileSystemQuota(fs, options) {
+    if (options.maxBytes !== Infinity && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0))
+        throw new RangeError("maxBytes must be a nonnegative safe integer or Infinity");
+    const scanLimits = {
+        maxScanEntries: options.maxScanEntries ?? Infinity,
+        maxScanDepth: options.maxScanDepth ?? Infinity,
+    };
+    for (const [name, value] of Object.entries({ maxScanEntries: options.maxScanEntries, maxScanDepth: options.maxScanDepth })) {
+        if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value < 0))
+            throw new RangeError(`${name} must be a nonnegative safe integer or Infinity`);
+    }
+    let queue = Promise.resolve();
+    let reservedBytes = 0;
+    const usedBytes = async (...args) => await scanUsedBytes(...args) + reservedBytes;
+    const mutate = (operation) => {
+        const result = queue.then(operation);
+        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 creationChange = async (path, delta, fsOptions) => {
+        // Resolve existing ancestors before comparing directory identities. A dangling
+        // final symlink cannot safely identify its publication directory here.
+        let target;
+        try {
+            target = fs.canonicalizeMissingTarget?.(path, fsOptions) ?? path;
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                throw new FileSystemQuotaError(options.maxBytes);
+            throw error;
+        }
+        try {
+            const entry = fs.canonicalizeMissingTarget ? undefined : await fs.lstat(target, fsOptions);
+            if (entry?.type === "symlink")
+                throw new FsError("ENOTSUP", { syscall: "write", path, message: "quota cannot locate missing symlink referent" });
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                throw error;
+        }
+        const boundary = target.lastIndexOf("/");
+        const parent = await fs.realpath(boundary <= 0 ? "/" : target.slice(0, boundary), fsOptions);
+        const stat = await fs.stat(parent, fsOptions);
+        fsOptions?.signal?.throwIfAborted();
+        if (stat.type !== "directory")
+            throw new FsError("ENOTDIR", { syscall: "write", path });
+        return { path: parent, stat, delta };
+    };
+    const assertDelta = async (path, nextBytes, fsOptions) => {
+        fsOptions?.signal?.throwIfAborted();
+        let current;
+        try {
+            current = await fs.stat(path, fsOptions);
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                throw error;
+        }
+        const projected = current?.type === "file" && nextBytes > current.size
+            ? await usedBytes(fs, scanLimits, fsOptions, { path, stat: current, delta: nextBytes - current.size })
+            : !current && nextBytes > 0
+                ? await usedBytes(fs, scanLimits, fsOptions, () => creationChange(path, nextBytes, fsOptions))
+                : await usedBytes(fs, scanLimits, fsOptions) - (current?.type === "directory" ? 0 : current?.size ?? 0) + nextBytes;
+        fsOptions?.signal?.throwIfAborted();
+        if (projected > options.maxBytes)
+            throw new FileSystemQuotaError(options.maxBytes);
+    };
+    const mutations = {
+        open(path, openOptions) {
+            return openFileDescriptor(path, openOptions, {
+                noFollow: true, positionedRead: true, positionedWrite: true, truncate: true, synchronization: "storage",
+            }, admitted => mutate(async () => {
+                admitted.signal?.throwIfAborted();
+                const open = fs.open;
+                const capabilities = admitted.noFollow || admitted.creation === "exclusive" ? fs.capabilities : await fs.capabilitiesFor?.(path, admitted) ?? fs.capabilities;
+                admitted.signal?.throwIfAborted();
+                if (!open || capabilities.open === false)
+                    throw new FsError("ENOTSUP", { syscall: "open", path });
+                admitted.signal?.throwIfAborted();
+                const descriptor = await open.call(fs, path, admitted);
+                try {
+                    admitted.signal?.throwIfAborted();
+                    const pinned = admitted.access === "read" ? undefined : { ...await descriptor.stat(admitted) };
+                    const conditional = descriptor.capabilities.publication === "conditional" && pinned !== undefined;
+                    let publishedSize = pinned?.size ?? 0;
+                    let reserved = 0;
+                    let publicationAliases = 1;
+                    if (conditional) {
+                        const baseline = await usedBytes(fs, scanLimits, admitted);
+                        publicationAliases = await usedBytes(fs, scanLimits, admitted, () => creationChange(path, 1, admitted)) - baseline;
+                        if (!Number.isSafeInteger(publicationAliases) || publicationAliases < 1)
+                            throw new FsError("ENOTSUP", { syscall: "open", path, message: "quota cannot determine publication aliases" });
+                    }
+                    const reserve = (size) => {
+                        const next = Math.max(0, size - publishedSize) * publicationAliases;
+                        reservedBytes += next - reserved;
+                        reserved = next;
+                    };
+                    admitted.signal?.throwIfAborted();
+                    if (pinned && (pinned.type !== "file" || !completeIdentity(pinned))) {
+                        throw new FsError("ENOTSUP", { syscall: "open", path, message: "quota requires complete retained file identity" });
+                    }
+                    if (pinned && (!Number.isSafeInteger(pinned.size) || pinned.size < 0)) {
+                        throw new FsError("EIO", { syscall: "fstat", path, message: "invalid retained file size" });
+                    }
+                    const current = async (operationOptions) => {
+                        const stat = { ...await descriptor.stat(operationOptions) };
+                        operationOptions.signal?.throwIfAborted();
+                        if (!pinned || stat.type !== "file" || !completeIdentity(stat)
+                            || !conditional && (stat.identityScope !== pinned.identityScope || stat.dev !== pinned.dev || stat.ino !== pinned.ino)
+                            || !Number.isSafeInteger(stat.size) || stat.size < 0) {
+                            throw new FsError("EIO", { syscall: "fstat", path, message: "invalid retained quota identity or size" });
+                        }
+                        return stat;
+                    };
+                    const admitSize = async (stat, nextBytes, operationOptions) => {
+                        if (!Number.isSafeInteger(nextBytes) || nextBytes < 0)
+                            throw new FsError("EFBIG", { syscall: "write", path });
+                        const projected = conditional
+                            ? await usedBytes(fs, scanLimits, operationOptions) - reserved + Math.max(0, nextBytes - publishedSize) * publicationAliases
+                            : await usedBytes(fs, scanLimits, operationOptions, { path, stat, delta: nextBytes - stat.size, retained: true });
+                        operationOptions.signal?.throwIfAborted();
+                        if (projected > options.maxBytes)
+                            throw new FileSystemQuotaError(options.maxBytes);
+                        if (conditional)
+                            reserve(Math.max(nextBytes, publishedSize + reserved / publicationAliases));
+                    };
+                    const forwarded = forwardFileDescriptor(descriptor, (syscall, operationOptions, action) => syscall === "close" && !conditional ? action() : mutate(async () => {
+                        try {
+                            operationOptions.signal?.throwIfAborted();
+                            const result = await action();
+                            if (conditional && (syscall === "fsync" || syscall === "fdatasync")) {
+                                publishedSize = (await current(operationOptions)).size;
+                                reserve(publishedSize);
+                            }
+                            return result;
+                        }
+                        finally {
+                            if (syscall === "close") {
+                                reservedBytes -= reserved;
+                                reserved = 0;
+                            }
+                        }
+                    }));
+                    return {
+                        ...forwarded,
+                        write: (retained, buffer, position, operationOptions) => mutate(async () => {
+                            operationOptions.signal?.throwIfAborted();
+                            if (buffer.byteLength === 0)
+                                return retained.write(buffer, position, operationOptions);
+                            const stat = await current(operationOptions);
+                            let offset = position;
+                            if (offset === null) {
+                                if (admitted.append)
+                                    offset = stat.size;
+                                else {
+                                    if (forwarded.capabilities?.position !== true || !forwarded.getPosition) {
+                                        throw new FsError("ENOTSUP", { syscall: "getPosition", path });
+                                    }
+                                    offset = await retained.getPosition(operationOptions);
+                                    operationOptions.signal?.throwIfAborted();
+                                }
+                            }
+                            if (!Number.isSafeInteger(offset) || offset < 0)
+                                throw new FsError("EIO", { syscall: "getPosition", path });
+                            await admitSize(stat, Math.max(stat.size, offset + buffer.byteLength), operationOptions);
+                            const count = await retained.write(buffer, position, operationOptions);
+                            if (conditional) {
+                                const size = (await current(operationOptions)).size;
+                                if (admitted.synchronization !== undefined)
+                                    publishedSize = size;
+                                reserve(size);
+                            }
+                            return count;
+                        }),
+                        truncate: (retained, length, operationOptions) => mutate(async () => {
+                            operationOptions.signal?.throwIfAborted();
+                            await admitSize(await current(operationOptions), length, operationOptions);
+                            await retained.truncate(length, operationOptions);
+                            if (conditional) {
+                                if (admitted.synchronization !== undefined)
+                                    publishedSize = length;
+                                reserve(length);
+                            }
+                        }),
+                    };
+                }
+                catch (error) {
+                    await finishCleanup(() => descriptor.close(), true);
+                    admitted.signal?.throwIfAborted();
+                    throw error;
+                }
+            }));
+        },
+        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";
+                const current = append ? await existingBytes(fs, path, writeOptions) : 0;
+                await assertDelta(path, current + data.length, writeOptions);
+                await fs.writeFile(path, data, writeOptions);
+            });
+        },
+        appendFile(path, data, appendOptions) {
+            return mutate(async () => {
+                await assertDelta(path, await existingBytes(fs, path, appendOptions) + data.length, appendOptions);
+                await fs.appendFile(path, data, appendOptions);
+            });
+        },
+        rename(source, destination, renameOptions) {
+            return mutate(async () => {
+                if (renameOptions?.noReplace) {
+                    renameOptions.signal?.throwIfAborted();
+                    const capabilities = await fs.capabilitiesFor?.(destination, renameOptions) ?? fs.capabilities;
+                    renameOptions.signal?.throwIfAborted();
+                    if (capabilities.atomicRenameNoReplace !== true)
+                        throw new FsError("ENOTSUP", { syscall: "rename", path: source, dest: destination });
+                }
+                await fs.rename(source, destination, renameOptions);
+            });
+        },
+        copyFile(source, destination, copyOptions) {
+            return mutate(async () => {
+                await assertDelta(destination, (await fs.stat(source, copyOptions)).size, copyOptions);
+                await fs.copyFile(source, destination, copyOptions);
+            });
+        },
+        truncate(path, length = 0, truncateOptions) {
+            return mutate(async () => {
+                await assertDelta(path, length, truncateOptions);
+                await fs.truncate(path, length, truncateOptions);
+            });
+        },
+        link(source, destination, linkOptions) {
+            return mutate(async () => {
+                await assertDelta(destination, (await fs.lstat(source, linkOptions)).size, linkOptions);
+                await fs.link(source, destination, linkOptions);
+            });
+        },
+        symlink(target, path, linkOptions) {
+            return mutate(async () => {
+                await assertDelta(path, new TextEncoder().encode(target).length, linkOptions);
+                await fs.symlink(target, path, linkOptions);
+            });
+        },
+        writeStream(path, source, writeOptions) {
+            return mutate(async () => {
+                const append = writeOptions?.flag === "a" || writeOptions?.flag === "ax";
+                if (!append)
+                    await fs.writeFile(path, new Uint8Array(), writeOptions);
+                for await (const chunk of source) {
+                    await assertDelta(path, await existingBytes(fs, path, writeOptions) + chunk.length, writeOptions);
+                    await fs.appendFile(path, chunk, writeOptions);
+                }
+            });
+        },
+    };
+    // Backend descriptors may be frozen. An independent view lets us adapt
+    // capabilities and methods without violating invariants on own properties.
+    return new Proxy(Object.create(fs), {
+        get(_target, property) {
+            if (property === "publishStagedFileSet" || property === "prepareStagingResolution" || property === "prepareDirectoryAncestry" || property === "publishFileConditional" || property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
+                return undefined;
+            if (property === "capabilities")
+                return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs)), ...(typeof fs.open === "function" ? {} : { open: false }) });
+            if (property === "capabilitiesFor")
+                return async (path, fsOptions) => {
+                    const capabilities = await fs.capabilitiesFor?.(path, fsOptions) ?? fs.capabilities;
+                    return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs, capabilities)), ...(typeof fs.open === "function" ? {} : { open: false }) });
+                };
+            if (property === "openReadFile")
+                return (path, fsOptions = {}) => openRetainedReadFile(fs, path, fsOptions);
+            const replacement = Reflect.get(mutations, property);
+            if (typeof replacement === "function")
+                return replacement;
+            const original = Reflect.get(fs, property);
+            return typeof original === "function" ? original.bind(fs) : original;
+        },
+    });
+}

package/node_modules/@poe-code/safe-fs/dist/fs/readonly/index.d.ts

@@ -0,0 +1,37 @@
+import type { ByteSource } from "../../contracts/io.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";
+import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
+export declare class ReadOnlyFileSystem implements FileSystem {
+    #private;
+    readonly removeEntryConditional?: NonNullable<FileSystem["removeEntryConditional"]>;
+    constructor(filesystem: FileSystem);
+    get capabilities(): FileSystemCapabilities;
+    capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
+    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>;
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    writeFile(path: string, _data: Uint8Array, _options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, _data: Uint8Array, _options?: AppendFileOptions): Promise<void>;
+    writeStream(path: string, _source: ByteSource, _options?: WriteFileOptions): Promise<void>;
+    mkdir(path: string, _options?: MkdirOptions): Promise<void>;
+    rm(path: string, _options?: RemoveOptions): Promise<void>;
+    unlink(path: string, _options?: FsOptions): Promise<void>;
+    rmdir(path: string, _options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, _options?: RenameOptions): Promise<void>;
+    copyFile(source: string, destination: string, _options?: CopyFileOptions): Promise<void>;
+    symlink(target: string, path: string, _options?: FsOptions): Promise<void>;
+    link(existingPath: string, newPath: string, _options?: FsOptions): Promise<void>;
+    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;