toolcraft 0.0.749 → 0.0.751

package/node_modules/@poe-code/safe-fs/dist/fs/devices/path.d.ts

@@ -0,0 +1,7 @@
+import type { FileSystem, FsOptions } from "../../contracts/filesystem.js";
+export declare const nullPath = "/dev/null";
+export declare const deviceDirectory = "/dev";
+export declare function lexicalDevicePath(path: string): string;
+export declare function resolveDevicePath(filesystem: FileSystem, path: string, options: FsOptions, followFinal?: boolean, resizeCreate?: boolean, traversal?: {
+    virtual: boolean;
+}): Promise<string>;

package/node_modules/@poe-code/safe-fs/dist/fs/devices/path.js

@@ -0,0 +1,250 @@
+import { FsError, isFsError } from "../../contracts/errors.js";
+import { pathByteLength, validatePath } from "../../contracts/virtual-path.js";
+import { capturePathNamespace, pathNamespace } from "../path-namespace.js";
+import { isCleanAbsolutePath, tryResolveMemoryDevicePath } from "../../runtime-core.js";
+export const nullPath = "/dev/null";
+export const deviceDirectory = "/dev";
+function isNullParts(parts) {
+    return parts.length === 2 && parts[0] === "dev" && parts[1] === "null";
+}
+export function lexicalDevicePath(path) {
+    validatePath(path);
+    if (isCleanAbsolutePath(path) && !path.startsWith("/dev/null/"))
+        return path;
+    const parts = [];
+    for (const component of path.split("/")) {
+        if (isNullParts(parts))
+            throw new FsError("ENOTDIR", { path });
+        if (component === "..")
+            parts.pop();
+        else if (component && component !== ".")
+            parts.push(component);
+    }
+    return `/${parts.join("/")}`;
+}
+async function resolveResizeDevicePath(filesystem, path, options, create, namespace, traversal) {
+    validatePath(path, options.pathLimits);
+    const components = (value) => {
+        const result = value.split("/").filter(Boolean);
+        if (value.endsWith("/"))
+            result.push("");
+        return result;
+    };
+    let pending = components(path);
+    let remainingComponents = (options.pathLimits?.maxPathComponents ?? Infinity) - pending.length;
+    if (remainingComponents < 0)
+        throw new FsError("ENAMETOOLONG", { path });
+    const parts = [];
+    let links = 0;
+    let expanded = pathByteLength(path);
+    let boundary;
+    while (pending.length) {
+        options.signal?.throwIfAborted();
+        const component = pending.shift();
+        const current = `/${parts.join("/")}`;
+        if (current === nullPath)
+            throw new FsError("ENOTDIR", { path });
+        if (current !== deviceDirectory) {
+            const observe = filesystem.stat;
+            options.signal?.throwIfAborted();
+            const stat = await Reflect.apply(observe, filesystem, [current, options]);
+            options.signal?.throwIfAborted();
+            if (stat.type !== "directory")
+                throw new FsError("ENOTDIR", { path });
+            if (!(component === "" && pending.length === 0)) {
+                const access = filesystem.access;
+                options.signal?.throwIfAborted();
+                await Reflect.apply(access, filesystem, [current, 1, options]);
+                options.signal?.throwIfAborted();
+            }
+        }
+        if (component === "." || component === "")
+            continue;
+        if (component === "..") {
+            if (boundary !== undefined && current === boundary)
+                throw new FsError("EACCES", { path });
+            parts.pop();
+            continue;
+        }
+        if (exceedsComponentByteLimit(component))
+            throw new FsError("ENAMETOOLONG", { path });
+        const candidate = `/${[...parts, component].join("/")}`;
+        const selected = namespace === undefined ? undefined : candidate === deviceDirectory || candidate === nullPath ? "/" : namespace(candidate);
+        if (boundary !== undefined && selected !== boundary)
+            throw new FsError("EACCES", { path });
+        if (traversal && (candidate === deviceDirectory || candidate === nullPath))
+            traversal.virtual = true;
+        if (create && pending.length === 1 && pending[0] === "")
+            throw new FsError("EISDIR", { path });
+        if (candidate !== deviceDirectory && candidate !== nullPath) {
+            let stat;
+            const lstat = filesystem.lstat;
+            options.signal?.throwIfAborted();
+            try {
+                stat = await Reflect.apply(lstat, filesystem, [candidate, options]);
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                if (!(isFsError(error, "ENOENT") && create && pending.length === 0))
+                    throw error;
+            }
+            options.signal?.throwIfAborted();
+            if (stat?.type === "symlink") {
+                boundary ??= selected;
+                const readlink = filesystem.readlink;
+                options.signal?.throwIfAborted();
+                if (typeof readlink !== "function")
+                    throw new FsError("ENOTSUP", { path });
+                if (++links > 40)
+                    throw new FsError("ELOOP", { path });
+                const target = await Reflect.apply(readlink, filesystem, [candidate, options]);
+                options.signal?.throwIfAborted();
+                validatePath(target, options.pathLimits);
+                expanded += pathByteLength(target);
+                if (expanded > (options.pathLimits?.maxPathBytes ?? Infinity))
+                    throw new FsError("ENAMETOOLONG", { path });
+                if (target.startsWith("/"))
+                    parts.splice(0, parts.length, ...(boundary ?? "/").split("/").filter(Boolean));
+                const targetParts = components(target);
+                if (targetParts.at(-1) === "" && pending[0] === "")
+                    targetParts.pop();
+                if (targetParts.length > remainingComponents)
+                    throw new FsError("ENAMETOOLONG", { path });
+                remainingComponents -= targetParts.length;
+                pending = targetParts.concat(pending);
+                continue;
+            }
+        }
+        parts.push(component);
+    }
+    return `/${parts.join("/")}`;
+}
+function utf8ByteLength(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length && value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+function exceedsComponentByteLimit(value) {
+    return value.length > 85 && (value.length > 255 || utf8ByteLength(value) > 255);
+}
+export async function resolveDevicePath(filesystem, path, options, followFinal = true, resizeCreate, traversal) {
+    options.signal?.throwIfAborted();
+    validatePath(path, options.pathLimits);
+    if (options.pathLimits === undefined && Reflect.get(filesystem, pathNamespace) === undefined) {
+        const fast = tryResolveMemoryDevicePath(filesystem, path, resizeCreate);
+        if (fast !== undefined)
+            return fast;
+    }
+    const namespace = capturePathNamespace(filesystem, options);
+    if (resizeCreate !== undefined)
+        return resolveResizeDevicePath(filesystem, path, options, resizeCreate, namespace, traversal);
+    const lexical = lexicalDevicePath(path);
+    const lstat = filesystem.lstat;
+    options.signal?.throwIfAborted();
+    const aliases = typeof lstat === "function";
+    if (!aliases && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/")
+        return lexical;
+    let pending = path.split("/");
+    let remainingComponents = (options.pathLimits?.maxPathComponents ?? Infinity) - pending.filter(Boolean).length;
+    if (remainingComponents < 0)
+        throw new FsError("ENAMETOOLONG", { path });
+    const parts = [];
+    let links = 0;
+    let expanded = pathByteLength(path);
+    let absolute = path.startsWith("/");
+    let traversalFailure;
+    let failedDepth = Infinity;
+    let boundary;
+    while (pending.length) {
+        options.signal?.throwIfAborted();
+        if (isNullParts(parts))
+            throw new FsError("ENOTDIR", { path });
+        const component = pending.shift();
+        if (!component || component === ".")
+            continue;
+        if (component === "..") {
+            if (boundary !== undefined && `/${parts.join("/")}` === boundary)
+                throw new FsError("EACCES", { path });
+            parts.pop();
+            if (parts.length < failedDepth) {
+                failedDepth = Infinity;
+            }
+            continue;
+        }
+        const candidate = `/${[...parts, component].join("/")}`;
+        const selected = namespace === undefined ? undefined : candidate === deviceDirectory || candidate === nullPath ? "/" : namespace(candidate);
+        if (boundary !== undefined && selected !== boundary)
+            throw new FsError("EACCES", { path });
+        if (traversal && (candidate === deviceDirectory || candidate === nullPath))
+            traversal.virtual = true;
+        if (parts.length < failedDepth && candidate !== deviceDirectory && candidate !== nullPath && ((followFinal && aliases) || pending.length)) {
+            const lookup = absolute ? candidate : candidate.slice(1);
+            let stat;
+            try {
+                if (typeof lstat !== "function")
+                    throw new FsError("ENOTSUP", { path });
+                stat = await Reflect.apply(lstat, filesystem, [lookup, options]);
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                if (isFsError(error, "ENOTSUP") && links === 0 && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/")
+                    return lexical;
+                if (!isFsError(error, "ENOENT"))
+                    throw error;
+                if (pending.length) {
+                    traversalFailure ??= error;
+                    failedDepth = Math.min(failedDepth, parts.length + 1);
+                }
+            }
+            options.signal?.throwIfAborted();
+            if (stat?.type === "symlink") {
+                boundary ??= selected;
+                const readlink = filesystem.readlink;
+                options.signal?.throwIfAborted();
+                if (typeof readlink !== "function")
+                    throw new FsError("ENOTSUP", { path });
+                if (++links > 40)
+                    throw new FsError("ELOOP", { path });
+                const target = await Reflect.apply(readlink, filesystem, [lookup, options]);
+                options.signal?.throwIfAborted();
+                validatePath(target, options.pathLimits);
+                expanded += pathByteLength(target);
+                if (expanded > (options.pathLimits?.maxPathBytes ?? Infinity))
+                    throw new FsError("ENAMETOOLONG", { path });
+                const targetSplit = target.split("/");
+                const nonEmptyCount = targetSplit.filter(Boolean).length;
+                if (nonEmptyCount > remainingComponents)
+                    throw new FsError("ENAMETOOLONG", { path });
+                remainingComponents -= nonEmptyCount;
+                if (target.startsWith("/")) {
+                    parts.splice(0, parts.length, ...(boundary ?? "/").split("/").filter(Boolean));
+                    absolute = true;
+                    failedDepth = Infinity;
+                }
+                pending = targetSplit.concat(pending);
+                continue;
+            }
+            if (stat && pending.length && stat.type !== "directory") {
+                traversalFailure ??= new FsError("ENOTDIR", { path });
+                failedDepth = Math.min(failedDepth, parts.length + 1);
+            }
+        }
+        parts.push(component);
+    }
+    const resolved = `/${parts.join("/")}`;
+    if (traversalFailure && (resolved === nullPath || resolved === deviceDirectory || resolved === "/"))
+        throw traversalFailure;
+    return resolved;
+}

package/node_modules/@poe-code/safe-fs/dist/fs/devices/stream.d.ts

@@ -0,0 +1,6 @@
+import type { ByteSource } from "../../contracts/io.js";
+import type { FileReadHandle } from "../../contracts/filesystem.js";
+export declare function deviceReadStream(open: () => Promise<ByteSource>, signal?: AbortSignal): ByteSource;
+export declare function drainDeviceFile(handle: FileReadHandle, signal?: AbortSignal): Promise<void>;
+export declare function createDeviceYield(): (length: number, signal?: AbortSignal) => Promise<void>;
+export declare function drainDeviceInput(source: ByteSource, signal?: AbortSignal): Promise<void>;

package/node_modules/@poe-code/safe-fs/dist/fs/devices/stream.js

@@ -0,0 +1,136 @@
+import { finishCleanup } from "../../contracts/cleanup.js";
+export function deviceReadStream(open, signal) {
+    return { [Symbol.asyncIterator]() {
+            let opened;
+            let closing;
+            const iterator = () => opened ??= Promise.resolve().then(open).then(source => source[Symbol.asyncIterator]());
+            const close = () => closing ??= !opened && signal?.aborted
+                ? Promise.resolve({ done: true, value: undefined })
+                : iterator().then(async (source) => source.return ? source.return() : { done: true, value: undefined });
+            return {
+                async next() {
+                    if (closing) {
+                        await closing;
+                        return { done: true, value: undefined };
+                    }
+                    try {
+                        const source = await iterator();
+                        signal?.throwIfAborted();
+                        if (closing) {
+                            await closing;
+                            return { done: true, value: undefined };
+                        }
+                        const next = source.next;
+                        signal?.throwIfAborted();
+                        if (closing) {
+                            await closing;
+                            return { done: true, value: undefined };
+                        }
+                        return await Reflect.apply(next, source, []);
+                    }
+                    catch (error) {
+                        await finishCleanup(close, true);
+                        throw error;
+                    }
+                },
+                return: close,
+            };
+        } };
+}
+export async function drainDeviceFile(handle, signal) {
+    let failed = false;
+    let position = 0;
+    try {
+        await drainDeviceInput({ [Symbol.asyncIterator]: () => ({ async next() {
+                    const value = await handle.read(position, 65536, signal ? { signal } : {});
+                    if (!(value instanceof Uint8Array) || value.byteLength > 65536)
+                        throw new TypeError("Retained reads must return bounded Uint8Array chunks");
+                    position += value.byteLength;
+                    if (!Number.isSafeInteger(position))
+                        throw new RangeError("Retained read position exceeds safe integer range");
+                    return { done: value.byteLength === 0, value };
+                } }) }, signal);
+    }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
+    finally {
+        await finishCleanup(async () => {
+            try {
+                await handle.close();
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                throw error;
+            }
+        }, failed);
+    }
+    signal?.throwIfAborted();
+}
+function nextChunk(iterator, signal) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const aborted = () => { signal?.removeEventListener("abort", aborted); reject(signal?.reason); };
+        signal?.addEventListener("abort", aborted, { once: true });
+        try {
+            Promise.resolve(iterator.next()).then(result => {
+                signal?.removeEventListener("abort", aborted);
+                if (signal?.aborted)
+                    reject(signal.reason);
+                else
+                    resolve(result);
+            }, error => { signal?.removeEventListener("abort", aborted); reject(signal?.aborted ? signal.reason : error); });
+        }
+        catch (error) {
+            signal?.removeEventListener("abort", aborted);
+            reject(signal?.aborted ? signal.reason : error);
+        }
+    });
+}
+export function createDeviceYield() {
+    let bytes = 0;
+    let pulls = 0;
+    return async (length, signal) => {
+        bytes += length;
+        if (++pulls >= 64 || bytes >= 65536) {
+            await new Promise(resolve => setTimeout(resolve, 0));
+            signal?.throwIfAborted();
+            bytes = 0;
+            pulls = 0;
+        }
+    };
+}
+export async function drainDeviceInput(source, signal) {
+    signal?.throwIfAborted();
+    const iterator = source[Symbol.asyncIterator]();
+    let failed = false;
+    const yieldAfterWrite = createDeviceYield();
+    try {
+        for (;;) {
+            const result = await nextChunk(iterator, signal);
+            signal?.throwIfAborted();
+            if (result.done)
+                break;
+            if (!(result.value instanceof Uint8Array))
+                throw new TypeError("Byte sources must yield Uint8Array chunks");
+            await yieldAfterWrite(result.value.byteLength, signal);
+        }
+    }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
+    finally {
+        await finishCleanup(async () => {
+            try {
+                await iterator.return?.();
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                throw error;
+            }
+        }, failed);
+    }
+    signal?.throwIfAborted();
+}

