@prometheus-ags/entity-graph-core 3.0.4 → 3.1.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
+import { graphStore, useGraphStore, subscribeDevtoolsEvent, getGraphDevtoolsCompatibilityDelegate, subscribeGraphDevtoolsCompatibility, matchesFilter, matchesSearch, compareEntities, emitLegacyDevtoolsEvent, __require } from './chunk-BE3BMRKF.mjs';
+export { EMPTY_ENTITY_STATE, EMPTY_IDS, EMPTY_LIST_STATE, EMPTY_SYNC_METADATA, applyView, attachGlobalListeners, cascadeInvalidation, checkCompleteness, compareEntities, configureEngine, createGraphStore, dedupe, fetchEntity, fetchList, findInsertionIndex, getActiveSubscriberCount, getEngineOptions, getMergeStrategy, getSchema, graphStore, hasMergeStrategy, lwwStrategy, matchesFilter, matchesSearch, readRelations, registerMergeStrategy, registerSchema, registerSubscriber, serializeKey, setDefaultMergeStrategy, startGarbageCollector, stopGarbageCollector, subscribeDevtoolsEvent, subscribeSubscriberStats, unregisterSubscriber, useGraphStore } from './chunk-BE3BMRKF.mjs';
 import { createStore } from 'zustand/vanilla';
