poe-code 12.0.2 → 12.0.4

package/packages/safe-fs/dist/fs/mount/index.d.ts

@@ -0,0 +1,44 @@
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { ByteSource } from "../../contracts/io.js";
+export interface MountFileSystemOptions {
+    readonly root: FileSystem;
+    readonly mounts?: Readonly<Record<string, FileSystem>>;
+}
+export declare class MountFileSystem implements FileSystem {
+    readonly capabilities: FileSystemCapabilities;
+    private readonly mounts;
+    constructor(options: MountFileSystemOptions);
+    private select;
+    private protected;
+    private error;
+    private operation;
+    private components;
+    private lookup;
+    private resolve;
+    private mutable;
+    private entryPath;
+    private optional;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    symlink(target: string, path: string, options?: FsOptions): Promise<void>;
+    link(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+}
+export declare function createMountFileSystem(options: MountFileSystemOptions): MountFileSystem;

package/packages/safe-fs/dist/fs/overlay/index.d.ts

@@ -0,0 +1,72 @@
+import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+export interface OverlayFileSystemOptions {
+    readonly upper: FileSystem;
+    readonly lower: FileSystem;
+    readonly maxBufferBytes?: number;
+}
+export declare class OverlayFileSystem implements FileSystem {
+    #private;
+    readonly capabilities: FileSystemCapabilities;
+    private readonly maxBufferBytes;
+    private readonly whiteouts;
+    private readonly opaque;
+    private readonly garbage;
+    private readonly activeStages;
+    private readonly linkMetadata;
+    private readonly linkOrigins;
+    private queue;
+    constructor(options: OverlayFileSystemOptions);
+    private run;
+    private writable;
+    private permission;
+    private maybeStat;
+    private hidden;
+    private lowerVisible;
+    private lookup;
+    private resolve;
+    private linkTarget;
+    private movableLinkTarget;
+    private required;
+    private listing;
+    private bytes;
+    private cleanGarbage;
+    cleanup(options?: FsOptions): Promise<void>;
+    private staged;
+    private preserve;
+    private clone;
+    private rememberLink;
+    private ensureDirectory;
+    private copyUp;
+    private parent;
+    private makeDirectory;
+    private writeOptions;
+    private writeLocation;
+    private replace;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, requestedMode?: number, options?: FsOptions): Promise<void>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    private materialize;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    symlink(target: string, path: string, options?: FsOptions): Promise<void>;
+    link(_existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
+    private metadata;
+    chmod(path: string, permissions: number, options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    private bounded;
+    private streamToUpper;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+}
+export declare function createOverlayFileSystem(options: OverlayFileSystemOptions): OverlayFileSystem;

package/packages/safe-fs/dist/fs/readonly/index.d.ts

@@ -0,0 +1,30 @@
+import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+export declare class ReadOnlyFileSystem implements FileSystem {
+    #private;
+    constructor(filesystem: FileSystem);
+    get capabilities(): FileSystemCapabilities;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    writeFile(path: string, _data: Uint8Array, _options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, _data: Uint8Array, _options?: AppendFileOptions): Promise<void>;
+    writeStream(path: string, _source: ByteSource, _options?: WriteFileOptions): Promise<void>;
+    mkdir(path: string, _options?: MkdirOptions): Promise<void>;
+    rm(path: string, _options?: RemoveOptions): Promise<void>;
+    unlink(path: string, _options?: FsOptions): Promise<void>;
+    rmdir(path: string, _options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, _options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, _options?: CopyFileOptions): Promise<void>;
+    symlink(target: string, path: string, _options?: FsOptions): Promise<void>;
+    link(existingPath: string, newPath: string, _options?: FsOptions): Promise<void>;
+    chmod(path: string, _mode: number, _options?: FsOptions): Promise<void>;
+    utimes(path: string, _atimeMs: number, _mtimeMs: number, _options?: FsOptions): Promise<void>;
+    truncate(path: string, _length?: number, _options?: FsOptions): Promise<void>;
+}
+export declare function createReadOnlyFileSystem(filesystem: FileSystem): ReadOnlyFileSystem;

package/packages/safe-fs/dist/fs/real/allocation.d.ts

@@ -0,0 +1 @@
+export declare function nativeAllocatedBytes(blocks: unknown, platform: string): number | undefined;

package/packages/safe-fs/dist/fs/real/index.d.ts

@@ -0,0 +1,76 @@
+import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+export interface RealFileSystemOptions {
+    /** An existing, absolute host directory. It is never created implicitly. */
+    readonly root: string;
+}
+/**
+ * Async byte filesystem for trusted POSIX hosts (Windows is unsupported).
+ * Both relative and absolute input paths are virtual POSIX paths rooted at `/`;
+ * components resolve in order, following symlinks before subsequent `..` and
+ * preserving trailing directory requirements. Empty paths are ENOENT. Excess
+ * input `..` clamps at the virtual root; symlink targets may never cross it.
+ * There is no process cwd dependency. The configured host root must already
+ * exist; its canonical location is pinned on first use or by the async factory.
+ *
+ * Absolute symlink targets created here are virtual paths, stored as rooted
+ * host targets without lexical normalization. Relative targets retain their
+ * text; safe dangling, non-directory, and looping targets may be created.
+ * Existing host symlinks are
+ * followed only when every traversed component remains beneath the root, with
+ * a 40-link traversal limit. Existing absolute host targets must start with the
+ * canonical root, not a different host alias of that root. lstat, removal, and
+ * rename inspect or modify a final symlink itself rather than its target. Absolute readlink results are
+ * translated back into virtual paths; external absolute targets are refused.
+ *
+ * SECURITY LIMIT: containment checks and subsequent Node path operations are
+ * not atomic. O_NOFOLLOW narrows final-file open races, but ancestor swaps,
+ * concurrent renames, mount changes, and preexisting hardlinks cannot be made
+ * safe by these APIs. This is NOT a race-proof sandbox or an isolation boundary
+ * against another process modifying the tree. Use an OS sandbox for that.
+ *
+ * Only regular files, directories, and symlinks are represented. Permissions,
+ * ownership, timestamp precision, case sensitivity, umask, and rename behavior
+ * are those of the host filesystem. Copy is not atomic; rename can fail EXDEV.
+ * Cancellation is cooperative between operations/chunks, not rollback: failed
+ * or canceled writes/copies may leave partial data. No native commands execute.
+ * Destructive rm/rename operands ending in `.` or `..` are refused with EINVAL,
+ * including native recursive-rm edge cases that could otherwise delete content.
+ * Public filesystem errors carry only virtual operands; native causes are
+ * intentionally omitted so host paths cannot escape through nested errors.
+ */
+export declare class RealFileSystem implements FileSystem {
+    readonly capabilities: FileSystemCapabilities;
+    private readonly configuredRoot;
+    private rootPromise;
+    constructor(options: RealFileSystemOptions | string);
+    private root;
+    private absoluteTarget;
+    private walk;
+    private path;
+    private operation;
+    private protectRoot;
+    private protectTerminal;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    symlink(target: string, path: string, options?: FsOptions): Promise<void>;
+    link(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+}
+/** Construct and validate an existing root before returning the backend. */
+export declare function createRealFileSystem(options: RealFileSystemOptions | string): Promise<RealFileSystem>;

package/packages/safe-fs/dist/fs/s3/authority.d.ts

@@ -0,0 +1,13 @@
+import type { EntryComparison, FileStat, FileSystem, FsOptions } from "../../contracts/filesystem.js";
+import type { EntryView } from "../mount/comparison.js";
+import type { S3HeadOutput, S3ObjectInput } from "./transport.js";
+export interface OwnedS3Entry {
+    readonly storage: object;
+    readonly key: string;
+}
+export declare function recordMockS3Head(output: S3HeadOutput, input: S3ObjectInput, storage: object): void;
+export declare function queryS3Head(input: S3ObjectInput, action: () => Promise<S3HeadOutput>): Promise<S3HeadOutput>;
+export declare function recordS3Stat(filesystem: FileSystem, path: string, stat: FileStat, metadata: S3HeadOutput | undefined): void;
+export declare function registerS3EntryOwner(filesystem: FileSystem, normalize: (path: string) => string, intact: () => boolean, baseComparison: NonNullable<FileSystem["compareEntry"]>, comparison?: NonNullable<FileSystem["compareEntry"]>): void;
+export declare function getOwnedS3Entry(view: EntryView): OwnedS3Entry | undefined;
+export declare function compareOwnedS3Entries(own: EntryView, peer: EntryView, options: FsOptions): Promise<EntryComparison>;

package/packages/safe-fs/dist/fs/s3/filesystem.d.ts

@@ -0,0 +1,93 @@
+import { FsError } from "../../contracts/errors.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { ByteSource } from "../../contracts/io.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;
+}
+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 {
+    readonly capabilities: Readonly<{
+        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;
+    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?: FsOptions): 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?: FsOptions): 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;
+}

package/packages/safe-fs/dist/fs/s3/http/index.d.ts

@@ -0,0 +1,2 @@
+export { createS3HttpTransport } from "./transport.js";
+export type { S3HttpCredentials, S3HttpCredentialProvider, S3HttpRequestFactory, S3HttpTransportOptions } from "./types.js";

package/packages/safe-fs/dist/fs/s3/http/request.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage, RequestOptions } from "node:http";
+import type { S3HttpRequestFactory } from "./types.js";
+export interface RequestScope {
+    readonly signal: AbortSignal;
+    readonly finish: () => void;
+}
+export declare function scopeFor(signal: AbortSignal | undefined, timeout: number): RequestScope;
+export declare function abortable<Value>(pending: Promise<Value>, signal: AbortSignal): Promise<Value>;
+export interface WireResponse {
+    readonly message: IncomingMessage;
+    readonly body: AsyncIterable<Uint8Array>;
+    readonly close: () => void;
+}
+export declare function sendRequest(options: RequestOptions, body: Uint8Array, scope: RequestScope, factory?: S3HttpRequestFactory): Promise<WireResponse>;
+export declare function limitedBody(response: WireResponse, maximum: number, expected?: number): AsyncIterable<Uint8Array>;
+export declare function collect(response: WireResponse, maximum: number, expected?: number): Promise<Uint8Array>;

