@graphrefly/graphrefly 0.34.0 → 0.35.0

package/dist/extra/storage-tiers-node.d.cts

@@ -0,0 +1,86 @@
+import { AppendLogStorageOptions, AppendLogStorageTier, StorageBackend, KvStorageOptions, KvStorageTier, SnapshotStorageOptions, SnapshotStorageTier } from './storage-tiers.cjs';
+
+/**
+ * Node-only Audit 4 storage backends + convenience factories.
+ *
+ * Imports `node:fs`, `node:path`, `node:crypto`, `node:sqlite`. Browser-safe
+ * consumers should not import this module.
+ *
+ * @module
+ */
+
+/**
+ * Filesystem backend. Each key becomes a file under `dir`; values are written
+ * via temp + rename for atomic replace.
+ *
+ * @category extra
+ */
+declare function fileBackend(dir: string): StorageBackend;
+/**
+ * SQLite backend (Node 22.5+ `node:sqlite`). Stores byte values under string
+ * keys in a single table; caller owns the connection lifetime via `close()`.
+ *
+ * @category extra
+ */
+declare function sqliteBackend(path: string): StorageBackend & {
+    close(): void;
+};
+/**
+ * Filesystem snapshot tier — `snapshotStorage(fileBackend(dir), opts)`.
+ *
+ * @category extra
+ */
+declare function fileSnapshot<T>(dir: string, opts?: Omit<SnapshotStorageOptions<T>, "name"> & {
+    name?: string;
+}): SnapshotStorageTier<T>;
+/**
+ * Filesystem append-log tier — `appendLogStorage(fileBackend(dir), opts)`.
+ *
+ * @category extra
+ */
+declare function fileAppendLog<T>(dir: string, opts?: Omit<AppendLogStorageOptions<T>, "name"> & {
+    name?: string;
+}): AppendLogStorageTier<T>;
+/**
+ * SQLite snapshot tier — caller owns the connection. Use the underlying
+ * backend's `close()` for explicit teardown.
+ *
+ * @category extra
+ */
+declare function sqliteSnapshot<T>(path: string, opts?: Omit<SnapshotStorageOptions<T>, "name"> & {
+    name?: string;
+}): SnapshotStorageTier<T> & {
+    close(): void;
+};
+/**
+ * SQLite append-log tier — caller owns the connection. Use the underlying
+ * backend's `close()` for explicit teardown.
+ *
+ * @category extra
+ */
+declare function sqliteAppendLog<T>(path: string, opts?: Omit<AppendLogStorageOptions<T>, "name"> & {
+    name?: string;
+}): AppendLogStorageTier<T> & {
+    close(): void;
+};
+/**
+ * Filesystem kv tier — `kvStorage(fileBackend(dir), opts)`.
+ *
+ * @category extra
+ */
+declare function fileKv<T>(dir: string, opts?: Omit<KvStorageOptions<T>, "name"> & {
+    name?: string;
+}): KvStorageTier<T>;
+/**
+ * SQLite kv tier — caller owns the connection. Use the underlying
+ * backend's `close()` for explicit teardown.
+ *
+ * @category extra
+ */
+declare function sqliteKv<T>(path: string, opts?: Omit<KvStorageOptions<T>, "name"> & {
+    name?: string;
+}): KvStorageTier<T> & {
+    close(): void;
+};
+
+export { fileAppendLog, fileBackend, fileKv, fileSnapshot, sqliteAppendLog, sqliteBackend, sqliteKv, sqliteSnapshot };

package/dist/extra/storage-tiers-node.d.ts

