@poe-platform/safe-js 0.1.0

package/dist/process-runner/docker/build-context.d.ts

@@ -0,0 +1,5 @@
+export interface DockerBuildContextFile {
+    relativePath: string;
+    bytes: Buffer;
+}
+export declare function readDockerBuildContextFiles(buildContext: string): Promise<DockerBuildContextFile[]>;

package/dist/process-runner/docker/context.d.ts

@@ -0,0 +1,3 @@
+import type { Engine } from "../types.js";
+export declare function detectContext(): string | null;
+export declare function buildContextArgs(engine: Engine, context: string | null): string[];

package/dist/process-runner/docker/docker-execution-env.d.ts

@@ -0,0 +1,28 @@
+import type { DockerMount, Engine, ExecutionState, ExecutionEnvFactory, Runner } from "../types.js";
+interface DockerRuntime {
+    type: "docker";
+    image?: string;
+    dockerfile?: string;
+    build_context?: string;
+    build_args?: Record<string, string>;
+    mounts?: DockerMount[];
+    engine?: Engine;
+    network?: string;
+    extra_args?: string[];
+}
+export interface BuildDockerRuntimeTemplateInput {
+    cwd: string;
+    runtime: DockerRuntime;
+    state?: ExecutionState;
+    runner?: Runner;
+    force?: boolean;
+}
+export interface BuildDockerRuntimeTemplateResult {
+    backend: "docker";
+    hash: string;
+    image: string;
+    cached: boolean;
+}
+export declare const dockerExecutionEnvFactory: ExecutionEnvFactory;
+export declare function buildDockerRuntimeTemplate(input: BuildDockerRuntimeTemplateInput): Promise<BuildDockerRuntimeTemplateResult>;
+export {};

package/dist/process-runner/docker/docker-runner.d.ts

@@ -0,0 +1,2 @@
+import type { DockerRunnerOptions, Runner } from "../types.js";
+export declare function createDockerRunner(options: DockerRunnerOptions): Runner;

package/dist/process-runner/docker/engine.d.ts

@@ -0,0 +1,3 @@
+import type { Engine } from "../types.js";
+export declare function detectEngine(): Engine;
+export declare function isEngineAvailable(engine: Engine): boolean;

package/dist/process-runner/host/host-execution-env.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutionEnvFactory } from "../types.js";
+export declare const hostExecutionEnvFactory: ExecutionEnvFactory;

package/dist/process-runner/host/host-runner.d.ts

@@ -0,0 +1,3 @@
+import type { Runner } from "../types.js";
+import type { HostRunnerOptions } from "../types.js";
+export declare function createHostRunner(options?: HostRunnerOptions): Runner;

package/dist/process-runner/index.d.ts

@@ -0,0 +1,10 @@
+export { buildContextArgs, detectContext } from "./docker/context.js";
+export { readDockerBuildContextFiles, type DockerBuildContextFile } from "./docker/build-context.js";
+export { detectEngine, isEngineAvailable } from "./docker/engine.js";
+export { createDockerRunner } from "./docker/docker-runner.js";
+export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/docker-execution-env.js";
+export { hostExecutionEnvFactory } from "./host/host-execution-env.js";
+export { createHostRunner } from "./host/host-runner.js";
+export { createMockRunner, createMockRunnerByCommand } from "./testing/index.js";
+export { downloadWorkspace, uploadWorkspace, type WorkspaceDownloadOptions, type WorkspaceTransferDirent, type WorkspaceTransferEnv, type WorkspaceTransferFileSystem, type WorkspaceTransferOptions, type WorkspaceTransferRunnerOptions, type WorkspaceTransferStats } from "./workspace-transfer.js";
+export type { DownloadResult, DockerMount, DockerPortMapping, DockerRunArgs, DockerRunnerOptions, Engine, ExecutionState, ExecutionEnvFactory, ExecutionEnvType, HostRunnerOptions, JobHandle, JobStatus, LogChunk, MockRunBehavior, OpenedEnv, OpenSpec, RunHandle, RunResult, Runner, RunSpec, TemplateEntry, UploadResult } from "./types.js";

package/dist/process-runner/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { createMockRunner, createMockRunnerByCommand } from "./mock-runner.js";
+export type { MockRunBehavior } from "../types.js";

package/dist/process-runner/testing/mock-runner.d.ts

