toolcraft 0.0.749 → 0.0.750

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

@@ -0,0 +1,81 @@
+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;
+    /** Optional confinement boundary; defaults to cwd. */
+    readonly root?: string;
+    readonly signal?: AbortSignal;
+    /** Trusted per-read backend byte cap, enforced before copying or decoding. */
+    readonly readFileMaxBytes?: number;
+    /** Reserve host resources; release after decoding and actual backend settlement, including cancellation. */
+    readonly reserveReadFile?: () => () => void;
+}
+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/node_modules/@poe-code/safe-fs/dist/bridge/types.js

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

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

@@ -0,0 +1,7 @@
+import { normalizeMemoryFileSystemLimits } from "../fs/memory/limits.js";
+export function createMemoryFileSystemAdapter(create) {
+    return {
+        validateOptions: normalizeMemoryFileSystemLimits,
+        create
+    };
+}

package/node_modules/@poe-code/safe-fs/dist/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/node_modules/@poe-code/safe-fs/dist/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 });
+        }
+    };
+}

package/node_modules/@poe-code/safe-fs/dist/config/registry.d.ts

@@ -0,0 +1,2 @@
+import type { FileSystemAdapterRegistry } from "../config.js";
+export declare function extendAdapterRegistry(defaults: FileSystemAdapterRegistry, extensions?: FileSystemAdapterRegistry): FileSystemAdapterRegistry;

package/node_modules/@poe-code/safe-fs/dist/config/registry.js

@@ -0,0 +1,15 @@
+export function extendAdapterRegistry(defaults, extensions) {
+    if (extensions !== undefined &&
+        (extensions === null ||
+            typeof extensions.get !== "function" ||
+            typeof extensions[Symbol.iterator] !== "function")) {
+        throw new TypeError("registry must be a filesystem adapter map.");
+    }
+    const registry = new Map(defaults);
+    for (const [name, descriptor] of extensions ?? []) {
+        if (registry.has(name))
+            throw new TypeError(`Filesystem adapter already registered: ${name}`);
+        registry.set(name, descriptor);
+    }
+    return registry;
+}

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

@@ -0,0 +1,15 @@
+import type { FileSystem, FileSystemFactory } from "./contracts/filesystem.js";
+export type FileSystemConfig = {
+    readonly type: string;
+    readonly options?: Readonly<Record<string, unknown>>;
+};
+export type FileSystemAdapterDescriptor = {
+    readonly validateOptions: (options: Readonly<Record<string, unknown>>) => void;
+    readonly create: FileSystemFactory;
+};
+export type FileSystemAdapterRegistry = ReadonlyMap<string, FileSystemAdapterDescriptor>;
+export declare function readConfigRecord(value: unknown, label: string, keys?: readonly string[]): Readonly<Record<string, unknown>>;
+export declare function validateFileSystemConfig(value: unknown): FileSystemConfig;
+export declare function createFileSystem(config: FileSystemConfig, options: {
+    registry: FileSystemAdapterRegistry;
+}): Promise<FileSystem>;

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