@@ -0,0 +1,86 @@
+import { AppendLogStorageOptions, AppendLogStorageTier, StorageBackend, KvStorageOptions, KvStorageTier, SnapshotStorageOptions, SnapshotStorageTier } from './storage-tiers.js';
+
+/**
+ * Node-only Audit 4 storage backends + convenience factories.
+ *
+ * Imports `node:fs`, `node:path`, `node:crypto`, `node:sqlite`. Browser-safe
+ * consumers should not import this module.
+ *
+ * @module
+ */
+
+/**
+ * Filesystem backend. Each key becomes a file under `dir`; values are written
+ * via temp + rename for atomic replace.
+ *
+ * @category extra
+ */
+declare function fileBackend(dir: string): StorageBackend;
+/**
+ * SQLite backend (Node 22.5+ `node:sqlite`). Stores byte values under string
+ * keys in a single table; caller owns the connection lifetime via `close()`.
+ *
+ * @category extra
+ */
+declare function sqliteBackend(path: string): StorageBackend & {
+    close(): void;
+};
+/**
+ * Filesystem snapshot tier — `snapshotStorage(fileBackend(dir), opts)`.
+ *
+ * @category extra
+ */
+declare function fileSnapshot<T>(dir: string, opts?: Omit<SnapshotStorageOptions<T>, "name"> & {
+    name?: string;
+}): SnapshotStorageTier<T>;
+/**
+ * Filesystem append-log tier — `appendLogStorage(fileBackend(dir), opts)`.
+ *
+ * @category extra
+ */
+declare function fileAppendLog<T>(dir: string, opts?: Omit<AppendLogStorageOptions<T>, "name"> & {
+    name?: string;
+}): AppendLogStorageTier<T>;
+/**
+ * SQLite snapshot tier — caller owns the connection. Use the underlying
+ * backend's `close()` for explicit teardown.
+ *
+ * @category extra
+ */
+declare function sqliteSnapshot<T>(path: string, opts?: Omit<SnapshotStorageOptions<T>, "name"> & {
+    name?: string;
+}): SnapshotStorageTier<T> & {
+    close(): void;
+};
+/**
+ * SQLite append-log tier — caller owns the connection. Use the underlying
+ * backend's `close()` for explicit teardown.
+ *
+ * @category extra
+ */
+declare function sqliteAppendLog<T>(path: string, opts?: Omit<AppendLogStorageOptions<T>, "name"> & {
+    name?: string;
+}): AppendLogStorageTier<T> & {
+    close(): void;
+};
+/**
+ * Filesystem kv tier — `kvStorage(fileBackend(dir), opts)`.
+ *
+ * @category extra
+ */
+declare function fileKv<T>(dir: string, opts?: Omit<KvStorageOptions<T>, "name"> & {
+    name?: string;
+}): KvStorageTier<T>;
+/**
+ * SQLite kv tier — caller owns the connection. Use the underlying
+ * backend's `close()` for explicit teardown.
+ *
+ * @category extra
+ */
+declare function sqliteKv<T>(path: string, opts?: Omit<KvStorageOptions<T>, "name"> & {
+    name?: string;
+}): KvStorageTier<T> & {
+    close(): void;
+};
+
+export { fileAppendLog, fileBackend, fileKv, fileSnapshot, sqliteAppendLog, sqliteBackend, sqliteKv, sqliteSnapshot };

package/dist/extra/storage-tiers-node.js

@@ -0,0 +1 @@
+import{a,b,c,d,e,f,g,h}from"../chunk-VN6RDSK2.js";import"../chunk-D5RFJOZ2.js";import"../chunk-CE72X3WO.js";import"../chunk-QYADASLV.js";export{d as fileAppendLog,a as fileBackend,g as fileKv,c as fileSnapshot,f as sqliteAppendLog,b as sqliteBackend,h as sqliteKv,e as sqliteSnapshot};

package/dist/extra/storage-tiers.cjs