@@ -0,0 +1,3 @@
+import type { MockRunBehavior, Runner } from "../types.js";
+export declare function createMockRunner(behaviors: MockRunBehavior[]): Runner;
+export declare function createMockRunnerByCommand(behaviorsByCommand: Record<string, MockRunBehavior>): Runner;

package/dist/process-runner/types.d.ts

@@ -0,0 +1,191 @@
+import type { Readable, Writable } from "node:stream";
+export interface RunHandle {
+    readonly pid: number | null;
+    readonly stdout: Readable | null;
+    readonly stderr: Readable | null;
+    readonly stdin: Writable | null;
+    readonly result: Promise<RunResult>;
+    kill(signal?: NodeJS.Signals): void;
+}
+export interface RunResult {
+    exitCode: number;
+}
+export interface RunSpec {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    stdin?: "pipe" | "inherit" | "ignore";
+    stdout?: "pipe" | "inherit";
+    stderr?: "pipe" | "inherit";
+    tty?: boolean;
+    signal?: AbortSignal;
+    /** Start in a separate process group so kill() can signal the full group where supported. */
+    killProcessGroup?: boolean;
+}
+export interface Runner {
+    exec(spec: RunSpec): RunHandle;
+    readonly name: string;
+}
+export interface HostRunnerOptions {
+    detached?: boolean;
+}
+export type ExecutionEnvType = "host" | "docker";
+export type JobStatus = "running" | "exited" | "killed" | "lost";
+export interface ExecutionEnvFactory {
+    readonly type: ExecutionEnvType;
+    readonly supportsDetach?: boolean;
+    /** Whether uploadWorkspace/downloadWorkspace move real files, i.e. whether runner.sync means anything. */
+    readonly supportsWorkspaceTransfer?: boolean;
+    open(spec: OpenSpec): Promise<OpenedEnv>;
+    attach(envId: string, context?: AttachedJobContext): Promise<OpenedEnv>;
+}
+export interface OpenSpec {
+    cwd: string;
+    runtime: unknown;
+    runner?: unknown;
+    state?: ExecutionState;
+    hostRunner?: Runner;
+    env: Record<string, string>;
+    uploadIgnoreFiles: string[];
+    jobLabel: {
+        tool: string;
+        argv: string[];
+    };
+    execution?: {
+        wrapForLogTee?: boolean;
+        stdin?: RunSpec["stdin"];
+        stdout?: RunSpec["stdout"];
+        stderr?: RunSpec["stderr"];
+        env?: RunSpec["env"];
+        tty?: boolean;
+        input?: string | Buffer;
+        captureOutput?: boolean;
+        activityTimeoutMs?: number;
+        onStdout?(chunk: string): void;
+        onStderr?(chunk: string): void;
+    };
+    shellSpec?: RunSpec;
+}
+export interface ExecutionState {
+    templates: {
+        get(backend: "docker", hash: string): Promise<TemplateEntry | null>;
+        put(backend: "docker", entry: TemplateEntry): Promise<void>;
+    };
+}
+export interface TemplateEntry {
+    hash: string;
+    template_id?: string;
+    image?: string;
+    runtime_type: string;
+    dockerfile_path: string;
+    built_at: string;
+}
+export interface UploadResult {
+    files: number;
+    bytes: number;
+    skipped: {
+        path: string;
+        bytes: number;
+        reason: "max_size";
+    }[];
+}
+export interface DownloadResult {
+    files: number;
+    bytes: number;
+    conflicts: {
+        path: string;
+        reason: "local_modified";
+    }[];
+}
+export interface LogChunk {
+    byteOffset: number;
+    data: string;
+}
+export interface AttachedJobContext {
+    jobId: string;
+    tool: string;
+    argv: string[];
+    cwd: string;
+    reattachContext?: Record<string, unknown>;
+}
+export interface OpenedEnv {
+    readonly id: string;
+    readonly job: JobHandle | null;
+    readonly reattachContext?: Record<string, unknown>;
+    uploadWorkspace(): Promise<UploadResult>;
+    downloadWorkspace(opts: {
+        conflictPolicy: "refuse" | "overwrite";
+    }): Promise<DownloadResult>;
+    exec(spec: RunSpec): RunHandle;
+    detach(): Promise<JobHandle>;
+    shell(): RunHandle;
+    close(): Promise<void>;
+}
+export interface JobHandle {
+    readonly id: string;
+    readonly envId: string;
+    readonly tool: string;
+    readonly argv: string[];
+    status(opts?: {
+        signal?: AbortSignal;
+    }): Promise<JobStatus>;
+    stream(opts?: {
+        sinceByte?: number;
+        since?: Date;
+        follow?: boolean;
+        signal?: AbortSignal;
+    }): AsyncIterable<LogChunk>;
+    wait(): Promise<{
+        exitCode: number;
+    }>;
+    kill(signal?: NodeJS.Signals): Promise<void>;
+}
+export type Engine = "docker" | "podman";
+export interface DockerMount {
+    source: string;
+    target: string;
+    readonly?: boolean;
+}
+export interface DockerPortMapping {
+    host: number;
+    container: number;
+    protocol?: "tcp" | "udp";
+}
+export interface DockerRunnerOptions {
+    image: string;
+    engine?: Engine;
+    context?: string;
+    mounts?: DockerMount[];
+    ports?: DockerPortMapping[];
+    network?: string;
+    extraArgs?: string[];
+    containerName?: string;
+}
+export interface DockerRunArgs {
+    engine: Engine;
+    context: string | null;
+    image: string;
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    envFilePath?: string;
+    mounts: DockerMount[];
+    ports: DockerPortMapping[];
+    network?: string;
+    containerName: string;
+    detached: boolean;
+    interactive: boolean;
+    tty: boolean;
+    rm: boolean;
+    extraArgs: string[];
+}
+export interface MockRunBehavior {
+    pid?: number;
+    exitCode: number;
+    exitAfterMs?: number;
+    stdout?: string[];
+    stderr?: string[];
+    stdoutInterval?: number;
+}