package/packages/safe-fs/dist/fs/s3/http/signature.d.ts

@@ -0,0 +1,20 @@
+import type { S3HttpCredentials } from "./types.js";
+export declare function invalid(message: string): never;
+export declare function uriEncode(value: string, preserveSlash?: boolean): string;
+export declare function canonicalQuery(entries: readonly (readonly [string, string])[]): string;
+export declare function sha256(bytes: Uint8Array | string): string;
+export declare function headerValue(value: string): string;
+export declare function signRequest(input: {
+    readonly method: string;
+    readonly path: string;
+    readonly query: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: Uint8Array;
+    readonly region: string;
+    readonly credentials: S3HttpCredentials;
+    readonly date: Date;
+}): {
+    readonly headers: Record<string, string>;
+    readonly canonicalRequest: string;
+    readonly signature: string;
+};

package/packages/safe-fs/dist/fs/s3/http/transport.d.ts

@@ -0,0 +1,3 @@
+import type { S3Transport } from "../transport.js";
+import type { S3HttpTransportOptions } from "./types.js";
+export declare function createS3HttpTransport(options: S3HttpTransportOptions): S3Transport;

package/packages/safe-fs/dist/fs/s3/http/types.d.ts

@@ -0,0 +1,30 @@
+import type { ClientRequest, IncomingMessage, RequestOptions } from "node:http";
+export interface S3HttpCredentials {
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly sessionToken?: string;
+}
+export type S3HttpCredentialProvider = (options: {
+    readonly signal: AbortSignal;
+}) => Promise<S3HttpCredentials>;
+export type S3HttpRequestFactory = (options: RequestOptions, onResponse: (response: IncomingMessage) => void) => ClientRequest;
+export interface S3HttpTransportOptions {
+    readonly endpoint: string;
+    readonly region: string;
+    readonly credentials: S3HttpCredentials | S3HttpCredentialProvider;
+    readonly addressingStyle?: "path" | "virtual-hosted";
+    readonly listUrlEncoding?: "percent" | "form";
+    readonly clock?: () => Date;
+    readonly request?: S3HttpRequestFactory;
+    readonly allowInsecureHttp?: boolean;
+    readonly maxPutBytes?: number;
+    readonly maxGetBytes?: number;
+    readonly maxXmlBytes?: number;
+    readonly requestTimeoutMs?: number;
+    readonly enableCopy?: boolean;
+    readonly verifiedConditionalOperations?: {
+        readonly put?: boolean;
+        readonly copy?: boolean;
+        readonly delete?: boolean;
+    };
+}

