@kamilio/wire 0.1.8 → 0.1.10

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

@@ -0,0 +1,27 @@
+import type { MemoryFileSystemLimits } from "./limits.js";
+export declare class MemoryLedger {
+    readonly limits: Readonly<MemoryFileSystemLimits>;
+    private retainedBytes;
+    private metadataUnits;
+    readonly maxFileBytesSmi: number;
+    readonly maxRetainedBytesSmi: number;
+    readonly maxMetadataUnitsSmi: number;
+    readonly hasInfiniteRetained: boolean;
+    readonly hasInfiniteFileBytes: boolean;
+    constructor(limits: Readonly<MemoryFileSystemLimits>);
+    get availableBytes(): number;
+    canPreallocate64(nameBytes: number): boolean;
+    fileSize(length: number, syscall: string, path: string): void;
+    private canReserve;
+    check(bytes: number, units: number, syscall: string, path: string): void;
+    reserve(bytes: number, units: number, syscall: string, path: string): void;
+    release(bytes: number, units: number): void;
+}
+export declare class MemoryAllocation {
+    private references;
+    readonly data: Uint8Array;
+    private ledger;
+    constructor(data: Uint8Array, ledger: MemoryLedger);
+    retain(): void;
+    release(): void;
+}

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/memory/ledger.js

@@ -0,0 +1,90 @@
+import { FsError } from "../../contracts/errors.js";
+const MAX_SMI = 1073741823;
+export class MemoryLedger {
+    limits;
+    retainedBytes = 0;
+    metadataUnits = 0;
+    maxFileBytesSmi;
+    maxRetainedBytesSmi;
+    maxMetadataUnitsSmi;
+    hasInfiniteRetained;
+    constructor(limits) {
+        this.limits = limits;
+        this.maxFileBytesSmi = Math.min(limits.maxFileBytes, MAX_SMI) | 0;
+        this.maxRetainedBytesSmi = Math.min(limits.maxRetainedBytes, MAX_SMI) | 0;
+        this.maxMetadataUnitsSmi = Math.min(limits.maxMetadataUnits, MAX_SMI) | 0;
+        this.hasInfiniteRetained = limits.maxRetainedBytes === Infinity;
+        if (limits.maxFileBytes !== Infinity)
+            this.hasInfiniteFileBytes = false;
+    }
+    get availableBytes() {
+        const max = this.limits.maxRetainedBytes;
+        return max === Infinity ? Infinity : max - this.retainedBytes;
+    }
+    canPreallocate64(nameBytes) {
+        return this.maxFileBytesSmi >= 64 && (this.hasInfiniteRetained || this.maxRetainedBytesSmi - this.retainedBytes > 65536 + nameBytes);
+    }
+    fileSize(length, syscall, path) {
+        if ((length | 0) === length && length >= 0 && length <= this.maxFileBytesSmi)
+            return;
+        if (!Number.isSafeInteger(length) || length < 0 || length > this.limits.maxFileBytes) {
+            throw new FsError("EFBIG", { syscall, path });
+        }
+    }
+    canReserve(bytes, units) {
+        return ((bytes | 0) === bytes && bytes >= 0 &&
+            (units | 0) === units && units >= 0 &&
+            this.retainedBytes <= this.maxRetainedBytesSmi - bytes &&
+            this.metadataUnits <= this.maxMetadataUnitsSmi - units);
+    }
+    check(bytes, units, syscall, path) {
+        if (this.canReserve(bytes, units))
+            return;
+        if (!Number.isSafeInteger(bytes) || bytes < 0 ||
+            bytes > this.limits.maxRetainedBytes - this.retainedBytes ||
+            !Number.isSafeInteger(units) || units < 0 ||
+            units > this.limits.maxMetadataUnits - this.metadataUnits) {
+            throw new FsError("ENOSPC", { syscall, path });
+        }
+    }
+    reserve(bytes, units, syscall, path) {
+        if (this.canReserve(bytes, units)) {
+            this.retainedBytes = (this.retainedBytes + bytes) | 0;
+            this.metadataUnits = (this.metadataUnits + units) | 0;
+            return;
+        }
+        this.check(bytes, units, syscall, path);
+        this.retainedBytes += bytes;
+        this.metadataUnits += units;
+    }
+    release(bytes, units) {
+        if (bytes < 0 || units < 0 || bytes > this.retainedBytes || units > this.metadataUnits) {
+            throw new Error("Invalid Memory filesystem reservation release");
+        }
+        this.retainedBytes -= bytes;
+        this.metadataUnits -= units;
+    }
+}
+export class MemoryAllocation {
+    constructor(data, ledger) {
+        this.references = 1;
+        this.data = data;
+        this.ledger = ledger;
+    }
+    retain() {
+        if (this.data.byteLength === 0)
+            return;
+        this.references++;
+    }
+    release() {
+        if (this.data.byteLength === 0)
+            return;
+        if (this.references <= 0)
+            throw new Error("Memory allocation already released");
+        if (--this.references === 0) {
+            this.data.fill(0);
+            this.ledger.release(this.data.byteLength, 0);
+        }
+    }
+}
+Object.assign(MemoryLedger.prototype, { hasInfiniteFileBytes: true });

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

