@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/runtime-core.js

@@ -0,0 +1,58 @@
+export * from "./contracts/errors.js";
+export * from "./contracts/filesystem.js";
+export * from "./contracts/io.js";
+export { compareIdentity, compareFileVersion } from "./fs/mount/identity.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./contracts/virtual-path.js";
+export { basename, dirname, extname, isAbsolutePath, joinPath, posixPath } from "./contracts/portable-path.js";
+const _getMemHooks = () => globalThis.__safeBashMemHooks;
+export function isUnmodifiedMemoryFileSystem(fs) {
+    const proto = Object.getPrototypeOf(fs);
+    if (!proto || !_getMemHooks()?.protos?.has(proto))
+        return false;
+    return Object.getOwnPropertyNames(fs).every(name => {
+        const method = Object.getOwnPropertyDescriptor(proto, name)?.value;
+        return typeof method !== "function" || Object.getOwnPropertyDescriptor(fs, name)?.value === method;
+    }) && Object.getOwnPropertyNames(proto).every(name => {
+        const method = Object.getOwnPropertyDescriptor(proto, name)?.value;
+        return typeof method !== "function" || Reflect.get(fs, name) === method;
+    });
+}
+export function isCleanAbsolutePath(p) {
+    const fn = _getMemHooks()?.isCleanAbsolutePath;
+    if (fn)
+        return fn(p);
+    return p.length > 0 && p.charCodeAt(0) === 47 && !p.includes("//") && !p.includes("/.") && (p.length === 1 || p.charCodeAt(p.length - 1) !== 47);
+}
+export function tryGetMemoryDirectoryEntryNamesSync(fs, path) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryGetMemoryDirectoryEntryNamesSync)?.(fs, path);
+}
+export function tryReadMemoryFileViewSync(fs, path, maxBytes, signal, captureSourceRef, beforeRead) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryReadMemoryFileViewSync)?.(fs, path, maxBytes, signal, captureSourceRef, beforeRead);
+}
+export function tryResolveMemoryDevicePath(fs, path, followFinal) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryResolveMemoryDevicePath)?.(fs, path, followFinal);
+}
+export * from "./fs/devices/index.js";
+export { retargetScopedFileSystem, scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export { compareEntries, registerEntryView } from "./fs/mount/comparison.js";
+export async function bindConditionalMutation(identityScope, binding, action) {
+    const fn = _getMemHooks()?.bindConditionalMutation;
+    return fn ? fn(identityScope, binding, action) : action();
+}
+export function tryOpenMemoryRedirectHandleSync(fs, path, append, mode, signal) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryOpenMemoryRedirectHandleSync)?.(fs, path, append, mode, signal);
+}
+export function tryWriteMemoryFileSync(fs, path, data, append, mode, signal) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryWriteMemoryFileSync)?.(fs, path, data, append, mode, signal));
+}
+export function tryMkdirMemorySync(fs, path, recursive, mode, signal, dirPrefixHint) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryMkdirMemorySync)?.(fs, path, recursive, mode, signal, dirPrefixHint));
+}
+export function tryRmRfMemorySync(fs, path, signal) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryRmRfMemorySync)?.(fs, path, signal));
+}
+export function tryWriteMemoryFileInDirSync(fs, dirPrefix, name, data, append, mode, signal) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryWriteMemoryFileInDirSync)?.(fs, dirPrefix, name, data, append, mode, signal));
+}
+export { readFileStream } from "./fs/read-file-stream.js";

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