-import { subscribeWithSelector } from 'zustand/middleware';
-import { immer } from 'zustand/middleware/immer';
 
 // src/errors.ts
 var TerminalError = class _TerminalError extends Error {
@@ -68,6 +68,88 @@ function getRegisteredEntityTypes() {
   return Array.from(transports.keys());
 }
 
+// src/active-store.ts
+var moduleActiveStore = null;
+var asyncScope = null;
+var asyncScopeAttempted = false;
+function isNodeLike() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function resolveAsyncScope() {
+  if (asyncScopeAttempted) return asyncScope;
+  asyncScopeAttempted = true;
+  if (!isNodeLike()) return null;
+  try {
+    const req = typeof module !== "undefined" && typeof module.require === "function" ? module.require : typeof __require === "function" ? __require : null;
+    if (!req) return null;
+    const { AsyncLocalStorage } = req("node:async_hooks");
+    asyncScope = new AsyncLocalStorage();
+  } catch {
+    asyncScope = null;
+  }
+  return asyncScope;
+}
+async function prepareGraphStoreScope() {
+  if (asyncScope) return true;
+  if (!isNodeLike()) {
+    asyncScopeAttempted = true;
+    return false;
+  }
+  if (resolveAsyncScope()) return true;
+  try {
+    const specifier = "node:async_hooks";
+    const mod = await import(
+      /* @vite-ignore */
+      specifier
+    );
+    asyncScope = new mod.AsyncLocalStorage();
+    asyncScopeAttempted = true;
+    return true;
+  } catch {
+    asyncScopeAttempted = true;
+    return false;
+  }
+}
+function setActiveGraphStore(store) {
+  const previous = moduleActiveStore;
+  moduleActiveStore = store;
+  return () => {
+    moduleActiveStore = previous;
+  };
+}
+var warnedUnscopedFallback = false;
+function warnUnscopedRequestFallback() {
+  if (warnedUnscopedFallback || !isNodeLike()) return;
+  warnedUnscopedFallback = true;
+  console.warn(
+    "[entity-graph-core] runWithGraphStore() could not load node:async_hooks, so it fell back to a module-level store. Concurrent requests will NOT be isolated. Await prepareGraphStoreScope() once during server startup."
+  );
+}
+function runWithGraphStore(store, fn) {
+  const scope = resolveAsyncScope();
+  if (!scope) {
+    warnUnscopedRequestFallback();
+    const restore = setActiveGraphStore(store);
+    try {
+      return fn();
+    } finally {
+      restore();
+    }
+  }
+  return scope.run(store, fn);
+}
+function resolveActiveGraphStore(fallback) {
+  const scoped = resolveAsyncScope()?.getStore();
+  if (scoped) return scoped;
+  return moduleActiveStore ?? fallback;
+}
+function __resetActiveGraphStore() {
+  moduleActiveStore = null;
+  asyncScope = null;
+  asyncScopeAttempted = false;
+  warnedUnscopedFallback = false;
+}
+
 // src/view/prisma-compile.ts
 function nestWhereField(parts, leaf) {
   if (parts.length === 0) return {};
@@ -405,506 +487,6 @@ function mapPostgrestError(error, status) {
   return toEntityError(error);
 }
 
-// src/merge/lww.ts
-var lwwStrategy = (prev, next) => {
-  return prev ? { ...prev, ...next } : { ...next };
-};
-
-// src/merge/registry.ts
-var byType = /* @__PURE__ */ new Map();
-var globalDefault = null;
-function registerMergeStrategy(type, strategy) {
-  byType.set(type, strategy);
-}
-function setDefaultMergeStrategy(strategy) {
-  globalDefault = strategy;
-}
-function getMergeStrategy(type) {
-  return byType.get(type) ?? globalDefault ?? lwwStrategy;
-}
-function hasMergeStrategy(type) {
-  return byType.has(type) || globalDefault !== null;
-}
-
-// src/view/evaluator.ts
-function matchesFilter(entity, filter) {
-  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
-  return matchesGroup(entity, filter);
-}
-function matchesGroup(entity, group) {
-  const { logic, clauses } = group;
-  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-}
-function matchesClause(entity, clause) {
-  const { field, op, value, predicate } = clause;
-  const fv = getNestedValue(entity, field);
-  switch (op) {
-    case "eq":
-      return fv === value;
-    case "neq":
-      return fv !== value;
-    case "gt":
-      return fv > value;
-    case "gte":
-      return fv >= value;
-    case "lt":
-      return fv < value;
-    case "lte":
-      return fv <= value;
-    case "in":
-      return Array.isArray(value) && value.includes(fv);
-    case "nin":
-      return Array.isArray(value) && !value.includes(fv);
-    case "isNull":
-      return fv == null;
-    case "isNotNull":
-      return fv != null;
-    case "contains":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
-    case "startsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
-    case "endsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
-    case "between": {
-      const [lo, hi] = value;
-      return fv >= lo && fv <= hi;
-    }
-    case "arrayContains":
-      return Array.isArray(fv) && fv.includes(value);
-    case "arrayOverlaps":
-      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
-    case "matches":
-      return typeof fv === "string" && new RegExp(value).test(fv);
-    case "custom":
-      return predicate ? predicate(fv, entity) : true;
-    default:
-      return true;
-  }
-}
-function matchesSearch(entity, query, fields) {
-  if (!query.trim()) return true;
-  const lq = query.toLowerCase();
-  return fields.some((field) => {
-    const v = getNestedValue(entity, field);
-    return typeof v === "string" && v.toLowerCase().includes(lq);
-  });
-}
-function compareEntities(a, b, sort) {
-  for (const clause of sort) {
-    const r = compareByClause(a, b, clause);
-    if (r !== 0) return r;
-  }
-  return 0;
-}
-function compareByClause(a, b, clause) {
-  const { field, direction, nulls = "last", comparator } = clause;
-  const av = getNestedValue(a, field);
-  const bv = getNestedValue(b, field);
-  const aNull = av == null;
-  const bNull = bv == null;
-  if (aNull && bNull) return 0;
-  if (aNull) return nulls === "first" ? -1 : 1;
-  if (bNull) return nulls === "first" ? 1 : -1;
-  let cmp;
-  if (comparator) cmp = comparator(av, bv);
-  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
-  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
-  else cmp = String(av).localeCompare(String(bv));
-  return direction === "desc" ? -cmp : cmp;
-}
-function findInsertionIndex(entity, sortedIds, getEntity, sort) {
-  let lo = 0;
-  let hi = sortedIds.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    const me = getEntity(sortedIds[mid]);
-    if (!me) {
-      lo = mid + 1;
-      continue;
-    }
-    if (compareEntities(entity, me, sort) <= 0) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
-}
-function applyView(ids, getEntity, filter, sort, search) {
-  let entries = [];
-  for (const id of ids) {
-    const entity = getEntity(id);
-    if (!entity) continue;
-    entries.push({ id, entity });
-  }
-  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
-  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
-  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
-  return entries.map((e) => e.id);
-}
-function checkCompleteness(loadedCount, total, hasNextPage) {
-  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
-  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
-  return { isComplete: true, reason: "no-more-pages" };
-}
-function getNestedValue(obj, path) {
-  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-
-// src/graph.ts
-var EMPTY_IDS = [];
-var EMPTY_ENTITY_STATE = {
-  isFetching: false,
-  lastFetched: null,
-  error: null,
-  stale: false
-};
-var EMPTY_SYNC_METADATA = {
-  synced: true,
-  origin: "server",
-  updatedAt: null
-};
-var EMPTY_LIST_STATE = {
-  ids: EMPTY_IDS,
-  total: null,
-  nextCursor: null,
-  prevCursor: null,
-  hasNextPage: false,
-  hasPrevPage: false,
-  isFetching: false,
-  isFetchingMore: false,
-  error: null,
-  lastError: null,
-  lastFetched: null,
-  stale: false,
-  currentPage: null,
-  pageSize: null
-};
-function defaultEntityState() {
-  return { ...EMPTY_ENTITY_STATE };
-}
-function defaultSyncMetadata() {
-  return { ...EMPTY_SYNC_METADATA };
-}
-function defaultListState() {
-  return { ...EMPTY_LIST_STATE, ids: [] };
-}
-function ek(type, id) {
-  return `${type}:${id}`;
-}
-var snapshotCache = /* @__PURE__ */ new Map();
-function readCachedEntitySnapshot(type, id, base, patch, metadata) {
-  const key = ek(type, id);
-  const cached = snapshotCache.get(key);
-  if (cached && cached.base === base && cached.patch === patch && cached.metadata === metadata) {
-    return cached.snapshot;
-  }
-  const snapshot = {
-    ...patch ? { ...base, ...patch } : base,
-    $synced: metadata.synced,
-    $origin: metadata.origin,
-    $updatedAt: metadata.updatedAt
-  };
-  snapshotCache.set(key, { base, patch, metadata, snapshot });
-  return snapshot;
-}
-function createGraphStore() {
-  return createStore()(
-    subscribeWithSelector(
-      immer((set, get) => ({
-        entities: {},
-        patches: {},
-        entityStates: {},
-        syncMetadata: {},
-        lists: {},
-        upsertEntity: (type, id, data) => set((s) => {
-          if (!s.entities[type]) s.entities[type] = {};
-          const key = ek(type, id);
-          const strategy = getMergeStrategy(type);
-          const ctx = { type, id, origin: s.syncMetadata[key]?.origin ?? "server", updatedAt: Date.now() };
-          s.entities[type][id] = strategy(s.entities[type][id], data, ctx);
-          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-        }),
-        upsertEntities: (type, entries) => set((s) => {
-          if (!s.entities[type]) s.entities[type] = {};
-          const strategy = getMergeStrategy(type);
-          for (const { id, data } of entries) {
-            const key = ek(type, id);
-            const ctx = { type, id, origin: s.syncMetadata[key]?.origin ?? "server", updatedAt: Date.now() };
-            s.entities[type][id] = strategy(s.entities[type][id], data, ctx);
-            if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-          }
-        }),
-        ingestFetchedList: (type, entries, options = {}) => set((s) => {
-          const fetchedAt = Date.now();
-          const ids = entries.map(({ id }) => id);
-          const batches = [
-            { type, entries },
-            ...options.sideBatches ?? []
-          ];
-          const origins = /* @__PURE__ */ new Map();
-          for (const batch of batches) {
-            if (!s.entities[batch.type]) s.entities[batch.type] = {};
-            for (const { id } of batch.entries) {
-              const key = ek(batch.type, id);
-              if (!origins.has(key)) {
-                origins.set(key, s.syncMetadata[key]?.origin ?? "server");
-              }
-            }
-          }
-          for (const batch of batches) {
-            const strategy = getMergeStrategy(batch.type);
-            for (const { id, data } of batch.entries) {
-              const key = ek(batch.type, id);
-              const ctx = {
-                type: batch.type,
-                id,
-                origin: origins.get(key) ?? "server",
-                updatedAt: fetchedAt
-              };
-              s.entities[batch.type][id] = strategy(s.entities[batch.type][id], data, ctx);
-            }
-          }
-          const completed = /* @__PURE__ */ new Set();
-          for (const batch of batches) {
-            for (const { id } of batch.entries) {
-              const key = ek(batch.type, id);
-              if (completed.has(key)) continue;
-              completed.add(key);
-              if (!s.entityStates[key]) s.entityStates[key] = defaultEntityState();
-              s.entityStates[key].lastFetched = fetchedAt;
-              s.entityStates[key].isFetching = false;
-              s.entityStates[key].error = null;
-              s.entityStates[key].stale = false;
-              s.syncMetadata[key] = {
-                ...s.syncMetadata[key] ?? defaultSyncMetadata(),
-                synced: true,
-                origin: "server",
-                updatedAt: fetchedAt
-              };
-            }
-          }
-          const readDraftEntity = (id) => {
-            const base = s.entities[type]?.[id];
-            if (!base) return null;
-            const patch = s.patches[type]?.[id];
-            const metadata = s.syncMetadata[ek(type, id)] ?? defaultSyncMetadata();
-            return {
-              ...base,
-              ...patch ?? {},
-              $synced: metadata.synced,
-              $origin: metadata.origin,
-              $updatedAt: metadata.updatedAt
-            };
-          };
-          for (const target of options.lists ?? []) {
-            const existing = s.lists[target.key] ?? defaultListState();
-            const targetIds = target.ids ?? ids;
-            const nextIds = target.mode === "append" ? Array.from(/* @__PURE__ */ new Set([...existing.ids, ...targetIds])) : targetIds;
-            s.lists[target.key] = {
-              ...existing,
-              ...target.meta ?? {},
-              ids: nextIds,
-              isFetching: false,
-              isFetchingMore: false,
-              error: null,
-              lastError: null,
-              stale: false,
-              lastFetched: fetchedAt
-            };
-          }
-          for (const projection of options.projections ?? []) {
-            const existing = s.lists[projection.key] ?? defaultListState();
-            const nextIds = [...existing.ids];
-            const { filter, sort, search } = projection.view;
-            for (const id of new Set(ids)) {
-              if (nextIds.includes(id)) continue;
-              const entity = readDraftEntity(id);
-              if (!entity) continue;
-              const matches = (!filter || matchesFilter(entity, filter)) && (!search?.query || matchesSearch(entity, search.query, search.fields));
-              if (!matches) continue;
-              if (sort && sort.length > 0) {
-                const index = findInsertionIndex(entity, nextIds, readDraftEntity, sort);
-                nextIds.splice(index, 0, id);
-              } else {
-                nextIds.unshift(id);
-              }
-            }
-            s.lists[projection.key] = projection.completeFetch ? {
-              ...existing,
-              ids: nextIds,
-              isFetching: false,
-              isFetchingMore: false,
-              error: null,
-              lastError: null,
-              stale: false,
-              lastFetched: fetchedAt
-            } : { ...existing, ids: nextIds };
-          }
-          for (const key of options.finishListFetches ?? []) {
-            if (!s.lists[key]) s.lists[key] = defaultListState();
-            s.lists[key].isFetching = false;
-          }
-        }),
-        replaceEntity: (type, id, data) => set((s) => {
-          if (!s.entities[type]) s.entities[type] = {};
-          s.entities[type][id] = data;
-          const key = ek(type, id);
-          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-        }),
-        removeEntity: (type, id) => set((s) => {
-          delete s.entities[type]?.[id];
-          delete s.patches[type]?.[id];
-          delete s.entityStates[ek(type, id)];
-          delete s.syncMetadata[ek(type, id)];
-        }),
-        patchEntity: (type, id, patch) => set((s) => {
-          if (!s.patches[type]) s.patches[type] = {};
-          s.patches[type][id] = { ...s.patches[type][id] ?? {}, ...patch };
-        }),
-        unpatchEntity: (type, id, keys) => set((s) => {
-          const p = s.patches[type]?.[id];
-          if (!p) return;
-          for (const k of keys) delete p[k];
-        }),
-        clearPatch: (type, id) => set((s) => {
-          delete s.patches[type]?.[id];
-        }),
-        setEntityFetching: (type, id, fetching) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].isFetching = fetching;
-        }),
-        setEntityError: (type, id, error) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].error = error;
-          s.entityStates[k].isFetching = false;
-        }),
-        setEntityFetched: (type, id) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].lastFetched = Date.now();
-          s.entityStates[k].isFetching = false;
-          s.entityStates[k].error = null;
-          s.entityStates[k].stale = false;
-          s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), synced: true, origin: "server", updatedAt: Date.now() };
-        }),
-        setEntityStale: (type, id, stale) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].stale = stale;
-        }),
-        setEntitySyncMetadata: (type, id, metadata) => set((s) => {
-          const k = ek(type, id);
-          s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), ...metadata };
-        }),
-        clearEntitySyncMetadata: (type, id) => set((s) => {
-          delete s.syncMetadata[ek(type, id)];
-        }),
-        setListResult: (key, ids, meta) => set((s) => {
-          const ex = s.lists[key] ?? defaultListState();
-          s.lists[key] = { ...ex, ...meta, ids, isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
-        }),
-        appendListResult: (key, ids, meta) => set((s) => {
-          const ex = s.lists[key] ?? defaultListState();
-          s.lists[key] = { ...ex, ...meta, ids: Array.from(/* @__PURE__ */ new Set([...ex.ids, ...ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
-        }),
-        prependListResult: (key, ids, meta) => set((s) => {
-          const ex = s.lists[key] ?? defaultListState();
-          s.lists[key] = { ...ex, ...meta ?? {}, ids: Array.from(/* @__PURE__ */ new Set([...ids, ...ex.ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
-        }),
-        removeIdFromAllLists: (_type, id) => set((s) => {
-          for (const key of Object.keys(s.lists)) {
-            const list = s.lists[key];
-            const idx = list.ids.indexOf(id);
-            if (idx !== -1) {
-              list.ids.splice(idx, 1);
-              if (list.total !== null) list.total -= 1;
-            }
-          }
-        }),
-        insertIdInList: (key, id, position) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          const ids = s.lists[key].ids;
-          const ex = ids.indexOf(id);
-          if (ex !== -1) ids.splice(ex, 1);
-          if (position === "start") ids.unshift(id);
-          else if (position === "end") ids.push(id);
-          else ids.splice(position, 0, id);
-        }),
-        setListFetching: (key, fetching) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].isFetching = fetching;
-        }),
-        setListFetchingMore: (key, fetchingMore) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].isFetchingMore = fetchingMore;
-        }),
-        setListError: (key, error, typed) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].error = error;
-          s.lists[key].lastError = typed ?? (error === null ? null : s.lists[key].lastError);
-          s.lists[key].isFetching = false;
-          s.lists[key].isFetchingMore = false;
-          s.lists[key].lastFetched = Date.now();
-          s.lists[key].stale = false;
-        }),
-        setListStale: (key, stale) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].stale = stale;
-        }),
-        invalidateEntity: (type, id) => set((s) => {
-          if (id) {
-            const k = ek(type, id);
-            if (s.entityStates[k]) s.entityStates[k].stale = true;
-          } else {
-            for (const k of Object.keys(s.entityStates)) if (k.startsWith(`${type}:`)) s.entityStates[k].stale = true;
-          }
-        }),
-        invalidateLists: (matcher) => set((s) => {
-          const pred = typeof matcher === "string" ? (k) => k.startsWith(matcher) : matcher;
-          for (const key of Object.keys(s.lists)) if (pred(key)) s.lists[key].stale = true;
-        }),
-        invalidateType: (type) => {
-          get().invalidateEntity(type);
-          get().invalidateLists(type);
-        },
-        readEntity: (type, id) => {
-          const s = get();
-          const base = s.entities[type]?.[id];
-          if (!base) return null;
-          const patch = s.patches[type]?.[id];
-          return patch ? { ...base, ...patch } : base;
-        },
-        readEntitySnapshot: (type, id) => {
-          const s = get();
-          const base = s.entities[type]?.[id];
-          if (!base) {
-            snapshotCache.delete(ek(type, id));
-            return null;
-          }
-          const patch = s.patches[type]?.[id];
-          const metadata = s.syncMetadata[ek(type, id)] ?? EMPTY_SYNC_METADATA;
-          return readCachedEntitySnapshot(
-            type,
-            id,
-            base,
-            patch,
-            metadata
-          );
-        }
-      }))
-    )
-  );
-}
-var graphStore = createGraphStore();
-var useGraphStore = graphStore;
-
 // src/object-path.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -948,8 +530,9 @@ function collectDirtyPaths(current, original, prefix = "", acc = /* @__PURE__ */
 
 // src/merge/loro.ts
 var ROOT_MAP = "entity";
