@wenathlan/saddle 2.0.153 → 2.0.155

package/dist/virtual.d.ts

@@ -1,640 +0,0 @@
-/**
- * virtual.ts — isolation, internal memory, storage and optional persistence contracts.
- *
- * This file is the v2.0.0 grand-merge consolidation of the former nested
- * folders of the repository (memory, storage, persistence) into the single
- * root-level domain file of the saddle family standard: one optimized
- * TypeScript file per correlated domain, ordinal sections, JSDoc on every
- * block, intra-domain imports dissolved, cross-domain imports rewritten to
- * ./<domain>.js. Every capability of every source file is preserved here;
- * the pure re-export barrels (storage/index.ts) folded their surface into this file directly.
- */
-import { sha256 } from "./foundation.js";
-/**
- * memory objects and compute results are serializable contracts between storage and runtime.
- */
-export declare function memoryobject(options?: {}): {
-    id: any;
-    buffer: Uint8Array<ArrayBufferLike>;
-    size: number;
-    type: any;
-    createdat: any;
-    metadata: any;
-};
-export declare function computeresult(options?: {}): {
-    id: any;
-    payload: any;
-    mimetype: any;
-    metadata: any;
-    processingtimems: any;
-    memoryusedbytes: any;
-};
-export declare function tobytes(value: any): Uint8Array<ArrayBufferLike>;
-/**
- * transforms annotate byte movement without pretending remote storage is physical vram.
- */
-export declare function transformtocompute(value: any, options?: {}): {
-    id: any;
-    buffer: Uint8Array<ArrayBufferLike>;
-    size: number;
-    type: any;
-    createdat: any;
-    metadata: any;
-    processingtimems: number;
-    memoryusedbytes: number;
-};
-export declare function transformtostorage(value: any, options?: {}): {
-    id: any;
-    payload: any;
-    mimetype: any;
-    metadata: any;
-    processingtimems: any;
-    memoryusedbytes: any;
-};
-/**
- * memory modes expose the same byte contract with different backing choices.
- */
-export declare function internalmemory(initial?: {}): {
-    mode: string;
-    put(key: any, value: any): Promise<{
-        key: any;
-        bytes: number;
-    }>;
-    get(key: any): Promise<Uint8Array<ArrayBufferLike>>;
-    delete(key: any): Promise<void>;
-    list(): Promise<string[]>;
-};
-export declare function externalmemory(storage: any): {
-    mode: string;
-    put(key: any, value: any): Promise<any>;
-    get(key: any): Promise<any>;
-    delete(key: any): Promise<any>;
-    list(prefix: any): Promise<any>;
-};
-export declare function physicalmemory(options?: {}): {
-    mode: string;
-    path: any;
-    put: any;
-    get: any;
-    delete: any;
-    list: any;
-};
-export declare function vectorizedmemory(): {
-    mode: string;
-    put(key: any, vector: any): Promise<{
-        key: any;
-        dimensions: any;
-    }>;
-    get(key: any): Promise<any>;
-    average(keys: any): Promise<number[]>;
-    list(): Promise<any[]>;
-};
-export declare function librarymemory(factory: any): {
-    mode: string;
-    load(options: any): Promise<any>;
-};
-export declare function targetfactory(type: any, options?: {}): {
-    type: any;
-    platform: any;
-    owner: any;
-    repo: any;
-    branch: any;
-    path: any;
-    token: any;
-    space?: undefined;
-    dataset?: undefined;
-    sslverification?: undefined;
-    namespace?: undefined;
-    revision?: undefined;
-    host?: undefined;
-    method?: undefined;
-} | {
-    platform?: undefined;
-    owner?: undefined;
-    branch?: undefined;
-    type: any;
-    space: any;
-    revision: any;
-    path: any;
-    token: any;
-    dataset?: undefined;
-    sslverification?: undefined;
-    namespace?: undefined;
-    repo?: undefined;
-    host?: undefined;
-    method?: undefined;
-} | {
-    platform?: undefined;
-    owner?: undefined;
-    branch?: undefined;
-    space?: undefined;
-    type: any;
-    dataset: any;
-    sslverification: any;
-    path: any;
-    token: any;
-    namespace?: undefined;
-    repo?: undefined;
-    revision?: undefined;
-    host?: undefined;
-    method?: undefined;
-} | {
-    platform?: undefined;
-    owner?: undefined;
-    branch?: undefined;
-    space?: undefined;
-    dataset?: undefined;
-    sslverification?: undefined;
-    type: any;
-    namespace: any;
-    repo: any;
-    revision: any;
-    path: any;
-    token: any;
-    host?: undefined;
-    method?: undefined;
-} | {
-    platform?: undefined;
-    owner?: undefined;
-    branch?: undefined;
-    space?: undefined;
-    dataset?: undefined;
-    sslverification?: undefined;
-    namespace?: undefined;
-    repo?: undefined;
-    revision?: undefined;
-    type: any;
-    host: any;
-    path: any;
-    method: any;
-    token: any;
-};
-export declare function targeturi(target: any): string;
-/**
- * memory engine loads from the first backend, persists to every backend and
- * bounds the hot working set without changing the default unbounded behavior.
- */
-/** Creates a storage-backed memory engine with optional LRU working-set limits. */
-export declare function memoryengine(options?: {}): {
-    load: (key: any) => Promise<any>;
-    persist: (key: any, data: any, options?: {}) => Promise<{
-        id: any;
-        buffer: Uint8Array<ArrayBufferLike>;
-        size: number;
-        type: any;
-        createdat: any;
-        metadata: any;
-    }>;
-    release: (key: any) => void;
-    safeload: (key: any) => Promise<{
-        success: boolean;
-        data: any;
-        error?: undefined;
-    } | {
-        data?: undefined;
-        success: boolean;
-        error: any;
-    }>;
-    sync: (key: any, options?: {}) => Promise<any[]>;
-    capabilities: () => any;
-    stats: () => {
-        entries: number;
-        bytes: number;
-        hits: number;
-        misses: number;
-        evictions: number;
-        maxentries: number;
-        maxbytes: number;
-    };
-    transformtocompute: typeof transformtocompute;
-    transformtostorage: typeof transformtostorage;
-    list(): any[];
-};
-/**
- * working-set planning keeps host memory operations declarative and caller-executed.
- */
-/** Validates a serializable working-set capacity budget. */
-export declare function workingbudget(input?: {}): Readonly<{
-    maxbytes: number;
-    maxentries: number;
-    maxage: number;
-}>;
-/** Selects bounded working-set candidates without materializing data or probing a host. */
-export declare function workingadmission(items: any, options?: {}): Readonly<{
-    version: 1;
-    policy: any;
-    budget: Readonly<{
-        maxbytes: number;
-        maxentries: number;
-        maxage: number;
-    }>;
-    usedbytes: number;
-    admitted: readonly any[];
-    deferred: readonly any[];
-}>;
-/** Produces a host bridge plan that an explicit privileged adapter may execute. */
-export declare function bridgeplan(input?: {}): Readonly<{
-    version: 1;
-    operation: string;
-    sizebytes: number;
-    state: "caller-executes" | "unsupported";
-    preconditions: readonly string[];
-    cleanup: Readonly<{
-        required: boolean;
-        owner: "caller";
-    }>;
-}>;
-/** Validates a materialized object record without reading storage or the local filesystem. */
-export declare function materializationrecord(input?: {}): Readonly<{
-    version: 1;
-    id: string;
-    sha256: string;
-    sizebytes: number;
-    tier: any;
-    state: any;
-    createdat: number;
-}>;
-/** Tracks materialization transitions and emits caller-owned cleanup plans without deleting resources. */
-export declare function materializationledger(input?: {}): Readonly<{
-    add: (record: any) => Readonly<{
-        version: 1;
-        id: string;
-        sha256: string;
-        sizebytes: number;
-        tier: any;
-        state: any;
-        createdat: number;
-    }>;
-    transition: (id: any, state: any) => any;
-    cleanupplan: (id: any) => Readonly<{
-        version: 1;
-        id: any;
-        sha256: any;
-        state: "caller-cleans";
-        reason: "already-cleaned" | "release-working-set";
-    }>;
-    list: () => readonly any[];
-}>;
-/**
- * memory bridges materialize and clear temporary working sets.
- */
-export declare function localmemory(options?: {}): {
-    prepare(job: any): Promise<{
-        jobid: any;
-        location: any;
-        resultpath: any;
-        createdat: number;
-    }>;
-    sync(set: any, bytes: any): Promise<{
-        bytes: any;
-        location: any;
-    }>;
-    cleanup(set: any): Promise<void>;
-};
-/**
- * storage adapters keep remote services out of the engine core.
- */
-export declare function storageadapter(methods: any): any;
-/**
- * memory storage keeps bytes in a bounded process-local map for browser workers, Deno, Bun and tests.
- */
-/** Creates a transport-neutral in-memory storage adapter with optional capacity limits. */
-export declare function memorystorage(options?: {}): any;
-/**
- * tiered cache keeps a bounded hot tier and an optional persistent cold tier with stale-while-revalidate.
- */
-/** Creates a cache with caller supplied encode, decode, clock and persistent storage policies. */
-export declare function tieredcache(options?: {}): {
-    get: (key: any, options?: {}) => Promise<any>;
-    set: (key: any, value: any, valueoptions?: {}) => Promise<any>;
-    getorload: (key: any, loader: any, options?: {}) => Promise<any>;
-    delete: (key: any) => Promise<void>;
-    clear: () => void;
-    inspect: () => {
-        hits: number;
-        misses: number;
-        stalehits: number;
-        evictions: number;
-        revalidations: number;
-        hotentries: number;
-        maxentries: number;
-        ttl: number;
-        stale: number;
-    };
-};
-/**
- * byte collection and hashing are grouped because every storage adapter uses them.
- */
-export { sha256 };
-export declare function collectbytes(input: any): Promise<Uint8Array<ArrayBufferLike>>;
-/**
- * content addressed storage deduplicates immutable bytes while keeping logical references separate.
- */
-/** Creates a content-addressed view over a caller supplied storage adapter. */
-export declare function contentstorage(storage: any, options?: {}): {
-    put: (input?: {}) => Promise<{
-        version: number;
-        key: string;
-        objectkey: string;
-        sha256: string;
-        sizebytes: number;
-        contenttype: any;
-        metadata: any;
-    }>;
-    get: (key: any) => Promise<any>;
-    head: (key: any) => Promise<any>;
-    delete: (key: any) => Promise<boolean>;
-    capabilities: {
-        immutableobjects: boolean;
-        dedupe: boolean;
-        references: boolean;
-    };
-};
-/**
- * storage synchronization compares versioned manifests and keeps conflict policy explicit.
- */
-/** Describes capabilities exposed by a storage adapter without forcing optional methods. */
-export declare function storagecapabilities(storage: any): Readonly<{
-    range: boolean;
-    conditional: boolean;
-    metadata: boolean;
-    delete: boolean;
-}>;
-/** Creates a comparable object manifest from bytes and caller metadata. */
-export declare function objectmanifest(key: any, data: any, options?: {}): Promise<{
-    version: number;
-    key: string;
-    sizebytes: number;
-    sha256: string;
-    updatedat: number;
-    etag: any;
-    metadata: any;
-}>;
-/** Compares two manifests and classifies an update or conflict. */
-export declare function comparemanifests(local: any, remote: any): {
-    state: string;
-    local?: undefined;
-    remote?: undefined;
-} | {
-    state: string;
-    remote: any;
-    local?: undefined;
-} | {
-    state: string;
-    local: any;
-    remote?: undefined;
-} | {
-    state: string;
-    local: any;
-    remote: any;
-};
-/** Synchronizes one logical object between two adapters with explicit conflict handling. */
-export declare function syncobject(source: any, target: any, key: any, options?: {}): Promise<{
-    key: string;
-    state: string;
-    manifest: any;
-}>;
-/** Synchronizes one object to multiple backends and returns each outcome. */
-export declare function syncbackends(source: any, targets: any[], key: any, options?: {}): Promise<any[]>;
-/**
- * chunked storage keeps large payloads split without forcing a database blob.
- */
-export declare function chunkedstorage(storage: any, options?: {}): {
-    put(input: any): Promise<{
-        version: number;
-        key: any;
-        sizebytes: number;
-        chunks: any[];
-        chunkbytes: any;
-        sha256: string;
-        contenttype: any;
-        status: string;
-        completed: number;
-        updatedat: number;
-        metadata: any;
-    }>;
-    get(key: any): Promise<Uint8Array<any>>;
-    getrange(key: any, start: number, end: any): Promise<Uint8Array<ArrayBuffer>>;
-    head(key: any): Promise<any>;
-    delete(key: any): Promise<void>;
-    list(prefix: any): Promise<any>;
-};
-/**
- * local storage is explicit, temporary friendly, and protected against traversal.
- */
-export declare function localstorage(root: any): any;
-/**
- * storage pools combine caller-owned adapters without selecting a provider or creating background work.
- */
-/** Creates a deterministic pool over explicit caller-owned storage adapters. */
-export declare function storagepool(options?: {}): Readonly<{
-    read: (key: any, options?: {}) => Promise<Readonly<{
-        version: 1;
-        key: string;
-        memberid: any;
-        data: Uint8Array<ArrayBufferLike>;
-        sha256: string;
-        verified: boolean;
-        manifest: any;
-        attempts: readonly any[];
-        budget: Readonly<{
-            maxattempts: number;
-            maxbytes: number;
-            maxmilliseconds: number;
-        }>;
-        readat: number;
-    }>>;
-    readrange: (key: any, start: any, end: any, options?: {}) => Promise<Readonly<{
-        version: 1;
-        key: string;
-        range: Readonly<{
-            start: number;
-            end: number;
-        }>;
-        memberid: any;
-        data: Uint8Array<ArrayBufferLike>;
-        sha256: string;
-        verified: boolean;
-        attempts: readonly any[];
-        budget: Readonly<{
-            maxattempts: number;
-            maxbytes: number;
-            maxmilliseconds: number;
-        }>;
-        readat: number;
-    }>>;
-    put: (input?: {}, options?: {}) => Promise<Readonly<{
-        version: 1;
-        key: string;
-        sha256: string;
-        sizebytes: number;
-        mode: any;
-        quorum: number;
-        state: "complete" | "partial";
-        results: readonly any[];
-        written: number;
-        budget: Readonly<{
-            maxattempts: number;
-            maxbytes: number;
-            maxmilliseconds: number;
-        }>;
-        writtenat: number;
-    }>>;
-    repairplan: (key: any, options?: {}) => Readonly<{
-        version: 1;
-        key: string;
-        sourceid: string;
-        sha256: string;
-        targets: any;
-        action: "caller-executes";
-    }>;
-    restoreplan: (key: any, options?: {}) => Readonly<{
-        version: 1;
-        key: string;
-        sha256: string;
-        action: "caller-restores";
-        candidates: any;
-    }>;
-    members: () => Readonly<{
-        id: any;
-        priority: any;
-    }>[];
-    capabilities: () => {
-        id: string;
-        priority: number;
-        capabilities: Readonly<{
-            range: boolean;
-            conditional: boolean;
-            metadata: boolean;
-            delete: boolean;
-        }>;
-    }[];
-    metrics: () => {
-        reads: number;
-        writes: number;
-        hits: number;
-        misses: number;
-        mismatches: number;
-        bytes: number;
-        attempts: number;
-        elapsedms: number;
-    };
-}>;
-/**
- * s3 compatible storage stays open by accepting a caller supplied signer.
- * List operations use the S3 ListObjectsV2 contract without owning credentials.
- */
-/** Creates an S3-compatible adapter with signed CRUD and paginated listing. */
-export declare function s3compatible(options?: {}): any;
-/**
- * github contents storage maps artifacts to repository files through an injected token.
- */
-export declare function githubcontents(options?: {}): any;
-/**
- * file hosting adapter accepts a caller supplied request function for s3compatible or webdav.
- */
-export declare function filehosting(options?: {}): any;
-/**
- * the schema descriptor is neutral so prisma drizzle mysql2 or another driver can map it.
- */
-export declare const schemadefinition: Readonly<{
-    jobs: {
-        id: string;
-        name: string;
-        status: string;
-        priority: string;
-        input: string;
-        outputkey: string;
-        createdat: string;
-        updatedat: string;
-    };
-    events: {
-        id: string;
-        jobid: string;
-        type: string;
-        at: string;
-        data: string;
-    };
-    sessions: {
-        id: string;
-        version: string;
-        agentname: string;
-        originurl: string;
-        seed: string;
-        status: string;
-        startedat: string;
-        finishedat: string;
-        events: string;
-    };
-    artifacts: {
-        key: string;
-        sizebytes: string;
-        sha256: string;
-        contenttype: string;
-        createdat: string;
-        metadata: string;
-    };
-    chunks: {
-        id: string;
-        artifactkey: string;
-        index: string;
-        offset: string;
-        sizebytes: string;
-        sha256: string;
-        storagekey: string;
-    };
-    queueitems: {
-        id: string;
-        status: string;
-        attempts: string;
-        payload: string;
-        result: string;
-        error: string;
-        createdat: string;
-        updatedat: string;
-    };
-}>;
-export declare function schemasql(options?: {}): string[];
-export declare function prismaschema(): string;
-/**
- * persistence adapters keep database and remote state outside the runtime core.
- */
-export declare function persistenceadapter(methods: any): any;
-/**
- * memory persistence is the local baseline for tests and offline operation.
- */
-export declare function memorypersistence(): any;
-/**
- * sql persistence keeps query execution injected for mysql2 drizzle or another sql client.
- */
-export declare function sqlpersistence(options?: {}): any;
-export declare function mysql2persistence(pool: any, options?: {}): any;
-/**
- * drizzle persistence accepts a small repository object generated by the caller's schema.
- */
-export declare function drizzlepersistence(repository: any): any;
-/**
- * prisma persistence maps model delegates through an explicit model configuration.
- */
-export declare function prismapersistence(client: any, options?: {}): any;
-/**
- * migration plans stay neutral so Prisma, Drizzle, MySQL2, Turso, and another SQL driver can map them.
- */
-export declare const migrationlist: readonly {
-    version: number;
-    name: string;
-    tables: string[];
-}[];
-/** Returns pending migration statements for a dialect. */
-export declare function migrationplan(options?: {
-    current?: number;
-    dialect?: string;
-}): {
-    version: number;
-    name: string;
-    tables: string[];
-    statements: string[];
-    dialect: string;
-}[];
-/** Returns the latest schema version. */
-export declare function latestmigration(): number;