@@ -0,0 +1,81 @@
+import type { FileSystem } from "./contracts/filesystem.js";
+export interface PagedStorageContext {
+    readonly fs: FileSystem;
+    readonly cwd: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly signal: AbortSignal;
+}
+type Page = {
+    bytes: Uint8Array;
+    dirty: boolean;
+};
+/** Shares one resident-page limit across stores, retaining each store's caller
+ * filesystem and cleanup ownership. Serializes cache users through eviction IO. */
+export declare class PagedStorageCache {
+    private readonly maxPages;
+    readonly pageBytes: number;
+    private readonly pages;
+    private active;
+    constructor(maxPages: number, pageBytes?: number);
+    get residentBytes(): number;
+    run<T>(action: () => Promise<T>): Promise<T>;
+    acquire(): Promise<Page>;
+    retain(page: Page, release: () => Promise<void>): void;
+    touch(page: Page): void;
+    forget(page: Page): void;
+}
+/** A bounded page cache backed only by the caller filesystem. The default is
+ * one MiB; callers own close() on every outcome. Memory filesystems still retain
+ * spilled data in RAM, so large workloads require an external backing provider. */
+export declare class PagedStorage {
+    private readonly context;
+    private readonly maxPages;
+    private readonly cache?;
+    private readonly pages;
+    private readonly pageBytes;
+    private readonly controller;
+    private readonly signal;
+    private descriptor;
+    private parent;
+    private initial;
+    private path;
+    private diskLength;
+    private unlinked;
+    private end;
+    private active;
+    private closing;
+    constructor(context: PagedStorageContext, maxPages?: number, cache?: PagedStorageCache | undefined);
+    allocate(length: number): number;
+    /** Acquire and unlink backing storage before observing a directory snapshot. */
+    prepare(): Promise<void>;
+    private operation;
+    private spill;
+    private flush;
+    private page;
+    write(position: number, bytes: Uint8Array): Promise<void>;
+    append(bytes: Uint8Array): Promise<number>;
+    read(position: number, length: number): Promise<Uint8Array>;
+    close(): Promise<void>;
+}
+/** Fixed-depth radix index: both dense and sparse 64-bit keys use bounded RAM. */
+export declare class IntegerTable {
+    private readonly storage;
+    private readonly maxEntries;
+    private root;
+    private revision;
+    private readonly branches;
+    private readonly cache;
+    constructor(storage: Pick<PagedStorage, "allocate" | "read" | "write">, maxEntries?: number);
+    private retain;
+    get(key: bigint): Promise<bigint | undefined>;
+    set(key: bigint, value: bigint): Promise<void>;
+    /** Ordered replay with a fixed 16-level radix stack (at most 2 KiB of
+     * owned node bytes) and 128 output records. Batches avoid alternating sparse
+     * index reads with consumer writes on every record. Mutation is not permitted. */
+    entries(start?: bigint, end?: bigint): AsyncGenerator<readonly [bigint, bigint]>;
+    /** Hot radix paths must not evict dirty leaf pages in a one-page backend. */
+    private branch;
+    private lookup;
+    private persist;
+}
+export {};

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