package/packages/safe-fs/dist/fs/s3/http/xml.d.ts

@@ -0,0 +1,11 @@
+export interface XmlNode {
+    readonly name: string;
+    readonly children: XmlNode[];
+    text: string;
+}
+export declare function malformed(message?: string): never;
+export declare function parseXml(bytes: Uint8Array): XmlNode;
+export declare function children(node: XmlNode, name: string): XmlNode[];
+export declare function text(node: XmlNode, name: string, required?: boolean): string | undefined;
+export declare function integer(value: string): number;
+export declare function timestamp(value: string): Date;

package/packages/safe-fs/dist/fs/s3/index.d.ts

@@ -0,0 +1,6 @@
+export { S3FileSystem, S3RenameError } from "./filesystem.js";
+export type { S3FileSystemOptions } from "./filesystem.js";
+export { MockS3Client } from "./mock.js";
+export type { MockS3ClientOptions, MockS3Operation, MockS3Request } from "./mock.js";
+export { createS3Transport, encodeCopySource, S3ServiceError } from "./transport.js";
+export type { S3Body, S3Client, S3CopyInput, S3CopyOutput, S3DeleteInput, S3GetOutput, S3HeadOutput, S3ListInput, S3ListOutput, S3ObjectInput, S3ObjectSummary, S3PutInput, S3RequestOptions, S3Transport, S3TransportCapabilities, } from "./transport.js";