@@ -0,0 +1 @@
+"use strict";var w=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var U=Object.getOwnPropertyNames;var B=Object.prototype.hasOwnProperty;var K=(e,n)=>{for(var t in n)w(e,t,{get:n[t],enumerable:!0})},L=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of U(n))!B.call(e,o)&&o!==t&&w(e,o,{get:()=>n[o],enumerable:!(r=E(n,o))||r.enumerable});return e};var j=e=>L(w({},"__esModule",{value:!0}),e);var H={};K(H,{appendLogStorage:()=>O,dictKv:()=>W,dictSnapshot:()=>D,jsonCodec:()=>h,jsonCodecFor:()=>N,kvStorage:()=>b,memoryAppendLog:()=>_,memoryBackend:()=>S,memoryKv:()=>z,memorySnapshot:()=>F,snapshotStorage:()=>A});module.exports=j(H);function P(e){if(e===null||typeof e!="object")return e;if(Array.isArray(e))return e.map(P);let n=e,t=Object.keys(n).sort(),r={};for(let o of t)r[o]=P(n[o]);return r}function x(e){return JSON.stringify(P(e),void 0,0)}var R=new TextEncoder,J=new TextDecoder("utf-8",{fatal:!0}),h={name:"json",version:1,encode(e){return R.encode(x(e))},decode(e){return JSON.parse(J.decode(e))}};function N(){return h}function S(){let e=new Map;return{name:"memory",read(n){let t=e.get(n);return t===void 0?void 0:new Uint8Array(t)},write(n,t){e.set(n,new Uint8Array(t))},delete(n){e.delete(n)},list(n){let t=[...e.keys()];return n?t.filter(r=>r.startsWith(n)).sort():t.sort()}}}function A(e,n={}){let t=n.codec??h,r=n.name??e.name??"snapshot",o=n.keyOf??(c=>c.name??n.name??e.name??"snapshot"),a,m=0,y=n.compactEvery,l,f={name:r,debounceMs:n.debounceMs,compactEvery:y,filter:n.filter,keyOf:o,save(c){if(!(n.filter&&!n.filter(c))&&(a={snapshot:c},m+=1,y!==void 0&&m%y===0||!n.debounceMs))return d()},load(){let c=l??r,i=e.read(c);if(i!==void 0)return i instanceof Uint8Array?i.length===0?void 0:t.decode(i):Promise.resolve(i).then(s=>s===void 0||s.length===0?void 0:t.decode(s))},async flush(){await d()},async rollback(){a=void 0}};function d(){let c=a;if(!c)return;a=void 0;let i=o(c.snapshot),s=t.encode(c.snapshot),u=e.write(i,s);if(u instanceof Promise)return u.then(()=>{l=i});l=i}return f}function O(e,n={}){let t=n.codec??h,r=n.name??e.name??"append-log",o=n.keyOf??(i=>r),a=n.compactEvery,m=new Map,y=0,l,f={name:r,debounceMs:n.debounceMs,compactEvery:a,keyOf:o,appendEntries(i){if(i.length!==0){for(let s of i){let u=o(s),g=m.get(u);g||(g=[],m.set(u,g)),g.push(s)}if(y+=i.length,a!==void 0&&y%a===0||!n.debounceMs)return d()}},async loadEntries(i){let s=i?.keyFilter,u=e.list===void 0?s!==void 0?[s]:[r]:await Promise.resolve(e.list(s)),g=[];for(let v of u){let T=await Promise.resolve(e.read(v));if(T===void 0||T.length===0)continue;let p=t.decode(T);Array.isArray(p)&&g.push(...p)}return{entries:g,cursor:void 0}},async flush(){await d()},async rollback(){m=new Map}};function d(){if(m.size===0)return;let i=m;m=new Map;let s=(l??Promise.resolve()).then(()=>{let u=c(i);return u instanceof Promise?u:Promise.resolve()},()=>{let u=c(i);return u instanceof Promise?u:Promise.resolve()});return l=s.finally(()=>{l===s&&(l=void 0)}),l}function c(i){let s=[];for(let[u,g]of i){let v=e.read(u),T=p=>{let M=[...p===void 0||p.length===0?[]:t.decode(p)??[],...g],C=t.encode(M);return e.write(u,C)};if(v instanceof Promise)s.push(v.then(async p=>{let k=T(p);k instanceof Promise&&await k}));else{let p=T(v);p instanceof Promise&&s.push(p)}}if(s.length>0)return Promise.all(s).then(()=>{})}return f}function b(e,n={}){let t=n.codec??h,r=n.name??e.name??"kv",o=n.compactEvery,a=new Map,m=0,y={name:r,debounceMs:n.debounceMs,compactEvery:o,filter:n.filter,save(f,d){if(!(n.filter&&!n.filter(f,d))&&(a.set(f,d),m+=1,o!==void 0&&m%o===0||!n.debounceMs))return l()},load(f){let d=e.read(f);if(d!==void 0)return d instanceof Uint8Array?d.length===0?void 0:t.decode(d):Promise.resolve(d).then(c=>c===void 0||c.length===0?void 0:t.decode(c))},delete(f){if(a.delete(f),!!e.delete)return e.delete(f)},list(f){return e.list?e.list(f):[]},async flush(){await l()},async rollback(){a=new Map}};function l(){if(a.size===0)return;let f=a;a=new Map;let d=[];for(let[c,i]of f){let s=t.encode(i),u=e.write(c,s);u instanceof Promise&&d.push(u)}if(d.length>0)return Promise.all(d).then(()=>{})}return y}function F(e){return A(S(),e)}function _(e){return O(S(),e)}function z(e){return b(S(),e)}function W(e,n){let t={name:n?.name??"dict-kv",read(r){return e[r]},write(r,o){e[r]=new Uint8Array(o)},delete(r){delete e[r]},list(r){let o=Object.keys(e).sort();return r?o.filter(a=>a.startsWith(r)):o}};return b(t,n)}function D(e,n){return A({name:"dict",read(r){return e[r]},write(r,o){e[r]=new Uint8Array(o)},delete(r){delete e[r]},list(r){let o=Object.keys(e).sort();return r?o.filter(a=>a.startsWith(r)):o}},n)}0&&(module.exports={appendLogStorage,dictKv,dictSnapshot,jsonCodec,jsonCodecFor,kvStorage,memoryAppendLog,memoryBackend,memoryKv,memorySnapshot,snapshotStorage});

