@wenathlan/saddle 1.8.18 → 2.0.2

package/dist/virtual.d.ts

@@ -0,0 +1,641 @@
+/**
+ * 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;
+//# sourceMappingURL=virtual.d.ts.map

package/dist/virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.d.ts","sourceRoot":"","sources":["../virtual.ts"],"names":[],"mappings":"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"}