@kamilio/wire 0.1.9 → 0.1.11

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

@@ -0,0 +1,321 @@
+import { FsError } from "./errors.js";
+import { finishCleanup } from "./cleanup.js";
+let sharedTextEncoder;
+const EMPTY_BYTES = new Uint8Array(0);
+const DONE_RESULT = Object.freeze({ done: true, value: undefined });
+const RESOLVED_DONE = Promise.resolve(DONE_RESULT);
+const readBytesSignal = Symbol.for("safe-fs.readBytesSignal");
+const EMPTY_BYTE_ITERATOR = Object.freeze({
+    [Symbol.asyncIterator]() { return this; },
+    tryNextSync() { return DONE_RESULT; },
+    next() { return RESOLVED_DONE; },
+    return() { return RESOLVED_DONE; },
+});
+const EMPTY_BYTE_SOURCE = Object.freeze({
+    [Symbol.asyncIterator]() { return EMPTY_BYTE_ITERATOR; },
+});
+const noop = () => { };
+class SingleChunkByteIterator {
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.consumed = false;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    tryNextSync() {
+        if (this.consumed)
+            return DONE_RESULT;
+        this.consumed = true;
+        return { done: false, value: this.bytes };
+    }
+    next() {
+        if (this.consumed)
+            return RESOLVED_DONE;
+        this.consumed = true;
+        return Promise.resolve({ done: false, value: this.bytes });
+    }
+    return() {
+        this.consumed = true;
+        return RESOLVED_DONE;
+    }
+}
+class SingleChunkByteSource {
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    [Symbol.asyncIterator]() {
+        return new SingleChunkByteIterator(this.bytes);
+    }
+}
+export function toByteSource(input) {
+    if (typeof input !== "string" && !(input instanceof Uint8Array)) {
+        throw new TypeError("Byte source input must be a string or Uint8Array");
+    }
+    if (typeof input === "string") {
+        if (input.length === 0)
+            return EMPTY_BYTE_SOURCE;
+    }
+    else if (input.byteLength === 0) {
+        return EMPTY_BYTE_SOURCE;
+    }
+    const bytes = typeof input === "string" ? (sharedTextEncoder ??= new TextEncoder()).encode(input) : new Uint8Array(input);
+    return new SingleChunkByteSource(bytes);
+}
+export async function collectBytes(source, options) {
+    if (options.maxBytes !== undefined && options.maxBytes !== Infinity && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)) {
+        throw new RangeError("maxBytes must be a nonnegative safe integer");
+    }
+    if (options.maxMemoryBytes !== undefined && options.maxMemoryBytes !== Infinity && (!Number.isSafeInteger(options.maxMemoryBytes) || options.maxMemoryBytes < 0)) {
+        throw new RangeError("maxMemoryBytes must be a nonnegative safe integer or Infinity");
+    }
+    const memoryLimit = options.maxMemoryBytes ?? Infinity;
+    let reserved = 0;
+    let inputBytes = 0;
+    let buffer = new Uint8Array(0);
+    let size = 0;
+    function reserve(bytes) {
+        if (bytes > memoryLimit - reserved) {
+            throw new FsError("EFBIG", { syscall: "collectBytes", message: "collection exceeds memory budget" });
+        }
+        reserved += bytes;
+    }
+    options.signal?.throwIfAborted();
+    for await (const chunk of readBytes(source, options.signal)) {
+        reserved -= inputBytes;
+        inputBytes = 0;
+        if (chunk.byteLength > (options.maxBytes ?? Infinity) - size) {
+            throw new FsError("EFBIG", { syscall: "collectBytes", message: "output exceeds maxBytes" });
+        }
+        // A small view can retain a large backing buffer. Keep this reservation
+        // while awaiting the next chunk, including while its source is suspended.
+        reserve(chunk.buffer.byteLength);
+        inputBytes = chunk.buffer.byteLength;
+        const nextSize = size + chunk.byteLength;
+        if (nextSize > buffer.byteLength) {
+            const capacity = Math.min(options.maxBytes ?? Infinity, Math.max(nextSize, buffer.byteLength * 2));
+            // Admit both generations before allocation. Do not fall back to repeated
+            // exact-size growth when geometric growth exceeds the budget.
+            reserve(capacity);
+            const replacement = new Uint8Array(capacity);
+            replacement.set(buffer.subarray(0, size));
+            reserved -= buffer.byteLength;
+            buffer = replacement;
+        }
+        buffer.set(chunk, size);
+        size = nextSize;
+    }
+    options.signal?.throwIfAborted();
+    return buffer.subarray(0, size);
+}
+/** Subscribe when supported; callers must still check cancellation at operation boundaries. */
+export function listenForAbort(signal, listener) {
+    let callback = listener;
+    const onAbort = () => callback?.();
+    const dispose = () => {
+        // Release operation state even when a frozen host refuses removal.
+        callback = undefined;
+        try {
+            signal.removeEventListener("abort", onAbort);
+        }
+        catch (error) {
+            if (!(error instanceof TypeError) || Object.isExtensible(signal))
+                throw error;
+        }
+    };
+    try {
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+    catch (error) {
+        // Frozen hosts may register before failing to update their bookkeeping.
+        dispose();
+        if (!(error instanceof TypeError) || Object.isExtensible(signal))
+            throw error;
+    }
+    return dispose;
+}
+async function abortable(operation, signal) {
+    signal?.throwIfAborted();
+    if (!signal)
+        return operation();
+    return new Promise((resolve, reject) => {
+        const dispose = listenForAbort(signal, () => {
+            dispose();
+            reject(signal.reason);
+        });
+        try {
+            Promise.resolve(operation()).then((result) => {
+                dispose();
+                resolve(result);
+            }, (error) => {
+                dispose();
+                reject(error);
+            });
+        }
+        catch (error) {
+            dispose();
+            reject(error);
+        }
+    });
+}
+class ReadBytesGenerator {
+    constructor(source, signal) {
+        this.source = source;
+        this.abortSignal = signal;
+        this.iterator = undefined;
+        this.nativeAbort = false;
+        this.finished = false;
+        this.closing = undefined;
+        this.turn = undefined;
+        this.readingSync = false;
+        this.syncFailure = undefined;
+    }
+    get [readBytesSignal]() {
+        return this.abortSignal;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    _schedule(action) {
+        const previous = this.turn;
+        let release;
+        const reserved = new Promise(resolve => { release = resolve; });
+        // Reserve before calling a producer, which may synchronously reenter us.
+        this.turn = reserved;
+        const result = previous
+            ? previous.then(action)
+            : this.readingSync
+                ? Promise.resolve().then(action)
+                : action();
+        const finish = () => {
+            if (this.turn === reserved)
+                this.turn = undefined;
+            release();
+        };
+        void result.then(finish, finish);
+        return result;
+    }
+    _ensureIterator() {
+        let it = this.iterator;
+        if (!it) {
+            const signal = this.abortSignal;
+            signal?.throwIfAborted();
+            it = this.source[Symbol.asyncIterator]();
+            this.iterator = it;
+            this.nativeAbort = signal !== undefined && it.abortSignal === signal;
+        }
+        return it;
+    }
+    async _cleanupIterator(failed) {
+        const signal = this.abortSignal;
+        if (!this.finished && this.iterator?.return) {
+            this.finished = true;
+            const it = this.iterator;
+            const cleanup = new Promise(resolve => { resolve(it.return()); });
+            if (signal?.aborted)
+                void cleanup.catch(noop);
+            else
+                this.closing = abortable(() => cleanup, signal).then(noop);
+        }
+        else {
+            this.finished = true;
+        }
+        if (this.closing) {
+            const pending = this.closing;
+            try {
+                await finishCleanup(() => pending, failed);
+            }
+            finally {
+                if (this.closing === pending)
+                    this.closing = undefined;
+            }
+        }
+    }
+    tryNextSync() {
+        if (this.turn || this.readingSync || this.syncFailure)
+            return undefined;
+        if (this.finished)
+            return DONE_RESULT;
+        this.readingSync = true;
+        try {
+            const it = this._ensureIterator();
+            if (typeof it.tryNextSync !== "function")
+                return undefined;
+            const signal = this.abortSignal;
+            signal?.throwIfAborted();
+            const syncResult = it.tryNextSync();
+            signal?.throwIfAborted();
+            if (syncResult === undefined)
+                return undefined;
+            if (syncResult.done) {
+                this.finished = true;
+                return DONE_RESULT;
+            }
+            if (!(syncResult.value instanceof Uint8Array))
+                throw new TypeError("Byte sources must yield Uint8Array chunks");
+            return syncResult;
+        }
+        catch (error) {
+            this.syncFailure = { reason: error };
+            return undefined;
+        }
+        finally {
+            this.readingSync = false;
+        }
+    }
+    async _runNext() {
+        if (this.finished)
+            return DONE_RESULT;
+        try {
+            if (this.syncFailure) {
+                const { reason } = this.syncFailure;
+                this.syncFailure = undefined;
+                throw reason;
+            }
+            const it = this._ensureIterator();
+            const signal = this.abortSignal;
+            signal?.throwIfAborted();
+            const syncResult = typeof it.tryNextSync === "function" ? it.tryNextSync() : undefined;
+            const result = syncResult ?? (this.nativeAbort ? await it.next() : await abortable(() => it.next(), signal));
+            signal?.throwIfAborted();
+            if (result.done) {
+                this.finished = true;
+                return DONE_RESULT;
+            }
+            if (!(result.value instanceof Uint8Array))
+                throw new TypeError("Byte sources must yield Uint8Array chunks");
+            return result;
+        }
+        catch (error) {
+            await this._cleanupIterator(true);
+            throw error;
+        }
+    }
+    next() {
+        if (this.finished && !this.turn && !this.readingSync && !this.syncFailure && !this.closing)
+            return RESOLVED_DONE;
+        return this._schedule(() => this._runNext());
+    }
+    return(value) {
+        if ((this.finished || !this.iterator?.return) && !this.turn && !this.readingSync && !this.closing && value === undefined) {
+            this.finished = true;
+            return RESOLVED_DONE;
+        }
+        return this._schedule(async () => {
+            await this._cleanupIterator(false);
+            return { done: true, value: await value };
+        });
+    }
+    throw(error) {
+        return this._schedule(async () => {
+            await this._cleanupIterator(true);
+            throw error;
+        });
+    }
+}
+export function readBytes(source, signal) {
+    if (signal !== undefined && source[readBytesSignal] === signal) {
+        return source;
+    }
+    return new ReadBytesGenerator(source, signal);
+}

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

@@ -0,0 +1,134 @@
+import type { FileType, FsOptions, ReadDirectoryOptions } from "./filesystem.js";
+/** Owned Unix path bytes. No decoding, normalization, or namespace authorization. */
+export declare class BytePath {
+    #private;
+    constructor(value: Uint8Array);
+    bytes(): Uint8Array;
+}
+/** JSON representation: octets, never a UTF-8 replacement string. */
+export declare function encodeBytePath(path: BytePath): number[];
+export declare function decodeBytePath(value: unknown): BytePath;
+/** Admit legacy numbers before conversion; native off_t profile is signed 64-bit. */
+export declare function fileOffset(value: number | bigint): bigint;
+export declare function encodeFileOffset(value: bigint): string;
+export declare function decodeFileOffset(value: unknown): bigint;
+export type SpecialFileType = "character" | "fifo" | "socket";
+export type ObjectFileType = FileType | SpecialFileType;
+export interface ExactFileStat {
+    readonly type: ObjectFileType;
+    readonly size: bigint;
+    readonly allocatedBytes?: bigint;
+    /** Observed link count, including zero for an unlinked retained object; not identity. */
+    readonly nlink?: bigint;
+    readonly mode?: number;
+    readonly uid?: number;
+    readonly gid?: number;
+    readonly atimeNs?: bigint;
+    readonly mtimeNs?: bigint;
+    readonly ctimeNs?: bigint;
+}
+/** Metadata updates affect the retained object. No implicit recursive/path fallback. */
+export interface ObjectMetadata {
+    readonly mode?: number;
+    readonly uid?: number;
+    readonly gid?: number;
+    readonly atimeNs?: bigint;
+    readonly mtimeNs?: bigint;
+}
+export interface ExactFileReadHandle {
+    stat(options?: FsOptions): Promise<ExactFileStat>;
+    read(position: bigint, maxBytes: number, options?: FsOptions): Promise<Uint8Array>;
+}
+export interface ExactFileResizeHandle {
+    stat(options?: FsOptions): Promise<ExactFileStat>;
+    truncate(length: bigint, options?: FsOptions): Promise<void>;
+}
+/** Cursor operation on the same retained open description. Aliases share its
+ * cursor; close ownership remains with the enclosing handle. No numeric fallback. */
+export interface ExactFileSeekHandle {
+    seek(position: bigint, options?: FsOptions): Promise<void>;
+}
+export interface OpenFileObjectOptions extends FsOptions {
+    /** Default read; retained handle access is independent of hardlink identity. */
+    readonly access?: "read" | "write" | "readwrite";
+    /** Separately authorized native endpoint; omission never admits a special file. */
+    readonly special?: SpecialFileType;
+}
+/** Native creation admission on the same object that is returned. Exclusive
+ * flags refuse every existing entry, including a symlink, without mutation.
+ * w truncates during acquisition; a preserves existing bytes. Failure after a
+ * completed truncation does not roll it back. Backend root/mount/readonly/quota
+ * policy applies before acquisition; no caller-side existence or stat probe. */
+export interface CreateFileObjectOptions extends FsOptions {
+    readonly flag: "w" | "wx" | "a" | "ax";
+    readonly access?: "read" | "write" | "readwrite";
+    readonly mode?: number;
+}
+export interface RetainedFileObject {
+    /** Qualified retained identity: aliases share this token while any retain exists.
+     * Tokens cannot collide across unrelated backend/mount authorities and are never
+     * derived from paths or unqualified stat tuples. They are NOT wire identifiers. */
+    readonly identity: object | symbol;
+    readonly type: ObjectFileType;
+    stat(options?: FsOptions): Promise<ExactFileStat>;
+    read?(position: bigint, maxBytes: number, options?: FsOptions): Promise<Uint8Array>;
+    write?(position: bigint, bytes: Uint8Array, options?: FsOptions): Promise<number>;
+    /** Choose EOF and append on this retained object as one backend operation.
+     * Return actual settled byte progress; never implement with caller-side stat/write. */
+    append?(bytes: Uint8Array, options?: FsOptions): Promise<number>;
+    truncate?(length: bigint, options?: FsOptions): Promise<void>;
+    /** Each field requires backend support; unsupported fields reject ENOTSUP. */
+    metadata?(changes: ObjectMetadata, options?: FsOptions): Promise<void>;
+    /** Link the retained object, not its former pathname. Preserve EXDEV/EPERM. */
+    link?(destination: BytePath, options?: FsOptions): Promise<void>;
+    close(): Promise<void>;
+}
+export interface CreatedFileObject extends RetainedFileObject {
+    /** Receipt from acquisition, never inferred from a later pathname probe. */
+    readonly creation: "created" | "opened" | "truncated";
+}
+/** Optional stronger byte namespace. Absence is unsupported, not string fallback.
+ * Implementations retain objects atomically, enforce mount/root permissions and
+ * validate requested endpoint kinds before any potentially blocking acquisition. */
+export interface ObjectFileSystem {
+    readonly specialFiles?: Readonly<Partial<Record<SpecialFileType, boolean>>>;
+    open(path: BytePath, options?: OpenFileObjectOptions): Promise<RetainedFileObject>;
+    /** Optional qualified create/open/truncate primitive. Mode is used for newly
+     * created files only. Defaults for access/mode belong to the backend. a/ax
+     * do not synthesize retained append support or an append cursor. */
+    create?(path: BytePath, options: CreateFileObjectOptions): Promise<CreatedFileObject>;
+    /** A receipt describes this operation's actual namespace effect, not a later
+     * pathname probe. Omission means unknown; identical-object renames may be no-ops. */
+    rename?(source: BytePath, destination: BytePath, options?: FsOptions): Promise<void | {
+        readonly moved: boolean;
+    }>;
+    unlink?(path: BytePath, options?: FsOptions): Promise<void>;
+    readdir?(path: BytePath, options?: ReadDirectoryOptions): Promise<readonly {
+        readonly name: BytePath;
+        readonly type: ObjectFileType;
+    }[]>;
+}
+export interface WireObjectDirectoryEntry {
+    readonly name: readonly number[];
+    readonly type: ObjectFileType;
+}
+export interface WireObjectHandle {
+    readonly handle: string;
+    readonly object: string;
+}
+export type WireExactFileStat = Omit<ExactFileStat, "size" | "allocatedBytes" | "nlink" | "atimeNs" | "mtimeNs" | "ctimeNs"> & {
+    readonly size: string;
+    readonly allocatedBytes?: string;
+    readonly nlink?: string;
+    readonly atimeNs?: string;
+    readonly mtimeNs?: string;
+    readonly ctimeNs?: string;
+};
+export type WireObjectMetadata = Omit<ObjectMetadata, "atimeNs" | "mtimeNs"> & {
+    readonly atimeNs?: string;
+    readonly mtimeNs?: string;
+};
+export declare function encodeObjectMetadata(value: ObjectMetadata): WireObjectMetadata;
+export declare function decodeObjectMetadata(value: unknown): ObjectMetadata;
+/** Signed nanoseconds since Unix epoch; admit exact values before serialization. */
+export declare function encodeFileTimestamp(value: bigint): string;

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

@@ -0,0 +1,97 @@
+import { FsError } from "./errors.js";
+/** Owned Unix path bytes. No decoding, normalization, or namespace authorization. */
+export class BytePath {
+    #value;
+    constructor(value) {
+        if (!(value instanceof Uint8Array)) {
+            throw new FsError("EINVAL", { syscall: "bytePath" });
+        }
+        this.#value = new Uint8Array(value);
+        if (this.#value.length === 0 || this.#value.includes(0)) {
+            throw new FsError("EINVAL", { syscall: "bytePath" });
+        }
+    }
+    bytes() { return this.#value.slice(); }
+}
+/** JSON representation: octets, never a UTF-8 replacement string. */
+export function encodeBytePath(path) {
+    return Array.from(BytePath.prototype.bytes.call(path));
+}
+export function decodeBytePath(value) {
+    if (!Array.isArray(value))
+        throw new FsError("EINVAL", { syscall: "bytePath" });
+    const octets = Array.from({ length: value.length }, (_, index) => {
+        if (!Object.hasOwn(value, index))
+            throw new FsError("EINVAL", { syscall: "bytePath" });
+        return value[index];
+    });
+    if (octets.some(byte => !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+        throw new FsError("EINVAL", { syscall: "bytePath" });
+    }
+    return new BytePath(Uint8Array.from(octets));
+}
+/** Admit legacy numbers before conversion; native off_t profile is signed 64-bit. */
+export function fileOffset(value) {
+    if (typeof value !== "bigint" && (typeof value !== "number" || !Number.isSafeInteger(value))) {
+        throw new FsError("EINVAL", { syscall: "offset" });
+    }
+    const exact = BigInt(value);
+    if (exact < 0n || exact > 9223372036854775807n)
+        throw new FsError("EINVAL", { syscall: "offset" });
+    return exact;
+}
+export function encodeFileOffset(value) {
+    if (typeof value !== "bigint")
+        throw new FsError("EINVAL", { syscall: "offset" });
+    return fileOffset(value).toString();
+}
+export function decodeFileOffset(value) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 19 ||
+        (value.length > 1 && value[0] === "0") || [...value].some(char => char < "0" || char > "9")) {
+        throw new FsError("EINVAL", { syscall: "offset" });
+    }
+    return fileOffset(BigInt(value));
+}
+export function encodeObjectMetadata(value) {
+    const { atimeNs, mtimeNs, ...rest } = value;
+    const wire = {
+        ...rest,
+        ...(atimeNs === undefined ? {} : { atimeNs: encodeFileTimestamp(atimeNs) }),
+        ...(mtimeNs === undefined ? {} : { mtimeNs: encodeFileTimestamp(mtimeNs) }),
+    };
+    decodeObjectMetadata(wire);
+    return wire;
+}
+export function decodeObjectMetadata(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new FsError("EINVAL");
+    const result = {};
+    for (const [key, field] of Object.entries(value)) {
+        if (key === "atimeNs" || key === "mtimeNs") {
+            if (typeof field !== "string" || field.length === 0 || field.length > 20)
+                throw new FsError("EINVAL");
+            const digits = field.startsWith("-") ? field.slice(1) : field;
+            if (digits.length === 0 || [...digits].some(char => char < "0" || char > "9"))
+                throw new FsError("EINVAL");
+            const exact = BigInt(field);
+            if (exact.toString() !== field || exact < -9223372036854775808n || exact > 9223372036854775807n)
+                throw new FsError("EINVAL");
+            result[key] = exact;
+        }
+        else if (key === "mode" || key === "uid" || key === "gid") {
+            if (typeof field !== "number" || !Number.isSafeInteger(field) || field < 0 || field > (key === "mode" ? 0o7777 : 4294967294))
+                throw new FsError("EINVAL");
+            result[key] = field;
+        }
+        else {
+            throw new FsError("ENOTSUP");
+        }
+    }
+    return result;
+}
+/** Signed nanoseconds since Unix epoch; admit exact values before serialization. */
+export function encodeFileTimestamp(value) {
+    if (typeof value !== "bigint" || value < -9223372036854775808n || value > 9223372036854775807n)
+        throw new FsError("EINVAL");
+    return value.toString();
+}

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

@@ -0,0 +1,3 @@
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./virtual-path.js";
+export { posixPath, basename, dirname, extname, joinPath, isAbsolutePath } from "./portable-path.js";
+export type { PathLimits } from "./virtual-path.js";

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

@@ -0,0 +1,2 @@
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./virtual-path.js";
+export { posixPath, basename, dirname, extname, joinPath, isAbsolutePath } from "./portable-path.js";

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/contracts/portable-path.d.ts

@@ -0,0 +1,21 @@
+import { dirname as virtualDirname } from "./virtual-path.js";
+export declare function basename(path: string, suffix?: string): string;
+export declare const dirname: typeof virtualDirname;
+export declare function extname(path: string): string;
+export declare function isAbsolutePath(path: string): boolean;
+export declare function joinPath(...paths: string[]): string;
+declare function resolve(...paths: string[]): string;
+declare function relative(from: string, to: string): string;
+export declare const posixPath: Readonly<{
+    basename: typeof basename;
+    dirname: typeof virtualDirname;
+    extname: typeof extname;
+    join: typeof joinPath;
+    isAbsolute: typeof isAbsolutePath;
+    normalize: typeof joinPath;
+    resolve: typeof resolve;
+    relative: typeof relative;
+    sep: "/";
+    delimiter: ":";
+}>;
+export {};

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/contracts/portable-path.js

@@ -0,0 +1,78 @@
+import { dirname as virtualDirname } from "./virtual-path.js";
+function assertString(value) {
+    if (typeof value !== "string")
+        throw new TypeError("path must be a string");
+}
+export function basename(path, suffix = "") {
+    assertString(path);
+    assertString(suffix);
+    if (suffix && path === suffix)
+        return "";
+    let end = path.length;
+    while (end > 0 && path[end - 1] === "/")
+        end--;
+    if (end === 0 && suffix && suffix.length <= path.length)
+        return path;
+    const start = path.lastIndexOf("/", end - 1) + 1;
+    const base = path.slice(start, end);
+    if (suffix.length > base.length && suffix.length <= path.length && suffix.endsWith(base))
+        return path.slice(start);
+    return suffix && suffix.length < base.length && base.endsWith(suffix)
+        ? base.slice(0, -suffix.length)
+        : base;
+}
+export const dirname = virtualDirname;
+export function extname(path) {
+    const base = basename(path);
+    const position = base.lastIndexOf(".");
+    return position <= 0 || base === ".." ? "" : base.slice(position);
+}
+export function isAbsolutePath(path) {
+    assertString(path);
+    return path.startsWith("/");
+}
+export function joinPath(...paths) {
+    for (const path of paths)
+        assertString(path);
+    const joined = paths.filter(Boolean).join("/");
+    if (!joined)
+        return ".";
+    const absolute = joined.startsWith("/");
+    const components = [];
+    for (const component of joined.split("/")) {
+        if (!component || component === ".")
+            continue;
+        if (component === "..") {
+            if (components.length && components.at(-1) !== "..")
+                components.pop();
+            else if (!absolute)
+                components.push(component);
+        }
+        else
+            components.push(component);
+    }
+    const result = `${absolute ? "/" : ""}${components.join("/")}` || ".";
+    return joined.endsWith("/") && result !== "/" ? `${result}/` : result;
+}
+// Portable paths have a stable root instead of a process working directory.
+function resolve(...paths) {
+    let joined = "/";
+    for (const path of paths) {
+        assertString(path);
+        joined = path.startsWith("/") ? path : `${joined}/${path}`;
+    }
+    const normalized = joinPath(joined);
+    return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function relative(from, to) {
+    const source = resolve(from).split("/").filter(Boolean);
+    const target = resolve(to).split("/").filter(Boolean);
+    let common = 0;
+    while (common < source.length && common < target.length && source[common] === target[common])
+        common++;
+    return [...Array(source.length - common).fill(".."), ...target.slice(common)].join("/");
+}
+export const posixPath = Object.freeze({
+    basename, dirname, extname, join: joinPath, isAbsolute: isAbsolutePath,
+    normalize: joinPath, resolve, relative, sep: "/", delimiter: ":"
+});

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/contracts/virtual-path.d.ts

@@ -0,0 +1,15 @@
+export declare const MAX_PATH_BYTES: number;
+export declare const MAX_PATH_COMPONENTS: number;
+export interface PathLimits {
+    readonly maxPathBytes?: number | undefined;
+    readonly maxPathComponents?: number | undefined;
+}
+export declare function pathByteLength(path: string): number;
+export declare function validatePath(path: string, limits?: PathLimits | number): void;
+export declare function resolvePath2(cwd: string, path0: string): string;
+export declare function resolvePath(cwd: string, ...paths: string[]): string;
+export declare function normalizePath(path: string, cwd?: string): string;
+export declare function dirname(path: string): string;
+export declare function relativePath(from: string, to: string): string;
+export declare function isPathWithin(root: string, path: string): boolean;
+export declare function assertPathWithin(root: string, path: string): string;