@@ -0,0 +1,46 @@
+export function readConfigRecord(value, label, keys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${label} must be a record.`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`${label} must be a plain record.`);
+    }
+    const record = Object.create(null);
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== "string" || (keys !== undefined && !keys.includes(key))) {
+            throw new TypeError(`Unknown ${label}: ${String(key)}`);
+        }
+        const property = Object.getOwnPropertyDescriptor(value, key);
+        if (!("value" in property))
+            throw new TypeError(`${label}.${key} must be a data property.`);
+        record[key] = property.value;
+    }
+    return Object.freeze(record);
+}
+export function validateFileSystemConfig(value) {
+    const config = readConfigRecord(value, "filesystem config", ["type", "options"]);
+    if (typeof config.type !== "string" || config.type.trim().length === 0) {
+        throw new TypeError("Filesystem adapter type must be a nonempty string.");
+    }
+    return {
+        type: config.type,
+        ...(config.options === undefined
+            ? {}
+            : { options: readConfigRecord(config.options, "filesystem options") })
+    };
+}
+export async function createFileSystem(config, options) {
+    const validated = validateFileSystemConfig(config);
+    const creation = readConfigRecord(options, "filesystem creation option", ["registry"]);
+    const registry = creation.registry;
+    if (registry === undefined || registry === null || typeof registry.get !== "function") {
+        throw new TypeError("registry must be a filesystem adapter map.");
+    }
+    const descriptor = registry.get(validated.type);
+    if (descriptor === undefined)
+        throw new TypeError(`Unknown filesystem adapter: ${validated.type}`);
+    const adapterOptions = validated.options ?? Object.freeze(Object.create(null));
+    descriptor.validateOptions(adapterOptions);
+    return await descriptor.create(adapterOptions);
+}

package/node_modules/@poe-code/safe-fs/dist/config.node.d.ts

@@ -0,0 +1,2 @@
+import type { FileSystemAdapterRegistry } from "./config.js";
+export declare function createNodeFileSystemAdapterRegistry(extensions?: FileSystemAdapterRegistry): FileSystemAdapterRegistry;

package/node_modules/@poe-code/safe-fs/dist/config.node.js

@@ -0,0 +1,11 @@
+import { extendAdapterRegistry } from "./config/registry.js";
+import { createMemoryFileSystemAdapter } from "./config/memory.js";
+import { createRealFileSystemAdapter } from "./config/real.js";
+import { createMemoryFileSystem } from "./fs/memory/index.js";
+import { createRealFileSystem } from "./fs/real/index.js";
+export function createNodeFileSystemAdapterRegistry(extensions) {
+    return extendAdapterRegistry(new Map([
+        ["memory", createMemoryFileSystemAdapter(createMemoryFileSystem)],
+        ["real", createRealFileSystemAdapter(createRealFileSystem)]
+    ]), extensions);
+}

package/node_modules/@poe-code/safe-fs/dist/config.portable.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystemAdapterRegistry } from "./config.js";
+/** Portable defaults never grant access to the host filesystem. */
+export declare function createPortableFileSystemAdapterRegistry(extensions?: FileSystemAdapterRegistry): FileSystemAdapterRegistry;

package/node_modules/@poe-code/safe-fs/dist/config.portable.js

@@ -0,0 +1,9 @@
+import { createMemoryFileSystemAdapter } from "./config/memory.js";
+import { extendAdapterRegistry } from "./config/registry.js";
+import { createMemoryFileSystem } from "./fs/memory/index.js";
+/** Portable defaults never grant access to the host filesystem. */
+export function createPortableFileSystemAdapterRegistry(extensions) {
+    return extendAdapterRegistry(new Map([
+        ["memory", createMemoryFileSystemAdapter(createMemoryFileSystem)]
+    ]), extensions);
+}

package/node_modules/@poe-code/safe-fs/dist/contracts/abort.d.ts

@@ -0,0 +1,5 @@
+export interface AbortSignalScope {
+    readonly signal: AbortSignal;
+    dispose(): void;
+}
+export declare function composeAbortSignals(signals: readonly AbortSignal[]): AbortSignalScope;

package/node_modules/@poe-code/safe-fs/dist/contracts/abort.js

@@ -0,0 +1,34 @@
+export function composeAbortSignals(signals) {
+    const controller = new AbortController();
+    const listeners = new Map();
+    const dispose = () => {
+        for (const [signal, listener] of listeners)
+            signal.removeEventListener("abort", listener);
+        listeners.clear();
+    };
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+            return { signal: controller.signal, dispose };
+        }
+    }
+    try {
+        for (const signal of new Set(signals)) {
+            const listener = () => {
+                dispose();
+                controller.abort(signal.reason);
+            };
+            listeners.set(signal, listener);
+            signal.addEventListener("abort", listener, { once: true });
+            if (signal.aborted)
+                listener();
+            if (controller.signal.aborted)
+                break;
+        }
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+    return { signal: controller.signal, dispose };
+}

package/node_modules/@poe-code/safe-fs/dist/contracts/cleanup.d.ts

@@ -0,0 +1 @@
+export declare function finishCleanup(cleanup: () => unknown, failed: boolean): Promise<void>;

package/node_modules/@poe-code/safe-fs/dist/contracts/cleanup.js

@@ -0,0 +1,9 @@
+export async function finishCleanup(cleanup, failed) {
+    try {
+        await cleanup();
+    }
+    catch (error) {
+        if (!failed)
+            throw error;
+    }
+}

package/node_modules/@poe-code/safe-fs/dist/contracts/descriptor.d.ts

@@ -0,0 +1,38 @@
+import type { FileStat, FsOptions } from "./filesystem.js";
+export interface OpenFileOptions extends FsOptions {
+    readonly access: "read" | "write" | "readwrite";
+    readonly creation?: "never" | "ifMissing" | "exclusive";
+    readonly truncate?: boolean;
+    readonly append?: boolean;
+    /** Atomically reject a final symlink; parent symlinks still follow provider policy. */
+    readonly noFollow?: boolean;
+    readonly mode?: number;
+    /** Apply mode exactly to new entries, without an additional host umask. */
+    readonly exactMode?: boolean;
+    readonly synchronization?: "data" | "all";
+}
+export interface FileDescriptorCapabilities {
+    readonly noFollow?: boolean;
+    readonly publication?: "conditional";
+    readonly position?: boolean;
+    readonly readObservation?: boolean;
+    readonly openTruncate?: boolean;
+    readonly positionedRead: boolean;
+    readonly positionedWrite: boolean;
+    readonly positionedAppendWrite?: boolean;
+    readonly delegateZeroLengthWrite?: boolean;
+    readonly truncate: boolean;
+    readonly synchronization: "none" | "volatile" | "storage";
+}
+export interface FileDescriptor {
+    readonly capabilities: FileDescriptorCapabilities;
+    getPosition?(options?: FsOptions): Promise<number>;
+    probeRead?(options?: FsOptions): Promise<"ready" | "blocked" | "unknown">;
+    stat(options?: FsOptions): Promise<FileStat>;
+    read(buffer: Uint8Array, position: number | null, options?: FsOptions): Promise<number>;
+    write(buffer: Uint8Array, position: number | null, options?: FsOptions): Promise<number>;
+    truncate(length: number, options?: FsOptions): Promise<void>;
+    sync(dataOnly: boolean, options?: FsOptions): Promise<void>;
+    /** Cancel cooperative close-time publication, while still releasing resources. */
+    close(options?: FsOptions): Promise<void>;
+}

package/node_modules/@poe-code/safe-fs/dist/contracts/descriptor.js

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

package/node_modules/@poe-code/safe-fs/dist/contracts/errors.d.ts

@@ -0,0 +1,53 @@
+import type { PlatformErrno } from "#safe-fs-platform";
+export type { PlatformErrno } from "#safe-fs-platform";
+declare const descriptions: {
+    readonly EACCES: "permission denied";
+    readonly EAGAIN: "resource temporarily unavailable";
+    readonly EBADF: "bad file descriptor";
+    readonly EBUSY: "resource busy or locked";
+    readonly ECANCELED: "operation canceled";
+    readonly EEXIST: "file already exists";
+    readonly EFBIG: "file too large";
+    readonly EILSEQ: "invalid or incomplete multibyte or wide character";
+    readonly EINTR: "interrupted system call";
+    readonly EINVAL: "invalid argument";
+    readonly EIO: "input/output error";
+    readonly EISDIR: "illegal operation on a directory";
+    readonly ELOOP: "too many symbolic links encountered";
+    readonly EMFILE: "too many open files";
+    readonly ENAMETOOLONG: "name too long";
+    readonly ENFILE: "file table overflow";
+    readonly ENOENT: "no such file or directory";
+    readonly ENOMEM: "not enough memory";
+    readonly ENOSPC: "no space left on device";
+    readonly ENOSYS: "function not implemented";
+    readonly ENOTDIR: "not a directory";
+    readonly ENOTEMPTY: "directory not empty";
+    readonly ENOTSUP: "operation not supported";
+    readonly EOPNOTSUPP: "operation not supported";
+    readonly EPERM: "operation not permitted";
+    readonly EPIPE: "broken pipe";
+    readonly EROFS: "read-only file system";
+    readonly ESPIPE: "illegal seek";
+    readonly ETIMEDOUT: "operation timed out";
+    readonly EXDEV: "cross-device link not permitted";
+};
+export type ErrnoCode = keyof typeof descriptions;
+export interface FsErrorOptions extends ErrorOptions {
+    readonly syscall?: string;
+    readonly path?: string;
+    readonly dest?: string;
+    readonly message?: string;
+}
+export declare class FsError extends Error {
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly code: ErrnoCode;
+    readonly errno: PlatformErrno;
+    readonly syscall?: string;
+    readonly path?: string;
+    readonly dest?: string;
+    constructor(code: ErrnoCode, options?: FsErrorOptions);
+}
+export declare function isErrnoCode(code: unknown): code is ErrnoCode;
+export declare function isFsError(error: unknown, code?: ErrnoCode): error is FsError;
+export declare function toFsError(error: unknown, options?: FsErrorOptions): FsError;

package/node_modules/@poe-code/safe-fs/dist/contracts/errors.js

@@ -0,0 +1,99 @@
+import { platform } from "#safe-fs-platform";
+const descriptions = {
+    EACCES: "permission denied",
+    EAGAIN: "resource temporarily unavailable",
+    EBADF: "bad file descriptor",
+    EBUSY: "resource busy or locked",
+    ECANCELED: "operation canceled",
+    EEXIST: "file already exists",
+    EFBIG: "file too large",
+    EILSEQ: "invalid or incomplete multibyte or wide character",
+    EINTR: "interrupted system call",
+    EINVAL: "invalid argument",
+    EIO: "input/output error",
+    EISDIR: "illegal operation on a directory",
+    ELOOP: "too many symbolic links encountered",
+    EMFILE: "too many open files",
+    ENAMETOOLONG: "name too long",
+    ENFILE: "file table overflow",
+    ENOENT: "no such file or directory",
+    ENOMEM: "not enough memory",
+    ENOSPC: "no space left on device",
+    ENOSYS: "function not implemented",
+    ENOTDIR: "not a directory",
+    ENOTEMPTY: "directory not empty",
+    ENOTSUP: "operation not supported",
+    EOPNOTSUPP: "operation not supported",
+    EPERM: "operation not permitted",
+    EPIPE: "broken pipe",
+    EROFS: "read-only file system",
+    ESPIPE: "illegal seek",
+    ETIMEDOUT: "operation timed out",
+    EXDEV: "cross-device link not permitted",
+};
+const FS_ERROR_BRAND = Symbol.for("@poe-code/safe-fs.FsError");
+export class FsError extends Error {
+    static [Symbol.hasInstance](value) {
+        if (typeof value !== "object" || value === null)
+            return false;
+        if (this !== FsError)
+            return Function.prototype[Symbol.hasInstance].call(this, value);
+        if (Function.prototype[Symbol.hasInstance].call(FsError, value))
+            return true;
+        const record = value;
+        return record[FS_ERROR_BRAND] === true && isErrnoCode(record.code);
+    }
+    code;
+    errno;
+    syscall;
+    path;
+    dest;
+    constructor(code, options = {}) {
+        if (!isErrnoCode(code))
+            throw new TypeError(`Unsupported errno code: ${String(code)}`);
+        const errno = platform.errno(code);
+        const operation = options.syscall ? `, ${options.syscall}` : "";
+        const path = options.path === undefined ? "" : ` '${options.path}'`;
+        const destination = options.dest === undefined ? "" : ` -> '${options.dest}'`;
+        const errorConstructor = Error;
+        const prevStackLimit = errorConstructor.stackTraceLimit;
+        errorConstructor.stackTraceLimit = 0;
+        try {
+            super(`${code}: ${options.message ?? descriptions[code]}${operation}${path}${destination}`, options);
+        }
+        finally {
+            errorConstructor.stackTraceLimit = prevStackLimit;
+        }
+        Object.defineProperty(this, FS_ERROR_BRAND, { value: true, enumerable: false, configurable: false, writable: false });
+        this.name = "FsError";
+        this.code = code;
+        this.errno = errno;
+        if (options.syscall !== undefined)
+            this.syscall = options.syscall;
+        if (options.path !== undefined)
+            this.path = options.path;
+        if (options.dest !== undefined)
+            this.dest = options.dest;
+    }
+}
+export function isErrnoCode(code) {
+    return typeof code === "string" && Object.hasOwn(descriptions, code);
+}
+export function isFsError(error, code) {
+    return error instanceof FsError && (code === undefined || error.code === code);
+}
+export function toFsError(error, options = {}) {
+    if (error instanceof FsError && Object.keys(options).length === 0)
+        return error;
+    const source = typeof error === "object" && error !== null
+        ? error
+        : {};
+    const details = {
+        ...(typeof source.syscall === "string" ? { syscall: source.syscall } : {}),
+        ...(typeof source.path === "string" ? { path: source.path } : {}),
+        ...(typeof source.dest === "string" ? { dest: source.dest } : {}),
+        cause: error,
+        ...options,
+    };
+    return new FsError(isErrnoCode(source.code) ? source.code : "EIO", details);
+}