@poe-platform/safe-fs 0.1.0

package/dist/safe-fs/bridge/filesystem.js

@@ -0,0 +1,411 @@
+import { composeAbortSignals } from "../contracts/abort.js";
+import { bridgeDirent, bridgeStats } from "./stats.js";
+import { booleanValue, checkSignal, onlyKeys, record, withSignal } from "./values.js";
+import { assertBridgePath, checkedBridgePath } from "./confinement.js";
+function fsError(code, syscall, path) {
+    return Object.assign(new Error(`${code}: ${syscall}${path === undefined ? "" : ` '${path}'`}`), {
+        code,
+        syscall,
+        ...(path === undefined ? {} : { path }),
+    });
+}
+function unsupported(operation) {
+    throw fsError("ENOTSUP", operation);
+}
+function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+function childPath(parent, name) {
+    return `${parent.replace(/\/$/u, "")}/${name}`;
+}
+function optionsRecord(value, allowed) {
+    const options = value == null ? {} : typeof value === "string" ? { encoding: value } : record(value, "options");
+    onlyKeys(options, allowed);
+    return options;
+}
+function modeValue(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    const parsed = typeof value === "string" && /^[0-7]+$/u.test(value) ? Number.parseInt(value, 8) : value;
+    if (typeof parsed !== "number" || !Number.isInteger(parsed) || parsed < 0 || parsed > 0o7777) {
+        throw new TypeError("Invalid file mode");
+    }
+    return parsed;
+}
+function timeValue(value) {
+    const number = value instanceof Date ? value.getTime() : Number(value) * 1000;
+    if ((typeof value !== "string" && typeof value !== "number" && !(value instanceof Date)) || !Number.isFinite(number)) {
+        throw new TypeError("Invalid timestamp");
+    }
+    return number;
+}
+export class FileSystemBridge {
+    #fs;
+    #cwd;
+    #signal;
+    #primitives;
+    #codec;
+    constructor(fs, options, primitives) {
+        if (fs === undefined)
+            throw new TypeError("An explicit filesystem is required");
+        const cwd = options.cwd ?? "/";
+        if (!primitives.paths.isAbsolute(cwd) || cwd.includes("\0"))
+            throw new TypeError("cwd must be an absolute virtual path");
+        const codec = primitives.codec;
+        if (codec === undefined || codec === null || typeof codec.isEncoding !== "function" || typeof codec.encode !== "function" || typeof codec.decode !== "function") {
+            throw new TypeError("An explicit filesystem codec is required");
+        }
+        this.#primitives = primitives;
+        this.#codec = Object.freeze({
+            isEncoding: codec.isEncoding.bind(codec),
+            encode: codec.encode.bind(codec),
+            decode: codec.decode.bind(codec)
+        });
+        this.#fs = fs;
+        this.#cwd = primitives.paths.resolve("/", cwd);
+        this.#signal = options.signal;
+    }
+    #encoding(value, fallback, names = false) {
+        const selected = value == null ? fallback : value;
+        if (typeof selected !== "string" || (selected !== "buffer" && !this.#codec.isEncoding(selected)) || (names && !this.#codec.isEncoding("utf8"))) {
+            throw new TypeError("Invalid encoding");
+        }
+        return selected;
+    }
+    #textBytes(value) {
+        return this.#primitives.copyBytes(this.#codec.encode(value, "utf8"));
+    }
+    #path(value) {
+        const path = this.#primitives.pathValue === undefined ? value : this.#primitives.pathValue(value);
+        if (typeof path !== "string" || path.includes("\0"))
+            throw new TypeError("Expected a path without NUL bytes; file handles are unsupported");
+        if (path.length === 0)
+            throw fsError("ENOENT", "path", path);
+        checkSignal(this.#signal);
+        const absolute = this.#primitives.paths.isAbsolute(path) ? path : childPath(this.#cwd, path);
+        assertBridgePath(this.#cwd, absolute);
+        return absolute;
+    }
+    async #call(paths, operation, signal, noFollow = []) {
+        if (signal !== undefined && !(signal instanceof AbortSignal))
+            throw new TypeError("Invalid AbortSignal");
+        const signalScope = signal !== undefined && this.#signal !== undefined && signal !== this.#signal
+            ? composeAbortSignals([signal, this.#signal]) : undefined;
+        const combined = signalScope?.signal ?? signal ?? this.#signal;
+        try {
+            checkSignal(combined);
+            const options = combined === undefined ? {} : { signal: combined };
+            return await withSignal(combined, async () => {
+                const absolute = paths.map((path) => this.#path(path));
+                const resolved = [...absolute];
+                if (this.#cwd !== "/") {
+                    for (let index = 0; index < absolute.length; index++) {
+                        resolved[index] = await checkedBridgePath(this.#fs, this.#cwd, absolute[index], options, !noFollow.includes(index));
+                    }
+                }
+                checkSignal(combined);
+                return operation(options, resolved);
+            });
+        }
+        finally {
+            signalScope?.dispose();
+        }
+    }
+    async readFile(path, value) {
+        const options = optionsRecord(value, ["encoding", "flag", "signal"]);
+        if (options.flag !== undefined && options.flag !== "r")
+            unsupported("readFile flag");
+        if (options.encoding === "buffer")
+            throw new TypeError("Invalid read encoding");
+        const codec = this.#encoding(options.encoding, "buffer");
+        const bytes = await this.#call([path], (signal, resolved) => this.#fs.readFile(resolved[0], signal), options.signal);
+        const buffer = this.#primitives.copyBytes(bytes);
+        return codec === "buffer" ? buffer : this.#codec.decode(buffer, codec);
+    }
+    async #write(path, data, value, fallback) {
+        const options = optionsRecord(value, ["encoding", "flag", "mode", "flush", "signal"]);
+        if (booleanValue(options.flush))
+            unsupported("writeFile flush");
+        const codec = this.#encoding(options.encoding, "utf8");
+        if (codec === "buffer")
+            throw new TypeError("Invalid write encoding");
+        const flag = options.flag ?? fallback;
+        if (flag !== "w" && flag !== "wx" && flag !== "a" && flag !== "ax")
+            unsupported("writeFile flag");
+        const mode = modeValue(options.mode, 0o666);
+        let bytes;
+        if (typeof data === "string")
+            bytes = this.#primitives.copyBytes(this.#codec.encode(data, codec));
+        else if (ArrayBuffer.isView(data))
+            bytes = this.#primitives.copyBytes(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+        else
+            throw new TypeError("writeFile accepts a string or ArrayBuffer view; streams and file handles are unsupported");
+        await this.#call([path], (signal, resolved) => this.#fs.writeFile(resolved[0], bytes, { ...signal, flag, mode }), options.signal);
+    }
+    async writeFile(path, data, options) {
+        await this.#write(path, data, options, "w");
+    }
+    async appendFile(path, data, options) {
+        await this.#write(path, data, options, "a");
+    }
+    async stat(path, value) {
+        const options = optionsRecord(value, ["bigint"]);
+        if (booleanValue(options.bigint))
+            unsupported("stat bigint");
+        return bridgeStats(await this.#call([path], (signal, resolved) => this.#fs.stat(resolved[0], signal)));
+    }
+    async lstat(path, value) {
+        const options = optionsRecord(value, ["bigint"]);
+        if (booleanValue(options.bigint))
+            unsupported("lstat bigint");
+        return bridgeStats(await this.#call([path], (signal, resolved) => this.#fs.lstat(resolved[0], signal), undefined, [0]));
+    }
+    async readdir(path, value) {
+        const options = optionsRecord(value, ["encoding", "withFileTypes", "recursive"]);
+        const codec = this.#encoding(options.encoding, "utf8", true);
+        const withFileTypes = booleanValue(options.withFileTypes);
+        const recursive = booleanValue(options.recursive);
+        const root = this.#path(path);
+        const entries = [];
+        const pending = [root];
+        while (pending.length > 0) {
+            const directory = pending.shift();
+            if (directory === undefined)
+                break;
+            for (const entry of await this.#call([directory], (signal, resolved) => this.#fs.readdir(resolved[0], signal))) {
+                if (entry.name === "" || entry.name === "." || entry.name === ".." || entry.name.includes("/") || entry.name.includes("\0")) {
+                    throw new TypeError("Invalid directory entry from filesystem");
+                }
+                const fullPath = childPath(directory, entry.name);
+                entries.push({ ...entry, parentPath: directory, relative: this.#primitives.paths.relative(root, fullPath) });
+                if (recursive && entry.type === "directory")
+                    pending.push(fullPath);
+            }
+        }
+        if (withFileTypes) {
+            return codec === "buffer"
+                ? entries.map((entry) => bridgeDirent(this.#textBytes(entry.name), entry.parentPath, entry.type))
+                : entries.map((entry) => bridgeDirent(this.#codec.decode(this.#textBytes(entry.name), codec), entry.parentPath, entry.type));
+        }
+        return codec === "buffer"
+            ? entries.map((entry) => this.#textBytes(entry.relative))
+            : entries.map((entry) => this.#codec.decode(this.#textBytes(entry.relative), codec));
+    }
+    async mkdir(path, value) {
+        const options = typeof value === "number" || typeof value === "string" ? { mode: value } : optionsRecord(value, ["mode", "recursive"]);
+        const mode = modeValue(options.mode, 0o777);
+        const recursive = booleanValue(options.recursive);
+        const target = this.#path(path);
+        let firstCreated;
+        if (recursive) {
+            let candidate = target;
+            while (true) {
+                try {
+                    await this.#call([candidate], (signal, resolved) => this.#fs.stat(resolved[0], signal));
+                    break;
+                }
+                catch (error) {
+                    if (!hasCode(error, "ENOENT"))
+                        throw error;
+                    firstCreated = candidate;
+                    if (candidate === this.#cwd)
+                        break;
+                    const parent = this.#primitives.paths.dirname(candidate);
+                    if (parent === candidate)
+                        break;
+                    candidate = parent;
+                }
+            }
+        }
+        await this.#call([target], (signal, resolved) => this.#fs.mkdir(resolved[0], { ...signal, mode, recursive }));
+        return firstCreated;
+    }
+    async access(path, mode = 0) {
+        if (!Number.isInteger(mode) || mode < 0 || mode > 7)
+            throw new TypeError("Invalid access mode");
+        await this.#call([path], (signal, resolved) => this.#fs.access(resolved[0], mode, signal));
+    }
+    async rm(path, value) {
+        const options = optionsRecord(value, ["force", "recursive", "maxRetries", "retryDelay"]);
+        if (options.maxRetries !== undefined && options.maxRetries !== 0)
+            unsupported("rm retries");
+        if (options.retryDelay !== undefined)
+            unsupported("rm retryDelay");
+        const recursive = booleanValue(options.recursive);
+        const force = booleanValue(options.force);
+        await this.#call([path], (signal, resolved) => this.#fs.rm(resolved[0], { ...signal, recursive, force }), undefined, [0]);
+    }
+    async rmdir(path, value) {
+        const options = optionsRecord(value, ["recursive", "maxRetries", "retryDelay"]);
+        const stat = await this.lstat(path);
+        if (!stat.isDirectory())
+            throw fsError("ENOTDIR", "rmdir", this.#path(path));
+        if (!booleanValue(options.recursive)) {
+            if ((await this.readdir(path)).length > 0)
+                throw fsError("ENOTEMPTY", "rmdir", this.#path(path));
+            if (options.maxRetries !== undefined && options.maxRetries !== 0)
+                unsupported("rmdir retries");
+            if (options.retryDelay !== undefined)
+                unsupported("rmdir retryDelay");
+            const method = this.#fs.rmdir;
+            if (method === undefined)
+                unsupported("atomic rmdir");
+            await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], signal), undefined, [0]);
+        }
+        else
+            await this.rm(path, options);
+    }
+    async rename(source, destination) {
+        await this.#call([source, destination], (signal, resolved) => this.#fs.rename(resolved[0], resolved[1], signal), undefined, [0, 1]);
+    }
+    async copyFile(source, destination, mode = 0) {
+        if (mode !== 0 && mode !== 1)
+            unsupported("copyFile mode");
+        await this.#call([source, destination], (signal, resolved) => this.#fs.copyFile(resolved[0], resolved[1], { ...signal, exclusive: mode === 1 }));
+    }
+    async cp(source, destination, value) {
+        const options = optionsRecord(value, ["recursive", "force", "errorOnExist", "mode", "dereference", "preserveTimestamps", "verbatimSymlinks"]);
+        if (booleanValue(options.dereference) || booleanValue(options.preserveTimestamps) || booleanValue(options.verbatimSymlinks))
+            unsupported("cp options");
+        const recursive = booleanValue(options.recursive);
+        const force = booleanValue(options.force, true);
+        const errorOnExist = booleanValue(options.errorOnExist);
+        if (options.mode !== undefined && options.mode !== 0 && options.mode !== 1)
+            unsupported("cp mode");
+        const from = this.#path(source);
+        const to = this.#path(destination);
+        const canonicalFrom = await this.realpath(from);
+        let ancestor = to === this.#cwd ? to : this.#primitives.paths.dirname(to);
+        let canonicalAncestor;
+        while (true) {
+            try {
+                canonicalAncestor = await this.realpath(ancestor);
+                break;
+            }
+            catch (error) {
+                if (!hasCode(error, "ENOENT"))
+                    throw error;
+                const parent = this.#primitives.paths.dirname(ancestor);
+                if (parent === ancestor)
+                    throw error;
+                ancestor = parent;
+            }
+        }
+        const canonicalTo = this.#primitives.paths.resolve(canonicalAncestor, this.#primitives.paths.relative(ancestor, to));
+        if (canonicalFrom === "/" || canonicalTo === canonicalFrom || canonicalTo.startsWith(`${canonicalFrom}/`))
+            throw fsError("EINVAL", "cp", to);
+        const copy = async (current, target) => {
+            const sourceStat = await this.lstat(current);
+            if (sourceStat.isSymbolicLink())
+                unsupported("cp symlink");
+            let destinationStat;
+            try {
+                destinationStat = await this.lstat(target);
+            }
+            catch (error) {
+                if (!hasCode(error, "ENOENT"))
+                    throw error;
+            }
+            if (destinationStat?.isSymbolicLink())
+                unsupported("cp destination symlink");
+            if (sourceStat.isDirectory()) {
+                if (!recursive)
+                    throw fsError("EISDIR", "cp", current);
+                if (destinationStat !== undefined && !destinationStat.isDirectory())
+                    throw fsError("ENOTDIR", "cp", target);
+                await this.mkdir(target, { recursive: true, mode: sourceStat.mode & 0o7777 });
+                for (const entry of await this.readdir(current))
+                    await copy(childPath(current, entry), childPath(target, entry));
+            }
+            else {
+                if (destinationStat?.isDirectory())
+                    throw fsError("EISDIR", "cp", target);
+                if (destinationStat !== undefined && !force) {
+                    if (errorOnExist)
+                        throw fsError("EEXIST", "cp", target);
+                    return;
+                }
+                await this.mkdir(this.#primitives.paths.dirname(target), { recursive: true });
+                await this.copyFile(current, target, options.mode === 1 || !force ? 1 : 0);
+            }
+        };
+        await copy(from, to);
+    }
+    async readlink(path, value) {
+        const codec = this.#encoding(optionsRecord(value, ["encoding"]).encoding, "utf8", true);
+        const method = this.#fs.readlink;
+        if (method === undefined)
+            unsupported("readlink");
+        const target = await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], signal), undefined, [0]);
+        return codec === "buffer" ? this.#textBytes(target) : this.#codec.decode(this.#textBytes(target), codec);
+    }
+    async realpath(path, value) {
+        const codec = this.#encoding(optionsRecord(value, ["encoding"]).encoding, "utf8", true);
+        const target = await this.#call([path], (signal, resolved) => this.#fs.realpath(resolved[0], signal));
+        assertBridgePath(this.#cwd, target);
+        return codec === "buffer" ? this.#textBytes(target) : this.#codec.decode(this.#textBytes(target), codec);
+    }
+    async mkdtemp(prefix, value) {
+        if (typeof prefix !== "string" || prefix.includes("\0"))
+            throw new TypeError("Invalid mkdtemp prefix");
+        const codec = this.#encoding(optionsRecord(value, ["encoding"]).encoding, "utf8", true);
+        for (let attempt = 0; attempt < 10; attempt += 1) {
+            const path = prefix + this.#primitives.randomSuffix();
+            try {
+                await this.mkdir(path, { mode: 0o700 });
+                return codec === "buffer" ? this.#textBytes(path) : this.#codec.decode(this.#textBytes(path), codec);
+            }
+            catch (error) {
+                if (!hasCode(error, "EEXIST"))
+                    throw error;
+            }
+        }
+        throw fsError("EEXIST", "mkdtemp", prefix);
+    }
+    async symlink(target, path, type) {
+        if (type !== undefined && type !== null && type !== "file" && type !== "dir")
+            unsupported("symlink type");
+        const linkTarget = this.#primitives.pathValue === undefined ? target : this.#primitives.pathValue(target);
+        if (typeof linkTarget !== "string" || linkTarget.includes("\0"))
+            throw new TypeError("Invalid symlink target");
+        const destination = this.#path(path);
+        const absoluteTarget = this.#path(this.#primitives.paths.isAbsolute(linkTarget)
+            ? linkTarget : childPath(this.#primitives.paths.dirname(destination), linkTarget));
+        if (this.#cwd !== "/" && this.#primitives.paths.isAbsolute(linkTarget)) {
+            throw fsError("ENOTSUP", "symlink", destination);
+        }
+        const method = this.#fs.symlink;
+        if (method === undefined)
+            unsupported("symlink");
+        await this.#call([destination, absoluteTarget], (signal, resolved) => method.call(this.#fs, linkTarget, resolved[0], signal), undefined, [0]);
+    }
+    async link(existing, path) {
+        const method = this.#fs.link;
+        if (method === undefined)
+            unsupported("link");
+        await this.#call([existing, path], (signal, resolved) => method.call(this.#fs, resolved[0], resolved[1], signal), undefined, [1]);
+    }
+    async chmod(path, value) {
+        const mode = modeValue(value, 0);
+        const method = this.#fs.chmod;
+        if (method === undefined)
+            unsupported("chmod");
+        await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], mode, signal));
+    }
+    async utimes(path, atime, mtime) {
+        const accessTime = timeValue(atime);
+        const modificationTime = timeValue(mtime);
+        const method = this.#fs.utimes;
+        if (method === undefined)
+            unsupported("utimes");
+        await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], accessTime, modificationTime, signal));
+    }
+    async truncate(path, length = 0) {
+        if (!Number.isInteger(length))
+            throw new TypeError("Invalid truncate length");
+        const method = this.#fs.truncate;
+        if (method === undefined)
+            unsupported("truncate");
+        await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], Math.max(0, length), signal));
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import { FileSystemBridge } from "./filesystem.js";
+import type { FsBridgeOptions } from "./types.js";
+export type { FsBridgeCodec, FsBridgeDirent, FsBridgeEncoding, FsBridgeFileSystem, FsBridgeOptions, FsBridgeStats } from "./types.js";
+export type FsBridge = FileSystemBridge<Uint8Array<ArrayBuffer>>;
+export declare function createFsBridge(fs: FileSystem, options: FsBridgeOptions): FsBridge;

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

@@ -0,0 +1,18 @@
+import { platform } from "#safe-fs-platform";
+import { dirname, relativePath, resolvePath } from "../contracts/virtual-path.js";
+import { FileSystemBridge } from "./filesystem.js";
+export function createFsBridge(fs, options) {
+    if (options === undefined || options === null)
+        throw new TypeError("An explicit filesystem codec is required");
+    return new FileSystemBridge(fs, options, {
+        codec: options.codec,
+        copyBytes(bytes) { return new Uint8Array(bytes); },
+        randomSuffix() { return platform.randomUUID().slice(0, 6); },
+        paths: {
+            isAbsolute(path) { return typeof path === "string" && path.startsWith("/"); },
+            dirname,
+            relative: relativePath,
+            resolve: resolvePath
+        }
+    });
+}

package/dist/safe-fs/bridge/stats.d.ts

@@ -0,0 +1,4 @@
+import type { FsBridgeDirent, FsBridgeStats } from "./types.js";
+import type { FileStat, FileType } from "../contracts/filesystem.js";
+export declare function bridgeStats(stat: FileStat): FsBridgeStats;
+export declare function bridgeDirent<Name extends string | Uint8Array>(name: Name, parentPath: string, type: FileType): FsBridgeDirent<Name>;

package/dist/safe-fs/bridge/stats.js

@@ -0,0 +1,37 @@
+function predicates(type) {
+    return {
+        isFile: () => type === "file",
+        isDirectory: () => type === "directory",
+        isSymbolicLink: () => type === "symlink",
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isFIFO: () => false,
+        isSocket: () => false,
+    };
+}
+export function bridgeStats(stat) {
+    return {
+        dev: stat.dev ?? 0,
+        ino: stat.ino ?? 0,
+        mode: (stat.mode & 0o7777) | (stat.type === "directory" ? 0o040000 : stat.type === "symlink" ? 0o120000 : 0o100000),
+        nlink: stat.nlink ?? 1,
+        uid: stat.uid ?? 0,
+        gid: stat.gid ?? 0,
+        rdev: 0,
+        size: stat.size,
+        blksize: 4096,
+        blocks: Math.ceil(stat.size / 512),
+        atimeMs: stat.atimeMs,
+        mtimeMs: stat.mtimeMs,
+        ctimeMs: stat.ctimeMs,
+        birthtimeMs: stat.birthtimeMs ?? stat.ctimeMs,
+        atime: new Date(stat.atimeMs),
+        mtime: new Date(stat.mtimeMs),
+        ctime: new Date(stat.ctimeMs),
+        birthtime: new Date(stat.birthtimeMs ?? stat.ctimeMs),
+        ...predicates(stat.type),
+    };
+}
+export function bridgeDirent(name, parentPath, type) {
+    return { name, parentPath, path: parentPath, ...predicates(type) };
+}

package/dist/safe-fs/bridge/types.d.ts

@@ -0,0 +1,75 @@
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export interface FsBridgeCodec {
+    isEncoding(encoding: string): boolean;
+    encode(text: string, encoding: string): Uint8Array;
+    decode(bytes: Uint8Array, encoding: string): string;
+}
+export interface FsBridgeOptions {
+    readonly codec: FsBridgeCodec;
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+export interface FsBridgeFileSystem extends FileSystem {
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+}
+export type FsBridgeEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+export interface ObjectEncodingOptions {
+    encoding?: FsBridgeEncoding | null | undefined;
+}
+export type BufferEncodingOption = "buffer" | {
+    encoding: "buffer";
+};
+export type Mode = number | string;
+export interface MakeDirectoryOptions {
+    recursive?: boolean | undefined;
+    mode?: Mode | undefined;
+}
+export interface StatOptions {
+    bigint?: boolean | undefined;
+}
+export interface FsBridgePredicates {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface FsBridgeStats extends FsBridgePredicates {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+export interface FsBridgeDirent<Name extends string | Uint8Array = string> extends FsBridgePredicates {
+    name: Name;
+    parentPath: string;
+    path: string;
+}
+export interface BridgePrimitives<Binary extends Uint8Array> {
+    readonly codec: FsBridgeCodec;
+    copyBytes(bytes: Uint8Array): Binary;
+    pathValue?(value: unknown): unknown;
+    randomSuffix(): string;
+    readonly paths: {
+        isAbsolute(path: string): boolean;
+        dirname(path: string): string;
+        relative(from: string, to: string): string;
+        resolve(cwd: string, ...paths: string[]): string;
+    };
+}

package/dist/safe-fs/bridge/types.js

@@ -0,0 +1 @@
+export {};

package/dist/safe-fs/bridge/values.d.ts

@@ -0,0 +1,6 @@
+export declare function record(value: unknown, name: string): Record<string, unknown>;
+export declare function onlyKeys(value: Record<string, unknown>, allowed: readonly string[]): void;
+export declare function booleanValue(value: unknown, fallback?: boolean): boolean;
+export declare function abortError(): Error;
+export declare function checkSignal(signal: AbortSignal | undefined): void;
+export declare function withSignal<Value>(signal: AbortSignal | undefined, operation: () => Promise<Value>): Promise<Value>;

package/dist/safe-fs/bridge/values.js

@@ -0,0 +1,65 @@
+export function record(value, name) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${name} must be a plain object`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`${name} must be a plain object`);
+    }
+    const result = {};
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (typeof key !== "string" || descriptor === undefined || !("value" in descriptor)) {
+            throw new TypeError(`${name} must contain only string-keyed data properties`);
+        }
+        Object.defineProperty(result, key, {
+            value: descriptor.value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return result;
+}
+export function onlyKeys(value, allowed) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key))
+            throw new TypeError(`Unsupported option: ${key}`);
+    }
+}
+export function booleanValue(value, fallback = false) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "boolean")
+        throw new TypeError("Expected a boolean option");
+    return value;
+}
+export function abortError() {
+    return Object.assign(new Error("The operation was aborted"), {
+        name: "AbortError",
+        code: "ABORT_ERR",
+    });
+}
+export function checkSignal(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+export async function withSignal(signal, operation) {
+    checkSignal(signal);
+    if (signal === undefined)
+        return operation();
+    let onAbort = () => undefined;
+    const cancelled = new Promise((_resolve, reject) => {
+        onAbort = () => reject(abortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([Promise.resolve().then(() => {
+                checkSignal(signal);
+                return operation();
+            }), cancelled]);
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+    }
+}

package/dist/safe-fs/config/memory.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemFactory } from "../contracts/filesystem.js";
+import { type FileSystemAdapterDescriptor } from "../config.js";
+export declare function createMemoryFileSystemAdapter(create: FileSystemFactory): FileSystemAdapterDescriptor;

package/dist/safe-fs/config/memory.js

@@ -0,0 +1,9 @@
+import { readConfigRecord } from "../config.js";
+export function createMemoryFileSystemAdapter(create) {
+    return {
+        validateOptions(options) {
+            readConfigRecord(options, "memory option", []);
+        },
+        create
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { FileSystemFactory } from "../contracts/filesystem.js";
+import { type FileSystemAdapterDescriptor } from "../config.js";
+export declare function createRealFileSystemAdapter(create: (options: {
+    readonly root: string;
+}) => ReturnType<FileSystemFactory>): FileSystemAdapterDescriptor;

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

@@ -0,0 +1,16 @@
+import { readConfigRecord } from "../config.js";
+export function createRealFileSystemAdapter(create) {
+    return {
+        validateOptions(options) {
+            const record = readConfigRecord(options, "real option", ["root"]);
+            if (typeof record.root !== "string" ||
+                !record.root.startsWith("/") ||
+                record.root.includes("\0")) {
+                throw new TypeError("adapter.options.root must be an absolute host directory");
+            }
+        },
+        create(options) {
+            return create({ root: options.root });
+        }
+    };
+}