package/node_modules/@poe-code/safe-fs/dist/fs/directory-admission.d.ts

@@ -0,0 +1,3 @@
+import type { ReadDirectoryOptions } from "../contracts/filesystem.js";
+export declare function directoryEntryLimit(options: ReadDirectoryOptions, path: string): number | undefined;
+export declare function admitDirectoryEntries(count: number, limit: number | undefined, path: string): void;

package/node_modules/@poe-code/safe-fs/dist/fs/directory-admission.js

@@ -0,0 +1,14 @@
+import { FsError } from "../contracts/errors.js";
+export function directoryEntryLimit(options, path) {
+    options.signal?.throwIfAborted();
+    const limit = options.maxEntries === Infinity ? undefined : options.maxEntries;
+    if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
+        throw new FsError("EINVAL", { syscall: "readdir", path, message: "directory entry limit must be a nonnegative safe integer or Infinity" });
+    }
+    return limit;
+}
+export function admitDirectoryEntries(count, limit, path) {
+    if (limit !== undefined && count > limit) {
+        throw new FsError("EFBIG", { syscall: "readdir", path, message: "directory entry limit exceeded" });
+    }
+}

package/node_modules/@poe-code/safe-fs/dist/fs/memory/atomic-view.d.ts

@@ -0,0 +1,11 @@
+import type { FileStat, FileSystem } from "../../contracts/filesystem.js";
+/** Internal authority: inspections and stock mutations share one JavaScript turn. */
+export interface MemoryAtomicView {
+    stat(path: string): FileStat | undefined;
+    names(path: string): readonly string[];
+}
+type LazyMemoryAtomicView = (this: FileSystem) => MemoryAtomicView | undefined;
+export declare function registerMemoryAtomicView(fs: FileSystem, view: MemoryAtomicView, intact: () => boolean): void;
+export declare function registerLazyMemoryAtomicView(fs: FileSystem, create: LazyMemoryAtomicView): void;
+export declare function memoryAtomicView(fs: FileSystem): MemoryAtomicView | undefined;
+export {};