+var LORO_MODULE_SPECIFIER = "loro-crdt";
 var docs = /* @__PURE__ */ new Map();
-function ek2(type, id) {
+function ek(type, id) {
   return `${type}:${id}`;
 }
 async function createLoroMergeStrategy(loadLoro) {
@@ -957,7 +540,7 @@ async function createLoroMergeStrategy(loadLoro) {
   try {
     const loaded = loadLoro ? await loadLoro() : await import(
       /* @vite-ignore */
-      'loro-crdt'
+      LORO_MODULE_SPECIFIER
     );
     if (typeof loaded.LoroDoc !== "function") {
       throw new TypeError("loro-crdt did not export a LoroDoc constructor");
@@ -971,7 +554,7 @@ async function createLoroMergeStrategy(loadLoro) {
   }
   const { LoroDoc } = mod;
   return (prev, next, ctx) => {
-    const key = ek2(ctx.type, ctx.id);
+    const key = ek(ctx.type, ctx.id);
     let doc = docs.get(key);
     if (!doc) {
       doc = new LoroDoc();
@@ -1059,272 +642,6 @@ function applySelection(row, select) {
   return picked;
 }
 
-// src/engine.ts
-function serializeKey(key) {
-  return JSON.stringify(key, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort()) : v);
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var inflightByStore = /* @__PURE__ */ new WeakMap();
-function inflightFor(store) {
-  let inflight = inflightByStore.get(store);
-  if (!inflight) {
-    inflight = /* @__PURE__ */ new Map();
-    inflightByStore.set(store, inflight);
-  }
-  return inflight;
-}
-function dedupe(key, fn, store = graphStore) {
-  const inflight = inflightFor(store);
-  if (inflight.has(key)) return inflight.get(key);
-  const p = fn().finally(() => inflight.delete(key));
-  inflight.set(key, p);
-  return p;
-}
-var subscriberStatsListeners = /* @__PURE__ */ new Set();
-function emitSubscriberStatsChange() {
-  for (const cb of subscriberStatsListeners) cb();
-}
-var subscribersByStore = /* @__PURE__ */ new WeakMap();
-function subscribersFor(store) {
-  let subscribers = subscribersByStore.get(store);
-  if (!subscribers) {
-    subscribers = /* @__PURE__ */ new Map();
-    subscribersByStore.set(store, subscribers);
-  }
-  return subscribers;
-}
-function registerSubscriber(key, store = graphStore) {
-  const subscribers = subscribersFor(store);
-  const token = Symbol(key);
-  if (!subscribers.has(key)) subscribers.set(key, /* @__PURE__ */ new Set());
-  subscribers.get(key).add(token);
-  emitSubscriberStatsChange();
-  return token;
-}
-function unregisterSubscriber(key, token, store = graphStore) {
-  const subscribers = subscribersFor(store);
-  const set = subscribers.get(key);
-  if (!set) return;
-  set.delete(token);
-  if (set.size === 0) subscribers.delete(key);
-  emitSubscriberStatsChange();
-}
-function hasSubscribers(key, store = graphStore) {
-  return (subscribersFor(store).get(key)?.size ?? 0) > 0;
-}
-var DEFAULT_OPTIONS = {
-  defaultStaleTime: 3e4,
-  defaultGcTime: 3e5,
-  gcInterval: 6e4,
-  maxRetries: 3,
-  retryBaseDelay: 1e3,
-  revalidateOnFocus: true,
-  revalidateOnReconnect: true
-};
-var engineOptions = { ...DEFAULT_OPTIONS };
-function subscribeSubscriberStats(onChange) {
-  subscriberStatsListeners.add(onChange);
-  return () => subscriberStatsListeners.delete(onChange);
-}
-function getActiveSubscriberCount(store = graphStore) {
-  let n = 0;
-  for (const set of subscribersFor(store).values()) n += set.size;
-  return n;
-}
-var devtoolsSubscribers = /* @__PURE__ */ new Set();
-function subscribeDevtoolsEvent(cb) {
-  devtoolsSubscribers.add(cb);
-  return () => {
-    devtoolsSubscribers.delete(cb);
-  };
-}
-function notifyDevtools(event) {
-  if (devtoolsSubscribers.size === 0) return;
-  const listeners2 = [...devtoolsSubscribers];
-  for (const cb of listeners2) {
-    try {
-      cb(event);
-    } catch (err) {
-      console.warn("[engine] devtools subscriber threw:", err);
-    }
-  }
-}
-var gcIntervalsByStore = /* @__PURE__ */ new Map();
-function runGarbageCollection(storeApi = graphStore) {
-  const store = storeApi.getState();
-  const { defaultGcTime: gcTime } = getEngineOptions();
-  const now = Date.now();
-  const toRemove = [];
-  for (const type of Object.keys(store.entities)) {
-    const bucket = store.entities[type];
-    if (!bucket) continue;
-    for (const id of Object.keys(bucket)) {
-      const key = `${type}:${id}`;
-      if (hasSubscribers(key, storeApi)) continue;
-      const patch = store.patches[type]?.[id];
-      if (patch !== void 0 && Object.keys(patch).length > 0) continue;
-      const entityState = store.entityStates[key];
-      if (entityState?.isFetching) continue;
-      const lastFetched = entityState?.lastFetched;
-      if (lastFetched == null) continue;
-      if (now - lastFetched <= gcTime) continue;
-      toRemove.push({ type, id });
-    }
-  }
-  for (const { type, id } of toRemove) {
-    store.removeEntity(type, id);
-    store.removeIdFromAllLists(type, id);
-  }
-}
-function stopGarbageCollector(storeApi = graphStore) {
-  const intervalId = gcIntervalsByStore.get(storeApi);
-  if (intervalId != null && typeof clearInterval !== "undefined") {
-    clearInterval(intervalId);
-    gcIntervalsByStore.delete(storeApi);
-  }
-}
-function startGarbageCollector(storeApi = graphStore) {
-  stopGarbageCollector(storeApi);
-  if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
-  };
-  const intervalId = setInterval(
-    () => runGarbageCollection(storeApi),
-    getEngineOptions().gcInterval
-  );
-  gcIntervalsByStore.set(storeApi, intervalId);
-  return () => stopGarbageCollector(storeApi);
-}
-function restartGarbageCollector(storeApi = graphStore) {
-  startGarbageCollector(storeApi);
-}
-function configureEngine(opts) {
-  engineOptions = { ...DEFAULT_OPTIONS, ...opts };
-  const activeStores = [...gcIntervalsByStore.keys()];
-  if (activeStores.length === 0) restartGarbageCollector();
-  else for (const storeApi of activeStores) restartGarbageCollector(storeApi);
-}
-function getEngineOptions() {
-  return engineOptions;
-}
-async function fetchEntity(opts, engineOpts, storeApi = graphStore) {
-  const { type, id, fetch, normalize, sideEffects, idField = "id" } = opts;
-  if (!id) return;
-  storeApi.getState().setEntityFetching(type, id, true);
-  const attempt = async (retries) => {
-    try {
-      const raw = await fetch(id);
-      const normalized = normalize(raw);
-      const resolvedId = normalized[idField] ?? id;
-      storeApi.getState().upsertEntity(type, resolvedId, normalized);
-      storeApi.getState().setEntityFetched(type, resolvedId);
-      if (sideEffects) sideEffects(raw, storeApi);
-      opts.onSuccess?.(normalized);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      storeApi.getState().setEntityError(type, id, error.message);
-      opts.onError?.(error);
-    }
-  };
-  await dedupe(`${type}:${id}`, () => attempt(0), storeApi);
-}
-async function fetchList(opts, params, engineOpts, isLoadMore = false, storeApi = graphStore) {
-  const { type, queryKey, fetch, normalize, sideEffects, mode = "replace" } = opts;
-  const key = serializeKey(queryKey);
-  const store = storeApi.getState();
-  if (!fetch || !normalize) return;
-  if (isLoadMore) store.setListFetchingMore(key, true);
-  else store.setListFetching(key, true);
-  const attempt = async (retries) => {
-    try {
-      const response = await fetch(params);
-      const normalized = response.items.map(normalize);
-      const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
-      storeApi.getState().ingestFetchedList(
-        type,
-        normalized.map(({ id, data }) => ({ id, data })),
-        { lists: [{ key, mode: mode === "append" && isLoadMore ? "append" : "replace", meta }] }
-      );
-      if (sideEffects) sideEffects(response.items, storeApi);
-      opts.onSuccess?.(response);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      storeApi.getState().setListError(key, error.message);
-      opts.onError?.(error);
-    }
-  };
-  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0), storeApi);
-}
-var globalListenerAttachments = /* @__PURE__ */ new WeakMap();
-function releaseGlobalListenerAttachment(storeApi, attachment) {
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    const current = globalListenerAttachments.get(storeApi);
-    if (current !== attachment) return;
-    current.references -= 1;
-    if (current.references > 0) return;
-    current.dispose();
-    globalListenerAttachments.delete(storeApi);
-  };
-}
-function attachGlobalListeners(storeApi = graphStore) {
-  if (typeof window === "undefined") return () => {
-  };
-  const existing = globalListenerAttachments.get(storeApi);
-  if (existing) {
-    existing.references += 1;
-    return releaseGlobalListenerAttachment(storeApi, existing);
-  }
-  const stopGc = startGarbageCollector(storeApi);
-  const revalidateAll = () => {
-    const state = storeApi.getState();
-    for (const key of subscribersFor(storeApi).keys()) {
-      if (!hasSubscribers(key, storeApi)) continue;
-      const colonIdx = key.indexOf(":");
-      if (colonIdx === -1) continue;
-      const type = key.slice(0, colonIdx);
-      const id = key.slice(colonIdx + 1);
-      state.setEntityStale(type, id, true);
-    }
-  };
-  const revalidateWhenVisible = () => {
-    if (document.visibilityState === "visible") revalidateAll();
-  };
-  const revalidateOnFocus = engineOptions.revalidateOnFocus;
-  const revalidateOnReconnect = engineOptions.revalidateOnReconnect;
-  if (revalidateOnFocus) {
-    window.addEventListener("visibilitychange", revalidateWhenVisible);
-    window.addEventListener("focus", revalidateAll);
-  }
-  if (revalidateOnReconnect) window.addEventListener("online", revalidateAll);
-  const attachment = {
-    references: 1,
-    dispose: () => {
-      if (revalidateOnFocus) {
-        window.removeEventListener("visibilitychange", revalidateWhenVisible);
-        window.removeEventListener("focus", revalidateAll);
-      }
-      if (revalidateOnReconnect) {
-        window.removeEventListener("online", revalidateAll);
-      }
-      stopGc();
-    }
-  };
-  globalListenerAttachments.set(storeApi, attachment);
-  return releaseGlobalListenerAttachment(storeApi, attachment);
-}
-
 // src/graph-actions.ts
 var graphActionListeners = /* @__PURE__ */ new Set();
 var graphActionReplayers = /* @__PURE__ */ new Map();
@@ -1335,7 +652,7 @@ function createGraphTransaction(storeApi = graphStore) {
     upsertEntity(type, id, data) {
       storeApi.getState().upsertEntity(type, id, data);
       if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
-        notifyDevtools({ kind: "upsert", type, id, data, at: (/* @__PURE__ */ new Date()).toISOString() });
+        emitLegacyDevtoolsEvent({ kind: "upsert", type, id, data, at: (/* @__PURE__ */ new Date()).toISOString() });
       }
       return tx;
     },
@@ -1350,14 +667,14 @@ function createGraphTransaction(storeApi = graphStore) {
     patchEntity(type, id, patch) {
       storeApi.getState().patchEntity(type, id, patch);
       if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
-        notifyDevtools({ kind: "patch", type, id, patch, at: (/* @__PURE__ */ new Date()).toISOString() });
+        emitLegacyDevtoolsEvent({ kind: "patch", type, id, patch, at: (/* @__PURE__ */ new Date()).toISOString() });
       }
       return tx;
     },
     clearPatch(type, id) {
       storeApi.getState().clearPatch(type, id);
       if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
-        notifyDevtools({ kind: "clearPatch", type, id, at: (/* @__PURE__ */ new Date()).toISOString() });
+        emitLegacyDevtoolsEvent({ kind: "clearPatch", type, id, at: (/* @__PURE__ */ new Date()).toISOString() });
       }
       return tx;
     },
@@ -1840,7 +1157,7 @@ function computeDelay(policy, attempt) {
       return base / 2 + Math.random() * (base / 2);
   }
 }
-function sleep2(ms) {
+function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -1853,7 +1170,7 @@ async function replayActionWithRetry(action, policy, storeApi = graphStore) {
     } catch (error) {
       lastError = error;
       if (attempt >= policy.maxAttempts) break;
-      await sleep2(computeDelay(policy, attempt));
+      await sleep(computeDelay(policy, attempt));
     }
   }
   try {
@@ -1887,9 +1204,9 @@ function getDefaultOnlineSource() {
 
 // src/devtools-event-bus.ts
 var _busInjectMap = /* @__PURE__ */ new WeakMap();
-var registry = /* @__PURE__ */ new Map();
+var registries = /* @__PURE__ */ new Map();
 function __resetStoreRegistry() {
-  registry.clear();
+  registries.clear();
 }
 function createDevtoolsEventBus(opts) {
   const bufferSize = opts?.bufferSize ?? 500;
@@ -2004,8 +1321,10 @@ function createDevtoolsEventBus(opts) {
       pendingBurst = [];
       dispatchedCount = 0;
       flushScheduled = false;
-      for (const entry of registry.values()) {
-        if (entry.bus === bus && entry.active) {
+      const registry = registries.get(bus);
+      if (registry) {
+        for (const entry of registry.values()) {
+          if (!entry.active) continue;
           entry.active = false;
           try {
             entry.unsubscribeSrc();
@@ -2013,12 +1332,19 @@ function createDevtoolsEventBus(opts) {
           }
         }
       }
+      registries.delete(bus);
+      _busInjectMap.delete(bus);
     }
   };
   _busInjectMap.set(bus, handleEngineEvent);
   return bus;
 }
 function registerStore(bus, source, name) {
+  let registry = registries.get(bus);
+  if (!registry) {
+    registry = /* @__PURE__ */ new Map();
+    registries.set(bus, registry);
+  }
   if (registry.get(name)?.active === true) {
     throw new Error(
       `[devtools-store-registry] Store name "${name}" is already registered and active`
@@ -2039,75 +1365,38 @@ function registerStore(bus, source, name) {
     unsubscribeSrc();
   };
 }
-function getRegisteredStores() {
-  return Array.from(registry.values()).map((e) => ({ name: e.name, active: e.active }));
+function getRegisteredStores(bus) {
+  const entries = bus ? [...registries.get(bus)?.values() ?? []] : [...registries.values()].flatMap((registry) => [...registry.values()]);
+  return entries.map((entry) => ({ name: entry.name, active: entry.active }));
 }
 
 // src/devtools-time-travel.ts
-var capacity = 50;
-var ring = [];
-var seqCounter = 0;
-var cursor = null;
-var listeners = /* @__PURE__ */ new Set();
-function notify() {
-  for (const l of listeners) l();
-}
-function cloneSlice(s) {
-  return {
-    entities: structuredClone(s.entities),
-    patches: structuredClone(s.patches),
-    entityStates: structuredClone(s.entityStates),
-    syncMetadata: structuredClone(s.syncMetadata),
-    lists: structuredClone(s.lists)
-  };
-}
-function configureTimeTravel(opts) {
-  if (opts.capacity && opts.capacity > 0) capacity = opts.capacity;
-  if (ring.length > capacity) ring = ring.slice(-capacity);
-  notify();
+function configureTimeTravel(opts, storeApi = graphStore) {
+  if (opts.capacity && opts.capacity > 0) {
+    getGraphDevtoolsCompatibilityDelegate(storeApi)?.configure(opts.capacity);
+  }
 }
 function recordGraphSnapshot(label, storeApi = graphStore) {
-  const s = storeApi.getState();
-  const snap = {
-    seq: seqCounter++,
-    at: Date.now(),
-    ...label !== void 0 ? { label } : {},
-    data: cloneSlice(s)
-  };
-  ring.push(snap);
-  if (ring.length > capacity) ring = ring.slice(-capacity);
-  cursor = null;
-  notify();
-  return snap.seq;
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.capture(label) ?? -1;
 }
 function restoreGraphSnapshot(index, storeApi = graphStore) {
-  const snap = ring[index];
-  if (!snap) return false;
-  const clone2 = cloneSlice(snap.data);
-  storeApi.setState(clone2);
-  cursor = index;
-  notify();
-  return true;
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.restoreByIndex(index) ?? false;
 }
 function restoreGraphSnapshotBySeq(seq, storeApi = graphStore) {
-  const index = ring.findIndex((s) => s.seq === seq);
-  return index === -1 ? false : restoreGraphSnapshot(index, storeApi);
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.restoreByCursor(seq) ?? false;
 }
 function stepTimeTravel(delta, storeApi = graphStore) {
-  const base = cursor ?? ring.length - 1;
-  const target = Math.max(0, Math.min(ring.length - 1, base + delta));
-  return restoreGraphSnapshot(target, storeApi);
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.step(delta) ?? false;
 }
-function getTimeTravelState() {
-  return {
-    snapshots: ring.map(({ data: _data, ...meta }) => meta),
-    cursor,
-    capacity
+function getTimeTravelState(storeApi = graphStore) {
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.getState() ?? {
+    snapshots: [],
+    cursor: null,
+    capacity: 50
   };
 }
-function subscribeTimeTravel(cb) {
-  listeners.add(cb);
-  return () => listeners.delete(cb);
+function subscribeTimeTravel(cb, storeApi = graphStore) {
+  return subscribeGraphDevtoolsCompatibility(storeApi, cb);
 }
 
 // src/view/incremental.ts
@@ -2202,78 +1491,6 @@ var IncrementalView = class {
   }
 };
 
-// src/crud/relations.ts
-var schemaRegistry2 = /* @__PURE__ */ new Map();
-function registerSchema(schema) {
-  schemaRegistry2.set(schema.type, schema);
-}
-function getSchema(type) {
-  return schemaRegistry2.get(type) ?? null;
-}
-function cascadeInvalidation(ctx, storeApi = graphStore) {
-  const schema = schemaRegistry2.get(ctx.type);
-  if (!schema) return;
-  const store = storeApi.getState();
-  if (schema.globalListKeys) for (const key of schema.globalListKeys) store.invalidateLists(key);
-  if (!schema.relations) return;
-  for (const [, relation] of Object.entries(schema.relations)) {
-    switch (relation.cardinality) {
-      case "belongsTo": {
-        const prevFk = ctx.previous?.[relation.foreignKey];
-        const nextFk = ctx.next?.[relation.foreignKey];
-        if (prevFk && prevFk !== nextFk && relation.invalidateTargetLists) for (const kp of relation.invalidateTargetLists) store.invalidateLists((k) => k.startsWith(kp) && k.includes(prevFk));
-        if (nextFk && relation.invalidateTargetLists) for (const kp of relation.invalidateTargetLists) store.invalidateLists((k) => k.startsWith(kp) && k.includes(nextFk));
-        if (prevFk) store.invalidateEntity(relation.targetType, prevFk);
-        if (nextFk) store.invalidateEntity(relation.targetType, nextFk);
-        break;
-      }
-      case "hasMany":
-        store.invalidateLists(serializeKey(relation.listKeyPrefix(ctx.id)));
-        break;
-      case "manyToMany": {
-        const prevIds = ctx.previous?.[relation.localArrayField ?? ""];
-        const nextIds = ctx.next?.[relation.localArrayField ?? ""];
-        for (const relatedId of /* @__PURE__ */ new Set([...prevIds ?? [], ...nextIds ?? []])) store.invalidateLists(serializeKey(relation.listKeyPrefix(relatedId)));
-        break;
-      }
-    }
-  }
-  for (const [, otherSchema] of schemaRegistry2) {
-    if (!otherSchema.relations) continue;
-    for (const [, rel] of Object.entries(otherSchema.relations)) {
-      if (rel.targetType !== ctx.type) continue;
-      if (rel.cardinality === "hasMany") store.invalidateLists(serializeKey(rel.listKeyPrefix(ctx.id)));
-    }
-  }
-}
-function readRelations(type, entity, storeApi = graphStore) {
-  const schema = schemaRegistry2.get(type);
-  if (!schema?.relations) return {};
-  const store = storeApi.getState();
-  const result = {};
-  for (const [name, relation] of Object.entries(schema.relations)) {
-    switch (relation.cardinality) {
-      case "belongsTo": {
-        const fkValue = entity[relation.foreignKey];
-        result[name] = fkValue ? store.readEntity(relation.targetType, fkValue) : null;
-        break;
-      }
-      case "hasMany": {
-        const listKey = serializeKey(relation.listKeyPrefix(entity.id));
-        const listState = store.lists[listKey];
-        result[name] = listState ? listState.ids.map((id) => store.readEntity(relation.targetType, id)).filter(Boolean) : [];
-        break;
-      }
-      case "manyToMany": {
-        const ids = entity[relation.localArrayField ?? ""];
-        result[name] = ids ? ids.map((id) => store.readEntity(relation.targetType, id)).filter(Boolean) : [];
-        break;
-      }
-    }
-  }
-  return result;
-}
-
 // src/agent/json-patch.ts
 function unescape(token) {
   return token.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -2811,10 +2028,10 @@ function createGraphQLSubscriptionAdapter(opts) {
     subscribe(_cfg, handler) {
       const unsubs = [];
       for (const sub of subscriptions) {
-        const { type, document: document2, variables, getPayload } = sub;
+        const { type, document, variables, getPayload } = sub;
         unsubs.push(
           client.subscribe(
-            { query: document2, variables },
+            { query: document, variables },
             {
               next: ({ data }) => {
                 const raw = getPayload(data);
@@ -3946,6 +3163,6 @@ function getFacetedRowModel(preFilteredRowModel, columnId, allFilteredRowModel)
   return preFilteredRowModel;
 }
 
-export { EMPTY_ENTITY_STATE, EMPTY_IDS, EMPTY_LIST_STATE, EMPTY_SYNC_METADATA, IncrementalView, RealtimeManager, TerminalError, TransientError, __resetEntityTransports, __resetStoreRegistry, applyAgUiDelta, applyAgUiSnapshot, applyJsonPatch, applyView, attachGlobalListeners, buildTenantWhere, cascadeInvalidation, checkCompleteness, collectDirtyPaths, compareEntities, configureEngine, configureTimeTravel, createConvexAdapter, createDevtoolsEventBus, createElectricAdapter, createFlintAdapter, createGraphAction, createGraphEffect, createGraphQLSubscriptionAdapter, createGraphStore, createGraphTool, createGraphTransaction, createLoroMergeStrategy, createPGlitePersistenceAdapter, createRow, createSchemaGraphTool, createSupabaseRealtimeAdapter, createSurrealLiveAdapter, createTauriSqlPersistenceAdapter, createTenantScopedElectricAdapter, createWebSocketAdapter, dedupe, escapeHtml, exportGraphSnapshot, exportGraphSnapshotWithSchemas, fetchEntity, fetchList, findInsertionIndex, flattenClauses, getActiveSubscriberCount, getCoreRowModel, getRealtimeManager as getElectricRealtimeManager, getEngineOptions, getEntityJsonSchema, getEntityTransport, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGraphSyncStatus, getGroupedRowModel, getMergeStrategy, getPaginatedRowModel, getRealtimeManager, getRegisteredEntityTypes, getRegisteredStores, getSchema, getSelectedRowModel, getSortedRowModel, getTimeTravelState, getValueAtPath, graphStore, graphSyncStatusStore, hasCustomPredicates, hasMergeStrategy, humanizeFieldName, hydrateGraphFromStorage, inferSchemaFieldType, lwwStrategy, makeRestTransport, matchesFilter, matchesSearch, parseCreateTable, persistGraphToStorage, publishFlintMutation, queryOnce, readRelations, recordGraphSnapshot, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerMergeStrategy, registerRuntimeSchema, registerSchema, registerStore, registerSubscriber, registryKey, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, restoreGraphSnapshot, restoreGraphSnapshotBySeq, selectGraph, serializeKey, setDefaultMergeStrategy, setValueAtPath, sqlTypeToJsonSchema, startGarbageCollector, startLocalFirstGraph, stepTimeTravel, stopGarbageCollector, subscribeDevtoolsEvent, subscribeSubscriberStats, subscribeTimeTravel, toEntityError, toGraphQLVariables, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses, unregisterSubscriber, useGraphStore };
+export { IncrementalView, RealtimeManager, TerminalError, TransientError, __resetActiveGraphStore, __resetEntityTransports, __resetStoreRegistry, applyAgUiDelta, applyAgUiSnapshot, applyJsonPatch, buildTenantWhere, collectDirtyPaths, configureTimeTravel, createConvexAdapter, createDevtoolsEventBus, createElectricAdapter, createFlintAdapter, createGraphAction, createGraphEffect, createGraphQLSubscriptionAdapter, createGraphTool, createGraphTransaction, createLoroMergeStrategy, createPGlitePersistenceAdapter, createRow, createSchemaGraphTool, createSupabaseRealtimeAdapter, createSurrealLiveAdapter, createTauriSqlPersistenceAdapter, createTenantScopedElectricAdapter, createWebSocketAdapter, escapeHtml, exportGraphSnapshot, exportGraphSnapshotWithSchemas, flattenClauses, getCoreRowModel, getRealtimeManager as getElectricRealtimeManager, getEntityJsonSchema, getEntityTransport, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGraphSyncStatus, getGroupedRowModel, getPaginatedRowModel, getRealtimeManager, getRegisteredEntityTypes, getRegisteredStores, getSelectedRowModel, getSortedRowModel, getTimeTravelState, getValueAtPath, graphSyncStatusStore, hasCustomPredicates, humanizeFieldName, hydrateGraphFromStorage, inferSchemaFieldType, makeRestTransport, parseCreateTable, persistGraphToStorage, prepareGraphStoreScope, publishFlintMutation, queryOnce, recordGraphSnapshot, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerRuntimeSchema, registerStore, registryKey, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, resolveActiveGraphStore, restoreGraphSnapshot, restoreGraphSnapshotBySeq, runWithGraphStore, selectGraph, setActiveGraphStore, setValueAtPath, sqlTypeToJsonSchema, startLocalFirstGraph, stepTimeTravel, subscribeTimeTravel, toEntityError, toGraphQLVariables, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map