@prometheus-ags/entity-graph-core 3.0.0-alpha.0 → 3.0.0

package/dist/index.d.cts

@@ -1,5 +1,4 @@
-import * as zustand from 'zustand';
-import React from 'react';
+import * as zustand_vanilla from 'zustand/vanilla';
 
 /**
  * Typed errors used throughout 2.0 to drive retry policy and consumer
@@ -140,7 +139,8 @@ declare const EMPTY_SYNC_METADATA: EntitySyncMetadata;
 declare const EMPTY_LIST_STATE: ListState;
 /**
  * Canonical Zustand store: **entities** (server truth), **patches** (UI-only overlay), **lists** (id order + list meta), and **entityStates** (per-entity fetch state).
- * Prefer hooks for React reads; use `useGraphStore.getState()` inside stores/adapters/engine code where React is not available.
+ * Framework bindings subscribe to the vanilla store; stores, adapters, and
+ * engines can read it synchronously through `graphStore.getState()`.
  */
 interface GraphState {
     /** Normalized server-confirmed records. Mutate only via upsert/replace/remove — not from components. */
@@ -245,11 +245,209 @@ interface GraphState {
      */
     readEntitySnapshot: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => EntitySnapshot<T & Record<string, unknown>> | null;
 }
+/** Creates an isolated, framework-neutral entity graph store. */
+declare function createGraphStore(): Omit<Omit<zustand_vanilla.StoreApi<GraphState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: GraphState, previousSelectedState: GraphState) => void): () => void;
+        <U>(selector: (state: GraphState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: GraphState | Partial<GraphState> | ((state: {
+        entities: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        patches: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        entityStates: {
+            [x: string]: {
+                isFetching: boolean;
+                lastFetched: number | null;
+                error: string | null;
+                stale: boolean;
+            };
+        };
+        syncMetadata: {
+            [x: string]: {
+                synced: boolean;
+                origin: SyncOrigin;
+                updatedAt: number | null;
+            };
+        };
+        lists: {
+            [x: string]: {
+                ids: string[];
+                total: number | null;
+                nextCursor: string | null;
+                prevCursor: string | null;
+                hasNextPage: boolean;
+                hasPrevPage: boolean;
+                isFetching: boolean;
+                isFetchingMore: boolean;
+                error: string | null;
+                lastError: {
+                    kind: "terminal";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | {
+                    kind: "transient";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | null;
+                lastFetched: number | null;
+                stale: boolean;
+                currentPage: number | null;
+                pageSize: number | null;
+            };
+        };
+        upsertEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        upsertEntities: (type: EntityType, entries: Array<{
+            id: EntityId;
+            data: Record<string, unknown>;
+        }>) => void;
+        replaceEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        removeEntity: (type: EntityType, id: EntityId) => void;
+        patchEntity: (type: EntityType, id: EntityId, patch: Record<string, unknown>) => void;
+        unpatchEntity: (type: EntityType, id: EntityId, keys: string[]) => void;
+        clearPatch: (type: EntityType, id: EntityId) => void;
+        setEntityFetching: (type: EntityType, id: EntityId, fetching: boolean) => void;
+        setEntityError: (type: EntityType, id: EntityId, error: string | null) => void;
+        setEntityFetched: (type: EntityType, id: EntityId) => void;
+        setEntityStale: (type: EntityType, id: EntityId, stale: boolean) => void;
+        setEntitySyncMetadata: (type: EntityType, id: EntityId, metadata: Partial<EntitySyncMetadata>) => void;
+        clearEntitySyncMetadata: (type: EntityType, id: EntityId) => void;
+        setListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        appendListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        prependListResult: (key: QueryKey, ids: EntityId[], meta?: Partial<ListState>) => void;
+        removeIdFromAllLists: (type: EntityType, id: EntityId) => void;
+        insertIdInList: (key: QueryKey, id: EntityId, position: "start" | "end" | number) => void;
+        setListFetching: (key: QueryKey, fetching: boolean) => void;
+        setListFetchingMore: (key: QueryKey, fetchingMore: boolean) => void;
+        setListError: (key: QueryKey, error: string | null, typed?: EntityError | null) => void;
+        setListStale: (key: QueryKey, stale: boolean) => void;
+        invalidateEntity: (type: EntityType, id?: EntityId) => void;
+        invalidateLists: (matcher: string | ((key: QueryKey) => boolean)) => void;
+        invalidateType: (type: EntityType) => void;
+        readEntity: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => T | null;
+        readEntitySnapshot: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => EntitySnapshot<T & Record<string, unknown>> | null;
+    }) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: GraphState | ((state: {
+        entities: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        patches: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        entityStates: {
+            [x: string]: {
+                isFetching: boolean;
+                lastFetched: number | null;
+                error: string | null;
+                stale: boolean;
+            };
+        };
+        syncMetadata: {
+            [x: string]: {
+                synced: boolean;
+                origin: SyncOrigin;
+                updatedAt: number | null;
+            };
+        };
+        lists: {
+            [x: string]: {
+                ids: string[];
+                total: number | null;
+                nextCursor: string | null;
+                prevCursor: string | null;
+                hasNextPage: boolean;
+                hasPrevPage: boolean;
+                isFetching: boolean;
+                isFetchingMore: boolean;
+                error: string | null;
+                lastError: {
+                    kind: "terminal";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | {
+                    kind: "transient";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | null;
+                lastFetched: number | null;
+                stale: boolean;
+                currentPage: number | null;
+                pageSize: number | null;
+            };
+        };
+        upsertEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        upsertEntities: (type: EntityType, entries: Array<{
+            id: EntityId;
+            data: Record<string, unknown>;
+        }>) => void;
+        replaceEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        removeEntity: (type: EntityType, id: EntityId) => void;
+        patchEntity: (type: EntityType, id: EntityId, patch: Record<string, unknown>) => void;
+        unpatchEntity: (type: EntityType, id: EntityId, keys: string[]) => void;
+        clearPatch: (type: EntityType, id: EntityId) => void;
+        setEntityFetching: (type: EntityType, id: EntityId, fetching: boolean) => void;
+        setEntityError: (type: EntityType, id: EntityId, error: string | null) => void;
+        setEntityFetched: (type: EntityType, id: EntityId) => void;
+        setEntityStale: (type: EntityType, id: EntityId, stale: boolean) => void;
+        setEntitySyncMetadata: (type: EntityType, id: EntityId, metadata: Partial<EntitySyncMetadata>) => void;
+        clearEntitySyncMetadata: (type: EntityType, id: EntityId) => void;
+        setListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        appendListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        prependListResult: (key: QueryKey, ids: EntityId[], meta?: Partial<ListState>) => void;
+        removeIdFromAllLists: (type: EntityType, id: EntityId) => void;
+        insertIdInList: (key: QueryKey, id: EntityId, position: "start" | "end" | number) => void;
+        setListFetching: (key: QueryKey, fetching: boolean) => void;
+        setListFetchingMore: (key: QueryKey, fetchingMore: boolean) => void;
+        setListError: (key: QueryKey, error: string | null, typed?: EntityError | null) => void;
+        setListStale: (key: QueryKey, stale: boolean) => void;
+        invalidateEntity: (type: EntityType, id?: EntityId) => void;
+        invalidateLists: (matcher: string | ((key: QueryKey) => boolean)) => void;
+        invalidateType: (type: EntityType) => void;
+        readEntity: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => T | null;
+        readEntitySnapshot: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => EntitySnapshot<T & Record<string, unknown>> | null;
+    }) => void), shouldReplace: true): void;
+};
 /**
- * Global entity graph store (Zustand + Immer). **Components should not subscribe directly** — use hooks so layering stays `Component → hook → store`.
- * `getState()` is intended for non-React code paths (engine, adapters, mutations) that must write or read the graph synchronously.
+ * Default process-wide entity graph store. Framework bindings subscribe to
+ * this vanilla store; non-React consumers use its `getState`, `setState`, and
+ * `subscribe` methods directly.
  */
-declare const useGraphStore: zustand.UseBoundStore<Omit<Omit<zustand.StoreApi<GraphState>, "subscribe"> & {
+declare const graphStore: Omit<Omit<zustand_vanilla.StoreApi<GraphState>, "subscribe"> & {
     subscribe: {
         (listener: (selectedState: GraphState, previousSelectedState: GraphState) => void): () => void;
         <U>(selector: (state: GraphState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
@@ -444,7 +642,208 @@ declare const useGraphStore: zustand.UseBoundStore<Omit<Omit<zustand.StoreApi<Gr
         readEntity: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => T | null;
         readEntitySnapshot: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => EntitySnapshot<T & Record<string, unknown>> | null;
     }) => void), shouldReplace: true): void;
-}>;
+};
+type GraphStore$1 = ReturnType<typeof createGraphStore>;
+/**
+ * @deprecated Import `graphStore` from core, or `useGraphStore` from the React
+ * binding. This StoreApi-shaped alias remains for non-React 2.x migrations.
+ */
+declare const useGraphStore: Omit<Omit<zustand_vanilla.StoreApi<GraphState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: GraphState, previousSelectedState: GraphState) => void): () => void;
+        <U>(selector: (state: GraphState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: GraphState | Partial<GraphState> | ((state: {
+        entities: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        patches: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        entityStates: {
+            [x: string]: {
+                isFetching: boolean;
+                lastFetched: number | null;
+                error: string | null;
+                stale: boolean;
+            };
+        };
+        syncMetadata: {
+            [x: string]: {
+                synced: boolean;
+                origin: SyncOrigin;
+                updatedAt: number | null;
+            };
+        };
+        lists: {
+            [x: string]: {
+                ids: string[];
+                total: number | null;
+                nextCursor: string | null;
+                prevCursor: string | null;
+                hasNextPage: boolean;
+                hasPrevPage: boolean;
+                isFetching: boolean;
+                isFetchingMore: boolean;
+                error: string | null;
+                lastError: {
+                    kind: "terminal";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | {
+                    kind: "transient";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | null;
+                lastFetched: number | null;
+                stale: boolean;
+                currentPage: number | null;
+                pageSize: number | null;
+            };
+        };
+        upsertEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        upsertEntities: (type: EntityType, entries: Array<{
+            id: EntityId;
+            data: Record<string, unknown>;
+        }>) => void;
+        replaceEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        removeEntity: (type: EntityType, id: EntityId) => void;
+        patchEntity: (type: EntityType, id: EntityId, patch: Record<string, unknown>) => void;
+        unpatchEntity: (type: EntityType, id: EntityId, keys: string[]) => void;
+        clearPatch: (type: EntityType, id: EntityId) => void;
+        setEntityFetching: (type: EntityType, id: EntityId, fetching: boolean) => void;
+        setEntityError: (type: EntityType, id: EntityId, error: string | null) => void;
+        setEntityFetched: (type: EntityType, id: EntityId) => void;
+        setEntityStale: (type: EntityType, id: EntityId, stale: boolean) => void;
+        setEntitySyncMetadata: (type: EntityType, id: EntityId, metadata: Partial<EntitySyncMetadata>) => void;
+        clearEntitySyncMetadata: (type: EntityType, id: EntityId) => void;
+        setListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        appendListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        prependListResult: (key: QueryKey, ids: EntityId[], meta?: Partial<ListState>) => void;
+        removeIdFromAllLists: (type: EntityType, id: EntityId) => void;
+        insertIdInList: (key: QueryKey, id: EntityId, position: "start" | "end" | number) => void;
+        setListFetching: (key: QueryKey, fetching: boolean) => void;
+        setListFetchingMore: (key: QueryKey, fetchingMore: boolean) => void;
+        setListError: (key: QueryKey, error: string | null, typed?: EntityError | null) => void;
+        setListStale: (key: QueryKey, stale: boolean) => void;
+        invalidateEntity: (type: EntityType, id?: EntityId) => void;
+        invalidateLists: (matcher: string | ((key: QueryKey) => boolean)) => void;
+        invalidateType: (type: EntityType) => void;
+        readEntity: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => T | null;
+        readEntitySnapshot: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => EntitySnapshot<T & Record<string, unknown>> | null;
+    }) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: GraphState | ((state: {
+        entities: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        patches: {
+            [x: string]: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        };
+        entityStates: {
+            [x: string]: {
+                isFetching: boolean;
+                lastFetched: number | null;
+                error: string | null;
+                stale: boolean;
+            };
+        };
+        syncMetadata: {
+            [x: string]: {
+                synced: boolean;
+                origin: SyncOrigin;
+                updatedAt: number | null;
+            };
+        };
+        lists: {
+            [x: string]: {
+                ids: string[];
+                total: number | null;
+                nextCursor: string | null;
+                prevCursor: string | null;
+                hasNextPage: boolean;
+                hasPrevPage: boolean;
+                isFetching: boolean;
+                isFetchingMore: boolean;
+                error: string | null;
+                lastError: {
+                    kind: "terminal";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | {
+                    kind: "transient";
+                    status?: number | undefined;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: unknown;
+                } | null;
+                lastFetched: number | null;
+                stale: boolean;
+                currentPage: number | null;
+                pageSize: number | null;
+            };
+        };
+        upsertEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        upsertEntities: (type: EntityType, entries: Array<{
+            id: EntityId;
+            data: Record<string, unknown>;
+        }>) => void;
+        replaceEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => void;
+        removeEntity: (type: EntityType, id: EntityId) => void;
+        patchEntity: (type: EntityType, id: EntityId, patch: Record<string, unknown>) => void;
+        unpatchEntity: (type: EntityType, id: EntityId, keys: string[]) => void;
+        clearPatch: (type: EntityType, id: EntityId) => void;
+        setEntityFetching: (type: EntityType, id: EntityId, fetching: boolean) => void;
+        setEntityError: (type: EntityType, id: EntityId, error: string | null) => void;
+        setEntityFetched: (type: EntityType, id: EntityId) => void;
+        setEntityStale: (type: EntityType, id: EntityId, stale: boolean) => void;
+        setEntitySyncMetadata: (type: EntityType, id: EntityId, metadata: Partial<EntitySyncMetadata>) => void;
+        clearEntitySyncMetadata: (type: EntityType, id: EntityId) => void;
+        setListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        appendListResult: (key: QueryKey, ids: EntityId[], meta: Partial<Omit<ListState, "ids" | "isFetching" | "isFetchingMore" | "error" | "stale">>) => void;
+        prependListResult: (key: QueryKey, ids: EntityId[], meta?: Partial<ListState>) => void;
+        removeIdFromAllLists: (type: EntityType, id: EntityId) => void;
+        insertIdInList: (key: QueryKey, id: EntityId, position: "start" | "end" | number) => void;
+        setListFetching: (key: QueryKey, fetching: boolean) => void;
+        setListFetchingMore: (key: QueryKey, fetchingMore: boolean) => void;
+        setListError: (key: QueryKey, error: string | null, typed?: EntityError | null) => void;
+        setListStale: (key: QueryKey, stale: boolean) => void;
+        invalidateEntity: (type: EntityType, id?: EntityId) => void;
+        invalidateLists: (matcher: string | ((key: QueryKey) => boolean)) => void;
+        invalidateType: (type: EntityType) => void;
+        readEntity: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => T | null;
+        readEntitySnapshot: <T = Record<string, unknown>>(type: EntityType, id: EntityId) => EntitySnapshot<T & Record<string, unknown>> | null;
+    }) => void), shouldReplace: true): void;
+};
 
 /**
  * Compiles a {@link FilterSpec} into a Prisma `where` object (plain JSON-serializable shape).
@@ -906,6 +1305,9 @@ declare function hasMergeStrategy(type: string): boolean;
  * contract), keeping per-write resolution off the async path.
  */
 
+type LoroModuleLoader = () => Promise<{
+    LoroDoc: unknown;
+}>;
 /**
  * Build a Loro-backed {@link MergeStrategy}. Resolves `loro-crdt` lazily; throws
  * a clear error if the optional peer is not installed.
@@ -916,7 +1318,7 @@ declare function hasMergeStrategy(type: string): boolean;
  * registerMergeStrategy("Document", loro);
  * ```
  */
-declare function createLoroMergeStrategy(): Promise<MergeStrategy>;
+declare function createLoroMergeStrategy(loadLoro?: LoroModuleLoader): Promise<MergeStrategy>;
 
 type GraphStore = ReturnType<typeof useGraphStore.getState>;
 type GraphIncludeMap = Record<string, GraphIncludeRelation>;
@@ -967,11 +1369,11 @@ declare function queryOnce<TEntity extends object>(opts: GraphQueryOptions<TEnti
 declare const selectGraph: typeof queryOnce;
 
 interface GraphDataSnapshot {
-    entities: ReturnType<typeof useGraphStore.getState>["entities"];
-    patches: ReturnType<typeof useGraphStore.getState>["patches"];
-    entityStates: ReturnType<typeof useGraphStore.getState>["entityStates"];
-    syncMetadata: ReturnType<typeof useGraphStore.getState>["syncMetadata"];
-    lists: ReturnType<typeof useGraphStore.getState>["lists"];
+    entities: ReturnType<typeof graphStore.getState>["entities"];
+    patches: ReturnType<typeof graphStore.getState>["patches"];
+    entityStates: ReturnType<typeof graphStore.getState>["entityStates"];
+    syncMetadata: ReturnType<typeof graphStore.getState>["syncMetadata"];
+    lists: ReturnType<typeof graphStore.getState>["lists"];
 }
 interface GraphTransaction {
     upsertEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => GraphTransaction;
@@ -1008,7 +1410,7 @@ type GraphActionEvent = {
     type: "settled";
     record: GraphActionRecord$1;
 };
-declare function createGraphTransaction(): GraphTransaction;
+declare function createGraphTransaction(storeApi?: GraphStore$1): GraphTransaction;
 declare function createGraphAction<TInput, TResult>(opts: GraphActionOptions<TInput, TResult>): (input: TInput) => Promise<TResult>;
 
 interface GraphEffectEvent<T> {
@@ -1132,22 +1534,24 @@ interface GraphSyncStatus {
 interface GraphSnapshotPayload {
     version: 1;
     snapshot: {
-        entities: ReturnType<typeof useGraphStore.getState>["entities"];
-        patches: ReturnType<typeof useGraphStore.getState>["patches"];
-        entityStates: ReturnType<typeof useGraphStore.getState>["entityStates"];
-        syncMetadata: ReturnType<typeof useGraphStore.getState>["syncMetadata"];
-        lists: ReturnType<typeof useGraphStore.getState>["lists"];
+        entities: ReturnType<typeof graphStore.getState>["entities"];
+        patches: ReturnType<typeof graphStore.getState>["patches"];
+        entityStates: ReturnType<typeof graphStore.getState>["entityStates"];
+        syncMetadata: ReturnType<typeof graphStore.getState>["syncMetadata"];
+        lists: ReturnType<typeof graphStore.getState>["lists"];
     };
     pendingActions: GraphActionRecord[];
 }
 interface PersistGraphToStorageOptions {
     storage: GraphPersistenceAdapter;
     key: string;
+    store?: GraphStore$1;
     pendingActions?: GraphActionRecord[];
 }
 interface HydrateGraphFromStorageOptions {
     storage: GraphPersistenceAdapter;
     key: string;
+    store?: GraphStore$1;
 }
 /**
  * Retry-with-backoff policy for replaying pending offline actions.
@@ -1171,6 +1575,7 @@ interface ReplayRetryPolicy {
 }
 interface StartLocalFirstGraphOptions {
     storage: GraphPersistenceAdapter;
+    store?: GraphStore$1;
     key?: string;
     replayPendingActions?: boolean;
     onlineSource?: {
@@ -1188,7 +1593,11 @@ interface LocalFirstGraphRuntime {
     hydrate: () => Promise<Awaited<ReturnType<typeof hydrateGraphFromStorage>>>;
     getStatus: () => GraphSyncStatus;
 }
-declare function useGraphSyncStatus(): GraphSyncStatus;
+declare const graphSyncStatusStore: zustand_vanilla.StoreApi<{
+    status: GraphSyncStatus;
+    setStatus: (status: Partial<GraphSyncStatus>) => void;
+}>;
+declare function getGraphSyncStatus(): GraphSyncStatus;
 declare function persistGraphToStorage(opts: PersistGraphToStorageOptions): Promise<{
     ok: true;
     key: string;
@@ -1226,7 +1635,7 @@ interface ResolvedRetryPolicy {
  * action goes to "poison" — the optional handler is invoked and the function
  * resolves. Exposed for unit testing.
  */
-declare function replayActionWithRetry(action: GraphActionRecord, policy: ResolvedRetryPolicy): Promise<{
+declare function replayActionWithRetry(action: GraphActionRecord, policy: ResolvedRetryPolicy, storeApi?: GraphStore$1): Promise<{
     ok: true;
 } | {
     ok: false;
@@ -1259,7 +1668,7 @@ interface EntityQueryOptions<TRaw, TEntity extends object> {
     fetch: (id: EntityId) => Promise<TRaw>;
     normalize: (raw: TRaw) => TEntity;
     idField?: string;
-    sideEffects?: (raw: TRaw, store: typeof useGraphStore) => void;
+    sideEffects?: (raw: TRaw, store: GraphStore$1) => void;
     staleTime?: number;
     enabled?: boolean;
     onSuccess?: (entity: TEntity) => void;
@@ -1304,7 +1713,7 @@ interface ListQueryOptions<TRaw, TEntity extends object> {
         id: EntityId;
         data: TEntity;
     };
-    sideEffects?: (items: TRaw[], store: typeof useGraphStore) => void;
+    sideEffects?: (items: TRaw[], store: GraphStore$1) => void;
     mode?: "replace" | "append";
     staleTime?: number;
     enabled?: boolean;
@@ -1321,21 +1730,21 @@ declare function serializeKey(key: unknown[]): string;
  * @param key - Logical dedupe key (e.g. `type:id` or serialized list key)
  * @param fn - Async work that performs the fetch + graph writes
  */
-declare function dedupe<T>(key: string, fn: () => Promise<T>): Promise<T>;
+declare function dedupe<T>(key: string, fn: () => Promise<T>, store?: GraphStore$1): Promise<T>;
 /**
  * Ref-count graph interest for a subscriber key (`${type}:${id}`). Background revalidation skips keys with zero subscribers.
  * @returns Opaque token required for `unregisterSubscriber`
  */
-declare function registerSubscriber(key: string): symbol;
+declare function registerSubscriber(key: string, store?: GraphStore$1): symbol;
 /** Pair with `registerSubscriber` on unmount so idle entities stop refetching. */
-declare function unregisterSubscriber(key: string, token: symbol): void;
+declare function unregisterSubscriber(key: string, token: symbol, store?: GraphStore$1): void;
 /**
  * Subscribe to ref-count changes for `registerSubscriber` / `unregisterSubscriber`.
  * Used by `useGraphDevTools` so subscriber totals update without graph mutations.
  */
 declare function subscribeSubscriberStats(onChange: () => void): () => boolean;
 /** Total active entity subscriber tokens across all keys (sum of ref-counts). */
-declare function getActiveSubscriberCount(): number;
+declare function getActiveSubscriberCount(store?: GraphStore$1): number;
 /**
  * Discriminated union of devtools events.
  *
@@ -1388,15 +1797,15 @@ type DevtoolsListener = (event: DevtoolsEvent) => void;
  */
 declare function subscribeDevtoolsEvent(cb: DevtoolsListener): () => void;
 /**
- * Stops the periodic garbage-collection timer started by `startGarbageCollector` / `configureEngine`.
+ * Stops the periodic garbage-collection timer for the selected graph.
  */
-declare function stopGarbageCollector(): void;
+declare function stopGarbageCollector(storeApi?: GraphStore$1): void;
 /**
  * Starts periodic garbage collection using current `getEngineOptions().gcInterval`.
  * Stops any previous interval first. No-ops during SSR (`window` is undefined) or without `setInterval`.
- * @returns Disposer that stops this collector (equivalent to `stopGarbageCollector`).
+ * @returns Disposer that stops this graph's collector.
  */
-declare function startGarbageCollector(): () => void;
+declare function startGarbageCollector(storeApi?: GraphStore$1): () => void;
 /** Override global engine behavior (typically once at app bootstrap). Restarts GC with merged options. */
 declare function configureEngine(opts: EngineOptions): void;
 /** Read merged engine options; hooks use this for default `staleTime` and retry behavior. */
@@ -1405,17 +1814,18 @@ declare function getEngineOptions(): Required<EngineOptions>;
  * Run a single-entity fetch with dedupe, retries, normalization, and graph updates.
  * Call from hooks/adapters — not from presentational components.
  */
-declare function fetchEntity<TRaw, TEntity extends object>(opts: EntityQueryOptions<TRaw, TEntity>, engineOpts: Required<EngineOptions>): Promise<void>;
+declare function fetchEntity<TRaw, TEntity extends object>(opts: EntityQueryOptions<TRaw, TEntity>, engineOpts: Required<EngineOptions>, storeApi?: GraphStore$1): Promise<void>;
 /**
  * Fetch a list page: upserts all rows, writes ids to the list key, supports append mode for pagination.
  * @param isLoadMore - When true, uses a separate dedupe key and `appendListResult` / `setListFetchingMore`.
  */
-declare function fetchList<TRaw, TEntity extends object>(opts: ListQueryOptions<TRaw, TEntity>, params: ListFetchParams, engineOpts: Required<EngineOptions>, isLoadMore?: boolean): Promise<void>;
+declare function fetchList<TRaw, TEntity extends object>(opts: ListQueryOptions<TRaw, TEntity>, params: ListFetchParams, engineOpts: Required<EngineOptions>, isLoadMore?: boolean, storeApi?: GraphStore$1): Promise<void>;
 /**
  * Opt-in window listeners that mark **subscribed** entities stale on focus/reconnect so hooks can SWR-refetch.
- * Idempotent; safe for SSR (no-ops without `window`). Pair with `configureEngine` flags.
+ * Reference-counted per graph and safe for SSR (no-ops without `window`).
+ * @returns Disposer that releases this attachment and removes listeners plus GC when the last owner releases it.
  */
-declare function attachGlobalListeners(): void;
+declare function attachGlobalListeners(storeApi?: GraphStore$1): () => void;
 
 /**
  * devtools-event-bus — W5 (seim-em-explorer-event-bus-registry)
@@ -1490,7 +1900,7 @@ declare function getRegisteredStores(): ReadonlyArray<RegisteredStore>;
  * not in production data paths.
  */
 
-type GraphSlice = Pick<ReturnType<typeof useGraphStore.getState>, "entities" | "patches" | "entityStates" | "syncMetadata" | "lists">;
+type GraphSlice = Pick<ReturnType<typeof graphStore.getState>, "entities" | "patches" | "entityStates" | "syncMetadata" | "lists">;
 interface TimeTravelSnapshot {
     /** Monotonic id (capture order). */
     seq: number;
@@ -1511,18 +1921,18 @@ declare function configureTimeTravel(opts: {
     capacity?: number;
 }): void;
 /** Capture the current live graph state into the ring. Returns the snapshot seq. */
-declare function recordGraphSnapshot(label?: string): number;
+declare function recordGraphSnapshot(label?: string, storeApi?: GraphStore$1): number;
 /**
  * Restore the live graph to the snapshot at ring `index` (0-based into the
  * current ring). The Zustand store is overwritten with a deep clone of the
  * captured slice, so all subscribers re-render at that historical state.
  * Returns true if restored.
  */
-declare function restoreGraphSnapshot(index: number): boolean;
+declare function restoreGraphSnapshot(index: number, storeApi?: GraphStore$1): boolean;
 /** Restore by capture seq (stable across ring eviction within capacity). */
-declare function restoreGraphSnapshotBySeq(seq: number): boolean;
+declare function restoreGraphSnapshotBySeq(seq: number, storeApi?: GraphStore$1): boolean;
 /** Step the cursor by `delta` (negative = back in time) and restore. */
-declare function stepTimeTravel(delta: number): boolean;
+declare function stepTimeTravel(delta: number, storeApi?: GraphStore$1): boolean;
 /** Snapshot metadata + cursor for the devtools UI (no heavy data payloads). */
 declare function getTimeTravelState(): TimeTravelState;
 /** Subscribe to ring/cursor changes (for useSyncExternalStore in the UI). */
@@ -1684,12 +2094,12 @@ declare function getSchema(type: EntityType): EntitySchema | null;
  * After a successful mutation, mark related entities/lists stale so hooks refetch without manually hunting query keys.
  * Traverses registered schemas (including reverse `hasMany`) so denormalized UIs stay eventually consistent with the graph.
  */
-declare function cascadeInvalidation(ctx: CascadeContext): void;
+declare function cascadeInvalidation(ctx: CascadeContext, storeApi?: GraphStore$1): void;
 /**
  * Resolve relation **placeholders** for detail panels: joins graph reads for belongs-to targets, has-many id lists, or many-to-many id arrays.
  * Returns plain objects suitable for rendering; does not mutate the graph.
  */
-declare function readRelations(type: EntityType, entity: Record<string, unknown>): Record<string, unknown>;
+declare function readRelations(type: EntityType, entity: Record<string, unknown>, storeApi?: GraphStore$1): Record<string, unknown>;
 
 /**
  * agent/json-patch.ts — Minimal RFC-6902 JSON Patch applier.
@@ -1856,6 +2266,7 @@ interface ChannelConfig {
 
 interface ManagerOptions {
     flushInterval?: number;
+    store?: GraphStore$1;
     onStatusChange?: (adapter: string, status: AdapterStatus) => void;
     onChangeReceived?: (adapter: string, change: EntityChange) => void;
 }
@@ -1865,6 +2276,7 @@ declare class RealtimeManager {
     private pendingListKeys;
     private flushTimer;
     private opts;
+    private store;
     constructor(opts?: ManagerOptions);
     register(adapter: RealtimeAdapter, channels: ChannelConfig[], normalize?: (raw: unknown) => EntityChange | null): UnsubscribeFn;
     unregister(name: string): void;
@@ -2435,11 +2847,10 @@ declare function registerEntityFromSql(opts: RegisterEntityFromSqlOptions): Enti
 /**
  * table/types.ts
  *
- * Pure table engine type definitions — zero external dependencies.
+ * Pure table engine type definitions — zero framework dependencies.
  * Structurally compatible with TanStack Table v8 for easy migration,
  * but fully self-contained within the prometheus-entity-management library.
  */
-
 type ViewMode = "table" | "gallery" | "list";
 type Updater<T> = T | ((prev: T) => T);
 type AccessorFn<TData, TValue = unknown> = (row: TData, index: number) => TValue;
@@ -2456,8 +2867,8 @@ type CellContext<TData> = {
     getValue: <T = unknown>() => T;
     renderValue: <T = unknown>() => T | null;
 };
-type HeaderRenderer<TData> = string | ((context: HeaderContext<TData>) => React.ReactNode);
-type CellRenderer<TData> = string | ((context: CellContext<TData>) => React.ReactNode);
+type HeaderRenderer<TData> = string | ((context: HeaderContext<TData>) => unknown);
+type CellRenderer<TData> = string | ((context: CellContext<TData>) => unknown);
 type FilterFn<TData> = (row: Row<TData>, columnId: string, filterValue: unknown) => boolean;
 type SortingFn<TData> = (rowA: Row<TData>, rowB: Row<TData>, columnId: string) => number;
 type AggregationFn<TData> = (columnId: string, leafRows: Row<TData>[], childRows: Row<TData>[]) => unknown;
@@ -2788,86 +3199,6 @@ interface TableInstance<TData> {
     getCanSomeRowsExpand: () => boolean;
     getExpandedDepth: () => number;
 }
-interface ActionDef<TData> {
-    id: string;
-    label: string;
-    icon?: React.ComponentType<{
-        className?: string;
-    }>;
-    onClick: (item: TData) => void;
-    destructive?: boolean;
-    hidden?: (item: TData) => boolean;
-    disabled?: (item: TData) => boolean;
-    confirm?: string | ((item: TData) => string);
-    variant?: "primary" | "default" | "ghost" | "destructive";
-}
-interface ItemDescriptorBadge<TData> {
-    field: keyof TData & string;
-    options?: Array<{
-        value: string;
-        label: string;
-        className?: string;
-    }>;
-}
-interface ItemDescriptorMeta<TData> {
-    field: keyof TData & string;
-    label: string;
-    format?: (value: unknown) => string;
-}
-interface ItemDescriptor<TData> {
-    title: keyof TData & string;
-    subtitle?: keyof TData & string;
-    image?: keyof TData & string;
-    icon?: (keyof TData & string) | React.ComponentType<{
-        className?: string;
-    }>;
-    avatar?: keyof TData & string;
-    badges?: ItemDescriptorBadge<TData>[];
-    metadata?: ItemDescriptorMeta<TData>[];
-    description?: keyof TData & string;
-}
-interface ItemRenderContext<TData> {
-    isSelected: boolean;
-    isEditing: boolean;
-    isMultiSelectMode: boolean;
-    onToggleSelect: () => void;
-    onEdit: () => void;
-    onSave: (changes: Partial<TData>) => void;
-    onCancel: () => void;
-    actions: ActionDef<TData>[];
-    row: Row<TData>;
-}
-interface EmptyStateConfig {
-    icon?: React.ComponentType<{
-        className?: string;
-    }>;
-    title?: string;
-    description?: string;
-    action?: {
-        label: string;
-        onClick: () => void;
-    };
-    filteredTitle?: string;
-    filteredDescription?: string;
-    filteredAction?: {
-        label: string;
-        onClick: () => void;
-    };
-}
-interface BatchActionDef {
-    id: string;
-    label: string;
-    icon?: React.ComponentType<{
-        className?: string;
-    }>;
-    destructive?: boolean;
-}
-interface GalleryColumns {
-    sm?: number;
-    md?: number;
-    lg?: number;
-    xl?: number;
-}
 
 /**
  * table/row-models.ts
@@ -2910,4 +3241,4 @@ declare function getFacetedMinMaxValues<TData>(rowModel: RowModel<TData>, column
  */
 declare function getFacetedRowModel<TData>(preFilteredRowModel: RowModel<TData>, columnId: string, allFilteredRowModel: RowModel<TData>): RowModel<TData>;
 
-export { type AccessorFn, type ActionDef, type AdapterStatus, type AgUiStateDeltaEvent, type AgUiStateMapping, type AgUiStateSnapshotEvent, type AggregationFn, type ApplyAgUiOptions, type BatchActionDef, type BelongsToRelation, type CascadeContext, type Cell, type CellContext, type CellRenderer, type ChangeEvent, type ChangeOp, type ChangeOperation, type ChangeSet, type ChannelConfig, type Column, type ColumnDef, type ColumnFiltersState, type ColumnMeta, type ColumnOrderState, type ColumnPinningState, type ColumnSizingInfoState, type ColumnSizingState, type ColumnVisibilityState, type CompletenessMode, type CreateFlintAdapterOptions, type CreatePGlitePersistenceAdapterOptions, type CreateTauriSqlPersistenceAdapterOptions, type DevtoolsEvent, type DevtoolsEventBus, type DevtoolsEventBusOptions, type DevtoolsSourceFn, EMPTY_ENTITY_STATE, EMPTY_IDS, EMPTY_LIST_STATE, EMPTY_SYNC_METADATA, type ElectricAdapterOptions, type ElectricTableConfig, type EmptyStateConfig, type EngineOptions, type EntityChange, type EntityError, type EntityErrorOptions, type EntityId, type EntityJsonSchemaConfig, type EntityQueryOptions, type EntitySchema, type EntitySnapshot, type EntityState, type EntitySyncMetadata, type EntityTransport, type EntityType, type ExpandedState, type FilterClause, type FilterFn, type FilterGroup, type FilterOperator, type FilterSpec, type FlintCheckpointStore, type FlintClientLike, type FlintEntityEvent, type FlintEntityQuery, type FlintEntityRecord, type GalleryColumns, type GetEntityJsonSchemaOptions, type GraphActionEvent, type GraphActionOptions, type GraphActionRecord$1 as GraphActionRecord, type GraphEffectEvent, type GraphEffectHandle, type GraphEffectOptions, type GraphIncludeMap, type GraphIncludeRelation, type GraphPersistenceAdapter, type GraphQueryOptions, type GraphSnapshotExportOptions, type GraphSnapshotPayload, type GraphSnapshotWithSchemasOptions, type GraphState, type GraphSyncStatus, type GraphToolContext, type GraphTransaction, type GroupingState, type HasManyRelation, type Header, type HeaderContext, type HeaderGroup, type HeaderRenderer, IncrementalView, type IncrementalViewOptions, type ItemDescriptor, type ItemDescriptorBadge, type ItemDescriptorMeta, type ItemRenderContext, type JsonPatchOp, type JsonSchemaObject, type ListFetchParams, type ListQuery, type ListQueryOptions, type ListResponse, type ListResult, type ListState, type LocalFirstGraphRuntime, type MakeRestTransportOptions, type ManagerOptions, type ManyToManyRelation, type MergeContext, type MergeStrategy, type PGlitePersistenceClient, type PaginationState, type ColumnDef as PureColumnDef, type ColumnMeta as PureColumnMeta, type QueryKey, type RealtimeAdapter, RealtimeManager, type RegisterEntityFromSqlOptions, type RegisteredStore, type RelationDescriptor, type ReplayRetryPolicy, type Row, type RowModel, type RowSelectionState, type SchemaGraphToolContext, type SortClause, type SortDirection, type SortSpec, type SortingFn, type SortingState, type StartLocalFirstGraphOptions, type SubscriptionConfig, type SupabaseAdapterOptions, type SupabaseLike, type SupabaseQueryBuilderLike, type SurrealCheckpointStore, type SurrealLike, type SurrealLiveAction, type SurrealLiveAdapterOptions, type SurrealTableConfig, type SyncAdapter, type SyncOrigin, type TableInstance, type TableOptions, type TableState, type TauriSqlClient, type TenantClaim, type TenantScopedAdapterOptions, type TenantScopedTableConfig, TerminalError, type TimeTravelSnapshot, type TimeTravelState, TransientError, type UnsubscribeFn, type Updater, type ViewDescriptor, type ViewMode, type WebSocketAdapterOptions, __resetEntityTransports, __resetStoreRegistry, applyAgUiDelta, applyAgUiSnapshot, applyJsonPatch, applyView, attachGlobalListeners, buildTenantWhere, cascadeInvalidation, checkCompleteness, collectDirtyPaths, compareEntities, configureEngine, configureTimeTravel, createConvexAdapter, createDevtoolsEventBus, createElectricAdapter, createFlintAdapter, createGraphAction, createGraphEffect, createGraphQLSubscriptionAdapter, createGraphTool, createGraphTransaction, createLoroMergeStrategy, createPGlitePersistenceAdapter, createRow, createSchemaGraphTool, createSupabaseRealtimeAdapter, createSurrealLiveAdapter, createTauriSqlPersistenceAdapter, createTenantScopedElectricAdapter, createWebSocketAdapter, dedupe, escapeHtml, exportGraphSnapshot, exportGraphSnapshotWithSchemas, fetchEntity, fetchList, findInsertionIndex, flattenClauses, getActiveSubscriberCount, getCoreRowModel, getRealtimeManager as getElectricRealtimeManager, getEngineOptions, getEntityJsonSchema, getEntityTransport, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getMergeStrategy, getPaginatedRowModel, getRealtimeManager, getRegisteredEntityTypes, getRegisteredStores, getSchema, getSelectedRowModel, getSortedRowModel, getTimeTravelState, getValueAtPath, hasCustomPredicates, hasMergeStrategy, humanizeFieldName, hydrateGraphFromStorage, inferSchemaFieldType, lwwStrategy, makeRestTransport, matchesFilter, matchesSearch, parseCreateTable, persistGraphToStorage, publishFlintMutation, queryOnce, readRelations, recordGraphSnapshot, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerMergeStrategy, registerRuntimeSchema, registerSchema, registerStore, registerSubscriber, registryKey, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, restoreGraphSnapshot, restoreGraphSnapshotBySeq, selectGraph, serializeKey, setDefaultMergeStrategy, setValueAtPath, sqlTypeToJsonSchema, startGarbageCollector, startLocalFirstGraph, stepTimeTravel, stopGarbageCollector, subscribeDevtoolsEvent, subscribeSubscriberStats, subscribeTimeTravel, toEntityError, toGraphQLVariables, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses, unregisterSubscriber, useGraphStore, useGraphSyncStatus };
+export { type AccessorFn, type AdapterStatus, type AgUiStateDeltaEvent, type AgUiStateMapping, type AgUiStateSnapshotEvent, type AggregationFn, type ApplyAgUiOptions, type BelongsToRelation, type CascadeContext, type Cell, type CellContext, type CellRenderer, type ChangeEvent, type ChangeOp, type ChangeOperation, type ChangeSet, type ChannelConfig, type Column, type ColumnDef, type ColumnFiltersState, type ColumnMeta, type ColumnOrderState, type ColumnPinningState, type ColumnSizingInfoState, type ColumnSizingState, type ColumnVisibilityState, type CompletenessMode, type CreateFlintAdapterOptions, type CreatePGlitePersistenceAdapterOptions, type CreateTauriSqlPersistenceAdapterOptions, type DevtoolsEvent, type DevtoolsEventBus, type DevtoolsEventBusOptions, type DevtoolsSourceFn, EMPTY_ENTITY_STATE, EMPTY_IDS, EMPTY_LIST_STATE, EMPTY_SYNC_METADATA, type ElectricAdapterOptions, type ElectricTableConfig, type EngineOptions, type EntityChange, type EntityError, type EntityErrorOptions, type EntityId, type EntityJsonSchemaConfig, type EntityQueryOptions, type EntitySchema, type EntitySnapshot, type EntityState, type EntitySyncMetadata, type EntityTransport, type EntityType, type ExpandedState, type FilterClause, type FilterFn, type FilterGroup, type FilterOperator, type FilterSpec, type FlintCheckpointStore, type FlintClientLike, type FlintEntityEvent, type FlintEntityQuery, type FlintEntityRecord, type GetEntityJsonSchemaOptions, type GraphActionEvent, type GraphActionOptions, type GraphActionRecord$1 as GraphActionRecord, type GraphEffectEvent, type GraphEffectHandle, type GraphEffectOptions, type GraphIncludeMap, type GraphIncludeRelation, type GraphPersistenceAdapter, type GraphQueryOptions, type GraphSnapshotExportOptions, type GraphSnapshotPayload, type GraphSnapshotWithSchemasOptions, type GraphState, type GraphStore$1 as GraphStore, type GraphSyncStatus, type GraphToolContext, type GraphTransaction, type GroupingState, type HasManyRelation, type Header, type HeaderContext, type HeaderGroup, type HeaderRenderer, IncrementalView, type IncrementalViewOptions, type JsonPatchOp, type JsonSchemaObject, type ListFetchParams, type ListQuery, type ListQueryOptions, type ListResponse, type ListResult, type ListState, type LocalFirstGraphRuntime, type LoroModuleLoader, type MakeRestTransportOptions, type ManagerOptions, type ManyToManyRelation, type MergeContext, type MergeStrategy, type PGlitePersistenceClient, type PaginationState, type ColumnDef as PureColumnDef, type ColumnMeta as PureColumnMeta, type QueryKey, type RealtimeAdapter, RealtimeManager, type RegisterEntityFromSqlOptions, type RegisteredStore, type RelationDescriptor, type ReplayRetryPolicy, type Row, type RowModel, type RowSelectionState, type SchemaGraphToolContext, type SortClause, type SortDirection, type SortSpec, type SortingFn, type SortingState, type StartLocalFirstGraphOptions, type SubscriptionConfig, type SupabaseAdapterOptions, type SupabaseLike, type SupabaseQueryBuilderLike, type SurrealCheckpointStore, type SurrealLike, type SurrealLiveAction, type SurrealLiveAdapterOptions, type SurrealTableConfig, type SyncAdapter, type SyncOrigin, type TableInstance, type TableOptions, type TableState, type TauriSqlClient, type TenantClaim, type TenantScopedAdapterOptions, type TenantScopedTableConfig, TerminalError, type TimeTravelSnapshot, type TimeTravelState, TransientError, type UnsubscribeFn, type Updater, type ViewDescriptor, type ViewMode, type WebSocketAdapterOptions, __resetEntityTransports, __resetStoreRegistry, applyAgUiDelta, applyAgUiSnapshot, applyJsonPatch, applyView, attachGlobalListeners, buildTenantWhere, cascadeInvalidation, checkCompleteness, collectDirtyPaths, compareEntities, configureEngine, configureTimeTravel, createConvexAdapter, createDevtoolsEventBus, createElectricAdapter, createFlintAdapter, createGraphAction, createGraphEffect, createGraphQLSubscriptionAdapter, createGraphStore, createGraphTool, createGraphTransaction, createLoroMergeStrategy, createPGlitePersistenceAdapter, createRow, createSchemaGraphTool, createSupabaseRealtimeAdapter, createSurrealLiveAdapter, createTauriSqlPersistenceAdapter, createTenantScopedElectricAdapter, createWebSocketAdapter, dedupe, escapeHtml, exportGraphSnapshot, exportGraphSnapshotWithSchemas, fetchEntity, fetchList, findInsertionIndex, flattenClauses, getActiveSubscriberCount, getCoreRowModel, getRealtimeManager as getElectricRealtimeManager, getEngineOptions, getEntityJsonSchema, getEntityTransport, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGraphSyncStatus, getGroupedRowModel, getMergeStrategy, getPaginatedRowModel, getRealtimeManager, getRegisteredEntityTypes, getRegisteredStores, getSchema, getSelectedRowModel, getSortedRowModel, getTimeTravelState, getValueAtPath, graphStore, graphSyncStatusStore, hasCustomPredicates, hasMergeStrategy, humanizeFieldName, hydrateGraphFromStorage, inferSchemaFieldType, lwwStrategy, makeRestTransport, matchesFilter, matchesSearch, parseCreateTable, persistGraphToStorage, publishFlintMutation, queryOnce, readRelations, recordGraphSnapshot, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerMergeStrategy, registerRuntimeSchema, registerSchema, registerStore, registerSubscriber, registryKey, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, restoreGraphSnapshot, restoreGraphSnapshotBySeq, selectGraph, serializeKey, setDefaultMergeStrategy, setValueAtPath, sqlTypeToJsonSchema, startGarbageCollector, startLocalFirstGraph, stepTimeTravel, stopGarbageCollector, subscribeDevtoolsEvent, subscribeSubscriberStats, subscribeTimeTravel, toEntityError, toGraphQLVariables, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses, unregisterSubscriber, useGraphStore };