toolcraft 0.0.749 → 0.0.751

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

@@ -0,0 +1,73 @@
+import { FsError } from "../../contracts/errors.js";
+import { assertCallbackAuthorityAllowed } from "../mount/comparison.js";
+import { enableS3TransportBudget } from "../../platform/transport-budget.js";
+const observedStats = new WeakMap();
+const entries = new WeakMap();
+const comparisons = new WeakMap();
+const configuredComparisons = new WeakMap();
+export function recordS3Observation(filesystem, path, stat, entry) {
+    observedStats.set(stat, { filesystem, path, entry });
+}
+export function registerS3EntryOwner(filesystem, normalize, intact, baseComparison, comparison) {
+    enableS3TransportBudget();
+    comparisons.set(filesystem, baseComparison);
+    if (comparison)
+        configuredComparisons.set(filesystem, comparison);
+    entries.set(filesystem, view => {
+        if (!intact())
+            return undefined;
+        const observation = observedStats.get(view.stat);
+        return observation?.filesystem === filesystem && observation.path === normalize(view.path) ? observation.entry : undefined;
+    });
+}
+export function getOwnedS3Entry(view) {
+    return entries.get(view.filesystem)?.(view);
+}
+export async function compareOwnedS3Entries(own, peer, options) {
+    options.signal?.throwIfAborted();
+    let explicit = false;
+    let answer = "unknown";
+    const visited = new Set();
+    for (const [left, right] of [[own, peer], [peer, own]]) {
+        const baseComparison = comparisons.get(left.filesystem);
+        if (!baseComparison || visited.has(left.filesystem))
+            continue;
+        visited.add(left.filesystem);
+        const current = left.filesystem.compareEntry;
+        const comparison = current === baseComparison ? configuredComparisons.get(left.filesystem) : current;
+        if (current === baseComparison && comparison === undefined)
+            continue;
+        explicit = true;
+        if (comparison === undefined)
+            continue;
+        options.signal?.throwIfAborted();
+        if (typeof comparison !== "function") {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit S3 comparison method" });
+        }
+        assertCallbackAuthorityAllowed();
+        const result = await comparison.call(left.filesystem, left.path, right.filesystem, right.path, options);
+        options.signal?.throwIfAborted();
+        if (result !== "same" && result !== "distinct" && result !== "unknown") {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit S3 comparison" });
+        }
+        if (result === "unknown")
+            continue;
+        if (answer !== "unknown" && answer !== result) {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting explicit S3 comparisons" });
+        }
+        answer = result;
+    }
+    const left = getOwnedS3Entry(own);
+    options.signal?.throwIfAborted();
+    const right = getOwnedS3Entry(peer);
+    options.signal?.throwIfAborted();
+    const same = left && right && left.storage === right.storage && left.key === right.key;
+    if (same && answer === "distinct") {
+        throw new FsError("EIO", { path: own.path, dest: peer.path, message: "explicit S3 comparison contradicts a known alias" });
+    }
+    if (same)
+        return "same";
+    if (explicit)
+        return answer;
+    return left && right ? "distinct" : "unknown";
+}

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

