toolcraft 0.0.749 → 0.0.751

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

@@ -0,0 +1,446 @@
+import { translatePythonOpenFlags } from './flags.js';
+import { writePythonStat } from './emscripten.js';
+const errno = {
+    EACCES: 2, EAGAIN: 6, EBADF: 8, EBUSY: 10, ECANCELED: 11, EEXIST: 20, EFBIG: 22,
+    EINTR: 27, EINVAL: 28, EIO: 29, EISDIR: 31, ELOOP: 32, EMFILE: 33,
+    ENAMETOOLONG: 37, ENFILE: 41, ENOENT: 44, ENOMEM: 48, ENOSPC: 51,
+    ENOSYS: 52, ENOTSUP: 138, EOPNOTSUPP: 138, ENOTDIR: 54, ENOTEMPTY: 55, ENOTTY: 59,
+    EOVERFLOW: 61, EPERM: 63, EPIPE: 64, ERANGE: 68, EROFS: 69, ESPIPE: 70,
+    ETIMEDOUT: 73, EXDEV: 75,
+};
+export function createPythonNativeSyscalls(options) {
+    const { runtime, signal, maxTransferBytes, runtimeMount } = options;
+    if (maxTransferBytes !== Infinity && (!Number.isSafeInteger(maxTransferBytes) || maxTransferBytes < 1))
+        throw new RangeError('Invalid native transfer limit');
+    const descriptors = new Map();
+    const closedStdio = new Set();
+    let cwd = options.cwd;
+    let closing;
+    let pending;
+    const fail = (code) => { throw { code }; };
+    const heap = () => runtime.HEAPU8;
+    const view = () => new DataView(heap().buffer, heap().byteOffset, heap().byteLength);
+    const range = (pointer, length) => {
+        if (!Number.isSafeInteger(pointer) || !Number.isSafeInteger(length) || pointer < 0 || length < 0 || pointer + length > heap().byteLength)
+            fail('EINVAL');
+    };
+    const text = (pointer) => {
+        range(pointer, 1);
+        const end = heap().indexOf(0, pointer);
+        if (end < 0)
+            fail('EINVAL');
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(heap().subarray(pointer, end));
+        }
+        catch {
+            return fail('EINVAL');
+        }
+    };
+    const integer = (value) => {
+        const number = Number(value);
+        if (!Number.isSafeInteger(number))
+            fail('EOVERFLOW');
+        return number;
+    };
+    const descriptor = (fd) => descriptors.get(fd) ?? fail('EBADF');
+    const pathAt = (fd, pointer, allowEmpty = false) => {
+        const path = text(pointer);
+        if (!path && !allowEmpty)
+            fail('ENOENT');
+        if (path.startsWith('/'))
+            return path;
+        const base = fd === -100 ? cwd : descriptor(fd).path;
+        if (fd !== -100 && path)
+            fail('ENOTDIR');
+        return path ? base + '/' + path : base;
+    };
+    const privatePath = (path) => {
+        const parts = [];
+        for (const part of path.split('/')) {
+            if (part === '..')
+                parts.pop();
+            else if (part && part !== '.')
+                parts.push(part);
+        }
+        const normalized = '/' + parts.join('/');
+        const privateNamespace = normalized === runtimeMount || normalized.startsWith(runtimeMount + '/');
+        if ((path === runtimeMount || path.startsWith(runtimeMount + '/')) && !privateNamespace)
+            fail('EACCES');
+        return privateNamespace;
+    };
+    const request = async (op, ...args) => {
+        signal.throwIfAborted();
+        const result = await options.dispatch({ op, args });
+        signal.throwIfAborted();
+        return result;
+    };
+    const original = (name, args) => options.original?.(name, args) ?? fail('ENOSYS');
+    const privateDescriptor = (fd) => {
+        const stream = runtime.FS.getStream?.(fd);
+        return !descriptors.has(fd) && typeof stream?.path === 'string' && privatePath(stream.path);
+    };
+    const allocate = (entry) => {
+        const refuse = () => fail('ENOTSUP');
+        const stream = runtime.FS.createStream({ path: entry.path, flags: entry.flags,
+            seekable: entry.seekable, position: entry.position,
+            node: { mode: 0o100000 }, stream_ops: { read: refuse, write: refuse, close: refuse } });
+        descriptors.set(stream.fd, entry);
+        return stream.fd;
+    };
+    const closeDescriptor = async (fd) => {
+        const entry = descriptor(fd);
+        descriptors.delete(fd);
+        runtime.FS.closeStream(fd);
+        if (--entry.references === 0)
+            await options.dispatch({ op: 'close', args: [entry.handle] });
+    };
+    const project = (value) => {
+        const type = value.type === 'directory' ? 0o40000 : value.type === 'symlink' ? 0o120000 : value.type === 'character' ? 0o20000 : 0o100000;
+        return { ...value, mode: value.mode | type, rdev: value.type === 'character' ? undefined : 0,
+            blksize: value.ioBlockSize ?? value.preferredIoBlockSize,
+            blocks: value.allocatedBytes === undefined ? undefined : Math.ceil(value.allocatedBytes / 512) };
+    };
+    const stat = (pointer, value) => {
+        try {
+            return writePythonStat(heap(), pointer, project(value));
+        }
+        catch {
+            return fail('EOVERFLOW');
+        }
+    };
+    const transfer = async (name, args) => {
+        const [fd, vectors, count] = args.map(integer);
+        const positioned = name === 'fd_pread' || name === 'fd_pwrite';
+        const output = integer(args[positioned ? 4 : 3]);
+        const writing = name === 'fd_write' || name === 'fd_pwrite';
+        let position = positioned ? integer(args[3]) : null;
+        range(vectors, count * 8);
+        range(output, 4);
+        if (position !== null && position < 0)
+            fail('EINVAL');
+        const entry = fd > 2 ? descriptor(fd) : undefined;
+        if (closedStdio.has(fd))
+            fail('EBADF');
+        if (!entry && (fd < 0 || positioned || (writing ? fd === 0 : fd !== 0)))
+            fail('EBADF');
+        if (entry && (entry.flags & 3) === (writing ? 0 : 1))
+            fail('EBADF');
+        if (entry && !positioned && (writing ? entry.capabilities.positionedWrite && !(entry.flags & 1024) : entry.capabilities.positionedRead))
+            position = entry.position;
+        let total = 0;
+        for (let index = 0; index < count; index++) {
+            const pointer = view().getUint32(vectors + index * 8, true);
+            const length = view().getUint32(vectors + index * 8 + 4, true);
+            range(pointer, length);
+            let offset = 0;
+            while (offset < length) {
+                const size = Math.min(length - offset, maxTransferBytes);
+                let transferred;
+                try {
+                    if (writing) {
+                        const bytes = Uint8Array.from(heap().subarray(pointer + offset, pointer + offset + size));
+                        transferred = entry ? await request('write', entry.handle, bytes, position)
+                            : (await request(fd === 1 ? 'stdout' : 'stderr', Array.from(bytes)), size);
+                    }
+                    else {
+                        const bytes = entry ? await request('read', entry.handle, size, position) : await request('stdin', size);
+                        if (!(bytes instanceof Uint8Array) && !Array.isArray(bytes) || bytes.length > size)
+                            fail('EIO');
+                        heap().set(bytes, pointer + offset);
+                        transferred = bytes.length;
+                    }
+                    if (!Number.isSafeInteger(transferred) || transferred < 0 || transferred > size)
+                        fail('EIO');
+                }
+                catch (error) {
+                    if (!total)
+                        throw error;
+                    view().setUint32(output, total, true);
+                    return 0;
+                }
+                total += transferred;
+                offset += transferred;
+                if (position !== null)
+                    position += transferred;
+                if (entry && !positioned)
+                    entry.position = writing && entry.flags & 1024
+                        ? await request('position', entry.handle) : entry.position + transferred;
+                if (transferred < size || !writing) {
+                    view().setUint32(output, total, true);
+                    return 0;
+                }
+            }
+        }
+        view().setUint32(output, total, true);
+        return 0;
+    };
+    const execute = async (name, args) => {
+        signal.throwIfAborted();
+        const first = integer(args[0] ?? 0);
+        const second = integer(args[1] ?? 0);
+        const third = integer(args[2] ?? 0);
+        const fourth = integer(args[3] ?? 0);
+        if (name.startsWith('fd_') && privateDescriptor(first)) {
+            if (name === 'fd_write' || name === 'fd_pwrite')
+                fail('EROFS');
+            return original(name, args);
+        }
+        switch (name) {
+            case '__syscall_openat': {
+                const path = pathAt(first, second);
+                if (privatePath(path)) {
+                    if ((third & 3) !== 0 || (third & (64 | 512)))
+                        fail('EROFS');
+                    return original(name, args);
+                }
+                if (fourth)
+                    range(fourth, 4);
+                const mode = (fourth ? view().getUint32(fourth, true) : 0o666) & ~(options.getUmask?.() ?? 0);
+                const openOptions = { ...translatePythonOpenFlags(third, mode), exactMode: true };
+                const handle = await options.dispatch({ op: 'open', args: [path, openOptions] });
+                try {
+                    signal.throwIfAborted();
+                    const capabilities = await request('descriptorCapabilities', handle);
+                    if ((third & 1024) && !capabilities.position)
+                        fail('ENOTSUP');
+                    const access = third & 3;
+                    const seekable = (access === 1 || capabilities.positionedRead === true)
+                        && (access === 0 || ((third & 1024) ? capabilities.position === true : capabilities.positionedWrite === true));
+                    return allocate({ handle, path, flags: third, capabilities, seekable, position: 0, references: 1 });
+                }
+                catch (error) {
+                    await options.dispatch({ op: 'close', args: [handle] }).catch(() => { });
+                    throw error;
+                }
+            }
+            case 'fd_read':
+            case 'fd_pread':
+            case 'fd_write':
+            case 'fd_pwrite': return transfer(name, args);
+            case 'fd_close':
+                if (first <= 2) {
+                    if (first < 0 || closedStdio.has(first))
+                        fail('EBADF');
+                    const status = options.original?.(name, args) ?? 0;
+                    if (status === 0)
+                        closedStdio.add(first);
+                    return status;
+                }
+                await closeDescriptor(first);
+                return 0;
+            case 'fd_seek': {
+                if (first < 0 || closedStdio.has(first))
+                    fail('EBADF');
+                if (first <= 2)
+                    fail('ESPIPE');
+                const entry = descriptor(first);
+                if (!entry.seekable)
+                    fail('ESPIPE');
+                if (third < 0 || third > 2)
+                    fail('EINVAL');
+                const position = second + (third === 0 ? 0 : third === 1 ? entry.position : (await request('fstat', entry.handle)).size);
+                if (!Number.isSafeInteger(position) || position < 0)
+                    fail('EINVAL');
+                range(fourth, 8);
+                entry.position = position;
+                view().setBigInt64(fourth, BigInt(position), true);
+                return 0;
+            }
+            case 'fd_sync':
+            case '__syscall_fdatasync':
+                await request('sync', descriptor(first).handle, name === '__syscall_fdatasync');
+                return 0;
+            case '__syscall_fstat64':
+                if (first < 0 || closedStdio.has(first))
+                    fail('EBADF');
+                if (first <= 2 || privateDescriptor(first))
+                    return original(name, args);
+                return stat(second, await request('fstat', descriptor(first).handle));
+            case '__syscall_stat64':
+            case '__syscall_lstat64': {
+                const path = pathAt(-100, first);
+                if (privatePath(path))
+                    return original(name, args);
+                return stat(second, await request(name === '__syscall_stat64' ? 'stat' : 'lstat', path));
+            }
+            case '__syscall_newfstatat': {
+                if (fourth & ~(256 | 4096))
+                    fail('EINVAL');
+                const path = pathAt(first, second, Boolean(fourth & 4096));
+                if (privatePath(path))
+                    return original(name, args);
+                return stat(third, await request(fourth & 256 ? 'lstat' : 'stat', path));
+            }
+            case '__syscall_getcwd': {
+                const bytes = new TextEncoder().encode(cwd + '\0');
+                if (!second)
+                    fail('EINVAL');
+                if (bytes.length > second)
+                    fail('ERANGE');
+                range(first, bytes.length);
+                heap().set(bytes, first);
+                return bytes.length;
+            }
+            case '__syscall_chdir': {
+                const path = pathAt(-100, first);
+                if (privatePath(path))
+                    fail('ENOTSUP');
+                const resolved = await request('realpath', path);
+                if ((await request('stat', resolved)).type !== 'directory')
+                    fail('ENOTDIR');
+                cwd = resolved;
+                runtime.FS.currentPath = cwd;
+                return 0;
+            }
+            case '__syscall_ioctl':
+                if (first < 0 || closedStdio.has(first))
+                    fail('EBADF');
+                if (first > 2 && !privateDescriptor(first))
+                    descriptor(first);
+                return fail('ENOTTY');
+            case '__syscall_fcntl64': {
+                if (first < 0 || closedStdio.has(first))
+                    fail('EBADF');
+                if (first <= 2 || privateDescriptor(first))
+                    return original(name, args);
+                const entry = descriptor(first);
+                if (second === 1 || second === 2)
+                    return 0;
+                if (second === 3)
+                    return entry.flags;
+                return fail('ENOTSUP');
+            }
+            case '__syscall_dup': {
+                const entry = descriptor(first);
+                const fd = allocate(entry);
+                entry.references++;
+                return fd;
+            }
+            case '__syscall_ftruncate64':
+                await request('ftruncate', descriptor(first).handle, second);
+                return 0;
+            case '__syscall_getdents64':
+                if (privateDescriptor(first))
+                    return original(name, args);
+                descriptor(first);
+                return fail('ENOTSUP');
+            case '__syscall_faccessat': {
+                if (fourth !== 0)
+                    fail('ENOTSUP');
+                const path = pathAt(first, second);
+                if (privatePath(path))
+                    return third & 2 ? fail('EROFS') : original(name, args);
+                await request('access', path, third);
+                return 0;
+            }
+            case '__syscall_mkdirat':
+            case '__syscall_unlinkat': {
+                const path = pathAt(first, second);
+                if (privatePath(path))
+                    fail('EROFS');
+                if (name === '__syscall_mkdirat')
+                    await request('mkdir', path, { mode: third & 0o7777 & ~(options.getUmask?.() ?? 0), exactMode: true });
+                else {
+                    if (third !== 0 && third !== 512)
+                        fail('EINVAL');
+                    await request(third === 512 ? 'rmdir' : 'rm', path);
+                }
+                return 0;
+            }
+            case '__syscall_rmdir':
+            case '__syscall_chmod':
+            case '__syscall_truncate64': {
+                const path = pathAt(-100, first);
+                if (privatePath(path))
+                    fail('EROFS');
+                if (name === '__syscall_rmdir')
+                    await request('rmdir', path);
+                else
+                    await request(name === '__syscall_chmod' ? 'chmod' : 'truncate', path, second);
+                return 0;
+            }
+            case '__syscall_renameat': {
+                const source = pathAt(first, second);
+                const destination = pathAt(third, fourth);
+                if (privatePath(source) || privatePath(destination))
+                    fail('EROFS');
+                await request('rename', source, destination);
+                return 0;
+            }
+            case '__syscall_symlinkat': {
+                const destination = pathAt(second, third);
+                if (privatePath(destination))
+                    fail('EROFS');
+                await request('symlink', text(first), destination);
+                return 0;
+            }
+            case '__syscall_readlinkat': {
+                const path = pathAt(first, second);
+                if (privatePath(path))
+                    return original(name, args);
+                if (fourth < 1)
+                    fail('EINVAL');
+                range(third, fourth);
+                const bytes = new TextEncoder().encode(await request('readlink', path)).subarray(0, fourth);
+                heap().set(bytes, third);
+                return bytes.length;
+            }
+            default: return fail('ENOSYS');
+        }
+    };
+    return {
+        async metadata(path, follow) {
+            if (closing || pending)
+                fail('EBUSY');
+            const operation = (async () => {
+                signal.throwIfAborted();
+                if (path === '')
+                    fail('ENOENT');
+                if (typeof path === 'number' && (path < 0 || closedStdio.has(path)))
+                    fail('EBADF');
+                if (typeof path === 'number' && (path <= 2 || privateDescriptor(path)) || typeof path === 'string' && privatePath(path.startsWith('/') ? path : cwd + '/' + path)) {
+                    const value = typeof path === 'number' ? runtime.FS.fstat(path) : follow ? runtime.FS.stat(path) : runtime.FS.lstat(path);
+                    return { ...value, atimeMs: value.atime.getTime(), mtimeMs: value.mtime.getTime(), ctimeMs: value.ctime.getTime() };
+                }
+                const value = typeof path === 'number' ? await request('fstat', descriptor(path).handle)
+                    : await request(follow ? 'stat' : 'lstat', path.startsWith('/') ? path : cwd + '/' + path);
+                return project(value);
+            })();
+            pending = operation;
+            try {
+                return await operation;
+            }
+            finally {
+                pending = undefined;
+            }
+        },
+        invoke(name, args) {
+            if (closing || pending)
+                return Promise.resolve((name.startsWith('fd_') ? 1 : -1) * errno.EBUSY);
+            const operation = execute(name, args).catch(error => {
+                const code = signal.aborted ? errno.ECANCELED : errno[error?.code ?? ''] ?? errno.EIO;
+                return (name.startsWith('fd_') ? 1 : -1) * code;
+            });
+            pending = operation;
+            void operation.then(() => { pending = undefined; });
+            return operation;
+        },
+        close() {
+            closing ??= (async () => {
+                await pending?.catch(() => { });
+                const failures = [];
+                for (const fd of [...descriptors.keys()]) {
+                    try {
+                        await closeDescriptor(fd);
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                }
+                if (failures.length)
+                    throw new AggregateError(failures, 'Native Python descriptor cleanup failed');
+            })();
+            return closing;
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { PythonFsRequest } from "./filesystem.js";
+export declare function parsePythonFsRequest(value: unknown, maxTransferBytes: number): PythonFsRequest;

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

@@ -0,0 +1,61 @@
+import { FsError } from "../contracts/errors.js";
+const argumentKinds = {
+    open: ["string", "object"], read: ["number", "number", "position"], write: ["number", "bytes", "position"],
+    descriptorCapabilities: ["number"], fstat: ["number"], close: ["number"], position: ["number"], ftruncate: ["number", "number"], sync: ["number", "boolean"],
+    stat: ["string"], lstat: ["string"], readdir: ["string"], realpath: ["string"], readlink: ["string"], rm: ["string"], rmdir: ["string"], rmtree: ["string"], rmtreeSupported: ["string"],
+    rename: ["string", "string"], symlink: ["string", "string"], link: ["string", "string"], mkdir: ["string", "optionalObject"],
+    chmod: ["string", "number"], truncate: ["string", "number"], access: ["string", "number"], utimes: ["string", "number", "number"],
+};
+export function parsePythonFsRequest(value, maxTransferBytes) {
+    if (!value || typeof value !== "object" || Reflect.ownKeys(value).some(key => key !== "op" && key !== "args"))
+        throw new FsError("EINVAL");
+    const op = Object.getOwnPropertyDescriptor(value, "op")?.value;
+    const args = Object.getOwnPropertyDescriptor(value, "args")?.value;
+    if (typeof op !== "string" || !Object.hasOwn(argumentKinds, op))
+        throw new FsError("ENOTSUP");
+    const kinds = argumentKinds[op];
+    if (!Array.isArray(args) || args.length > kinds.length || args.length < kinds.length - (kinds.at(-1) === "optionalObject" ? 1 : 0))
+        throw new FsError("EINVAL", { syscall: op });
+    const selected = [];
+    for (let index = 0; index < kinds.length; index++) {
+        const kind = kinds[index];
+        const descriptor = Object.getOwnPropertyDescriptor(args, String(index));
+        if (descriptor && !Object.hasOwn(descriptor, "value"))
+            throw new FsError("EINVAL", { syscall: op });
+        const argument = descriptor?.value;
+        if (kind === "bytes") {
+            if (!(argument instanceof Uint8Array) && !Array.isArray(argument))
+                throw new FsError("EINVAL", { syscall: op });
+            if (argument.length > maxTransferBytes)
+                throw new FsError("EFBIG", { syscall: op });
+            const owned = new Uint8Array(argument.length);
+            for (let byteIndex = 0; byteIndex < argument.length; byteIndex++) {
+                const entry = Object.getOwnPropertyDescriptor(argument, String(byteIndex));
+                const byte = entry?.value;
+                if (!entry || !Object.hasOwn(entry, "value") || typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255)
+                    throw new FsError("EINVAL", { syscall: op });
+                owned[byteIndex] = byte;
+            }
+            selected.push(owned);
+            continue;
+        }
+        if (kind === "position" ? argument !== null && typeof argument !== "number"
+            : kind === "optionalObject" ? argument !== undefined && (typeof argument !== "object" || argument === null || Array.isArray(argument))
+                : kind === "object" ? typeof argument !== "object" || argument === null || Array.isArray(argument)
+                    : typeof argument !== kind)
+            throw new FsError("EINVAL", { syscall: op });
+        if (argument !== null && typeof argument === "object") {
+            const snapshot = {};
+            for (const key of Reflect.ownKeys(argument)) {
+                const field = Object.getOwnPropertyDescriptor(argument, key);
+                if (typeof key !== "string" || !field || !Object.hasOwn(field, "value"))
+                    throw new FsError("EINVAL", { syscall: op });
+                Object.defineProperty(snapshot, key, { value: field.value, enumerable: true });
+            }
+            selected.push(snapshot);
+        }
+        else
+            selected.push(argument);
+    }
+    return { op, args: selected };
+}

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

@@ -0,0 +1,8 @@
+import type { FileStat } from "../contracts/filesystem.js";
+export type PythonWireStat = Omit<FileStat, "identityScope">;
+/** Invocation-local device numbers qualify canonical scope/dev without serializing opaque authority. */
+export declare class PythonStatTranslator {
+    #private;
+    constructor(maxDevices?: number);
+    translate(stat: FileStat): PythonWireStat;
+}

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

@@ -0,0 +1,34 @@
+import { FsError } from "../contracts/errors.js";
+/** Invocation-local device numbers qualify canonical scope/dev without serializing opaque authority. */
+export class PythonStatTranslator {
+    #devices = new Map();
+    #maxDevices;
+    #next = 1;
+    constructor(maxDevices = Infinity) {
+        if (maxDevices !== Infinity && (!Number.isSafeInteger(maxDevices) || maxDevices < 1))
+            throw new FsError("EINVAL");
+        this.#maxDevices = maxDevices;
+    }
+    translate(stat) {
+        const { identityScope, dev, ino, ...rest } = stat;
+        if (!(typeof identityScope === "symbol" || typeof identityScope === "object" && identityScope !== null)
+            || !Number.isSafeInteger(dev) || dev < 0 || !Number.isSafeInteger(ino) || ino < 0)
+            return rest;
+        let devices = this.#devices.get(identityScope);
+        let guestDevice = devices?.get(dev);
+        if (guestDevice === undefined) {
+            if (this.#next > this.#maxDevices)
+                throw new FsError("EFBIG", { syscall: "stat", message: "Python device identity limit exceeded" });
+            // The upper half of the uint32 guest ABI is reserved for runtime devices.
+            if (this.#next >= 0x80000000)
+                throw new FsError("EFBIG", { syscall: "stat", message: "Python device identity exceeds guest ABI range" });
+            if (!devices) {
+                devices = new Map();
+                this.#devices.set(identityScope, devices);
+            }
+            guestDevice = this.#next++;
+            devices.set(dev, guestDevice);
+        }
+        return { ...rest, dev: guestDevice, ino: ino };
+    }
+}

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

@@ -0,0 +1,27 @@
+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 type { DescriptorBackend, DescriptorOpenOptions } 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";
+import type { FileSystem } from "./contracts/filesystem.js";
+export type { MemoryFileSystem, MemoryFileSystemLimits, MemoryFileSystemOptions, MemoryRedirectHandle } from "./fs/memory/index.js";
+export declare function isUnmodifiedMemoryFileSystem(fs: FileSystem): boolean;
+export declare function isCleanAbsolutePath(p: string): boolean;
+export declare function tryGetMemoryDirectoryEntryNamesSync(fs: FileSystem, path: string): any;
+export declare function tryReadMemoryFileViewSync(fs: FileSystem, path: string, maxBytes?: number, signal?: AbortSignal, captureSourceRef?: boolean, beforeRead?: () => void): Uint8Array | undefined;
+export declare function tryResolveMemoryDevicePath(fs: FileSystem, path: string, followFinal?: boolean): string | undefined;
+export * from "./fs/devices/index.js";
+export { retargetScopedFileSystem, scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export type { RetainedFileSystemCleanupView, RetainedFileSystemCleanupOptions } from "./fs/scoped.js";
+export { compareEntries, registerEntryView } from "./fs/mount/comparison.js";
+export type { EntryViewResolver } from "./fs/mount/comparison.js";
+export type { ConditionalMutationBinding } from "./fs/memory/index.js";
+export declare function bindConditionalMutation<Result>(identityScope: object | symbol | undefined, binding: any, action: () => Promise<Result>): Promise<Result>;
+export declare function tryOpenMemoryRedirectHandleSync(fs: FileSystem, path: string, append: boolean, mode: number, signal?: AbortSignal): any;
+export declare function tryWriteMemoryFileSync(fs: FileSystem, path: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;
+export declare function tryMkdirMemorySync(fs: FileSystem, path: string, recursive: boolean, mode: number, signal?: AbortSignal, dirPrefixHint?: string): boolean;
+export declare function tryRmRfMemorySync(fs: FileSystem, path: string, signal?: AbortSignal): boolean;
+export declare function tryWriteMemoryFileInDirSync(fs: FileSystem, dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;

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

@@ -0,0 +1,57 @@
+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));
+}

package/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[];