toolcraft 0.0.749 → 0.0.751

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

@@ -0,0 +1,7 @@
+import type { FileStat, FileSystem } from "../../contracts/filesystem.js";
+import type { S3HeadOutput, S3ObjectInput } from "./transport.js";
+export { registerS3EntryOwner, getOwnedS3Entry, compareOwnedS3Entries } from "./registry.js";
+export type { OwnedS3Entry } from "./registry.js";
+export declare function recordMockS3Head(output: S3HeadOutput, input: S3ObjectInput, storage: object): void;
+export declare function queryS3Head(input: S3ObjectInput, action: (query: S3ObjectInput) => Promise<S3HeadOutput>): Promise<S3HeadOutput>;
+export declare function recordS3Stat(filesystem: FileSystem, path: string, stat: FileStat, metadata: S3HeadOutput | undefined): void;

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

@@ -0,0 +1,38 @@
+import { recordS3Observation } from "./registry.js";
+export { registerS3EntryOwner, getOwnedS3Entry, compareOwnedS3Entries } from "./registry.js";
+const queryKey = Symbol("s3-head-query");
+const queries = new WeakMap();
+const providerHeads = new WeakMap();
+const acceptedHeads = new WeakMap();
+export function recordMockS3Head(output, input, storage) {
+    const token = input[queryKey];
+    const query = token && queries.get(token);
+    if (query && query.Bucket === input.Bucket && query.Key === input.Key) {
+        providerHeads.set(output, { query, entry: { storage, key: input.Key } });
+    }
+}
+export async function queryS3Head(input, action) {
+    const token = Object.freeze({});
+    const query = Object.freeze({ ...input });
+    const forwarded = { ...query, [queryKey]: token };
+    queries.set(token, query);
+    try {
+        const output = await action(forwarded);
+        acceptedHeads.delete(output);
+        const proof = providerHeads.get(output);
+        if (proof?.query === query)
+            acceptedHeads.set(output, proof.entry);
+        return output;
+    }
+    finally {
+        queries.delete(token);
+    }
+}
+export function recordS3Stat(filesystem, path, stat, metadata) {
+    if (!metadata)
+        return;
+    const entry = acceptedHeads.get(metadata);
+    acceptedHeads.delete(metadata);
+    if (entry)
+        recordS3Observation(filesystem, path, stat, entry);
+}

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

@@ -0,0 +1,130 @@
+import { FsError } from "../../contracts/errors.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { ByteSource } from "../../contracts/io.js";
+import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
+import type { S3Transport } from "./transport.js";
+export interface S3FileSystemOptions {
+    readonly transport: S3Transport;
+    readonly bucket: string;
+    readonly prefix?: string;
+    readonly compareEntry?: (this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>;
+    readonly readOnly?: boolean;
+    readonly allowNonAtomicRename?: boolean;
+    readonly pageSize?: number;
+    readonly maxReadBytes?: number;
+    readonly maxStreamBytes?: number;
+    readonly maxListEntries?: number;
+    readonly maxRequests?: number;
+    /** Aggregate budgets for each rm operation, including ancestor inspection. */
+    readonly removalLimits?: {
+        readonly maxRequests?: number;
+        readonly maxListEntries?: number;
+        readonly maxDeleteObjects?: number;
+    };
+}
+export declare class S3RenameError extends FsError {
+    readonly phase: "copy" | "delete";
+    readonly copiedKeys: readonly string[];
+    readonly deletedKeys: readonly string[];
+    constructor(source: string, destination: string, phase: "copy" | "delete", copied: string[], deleted: string[], cause: FsError);
+}
+export declare class S3FileSystem implements FileSystem {
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
+    readonly capabilities: Readonly<{
+        open: false;
+        read: true;
+        stat: true;
+        readdir: true;
+        realpath: true;
+        access: true;
+        write: true;
+        explicitDirectories: true;
+        implicitDirectories: true;
+        mkdir: true;
+        recursiveMkdir: true;
+        remove: true;
+        removeDirectory: true;
+        recursiveRemove: true;
+        copy: true;
+        readlink: false;
+        exclusiveCopy: boolean;
+        append: boolean;
+        exclusiveCreate: boolean;
+        truncate: boolean;
+        atomicRenameNoReplace: false;
+        rename: boolean;
+        streamingAppend: boolean;
+        randomAccessWrite: false;
+        readOnly: boolean;
+        symlinks: false;
+        hardlinks: false;
+        permissions: false;
+        timestamps: boolean;
+        atomicRename: false;
+        snapshotRmdir: true;
+        streamingRead: boolean;
+        streamingWrite: boolean;
+    }>;
+    readonly readStream?: (path: string, options?: ReadStreamOptions) => ByteSource;
+    readonly writeStream?: (path: string, source: ByteSource, options?: WriteFileOptions) => Promise<void>;
+    private readonly transport;
+    private readonly bucket;
+    private readonly prefix;
+    private readonly allowRename;
+    private readonly pageSize;
+    private readonly maxReadBytes;
+    private readonly maxStreamBytes;
+    private readonly maxListEntries;
+    private readonly maxRequests;
+    private requests;
+    private readonly removalLimits;
+    private readonly removalBudgets;
+    constructor(options: S3FileSystemOptions);
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    private path;
+    private key;
+    private directoryKey;
+    private checkAbort;
+    private requestOptions;
+    private call;
+    private writable;
+    private unsupported;
+    private head;
+    private makeStat;
+    private page;
+    private validateKey;
+    private validateObject;
+    private pages;
+    private inspect;
+    private lookup;
+    private requireDirectorySuffix;
+    stat(input: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    private body;
+    private get;
+    readFile(input: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    private etag;
+    writeFile(input: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    private writeMetadata;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    mkdir(input: string, options?: MkdirOptions): Promise<void>;
+    readdir(input: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    private tree;
+    rmdir(input: string, options?: FsOptions): Promise<void>;
+    rm(input: string, options?: RemoveOptions): Promise<void>;
+    private copy;
+    copyFile(sourceInput: string, destinationInput: string, options?: CopyFileOptions): Promise<void>;
+    rename(sourceInput: string, destinationInput: string, options?: RenameOptions): Promise<void>;
+    private copyWithPut;
+    realpath(input: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string): Promise<string>;
+    symlink(_target: string, path: string): Promise<void>;
+    link(_existingPath: string, path: string): Promise<void>;
+    chmod(path: string, _mode: number): Promise<void>;
+    utimes(input: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(input: string, length?: number, options?: FsOptions): Promise<void>;
+    private streamRead;
+    private dispose;
+    private streamWrite;
+}