@@ -0,0 +1,103 @@
+export interface S3RequestOptions {
+    readonly abortSignal?: AbortSignal;
+}
+export interface S3ObjectInput {
+    readonly Bucket: string;
+    readonly Key: string;
+}
+export interface S3HeadOutput {
+    readonly ContentLength?: number | undefined;
+    readonly LastModified?: Date | undefined;
+    readonly ETag?: string | undefined;
+    readonly Metadata?: Record<string, string> | undefined;
+}
+export type S3Body = Uint8Array | AsyncIterable<Uint8Array> | {
+    transformToByteArray(): Promise<Uint8Array>;
+};
+export interface S3GetOutput extends S3HeadOutput {
+    readonly Body?: S3Body | undefined;
+}
+export interface S3StreamGetInput extends S3ObjectInput {
+    readonly Range?: string;
+    readonly IfMatch?: string;
+}
+export interface S3StreamGetOutput extends S3HeadOutput {
+    readonly Body: AsyncIterable<Uint8Array>;
+}
+export interface S3StreamPutInput extends Omit<S3PutInput, "Body"> {
+    readonly Body: AsyncIterable<Uint8Array>;
+}
+export interface S3PutInput extends S3ObjectInput {
+    readonly Body: Uint8Array;
+    readonly IfMatch?: string;
+    readonly IfNoneMatch?: "*";
+    readonly Metadata?: Record<string, string>;
+}
+export interface S3DeleteInput extends S3ObjectInput {
+    readonly IfMatch?: string;
+}
+export interface S3CopyInput extends S3ObjectInput {
+    readonly CopySource: string;
+    readonly CopySourceIfMatch?: string;
+    readonly IfNoneMatch?: "*";
+    readonly IfMatch?: string;
+    readonly MetadataDirective?: "COPY" | "REPLACE";
+    readonly Metadata?: Record<string, string>;
+}
+export interface S3CopyOutput {
+    readonly CopyObjectResult?: {
+        readonly ETag?: string | undefined;
+        readonly LastModified?: Date | undefined;
+    } | undefined;
+}
+export interface S3ListInput {
+    readonly Bucket: string;
+    readonly Prefix?: string;
+    readonly Delimiter?: string;
+    readonly MaxKeys?: number;
+    readonly ContinuationToken?: string;
+}
+export interface S3ObjectSummary {
+    readonly Key?: string | undefined;
+    readonly Size?: number | undefined;
+    readonly ETag?: string | undefined;
+    readonly LastModified?: Date | undefined;
+}
+export interface S3ListOutput {
+    readonly Contents?: readonly S3ObjectSummary[] | undefined;
+    readonly CommonPrefixes?: readonly {
+        readonly Prefix?: string | undefined;
+    }[] | undefined;
+    readonly IsTruncated?: boolean | undefined;
+    readonly NextContinuationToken?: string | undefined;
+    readonly KeyCount?: number | undefined;
+}
+export interface S3Client {
+    getObjectStream?(input: S3StreamGetInput, options?: S3RequestOptions): Promise<S3StreamGetOutput>;
+    putObjectStream?(input: S3StreamPutInput, options?: S3RequestOptions): Promise<unknown>;
+    headObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3HeadOutput>;
+    getObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3GetOutput>;
+    putObject(input: S3PutInput, options?: S3RequestOptions): Promise<unknown>;
+    deleteObject(input: S3DeleteInput, options?: S3RequestOptions): Promise<unknown>;
+    copyObject(input: S3CopyInput, options?: S3RequestOptions): Promise<S3CopyOutput>;
+    listObjectsV2(input: S3ListInput, options?: S3RequestOptions): Promise<S3ListOutput>;
+}
+export interface S3TransportCapabilities {
+    readonly streamingRead?: boolean;
+    readonly streamingWrite?: boolean;
+    readonly conditionalPut?: boolean;
+    readonly conditionalCopy?: boolean;
+    readonly conditionalDelete?: boolean;
+}
+export interface S3Transport extends S3Client {
+    readonly capabilities?: S3TransportCapabilities;
+}
+export declare function createS3Transport(client: S3Client, capabilities?: S3TransportCapabilities): S3Transport;
+export declare class S3ServiceError extends Error {
+    readonly code: string;
+    readonly $metadata: {
+        readonly httpStatusCode: number;
+    };
+    constructor(code: string, status: number, message?: string);
+}
+export declare function encodeCopySource(bucket: string, key: string): string;

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

@@ -0,0 +1,28 @@
+export function createS3Transport(client, capabilities = {}) {
+    const transport = {
+        capabilities: Object.freeze({ ...capabilities }),
+        ...(client.getObjectStream ? { getObjectStream: (input, options) => client.getObjectStream(input, options) } : {}),
+        ...(client.putObjectStream ? { putObjectStream: (input, options) => client.putObjectStream(input, options) } : {}),
+        headObject: (input, options) => client.headObject(input, options),
+        getObject: (input, options) => client.getObject(input, options),
+        putObject: (input, options) => client.putObject(input, options),
+        deleteObject: (input, options) => client.deleteObject(input, options),
+        copyObject: (input, options) => client.copyObject(input, options),
+        listObjectsV2: (input, options) => client.listObjectsV2(input, options),
+    };
+    return transport;
+}
+export class S3ServiceError extends Error {
+    code;
+    $metadata;
+    constructor(code, status, message = code) {
+        super(message);
+        this.name = code;
+        this.code = code;
+        this.$metadata = { httpStatusCode: status };
+    }
+}
+export function encodeCopySource(bucket, key) {
+    return [bucket, ...key.split("/")].map((part) => encodeURIComponent(part)
+        .replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
+}

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

@@ -0,0 +1,19 @@
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export declare function retargetScopedFileSystem(scoped: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, maxPathComponents?: number): boolean;
+export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, options?: {
+    readonly preserveDescriptorWriteReceipt?: boolean;
+    readonly creationMask?: number;
+    readonly maxPathComponents?: number;
+}): FileSystem;
+export interface RetainedFileSystemCleanupView {
+    readonly removeFileConditional?: NonNullable<FileSystem["removeFileConditional"]>;
+    readonly removeStagedFile?: NonNullable<FileSystem["removeStagedFile"]>;
+    readonly lstat: FileSystem["lstat"];
+    readonly realpath: FileSystem["realpath"];
+    readonly rm: (path: string, options?: FsOptions) => Promise<void>;
+    readonly rmdir?: NonNullable<FileSystem["rmdir"]>;
+}
+export interface RetainedFileSystemCleanupOptions {
+    readonly maxOperations?: number;
+}
+export declare function retainFileSystemCleanup(filesystem: FileSystem, cleanupCallback: (view: RetainedFileSystemCleanupView) => void | PromiseLike<void>, options?: RetainedFileSystemCleanupOptions): () => Promise<void>;