toolcraft 0.0.749 → 0.0.750

package/node_modules/@poe-code/safe-fs/dist/bridge/filesystem.d.ts

@@ -0,0 +1,93 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import type { BridgePrimitives, BufferEncodingOption, FsBridgeDirent, FsBridgeEncoding, FsBridgeStats, MakeDirectoryOptions, Mode, ObjectEncodingOptions, StatOptions } from "./types.js";
+type Encoding = FsBridgeEncoding | "buffer";
+type ReadOptions = ObjectEncodingOptions & {
+    flag?: string | number | undefined;
+    signal?: AbortSignal | undefined;
+};
+type DirectoryOptions = {
+    encoding?: Encoding | null | undefined;
+    recursive?: boolean | undefined;
+    withFileTypes?: boolean | undefined;
+};
+export declare class FileSystemBridge<Binary extends Uint8Array> {
+    #private;
+    static getProvider(bridge: object): FileSystem | undefined;
+    constructor(fs: FileSystem, options: {
+        readonly cwd?: string;
+        readonly root?: string;
+        readonly signal?: AbortSignal;
+        readonly readFileMaxBytes?: number;
+        readonly reserveReadFile?: () => () => void;
+    }, primitives: BridgePrimitives<Binary>);
+    readFile(path: unknown, options?: {
+        encoding?: null | undefined;
+        flag?: string | number | undefined;
+        signal?: AbortSignal | undefined;
+    } | null): Promise<Binary>;
+    readFile(path: unknown, options: FsBridgeEncoding | (ReadOptions & {
+        encoding: FsBridgeEncoding;
+    })): Promise<string>;
+    readFile(path: unknown, options?: ReadOptions | FsBridgeEncoding | null): Promise<string | Binary>;
+    writeFile(path: unknown, data: unknown, options?: unknown): Promise<void>;
+    appendFile(path: unknown, data: unknown, options?: unknown): Promise<void>;
+    stat(path: unknown, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<FsBridgeStats>;
+    stat(path: unknown, options: StatOptions & {
+        bigint: true;
+    }): Promise<never>;
+    stat(path: unknown, options?: StatOptions): Promise<FsBridgeStats>;
+    lstat(path: unknown, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<FsBridgeStats>;
+    lstat(path: unknown, options: StatOptions & {
+        bigint: true;
+    }): Promise<never>;
+    lstat(path: unknown, options?: StatOptions): Promise<FsBridgeStats>;
+    readdir(path: unknown, options?: FsBridgeEncoding | (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | null): Promise<string[]>;
+    readdir(path: unknown, options: "buffer" | (DirectoryOptions & {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+    })): Promise<Binary[]>;
+    readdir(path: unknown, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Promise<FsBridgeDirent[]>;
+    readdir(path: unknown, options: DirectoryOptions & {
+        encoding: "buffer";
+        withFileTypes: true;
+    }): Promise<FsBridgeDirent<Binary>[]>;
+    mkdir(path: unknown, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): Promise<string | undefined>;
+    mkdir(path: unknown, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null): Promise<void>;
+    mkdir(path: unknown, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
+    access(path: unknown, mode?: number): Promise<void>;
+    unlink(path: unknown): Promise<void>;
+    rm(path: unknown, value?: unknown): Promise<void>;
+    rmdir(path: unknown, value?: unknown): Promise<void>;
+    rename(source: unknown, destination: unknown): Promise<void>;
+    copyFile(source: unknown, destination: unknown, mode?: number): Promise<void>;
+    cp(source: unknown, destination: unknown, value?: unknown): Promise<void>;
+    readlink(path: unknown, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    readlink(path: unknown, options: BufferEncodingOption): Promise<Binary>;
+    readlink(path: unknown, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    realpath(path: unknown, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    realpath(path: unknown, options: BufferEncodingOption): Promise<Binary>;
+    realpath(path: unknown, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    mkdtemp(prefix: string, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    mkdtemp(prefix: string, options: BufferEncodingOption): Promise<Binary>;
+    mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    symlink(target: unknown, path: unknown, type?: unknown): Promise<void>;
+    link(existing: unknown, path: unknown): Promise<void>;
+    chmod(path: unknown, value: unknown): Promise<void>;
+    utimes(path: unknown, atime: unknown, mtime: unknown): Promise<void>;
+    truncate(path: unknown, length?: number): Promise<void>;
+}
+export {};

package/node_modules/@poe-code/safe-fs/dist/bridge/filesystem.js

@@ -0,0 +1,453 @@
+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 {
+    static getProvider(bridge) {
+        return #fs in bridge ? bridge.#fs : undefined;
+    }
+    #fs;
+    #cwd;
+    #root;
+    #signal;
+    #readFileMaxBytes;
+    #reserveReadFile;
+    #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.#root = primitives.paths.resolve("/", options.root ?? cwd);
+        assertBridgePath(this.#root, this.#cwd);
+        this.#signal = options.signal;
+        const maximum = options.readFileMaxBytes;
+        if (maximum !== undefined && maximum !== Infinity && (!Number.isSafeInteger(maximum) || maximum < 0))
+            throw new TypeError("Invalid readFileMaxBytes");
+        this.#readFileMaxBytes = maximum;
+        if (options.reserveReadFile !== undefined && typeof options.reserveReadFile !== "function")
+            throw new TypeError("Invalid reserveReadFile");
+        this.#reserveReadFile = options.reserveReadFile;
+    }
+    #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.#root, 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.#root !== "/") {
+                    for (let index = 0; index < absolute.length; index++) {
+                        resolved[index] = await checkedBridgePath(this.#fs, this.#root, 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 maxBytes = this.#readFileMaxBytes;
+        const release = this.#reserveReadFile?.();
+        let pending;
+        try {
+            const bytes = await this.#call([path], (signal, resolved) => {
+                pending = this.#fs.readFile(resolved[0], { ...signal, ...(maxBytes === undefined ? {} : { maxBytes }) });
+                return pending;
+            }, options.signal);
+            if (maxBytes !== undefined && bytes.byteLength > maxBytes)
+                throw fsError("EFBIG", "readFile");
+            const buffer = this.#primitives.copyBytes(bytes);
+            return codec === "buffer" ? buffer : this.#codec.decode(buffer, codec);
+        }
+        finally {
+            // Cancellation may reject #call before a backend acknowledges it. Keep
+            // its reservation until the actual read settles, as well as through decode.
+            if (release !== undefined) {
+                if (pending === undefined)
+                    release();
+                else
+                    void pending.then(release, release);
+            }
+        }
+    }
+    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.#root)
+                        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 unlink(path) {
+        await this.#call([path], async (signal, resolved) => {
+            if (!this.#fs.unlink)
+                unsupported("unlink");
+            await this.#fs.unlink(resolved[0], signal);
+        }, undefined, [0]);
+    }
+    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.#root ? 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.#root, 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.#root !== "/" && 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/node_modules/@poe-code/safe-fs/dist/bridge/index.d.ts

@@ -0,0 +1,7 @@
+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;
+export declare const getFsBridgeProvider: typeof FileSystemBridge.getProvider;

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

@@ -0,0 +1,19 @@
+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
+        }
+    });
+}
+export const getFsBridgeProvider = FileSystemBridge.getProvider;

package/node_modules/@poe-code/safe-fs/dist/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/node_modules/@poe-code/safe-fs/dist/bridge/stats.js

@@ -0,0 +1,37 @@
+function predicates(type) {
+    return {
+        isFile: () => type === "file",
+        isDirectory: () => type === "directory",
+        isSymbolicLink: () => type === "symlink",
+        isBlockDevice: () => false,
+        isCharacterDevice: () => type === "character",
+        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 : stat.type === "character" ? 0o020000 : 0o100000),
+        nlink: stat.nlink ?? 1,
+        uid: stat.uid ?? 0,
+        gid: stat.gid ?? 0,
+        rdev: 0,
+        size: stat.size,
+        blksize: stat.ioBlockSize ?? stat.preferredIoBlockSize ?? 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) };
+}