package/packages/safe-fs/dist/fs/s3/mock.d.ts

@@ -0,0 +1,48 @@
+import type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./transport.js";
+import type { S3CopyInput, S3CopyOutput, S3DeleteInput, S3GetOutput, S3HeadOutput, S3ListInput, S3ListOutput, S3ObjectInput, S3PutInput, S3RequestOptions, S3Transport } from "./transport.js";
+export type MockS3Operation = "headObject" | "getObject" | "putObject" | "deleteObject" | "copyObject" | "listObjectsV2";
+export interface MockS3Request {
+    readonly operation: MockS3Operation;
+    readonly input: S3ObjectInput | S3ListInput | S3CopyInput | S3PutInput | S3DeleteInput;
+}
+export interface MockS3ClientOptions {
+    readonly buckets: readonly string[];
+    readonly pageSize?: number;
+    readonly now?: () => Date;
+    readonly authorize?: (request: MockS3Request) => void | Promise<void>;
+}
+export declare class MockS3Client implements S3Transport {
+    readonly capabilities: Readonly<{
+        conditionalPut: true;
+        conditionalCopy: true;
+        conditionalDelete: true;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly buckets;
+    private readonly cursors;
+    private readonly history;
+    private readonly pageSize;
+    private readonly now;
+    private readonly authorize;
+    private nextToken;
+    constructor(options: MockS3ClientOptions);
+    get requests(): readonly MockS3Request[];
+    private begin;
+    private bucket;
+    private object;
+    private head;
+    private store;
+    headObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3HeadOutput>;
+    getObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3GetOutput>;
+    putObject(input: S3PutInput, options?: S3RequestOptions): Promise<{
+        ETag: string;
+    }>;
+    getObjectStream(input: S3StreamGetInput, options?: S3RequestOptions): Promise<S3StreamGetOutput>;
+    putObjectStream(input: S3StreamPutInput, options?: S3RequestOptions): Promise<{
+        ETag: string;
+    }>;
+    deleteObject(input: S3DeleteInput, options?: S3RequestOptions): Promise<Record<string, never>>;
+    copyObject(input: S3CopyInput, options?: S3RequestOptions): Promise<S3CopyOutput>;
+    listObjectsV2(input: S3ListInput, options?: S3RequestOptions): Promise<S3ListOutput>;
+}

package/packages/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/packages/safe-fs/dist/fs/webdav/index.d.ts

@@ -0,0 +1,2 @@
+export { WebDavFileSystem } from "./webdav.js";
+export type { WebDavFileSystemOptions, WebDavFetch, WebDavAtomicEmptyDirectoryBinding, WebDavAtomicEmptyDirectoryRequest, WebDavAtomicEmptyDirectoryResult, } from "./webdav.js";

package/packages/safe-fs/dist/fs/webdav/resource-id.d.ts

@@ -0,0 +1,18 @@
+import type { FileStat, FileSystem, FsOptions } from "../../contracts/filesystem.js";
+import type { EntryAuthority, EntryView } from "../mount/comparison.js";
+export interface OwnedWebDavEntry {
+    readonly storage: object;
+    readonly resource: object;
+}
+export interface OwnedWebDavResource extends OwnedWebDavEntry {
+    readonly identifier: string;
+}
+export declare function registerOwnedResourceResponse(response: Response, entries: ReadonlyMap<string, OwnedWebDavResource>): void;
+export declare function recordOwnedResourceStat(response: Response, filesystem: FileSystem, path: string, stat: FileStat): void;
+export declare function getOwnedWebDavEntry(view: EntryView): OwnedWebDavEntry | undefined;
+export declare function ownedResponseIdentifier(response: Response, path: string): string | undefined;
+type ResourceQuery = (path: string, options: FsOptions) => Promise<string | undefined>;
+export declare function registerResourceQuery(filesystem: FileSystem, query: ResourceQuery, baseComparison: NonNullable<FileSystem["compareEntry"]>, callback?: NonNullable<FileSystem["compareEntry"]>): void;
+export declare function resourceIdentifier(value: string): string;
+export declare const compareWebDavResources: EntryAuthority;
+export {};