toolcraft 0.0.749 → 0.0.751

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

@@ -0,0 +1,162 @@
+import { FsError } from "./errors.js";
+export const MAX_PATH_BYTES = Infinity;
+export const MAX_PATH_COMPONENTS = Infinity;
+export function pathByteLength(path) {
+    let bytes = 0;
+    for (const point of path) {
+        const code = point.codePointAt(0);
+        bytes += code <= 0x7f ? 1 : code <= 0x7ff ? 2 : code <= 0xffff ? 3 : 4;
+    }
+    return bytes;
+}
+export function validatePath(path, limits = {}) {
+    const maxBytes = typeof limits === "number" ? Infinity : limits.maxPathBytes ?? Infinity;
+    const maxComponents = typeof limits === "number" ? limits : limits.maxPathComponents ?? Infinity;
+    for (const value of [maxBytes, maxComponents]) {
+        if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new RangeError("Path limits must be nonnegative safe integers or Infinity");
+        }
+    }
+    if (typeof path !== "string" || path.includes("\0")) {
+        throw new FsError("EINVAL", { syscall: "resolve", message: "paths must be strings without NUL bytes" });
+    }
+    if (maxBytes !== Infinity && pathByteLength(path) > maxBytes) {
+        throw new FsError("ENAMETOOLONG", { syscall: "resolve", path });
+    }
+    if (maxComponents === Infinity)
+        return;
+    const limit = maxComponents;
+    let components = 0;
+    let inComponent = false;
+    for (let i = 0; i < path.length; i++) {
+        if (path.charCodeAt(i) === 47) {
+            inComponent = false;
+        }
+        else if (!inComponent) {
+            inComponent = true;
+            if (++components > limit) {
+                throw new FsError("ENAMETOOLONG", { syscall: "resolve", path });
+            }
+        }
+    }
+}
+function isFastCleanAbsPath(path) {
+    const len = path.length;
+    if (len === 0 || path.charCodeAt(0) !== 47)
+        return false;
+    if (len === 1)
+        return true;
+    if (path.charCodeAt(len - 1) === 47)
+        return false;
+    let segStart = 1;
+    for (let i = 1; i < len; i++) {
+        const c = path.charCodeAt(i);
+        if (c === 0)
+            return false;
+        if (c === 47) {
+            const segLen = i - segStart;
+            if (segLen === 0)
+                return false;
+            if (segLen === 1 && path.charCodeAt(segStart) === 46)
+                return false;
+            if (segLen === 2 && path.charCodeAt(segStart) === 46 && path.charCodeAt(segStart + 1) === 46)
+                return false;
+            segStart = i + 1;
+        }
+    }
+    const lastLen = len - segStart;
+    if (lastLen === 1 && path.charCodeAt(segStart) === 46)
+        return false;
+    if (lastLen === 2 && path.charCodeAt(segStart) === 46 && path.charCodeAt(segStart + 1) === 46)
+        return false;
+    return true;
+}
+function resolvePathSlow(cwd, paths) {
+    const argLen = paths.length + 1;
+    const components = [];
+    for (let a = 0; a < argLen; a++) {
+        const path = a === 0 ? cwd : paths[a - 1];
+        if (a > 0)
+            validatePath(path);
+        if (path.startsWith("/"))
+            components.length = 0;
+        for (const component of path.split("/")) {
+            if (component === "" || component === ".")
+                continue;
+            if (component === "..")
+                components.pop();
+            else
+                components.push(component);
+        }
+    }
+    return `/${components.join("/")}`;
+}
+export function resolvePath2(cwd, path0) {
+    validatePath(cwd);
+    if (cwd.charCodeAt(0) !== 47)
+        throw new FsError("EINVAL", { syscall: "resolve", path: cwd, message: "cwd must be absolute" });
+    validatePath(path0);
+    if (isFastCleanAbsPath(path0))
+        return path0;
+    if (isFastCleanAbsPath(cwd) && path0.length > 0 && path0.charCodeAt(0) !== 47 && !path0.includes("/")) {
+        if (path0 === ".")
+            return cwd;
+        if (path0 !== "..")
+            return cwd === "/" ? `/${path0}` : `${cwd}/${path0}`;
+    }
+    return resolvePathSlow(cwd, [path0]);
+}
+export function resolvePath(cwd, ...paths) {
+    validatePath(cwd);
+    if (!cwd.startsWith("/"))
+        throw new FsError("EINVAL", { syscall: "resolve", path: cwd, message: "cwd must be absolute" });
+    const argLen = paths.length + 1;
+    if (argLen === 1) {
+        if (isFastCleanAbsPath(cwd))
+            return cwd;
+        return resolvePathSlow(cwd, paths);
+    }
+    if (argLen === 2) {
+        return resolvePath2(cwd, paths[0]);
+    }
+    return resolvePathSlow(cwd, paths);
+}
+export function normalizePath(path, cwd = "/") {
+    return resolvePath2(cwd, path);
+}
+export function dirname(path) {
+    if (typeof path !== "string")
+        throw new TypeError("path must be a string");
+    let end = path.length;
+    while (end > 0 && path[end - 1] === "/")
+        end--;
+    if (end === 0)
+        return path.startsWith("/") ? "/" : ".";
+    const boundary = path.lastIndexOf("/", end - 1);
+    if (boundary < 0)
+        return ".";
+    if (boundary === 0)
+        return "/";
+    if (boundary === 1 && path.startsWith("/"))
+        return "//";
+    return path.slice(0, boundary);
+}
+export function relativePath(from, to) {
+    const source = normalizePath(from).split("/").filter(Boolean);
+    const target = normalizePath(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 function isPathWithin(root, path) {
+    const normalizedRoot = normalizePath(root);
+    const normalizedPath = normalizePath(path);
+    return normalizedRoot === "/" || normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+export function assertPathWithin(root, path) {
+    const normalizedPath = normalizePath(path);
+    if (!isPathWithin(root, normalizedPath))
+        throw new FsError("EACCES", { syscall: "resolve", path, message: "path escapes the allowed root" });
+    return normalizedPath;
+}

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

@@ -0,0 +1,19 @@
+export * from "./runtime-core.js";
+export { MemoryFileSystem, MemoryRedirectHandle, createMemoryFileSystem, defaultMemoryFileSystemLimits, bindConditionalMutation, getLastReadMemoryFileSourceRef, isCleanAbsolutePath, tryGetMemoryDirectoryEntryNamesSync, tryMkdirMemorySync, tryOpenMemoryRedirectHandleSync, tryReadMemoryFileViewSync, tryResolveMemoryDevicePath, tryRmRfMemorySync, tryWriteMemoryFileInDirSync, tryWriteMemoryFileSync, utf8ByteLength } from "./fs/memory/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./fs/quota/index.js";
+export * from "./fs/object-publication/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./bridge/index.js";
+export * from "./python/index.js";
+export { parseXml, parseXmlSteps, XmlLimitError } from "./xml.js";
+export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits } from "./xml.js";
+export * from "./contracts/object.js";
+export { ObjectAuthority } from "./fs/object-authority.js";
+export * from "./fs/s3/index.js";
+export * from "./fs/s3/http/index.js";
+export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
+export type { FileSystemConfig, FileSystemAdapterDescriptor, FileSystemAdapterRegistry } from "./config.js";
+export { createPortableFileSystemAdapterRegistry } from "./config.portable.js";

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

@@ -0,0 +1,17 @@
+export * from "./runtime-core.js";
+export { MemoryFileSystem, MemoryRedirectHandle, createMemoryFileSystem, defaultMemoryFileSystemLimits, bindConditionalMutation, getLastReadMemoryFileSourceRef, isCleanAbsolutePath, tryGetMemoryDirectoryEntryNamesSync, tryMkdirMemorySync, tryOpenMemoryRedirectHandleSync, tryReadMemoryFileViewSync, tryResolveMemoryDevicePath, tryRmRfMemorySync, tryWriteMemoryFileInDirSync, tryWriteMemoryFileSync, utf8ByteLength } from "./fs/memory/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./fs/quota/index.js";
+export * from "./fs/object-publication/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./bridge/index.js";
+export * from "./python/index.js";
+export { parseXml, parseXmlSteps, XmlLimitError } from "./xml.js";
+export * from "./contracts/object.js";
+export { ObjectAuthority } from "./fs/object-authority.js";
+export * from "./fs/s3/index.js";
+export * from "./fs/s3/http/index.js";
+export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
+export { createPortableFileSystemAdapterRegistry } from "./config.portable.js";

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

@@ -0,0 +1,10 @@
+import type { FsOptions, FileReadHandle, FileResizeHandle, FileSystem, FileSystemCapabilities, OpenReadFileOptions, OpenResizeFileOptions } from "../contracts/filesystem.js";
+export declare function retainedReadCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
+export declare function openRetainedReadFile(filesystem: FileSystem, path: string, options: OpenReadFileOptions): Promise<FileReadHandle>;
+export declare function requireCapabilities(...values: readonly (boolean | undefined)[]): boolean | undefined;
+export declare function retainedResizeCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
+export declare function openRetainedResizeFile(filesystem: FileSystem, path: string, options: OpenResizeFileOptions): Promise<FileResizeHandle>;
+export declare function readOnlyCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
+export declare function quotaCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
+export declare function ownedMutationCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
+export declare function requireOwnedMutation(filesystem: FileSystem, path: string, capability: "retainedStagingCleanup" | "atomicFilePublication" | "atomicEntryRemoval" | "atomicEntryRemovalReceipt" | "atomicTreeRemoval" | "atomicFileMutation" | "atomicFileStaging" | "guardedStagingPublication" | "atomicStagingAncestry" | "atomicDirectoryMetadata", options: FsOptions, create?: boolean): Promise<void>;

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

@@ -0,0 +1,216 @@
+import { FsError, toFsError } from "../contracts/errors.js";
+import { finishCleanup } from "../contracts/cleanup.js";
+import { inspectStagingBindings } from "./staging-ancestry.js";
+const signalWaiters = new WeakMap();
+function getSignalWaiters(signal) {
+    let entry = signalWaiters.get(signal);
+    if (!entry) {
+        const waiters = new Set();
+        const listener = () => {
+            signalWaiters.delete(signal);
+            signal.removeEventListener("abort", listener);
+            const pending = [...waiters];
+            waiters.clear();
+            for (const fn of pending)
+                fn();
+        };
+        entry = { waiters, listener };
+        signalWaiters.set(signal, entry);
+        signal.addEventListener("abort", listener, { once: true });
+    }
+    return entry;
+}
+function releaseSignalWaiter(signal, entry, abort) {
+    entry.waiters.delete(abort);
+    if (entry.waiters.size === 0 && signalWaiters.get(signal) === entry) {
+        signalWaiters.delete(signal);
+        signal.removeEventListener("abort", entry.listener);
+    }
+}
+function awaitWithSignal(promise, signal) {
+    if (!signal)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const entry = getSignalWaiters(signal);
+        const abort = () => { releaseSignalWaiter(signal, entry, abort); reject(signal.reason); };
+        entry.waiters.add(abort);
+        promise.then(value => { releaseSignalWaiter(signal, entry, abort); resolve(value); }, error => { releaseSignalWaiter(signal, entry, abort); reject(error); });
+        if (signal.aborted)
+            abort();
+    });
+}
+export function retainedReadCapabilities(filesystem, capabilities = filesystem.capabilities) {
+    return typeof filesystem.openReadFile === "function" ? capabilities : { ...capabilities, retainedRead: false };
+}
+export async function openRetainedReadFile(filesystem, path, options) {
+    const signal = options.signal;
+    let handle;
+    try {
+        signal?.throwIfAborted();
+        const available = typeof filesystem.openReadFile === "function";
+        signal?.throwIfAborted();
+        if (!available)
+            throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
+        const query = filesystem.capabilitiesFor;
+        signal?.throwIfAborted();
+        const metadata = Promise.resolve(query == null ? undefined : Reflect.apply(query, filesystem, [path, options]));
+        const queried = await awaitWithSignal(metadata, signal);
+        signal?.throwIfAborted();
+        const capabilities = queried ?? filesystem.capabilities;
+        signal?.throwIfAborted();
+        const supported = capabilities.retainedRead;
+        signal?.throwIfAborted();
+        if (supported !== true)
+            throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
+        const acquire = filesystem.openReadFile;
+        signal?.throwIfAborted();
+        if (typeof acquire !== "function")
+            throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
+        handle = await Reflect.apply(acquire, filesystem, [path, options]);
+        signal?.throwIfAborted();
+        return handle;
+    }
+    catch (error) {
+        if (handle)
+            await finishCleanup(() => handle.close(), true);
+        signal?.throwIfAborted();
+        throw error;
+    }
+}
+export function requireCapabilities(...values) {
+    return values.some(value => value === false) ? false : values.every(value => value === true) ? true : undefined;
+}
+export function retainedResizeCapabilities(filesystem, capabilities = filesystem.capabilities) {
+    if (capabilities.retainedResize !== true)
+        return capabilities;
+    return typeof filesystem.openResizeFile === "function" && capabilities.readOnly !== true
+        ? capabilities : { ...capabilities, retainedResize: false };
+}
+export async function openRetainedResizeFile(filesystem, path, options) {
+    const signal = options.signal;
+    let handle;
+    try {
+        signal?.throwIfAborted();
+        const available = typeof filesystem.openResizeFile === "function";
+        signal?.throwIfAborted();
+        if (!available)
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        const query = filesystem.capabilitiesFor;
+        signal?.throwIfAborted();
+        const intent = { ...(signal === undefined ? {} : { signal }), create: options.create === true };
+        signal?.throwIfAborted();
+        const metadata = Promise.resolve(query === undefined ? filesystem.capabilities : Reflect.apply(query, filesystem, [path, intent]));
+        const capabilities = await awaitWithSignal(metadata, signal);
+        signal?.throwIfAborted();
+        const readOnly = capabilities.readOnly;
+        signal?.throwIfAborted();
+        if (readOnly === true)
+            throw new FsError("EROFS", { syscall: "openResizeFile", path });
+        const supported = capabilities.retainedResize;
+        signal?.throwIfAborted();
+        if (supported !== true)
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        const acquire = filesystem.openResizeFile;
+        signal?.throwIfAborted();
+        if (typeof acquire !== "function")
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        handle = await Reflect.apply(acquire, filesystem, [path, options]);
+        signal?.throwIfAborted();
+        return handle;
+    }
+    catch (error) {
+        if (handle)
+            await finishCleanup(() => handle.close(), true);
+        signal?.throwIfAborted();
+        throw error;
+    }
+}
+export function readOnlyCapabilities(capabilities) {
+    const inspection = Object.fromEntries([
+        "read", "stat", "readdir", "realpath", "access", "readlink", "explicitDirectories", "implicitDirectories",
+        "symlinks", "streamingRead", "open", "retainedRead", "versionedDescriptors",
+    ].filter(name => capabilities[name] !== undefined).map(name => [name, capabilities[name]]));
+    return Object.freeze({
+        ...inspection, retainedStagingCleanup: false, retainedStagingWrite: false, readOnly: true, write: false, append: false, exclusiveCreate: false,
+        synchronousStagingResolution: false,
+        mkdir: false, recursiveMkdir: false, remove: false, removeDirectory: false, recursiveRemove: false,
+        rename: false, copy: false, exclusiveCopy: false, truncate: false, streamingAppend: false,
+        randomAccessWrite: false, hardlinks: false, permissions: false, conditionalChmod: false, timestamps: false,
+        descriptorWriteStream: false, atomicResize: false, retainedResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicEntryRemovalReceipt: false, atomicTreeRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false, trustedOwnedStaging: false,
+        atomicFilePublication: false, atomicRename: false, atomicRenameNoReplace: false, streamingWrite: false,
+    });
+}
+export function quotaCapabilities(capabilities) {
+    const streamingWrite = requireCapabilities(capabilities.write, capabilities.append, !capabilities.readOnly);
+    const streamingAppend = requireCapabilities(capabilities.append, !capabilities.readOnly);
+    const { streamingWrite: ignoredWrite, streamingAppend: ignoredAppend, ...rest } = capabilities;
+    return Object.freeze({ ...rest, synchronousStagingResolution: false, retainedStagingCleanup: false, retainedStagingWrite: false, atomicStagingAncestry: false, synchronousDirectoryValidation: false, guardedStagingPublication: false, atomicFilePublication: false, descriptorWriteStream: false, atomicResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicEntryRemovalReceipt: false, atomicFileStaging: false, atomicDirectoryMetadata: false, trustedOwnedStaging: false,
+        ...(streamingWrite === undefined ? {} : { streamingWrite }),
+        ...(streamingAppend === undefined ? {} : { streamingAppend }),
+    });
+}
+const TRUSTED_OWNED_STAGING_METHODS = [
+    "createStagedFile", "publishStagedFile", "removeStagedFile", "writeFileConditional", "removeFileConditional", "prepareDirectory",
+];
+export function ownedMutationCapabilities(filesystem, capabilities = filesystem.capabilities) {
+    let unavailable;
+    if (capabilities.atomicFilePublication === true && (capabilities.readOnly === true || typeof filesystem.publishFileConditional !== "function"))
+        (unavailable ??= {}).atomicFilePublication = false;
+    if (capabilities.atomicEntryRemoval === true && (capabilities.readOnly === true || typeof filesystem.removeEntryConditional !== "function"))
+        (unavailable ??= {}).atomicEntryRemoval = false;
+    if (capabilities.atomicEntryRemovalReceipt === true && (capabilities.atomicEntryRemoval !== true || unavailable?.atomicEntryRemoval === false))
+        (unavailable ??= {}).atomicEntryRemovalReceipt = false;
+    if (capabilities.atomicTreeRemoval === true && (capabilities.readOnly === true || typeof filesystem.removeTreeConditional !== "function"))
+        (unavailable ??= {}).atomicTreeRemoval = false;
+    if (capabilities.atomicFileMutation === true && (capabilities.readOnly === true || typeof filesystem.writeFileConditional !== "function" || typeof filesystem.removeFileConditional !== "function"))
+        (unavailable ??= {}).atomicFileMutation = false;
+    if (capabilities.atomicFileStaging === true && (capabilities.readOnly === true
+        || typeof filesystem.createStagedFile !== "function" || typeof filesystem.publishStagedFile !== "function" || typeof filesystem.removeStagedFile !== "function"))
+        (unavailable ??= {}).atomicFileStaging = false;
+    if (capabilities.retainedStagingCleanup === true && (capabilities.atomicFileStaging !== true || unavailable?.atomicFileStaging === false))
+        (unavailable ??= {}).retainedStagingCleanup = false;
+    if (capabilities.retainedStagingWrite === true && (capabilities.retainedStagingCleanup !== true || unavailable?.retainedStagingCleanup === false))
+        (unavailable ??= {}).retainedStagingWrite = false;
+    if (capabilities.atomicStagingAncestry === true && (capabilities.atomicFileStaging !== true || unavailable?.atomicFileStaging === false))
+        (unavailable ??= {}).atomicStagingAncestry = false;
+    if (capabilities.synchronousDirectoryValidation === true && typeof filesystem.prepareDirectoryAncestry !== "function")
+        (unavailable ??= {}).synchronousDirectoryValidation = false;
+    if (capabilities.synchronousStagingResolution === true && (capabilities.readOnly === true || typeof filesystem.prepareStagingResolution !== "function"))
+        (unavailable ??= {}).synchronousStagingResolution = false;
+    if (capabilities.guardedStagingPublication === true && (capabilities.atomicFileStaging !== true || unavailable?.atomicFileStaging === false))
+        (unavailable ??= {}).guardedStagingPublication = false;
+    if (capabilities.atomicDirectoryMetadata === true && (capabilities.readOnly === true || typeof filesystem.prepareDirectory !== "function"))
+        (unavailable ??= {}).atomicDirectoryMetadata = false;
+    if (capabilities.trustedOwnedStaging === true) {
+        let missing = capabilities.readOnly === true;
+        if (!missing) {
+            for (let i = 0; i < TRUSTED_OWNED_STAGING_METHODS.length; i++) {
+                if (typeof filesystem[TRUSTED_OWNED_STAGING_METHODS[i]] !== "function") {
+                    missing = true;
+                    break;
+                }
+            }
+        }
+        if (missing)
+            (unavailable ??= {}).trustedOwnedStaging = false;
+    }
+    return unavailable ? { ...capabilities, ...unavailable } : capabilities;
+}
+export async function requireOwnedMutation(filesystem, path, capability, options, create = false) {
+    try {
+        options.signal?.throwIfAborted();
+        const query = create ? { ...options, create: true } : options;
+        const capabilities = ownedMutationCapabilities(filesystem, await filesystem.capabilitiesFor?.(path, capability === "atomicStagingAncestry" ? { ...query, stagingAncestry: true } : query) ?? filesystem.capabilities);
+        options.signal?.throwIfAborted();
+        if (capabilities[capability] !== true && !(capabilities.trustedOwnedStaging === true && ["atomicFileStaging", "atomicFileMutation", "atomicDirectoryMetadata"].includes(capability)))
+            throw new FsError("ENOTSUP", { path, syscall: capability });
+    }
+    catch (error) {
+        options.signal?.throwIfAborted();
+        if (capability === "atomicStagingAncestry" && "ancestors" in options && options.ancestors !== undefined
+            && "destination" in options && ["ENOTSUP", "ENOENT", "ENOTDIR", "ELOOP"].includes(toFsError(error).code)) {
+            await inspectStagingBindings(entry => filesystem.lstat(entry, options), path, options);
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ChmodOptions, FileStagingEntry, FileStat } from "../contracts/filesystem.js";
+export interface ConditionalChmodOptions extends ChmodOptions {
+    readonly parent: FileStat;
+    readonly expected: FileStat;
+    readonly ancestors: readonly FileStagingEntry[];
+}
+export declare function snapshotConditionalChmod(path: string, options: ChmodOptions): ConditionalChmodOptions | undefined;

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

@@ -0,0 +1,19 @@
+import { FsError } from "../contracts/errors.js";
+import { dirname } from "../contracts/virtual-path.js";
+import { snapshotDirectoryAncestry } from "./staging-ancestry.js";
+export function snapshotConditionalChmod(path, options) {
+    const { signal, parent, expected, ancestors, commitGuard } = options;
+    signal?.throwIfAborted();
+    if (parent === undefined && expected === undefined && ancestors === undefined && commitGuard === undefined)
+        return undefined;
+    if (parent === undefined || expected === undefined || ancestors === undefined) {
+        throw new FsError("EINVAL", { syscall: "chmod", path, message: "complete conditional chmod receipt is required" });
+    }
+    if (commitGuard !== undefined && typeof commitGuard !== "function")
+        throw new FsError("EINVAL", { syscall: "chmod", path });
+    const entries = snapshotDirectoryAncestry(ancestors);
+    if (entries.at(-1)?.path !== dirname(path))
+        throw new FsError("EINVAL", { syscall: "chmod", path });
+    return { ...(signal === undefined ? {} : { signal }), parent: { ...parent }, expected: { ...expected }, ancestors: entries,
+        ...(commitGuard === undefined ? {} : { commitGuard }) };
+}

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

@@ -0,0 +1,21 @@
+import type { FileDescriptor, FileDescriptorCapabilities, FileStat, FsOptions, OpenFileOptions } from "../contracts/filesystem.js";
+export interface DescriptorOpenOptions extends OpenFileOptions {
+    readonly creation: "never" | "ifMissing" | "exclusive";
+    readonly truncate: boolean;
+    readonly append: boolean;
+    readonly mode: number;
+}
+export interface DescriptorBackend<Resource> {
+    readonly resource: Resource;
+    readonly capabilities?: FileDescriptorCapabilities;
+    getPosition?(resource: Resource, options: FsOptions): Promise<number>;
+    probeRead?(resource: Resource, options: FsOptions): Promise<"ready" | "blocked" | "unknown">;
+    stat(resource: Resource, options: FsOptions): Promise<FileStat>;
+    read(resource: Resource, buffer: Uint8Array, position: number | null, options: FsOptions): Promise<number>;
+    write(resource: Resource, buffer: Uint8Array, position: number | null, options: FsOptions): Promise<number>;
+    truncate(resource: Resource, length: number, options: FsOptions): Promise<void>;
+    sync(resource: Resource, dataOnly: boolean, options: FsOptions): Promise<void>;
+    close(resource: Resource, options: FsOptions): Promise<void>;
+}
+export declare function forwardFileDescriptor(descriptor: FileDescriptor, operation: <Result>(syscall: string, options: FsOptions, action: () => Promise<Result>) => Promise<Result>, capabilities?: FileDescriptorCapabilities, snapshot?: (stat: FileStat) => FileStat): DescriptorBackend<FileDescriptor>;
+export declare function openFileDescriptor<Resource>(path: string, options: OpenFileOptions, capabilities: FileDescriptorCapabilities, acquire: (options: DescriptorOpenOptions) => Promise<DescriptorBackend<Resource>>): Promise<FileDescriptor>;