@@ -0,0 +1,13 @@
+export interface MemoryFileSystemLimits {
+    readonly maxBytes?: number;
+    readonly maxPathBytes: number;
+    readonly maxPathComponents: number;
+    readonly maxFileBytes: number;
+    readonly maxRetainedBytes: number;
+    readonly maxMetadataUnits: number;
+}
+export type MemoryFileSystemOptions = {
+    readonly [Key in keyof MemoryFileSystemLimits]?: MemoryFileSystemLimits[Key] | undefined;
+};
+export declare const defaultMemoryFileSystemLimits: Readonly<MemoryFileSystemLimits>;
+export declare function normalizeMemoryFileSystemLimits(options: unknown): Readonly<MemoryFileSystemLimits>;

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/memory/limits.js

@@ -0,0 +1,26 @@
+import { readConfigRecord } from "../../config.js";
+export const defaultMemoryFileSystemLimits = Object.freeze({
+    maxPathBytes: Infinity,
+    maxPathComponents: Infinity,
+    maxFileBytes: Infinity,
+    maxRetainedBytes: Infinity,
+    maxMetadataUnits: Infinity,
+});
+export function normalizeMemoryFileSystemLimits(options) {
+    if (options === undefined || (typeof options === "object" && options !== null && Object.getPrototypeOf(options) === Object.prototype && Reflect.ownKeys(options).length === 0)) {
+        return defaultMemoryFileSystemLimits;
+    }
+    const keys = ["maxPathBytes", "maxPathComponents", "maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
+    const record = readConfigRecord(options, "memory option", [...keys, "maxBytes"]);
+    const limits = { ...defaultMemoryFileSystemLimits };
+    for (const key of [...keys, "maxBytes"]) {
+        const value = record[key];
+        if (value === undefined || value === Infinity)
+            continue;
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key === "maxMetadataUnits" ? 1 : 0)) {
+            throw new RangeError(`${key} must be a ${key === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer or Infinity`);
+        }
+        limits[key] = value;
+    }
+    return Object.freeze(limits);
+}

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/memory/missing-target.d.ts

@@ -0,0 +1,15 @@
+import { type PathLimits } from "../../contracts/virtual-path.js";
+type Node = {
+    type: "file";
+    mode: number;
+} | {
+    type: "symlink";
+    mode: number;
+    target: string;
+} | {
+    type: "directory";
+    mode: number;
+    entries: ReadonlyMap<string, Node>;
+};
+export declare function resolveMissingTarget(root: Node, path: string, signal?: AbortSignal, limits?: PathLimits): string;
+export {};

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/memory/missing-target.js

