@cimplify/sdk 0.108.0 → 0.110.2

package/dist/weave-delivery-CW-Kstut.d.mts

@@ -0,0 +1,360 @@
+interface ChunkSource {
+    fetch(digest: string, signal?: AbortSignal, partial?: PartialChunk): Promise<Uint8Array>;
+    fetchRun?(digests: readonly string[], signal?: AbortSignal): Promise<readonly (Uint8Array | null)[]>;
+    /** A chunk's brotli twin, inflated under `cap`, or null when there is none or it is unusable. */
+    fetchTwin?(digest: string, cap: number, signal?: AbortSignal): Promise<Uint8Array | null>;
+}
+declare class PartialChunk {
+    private readonly parts;
+    private length;
+    get received(): number;
+    append(bytes: Uint8Array): void;
+    reset(): void;
+    join(): Uint8Array;
+}
+/**
+ * A chunk source that takes the brotli twin of each chunk `caps` names, inflated under its cap, when the upstream
+ * serves twins, and the chunk itself when the twin is missing, unusable or wrong.
+ */
+/**
+ * Serves the digests `held` names from `local`, checked against the digest, and everything else, or any local
+ * failure, from `upstream`.
+ */
+declare function localFirstChunks(local: ChunkSource, held: Promise<ReadonlySet<string>>, upstream: ChunkSource): ChunkSource;
+
+declare const PART_STORE_VERSION = 2;
+declare const LEGACY_PART_STORE_VERSION = 1;
+declare const DEFAULT_PART_STORE_BUDGET_BYTES: number;
+declare const DEFAULT_KEPT_BUDGET_BYTES: number;
+declare const DEFAULT_DISK_RESERVE_BYTES: number;
+declare const DEFAULT_PART_ZONE = "";
+type KeepReason = "manifest" | "user";
+declare const KEEP_REASONS: readonly KeepReason[];
+type EvictionReason = "budget" | "kept_quota" | "disk_pressure";
+interface ZonedPart {
+    readonly digest: string;
+    readonly zone: string;
+}
+type GamePart = string | ZonedPart;
+interface InstallOptions {
+    readonly keep_on_device?: boolean;
+}
+interface PartEviction {
+    readonly game: string;
+    readonly zone: string;
+    readonly parts: number;
+    readonly bytes: number;
+    readonly reason: EvictionReason;
+    readonly kept: boolean;
+}
+type StoredPart = readonly [digest: string, bytes: number, used: number];
+type InstalledZone = readonly [zone: string, played: number, digests: readonly string[]];
+type InstalledGame = readonly [game: string, zones: readonly InstalledZone[], keep: readonly KeepReason[]];
+type LegacyInstalledGame = readonly [game: string, digests: readonly string[]];
+interface PartStoreSnapshot {
+    readonly version: typeof PART_STORE_VERSION;
+    readonly clock: number;
+    readonly parts: readonly StoredPart[];
+    readonly games: readonly InstalledGame[];
+}
+interface LegacyPartStoreSnapshot {
+    readonly version: typeof LEGACY_PART_STORE_VERSION;
+    readonly clock: number;
+    readonly parts: readonly StoredPart[];
+    readonly games: readonly LegacyInstalledGame[];
+}
+interface PartStoreBackend {
+    read(digest: string): Promise<Uint8Array | null>;
+    write(digest: string, bytes: Uint8Array): Promise<void>;
+    remove(digest: string): Promise<void>;
+    load(): Promise<PartStoreSnapshot | LegacyPartStoreSnapshot | null>;
+    save(snapshot: PartStoreSnapshot): Promise<void>;
+}
+interface PartStoreDisk {
+    free_bytes(): Promise<number | null>;
+}
+interface PartStoreOptions {
+    readonly budget_bytes?: number;
+    readonly kept_budget_bytes?: number;
+    readonly disk_reserve_bytes?: number;
+    readonly disk?: PartStoreDisk;
+}
+interface PartStoreStats {
+    readonly bytes: number;
+    readonly parts: number;
+    readonly budget_bytes: number;
+    readonly feed_bytes: number;
+    readonly kept_bytes: number;
+    readonly kept_budget_bytes: number;
+    readonly referenced_bytes: number;
+    readonly pinned_bytes: number;
+    readonly games: number;
+    readonly kept_games: number;
+    readonly hits: number;
+    readonly misses: number;
+    readonly downloaded_bytes: number;
+    readonly evicted_bytes: number;
+}
+interface SizedDigest {
+    readonly digest: string;
+    readonly size: number;
+}
+type EvictionListener = (eviction: PartEviction) => void;
+declare class PartVerifyError extends Error {
+    readonly digest: string;
+    constructor(digest: string);
+}
+declare class MemoryPartBackend implements PartStoreBackend {
+    readonly bodies: Map<string, Uint8Array<ArrayBufferLike>>;
+    snapshot: PartStoreSnapshot | LegacyPartStoreSnapshot | null;
+    read(digest: string): Promise<Uint8Array | null>;
+    write(digest: string, bytes: Uint8Array): Promise<void>;
+    remove(digest: string): Promise<void>;
+    load(): Promise<PartStoreSnapshot | LegacyPartStoreSnapshot | null>;
+    save(snapshot: PartStoreSnapshot): Promise<void>;
+}
+declare class PartSession {
+    readonly store: SharedPartStore;
+    readonly game: string;
+    private readonly held;
+    private readonly listeners;
+    private readonly unwatch;
+    readonly installed: Promise<void>;
+    constructor(store: SharedPartStore, game: string, parts: readonly GamePart[], options?: InstallOptions);
+    source(upstream: ChunkSource): ChunkSource;
+    on_evicted(listener: EvictionListener): () => void;
+    hold(digest: string): void;
+    release(digest: string): void;
+    close(): void;
+}
+declare class SharedPartStore {
+    private readonly backend;
+    private readonly entries;
+    private readonly games;
+    private readonly refs;
+    private readonly keptRefs;
+    private readonly pins;
+    private readonly inflight;
+    private readonly listeners;
+    private readonly budget;
+    private readonly keptBudget;
+    private readonly reserve;
+    private readonly disk;
+    private clock;
+    private total;
+    private kept;
+    private hits;
+    private misses;
+    private downloaded;
+    private evicted;
+    private saving;
+    private dirty;
+    private constructor();
+    static open(backend: PartStoreBackend, options?: PartStoreOptions): Promise<SharedPartStore>;
+    private restore;
+    snapshot(): PartStoreSnapshot;
+    private persist;
+    flush(): Promise<void>;
+    private setGame;
+    private link;
+    private unlink;
+    private keepRef;
+    private unkeepRef;
+    install(game: string, parts: readonly GamePart[], options?: InstallOptions): Promise<void>;
+    uninstall(game: string): Promise<void>;
+    installed(game: string): readonly string[];
+    keep(game: string, reason?: KeepReason): Promise<void>;
+    release(game: string, reason?: KeepReason): Promise<void>;
+    keptReasons(game: string): readonly KeepReason[];
+    isKept(game: string): boolean;
+    played(game: string, digest: string): void;
+    resident(game: string, zone?: string): boolean;
+    on_evicted(listener: EvictionListener): () => void;
+    pin(digest: string): void;
+    unpin(digest: string): void;
+    pinned(digest: string): boolean;
+    has(digest: string): boolean;
+    size(digest: string): number | null;
+    refcount(digest: string): number;
+    missingBytes(refs: readonly SizedDigest[]): number;
+    uniqueBytes(game: string): number;
+    stats(): PartStoreStats;
+    read(digest: string): Promise<Uint8Array | null>;
+    fetch(digest: string, upstream: ChunkSource, signal?: AbortSignal, partial?: PartialChunk): Promise<Uint8Array>;
+    private load;
+    fetchRun(digests: readonly string[], upstream: ChunkSource, signal?: AbortSignal): Promise<(Uint8Array | null)[]>;
+    private loadRun;
+    peek(digest: string): Promise<Uint8Array | null>;
+    admit(digest: string, body: Uint8Array): Promise<void>;
+    source(upstream: ChunkSource): ChunkSource;
+    session(game: string, parts: readonly GamePart[], options?: InstallOptions): PartSession;
+    private drop;
+    private remove;
+    private enforce;
+    private tally;
+    private evictFeed;
+    private evictKept;
+}
+
+type Ed25519Verify = (key: Uint8Array, message: Uint8Array, signature: Uint8Array) => boolean;
+
+declare const WEAVE_VERSION = 1;
+declare const WEAVE_NODE_MAGIC = 1314281283;
+declare const WEAVE_NODE_HEADER_BYTES = 16;
+declare const WEAVE_LEAF_ENTRY_BYTES = 40;
+declare const WEAVE_CHILD_ENTRY_BYTES = 48;
+declare const WEAVE_MIN_NODE_ENTRIES = 16;
+declare const WEAVE_MAX_NODE_ENTRIES = 256;
+declare const WEAVE_BOUNDARY_MASK = 63;
+declare const WEAVE_MAX_HEIGHT = 8;
+declare const WEAVE_MAX_NODE_BYTES: number;
+declare const WEAVE_LEAF_DECORATED = 1;
+/** The chunk has a brotli twin (its signed entry carries `brotli_bytes`); hosts fetch the twin first. */
+declare const WEAVE_LEAF_TWINNED = 2;
+declare const WEAVE_HEAD_DOMAIN = "cimplify-weave-head-v1\n";
+declare const WEAVE_NODE_ZONE = "weave:nodes";
+interface WeaveRoot {
+    readonly version: number;
+    readonly root: string;
+    readonly parts: number;
+    readonly bytes: number;
+    readonly height: number;
+}
+interface WeaveLeaf {
+    readonly zone: number;
+    readonly flags: number;
+    readonly length: number;
+    readonly digest: string;
+}
+interface WeaveTree {
+    readonly root: WeaveRoot;
+    readonly nodes: ReadonlyMap<string, Uint8Array>;
+}
+declare const WeaveRefusal: {
+    readonly digest: "digest";
+    readonly malformed: "malformed";
+    readonly summary: "summary";
+    readonly height: "height";
+    readonly missing: "missing";
+    readonly head: "head";
+};
+type WeaveRefusal = (typeof WeaveRefusal)[keyof typeof WeaveRefusal];
+declare class WeaveVerifyError extends Error {
+    readonly refusal: WeaveRefusal;
+    readonly digest: string;
+    constructor(refusal: WeaveRefusal, digest: string);
+}
+declare function buildWeave(leaves: readonly WeaveLeaf[]): WeaveTree;
+declare function nodeMatches(node: Uint8Array, expected: Uint8Array, at: number): boolean;
+declare function weaveNodeLevel(node: Uint8Array): number;
+declare function weaveNodeCount(node: Uint8Array): number;
+declare function weaveNodeValid(node: Uint8Array): boolean;
+declare function leafAt(index: number): number;
+declare function leafZone(node: Uint8Array, index: number): number;
+declare function leafFlags(node: Uint8Array, index: number): number;
+declare function leafLength(node: Uint8Array, index: number): number;
+declare function leafDigestAt(index: number): number;
+declare function leafDigest(node: Uint8Array, index: number): string;
+declare function childDigestAt(index: number): number;
+declare function verifyChild(node: Uint8Array, parent: Uint8Array, index: number): WeaveRefusal | null;
+declare function verifyRoot(node: Uint8Array, root: WeaveRoot): WeaveRefusal | null;
+interface WeaveNodeSource {
+    local(digest: string): Promise<Uint8Array | null>;
+    fetch(digest: string): Promise<Uint8Array>;
+    admit?(digest: string, node: Uint8Array): Promise<void>;
+}
+type WeaveLeafVisitor = (node: Uint8Array, index: number, changed: boolean) => void;
+interface WeaveWalk {
+    readonly nodes: number;
+    readonly fetched_nodes: number;
+    readonly fetched_bytes: number;
+    readonly changed_nodes: number;
+    readonly parts: number;
+    readonly node_digests: readonly string[];
+}
+declare function walkWeave(root: WeaveRoot, source: WeaveNodeSource, visit: WeaveLeafVisitor, old?: WeaveRoot | null): Promise<WeaveWalk>;
+declare function weaveHeadMessage(head: Uint8Array): Uint8Array;
+declare function validWeaveRoot(value: unknown): value is WeaveRoot;
+
+interface WeaveRuntimeTag {
+    readonly name: string;
+    readonly version: string;
+}
+interface WeaveHeadGroup {
+    readonly name: string;
+    readonly before_play: boolean;
+}
+interface WeaveHeadChunk {
+    readonly digest: string;
+    readonly size: number;
+    readonly group: number;
+    readonly runtime?: WeaveRuntimeTag | null;
+    readonly payload_digest?: string | null;
+    readonly brotli_bytes?: number | null;
+    readonly guest?: string | null;
+}
+interface WeaveHead {
+    readonly interactive_id: string;
+    readonly revision_id: string;
+    readonly asset_groups: readonly WeaveHeadGroup[];
+    readonly chunks: readonly WeaveHeadChunk[];
+    readonly weave: WeaveRoot;
+    readonly keep_on_device?: boolean;
+}
+interface PackageWeaveRef {
+    readonly root: WeaveRoot;
+    readonly head: string;
+    readonly signature: string;
+    readonly key_id: string;
+}
+interface WeaveTrust {
+    readonly keys: Readonly<Record<string, string>>;
+    readonly verify: Ed25519Verify;
+}
+interface WeaveChunk {
+    readonly digest: string;
+    readonly size: number;
+    readonly asset_group: string;
+    readonly before_play: boolean;
+    readonly lazy: boolean;
+    readonly runtime: WeaveRuntimeTag | null;
+    readonly payload_digest: string | null;
+    /** The chunk has a brotli twin to fetch first; absent when it has none. */
+    readonly twinned?: true;
+}
+interface WeaveScheduled {
+    readonly digest: string;
+    readonly size: number;
+    readonly zone: string;
+}
+interface WeavePlan {
+    readonly head: WeaveHead;
+    readonly chunks: readonly WeaveChunk[];
+    readonly schedule: readonly WeaveScheduled[];
+    readonly schedule_bytes: number;
+    readonly walk: WeaveWalk;
+}
+declare function openWeaveHead(weave: PackageWeaveRef, trust?: WeaveTrust | null): WeaveHead;
+declare function storeWeaveSource(store: SharedPartStore, upstream: ChunkSource): WeaveNodeSource;
+declare function chunkWeaveSource(upstream: ChunkSource): WeaveNodeSource;
+declare function planWeave(head: WeaveHead, store: SharedPartStore, upstream: ChunkSource, old?: WeaveRoot | null): Promise<WeavePlan>;
+interface WovenIndex {
+    readonly weave?: PackageWeaveRef;
+    readonly chunks: readonly unknown[];
+}
+declare function woven(index: WovenIndex): boolean;
+declare function unweaveIndex<T extends WovenIndex>(index: T, nodes: WeaveNodeSource, trust?: WeaveTrust | null, old?: WeaveRoot | null): Promise<{
+    readonly index: Omit<T, "chunks"> & {
+        readonly chunks: readonly WeaveChunk[];
+    };
+    readonly plan: WeavePlan;
+}>;
+declare function weaveParts(plan: WeavePlan): GamePart[];
+interface WeaveSession {
+    readonly plan: WeavePlan;
+    readonly session: PartSession;
+}
+declare function openWeaveSession(store: SharedPartStore, game: string, head: WeaveHead, upstream: ChunkSource, old?: WeaveRoot | null, options?: InstallOptions): Promise<WeaveSession>;
+declare function deliverSchedule(session: PartSession, upstream: ChunkSource, schedule: readonly WeaveScheduled[], signal?: AbortSignal): Promise<number>;
+
+export { type WeaveWalk as $, WEAVE_NODE_ZONE as A, WEAVE_VERSION as B, type ChunkSource as C, DEFAULT_DISK_RESERVE_BYTES as D, type EvictionListener as E, type WeaveChunk as F, type GamePart as G, type WeaveHead as H, type InstallOptions as I, type WeaveHeadChunk as J, KEEP_REASONS as K, type WeaveHeadGroup as L, MemoryPartBackend as M, type WeaveLeaf as N, type WeaveLeafVisitor as O, type PartStoreBackend as P, type WeaveNodeSource as Q, type WeavePlan as R, SharedPartStore as S, WeaveRefusal as T, type WeaveRoot as U, type WeaveRuntimeTag as V, type WeaveTrust as W, type WeaveScheduled as X, type WeaveSession as Y, type WeaveTree as Z, WeaveVerifyError as _, type PartStoreSnapshot as a, type WovenIndex as a0, buildWeave as a1, childDigestAt as a2, chunkWeaveSource as a3, deliverSchedule as a4, leafAt as a5, leafDigest as a6, leafDigestAt as a7, leafFlags as a8, leafLength as a9, leafZone as aa, nodeMatches as ab, openWeaveHead as ac, openWeaveSession as ad, planWeave as ae, storeWeaveSource as af, unweaveIndex as ag, validWeaveRoot as ah, verifyChild as ai, verifyRoot as aj, walkWeave as ak, weaveHeadMessage as al, weaveNodeCount as am, weaveNodeLevel as an, weaveNodeValid as ao, weaveParts as ap, woven as aq, type PartStoreOptions as b, type PartStoreDisk as c, DEFAULT_KEPT_BUDGET_BYTES as d, DEFAULT_PART_STORE_BUDGET_BYTES as e, DEFAULT_PART_ZONE as f, type EvictionReason as g, type KeepReason as h, type PartEviction as i, PartSession as j, type PartStoreStats as k, PartVerifyError as l, localFirstChunks as m, type PackageWeaveRef as n, WEAVE_BOUNDARY_MASK as o, WEAVE_CHILD_ENTRY_BYTES as p, WEAVE_HEAD_DOMAIN as q, WEAVE_LEAF_DECORATED as r, WEAVE_LEAF_ENTRY_BYTES as s, WEAVE_LEAF_TWINNED as t, WEAVE_MAX_HEIGHT as u, WEAVE_MAX_NODE_BYTES as v, WEAVE_MAX_NODE_ENTRIES as w, WEAVE_MIN_NODE_ENTRIES as x, WEAVE_NODE_HEADER_BYTES as y, WEAVE_NODE_MAGIC as z };