package/node_modules/@poe-code/safe-fs/dist/fs/memory/atomic-view.js

@@ -0,0 +1,13 @@
+const views = new WeakMap();
+export function registerMemoryAtomicView(fs, view, intact) {
+    views.set(fs, { view, intact });
+}
+export function registerLazyMemoryAtomicView(fs, create) {
+    views.set(fs, create);
+}
+export function memoryAtomicView(fs) {
+    const registered = views.get(fs);
+    if (typeof registered === "function")
+        return registered.call(fs);
+    return registered?.intact() ? registered.view : undefined;
+}

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

@@ -0,0 +1,186 @@
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, FileDescriptor, OpenFileOptions, OpenReadFileOptions, OpenResizeFileOptions, WriteFileOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PublishStagedFileSetOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
+import type { ByteSource } from "../../contracts/io.js";
+import { type MemoryAtomicView } from "./atomic-view.js";
+import { MemoryAllocation, MemoryLedger } from "./ledger.js";
+import { type MemoryFileSystemOptions } from "./limits.js";
+export { defaultMemoryFileSystemLimits, type MemoryFileSystemLimits, type MemoryFileSystemOptions } from "./limits.js";
+interface Metadata {
+    revision: number;
+    mode: number;
+    ino: number;
+    nlink: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    references: number;
+}
+interface FileNode extends Metadata {
+    type: "file";
+    sourceRef?: Uint8Array | undefined;
+    byteLength: number;
+    view: Uint8Array | undefined;
+    data: Uint8Array;
+    allocation: MemoryAllocation;
+}
+interface DirectoryNode extends Metadata {
+    type: "directory";
+    entries: Map<string, MemoryNode>;
+    cachedNlink?: number;
+    cachedNlinkRev?: number;
+}
+interface SymlinkNode extends Metadata {
+    type: "symlink";
+    target: string;
+}
+type MemoryNode = FileNode | DirectoryNode | SymlinkNode;
+declare class MemoryCache {
+    readonly files: FileNode[];
+    readonly directories: DirectoryNode[];
+    readonly removedScratch: MemoryNode[];
+    lastFastDirPrefix: string;
+    lastFastDirNode: DirectoryNode | undefined;
+    lastFastFilePath: string;
+    lastFastFileName: string;
+    lastFastFileNode: FileNode | undefined;
+    clearWrites(): void;
+}
+type OwnedStore = {
+    root: DirectoryNode;
+    ledger: MemoryLedger;
+    capabilities: FileSystem["capabilities"];
+    intact: () => boolean;
+};
+export interface ConditionalMutationBinding {
+    readonly path: string;
+    readonly parent: FileStat;
+    readonly expected: FileStat;
+    readonly ancestors: readonly FileStagingEntry[];
+}
+export declare function bindConditionalMutation<Result>(identityScope: object | symbol | undefined, binding: ConditionalMutationBinding, action: () => Promise<Result>): Promise<Result>;
+export declare class MemoryFileSystem implements FileSystem {
+    #private;
+    capabilitiesFor?: NonNullable<FileSystem["capabilitiesFor"]>;
+    private get identityScope();
+    get capabilities(): FileSystemCapabilities;
+    private nextInode;
+    private readonly ledger;
+    readonly _cache: MemoryCache;
+    mutationTick: number;
+    readonly _owner: OwnedStore;
+    private readonly root;
+    private totalBytes;
+    symlinkCount: number;
+    _getAtomicView(): MemoryAtomicView | undefined;
+    constructor(options?: MemoryFileSystemOptions);
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    canonicalizeMissingTarget(path: string, options?: FsOptions): string | undefined;
+    confineExtraction(roots: readonly string[], options?: FsOptions): Promise<FileSystem>;
+    private metadata;
+    private directory;
+    private addDirectoryNode;
+    private addNode;
+    private releaseNode;
+    private releaseReference;
+    private replaceData;
+    private admitSize;
+    private fail;
+    private validatePath;
+    private permission;
+    private mode;
+    private integer;
+    private changed;
+    private resolveNode;
+    private resolve;
+    private file;
+    private entry;
+    private terminalDot;
+    private directoryNlink;
+    private snapshot;
+    private bytes;
+    private allocate;
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
+    private prepareWrite;
+    private openWrite;
+    private writeData;
+    private writeAt;
+    private writeAtRange;
+    writeMemoryFileFast(path: string, data: Uint8Array, append: boolean, mode: number): void;
+    writeMemoryFilesInDirBatchFast(firstFileName: string, dirPrefix: string, fileNames: readonly string[], nameHashes: Int32Array, payloads: readonly Uint8Array[], totalNameBytes: number, payloadBytesSum: number, mode: number): void;
+    writeMemoryFileInDirFast(dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number, nameHash?: number): void;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    private expectEntry;
+    private stagingLocations;
+    createStagedFile(directoryPath: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
+    private retainStagingCleanup;
+    prepareDirectoryAncestry(ancestors: readonly FileStagingEntry[], options?: FsOptions): Promise<() => true>;
+    prepareStagingResolution(path: string, options?: FsOptions): Promise<FileStagingResolution>;
+    private verifyDirectoryAncestry;
+    publishStagedFile(receipt: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
+    publishStagedFileSet(receipt: FileStaging, destination: string, options: PublishStagedFileSetOptions): Promise<FileStat>;
+    removeStagedFile(staging: FileStaging, options?: FsOptions): Promise<void>;
+    private removeStagingLocations;
+    prepareDirectory(path: string, options: PrepareDirectoryOptions): Promise<FileStat>;
+    writeFileConditional(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
+    removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions & {
+        readonly returnRemainingStat?: false | undefined;
+    }): Promise<void>;
+    removeEntryConditional(path: string, options: ConditionalRemoveEntryReceiptOptions): Promise<void | FileStat>;
+    removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
+    removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    tryMkdirFastSync(path: string, recursive: boolean, mode: number | undefined): boolean;
+    tryRmFastSync(path: string, recursive: boolean, force: boolean): boolean;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions & Partial<ConditionalMutationBinding>): Promise<void>;
+    private removeLocation;
+    unlink(path: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    symlink(target: string, path: string, options?: FsOptions): Promise<void>;
+    link(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: ChmodOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
+    private resizeNode;
+    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>;
+}
+export declare function createMemoryFileSystem(options?: MemoryFileSystemOptions | Readonly<Record<string, unknown>>): MemoryFileSystem;
+export declare class MemoryRedirectHandle {
+    fs: MemoryFileSystem;
+    path: string;
+    node: FileNode;
+    append: boolean;
+    position: number;
+    closed: boolean;
+    constructor(fs: MemoryFileSystem, path: string, node: FileNode, append: boolean);
+    reset(fs: MemoryFileSystem, path: string, node: FileNode, append: boolean): void;
+    writeRangeSync(src: Uint8Array, len: number, signal?: AbortSignal): void;
+    writeImmutableSync(immutableData: Uint8Array, signal?: AbortSignal): void;
+    writeSync(chunk: Uint8Array, signal?: AbortSignal): void;
+    close(): void;
+}
+export declare function tryOpenMemoryRedirectHandleSync(filesystem: FileSystem, path: string, append: boolean, mode: number, signal?: AbortSignal): MemoryRedirectHandle | undefined;
+export declare function utf8ByteLength(value: string): number;
+export declare function isCleanAbsolutePath(path: string): boolean;
+export declare function tryResolveMemoryDevicePath(filesystem: FileSystem, path: string, resizeCreate?: boolean): string | undefined;
+export declare function getLastReadMemoryFileSourceRef(view: Uint8Array): Uint8Array | undefined;
+export declare function tryReadMemoryFileViewSync(filesystem: FileSystem, path: string, maxBytes?: number, signal?: AbortSignal, captureSourceRef?: boolean, beforeRead?: () => void): Uint8Array | undefined;
+export declare function tryGetMemoryDirectoryEntryNamesSync(filesystem: FileSystem, path: string): ReadonlyMap<string, {
+    readonly type: "file" | "directory" | "symlink";
+}> | undefined;
+export declare function tryWriteMemoryFileSync(filesystem: FileSystem, path: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;
+export declare function tryMkdirMemorySync(filesystem: FileSystem, path: string, recursive: boolean, mode: number, signal?: AbortSignal, dirPrefixHint?: string): boolean;
+export declare function tryRmRfMemorySync(filesystem: FileSystem, path: string, signal?: AbortSignal): boolean;
+export declare function tryWriteMemoryFileInDirSync(filesystem: FileSystem, dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;