@@ -0,0 +1,144 @@
+import { pathByteLength, validatePath } from "../../contracts/virtual-path.js";
+import { FsError } from "../../contracts/errors.js";
+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);
+}
+function components(path, signal) {
+    const result = [];
+    let start = 0;
+    for (let offset = 0; offset <= path.length; offset++) {
+        signal?.throwIfAborted();
+        if (offset !== path.length && path.charCodeAt(offset) !== 47)
+            continue;
+        if (offset > start)
+            result.push({ name: path.slice(start, offset), start });
+        start = offset + 1;
+    }
+    return result;
+}
+export function resolveMissingTarget(root, path, signal, limits = {}) {
+    validatePath(path, limits);
+    const fail = (code, failedPath = path) => {
+        throw new FsError(code, { syscall: "realpath", path: failedPath });
+    };
+    const origin = components(path, signal);
+    let remainingBytes = (limits.maxPathBytes ?? Infinity) - pathByteLength(path);
+    let remainingComponents = (limits.maxPathComponents ?? Infinity) - origin.length;
+    const initial = { node: root, name: "" };
+    let position = initial;
+    let links = 0;
+    let missing = origin.length;
+    let missingLink = false;
+    for (let index = 0; index <= origin.length; index++) {
+        const token = origin[index];
+        if (!token && path.length > 0 && !path.endsWith("/"))
+            break;
+        const before = position;
+        const frames = [{ names: [token ?? { name: ".", start: path.length }], next: 0 }];
+        let first = true;
+        let originLink = false;
+        let found = true;
+        while (frames.length > 0) {
+            signal?.throwIfAborted();
+            const frame = frames.at(-1);
+            if (!frame)
+                break;
+            const component = frame.names[frame.next++];
+            if (!component) {
+                frames.pop();
+                continue;
+            }
+            const current = position.node;
+            if (current.type !== "directory")
+                return fail("ENOTDIR");
+            if (((current.mode >> 6) & 1) !== 1)
+                return fail("EACCES");
+            const name = component.name;
+            if (name === ".") {
+                first = false;
+                continue;
+            }
+            if (name === "..") {
+                position = position.parent ?? initial;
+                first = false;
+                continue;
+            }
+            if (exceedsComponentByteLimit(name))
+                return fail("ENAMETOOLONG");
+            const node = current.entries.get(name);
+            if (!node) {
+                found = false;
+                break;
+            }
+            if (first)
+                originLink = node.type === "symlink";
+            first = false;
+            if (node.type === "symlink") {
+                if (++links > 40)
+                    return fail("ELOOP");
+                validatePath(node.target, { maxPathBytes: remainingBytes, maxPathComponents: remainingComponents });
+                const names = components(node.target, signal);
+                remainingBytes -= pathByteLength(node.target);
+                remainingComponents -= names.length;
+                if (node.target.endsWith("/"))
+                    names.push({ name: ".", start: node.target.length });
+                if (node.target.startsWith("/"))
+                    position = initial;
+                frames.push({ names, next: 0 });
+            }
+            else
+                position = { node, name, parent: position };
+        }
+        if (!found) {
+            position = before;
+            missing = index;
+            missingLink = originLink;
+            break;
+        }
+    }
+    if (missingLink) {
+        let end = path.length;
+        for (let count = origin.length; count > missing; count--) {
+            signal?.throwIfAborted();
+            if (count === missing + 1 && path[end - 1] !== "/")
+                return fail("ENOENT", path.slice(0, end));
+            const last = origin[count - 1];
+            if (!last)
+                break;
+            const boundary = last.start - 1;
+            end = boundary <= 0 ? 1 : boundary === 1 && path.startsWith("/") ? 2 : boundary;
+        }
+    }
+    const names = [];
+    for (let current = position; current?.parent; current = current.parent) {
+        signal?.throwIfAborted();
+        names.push(current.name);
+    }
+    names.reverse();
+    for (let index = missing; index < origin.length; index++) {
+        signal?.throwIfAborted();
+        const name = origin[index]?.name;
+        if (name === "..")
+            names.pop();
+        else if (name && name !== ".")
+            names.push(name);
+    }
+    return `/${names.join("/")}`;
+}

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/mount/comparison.d.ts

