@prometheus-ags/entity-graph-core 3.2.0 → 4.0.1

package/dist/index.d.cts

@@ -1,2383 +0,0 @@
-import { S as SortSpec, F as FilterSpec, E as EntityType, G as GraphStore$1, a as EntityId, b as SyncOrigin, Q as QueryKey, u as useGraphStore, c as EntitySnapshot, d as EntitySyncMetadata, g as graphStore } from './graph-ClW3HD8B.cjs';
-export { C as CompletenessMode, e as EMPTY_ENTITY_STATE, f as EMPTY_IDS, h as EMPTY_LIST_STATE, i as EMPTY_SYNC_METADATA, j as EntityError, k as EntityErrorOptions, l as EntityState, m as FetchedEntityBatch, n as FetchedListProjection, o as FetchedListTarget, p as FilterClause, q as FilterGroup, r as FilterOperator, s as GraphState, I as IngestFetchedListOptions, L as ListResultMeta, t as ListState, v as SortClause, w as SortDirection, T as TerminalError, x as TransientError, V as ViewDescriptor, y as createGraphStore, z as flattenClauses, A as hasCustomPredicates, B as toEntityError, D as toGraphQLVariables, H as toRestParams, J as toSQLClauses } from './graph-ClW3HD8B.cjs';
-import * as zustand_vanilla from 'zustand/vanilla';
-
-/**
- * Compiles a {@link FilterSpec} into a Prisma `where` object (plain JSON-serializable shape).
- *
- * Operator mapping matches common Prisma filter APIs: `eq` → `equals`, string ops use `mode: "insensitive"`,
- * `nin` → `notIn`, `arrayContains` → `has`, `isNull` uses `null` / `{ not: null }` per `value`, and `isNotNull` → `{ not: null }`.
- * Unsupported ops (`between`, `arrayOverlaps`, `matches`, `custom`) are omitted from the result.
- *
- * Top-level clause arrays are combined with `AND`. {@link FilterGroup} uses `AND` / `OR` to match `group.logic`.
- */
-declare function toPrismaWhere(filter: FilterSpec): Record<string, unknown>;
-/**
- * Compiles a {@link SortSpec} into Prisma `orderBy` form: `[{ fieldName: "asc" | "desc" }, …]`.
- * `nulls` and `comparator` on {@link SortClause} are ignored (local-only); extend callers if your Prisma version supports null ordering.
- */
-declare function toPrismaOrderBy(sort: SortSpec): Record<string, string>[];
-
-/**
- * 2.0 transport contract.
- *
- * Why this exists: in 1.x each call site of `useEntityList` /
- * `useEntityView` passed its own `fetch` closure + `normalize`
- * callback. That leaked the transport contract to every consumer and
- * was the structural cause of the Quick Stats trap — each widget could
- * (and did) reinvent the same retry-loop bug.
- *
- * In 2.0 the transport is registered ONCE per entity type at app boot
- * via `registerEntityTransport(type, transport)`. Hooks
- * (`useEntities`, `useEntityQuery`) look up the registered transport
- * by entity type — consumers never pass a fetcher.
- *
- * Transports are pluggable: a built-in `makeRestTransport` covers
- * PostgREST / Supabase; future helpers can cover GraphQL, PGlite-direct,
- * mock-in-memory, etc. The contract is intentionally tiny.
- */
-
-/**
- * Transport-agnostic list query passed by `useEntities` / `useEntityQuery`
- * down to the registered transport.
- *
- * The transport is responsible for compiling this into the
- * transport-specific wire format (HTTP query string, GraphQL variables,
- * SQL WHERE, in-memory predicate, etc.).
- */
-interface ListQuery {
-    /** Optional filter; transport-agnostic, see `FilterSpec`. */
-    filter?: FilterSpec | null;
-    /** Optional sort spec; transport-agnostic. */
-    sort?: SortSpec | null;
-    /** Free-text search string; transport decides which fields to match. */
-    search?: string;
-    /** Page size hint. Transport may cap or ignore. */
-    limit?: number;
-    /** Opaque cursor for pagination (cursor or numeric offset). */
-    cursor?: string | number | null;
-    /** Aborts the request when fired. Transports MUST honour this. */
-    signal?: AbortSignal;
-}
-/**
- * Page of results returned by `EntityTransport.list`.
- *
- * `total` is `null` when the backend doesn't report it cheaply
- * (consumers should treat as "unknown" rather than "zero").
- *
- * `nextCursor` is `null`/`undefined` when there are no more pages.
- */
-interface ListResult<T> {
-    rows: T[];
-    total: number | null;
-    nextCursor?: string | number | null;
-}
-/**
- * Operation flavour for a realtime change event.
- */
-type ChangeOp = "insert" | "update" | "delete";
-/**
- * Realtime change event emitted by a transport's `subscribe`.
- *
- * For `delete` only `id` is meaningful; `row` MAY be omitted.
- */
-interface ChangeEvent<T> {
-    op: ChangeOp;
-    id: string;
-    row?: T;
-}
-/**
- * The full per-entity transport contract.
- *
- * One transport per entity type, registered at app boot. The hooks
- * (`useEntities`, `useEntityQuery`) look it up via `getEntityTransport(type)`.
- *
- * Required: `identify`, `authoritative`, `list`.
- * Optional: `get` (for single-row fetches), `subscribe` (for realtime),
- * `staleTime` (hint for SWR).
- */
-interface EntityTransport<T extends object> {
-    /**
-     * Derive the stable string id of a row. Used by the engine to write
-     * into the entity graph under the right id key.
-     */
-    identify: (row: T) => string;
-    /**
-     * `true` when the local copy is considered authoritative (e.g. PGlite
-     * + Electric Tier-A sync) — consumers can render from cache without
-     * a remote round-trip on every mount.
-     *
-     * `false` when the remote is authoritative (Tier-B REST hybrid) — the
-     * cache is a hint, not the truth.
-     */
-    authoritative: boolean;
-    /**
-     * Stale-time hint in ms. The engine SWR logic refetches when
-     * `Date.now() - lastFetched > staleTime`. Omit to inherit the engine
-     * default (30s).
-     */
-    staleTime?: number;
-    /** Fetch a list. The signal in `q.signal` MUST be honoured. */
-    list: (q: ListQuery) => Promise<ListResult<T>>;
-    /** Fetch a single row by id. Optional. */
-    get?: (id: string, signal?: AbortSignal) => Promise<T | null>;
-    /**
-     * Subscribe to realtime change events for this entity type. Optional.
-     *
-     * Called by `useEntities` / `useEntityQuery` exactly once per
-     * subscriber-bearing key. The returned function MUST tear down all
-     * underlying resources (sockets, channels, intervals).
-     */
-    subscribe?: (onChange: (ev: ChangeEvent<T>) => void) => () => void;
-}
-
-/**
- * Process-global registry of `EntityTransport` instances by entity type.
- *
- * Why global state: every consumer of `useEntities("Client")` must
- * resolve the SAME transport. Threading a registry through React
- * context would require every test, every isolated story, every
- * non-React caller (engine internals) to plumb the context — a tax
- * that buys nothing. The 1.x library already used module-global state
- * for the `useGraphStore` Zustand store; this follows the same shape.
- *
- * The registry is mutable: re-registering a type silently replaces the
- * prior transport (tests rely on this; production code should only
- * register once at app boot).
- */
-
-/**
- * Register the transport for an entity type. Called once per type at
- * app boot, typically from `src/shared/db/entity-transports.ts` in the
- * consuming application.
- *
- * Re-registering REPLACES the prior transport — useful for tests, a
- * footgun for production code. If you find yourself re-registering at
- * runtime, you almost certainly want a different design.
- */
-declare function registerEntityTransport<T extends object>(type: EntityType, transport: EntityTransport<T>): void;
-/**
- * Look up the transport for an entity type. Throws if none is
- * registered — there is no "default" transport, by design.
- *
- * The cast to `EntityTransport<T>` is the API ergonomic
- * compromise that lets call sites stay generic; the registry stores
- * `EntityTransport<object>` because TypeScript can't otherwise unify
- * heterogeneous rows in one map.
- */
-declare function getEntityTransport<T extends object>(type: EntityType): EntityTransport<T>;
-/**
- * Test-only: clear ALL registered transports. Production code should
- * never need this; tests use it to reset between specs.
- */
-declare function __resetEntityTransports(): void;
-/**
- * Introspection: how many transports are currently registered.
- * Useful for asserting in tests that boot wiring ran exactly once.
- */
-declare function getRegisteredEntityTypes(): EntityType[];
-
-/**
- * Active-graph resolution for imperative (non-hook) access.
- *
- * `GraphStoreProvider` scopes the React *hook* surface, but imperative callers —
- * Zustand store actions, module-level helpers, mutation callbacks — have no
- * React context to read. Before this module they had no way to reach a scoped
- * graph at all, so a mounted provider silently failed to isolate them.
- *
- * Two independent mechanisms, both opt-in, both falling back to the package
- * singleton so existing consumers are unaffected:
- *
- * 1. `setActiveGraphStore(store)` — a module-level active store. Correct in the
- *    browser, where there is exactly one application tree. `GraphStoreProvider`
- *    sets it on mount and restores the previous value on unmount.
- *
- * 2. `runWithGraphStore(store, fn)` — an `AsyncLocalStorage` scope. Required on
- *    the server, where concurrent requests interleave and a module-level value
- *    would leak across them.
- *
- * ALS takes precedence: if a request scope is active it always wins over the
- * module-level value, because a server render must never observe another
- * request's graph.
- *
- * ## Why `node:async_hooks` is loaded lazily
- *
- * This package is bundled for the browser as well as Node. A static
- * `import "node:async_hooks"` would break browser builds and pull a polyfill
- * into client bundles. The import is therefore attempted once, at first use of
- * `runWithGraphStore`, and failure degrades to the module-level mechanism
- * rather than throwing.
- */
-
-/**
- * Initialise request scoping on runtimes without a synchronous `require`.
- *
- * Under **pure ESM** there is no `require`, so the synchronous path above cannot
- * load `node:async_hooks` and `runWithGraphStore` would silently degrade to the
- * module-level store — which does NOT isolate concurrent requests. An ESM server
- * must therefore `await prepareGraphStoreScope()` once during startup, before
- * serving traffic.
- *
- * Safe to call anywhere: it resolves to `false` in the browser and is idempotent.
- */
-declare function prepareGraphStoreScope(): Promise<boolean>;
-/**
- * Set the process/tab-wide active graph.
- *
- * Returns a restore function; callers MUST invoke it on teardown so a nested or
- * remounted provider does not strand a stale store. Passing `null` clears it.
- */
-declare function setActiveGraphStore(store: GraphStore$1 | null): () => void;
-/**
- * Run `fn` with `store` as the active graph for this async context.
- *
- * This is the server-side entry point: an SSR host wraps each request so that
- * concurrent renders never share entity state. When the runtime has no
- * `AsyncLocalStorage`, `fn` still runs — under the module-level store — rather
- * than failing, so isomorphic code does not need a branch.
- */
-declare function runWithGraphStore<R>(store: GraphStore$1, fn: () => R): R;
-/**
- * The graph imperative access should target right now.
- *
- * Precedence: request scope (ALS) → module-level active store → `fallback`.
- * `fallback` is the package singleton, supplied by the caller to avoid a
- * circular import with `graph.ts`.
- */
-declare function resolveActiveGraphStore(fallback: GraphStore$1): GraphStore$1;
-/** Test seam: drop all active-store state. */
-declare function __resetActiveGraphStore(): void;
-
-/**
- * `makeRestTransport` — built-in helper for the most common case: a
- * Supabase / PostgREST backend reached through a `SupabaseClient`-like
- * object.
- *
- * Why a helper (not a class): consumers stay declarative —
- *   registerEntityTransport("Client",
- *     makeRestTransport<Client>({ supabase, table: "client" }));
- * — and the library never imports `@supabase/supabase-js` directly
- * (peer-dep-free).
- *
- * The transport:
- * - Compiles `ListQuery` (filter / sort / search / cursor / limit)
- *   into a PostgREST query via the supabase-js builder.
- * - Maps HTTP status to `TerminalError` (4xx) or `TransientError`
- *   (5xx / network).
- * - Honours `AbortSignal` via supabase-js `.abortSignal(signal)`.
- * - Returns `total` from PostgREST `count: 'exact'` when requested.
- */
-
-/**
- * Minimal slice of the `@supabase/supabase-js` `SupabaseClient` we use.
- * Declared structurally so the library does not need to import the
- * package as a dependency (peer-dep-free).
- */
-interface SupabaseLike {
-    from: (table: string) => SupabaseQueryBuilderLike;
-}
-/**
- * Subset of the supabase-js builder we exercise. Each call returns the
- * same builder for chaining; `then`-able at the end resolves to
- * `{ data, error, count, status }`.
- */
-interface SupabaseQueryBuilderLike {
-    select: (columns: string, opts?: {
-        count?: "exact" | "planned" | "estimated";
-        head?: boolean;
-    }) => SupabaseQueryBuilderLike;
-    eq: (col: string, val: unknown) => SupabaseQueryBuilderLike;
-    neq: (col: string, val: unknown) => SupabaseQueryBuilderLike;
-    gt: (col: string, val: unknown) => SupabaseQueryBuilderLike;
-    gte: (col: string, val: unknown) => SupabaseQueryBuilderLike;
-    lt: (col: string, val: unknown) => SupabaseQueryBuilderLike;
-    lte: (col: string, val: unknown) => SupabaseQueryBuilderLike;
-    in: (col: string, vals: readonly unknown[]) => SupabaseQueryBuilderLike;
-    ilike: (col: string, pattern: string) => SupabaseQueryBuilderLike;
-    is: (col: string, val: null | boolean) => SupabaseQueryBuilderLike;
-    or: (filter: string) => SupabaseQueryBuilderLike;
-    order: (col: string, opts?: {
-        ascending?: boolean;
-        nullsFirst?: boolean;
-    }) => SupabaseQueryBuilderLike;
-    range: (from: number, to: number) => SupabaseQueryBuilderLike;
-    limit: (n: number) => SupabaseQueryBuilderLike;
-    abortSignal?: (signal: AbortSignal) => SupabaseQueryBuilderLike;
-    then: <TResult1 = unknown, TResult2 = never>(onfulfilled?: ((value: {
-        data: unknown;
-        error: unknown;
-        count?: number | null;
-        status?: number;
-    }) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null) => Promise<TResult1 | TResult2>;
-}
-/** Options for `makeRestTransport`. */
-interface MakeRestTransportOptions<T extends object> {
-    /** A `@supabase/supabase-js` client (or any structurally-compatible thing). */
-    supabase: SupabaseLike;
-    /** PostgREST table name. */
-    table: string;
-    /** Columns to select (default `"*"`). */
-    select?: string;
-    /** Stable id derivation. Defaults to `(row) => String(row.id)`. */
-    identify?: (row: T) => string;
-    /** Whether the local cache is treated as authoritative. */
-    authoritative?: boolean;
-    /** Stale-time hint in ms. */
-    staleTime?: number;
-    /** Free-text search column list (compiled to `or=col.ilike.*query*,…`). */
-    searchColumns?: string[];
-    /** Default page size when `ListQuery.limit` is absent. */
-    defaultLimit?: number;
-}
-/**
- * Build an `EntityTransport<T>` from a Supabase client + a table name.
- *
- * The returned transport:
- * - Maps `ListQuery.filter` clauses to PostgREST operators (`eq`, `gt`,
- *   `in`, `ilike`, `is null`, etc.).
- * - Compiles `ListQuery.search` into an `or=` clause across
- *   `searchColumns`.
- * - Uses `count: 'exact'` on first page to surface `total`.
- * - Throws `TerminalError` on 4xx (no retry); `TransientError` on 5xx
- *   or network failure.
- * - Honours `signal` via `.abortSignal(signal)` (supabase-js >= 2.39).
- */
-declare function makeRestTransport<T extends object>(opts: MakeRestTransportOptions<T>): EntityTransport<T>;
-
-declare function getValueAtPath<T = unknown>(source: unknown, path: string): T | undefined;
-declare function setValueAtPath<T extends object>(source: T, path: string, value: unknown): T;
-declare function collectDirtyPaths(current: unknown, original: unknown, prefix?: string, acc?: Set<string>): Set<string>;
-
-/**
- * merge/types.ts — Pluggable conflict-resolution seam for the entity graph.
- *
- * Why a port (not a hard-wired engine):
- * - The graph receives concurrent writes from multiple sources — realtime
- *   adapters (Flint, Supabase, Surreal), AG-UI agents, and optimistic local
- *   mutations. The default resolution is last-write-wins (LWW), matching the
- *   historical shallow-merge in `upsertEntity`.
- * - Collaborative / agentic multi-writer scenarios need stronger guarantees
- *   (CRDT). But the *engine* (Loro vs Automerge vs Yjs) is a downstream
- *   decision — and the Flint fabric's own CRDT choice is still open. Encoding
- *   the decision as a swappable `MergeStrategy` keeps that open decision from
- *   blocking this layer.
- *
- * One strategy is registered per entity type (or a global default). The graph
- * consults it at write time; absent a registration it falls back to LWW, so
- * existing behavior is byte-for-byte preserved.
- */
-
-/** Context handed to a {@link MergeStrategy} for one write. */
-interface MergeContext {
-    /** Entity kind being written. */
-    type: EntityType;
-    /** Entity id being written. */
-    id: EntityId;
-    /** Provenance of the incoming write (server / client / optimistic). */
-    origin: SyncOrigin;
-    /** Wall-clock ms of the incoming write, when the caller knows it. */
-    updatedAt: number | null;
-}
-/**
- * Resolves the next canonical entity value from the previous value and an
- * incoming partial/full write.
- *
- * Contract:
- * - MUST be pure (no side effects, no graph access) — the graph applies the
- *   returned value inside its Immer producer.
- * - MUST return a NEW object; never mutate `prev` or `next` (immutability rule).
- * - `prev` is `undefined` on first write for an id.
- *
- * @param prev - Current canonical value, or undefined if none exists yet.
- * @param next - Incoming write (partial for upsert, full for replace).
- * @param ctx  - Type/id/origin/timestamp metadata for this write.
- * @returns The merged canonical value to store.
- */
-type MergeStrategy = (prev: Record<string, unknown> | undefined, next: Record<string, unknown>, ctx: MergeContext) => Record<string, unknown>;
-
-/**
- * merge/lww.ts — Last-write-wins default strategy.
- *
- * Semantics match the historical `upsertEntity` behavior exactly: shallow-merge
- * the incoming write over the previous value. This is the fallback when no
- * other strategy is registered, so registering nothing is a no-op change.
- */
-
-/**
- * Shallow-merge `next` over `prev` (incoming keys win). Returns a new object.
- * On first write (`prev` undefined) returns a shallow copy of `next`.
- */
-declare const lwwStrategy: MergeStrategy;
-
-/**
- * merge/registry.ts — One MergeStrategy per entity type (+ optional global default).
- *
- * Lookup order at write time:
- *   1. strategy registered for the exact `type`
- *   2. global default strategy (if one was set)
- *   3. built-in LWW (`lwwStrategy`)
- *
- * Step 3 guarantees that with zero registrations the graph behaves exactly as
- * it did before this seam existed.
- */
-
-/**
- * Register a {@link MergeStrategy} for one entity type. Overwrites any prior
- * registration for that type.
- */
-declare function registerMergeStrategy(type: string, strategy: MergeStrategy): void;
-/**
- * Set the fallback strategy used for any type without its own registration.
- * Pass `null` to clear it (reverting the fallback to built-in LWW).
- */
-declare function setDefaultMergeStrategy(strategy: MergeStrategy | null): void;
-/**
- * Resolve the effective strategy for a type: per-type → global default → LWW.
- * Always returns a usable strategy (never null).
- */
-declare function getMergeStrategy(type: string): MergeStrategy;
-/** True if `type` (or a global default) has a non-LWW strategy registered. */
-declare function hasMergeStrategy(type: string): boolean;
-
-/**
- * merge/loro.ts — Loro-backed CRDT MergeStrategy (reference implementation).
- *
- * Maps each entity (`type:id`) onto a Loro document whose root is an LWW-Map —
- * a near-1:1 fit for the graph's `type:id:field` model. Concurrent field writes
- * resolve via Loro's CRDT semantics rather than blind last-write-wins, so two
- * writers updating *different* fields never clobber each other, and writers
- * updating the *same* field resolve deterministically across replicas.
- *
- * `loro-crdt` is an OPTIONAL peer dependency. It is imported lazily so the core
- * bundle stays `zustand + immer` only — nothing loads Loro unless an app
- * actually registers `createLoroMergeStrategy()`.
- *
- * NOTE: `createLoroMergeStrategy` is async because it dynamically imports the
- * engine. Await it once at boot, then register the resolved synchronous
- * strategy. The returned strategy itself is pure+sync (the MergeStrategy
- * 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.
- *
- * @example
- * ```ts
- * const loro = await createLoroMergeStrategy();
- * registerMergeStrategy("Document", loro);
- * ```
- */
-declare function createLoroMergeStrategy(loadLoro?: LoroModuleLoader): Promise<MergeStrategy>;
-
-type GraphStore = ReturnType<typeof useGraphStore.getState>;
-type GraphIncludeMap = Record<string, GraphIncludeRelation>;
-type GraphIncludeRelation = {
-    type: EntityType;
-    via: {
-        kind: "field";
-        field: string;
-    };
-    include?: GraphIncludeMap;
-} | {
-    type: EntityType;
-    via: {
-        kind: "array";
-        field: string;
-    };
-    include?: GraphIncludeMap;
-} | {
-    type: EntityType;
-    via: {
-        kind: "list";
-        key: QueryKey | ((entity: Record<string, unknown>) => QueryKey | null | undefined);
-    };
-    include?: GraphIncludeMap;
-} | {
-    type: EntityType;
-    via: {
-        kind: "resolver";
-        resolve: (entity: Record<string, unknown>, store: GraphStore) => EntityId | EntityId[] | null | undefined;
-    };
-    include?: GraphIncludeMap;
-};
-interface GraphQueryOptions<TEntity extends object> {
-    type: EntityType;
-    id?: EntityId;
-    ids?: EntityId[];
-    listKey?: QueryKey;
-    where?: (entity: EntitySnapshot<TEntity>) => boolean;
-    sort?: (a: EntitySnapshot<TEntity>, b: EntitySnapshot<TEntity>) => number;
-    include?: GraphIncludeMap;
-    select?: ((entity: Record<string, unknown>) => unknown) | string[];
-}
-type ProjectedRow = Record<string, unknown>;
-declare function queryOnce<TEntity extends object>(opts: GraphQueryOptions<TEntity> & {
-    id: EntityId;
-}): ProjectedRow | null;
-declare function queryOnce<TEntity extends object>(opts: GraphQueryOptions<TEntity>): ProjectedRow[];
-declare const selectGraph: typeof queryOnce;
-
-interface GraphDataSnapshot {
-    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;
-    replaceEntity: (type: EntityType, id: EntityId, data: Record<string, unknown>) => GraphTransaction;
-    removeEntity: (type: EntityType, id: EntityId) => GraphTransaction;
-    patchEntity: (type: EntityType, id: EntityId, patch: Record<string, unknown>) => GraphTransaction;
-    clearPatch: (type: EntityType, id: EntityId) => GraphTransaction;
-    insertIdInList: (key: QueryKey, id: EntityId, position: "start" | "end" | number) => GraphTransaction;
-    removeIdFromAllLists: (type: EntityType, id: EntityId) => GraphTransaction;
-    setEntitySyncMetadata: (type: EntityType, id: EntityId, metadata: Partial<EntitySyncMetadata>) => GraphTransaction;
-    markEntityPending: (type: EntityType, id: EntityId, origin?: SyncOrigin) => GraphTransaction;
-    markEntitySynced: (type: EntityType, id: EntityId, origin?: SyncOrigin) => GraphTransaction;
-    commit: () => void;
-    rollback: () => void;
-    snapshot: () => GraphDataSnapshot;
-}
-interface GraphActionOptions<TInput, TResult> {
-    key?: string;
-    optimistic?: (tx: GraphTransaction, input: TInput) => void;
-    run: (tx: GraphTransaction, input: TInput) => Promise<TResult> | TResult;
-    onSuccess?: (result: TResult, input: TInput, tx: GraphTransaction) => void;
-    onError?: (error: Error, input: TInput) => void;
-}
-interface GraphActionRecord$1 {
-    id: string;
-    key: string;
-    input: unknown;
-    enqueuedAt: string;
-}
-type GraphActionEvent = {
-    type: "enqueued";
-    record: GraphActionRecord$1;
-} | {
-    type: "settled";
-    record: GraphActionRecord$1;
-};
-declare function createGraphTransaction(storeApi?: GraphStore$1): GraphTransaction;
-declare function createGraphAction<TInput, TResult>(opts: GraphActionOptions<TInput, TResult>): (input: TInput) => Promise<TResult>;
-
-interface GraphEffectEvent<T> {
-    key: string;
-    value: T;
-    previousValue: T;
-}
-interface GraphEffectOptions<T> {
-    query: () => T[] | T | null;
-    getKey?: (value: T, index: number) => string;
-    skipInitial?: boolean;
-    isEqual?: (previousValue: T, nextValue: T) => boolean;
-    onEnter?: (event: {
-        key: string;
-        value: T;
-    }) => void;
-    onUpdate?: (event: GraphEffectEvent<T>) => void;
-    onExit?: (event: {
-        key: string;
-        previousValue: T;
-    }) => void;
-}
-interface GraphEffectHandle {
-    dispose: () => void;
-}
-declare function createGraphEffect<T>(opts: GraphEffectOptions<T>): GraphEffectHandle;
-
-/**
- * schema.ts (core) — framework-agnostic JSON-schema registry + snapshot/markdown
- * helpers. The React field renderers/editors (MarkdownFieldRenderer,
- * MarkdownFieldEditor, useSchemaEntityFields, buildEntityFieldsFromSchema which
- * depends on the UI FieldDescriptor type) live in the react binding's schema.tsx,
- * built on these primitives.
- */
-interface JsonSchemaObject {
-    $id?: string;
-    title?: string;
-    description?: string;
-    type?: string | string[];
-    format?: string;
-    enum?: readonly unknown[];
-    default?: unknown;
-    properties?: Record<string, JsonSchemaObject>;
-    items?: JsonSchemaObject;
-    required?: string[];
-    additionalProperties?: boolean | JsonSchemaObject;
-    ["x-a2ui-component"]?: string;
-    ["x-display-order"]?: number;
-    ["x-field-type"]?: string;
-    ["x-hidden"]?: boolean;
-}
-interface EntityJsonSchemaConfig {
-    entityType: string;
-    schemaId?: string;
-    field?: string;
-    version?: string;
-    source?: "static" | "runtime" | "ai";
-    schema: JsonSchemaObject;
-}
-interface GetEntityJsonSchemaOptions {
-    entityType: string;
-    schemaId?: string;
-    field?: string;
-}
-interface GraphSnapshotWithSchemasOptions {
-    scope: string;
-    data: unknown;
-    schemas: Array<EntityJsonSchemaConfig | null | undefined>;
-    pretty?: boolean;
-}
-declare function registerEntityJsonSchema(config: EntityJsonSchemaConfig): void;
-declare function registerRuntimeSchema(config: EntityJsonSchemaConfig): void;
-declare function getEntityJsonSchema(opts: GetEntityJsonSchemaOptions): EntityJsonSchemaConfig | null;
-declare function exportGraphSnapshotWithSchemas(opts: GraphSnapshotWithSchemasOptions): string;
-declare function escapeHtml(input: string): string;
-declare function renderMarkdownToHtml(value: string): string;
-/** Infer a coarse field-type string from a JSON-schema node (UI-agnostic). */
-declare function inferSchemaFieldType(schema: JsonSchemaObject): string;
-declare function registryKey(entityType: string, field?: string, schemaId?: string): string;
-declare function humanizeFieldName(value: string): string;
-
-interface GraphSnapshotExportOptions {
-    scope: string;
-    data: unknown;
-    pretty?: boolean;
-}
-interface GraphToolContext {
-    store: ReturnType<typeof useGraphStore.getState>;
-    queryOnce: typeof queryOnce;
-    exportGraphSnapshot: typeof exportGraphSnapshot;
-}
-interface SchemaGraphToolContext extends GraphToolContext {
-    getEntityJsonSchema: typeof getEntityJsonSchema;
-    exportGraphSnapshotWithSchemas: typeof exportGraphSnapshotWithSchemas;
-}
-declare function exportGraphSnapshot(opts: GraphSnapshotExportOptions): string;
-declare function createGraphTool<TInput, TResult>(handler: (input: TInput, ctx: GraphToolContext) => Promise<TResult> | TResult): (input: TInput) => TResult | Promise<TResult>;
-declare function createSchemaGraphTool<TInput, TResult>(handler: (input: TInput, ctx: SchemaGraphToolContext) => Promise<TResult> | TResult): (input: TInput) => TResult | Promise<TResult>;
-
-interface GraphPersistenceAdapter {
-    get: (key: string) => Promise<string | null> | string | null;
-    set: (key: string, value: string) => Promise<void> | void;
-    remove?: (key: string) => Promise<void> | void;
-}
-interface GraphActionRecord {
-    id: string;
-    key: string;
-    input: unknown;
-    enqueuedAt: string;
-}
-interface GraphSyncStatus {
-    phase: "idle" | "hydrating" | "syncing" | "ready" | "offline" | "error";
-    isOnline: boolean;
-    isSynced: boolean;
-    pendingActions: number;
-    lastHydratedAt: string | null;
-    lastPersistedAt: string | null;
-    storageKey: string | null;
-    error: string | null;
-}
-interface GraphSnapshotPayload {
-    version: 1;
-    snapshot: {
-        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.
- *
- * The replay loop tracks per-action attempt counts. After `maxAttempts`
- * failed attempts the action is considered "poisoned" — it is removed from
- * the in-memory pending queue (so it won't block other actions) and the
- * optional `poisonHandler` is invoked. Consumers typically log the action,
- * surface a UI prompt, or persist it to a dead-letter store.
- *
- * Defaults: 5 attempts, starting at 500ms, doubling up to 30s, with
- * "equal" jitter (random in `[delay/2, delay]`).
- */
-interface ReplayRetryPolicy {
-    maxAttempts?: number;
-    initialDelayMs?: number;
-    maxDelayMs?: number;
-    backoffFactor?: number;
-    jitter?: "full" | "equal" | "none";
-    poisonHandler?: (action: GraphActionRecord, error: unknown) => void | Promise<void>;
-}
-interface StartLocalFirstGraphOptions {
-    storage: GraphPersistenceAdapter;
-    store?: GraphStore$1;
-    key?: string;
-    replayPendingActions?: boolean;
-    onlineSource?: {
-        getIsOnline: () => boolean;
-        subscribe: (listener: (online: boolean) => void) => () => void;
-    };
-    persistDebounceMs?: number;
-    /** Retry-with-backoff policy for offline action replay. */
-    retryPolicy?: ReplayRetryPolicy;
-}
-interface LocalFirstGraphRuntime {
-    ready: Promise<void>;
-    dispose: () => void;
-    persistNow: () => Promise<void>;
-    hydrate: () => Promise<Awaited<ReturnType<typeof hydrateGraphFromStorage>>>;
-    getStatus: () => 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;
-    bytes: number;
-    persistedAt: string;
-}>;
-declare function hydrateGraphFromStorage(opts: HydrateGraphFromStorageOptions): Promise<{
-    ok: false;
-    key: string;
-    hydratedAt: null;
-    entityCounts: {};
-    error: string;
-    pendingActions?: undefined;
-} | {
-    ok: true;
-    key: string;
-    hydratedAt: string;
-    entityCounts: {
-        [k: string]: number;
-    };
-    pendingActions: GraphActionRecord[];
-    error?: undefined;
-}>;
-declare function startLocalFirstGraph(opts: StartLocalFirstGraphOptions): LocalFirstGraphRuntime;
-interface ResolvedRetryPolicy {
-    maxAttempts: number;
-    initialDelayMs: number;
-    maxDelayMs: number;
-    backoffFactor: number;
-    jitter: "full" | "equal" | "none";
-    poisonHandler?: (action: GraphActionRecord, error: unknown) => void | Promise<void>;
-}
-/**
- * Attempt to replay an action up to `maxAttempts` times. On exhaustion the
- * action goes to "poison" — the optional handler is invoked and the function
- * resolves. Exposed for unit testing.
- */
-declare function replayActionWithRetry(action: GraphActionRecord, policy: ResolvedRetryPolicy, storeApi?: GraphStore$1): Promise<{
-    ok: true;
-} | {
-    ok: false;
-    poisoned: true;
-    error: unknown;
-}>;
-
-/** Deprecated in-process event shape retained by the package root. */
-type LegacyDevtoolsEvent = {
-    kind: "upsert";
-    type: string;
-    id: string;
-    data: Record<string, unknown>;
-    at: string;
-} | {
-    kind: "patch";
-    type: string;
-    id: string;
-    patch: Record<string, unknown>;
-    at: string;
-} | {
-    kind: "unpatch";
-    type: string;
-    id: string;
-    keys: string[];
-    at: string;
-} | {
-    kind: "clearPatch";
-    type: string;
-    id: string;
-    at: string;
-} | {
-    kind: "list";
-    key: string;
-    idCount: number;
-    at: string;
-};
-
-/**
- * Process-wide defaults for stale times, retries, and background revalidation.
- * Keeps hook signatures small: `useEntity` / `useEntityList` merge these with per-query overrides.
- */
-interface EngineOptions {
-    defaultStaleTime?: number;
-    /** Max age (`Date.now() - lastFetched`) for evicting entities with zero subscribers during GC. */
-    defaultGcTime?: number;
-    /** Interval between GC passes when the collector is active (default 60s). */
-    gcInterval?: number;
-    maxRetries?: number;
-    retryBaseDelay?: number;
-    revalidateOnFocus?: boolean;
-    revalidateOnReconnect?: boolean;
-}
-/**
- * Declarative **instruction** for loading one entity: wire transport (`fetch`), normalization, and graph writes.
- * Hooks pass this to `fetchEntity`; the graph remains source of truth after success.
- */
-interface EntityQueryOptions<TRaw, TEntity extends object> {
-    type: EntityType;
-    id: EntityId | null | undefined;
-    fetch: (id: EntityId) => Promise<TRaw>;
-    normalize: (raw: TRaw) => TEntity;
-    idField?: string;
-    sideEffects?: (raw: TRaw, store: GraphStore$1) => void;
-    staleTime?: number;
-    enabled?: boolean;
-    onSuccess?: (entity: TEntity) => void;
-    onError?: (error: Error) => void;
-}
-/** Cursor/page knobs passed through to list `fetch` implementations (REST, GraphQL, etc.). */
-interface ListFetchParams {
-    cursor?: string;
-    page?: number;
-    pageSize?: number;
-    params?: Record<string, unknown>;
-}
-/**
- * Normalized list page shape from any backend. Items are mapped through `normalize` into `{ id, data }` upserts — the list stores ids only.
- */
-interface ListResponse<T> {
-    items: T[];
-    total?: number | null;
-    nextCursor?: string | null;
-    prevCursor?: string;
-    hasNextPage?: boolean;
-    hasPrevPage?: boolean;
-    page?: number;
-    pageSize?: number;
-}
-/**
- * Declarative **instruction** for a collection query: stable `queryKey`, fetcher, and per-row normalization into the graph.
- * `mode` controls whether a fetch replaces ids or appends (infinite scroll) when used with load-more.
- */
-interface ListQueryOptions<TRaw, TEntity extends object> {
-    type: EntityType;
-    queryKey: unknown[];
-    /**
-     * Inline fetcher (deprecated 1.x REST form). Optional in 2.0: pure graph
-     * subscriptions for Tier-A PGlite/Electric entities pass no fetcher — the
-     * graph is hydrated out-of-band and the hook only joins ids → entities.
-     * When omitted, `fetchList` is a no-op and the hook is read-only.
-     */
-    fetch?: (params: ListFetchParams) => Promise<ListResponse<TRaw>>;
-    /** Row normalizer. Optional alongside `fetch` (graph-only callers omit both). */
-    normalize?: (raw: TRaw) => {
-        id: EntityId;
-        data: TEntity;
-    };
-    sideEffects?: (items: TRaw[], store: GraphStore$1) => void;
-    mode?: "replace" | "append";
-    staleTime?: number;
-    enabled?: boolean;
-    onSuccess?: (result: ListResponse<TRaw>) => void;
-    onError?: (error: Error) => void;
-}
-/**
- * Deterministic string key for list queries so object order in nested keys does not create duplicate cache entries.
- * @param key - Hook-provided query key array (serializable values)
- */
-declare function serializeKey(key: unknown[]): string;
-/**
- * Collapse concurrent identical requests into one Promise (prevents stampedes when many components mount the same entity/list).
- * @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>, 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, store?: GraphStore$1): symbol;
-/** Pair with `registerSubscriber` on unmount so idle entities stop refetching. */
-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, store?: GraphStore$1): () => boolean;
-/** Total active entity subscriber tokens across all keys (sum of ref-counts). */
-declare function getActiveSubscriberCount(store?: GraphStore$1): number;
-/**
- * Discriminated union of devtools events.
- *
- * New inspection surfaces should use the versioned `./devtools` subpath.
- */
-type DevtoolsEvent = LegacyDevtoolsEvent;
-type DevtoolsListener = (event: DevtoolsEvent) => void;
-/**
- * Subscribe to the devtools event stream.
- *
- * - Returns an `UnsubscribeFn` that removes this listener.
- * - Idempotent: subscribing the same function reference twice tracks it once
- *   (Set semantics).
- * - Throwing listeners do NOT block delivery to other listeners; the error is
- *   logged via `console.warn` and dispatch continues.
- * - Re-entrancy safe: listeners that subscribe/unsubscribe during dispatch
- *   affect future events only, not the in-flight one.
- */
-declare function subscribeDevtoolsEvent(cb: DevtoolsListener): () => void;
-/**
- * Stops the periodic garbage-collection timer for the selected graph.
- */
-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 graph's collector.
- */
-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. */
-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>, 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, storeApi?: GraphStore$1): Promise<void>;
-/**
- * Opt-in window listeners that mark **subscribed** entities stale on focus/reconnect so hooks can SWR-refetch.
- * 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(storeApi?: GraphStore$1): () => void;
-
-/**
- * devtools-event-bus — W5 (seim-em-explorer-event-bus-registry)
- *
- * Ring-buffered, fan-out event bus on top of the W3 `subscribeDevtoolsEvent` tap.
- * Adds: replay-on-subscribe, microtask-level burst coalescing, multi-store registry.
- */
-
-interface DevtoolsEventBusOptions {
-    /** Maximum events retained in the ring buffer. Default: 500. */
-    bufferSize?: number;
-    /**
-     * Events 1..N (N = threshold) are dispatched individually as they arrive.
-     * Events N+1.. accumulate until the end of the microtask, then are coalesced
-     * into one synthetic `kind:"list"` summary event.
-     * Default: 10. Set to 0 to disable coalescing entirely.
-     */
-    coalesceBurstThreshold?: number;
-}
-interface DevtoolsEventBus {
-    /** Subscribe to live events. Replays current buffer synchronously before returning. */
-    subscribe(cb: (event: DevtoolsEvent) => void): () => void;
-    /** Snapshot of buffered events in chronological order (oldest first). */
-    getBuffer(): readonly DevtoolsEvent[];
-    /** Force-dispatch any pending coalesced burst synchronously. */
-    flush(): void;
-    /** Release engine-tap, clear all subscribers, cascade inactive to registry. */
-    destroy(): void;
-    /**
-     * Inject a synthetic `DevtoolsEvent` directly into the bus, bypassing the
-     * engine tap. Used by the Chrome MV3 extension panel to feed events arriving
-     * over the port-messaging bridge into the local bus instance.
-     */
-    inject(event: DevtoolsEvent): void;
-}
-/** Matches the signature of `subscribeDevtoolsEvent` — used for external sources. */
-type DevtoolsSourceFn = (cb: (event: DevtoolsEvent) => void) => () => void;
-interface RegisteredStore {
-    name: string;
-    active: boolean;
-}
-/** Test-only helper: clears the devtools store registry between test runs. */
-declare function __resetStoreRegistry(): void;
-declare function createDevtoolsEventBus(opts?: DevtoolsEventBusOptions): DevtoolsEventBus;
-/**
- * Wire an additional event source into an existing `DevtoolsEventBus`.
- * Events from `source` flow through the bus's ring buffer, coalescing, and fan-out.
- * Throws if `name` is already registered and active.
- */
-declare function registerStore(bus: DevtoolsEventBus, source: DevtoolsSourceFn, name: string): () => void;
-/** Returns registered stores for one bus, or every bus for legacy callers. */
-declare function getRegisteredStores(bus?: DevtoolsEventBus): ReadonlyArray<RegisteredStore>;
-
-/**
- * Deprecated root time-travel compatibility facade.
- *
- * Snapshot data, cursors, retention, rewind state, and listeners are owned by
- * the optional per-store DevTools controller. This root module imports only a
- * lightweight delegate bridge, so normal package imports do not pull the
- * optional controller/protocol implementation into the root bundle.
- */
-
-type GraphSlice = Pick<ReturnType<typeof graphStore.getState>, "entities" | "patches" | "entityStates" | "syncMetadata" | "lists">;
-interface TimeTravelSnapshot {
-    /** Monotonic controller cursor for the captured state. */
-    seq: number;
-    /** Capture timestamp (ms). */
-    at: number;
-    /** Optional compatibility label. */
-    label?: string;
-    /** Snapshot payloads are controller-private and no longer exposed at root. */
-    data: GraphSlice;
-}
-interface TimeTravelState {
-    snapshots: ReadonlyArray<Omit<TimeTravelSnapshot, "data">>;
-    /** Compatibility ring index currently restored, or null when live. */
-    cursor: number | null;
-    capacity: number;
-}
-/** @deprecated Attach `@prometheus-ags/entity-graph-core/devtools` and configure its controller. */
-declare function configureTimeTravel(opts: {
-    capacity?: number;
-}, storeApi?: GraphStore$1): void;
-/**
- * @deprecated Use the attached controller's automatic snapshot history.
- * Returns `-1` when the optional controller is not attached to `storeApi`.
- */
-declare function recordGraphSnapshot(label?: string, storeApi?: GraphStore$1): number;
-/** @deprecated Use `controller.rewind(cursor)` from the explicit `./devtools` entry. */
-declare function restoreGraphSnapshot(index: number, storeApi?: GraphStore$1): boolean;
-/** @deprecated Use `controller.rewind(cursor)` from the explicit `./devtools` entry. */
-declare function restoreGraphSnapshotBySeq(seq: number, storeApi?: GraphStore$1): boolean;
-/** @deprecated Resolve retained cursors through the explicit per-store controller. */
-declare function stepTimeTravel(delta: number, storeApi?: GraphStore$1): boolean;
-/** @deprecated Use `controller.getSnapshotHistoryStatus()` and controller events. */
-declare function getTimeTravelState(storeApi?: GraphStore$1): TimeTravelState;
-/** @deprecated Subscribe to the explicit per-store controller. */
-declare function subscribeTimeTravel(cb: () => void, storeApi?: GraphStore$1): () => void;
-
-/**
- * Evaluate `FilterSpec` against one in-memory entity — mirrors remote semantics as closely as plain JS allows.
- * Use for **local** and **hybrid** `useEntityView` paths so UI filtering matches what users expect from the declarative spec.
- */
-declare function matchesFilter(entity: Record<string, unknown>, filter: FilterSpec): boolean;
-/**
- * Case-insensitive substring match across configured string fields; empty query is a no-op pass.
- * Keeps quick search consistent between client-only and debounced remote `q` params.
- */
-declare function matchesSearch(entity: Record<string, unknown>, query: string, fields: string[]): boolean;
-/**
- * Multi-key comparator implementing `SortSpec` (null ordering, optional custom comparators, locale-aware string fallback).
- * Shared by local sorting and binary insertion for realtime updates.
- */
-declare function compareEntities(a: Record<string, unknown>, b: Record<string, unknown>, sort: SortSpec): number;
-/**
- * Binary-search insertion index so realtime inserts land in sorted order without resorting the full id list (O(log n) per insert).
- * Skips missing `getEntity` rows by advancing low — callers should ensure entities exist or tolerate append-like behavior.
- */
-declare function findInsertionIndex(entity: Record<string, unknown>, sortedIds: string[], getEntity: (id: string) => Record<string, unknown> | null, sort: SortSpec): number;
-/**
- * Pure list projection: map ids → entities, drop missing, filter/sort/search, return **ids** in display order.
- * Bridges stored id lists with on-the-fly view descriptors without duplicating entity payloads.
- */
-declare function applyView(ids: string[], getEntity: (id: string) => Record<string, unknown> | null, filter?: FilterSpec | null, sort?: SortSpec | null, search?: {
-    query: string;
-    fields: string[];
-} | null): string[];
-/**
- * Heuristic for whether the graph likely holds **all** rows for a list key (enables local-only filtering/sorting in `useEntityView`).
- * `total` and `hasNextPage` come from list metadata written by fetchers.
- */
-declare function checkCompleteness(loadedCount: number, total: number | null, hasNextPage: boolean): {
-    isComplete: boolean;
-    reason: string;
-};
-
-/**
- * view/incremental.ts — G3 parity: incremental view maintenance.
- *
- * The baseline `applyView` re-filters + re-sorts the entire id list on every
- * change — O(n) per update. For large lists this is the gap vs TanStack DB's
- * differential-dataflow live queries.
- *
- * This maintains a derived, sorted result and updates it for a SINGLE entity
- * change in O(log n): binary-search the entity's current position, decide
- * membership via the filter, and insert / remove / reposition. No full
- * re-derivation. Result is byte-identical to `applyView` for the same inputs
- * (correctness parity is asserted in tests).
- *
- * Design choice: a hand-rolled dirty-tracking index rather than adopting d2ts
- * (0.1.x, pre-production) — same acceptance bar (sub-linear single-row update),
- * far lower dependency risk. The differential engine can replace the internals
- * later behind this same class without an API change.
- */
-
-interface IncrementalViewOptions {
-    filter?: FilterSpec | null;
-    sort?: SortSpec | null;
-    search?: {
-        query: string;
-        fields: string[];
-    } | null;
-    /** Resolve an entity by id from the graph (or null if absent). */
-    getEntity: (id: string) => Record<string, unknown> | null;
-}
-/**
- * A live, sorted view over a set of entity ids that updates incrementally.
- *
- * - `seed(ids)` builds the initial result (one O(n log n) pass).
- * - `applyChange(id)` updates the result for one changed/added/removed entity
- *   in O(log n) comparisons (+ array splice).
- * - `result()` returns the current ordered id list (stable reference until a
- *   change mutates it).
- */
-declare class IncrementalView {
-    private readonly opts;
-    private ids;
-    private readonly members;
-    constructor(opts: IncrementalViewOptions);
-    /** Whether an entity qualifies for this view (filter + search). */
-    private qualifies;
-    /** Comparator over ids using the configured sort (stable, id tiebreak). */
-    private cmp;
-    /** Binary-search the insertion index for `id` among current `ids`. */
-    private insertionIndex;
-    /** Build the initial sorted result from a full id set. */
-    seed(ids: string[]): void;
-    /**
-     * Update the view for ONE entity that changed/was added/removed.
-     * Returns true if the result order changed.
-     *
-     * O(log n) to locate; the array splice is O(n) memory-move but performs no
-     * filter/sort over the whole set — the differentiator from full re-derivation.
-     */
-    applyChange(id: string): boolean;
-    /** Current ordered id list. */
-    result(): string[];
-    /** Current member count. */
-    size(): number;
-}
-
-/**
- * FK edge: this entity points at one parent row. Used to invalidate parent aggregates and optional list keys when the FK changes.
- */
-interface BelongsToRelation {
-    cardinality: "belongsTo";
-    foreignKey: string;
-    targetType: EntityType;
-    invalidateTargetLists?: string[];
-}
-/**
- * Inverse collection: children carry `foreignKey` pointing here; `listKeyPrefix` builds the child list query key for a given parent id.
- */
-interface HasManyRelation {
-    cardinality: "hasMany";
-    targetType: EntityType;
-    foreignKey: string;
-    listKeyPrefix: (parentId: EntityId) => unknown[];
-}
-/**
- * Join-style relation stored as an id array on this entity; invalidates partner lists derived via `listKeyPrefix` for each touched id.
- */
-interface ManyToManyRelation {
-    cardinality: "manyToMany";
-    targetType: EntityType;
-    localArrayField?: string;
-    listKeyPrefix: (thisId: EntityId) => unknown[];
-}
-type RelationDescriptor = BelongsToRelation | HasManyRelation | ManyToManyRelation;
-/**
- * Declarative relation metadata for one `EntityType`: optional named relations and list key prefixes to invalidate on any mutation.
- */
-interface EntitySchema {
-    type: EntityType;
-    relations?: Record<string, RelationDescriptor>;
-    globalListKeys?: string[];
-}
-/**
- * Snapshot diff passed to cascade rules after CRUD: compare `previous` vs `next` to find FK moves, array membership changes, etc.
- */
-interface CascadeContext {
-    type: EntityType;
-    id: EntityId;
-    previous: Record<string, unknown> | null;
-    next: Record<string, unknown> | null;
-    op: "create" | "update" | "delete";
-}
-/** Register or replace schema for `schema.type` (typically at app init). */
-declare function registerSchema(schema: EntitySchema): void;
-/** Lookup schema for cascade/join reads; returns null if unregistered. */
-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, 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>, storeApi?: GraphStore$1): Record<string, unknown>;
-
-/**
- * agent/json-patch.ts — Minimal RFC-6902 JSON Patch applier.
- *
- * AG-UI `STATE_DELTA` events carry RFC-6902 operations. Rather than take a hard
- * dependency on `fast-json-patch` (last released 2022) or require consumers to
- * have `@ag-ui/client`'s applier, this implements the standard's six operations
- * directly. It is small, dependency-free, and fully unit-tested.
- *
- * Immutability: every op returns a NEW document; the input is never mutated.
- *
- * Supported ops: add, replace, remove, move, copy, test.
- * Pointers follow RFC-6901 (`/a/b/0`), including the `-` array-append token and
- * `~1`/`~0` escapes for `/` and `~`.
- */
-interface JsonPatchOp {
-    op: "add" | "remove" | "replace" | "move" | "copy" | "test";
-    path: string;
-    /** For add/replace/test. */
-    value?: unknown;
-    /** For move/copy. */
-    from?: string;
-}
-/**
- * Apply a sequence of RFC-6902 operations to `doc`, returning a new document.
- * A failing `test` op throws (per spec); structural ops are applied in order.
- */
-declare function applyJsonPatch<T = unknown>(doc: T, ops: readonly JsonPatchOp[]): T;
-
-/**
- * agent/ag-ui-bridge.ts — Ingest AG-UI agent state into the entity graph.
- *
- * The headline agentic capability (change C2): an agent emits AG-UI state, it
- * lands in the entity graph, and every view reading those entities updates.
- *
- * AG-UI (https://docs.ag-ui.com) streams two state events:
- *   - STATE_SNAPSHOT — the complete agent state object
- *   - STATE_DELTA    — a partial update as an RFC-6902 JSON Patch
- *
- * Our `patchEntity`/`upsertEntity` already align with this model: STATE_DELTA's
- * JSON Patch maps onto the graph, and writes route through the C1 MergeStrategy
- * so agent edits resolve against concurrent realtime/local writes.
- *
- * Mapping: the agent's state tree is projected onto entities via an
- * {@link AgUiStateMapping}. Each entry says "the object at this JSON-Pointer
- * prefix is an entity of `type`, keyed by `id` (a field of that object or a
- * constant)". This keeps the bridge transport-agnostic — it does not depend on
- * `@ag-ui/client` and takes plain event objects, so `@ag-ui/*` stays an OPTIONAL
- * peer (use it for typed events on the consumer side if desired).
- */
-
-/** AG-UI STATE_SNAPSHOT event (minimal shape — no @ag-ui dependency). */
-interface AgUiStateSnapshotEvent {
-    type?: "STATE_SNAPSHOT" | string;
-    snapshot: Record<string, unknown>;
-}
-/** AG-UI STATE_DELTA event (minimal shape — RFC-6902 patch). */
-interface AgUiStateDeltaEvent {
-    type?: "STATE_DELTA" | string;
-    delta: JsonPatchOp[];
-}
-/** Maps one slice of agent state onto an entity type. */
-interface AgUiStateMapping {
-    /** Entity type the mapped object(s) belong to. */
-    entityType: string;
-    /**
-     * JSON-Pointer prefix into the agent state where this entity (or collection)
-     * lives. `"/order"` → a single entity; `"/orders"` → a collection keyed by id.
-     */
-    pointer: string;
-    /** Whether `pointer` addresses one object or a collection (array/record). */
-    kind: "single" | "collection";
-    /**
-     * Field on each object that holds its entity id. For `single` you may instead
-     * pass a constant id via `constantId`.
-     */
-    idField?: string;
-    /** Constant id for `single` mappings whose object has no id field. */
-    constantId?: string;
-    /**
-     * How to write: `upsert` (merge via MergeStrategy — default) or `replace`
-     * (full overwrite). Snapshots typically replace; deltas typically upsert.
-     */
-    write?: "upsert" | "replace";
-}
-interface ApplyAgUiOptions {
-    mappings: AgUiStateMapping[];
-}
-/**
- * Apply an AG-UI STATE_SNAPSHOT to the graph. Each mapped slice is written as an
- * entity. Snapshots default to `replace` semantics when the mapping does not
- * specify otherwise is left to the mapping's `write` field (default upsert).
- *
- * @example
- * ```ts
- * applyAgUiSnapshot(event, { mappings: [
- *   { entityType: "Order", pointer: "/order", kind: "single", write: "replace" },
- *   { entityType: "LineItem", pointer: "/order/items", kind: "collection" },
- * ]});
- * ```
- */
-declare function applyAgUiSnapshot(event: AgUiStateSnapshotEvent, options: ApplyAgUiOptions): void;
-/**
- * Apply an AG-UI STATE_DELTA (RFC-6902 JSON Patch) to the graph.
- *
- * The delta is applied against a reconstructed agent-state view assembled from
- * the current graph entities (per the mappings), then the resulting slices are
- * re-projected back into the graph. This lets path-based deltas target nested
- * entity fields without the caller tracking the full agent state themselves.
- */
-declare function applyAgUiDelta(event: AgUiStateDeltaEvent, options: ApplyAgUiOptions, 
-/** Current agent-state view; if omitted, reconstructed from the graph mappings. */
-currentState?: Record<string, unknown>): void;
-
-/**
- * adapters/types.ts
- *
- * Common contract every data-source adapter implements.
- * The entity graph doesn't care whether data comes from REST, GraphQL,
- * WebSocket, Supabase, Convex, PGlite shape sync — they all speak this
- * interface and write into the same graph.
- */
-
-type ChangeOperation = "insert" | "update" | "delete" | "upsert";
-interface EntityChange<T = Record<string, unknown>> {
-    op: ChangeOperation;
-    type: EntityType;
-    id: EntityId;
-    data?: T;
-    patch?: Partial<T>;
-}
-interface ChangeSet<T = Record<string, unknown>> {
-    changes: EntityChange<T>[];
-    affectedListKeys?: string[];
-    timestamp?: string;
-}
-type UnsubscribeFn = () => void;
-interface SubscriptionConfig {
-    label?: string;
-    replayOnConnect?: boolean;
-}
-interface RealtimeAdapter {
-    readonly name: string;
-    subscribe(config: SubscriptionConfig, handler: (changeset: ChangeSet) => void): UnsubscribeFn;
-    onStatusChange?: (cb: (status: AdapterStatus) => void) => UnsubscribeFn;
-}
-type AdapterStatus = "connecting" | "connected" | "disconnected" | "error";
-interface SyncQueryResult<T> {
-    rows: T[];
-    total?: number;
-}
-interface SyncAdapter extends RealtimeAdapter {
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<SyncQueryResult<T>>;
-    execute(sql: string, params?: unknown[]): Promise<void>;
-    isSynced(): boolean;
-    onSyncComplete(cb: () => void): UnsubscribeFn;
-}
-interface ChannelConfig {
-    type: EntityType;
-    filter?: Record<string, unknown>;
-    id?: EntityId;
-    operations?: ChangeOperation[];
-}
-
-interface ManagerOptions {
-    flushInterval?: number;
-    store?: GraphStore$1;
-    onStatusChange?: (adapter: string, status: AdapterStatus) => void;
-    onChangeReceived?: (adapter: string, change: EntityChange) => void;
-}
-declare class RealtimeManager {
-    private adapters;
-    private pendingChanges;
-    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;
-    unregisterAll(): void;
-    private handleChangeset;
-    private scheduleFlush;
-    flush(): void;
-    forceFlush(): void;
-}
-declare function getRealtimeManager(opts?: ManagerOptions): RealtimeManager;
-declare function resetRealtimeManager(): void;
-
-/**
- * adapters/realtime-adapters.ts
- *
- * WebSocket, Supabase Realtime, Convex, and GraphQL subscription adapters.
- * All implement RealtimeAdapter and route through RealtimeManager → entity graph.
- */
-
-interface WebSocketAdapterOptions {
-    url: string | (() => string);
-    parseMessage?: (data: unknown) => EntityChange[] | null;
-    protocols?: string | string[];
-    reconnectBaseDelay?: number;
-    maxReconnectAttempts?: number;
-    pingInterval?: number;
-    pingMessage?: string;
-}
-declare function createWebSocketAdapter(opts: WebSocketAdapterOptions): RealtimeAdapter;
-interface SupabaseClient {
-    channel(name: string): SupabaseChannel;
-}
-interface SupabaseChannel {
-    on(event: "postgres_changes", config: {
-        event: "*" | "INSERT" | "UPDATE" | "DELETE";
-        schema: string;
-        table: string;
-        filter?: string;
-    }, handler: (payload: SupabasePayload) => void): SupabaseChannel;
-    subscribe(cb?: (status: string) => void): SupabaseChannel;
-    unsubscribe(): Promise<void>;
-}
-interface SupabasePayload {
-    eventType: "INSERT" | "UPDATE" | "DELETE";
-    new: Record<string, unknown>;
-    old: Record<string, unknown>;
-    table: string;
-}
-interface SupabaseAdapterOptions {
-    tableTypeMap?: Record<string, string>;
-    extractId?: (record: Record<string, unknown>) => string;
-    schema?: string;
-}
-declare function createSupabaseRealtimeAdapter(client: SupabaseClient, opts?: SupabaseAdapterOptions): RealtimeAdapter & {
-    subscribeChannel: (config: ChannelConfig & {
-        _handler?: (cs: ChangeSet) => void;
-    }) => UnsubscribeFn;
-};
-interface ConvexClient {
-    onUpdate<T>(query: unknown, args: Record<string, unknown>, handler: (result: T) => void): UnsubscribeFn;
-}
-interface ConvexChannelConfig<T extends object> {
-    type: string;
-    query: unknown;
-    args?: Record<string, unknown>;
-    extractId?: (record: T) => string;
-    normalize?: (record: T) => Record<string, unknown>;
-}
-declare function createConvexAdapter<T extends object>(opts: {
-    client: ConvexClient;
-    channels: ConvexChannelConfig<T>[];
-}): RealtimeAdapter;
-interface GQLWsClient {
-    subscribe<T>(payload: {
-        query: string;
-        variables?: Record<string, unknown>;
-    }, sink: {
-        next: (value: {
-            data: T;
-        }) => void;
-        error: (err: unknown) => void;
-        complete: () => void;
-    }): UnsubscribeFn;
-}
-interface GQLSubscriptionConfig<T extends object> {
-    type: string;
-    document: string;
-    variables?: Record<string, unknown>;
-    getPayload: (data: T) => GQLPayload | GQLPayload[] | null;
-}
-interface GQLPayload {
-    type?: string;
-    node?: Record<string, unknown>;
-    id?: string;
-}
-declare function createGraphQLSubscriptionAdapter<T extends object>(opts: {
-    client: GQLWsClient;
-    subscriptions: GQLSubscriptionConfig<T>[];
-    extractId?: (node: Record<string, unknown>, type: string) => string;
-    normalize?: (node: Record<string, unknown>, type: string) => Record<string, unknown>;
-}): RealtimeAdapter;
-
-/**
- * adapters/surreal-live.ts
- *
- * SurrealDB LIVE SELECT realtime adapter.
- *
- *   SurrealDB live stream → per-channel state machine → RealtimeAdapter contract
- *   one ChannelConfig = one LIVE SELECT = one independent reconnect/replay state
- *
- * Implements the RealtimeAdapter contract (NOT SyncAdapter) per the corrected
- * spec at openspec/specs/entity-surreal-live-adapter/spec.md. The consumer
- * owns the SurrealDB client; the adapter only orchestrates live queries.
- */
-
-interface SurrealLike {
-    query<T = unknown>(sql: string, vars?: Record<string, unknown>): Promise<T[]>;
-    live<T = unknown>(table: string, callback: (action: SurrealLiveAction<T>) => void, diff?: boolean): Promise<string>;
-    kill(uuid: string): Promise<void>;
-}
-interface SurrealLiveAction<T = unknown> {
-    action: "CREATE" | "UPDATE" | "DELETE" | "CLOSE" | string;
-    result: T;
-}
-interface SurrealCheckpointStore {
-    get(channelKey: string): Promise<string | undefined>;
-    set(channelKey: string, value: string): Promise<void>;
-}
-interface SurrealTableConfig {
-    type: EntityType;
-    /** SurrealDB table name; defaults to `type`. */
-    table?: string;
-    /** Field in the row that carries the entity id; defaults to "id". */
-    idField?: string;
-}
-interface SurrealLiveAdapterOptions {
-    name?: string;
-    surreal: SurrealLike;
-    tables: SurrealTableConfig[];
-    initialQueryStrategy?: "select-then-live" | "live-only";
-    initialDelayMs?: number;
-    maxDelayMs?: number;
-    connectedSettleMs?: number;
-    checkpointStore?: SurrealCheckpointStore;
-    checkpointField?: string;
-    listKeyResolver?: (change: EntityChange) => string[] | undefined;
-    permanentErrorPatterns?: RegExp[];
-}
-declare function createSurrealLiveAdapter(opts: SurrealLiveAdapterOptions): RealtimeAdapter;
-
-/**
- * adapters/flint.ts — Flint Realtime Fabric adapter.
- *
- *   Flint frf-entity-management `watchEntities()` AsyncIterable
- *     → our ChangeSet stream → RealtimeManager → entity graph
- *
- * GAP-1 is a BRIDGE, not a from-scratch build: the Flint repo already ships
- * `@prometheusags/frf-entity-management` whose `RealtimeAdapter.watchEntities()`
- * yields a plain `EntityEvent` (it JSON-decodes the spine envelope — no proto
- * types leak). We consume that entity-shaped facade behind a minimal-surface
- * type, so:
- *   - The unfrozen `proto-v1` risk is contained BELOW this seam.
- *   - `@prometheusags/frf-sdk` stays an OPTIONAL peer; this module imports
- *     nothing from it. The consumer constructs the Flint client and passes it in.
- *
- * `EntityEvent.offset` (bigint) is forwarded to an optional checkpoint store so
- * reconnects resume from the last seen offset (mirrors the surreal-live adapter).
- */
-
-/** A decoded entity change event received from the Flint spine. */
-interface FlintEntityEvent {
-    entityType: string;
-    entityId: string;
-    tenantId: string;
-    channelId: string;
-    data: Record<string, unknown>;
-    offset: bigint;
-    correlationId?: string;
-}
-/** Filter criteria for a Flint entity subscription. */
-interface FlintEntityQuery {
-    channelId: string;
-    consumerId: string;
-    entityType?: string;
-    fromOffset?: bigint;
-}
-/** An entity mutation to publish on the Flint spine. */
-interface FlintEntityRecord {
-    entityType: string;
-    entityId: string;
-    tenantId: string;
-    channelId: string;
-    data: Record<string, unknown>;
-    correlationId?: string;
-}
-/** Minimal surface of the Flint `RealtimeAdapter` we consume. */
-interface FlintClientLike {
-    watchEntities(query: FlintEntityQuery): AsyncIterable<FlintEntityEvent>;
-    mutateEntity(record: FlintEntityRecord): Promise<void>;
-}
-/** Optional resume-offset persistence (per channel+consumer). */
-interface FlintCheckpointStore {
-    get(key: string): Promise<bigint | undefined> | bigint | undefined;
-    set(key: string, offset: bigint): Promise<void> | void;
-}
-interface CreateFlintAdapterOptions {
-    name?: string;
-    /** The Flint entity-management client (frf-entity-management RealtimeAdapter). */
-    client: FlintClientLike;
-    /** Channel to subscribe/publish on. */
-    channelId: string;
-    /** Consumer id for this subscription. */
-    consumerId: string;
-    /** Restrict to one entity type (optional). */
-    entityType?: string;
-    /** Resume-offset store; reconnects start `fromOffset = lastSeen + 1`. */
-    checkpoints?: FlintCheckpointStore;
-    /** Map a Flint event to a change operation. Defaults to "upsert". */
-    resolveOp?: (event: FlintEntityEvent) => ChangeOperation;
-}
-/**
- * Build a {@link RealtimeAdapter} backed by the Flint Realtime Fabric.
- *
- * The consumer owns the Flint client (constructed from `@prometheusags/frf-sdk`
- * / `frf-entity-management`); this adapter only orchestrates the stream.
- *
- * @example
- * ```ts
- * import { RealtimeAdapter as FrfAdapter } from "@prometheusags/frf-entity-management";
- * import { getRealtimeManager, createFlintAdapter } from "@prometheus-ags/prometheus-entity-management";
- *
- * const flint = new FrfAdapter(spineClient);
- * const adapter = createFlintAdapter({ client: flint, channelId: "tenant-1", consumerId: "web-1" });
- * getRealtimeManager().register(adapter);
- * ```
- */
-declare function createFlintAdapter(options: CreateFlintAdapterOptions): RealtimeAdapter;
-/**
- * Publish an entity mutation to the Flint spine via the client.
- * Thin pass-through kept here so consumers import one Flint surface from us.
- */
-declare function publishFlintMutation(client: FlintClientLike, record: FlintEntityRecord): Promise<void>;
-
-/**
- * adapters/electricsql.ts (core)
- *
- * ElectricSQL + PGlite local-first adapter — the React-free base.
- *
- * Server Postgres → ElectricSQL shape sync (SSE) → PGlite (local WASM Postgres)
- *                                                        ↓ NOTIFY
- *                                                   Entity Graph (Zustand)
- *
- * React hooks (`useLocalFirst`, `usePGliteQuery`) live in the binding package
- * (`@prometheus-ags/entity-graph-react`), built on this adapter.
- */
-
-interface PGlite$1 {
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
-        rows: T[];
-    }>;
-    exec(sql: string): Promise<unknown>;
-    listen(channel: string, handler: (payload: string) => void): Promise<() => void>;
-}
-interface ShapeMessage$1<T = Record<string, unknown>> {
-    headers: {
-        operation: "insert" | "update" | "delete";
-    };
-    offset: string;
-    value: T;
-    key: string;
-}
-interface ShapeStream$1<T = Record<string, unknown>> {
-    subscribe(onMsg: (msgs: ShapeMessage$1<T>[]) => void, onErr?: (e: Error) => void): () => void;
-    isUpToDate: boolean;
-    lastOffset: string;
-}
-interface ElectricTableConfig<T extends object> {
-    type: EntityType;
-    table: string;
-    where?: string;
-    idColumn?: string;
-    normalize?: (row: T) => Record<string, unknown>;
-    shapeStream: ShapeStream$1<T>;
-}
-interface ElectricAdapterOptions {
-    pglite: PGlite$1;
-    tables: ElectricTableConfig<Record<string, unknown>>[];
-    onSynced?: () => void;
-}
-
-declare function createElectricAdapter(opts: ElectricAdapterOptions): SyncAdapter;
-
-/**
- * adapters/electricsql-tenant.ts
- *
- * Tenant-scoped Electric adapter — the safety primitive that enforces
- * **RULE 5 — Shape predicates ⊆ RLS** (see hotseaters constraints).
- *
- * PGlite has no row-level security. The only way to guarantee a client
- * never sees cross-tenant data through Electric is to refuse to attach
- * any shape that lacks a tenant predicate. This wrapper does exactly that:
- *
- *   - Validates the tenant claim (currently `{ companyId }`) is a UUID.
- *   - Refuses to attach a shape whose `tenantColumn` is `undefined`. We
- *     accept explicit `null` for the company root itself (filtered by `id`).
- *   - Builds the `where` clause from `tenantColumn` and the validated
- *     companyId so individual shape factories cannot drift from RLS.
- *   - Delegates to the existing `createElectricAdapter` for the actual
- *     sync wiring.
- *
- * This also fulfils Change 13 item 11 (auth-claim-aware shape registration):
- * the `tenantClaim` is the typed seam where authn meets shape registration.
- *
- * Self-hosted Supabase only. Local stack and `https://electricsql.prometheusags.ai`
- * are the only acceptable Electric endpoints — this module does not
- * hard-code either; it only governs the predicate.
- */
-
-interface PGlite {
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
-        rows: T[];
-    }>;
-    exec(sql: string): Promise<unknown>;
-    listen(channel: string, handler: (payload: string) => void): Promise<() => void>;
-}
-interface ShapeMessage<T = Record<string, unknown>> {
-    headers: {
-        operation: "insert" | "update" | "delete";
-    };
-    offset: string;
-    value: T;
-    key: string;
-}
-interface ShapeStream<T = Record<string, unknown>> {
-    subscribe(onMsg: (msgs: ShapeMessage<T>[]) => void, onErr?: (e: Error) => void): () => void;
-    isUpToDate: boolean;
-    lastOffset: string;
-}
-/** Auth claim required to register tenant-scoped shapes. */
-interface TenantClaim {
-    companyId: string;
-}
-interface TenantScopedTableConfig<T extends object = Record<string, unknown>> {
-    type: EntityType;
-    table: string;
-    /**
-     * Column used for tenant filtering.
-     *
-     * - A string (`"company_id"`) yields `WHERE company_id = '<companyId>'`.
-     * - Explicit `null` means the table IS the tenant root and is filtered by
-     *   `id = '<companyId>'`. Only the `company` table qualifies.
-     * - `undefined` is **rejected** — this is the safety gate.
-     */
-    tenantColumn: string | null;
-    primaryKey?: string[];
-    /**
-     * Factory invoked with the constructed `where` clause and the tenant claim.
-     * Consumers wire their preferred Electric `ShapeStream` builder here. The
-     * factory must use the supplied `where` verbatim (no widening).
-     */
-    shapeStreamFactory: (params: {
-        table: string;
-        where: string;
-        tenantClaim: TenantClaim;
-    }) => ShapeStream<T>;
-    normalize?: (row: T) => Record<string, unknown>;
-}
-interface TenantScopedAdapterOptions {
-    pglite: PGlite;
-    tenantClaim: TenantClaim;
-    tables: TenantScopedTableConfig[];
-    onSynced?: () => void;
-}
-/**
- * Build the `where` clause for a single shape. Exposed for tests.
- *
- * - `tenantColumn === null` → `id = '<companyId>'` (company-root case)
- * - `tenantColumn === string` → `<tenantColumn> = '<companyId>'`
- *
- * Throws if `tenantColumn` is `undefined` or `companyId` is not a UUID.
- */
-declare function buildTenantWhere(tenantColumn: string | null | undefined, companyId: string, tableLabel: string): string;
-/**
- * Build a tenant-scoped {@link SyncAdapter}.
- *
- * For each table in `tables`:
- *   1. Validates `tenantColumn` is defined (string or explicit null).
- *   2. Validates `companyId` is a UUID.
- *   3. Builds the predicate and calls `shapeStreamFactory(...)` to get the
- *      actual `ShapeStream`.
- *   4. Hands the resulting list off to `createElectricAdapter` for wiring.
- *
- * @throws if any table lacks `tenantColumn`, or the company id is not a UUID.
- */
-declare function createTenantScopedElectricAdapter(opts: TenantScopedAdapterOptions): SyncAdapter;
-
-/**
- * adapters/pglite-persistence.ts
- *
- * PGlite-backed implementation of {@link GraphPersistenceAdapter}.
- *
- * Stores the local-first runtime's graph snapshot inside a PGlite table
- * (`_graph_snapshot` by default) instead of `localStorage`/`IndexedDB`.
- *
- * Why this exists:
- *   - The app already has a PGlite handle for ElectricSQL sync.
- *   - Putting the graph snapshot alongside synced data means one storage
- *     surface to back up, clear, and reason about.
- *   - Works in Tauri WebView + Node (PGlite is a WASM Postgres) without
- *     pulling in browser-only storage.
- *
- * Contract:
- *   - `get(key)`    -> returns the stored string or null
- *   - `set(key, v)` -> upserts (insert-or-replace), stamping `updated_at`
- *   - `remove(key)` -> deletes the row (no-op if absent)
- *
- * The function lazily ensures the storage table exists on first call.
- * That `CREATE TABLE IF NOT EXISTS` is idempotent so it's safe to retry.
- *
- * Self-hosted Supabase only. HotSeatersMVP is the bible. This module does
- * not import `@electric-sql/pglite` — consumers pass a PGlite-shaped handle.
- */
-
-interface PGlitePersistenceClient {
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
-        rows: T[];
-    }>;
-    exec(sql: string): Promise<unknown>;
-}
-interface CreatePGlitePersistenceAdapterOptions {
-    /** Name of the snapshot table. Defaults to `_graph_snapshot`. */
-    tableName?: string;
-}
-/**
- * Returns a {@link GraphPersistenceAdapter} that reads/writes the graph
- * snapshot through a PGlite-shaped client.
- *
- * @example
- * ```ts
- * import { PGlite } from "@electric-sql/pglite";
- * import { startLocalFirstGraph, createPGlitePersistenceAdapter } from "@prometheus-ags/prometheus-entity-management";
- *
- * const pglite = await PGlite.create("idb://hotseaters");
- * const storage = await createPGlitePersistenceAdapter(pglite);
- * const runtime = startLocalFirstGraph({ storage, key: "hotseaters:graph" });
- * ```
- */
-declare function createPGlitePersistenceAdapter(pglite: PGlitePersistenceClient, options?: CreatePGlitePersistenceAdapterOptions): Promise<GraphPersistenceAdapter>;
-
-/**
- * adapters/tauri-sql-persistence.ts
- *
- * SQLite-backed implementation of {@link GraphPersistenceAdapter} for Tauri
- * desktop, via the official `@tauri-apps/plugin-sql` `Database` handle.
- *
- * Why this exists:
- *   - On Tauri desktop the natural on-device store is SQLite, not PGlite-wasm.
- *   - This pairs with `createPGlitePersistenceAdapter` (browser/wasm) so the
- *     same local-first runtime persists across web and desktop unchanged.
- *
- * The consumer owns the Tauri `Database` handle (from `Database.load(...)`).
- * This module does NOT import `@tauri-apps/plugin-sql` — it takes a
- * minimal-surface client, mirroring the PGlite/Electric adapter pattern, so it
- * adds no hard dependency. `@tauri-apps/plugin-sql` is an optional peer.
- *
- * Contract (same as every GraphPersistenceAdapter):
- *   - `get(key)`    -> stored string or null
- *   - `set(key, v)` -> upsert (INSERT ... ON CONFLICT)
- *   - `remove(key)` -> delete (no-op if absent)
- *
- * Tauri SQL uses SQLite `?`-positional bind params (not `$1`).
- */
-
-/**
- * Minimal surface of a `@tauri-apps/plugin-sql` `Database` handle.
- * Avoids a hard dep; matches the loaded-Database shape (`execute` + `select`).
- */
-interface TauriSqlClient {
-    execute(query: string, bindValues?: unknown[]): Promise<unknown>;
-    select<T = Record<string, unknown>>(query: string, bindValues?: unknown[]): Promise<T[]>;
-}
-interface CreateTauriSqlPersistenceAdapterOptions {
-    /** Name of the snapshot table. Defaults to `_graph_snapshot`. */
-    tableName?: string;
-}
-/**
- * Returns a {@link GraphPersistenceAdapter} backed by a Tauri SQLite `Database`.
- *
- * @example
- * ```ts
- * import Database from "@tauri-apps/plugin-sql";
- * import { startLocalFirstGraph, createTauriSqlPersistenceAdapter } from "@prometheus-ags/prometheus-entity-management";
- *
- * const db = await Database.load("sqlite:app.db");
- * const storage = await createTauriSqlPersistenceAdapter(db);
- * const runtime = startLocalFirstGraph({ storage, key: "app:graph" });
- * ```
- */
-declare function createTauriSqlPersistenceAdapter(db: TauriSqlClient, options?: CreateTauriSqlPersistenceAdapterOptions): Promise<GraphPersistenceAdapter>;
-
-/**
- * schema-from-sql.ts
- *
- * Generates a JSON Schema (and registers it via `registerEntityJsonSchema`)
- * directly from a Postgres `CREATE TABLE` statement. Lets a consumer keep
- * `latest-data/supabase/migrations/*.sql` as the single source of truth for
- * column shapes — no hand-maintained TypeScript schema duplicates.
- *
- * Deliberately regex-based: a real SQL parser is overkill for the slice of
- * DDL we care about, and would add a non-trivial runtime dep.
- *
- * Type mapping
- * ------------
- *   UUID, TEXT, VARCHAR(*)             -> { type: "string" }
- *   INTEGER, INT, BIGINT, SMALLINT     -> { type: "integer" }
- *   NUMERIC(*), DECIMAL(*)             -> { type: "number" }
- *   BOOLEAN, BOOL                      -> { type: "boolean" }
- *   TIMESTAMPTZ, TIMESTAMP             -> { type: "string", format: "date-time" }
- *   DATE                               -> { type: "string", format: "date" }
- *   JSONB, JSON                        -> { type: "object" }
- *   TEXT[]                             -> { type: "array", items: { type: "string" } }
- *   anything else                      -> { type: "string" } + "x-warning"
- *
- * `required` is populated from `NOT NULL` columns that lack a `DEFAULT`.
- * Callers can pass `overrides` to deep-merge a partial config (typically to
- * narrow a JSONB column to an array, or to add `enum`/`format` hints).
- */
-
-interface RegisterEntityFromSqlOptions {
-    entityType: string;
-    /** A single `CREATE TABLE` statement (extra DDL around it is ignored). */
-    createTableSql: string;
-    /** Optional deep-merge overrides (overrides win). */
-    overrides?: Partial<EntityJsonSchemaConfig>;
-}
-interface ParsedColumn {
-    name: string;
-    sqlType: string;
-    notNull: boolean;
-    hasDefault: boolean;
-}
-interface ParsedTable {
-    tableName: string;
-    columns: ParsedColumn[];
-}
-/**
- * Parse a `CREATE TABLE` block. Exposed for tests and for callers who need
- * the intermediate representation.
- */
-declare function parseCreateTable(sql: string): ParsedTable;
-/**
- * Map a normalized (uppercased, whitespace-stripped) SQL type to a JSON
- * schema fragment.
- *
- * Returns `{ schema, warning }` so the caller can surface "unmapped type"
- * notes via `x-warning` on the property.
- */
-declare function sqlTypeToJsonSchema(sqlType: string): {
-    schema: JsonSchemaObject;
-    warning?: string;
-};
-/**
- * Build (and register) an `EntityJsonSchemaConfig` from a CREATE TABLE
- * statement. Returns the registered config so callers can introspect it.
- */
-declare function registerEntityFromSql(opts: RegisterEntityFromSqlOptions): EntityJsonSchemaConfig;
-
-/**
- * table/types.ts
- *
- * 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;
-type HeaderContext<TData> = {
-    table: TableInstance<TData>;
-    header: Header<TData>;
-    column: Column<TData>;
-};
-type CellContext<TData> = {
-    table: TableInstance<TData>;
-    row: Row<TData>;
-    cell: Cell<TData>;
-    column: Column<TData>;
-    getValue: <T = unknown>() => T;
-    renderValue: <T = unknown>() => T | null;
-};
-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;
-interface ColumnMeta<TData = unknown> {
-    entityMeta?: {
-        field: keyof TData;
-        filterType: "text" | "number" | "date" | "dateRange" | "boolean" | "enum" | "relation" | "none";
-        enumOptions?: Array<{
-            label: string;
-            value: string;
-            color?: string;
-        }>;
-        relationEntityType?: string;
-        editable?: boolean;
-        hideable?: boolean;
-    };
-    [key: string]: unknown;
-}
-interface ColumnDef<TData, TValue = unknown> {
-    id?: string;
-    accessorKey?: keyof TData & string;
-    accessorFn?: AccessorFn<TData, TValue>;
-    header?: HeaderRenderer<TData>;
-    cell?: CellRenderer<TData>;
-    footer?: HeaderRenderer<TData>;
-    size?: number;
-    minSize?: number;
-    maxSize?: number;
-    enableSorting?: boolean;
-    enableFiltering?: boolean;
-    enableHiding?: boolean;
-    enablePinning?: boolean;
-    enableGrouping?: boolean;
-    enableResizing?: boolean;
-    filterFn?: FilterFn<TData> | "auto";
-    sortingFn?: SortingFn<TData> | "auto";
-    aggregationFn?: AggregationFn<TData> | "auto" | "sum" | "min" | "max" | "count" | "mean" | "median" | "unique";
-    sortDescFirst?: boolean;
-    sortUndefined?: "first" | "last" | false;
-    invertSorting?: boolean;
-    meta?: ColumnMeta<TData>;
-    columns?: ColumnDef<TData, unknown>[];
-}
-interface SortingColumn {
-    id: string;
-    desc: boolean;
-}
-type SortingState = SortingColumn[];
-interface ColumnFilter {
-    id: string;
-    value: unknown;
-}
-type ColumnFiltersState = ColumnFilter[];
-type RowSelectionState = Record<string, boolean>;
-type ColumnVisibilityState = Record<string, boolean>;
-type ColumnOrderState = string[];
-interface ColumnPinningState {
-    left?: string[];
-    right?: string[];
-}
-type ColumnSizingState = Record<string, number>;
-type ColumnSizingInfoState = {
-    startOffset: number | null;
-    startSize: number | null;
-    deltaOffset: number | null;
-    deltaPercentage: number | null;
-    isResizingColumn: string | false;
-    columnSizingStart: [string, number][];
-};
-type ExpandedState = Record<string, boolean> | true;
-type GroupingState = string[];
-interface PaginationState {
-    pageIndex: number;
-    pageSize: number;
-}
-interface TableState {
-    sorting: SortingState;
-    columnFilters: ColumnFiltersState;
-    globalFilter: unknown;
-    rowSelection: RowSelectionState;
-    columnVisibility: ColumnVisibilityState;
-    columnOrder: ColumnOrderState;
-    columnPinning: ColumnPinningState;
-    columnSizing: ColumnSizingState;
-    columnSizingInfo: ColumnSizingInfoState;
-    expanded: ExpandedState;
-    grouping: GroupingState;
-    pagination: PaginationState;
-}
-interface Row<TData> {
-    id: string;
-    index: number;
-    original: TData;
-    depth: number;
-    parentId?: string;
-    subRows: Row<TData>[];
-    getValue: <T = unknown>(columnId: string) => T;
-    renderValue: <T = unknown>(columnId: string) => T | null;
-    getIsSelected: () => boolean;
-    getCanSelect: () => boolean;
-    getIsAllSubRowsSelected: () => boolean;
-    getIsSomeSelected: () => boolean;
-    toggleSelected: (value?: boolean) => void;
-    getToggleSelectedHandler: () => (e: unknown) => void;
-    getIsExpanded: () => boolean;
-    getCanExpand: () => boolean;
-    toggleExpanded: (value?: boolean) => void;
-    getToggleExpandedHandler: () => () => void;
-    getIsGrouped: () => boolean;
-    groupingColumnId?: string;
-    groupingValue?: unknown;
-    getVisibleCells: () => Cell<TData>[];
-    getAllCells: () => Cell<TData>[];
-    getIsPinned: () => "top" | "bottom" | false;
-    pin: (position: "top" | "bottom" | false) => void;
-}
-interface Cell<TData> {
-    id: string;
-    row: Row<TData>;
-    column: Column<TData>;
-    getValue: <T = unknown>() => T;
-    renderValue: <T = unknown>() => T | null;
-    getIsGrouped: () => boolean;
-    getIsPlaceholder: () => boolean;
-    getIsAggregated: () => boolean;
-    getContext: () => CellContext<TData>;
-}
-interface Header<TData> {
-    id: string;
-    index: number;
-    depth: number;
-    column: Column<TData>;
-    isPlaceholder: boolean;
-    placeholderId?: string;
-    subHeaders: Header<TData>[];
-    colSpan: number;
-    rowSpan: number;
-    getSize: () => number;
-    getStart: () => number;
-    getContext: () => HeaderContext<TData>;
-    getResizeHandler: () => (event: unknown) => void;
-    getLeafHeaders: () => Header<TData>[];
-}
-interface HeaderGroup<TData> {
-    id: string;
-    depth: number;
-    headers: Header<TData>[];
-}
-interface Column<TData> {
-    id: string;
-    depth: number;
-    columnDef: ColumnDef<TData>;
-    columns: Column<TData>[];
-    parent?: Column<TData>;
-    getFlatColumns: () => Column<TData>[];
-    getLeafColumns: () => Column<TData>[];
-    getIsSorted: () => false | "asc" | "desc";
-    getNextSortingOrder: () => "asc" | "desc" | false;
-    getCanSort: () => boolean;
-    toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
-    clearSorting: () => void;
-    getSortIndex: () => number;
-    getAutoSortingFn: () => SortingFn<TData>;
-    getAutoSortDir: () => "asc" | "desc";
-    getIsFiltered: () => boolean;
-    getFilterValue: () => unknown;
-    setFilterValue: (value: unknown) => void;
-    getCanFilter: () => boolean;
-    getAutoFilterFn: () => FilterFn<TData> | undefined;
-    getIsVisible: () => boolean;
-    toggleVisibility: (value?: boolean) => void;
-    getCanHide: () => boolean;
-    getIsPinned: () => "left" | "right" | false;
-    pin: (position: "left" | "right" | false) => void;
-    getCanPin: () => boolean;
-    getIsGrouped: () => boolean;
-    toggleGrouping: () => void;
-    getCanGroup: () => boolean;
-    getGroupedIndex: () => number;
-    getSize: () => number;
-    getStart: (position?: "left" | "center" | "right") => number;
-    getCanResize: () => boolean;
-    resetSize: () => void;
-    getIndex: (position?: "left" | "center" | "right") => number;
-}
-interface RowModel<TData> {
-    rows: Row<TData>[];
-    flatRows: Row<TData>[];
-    rowsById: Record<string, Row<TData>>;
-}
-interface TableOptions<TData> {
-    data: TData[];
-    columns: ColumnDef<TData>[];
-    getRowId?: (row: TData, index: number, parent?: Row<TData>) => string;
-    defaultColumn?: Partial<ColumnDef<TData>>;
-    /** Seed the initial value for any internal state slice without making it controlled. */
-    initialState?: Partial<TableState>;
-    /** Fully controlled state — every key provided here locks that slice and must be updated externally. */
-    state?: Partial<TableState>;
-    onStateChange?: (updater: Updater<TableState>) => void;
-    manualSorting?: boolean;
-    enableSorting?: boolean;
-    enableMultiSort?: boolean;
-    enableSortingRemoval?: boolean;
-    enableMultiRemove?: boolean;
-    maxMultiSortColCount?: number;
-    sortDescFirst?: boolean;
-    onSortingChange?: (updater: Updater<SortingState>) => void;
-    manualFiltering?: boolean;
-    enableFiltering?: boolean;
-    enableColumnFilters?: boolean;
-    enableGlobalFilter?: boolean;
-    globalFilterFn?: FilterFn<TData>;
-    onColumnFiltersChange?: (updater: Updater<ColumnFiltersState>) => void;
-    onGlobalFilterChange?: (updater: Updater<unknown>) => void;
-    manualPagination?: boolean;
-    pageCount?: number;
-    autoResetPageIndex?: boolean;
-    onPaginationChange?: (updater: Updater<PaginationState>) => void;
-    enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
-    enableMultiRowSelection?: boolean | ((row: Row<TData>) => boolean);
-    enableSubRowSelection?: boolean | ((row: Row<TData>) => boolean);
-    onRowSelectionChange?: (updater: Updater<RowSelectionState>) => void;
-    enableHiding?: boolean;
-    onColumnVisibilityChange?: (updater: Updater<ColumnVisibilityState>) => void;
-    onColumnOrderChange?: (updater: Updater<ColumnOrderState>) => void;
-    enablePinning?: boolean;
-    onColumnPinningChange?: (updater: Updater<ColumnPinningState>) => void;
-    enableColumnResizing?: boolean;
-    columnResizeMode?: "onChange" | "onEnd";
-    columnResizeDirection?: "ltr" | "rtl";
-    onColumnSizingChange?: (updater: Updater<ColumnSizingState>) => void;
-    onColumnSizingInfoChange?: (updater: Updater<ColumnSizingInfoState>) => void;
-    manualGrouping?: boolean;
-    enableGrouping?: boolean;
-    onGroupingChange?: (updater: Updater<GroupingState>) => void;
-    manualExpanding?: boolean;
-    enableExpanding?: boolean;
-    getSubRows?: (row: TData, index: number) => TData[] | undefined;
-    getIsRowExpanded?: (row: Row<TData>) => boolean;
-    onExpandedChange?: (updater: Updater<ExpandedState>) => void;
-    paginateExpandedRows?: boolean;
-    enableRowPinning?: boolean | ((row: Row<TData>) => boolean);
-    keepPinnedRows?: boolean;
-    onRowPinningChange?: (updater: Updater<Record<string, "top" | "bottom">>) => void;
-}
-interface TableInstance<TData> {
-    options: TableOptions<TData>;
-    getState: () => TableState;
-    setState: (updater: Updater<TableState>) => void;
-    reset: () => void;
-    getAllColumns: () => Column<TData>[];
-    getAllFlatColumns: () => Column<TData>[];
-    getAllLeafColumns: () => Column<TData>[];
-    getColumn: (id: string) => Column<TData> | undefined;
-    getHeaderGroups: () => HeaderGroup<TData>[];
-    getLeftHeaderGroups: () => HeaderGroup<TData>[];
-    getCenterHeaderGroups: () => HeaderGroup<TData>[];
-    getRightHeaderGroups: () => HeaderGroup<TData>[];
-    getFooterGroups: () => HeaderGroup<TData>[];
-    getCoreRowModel: () => RowModel<TData>;
-    getRowModel: () => RowModel<TData>;
-    getPreFilteredRowModel: () => RowModel<TData>;
-    getFilteredRowModel: () => RowModel<TData>;
-    getPreSortedRowModel: () => RowModel<TData>;
-    getSortedRowModel: () => RowModel<TData>;
-    getGroupedRowModel: () => RowModel<TData>;
-    getExpandedRowModel: () => RowModel<TData>;
-    getPrePaginationRowModel: () => RowModel<TData>;
-    getPaginationRowModel: () => RowModel<TData>;
-    getSelectedRowModel: () => RowModel<TData>;
-    getRow: (id: string) => Row<TData>;
-    setSorting: (updater: Updater<SortingState>) => void;
-    resetSorting: (defaultState?: boolean) => void;
-    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
-    resetColumnFilters: (defaultState?: boolean) => void;
-    setGlobalFilter: (value: unknown) => void;
-    resetGlobalFilter: (defaultState?: boolean) => void;
-    setPageIndex: (updater: Updater<number>) => void;
-    resetPageIndex: (defaultState?: boolean) => void;
-    setPageSize: (updater: Updater<number>) => void;
-    resetPageSize: (defaultState?: boolean) => void;
-    getPageCount: () => number;
-    getCanPreviousPage: () => boolean;
-    getCanNextPage: () => boolean;
-    previousPage: () => void;
-    nextPage: () => void;
-    firstPage: () => void;
-    lastPage: () => void;
-    setRowSelection: (updater: Updater<RowSelectionState>) => void;
-    resetRowSelection: (defaultState?: boolean) => void;
-    toggleAllRowsSelected: (value?: boolean) => void;
-    toggleAllPageRowsSelected: (value?: boolean) => void;
-    getIsAllRowsSelected: () => boolean;
-    getIsAllPageRowsSelected: () => boolean;
-    getIsSomeRowsSelected: () => boolean;
-    getIsSomePageRowsSelected: () => boolean;
-    getToggleAllRowsSelectedHandler: () => (e: unknown) => void;
-    getToggleAllPageRowsSelectedHandler: () => (e: unknown) => void;
-    setColumnVisibility: (updater: Updater<ColumnVisibilityState>) => void;
-    resetColumnVisibility: (defaultState?: boolean) => void;
-    toggleAllColumnsVisible: (value?: boolean) => void;
-    getIsAllColumnsVisible: () => boolean;
-    getIsSomeColumnsVisible: () => boolean;
-    getToggleAllColumnsVisibilityHandler: () => (e: unknown) => void;
-    getVisibleFlatColumns: () => Column<TData>[];
-    getVisibleLeafColumns: () => Column<TData>[];
-    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
-    resetColumnOrder: (defaultState?: boolean) => void;
-    setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
-    resetColumnPinning: (defaultState?: boolean) => void;
-    getLeftFlatColumns: () => Column<TData>[];
-    getRightFlatColumns: () => Column<TData>[];
-    getCenterFlatColumns: () => Column<TData>[];
-    getLeftLeafColumns: () => Column<TData>[];
-    getRightLeafColumns: () => Column<TData>[];
-    getCenterLeafColumns: () => Column<TData>[];
-    setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
-    setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
-    resetColumnSizing: (defaultState?: boolean) => void;
-    setGrouping: (updater: Updater<GroupingState>) => void;
-    resetGrouping: (defaultState?: boolean) => void;
-    setExpanded: (updater: Updater<ExpandedState>) => void;
-    resetExpanded: (defaultState?: boolean) => void;
-    toggleAllRowsExpanded: (expanded?: boolean) => void;
-    getIsAllRowsExpanded: () => boolean;
-    getIsSomeRowsExpanded: () => boolean;
-    getCanSomeRowsExpand: () => boolean;
-    getExpandedDepth: () => number;
-}
-
-/**
- * table/row-models.ts
- *
- * Pure row model pipeline functions. Each stage transforms data
- * into a RowModel — no side effects, no external dependencies.
- */
-
-declare function createRow<TData>(original: TData, index: number, columns: Column<TData>[], table: TableInstance<TData>, depth?: number, parentId?: string, subRows?: Row<TData>[]): Row<TData>;
-declare function getCoreRowModel<TData>(data: TData[], columns: Column<TData>[], table: TableInstance<TData>): RowModel<TData>;
-declare function getFilteredRowModel<TData>(rowModel: RowModel<TData>, columnFilters: ColumnFiltersState, globalFilter: unknown, columns: Column<TData>[], globalFilterFn?: FilterFn<TData>): RowModel<TData>;
-declare function getSortedRowModel<TData>(rowModel: RowModel<TData>, sorting: SortingState, columns: Column<TData>[]): RowModel<TData>;
-declare function getGroupedRowModel<TData>(rowModel: RowModel<TData>, grouping: GroupingState, columns: Column<TData>[], table: TableInstance<TData>): RowModel<TData>;
-declare function getExpandedRowModel<TData>(rowModel: RowModel<TData>, expanded: ExpandedState): RowModel<TData>;
-declare function getPaginatedRowModel<TData>(rowModel: RowModel<TData>, pagination: PaginationState): RowModel<TData>;
-declare function getSelectedRowModel<TData>(rowModel: RowModel<TData>, selection: Record<string, boolean>): RowModel<TData>;
-
-/**
- * table/faceting.ts
- *
- * Column faceting utilities — compute unique values, counts,
- * and min/max for filter UI controls.
- */
-
-/**
- * Compute unique values and their counts for a given column.
- * Useful for rendering filter dropdown options with hit counts.
- */
-declare function getFacetedUniqueValues<TData>(rowModel: RowModel<TData>, columnId: string): Map<unknown, number>;
-/**
- * Compute min and max numeric values for a given column.
- * Returns [min, max] or undefined if no numeric values exist.
- */
-declare function getFacetedMinMaxValues<TData>(rowModel: RowModel<TData>, columnId: string): [number, number] | undefined;
-/**
- * Get a filtered row model scoped to a single column's facet.
- * Returns a row model that excludes the given column's own filter,
- * so the facet counts reflect what would be available if that
- * specific filter were removed.
- */
-declare function getFacetedRowModel<TData>(preFilteredRowModel: RowModel<TData>, columnId: string, allFilteredRowModel: RowModel<TData>): RowModel<TData>;
-
-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 CreateFlintAdapterOptions, type CreatePGlitePersistenceAdapterOptions, type CreateTauriSqlPersistenceAdapterOptions, type DevtoolsEvent, type DevtoolsEventBus, type DevtoolsEventBusOptions, type DevtoolsSourceFn, type ElectricAdapterOptions, type ElectricTableConfig, type EngineOptions, type EntityChange, EntityId, type EntityJsonSchemaConfig, type EntityQueryOptions, type EntitySchema, EntitySnapshot, EntitySyncMetadata, type EntityTransport, EntityType, type ExpandedState, type FilterFn, 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, 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 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, QueryKey, type RealtimeAdapter, RealtimeManager, type RegisterEntityFromSqlOptions, type RegisteredStore, type RelationDescriptor, type ReplayRetryPolicy, type Row, type RowModel, type RowSelectionState, type SchemaGraphToolContext, 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, SyncOrigin, type TableInstance, type TableOptions, type TableState, type TauriSqlClient, type TenantClaim, type TenantScopedAdapterOptions, type TenantScopedTableConfig, type TimeTravelSnapshot, type TimeTravelState, type UnsubscribeFn, type Updater, type ViewMode, type WebSocketAdapterOptions, __resetActiveGraphStore, __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, 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, hasMergeStrategy, humanizeFieldName, hydrateGraphFromStorage, inferSchemaFieldType, lwwStrategy, makeRestTransport, matchesFilter, matchesSearch, parseCreateTable, persistGraphToStorage, prepareGraphStoreScope, publishFlintMutation, queryOnce, readRelations, recordGraphSnapshot, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerMergeStrategy, registerRuntimeSchema, registerSchema, registerStore, registerSubscriber, registryKey, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, resolveActiveGraphStore, restoreGraphSnapshot, restoreGraphSnapshotBySeq, runWithGraphStore, selectGraph, serializeKey, setActiveGraphStore, setDefaultMergeStrategy, setValueAtPath, sqlTypeToJsonSchema, startGarbageCollector, startLocalFirstGraph, stepTimeTravel, stopGarbageCollector, subscribeDevtoolsEvent, subscribeSubscriberStats, subscribeTimeTravel, toPrismaOrderBy, toPrismaWhere, unregisterSubscriber, useGraphStore };