package/dist/process-runner/workspace-transfer.d.ts

@@ -0,0 +1,61 @@
+import type { DownloadResult, UploadResult } from "./types.js";
+export type { DownloadResult, UploadResult } from "./types.js";
+export interface WorkspaceTransferDirent {
+    name: string;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink?(): boolean;
+}
+export interface WorkspaceTransferStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink?(): boolean;
+    size: number;
+}
+export interface WorkspaceTransferFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }): Promise<WorkspaceTransferDirent[]>;
+    readFile(path: string): Promise<Buffer>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string | Buffer, options?: {
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
+    stat(path: string): Promise<WorkspaceTransferStats>;
+    lstat?(path: string): Promise<WorkspaceTransferStats>;
+    rename?(oldPath: string, newPath: string): Promise<void>;
+    rm?(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    unlink?(path: string): Promise<void>;
+    rmdir?(path: string): Promise<void>;
+}
+export interface WorkspaceTransferEnv {
+    cwd: string;
+    uploadDir: string;
+    workspaceDir?: string;
+    fs?: WorkspaceTransferFileSystem;
+    remoteFs?: WorkspaceTransferFileSystem;
+}
+export interface WorkspaceTransferOptions {
+    runner?: WorkspaceTransferRunnerOptions;
+    uploadMaxFileMb?: number;
+    workspaceExclude?: string[];
+    warn?: (message: string) => void;
+}
+export interface WorkspaceTransferRunnerOptions {
+    upload_max_file_mb?: number;
+    workspace?: {
+        exclude?: string[];
+    };
+}
+export interface WorkspaceDownloadOptions {
+    conflictPolicy: "refuse" | "overwrite";
+}
+export declare function uploadWorkspace(env: WorkspaceTransferEnv, opts: WorkspaceTransferOptions): Promise<UploadResult>;
+export declare function downloadWorkspace(env: WorkspaceTransferEnv, opts: WorkspaceDownloadOptions): Promise<DownloadResult>;

package/dist/providers/auth/api-key.d.ts

@@ -0,0 +1,5 @@
+import type { AuthStrategy } from "./types.js";
+export interface ApiKeyLoginOptions {
+    apiKey?: string;
+}
+export declare const apiKeyAuthStrategy: AuthStrategy<ApiKeyLoginOptions>;

package/dist/providers/auth/types.d.ts

@@ -0,0 +1,14 @@
+import type { SecretStore } from "../../auth-store/index.js";
+import type { ApiKeyPrompt, AuthProvider } from "../types.js";
+export type PromptForSecret = (prompt: ApiKeyPrompt) => Promise<string | undefined>;
+export interface AuthStrategyContext {
+    secretStore: SecretStore;
+    promptForSecret?: PromptForSecret;
+    readOnly?: boolean;
+}
+export interface AuthStrategy<TLoginOptions> {
+    login(provider: AuthProvider, options: TLoginOptions, context: AuthStrategyContext): Promise<string>;
+    logout(provider: AuthProvider, context: AuthStrategyContext): Promise<void>;
+    isLoggedIn(provider: AuthProvider, context: AuthStrategyContext): Promise<boolean>;
+    resolveCredential(provider: AuthProvider, context: AuthStrategyContext): Promise<string>;
+}

package/dist/providers/compatibility.d.ts

@@ -0,0 +1,4 @@
+import type { ApiShapeId, AuthProvider } from "./types.js";
+export declare function resolveApiShape(provider: AuthProvider, agent: {
+    apiShapes?: readonly ApiShapeId[];
+}): ApiShapeId | undefined;

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+export type { ApiShapeBinding, ApiShapeId, ApiKeyAuth, ApiKeyPrompt, AuthMethod, AuthProvider, EnvValueSource, OAuthAuth, ProviderModelInput } from "./types.js";
+export { ProviderRegistry } from "./registry.js";
+export type { AuthStrategy, AuthStrategyContext, PromptForSecret } from "./auth/types.js";
+export { resolveApiShape } from "./compatibility.js";
+export { apiKeyAuthStrategy } from "./auth/api-key.js";
+export type { ApiKeyLoginOptions } from "./auth/api-key.js";
+export { POE_PROVIDER_ID } from "./providers/poe.js";
+export * from "./providers/generated.js";

package/dist/providers/providers/anthropic.d.ts

@@ -0,0 +1 @@
+export declare const anthropicProvider: import("../types.js").AuthProvider;

package/dist/providers/providers/cloudflare.d.ts

@@ -0,0 +1 @@
+export declare const cloudflareProvider: import("../types.js").AuthProvider;

package/dist/providers/providers/generated.d.ts

@@ -0,0 +1,5 @@
+export * from "./anthropic.js";
+export * from "./cloudflare.js";
+export * from "./openai.js";
+export * from "./poe.js";
+export declare const allAuthProviders: readonly import("../types.js").AuthProvider[];

package/dist/providers/providers/openai.d.ts

@@ -0,0 +1 @@
+export declare const openaiProvider: import("../types.js").AuthProvider;

package/dist/providers/providers/poe.d.ts

@@ -0,0 +1,2 @@
+export declare const POE_PROVIDER_ID: "poe";
+export declare const poeProvider: import("../types.js").AuthProvider;

package/dist/providers/registry.d.ts

@@ -0,0 +1,44 @@
+import type { ApiShapeId, AuthProvider } from "./types.js";
+import type { SecretStore } from "../auth-store/index.js";
+import type { ApiKeyLoginOptions } from "./auth/api-key.js";
+import type { PromptForSecret } from "./auth/types.js";
+export interface LoginContext {
+    promptForSecret?: PromptForSecret;
+    envVars?: Record<string, string | undefined>;
+    store?: SecretStore;
+    resolvePreferredLogin?: (input: {
+        provider: AuthProvider;
+        apiKey?: string;
+        envValue?: string;
+    }) => Promise<string>;
+}
+export type ProviderStoreFactory = (provider: AuthProvider) => SecretStore;
+export interface ProviderRegistryOptions {
+    envVars?: Record<string, string | undefined>;
+}
+export interface ProviderAgent {
+    id: string;
+    apiShapes?: readonly ApiShapeId[];
+}
+export declare class ProviderRegistry {
+    private readonly providers;
+    private readonly byId;
+    private readonly storeFactory?;
+    private readonly envVars;
+    constructor(providers: readonly AuthProvider[], storeFactory?: ProviderStoreFactory, options?: ProviderRegistryOptions);
+    list(): readonly AuthProvider[];
+    get(id: string): AuthProvider | undefined;
+    forAgent(agent: ProviderAgent): readonly AuthProvider[];
+    isLoggedIn(id: string, options?: {
+        readOnly?: boolean;
+    }): Promise<boolean>;
+    login(id: string, options: ApiKeyLoginOptions, context?: LoginContext): Promise<void>;
+    resolveCredential(id: string, options?: ApiKeyLoginOptions, context?: Pick<LoginContext, "envVars"> & {
+        readOnly?: boolean;
+    }): Promise<string>;
+    logout(id: string, options?: {
+        store?: SecretStore;
+    }): Promise<void>;
+    private requireProvider;
+    private requireStore;
+}

package/dist/providers/types.d.ts

@@ -0,0 +1,54 @@
+import type { ApiShapeId } from "../agent-defs/index.js";
+export type { ApiShapeId } from "../agent-defs/index.js";
+export type EnvValueSource = {
+    kind: "literal";
+    value: string;
+} | {
+    kind: "providerCredential";
+    prefix?: string;
+} | {
+    kind: "providerBaseUrl";
+} | {
+    kind: "providerField";
+    path: string;
+};
+export interface ApiKeyPrompt {
+    title: string;
+    placeholder?: string;
+}
+export interface ApiKeyAuth {
+    kind: "api-key";
+    envVar: string;
+    storageKey: string;
+    prompt: ApiKeyPrompt;
+    preferredLogin?: "oauth";
+}
+export interface OAuthAuth {
+    kind: "oauth";
+}
+export type AuthMethod = ApiKeyAuth | OAuthAuth;
+export interface ApiShapeBinding {
+    readonly id: ApiShapeId;
+    readonly baseUrlPath?: string;
+    readonly envBaseUrlPath?: string;
+    readonly defaultBaseUrl?: string;
+}
+export interface ProviderModelInput {
+    readonly kind: "freeform";
+}
+export interface AuthProvider {
+    readonly id: string;
+    readonly label: string;
+    readonly summary?: string;
+    readonly baseUrl?: string;
+    readonly agentBaseUrl?: string;
+    readonly baseUrlEnvVar?: string;
+    readonly baseUrlEnvPath?: string;
+    readonly agentBaseUrlPath?: string;
+    readonly requiresBaseUrl?: boolean;
+    readonly modelInput?: ProviderModelInput;
+    readonly auth: AuthMethod;
+    readonly apiShapes?: readonly ApiShapeBinding[];
+    readonly env?: Readonly<Record<string, EnvValueSource>>;
+}
+export declare function defineProvider(provider: AuthProvider): AuthProvider;

package/dist/safe-fs/bridge/filesystem.d.ts

@@ -0,0 +1,88 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import type { BridgePrimitives, BufferEncodingOption, FsBridgeDirent, FsBridgeEncoding, FsBridgeStats, MakeDirectoryOptions, Mode, ObjectEncodingOptions, StatOptions } from "./types.js";
+type Encoding = FsBridgeEncoding | "buffer";
+type ReadOptions = ObjectEncodingOptions & {
+    flag?: string | number | undefined;
+    signal?: AbortSignal | undefined;
+};
+type DirectoryOptions = {
+    encoding?: Encoding | null | undefined;
+    recursive?: boolean | undefined;
+    withFileTypes?: boolean | undefined;
+};
+export declare class FileSystemBridge<Binary extends Uint8Array> {
+    #private;
+    constructor(fs: FileSystem, options: {
+        readonly cwd?: string;
+        readonly signal?: AbortSignal;
+    }, primitives: BridgePrimitives<Binary>);
+    readFile(path: unknown, options?: {
+        encoding?: null | undefined;
+        flag?: string | number | undefined;
+        signal?: AbortSignal | undefined;
+    } | null): Promise<Binary>;
+    readFile(path: unknown, options: FsBridgeEncoding | (ReadOptions & {
+        encoding: FsBridgeEncoding;
+    })): Promise<string>;
+    readFile(path: unknown, options?: ReadOptions | FsBridgeEncoding | null): Promise<string | Binary>;
+    writeFile(path: unknown, data: unknown, options?: unknown): Promise<void>;
+    appendFile(path: unknown, data: unknown, options?: unknown): Promise<void>;
+    stat(path: unknown, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<FsBridgeStats>;
+    stat(path: unknown, options: StatOptions & {
+        bigint: true;
+    }): Promise<never>;
+    stat(path: unknown, options?: StatOptions): Promise<FsBridgeStats>;
+    lstat(path: unknown, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<FsBridgeStats>;
+    lstat(path: unknown, options: StatOptions & {
+        bigint: true;
+    }): Promise<never>;
+    lstat(path: unknown, options?: StatOptions): Promise<FsBridgeStats>;
+    readdir(path: unknown, options?: FsBridgeEncoding | (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | null): Promise<string[]>;
+    readdir(path: unknown, options: "buffer" | (DirectoryOptions & {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+    })): Promise<Binary[]>;
+    readdir(path: unknown, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Promise<FsBridgeDirent[]>;
+    readdir(path: unknown, options: DirectoryOptions & {
+        encoding: "buffer";
+        withFileTypes: true;
+    }): Promise<FsBridgeDirent<Binary>[]>;
+    mkdir(path: unknown, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): Promise<string | undefined>;
+    mkdir(path: unknown, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null): Promise<void>;
+    mkdir(path: unknown, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
+    access(path: unknown, mode?: number): Promise<void>;
+    rm(path: unknown, value?: unknown): Promise<void>;
+    rmdir(path: unknown, value?: unknown): Promise<void>;
+    rename(source: unknown, destination: unknown): Promise<void>;
+    copyFile(source: unknown, destination: unknown, mode?: number): Promise<void>;
+    cp(source: unknown, destination: unknown, value?: unknown): Promise<void>;
+    readlink(path: unknown, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    readlink(path: unknown, options: BufferEncodingOption): Promise<Binary>;
+    readlink(path: unknown, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    realpath(path: unknown, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    realpath(path: unknown, options: BufferEncodingOption): Promise<Binary>;
+    realpath(path: unknown, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    mkdtemp(prefix: string, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    mkdtemp(prefix: string, options: BufferEncodingOption): Promise<Binary>;
+    mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    symlink(target: unknown, path: unknown, type?: unknown): Promise<void>;
+    link(existing: unknown, path: unknown): Promise<void>;
+    chmod(path: unknown, value: unknown): Promise<void>;
+    utimes(path: unknown, atime: unknown, mtime: unknown): Promise<void>;
+    truncate(path: unknown, length?: number): Promise<void>;
+}
+export {};

package/dist/safe-fs/bridge/index.d.ts

@@ -0,0 +1,6 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import { FileSystemBridge } from "./filesystem.js";
+import type { FsBridgeOptions } from "./types.js";
+export type { FsBridgeCodec, FsBridgeDirent, FsBridgeEncoding, FsBridgeFileSystem, FsBridgeOptions, FsBridgeStats } from "./types.js";
+export type FsBridge = FileSystemBridge<Uint8Array<ArrayBuffer>>;
+export declare function createFsBridge(fs: FileSystem, options: FsBridgeOptions): FsBridge;

package/dist/safe-fs/bridge/types.d.ts

@@ -0,0 +1,75 @@
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export interface FsBridgeCodec {
+    isEncoding(encoding: string): boolean;
+    encode(text: string, encoding: string): Uint8Array;
+    decode(bytes: Uint8Array, encoding: string): string;
+}
+export interface FsBridgeOptions {
+    readonly codec: FsBridgeCodec;
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+export interface FsBridgeFileSystem extends FileSystem {
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+}
+export type FsBridgeEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+export interface ObjectEncodingOptions {
+    encoding?: FsBridgeEncoding | null | undefined;
+}
+export type BufferEncodingOption = "buffer" | {
+    encoding: "buffer";
+};
+export type Mode = number | string;
+export interface MakeDirectoryOptions {
+    recursive?: boolean | undefined;
+    mode?: Mode | undefined;
+}
+export interface StatOptions {
+    bigint?: boolean | undefined;
+}
+export interface FsBridgePredicates {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface FsBridgeStats extends FsBridgePredicates {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+export interface FsBridgeDirent<Name extends string | Uint8Array = string> extends FsBridgePredicates {
+    name: Name;
+    parentPath: string;
+    path: string;
+}
+export interface BridgePrimitives<Binary extends Uint8Array> {
+    readonly codec: FsBridgeCodec;
+    copyBytes(bytes: Uint8Array): Binary;
+    pathValue?(value: unknown): unknown;
+    randomSuffix(): string;
+    readonly paths: {
+        isAbsolute(path: string): boolean;
+        dirname(path: string): string;
+        relative(from: string, to: string): string;
+        resolve(cwd: string, ...paths: string[]): string;
+    };
+}