@@ -0,0 +1,19 @@
+import type { EntryComparison, FileStat, FileSystem, FsOptions } from "../../contracts/filesystem.js";
+export interface EntryLocation {
+    readonly filesystem: FileSystem;
+    readonly path: string;
+    readonly readOnly?: boolean;
+    readonly stat?: FileStat;
+}
+export interface EntryView extends EntryLocation {
+    readonly stat: FileStat;
+    readonly readOnly: boolean;
+}
+export type EntryViewResolver = (path: string, options: FsOptions) => Promise<EntryLocation>;
+export type EntryAuthority = (own: EntryView, peer: EntryView, options: FsOptions) => Promise<EntryComparison>;
+export declare function assertCallbackAuthorityAllowed(): void;
+export declare function registerEntryView(filesystem: FileSystem, resolver: EntryViewResolver): void;
+export declare function registerEntryAuthority(filesystem: FileSystem, authority: EntryAuthority): void;
+export declare function resolveEntryView(filesystem: FileSystem, path: string, options?: FsOptions): Promise<EntryView>;
+export declare function compareResolvedEntries(own: EntryView, peer: EntryView, options?: FsOptions): Promise<EntryComparison>;
+export declare function compareEntries(filesystem: FileSystem, path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/mount/comparison.js

@@ -0,0 +1,118 @@
+import { comparisonContext, platform } from "#safe-fs-platform";
+import { FsError } from "../../contracts/errors.js";
+import { compareIdentity } from "./identity.js";
+const resolvers = new WeakMap();
+const authorities = new WeakMap();
+export function assertCallbackAuthorityAllowed() {
+    if (!platform.callbackAuthorities)
+        throw new FsError("ENOTSUP", { message: "custom comparison authorities require Node context" });
+}
+export function registerEntryView(filesystem, resolver) {
+    if (resolvers.has(filesystem))
+        throw new TypeError("entry view already registered");
+    resolvers.set(filesystem, resolver);
+}
+export function registerEntryAuthority(filesystem, authority) {
+    if (authorities.has(filesystem))
+        throw new TypeError("entry authority already registered");
+    authorities.set(filesystem, authority);
+}
+export async function resolveEntryView(filesystem, path, options = {}) {
+    let location = { filesystem, path };
+    let readOnly = false;
+    const visited = new Set();
+    for (;;) {
+        options.signal?.throwIfAborted();
+        if (visited.has(location.filesystem))
+            throw new FsError("EIO", { path, message: "cyclic entry view" });
+        visited.add(location.filesystem);
+        readOnly ||= location.readOnly === true || location.filesystem.capabilities.readOnly === true;
+        if (location.stat)
+            return { filesystem: location.filesystem, path: location.path, stat: location.stat, readOnly };
+        const resolve = resolvers.get(location.filesystem) ?? location.filesystem._resolveEntryView;
+        if (!resolve) {
+            let stat;
+            let followedPath;
+            try {
+                followedPath = await location.filesystem.realpath(location.path, options);
+                options.signal?.throwIfAborted();
+                stat = await location.filesystem.lstat(followedPath, options);
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                throw error;
+            }
+            options.signal?.throwIfAborted();
+            if (stat.type === "symlink")
+                throw new FsError("EIO", { path, message: "followed entry changed during observation" });
+            return { filesystem: location.filesystem, path: followedPath, stat, readOnly };
+        }
+        let next;
+        try {
+            next = await resolve.call(location.filesystem, location.path, options);
+        }
+        catch (error) {
+            options.signal?.throwIfAborted();
+            throw error;
+        }
+        options.signal?.throwIfAborted();
+        if (next.filesystem === location.filesystem && next.stat) {
+            return { filesystem: next.filesystem, path: next.path, stat: next.stat, readOnly: readOnly || next.readOnly === true };
+        }
+        location = next;
+    }
+}
+export async function compareResolvedEntries(own, peer, options = {}) {
+    options.signal?.throwIfAborted();
+    if (comparisonContext.active(options))
+        return "unknown";
+    const identity = compareIdentity(own.stat, peer.stat);
+    if (identity !== "unknown")
+        return identity;
+    return comparisonContext.run(options, async (options) => {
+        const queried = new Set();
+        let result = "unknown";
+        for (const [left, right] of [[own, peer], [peer, own]]) {
+            options.signal?.throwIfAborted();
+            const authority = authorities.get(left.filesystem) ?? left.filesystem._entryAuthority;
+            const key = authority ?? left.filesystem;
+            if (queried.has(key))
+                continue;
+            queried.add(key);
+            let answer;
+            try {
+                if (authority)
+                    answer = await authority(left, right, options);
+                else if (left.filesystem.compareEntry) {
+                    assertCallbackAuthorityAllowed();
+                    answer = await left.filesystem.compareEntry(left.path, right.filesystem, right.path, options);
+                }
+                else
+                    continue;
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                throw error;
+            }
+            options.signal?.throwIfAborted();
+            if (answer !== "same" && answer !== "distinct" && answer !== "unknown") {
+                throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid entry comparison answer" });
+            }
+            if (answer === "unknown")
+                continue;
+            if (result !== "unknown" && result !== answer) {
+                throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting entry comparison answers" });
+            }
+            result = answer;
+        }
+        return result;
+    });
+}
+export async function compareEntries(filesystem, path, peer, peerPath, options = {}) {
+    options.signal?.throwIfAborted();
+    if (comparisonContext.active(options))
+        return "unknown";
+    const own = await resolveEntryView(filesystem, path, options);
+    const other = await resolveEntryView(peer, peerPath, options);
+    return compareResolvedEntries(own, other, options);
+}

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/mount/identity.d.ts

@@ -0,0 +1,6 @@
+import type { FileStat } from "../../contracts/filesystem.js";
+export declare function compareIdentity(left: FileStat | undefined, right: FileStat | undefined): "same" | "distinct" | "unknown";
+/** Compare content snapshots, including adapter generations when supplied.
+ * Identity is checked separately so identityless streaming adapters remain usable.
+ */
+export declare function compareFileVersion(left: FileStat, right: FileStat): boolean;

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/mount/identity.js

@@ -0,0 +1,29 @@
+function complete(stat) {
+    const { identityScope, dev, ino } = stat;
+    return ((typeof identityScope === "object" && identityScope !== null) || typeof identityScope === "symbol")
+        && typeof dev === "number" && Number.isSafeInteger(dev) && dev >= 0
+        && typeof ino === "number" && Number.isSafeInteger(ino) && ino >= 0;
+}
+function opaqueComplete(stat) {
+    return ((typeof stat.identityScope === "object" && stat.identityScope !== null) || typeof stat.identityScope === "symbol")
+        && typeof stat.opaqueIdentity === "string" && stat.opaqueIdentity.length > 0 && stat.opaqueIdentity.length <= 4096;
+}
+export function compareIdentity(left, right) {
+    if (!left || !right)
+        return "unknown";
+    if (complete(left) && complete(right))
+        return left.identityScope === right.identityScope && left.dev === right.dev && left.ino === right.ino ? "same" : "distinct";
+    if (opaqueComplete(left) && opaqueComplete(right))
+        return left.identityScope === right.identityScope && left.opaqueIdentity === right.opaqueIdentity ? "same" : "distinct";
+    if ((complete(left) || opaqueComplete(left)) && (complete(right) || opaqueComplete(right)) && left.identityScope !== right.identityScope)
+        return "distinct";
+    return "unknown";
+}
+/** Compare content snapshots, including adapter generations when supplied.
+ * Identity is checked separately so identityless streaming adapters remain usable.
+ */
+export function compareFileVersion(left, right) {
+    return left.type === right.type && left.size === right.size
+        && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs
+        && left.revision === right.revision && left.opaqueVersion === right.opaqueVersion;
+}

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

@@ -0,0 +1,79 @@
+import type { ExtractionOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PrepareStagingResolutionOptions, PublishStagedFileOptions, PublishStagedFileSetOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
+import type { ByteSource } from "../../contracts/io.js";
+import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
+export interface MountFileSystemOptions {
+    readonly root: FileSystem;
+    readonly mounts?: Readonly<Record<string, FileSystem>>;
+}
+export declare class MountFileSystem implements FileSystem {
+    readonly capabilities: FileSystemCapabilities;
+    private readonly mounts;
+    private activeNamespaceOperations;
+    private namespaceMutation;
+    private readonly namespaceWaiters;
+    constructor(options: MountFileSystemOptions);
+    private confineArchive;
+    confineTrustedExtraction(roots: readonly string[], options?: ExtractionOptions): Promise<FileSystem>;
+    confineExtraction(roots: readonly string[], options?: ExtractionOptions): Promise<FileSystem>;
+    private select;
+    capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
+    private supportsStagingAncestry;
+    private supportsDirectoryValidation;
+    prepareDirectoryAncestry(ancestors: readonly FileStagingEntry[], options?: FsOptions): Promise<() => true>;
+    prepareStagingResolution(path: string, options?: PrepareStagingResolutionOptions): Promise<FileStagingResolution>;
+    private prepareAncestry;
+    private protected;
+    openReadFile(path: string, options?: OpenReadFileOptions): Promise<FileReadHandle>;
+    resizeFile(path: string, operation: FileResizeOperation, options?: FileResizeOptions): Promise<void>;
+    openResizeFile(path: string, options?: OpenResizeFileOptions): Promise<FileResizeHandle>;
+    private error;
+    private acquireNamespace;
+    private operation;
+    private components;
+    private lookup;
+    private resolve;
+    private mutable;
+    private entryPath;
+    private optional;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
+    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[]>;
+    iterateDirectory(path: string, options?: FsOptions): AsyncIterable<DirectoryEntry>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    unlink(path: string, options?: FsOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    private localStaging;
+    publishFileConditional(path: string, source: ByteSource, options: ConditionalFilePublicationOptions): 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>;
+    createStagedFile(path: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
+    publishStagedFile(staging: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
+    publishStagedFileSet(staging: FileStaging, destination: string, supplied: PublishStagedFileSetOptions): Promise<FileStat>;
+    removeStagedFile(staging: FileStaging, options?: FsOptions): Promise<void>;
+    prepareDirectory(path: string, options: PrepareDirectoryOptions): Promise<FileStat>;
+    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>;
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
+    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>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+}
+export declare function createMountFileSystem(options: MountFileSystemOptions): MountFileSystem;