@@ -0,0 +1,430 @@
+import { FsError, isFsError } from "./contracts/errors.js";
+const defaultPageBytes = 16 * 1024;
+let serial = 0;
+/** Shares one resident-page limit across stores, retaining each store's caller
+ * filesystem and cleanup ownership. Serializes cache users through eviction IO. */
+export class PagedStorageCache {
+    maxPages;
+    pageBytes;
+    pages = new Map();
+    active = Promise.resolve();
+    constructor(maxPages, pageBytes = defaultPageBytes) {
+        this.maxPages = maxPages;
+        this.pageBytes = pageBytes;
+        if (!Number.isSafeInteger(pageBytes) || pageBytes < defaultPageBytes || pageBytes > 1024 * 1024 || pageBytes % defaultPageBytes !== 0)
+            throw new RangeError("Invalid storage page size");
+        if (!Number.isSafeInteger(maxPages) || maxPages < 1)
+            throw new RangeError("Invalid storage page cache size");
+    }
+    get residentBytes() { return this.pages.size * this.pageBytes; }
+    run(action) {
+        const work = this.active.then(action);
+        this.active = work.then(() => undefined, () => undefined);
+        return work;
+    }
+    async acquire() {
+        if (this.pages.size < this.maxPages)
+            return { bytes: new Uint8Array(this.pageBytes), dirty: false };
+        const [page, release] = this.pages.entries().next().value;
+        await release();
+        this.pages.delete(page);
+        page.bytes.fill(0);
+        return page;
+    }
+    retain(page, release) {
+        this.pages.delete(page);
+        this.pages.set(page, release);
+    }
+    touch(page) {
+        const release = this.pages.get(page);
+        this.pages.delete(page);
+        this.pages.set(page, release);
+    }
+    forget(page) { this.pages.delete(page); }
+}
+/** A bounded page cache backed only by the caller filesystem. The default is
+ * one MiB; callers own close() on every outcome. Memory filesystems still retain
+ * spilled data in RAM, so large workloads require an external backing provider. */
+export class PagedStorage {
+    context;
+    maxPages;
+    cache;
+    pages = new Map();
+    pageBytes;
+    controller = new AbortController();
+    signal;
+    descriptor;
+    parent;
+    initial;
+    path;
+    diskLength = 0;
+    unlinked = false;
+    end = 8; // Zero is the absent-pointer sentinel.
+    active = Promise.resolve();
+    closing;
+    constructor(context, maxPages = 64, cache) {
+        this.context = context;
+        this.maxPages = maxPages;
+        this.cache = cache;
+        if (!Number.isSafeInteger(maxPages) || maxPages < 1)
+            throw new RangeError("Invalid storage page cache size");
+        this.pageBytes = cache?.pageBytes ?? defaultPageBytes;
+        this.signal = AbortSignal.any([context.signal, this.controller.signal]);
+    }
+    allocate(length) {
+        this.signal.throwIfAborted();
+        if (!Number.isSafeInteger(length) || length < 0 || length > Number.MAX_SAFE_INTEGER - this.end)
+            throw new FsError("EFBIG");
+        const offset = this.end;
+        this.end += length;
+        return offset;
+    }
+    /** Acquire and unlink backing storage before observing a directory snapshot. */
+    async prepare() {
+        await this.operation(async () => { if (!this.descriptor)
+            await this.spill(); });
+    }
+    operation(action) {
+        this.signal.throwIfAborted();
+        const execute = () => {
+            this.signal.throwIfAborted();
+            return action();
+        };
+        const work = this.active.then(() => this.cache ? this.cache.run(execute) : execute());
+        this.active = work.then(() => undefined, () => undefined);
+        return work;
+    }
+    async spill() {
+        const { fs, cwd, env } = this.context;
+        if (!fs.open || !fs.removeFileConditional)
+            throw new FsError("ENOTSUP", { message: "spill storage requires retained read/write handles and conditional removal" });
+        const selected = env.TMPDIR || cwd;
+        const directory = selected.startsWith("/") ? selected : `${cwd}/${selected}`;
+        this.parent = await fs.stat(directory, { signal: this.signal });
+        this.signal.throwIfAborted();
+        if (this.parent.type !== "directory")
+            throw new FsError("ENOTDIR", { path: directory });
+        for (let attempt = 0; attempt < 128; attempt++) {
+            const path = `${directory.endsWith("/") ? directory : directory + "/"}.storage-${++serial}`;
+            try {
+                this.descriptor = await fs.open(path, { access: "readwrite", creation: "exclusive", mode: 0o600, signal: this.signal });
+                this.path = path;
+                break;
+            }
+            catch (error) {
+                this.signal.throwIfAborted();
+                if (!isFsError(error) || error.code !== "EEXIST")
+                    throw error;
+            }
+        }
+        if (!this.descriptor)
+            throw new FsError("EEXIST", { path: directory });
+        // Retain the acquisition receipt even if cancellation wins immediately after open.
+        this.initial = await this.descriptor.stat();
+        this.signal.throwIfAborted();
+        if (!this.descriptor.capabilities.positionedRead || !this.descriptor.capabilities.positionedWrite)
+            throw new FsError("ENOTSUP");
+        // Detach the name before storing input. A later output or random-source path
+        // cannot alias our scratch file; the retained descriptor owns its lifetime.
+        await fs.removeFileConditional(this.path, { parent: this.parent, expected: this.initial, signal: this.signal });
+        this.unlinked = true;
+        for (const [number, page] of this.pages)
+            await this.flush(number, page);
+    }
+    async flush(number, page) {
+        if (!page.dirty)
+            return;
+        let offset = 0;
+        while (offset < this.pageBytes) {
+            this.signal.throwIfAborted();
+            const count = await this.descriptor.write(page.bytes.subarray(offset), number * this.pageBytes + offset, { signal: this.signal });
+            this.signal.throwIfAborted();
+            if (!Number.isSafeInteger(count) || count <= 0 || count > this.pageBytes - offset)
+                throw new FsError("EIO");
+            offset += count;
+        }
+        this.diskLength = Math.max(this.diskLength, (number + 1) * this.pageBytes);
+        page.dirty = false;
+    }
+    async page(number) {
+        this.signal.throwIfAborted();
+        const cached = this.pages.get(number);
+        if (cached) {
+            this.pages.delete(number);
+            this.pages.set(number, cached);
+            this.cache?.touch(cached);
+            return cached;
+        }
+        let reusable;
+        if (this.pages.size === this.maxPages) {
+            if (!this.descriptor)
+                await this.spill();
+            const [oldNumber, oldPage] = this.pages.entries().next().value;
+            await this.flush(oldNumber, oldPage);
+            this.pages.delete(oldNumber);
+            this.cache?.forget(oldPage);
+            reusable = oldPage;
+        }
+        // Flush owns the bytes until its awaited write completes. Reuse only then;
+        // zero new/unwritten ranges so the previous page cannot leak into them.
+        const page = reusable ?? (this.cache ? await this.cache.acquire() : { bytes: new Uint8Array(this.pageBytes), dirty: false });
+        // Shared eviction may await IO owned by a different, still-live signal.
+        this.signal.throwIfAborted();
+        if (reusable)
+            page.bytes.fill(0);
+        if (number * this.pageBytes < this.diskLength) {
+            let offset = 0;
+            while (offset < this.pageBytes) {
+                const count = await this.descriptor.read(page.bytes.subarray(offset), number * this.pageBytes + offset, { signal: this.signal });
+                this.signal.throwIfAborted();
+                if (!Number.isSafeInteger(count) || count <= 0 || count > this.pageBytes - offset)
+                    throw new FsError("EIO");
+                offset += count;
+            }
+        }
+        this.pages.set(number, page);
+        this.cache?.retain(page, async () => {
+            if (!this.descriptor)
+                await this.spill();
+            await this.flush(number, page);
+            this.pages.delete(number);
+        });
+        return page;
+    }
+    write(position, bytes) {
+        if (!Number.isSafeInteger(position) || position < 8 || position + bytes.length > this.end)
+            throw new RangeError("Invalid paged storage range");
+        return this.operation(async () => {
+            for (let offset = 0; offset < bytes.length;) {
+                const target = position + offset;
+                const page = await this.page(Math.floor(target / this.pageBytes));
+                const count = Math.min(bytes.length - offset, this.pageBytes - target % this.pageBytes);
+                page.bytes.set(bytes.subarray(offset, offset + count), target % this.pageBytes);
+                page.dirty = true;
+                offset += count;
+            }
+        });
+    }
+    async append(bytes) {
+        const position = this.allocate(bytes.length);
+        await this.write(position, bytes);
+        return position;
+    }
+    read(position, length) {
+        if (!Number.isSafeInteger(position) || position < 8 || !Number.isSafeInteger(length) || length < 0 || length > defaultPageBytes || position + length > this.end)
+            throw new RangeError("Invalid paged storage range");
+        return this.operation(async () => {
+            const bytes = new Uint8Array(length);
+            for (let offset = 0; offset < length;) {
+                const source = position + offset;
+                const page = await this.page(Math.floor(source / this.pageBytes));
+                const count = Math.min(length - offset, this.pageBytes - source % this.pageBytes);
+                bytes.set(page.bytes.subarray(source % this.pageBytes, source % this.pageBytes + count), offset);
+                offset += count;
+            }
+            return bytes;
+        });
+    }
+    close() {
+        this.controller.abort(new FsError("ECANCELED"));
+        return this.closing ??= (async () => {
+            await this.active.catch(() => { });
+            const retire = async () => {
+                for (const page of this.pages.values())
+                    this.cache?.forget(page);
+                this.pages.clear();
+                const descriptor = this.descriptor;
+                if (!descriptor)
+                    return;
+                const cancellation = new FsError("ECANCELED");
+                try {
+                    if (!this.unlinked) {
+                        const expected = this.initial ?? await descriptor.stat();
+                        await this.context.fs.removeFileConditional(this.path, { parent: this.parent, expected }).catch(error => {
+                            if (!isFsError(error) || error.code !== "ENOENT")
+                                throw error;
+                        });
+                    }
+                }
+                finally {
+                    // Conditional descriptors must discard their private staged writes, not
+                    // publish the scratch data when the command retires its handle.
+                    await descriptor.close({ signal: AbortSignal.abort(cancellation) }).catch(error => {
+                        if (error !== cancellation)
+                            throw error;
+                    });
+                }
+            };
+            await (this.cache ? this.cache.run(retire) : retire());
+        })();
+    }
+}
+/** Fixed-depth radix index: both dense and sparse 64-bit keys use bounded RAM. */
+export class IntegerTable {
+    storage;
+    maxEntries;
+    root = 0;
+    revision = 0;
+    branches = new Map();
+    cache = new Map();
+    constructor(storage, maxEntries = 4096) {
+        this.storage = storage;
+        this.maxEntries = maxEntries;
+        if (!Number.isSafeInteger(maxEntries) || maxEntries < 1)
+            throw new RangeError("Invalid integer table cache size");
+    }
+    async retain(key, value, dirty) {
+        if (this.cache.size === this.maxEntries && !this.cache.has(key)) {
+            const [oldKey, old] = this.cache.entries().next().value;
+            // Flush the bounded dirty window together, before the caller touches other
+            // stored data. One dirty leaf per insertion otherwise thrashes a page cache.
+            if (old.dirty)
+                for (const [key, entry] of this.cache)
+                    if (entry.dirty) {
+                        await this.persist(key, entry.value);
+                        entry.dirty = false;
+                    }
+            this.cache.delete(oldKey);
+        }
+        this.cache.delete(key);
+        this.cache.set(key, { value, dirty });
+    }
+    async get(key) {
+        const cached = this.cache.get(key);
+        if (cached) {
+            this.cache.delete(key);
+            this.cache.set(key, cached);
+            return cached.value;
+        }
+        const value = await this.lookup(key);
+        if (value !== undefined)
+            await this.retain(key, value, false);
+        return value;
+    }
+    async set(key, value) {
+        if (key < 0n || key > 0xffffffffffffffffn || value < 0n || value >= 0xffffffffffffffffn)
+            throw new RangeError("Invalid storage integer table value");
+        this.revision++;
+        await this.retain(key, value, true);
+    }
+    /** Ordered replay with a fixed 16-level radix stack (at most 2 KiB of
+     * owned node bytes) and 128 output records. Batches avoid alternating sparse
+     * index reads with consumer writes on every record. Mutation is not permitted. */
+    async *entries(start = 0n, end = 0x10000000000000000n) {
+        if (start < 0n || start > end || end > 0x10000000000000000n)
+            throw new RangeError("Invalid integer table range");
+        if (start === end)
+            return;
+        const revision = this.revision;
+        const check = () => { if (revision !== this.revision)
+            throw new Error("Integer table changed during iteration"); };
+        for (const [key, entry] of this.cache)
+            if (entry.dirty) {
+                check();
+                await this.persist(key, entry.value);
+                check();
+                entry.dirty = false;
+            }
+        const storage = this.storage;
+        async function* visit(position, shift, prefix) {
+            check();
+            if (!position)
+                return;
+            const bytes = new Uint8Array(await storage.read(position, 128));
+            check();
+            if (bytes.length !== 128)
+                throw new RangeError("Truncated integer table node");
+            const node = new DataView(bytes.buffer);
+            for (let slot = 0; slot < 16; slot++) {
+                check();
+                const value = node.getBigUint64(slot * 8, true);
+                if (!value)
+                    continue;
+                const key = prefix | BigInt(slot) << shift;
+                if (key >= end || key + (1n << shift) <= start)
+                    continue;
+                if (shift === 0n)
+                    yield [key, value - 1n];
+                else
+                    yield* visit(Number(value), shift - 4n, key);
+            }
+        }
+        const batch = [];
+        for await (const entry of visit(this.root, 60n, 0n)) {
+            batch.push(entry);
+            if (batch.length === 128) {
+                for (const entry of batch) {
+                    check();
+                    yield entry;
+                }
+                batch.length = 0;
+            }
+        }
+        for (const entry of batch) {
+            check();
+            yield entry;
+        }
+        check();
+    }
+    /** Hot radix paths must not evict dirty leaf pages in a one-page backend. */
+    branch(key, shift, position) {
+        const prefix = key >> shift | 1n << (64n - shift);
+        const value = position ?? this.branches.get(prefix);
+        if (value !== undefined) {
+            this.branches.delete(prefix);
+            this.branches.set(prefix, value);
+            if (this.branches.size > 128)
+                this.branches.delete(this.branches.keys().next().value);
+        }
+        return value;
+    }
+    async lookup(key) {
+        let node = this.root;
+        for (let shift = 60n; shift >= 0n; shift -= 4n) {
+            if (!node)
+                return undefined;
+            const cached = shift === 0n ? undefined : this.branch(key, shift);
+            if (cached !== undefined) {
+                node = cached;
+                continue;
+            }
+            const slot = node + Number((key >> shift) & 15n) * 8;
+            const bytes = await this.storage.read(slot, 8);
+            const value = new DataView(bytes.buffer, bytes.byteOffset, 8).getBigUint64(0, true);
+            if (shift === 0n)
+                return value === 0n ? undefined : value - 1n;
+            node = Number(value);
+            if (node)
+                this.branch(key, shift, node);
+        }
+        return undefined;
+    }
+    async persist(key, value) {
+        if (!this.root)
+            this.root = this.storage.allocate(128);
+        let node = this.root;
+        for (let shift = 60n; shift >= 0n; shift -= 4n) {
+            const cached = shift === 0n ? undefined : this.branch(key, shift);
+            if (cached !== undefined) {
+                node = cached;
+                continue;
+            }
+            const slot = node + Number((key >> shift) & 15n) * 8;
+            const bytes = await this.storage.read(slot, 8);
+            const view = new DataView(bytes.buffer, bytes.byteOffset, 8);
+            if (shift === 0n) {
+                view.setBigUint64(0, value + 1n, true);
+                await this.storage.write(slot, bytes);
+                return;
+            }
+            let child = Number(view.getBigUint64(0, true));
+            if (!child) {
+                child = this.storage.allocate(128);
+                view.setBigUint64(0, BigInt(child), true);
+                await this.storage.write(slot, bytes);
+            }
+            node = child;
+            this.branch(key, shift, child);
+        }
+    }
+}

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/testing/atomic-filesystem.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+export interface AtomicFileSystemConformanceFixture {
+    readonly fs: FileSystem;
+    readonly peer?: FileSystem;
+    readonly root: string;
+    dispose(): void | Promise<void>;
+}
+export interface AtomicFileSystemConformanceOptions {
+    readonly createFixture: () => AtomicFileSystemConformanceFixture | Promise<AtomicFileSystemConformanceFixture>;
+    readonly includeSymlinks?: boolean;
+}
+export interface AtomicFileSystemConformanceCase {
+    readonly name: string;
+    run(): Promise<void>;
+}
+export declare function createAtomicFileSystemConformance(options: AtomicFileSystemConformanceOptions): readonly AtomicFileSystemConformanceCase[];