package/dist/extra/storage-tiers.d.cts

@@ -0,0 +1,284 @@
+/**
+ * Storage tier architecture (Audit 4 — locked 2026-04-24).
+ *
+ * Three-layer design:
+ *
+ * - **Layer 1 — {@link StorageBackend}:** generic bytes-level kv I/O. One
+ *   `read(key) → Uint8Array | undefined`, `write(key, bytes)`, optional
+ *   `delete(key)` / `list(prefix)`. No tier-level concerns (debounce, codec).
+ * - **Layer 2 — Tier specializations** layered over a backend, parametric over
+ *   `T`: {@link SnapshotStorageTier} (one snapshot under one key) and
+ *   {@link AppendLogStorageTier} (sequential entries, optional partition via
+ *   `keyOf`). Both extend {@link BaseStorageTier} which carries
+ *   `flush?` / `rollback?` for the wave-as-transaction model.
+ * - **Layer 3 — High-level wiring:** `Graph.attachSnapshotStorage(tiers)`,
+ *   `reactiveLog.attachStorage(tiers)`, `cqrsGraph.attachEventStorage(tiers)`,
+ *   `jobQueueGraph.attachEventStorage(tiers)`. These layers consume tier
+ *   specializations directly — they don't see the backend.
+ *
+ * Browser-safe by default. {@link memoryBackend} + the in-memory factories
+ * live here; Node-only (`fileBackend` / `sqliteBackend`) lives in
+ * `extra/storage-node.ts`; browser-only (`indexedDbBackend`) lives in
+ * `extra/storage-browser.ts`.
+ *
+ * @module
+ */
+/**
+ * Bytes-level kv backend. One responsibility: read/write byte ranges under
+ * string keys. Tier specializations layer on top.
+ *
+ * @category extra
+ */
+interface StorageBackend {
+    /** Diagnostic name (e.g., `"memory"`, `"file:./checkpoints"`). */
+    readonly name: string;
+    /** Read raw bytes; returns `undefined` on miss. */
+    read(key: string): Uint8Array | undefined | Promise<Uint8Array | undefined>;
+    /** Write raw bytes. Sync backends return `void`; async return `Promise<void>`. */
+    write(key: string, bytes: Uint8Array): void | Promise<void>;
+    /** Optional delete-by-key. */
+    delete?(key: string): void | Promise<void>;
+    /** Optional enumeration; `prefix` filters keys. */
+    list?(prefix?: string): readonly string[] | Promise<readonly string[]>;
+    /** Optional drain hook — adapter authors implement when buffering writes. */
+    flush?(): Promise<void>;
+}
+/**
+ * Codec for tier serialization. Tiers call `encode(value) → bytes` before
+ * `backend.write` and `decode(bytes) → value` after `backend.read`.
+ *
+ * @category extra
+ */
+interface Codec<T = unknown> {
+    readonly name: string;
+    readonly version: number;
+    encode(value: T): Uint8Array;
+    decode(bytes: Uint8Array): T;
+}
+/**
+ * Default JSON codec — UTF-8 text, stable key order (via `stableJsonString`).
+ * Any value JSON-serializable is supported.
+ *
+ * @category extra
+ */
+declare const jsonCodec: Codec<unknown>;
+/** Build a `Codec<T>` over the default JSON encoding. Pure typing helper. */
+declare function jsonCodecFor<T>(): Codec<T>;
+/**
+ * Common tier surface: name + cadence knobs + transaction lifecycle.
+ *
+ * Lifecycle hooks (`flush` / `rollback`) implement Audit 4's "one wave = one
+ * transaction" model. Framework integration:
+ *  - After every wave (and on `batch()` close), framework iterates attached
+ *    tiers and calls `tier.flush()` if exposed.
+ *  - On wave-throw (per C.2 F rollback policy), framework calls
+ *    `tier.rollback()` if exposed — pending writes discarded.
+ *  - Cross-tier atomicity is best-effort. Each tier is its own transaction.
+ *
+ * @category extra
+ */
+interface BaseStorageTier {
+    readonly name: string;
+    /** Debounce window (ms). `0` = sync-through; >0 batches across waves. */
+    readonly debounceMs?: number;
+    /** Force flush every Nth write regardless of debounce. */
+    readonly compactEvery?: number;
+    /** Commit pending; framework calls at wave-close / debounce-fire. */
+    flush?(): Promise<void>;
+    /** Discard pending; framework calls on wave-throw. */
+    rollback?(): Promise<void>;
+}
+/**
+ * Snapshot tier — writes a single record per `save(snapshot)` call.
+ *
+ * The tier maps the snapshot to a backend key via `keyOf(snapshot)` (default
+ * `() => name ?? "snapshot"`). For `Graph.attachSnapshotStorage`, the framework
+ * supplies a closure that pulls the graph name out of the record envelope.
+ *
+ * @category extra
+ */
+interface SnapshotStorageTier<T = unknown> extends BaseStorageTier {
+    save(snapshot: T): void | Promise<void>;
+    load?(): T | Promise<T | undefined> | undefined;
+    /** Skip-save policy — return `false` to skip persisting this snapshot. */
+    filter?: (snapshot: T) => boolean;
+    /** Extract the backend key per-snapshot; default `() => name ?? "snapshot"`. */
+    keyOf?: (snapshot: T) => string;
+}
+/**
+ * Append-log tier — bulk-friendly entry persistence with optional partitioning.
+ *
+ * Entries are appended to a logical stream; `keyOf?` partitions across backend
+ * keys (e.g., `(e) => `${e.type}::${e.aggregateId}`` for CQRS).
+ *
+ * @category extra
+ */
+interface AppendLogStorageTier<T = unknown> extends BaseStorageTier {
+    appendEntries(entries: readonly T[]): void | Promise<void>;
+    loadEntries?(opts?: {
+        cursor?: AppendCursor;
+        pageSize?: number;
+        keyFilter?: string;
+    }): AppendLoadResult<T> | Promise<AppendLoadResult<T>>;
+    /** Partition key per-entry (default `() => name ?? "append-log"`). */
+    keyOf?: (entry: T) => string;
+}
+/** Opaque cursor for windowed `loadEntries` pagination. */
+type AppendCursor = Readonly<{
+    position: number;
+    tag?: string;
+}> & {
+    readonly __brand: "AppendCursor";
+};
+type AppendLoadResult<T> = {
+    entries: readonly T[];
+    cursor: AppendCursor | undefined;
+};
+/**
+ * In-process bytes backend backed by `Map<string, Uint8Array>`. Useful for
+ * tests, hot tiers, and as a default for the convenience factories below.
+ *
+ * @category extra
+ */
+declare function memoryBackend(): StorageBackend;
+type SnapshotStorageOptions<T> = {
+    name?: string;
+    codec?: Codec<T>;
+    debounceMs?: number;
+    compactEvery?: number;
+    filter?: (snapshot: T) => boolean;
+    keyOf?: (snapshot: T) => string;
+};
+/**
+ * Wrap a {@link StorageBackend} as a typed snapshot tier.
+ *
+ * Buffer model: `save(snapshot)` accumulates one pending snapshot in memory.
+ * `flush()` encodes via codec and writes to the backend under
+ * `keyOf(snapshot)` (default `name ?? "snapshot"`). `rollback()` discards
+ * the pending write.
+ *
+ * @category extra
+ */
+declare function snapshotStorage<T>(backend: StorageBackend, opts?: SnapshotStorageOptions<T>): SnapshotStorageTier<T>;
+type AppendLogStorageOptions<T> = {
+    name?: string;
+    codec?: Codec<readonly T[]>;
+    keyOf?: (entry: T) => string;
+    debounceMs?: number;
+    compactEvery?: number;
+};
+/**
+ * Wrap a {@link StorageBackend} as a typed append-log tier.
+ *
+ * Buffer model: `appendEntries(entries)` accumulates per-key buckets in
+ * memory. `flush()` encodes each bucket as a JSON array via codec and writes
+ * under that bucket key. `rollback()` discards pending appends.
+ *
+ * Storage shape: each backend key holds a JSON array of all entries for that
+ * partition, growing on every flush. Adapters that need true append semantics
+ * (versus rewrite) should layer their own tier impl over the same backend.
+ *
+ * @category extra
+ */
+declare function appendLogStorage<T>(backend: StorageBackend, opts?: AppendLogStorageOptions<T>): AppendLogStorageTier<T>;
+/**
+ * Key-value tier — typed records under arbitrary string keys with codec
+ * serialization at the storage-tier boundary. Use for content-addressed
+ * caches (replay), multi-record archives (snapshot index, AI memory), and
+ * fixture stores. Snapshot tier is "one record"; append-log is "sequential
+ * entries"; kv is "many records, addressable by key".
+ *
+ * @category extra
+ */
+interface KvStorageTier<T = unknown> extends BaseStorageTier {
+    load(key: string): T | undefined | Promise<T | undefined>;
+    save(key: string, value: T): void | Promise<void>;
+    delete?(key: string): void | Promise<void>;
+    list?(prefix?: string): readonly string[] | Promise<readonly string[]>;
+    /** Pre-save filter — return `false` to skip persisting this record. */
+    filter?: (key: string, value: T) => boolean;
+}
+type KvStorageOptions<T> = {
+    name?: string;
+    codec?: Codec<T>;
+    debounceMs?: number;
+    compactEvery?: number;
+    filter?: (key: string, value: T) => boolean;
+};
+/**
+ * Wrap a {@link StorageBackend} as a typed kv tier.
+ *
+ * Buffer model: `save(k, v)` encodes via codec and writes to the backend
+ * unless debounced. Pending writes are committed on `flush()` and discarded
+ * on `rollback()` — the wave-as-transaction model.
+ *
+ * @category extra
+ */
+declare function kvStorage<T>(backend: StorageBackend, opts?: KvStorageOptions<T>): KvStorageTier<T>;
+/**
+ * In-memory snapshot tier — `snapshotStorage(memoryBackend(), opts)`.
+ *
+ * @category extra
+ */
+declare function memorySnapshot<T>(opts?: Omit<SnapshotStorageOptions<T>, "name"> & {
+    name?: string;
+}): SnapshotStorageTier<T>;
+/**
+ * In-memory append-log tier — `appendLogStorage(memoryBackend(), opts)`.
+ *
+ * @category extra
+ */
+declare function memoryAppendLog<T>(opts?: Omit<AppendLogStorageOptions<T>, "name"> & {
+    name?: string;
+}): AppendLogStorageTier<T>;
+/**
+ * In-memory kv tier — `kvStorage(memoryBackend(), opts)`.
+ *
+ * @category extra
+ */
+declare function memoryKv<T>(opts?: Omit<KvStorageOptions<T>, "name"> & {
+    name?: string;
+}): KvStorageTier<T>;
+/**
+ * Dict-backed kv tier — wraps a caller-owned plain object as a
+ * {@link StorageBackend} and returns a kv tier over it. Useful for
+ * embedding in a parent state shape or for tests that need access to the
+ * raw bytes.
+ *
+ * The dict stores raw encoded bytes as `Uint8Array`. Use `opts.name` to
+ * control the tier's diagnostic name (defaults to `"dict-kv"`).
+ *
+ * @example
+ * ```ts
+ * const store: Record<string, Uint8Array> = {};
+ * const tier = dictKv<MyRecord>(store);
+ * await tier.save("key1", myRecord);
+ * ```
+ *
+ * @category extra
+ */
+declare function dictKv<T>(storage: Record<string, Uint8Array>, opts?: Omit<KvStorageOptions<T>, "name"> & {
+    name?: string;
+}): KvStorageTier<T>;
+/**
+ * Dict-backed snapshot tier — wraps a caller-owned plain object as a
+ * {@link StorageBackend} and returns a snapshot tier over it. Useful for
+ * embedding checkpoints inside a parent state shape or for tests that need
+ * access to the raw bytes.
+ *
+ * The dict stores raw JSON bytes as `Uint8Array`. Use `opts.name` to control
+ * the storage key (defaults to `"snapshot"`).
+ *
+ * @example
+ * ```ts
+ * const store: Record<string, Uint8Array> = {};
+ * graph.attachSnapshotStorage([dictSnapshot(store, { name: graph.name })]);
+ * ```
+ *
+ * @category extra
+ */
+declare function dictSnapshot<T>(storage: Record<string, Uint8Array>, opts?: Omit<SnapshotStorageOptions<T>, "name"> & {
+    name?: string;
+}): SnapshotStorageTier<T>;
+
+export { type AppendCursor, type AppendLoadResult, type AppendLogStorageOptions, type AppendLogStorageTier, type BaseStorageTier, type Codec, type KvStorageOptions, type KvStorageTier, type SnapshotStorageOptions, type SnapshotStorageTier, type StorageBackend, appendLogStorage, dictKv, dictSnapshot, jsonCodec, jsonCodecFor, kvStorage, memoryAppendLog, memoryBackend, memoryKv, memorySnapshot, snapshotStorage };