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

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { create } from 'zustand';
+import { createStore } from 'zustand/vanilla';
 import { subscribeWithSelector } from 'zustand/middleware';
 import { immer } from 'zustand/middleware/immer';
 
@@ -483,183 +483,187 @@ function readCachedEntitySnapshot(type, id, base, patch, metadata) {
   snapshotCache.set(key, { base, patch, metadata, snapshot });
   return snapshot;
 }
-var useGraphStore = create()(
-  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) {
+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();
-        }
-      }),
-      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;
+        }),
+        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();
           }
-        }
-      }),
-      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) {
+        }),
+        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].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;
+          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
+          );
         }
-        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) {
@@ -708,13 +712,17 @@ var docs = /* @__PURE__ */ new Map();
 function ek2(type, id) {
   return `${type}:${id}`;
 }
-async function createLoroMergeStrategy() {
+async function createLoroMergeStrategy(loadLoro) {
   let mod;
   try {
-    mod = await import(
+    const loaded = loadLoro ? await loadLoro() : await import(
       /* @vite-ignore */
       'loro-crdt'
     );
+    if (typeof loaded.LoroDoc !== "function") {
+      throw new TypeError("loro-crdt did not export a LoroDoc constructor");
+    }
+    mod = loaded;
   } catch (cause) {
     throw new Error(
       "[merge/loro] createLoroMergeStrategy requires the optional peer dependency 'loro-crdt'. Install it with `pnpm add loro-crdt`.",
@@ -818,8 +826,17 @@ function serializeKey(key) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var inflight = /* @__PURE__ */ new Map();
-function dedupe(key, fn) {
+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);
@@ -829,23 +846,33 @@ var subscriberStatsListeners = /* @__PURE__ */ new Set();
 function emitSubscriberStatsChange() {
   for (const cb of subscriberStatsListeners) cb();
 }
-var subscribers = /* @__PURE__ */ new Map();
-function registerSubscriber(key) {
+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) {
+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) {
-  return (subscribers.get(key)?.size ?? 0) > 0;
+function hasSubscribers(key, store = graphStore) {
+  return (subscribersFor(store).get(key)?.size ?? 0) > 0;
 }
 var DEFAULT_OPTIONS = {
   defaultStaleTime: 3e4,
@@ -861,9 +888,9 @@ function subscribeSubscriberStats(onChange) {
   subscriberStatsListeners.add(onChange);
   return () => subscriberStatsListeners.delete(onChange);
 }
-function getActiveSubscriberCount() {
+function getActiveSubscriberCount(store = graphStore) {
   let n = 0;
-  for (const set of subscribers.values()) n += set.size;
+  for (const set of subscribersFor(store).values()) n += set.size;
   return n;
 }
 var devtoolsSubscribers = /* @__PURE__ */ new Set();
@@ -884,9 +911,9 @@ function notifyDevtools(event) {
     }
   }
 }
-var gcIntervalId = null;
-function runGarbageCollection() {
-  const store = useGraphStore.getState();
+var gcIntervalsByStore = /* @__PURE__ */ new Map();
+function runGarbageCollection(storeApi = graphStore) {
+  const store = storeApi.getState();
   const { defaultGcTime: gcTime } = getEngineOptions();
   const now = Date.now();
   const toRemove = [];
@@ -895,7 +922,7 @@ function runGarbageCollection() {
     if (!bucket) continue;
     for (const id of Object.keys(bucket)) {
       const key = `${type}:${id}`;
-      if (hasSubscribers(key)) continue;
+      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];
@@ -911,41 +938,48 @@ function runGarbageCollection() {
     store.removeIdFromAllLists(type, id);
   }
 }
-function stopGarbageCollector() {
-  if (gcIntervalId != null && typeof clearInterval !== "undefined") {
-    clearInterval(gcIntervalId);
-    gcIntervalId = null;
+function stopGarbageCollector(storeApi = graphStore) {
+  const intervalId = gcIntervalsByStore.get(storeApi);
+  if (intervalId != null && typeof clearInterval !== "undefined") {
+    clearInterval(intervalId);
+    gcIntervalsByStore.delete(storeApi);
   }
 }
-function startGarbageCollector() {
-  stopGarbageCollector();
+function startGarbageCollector(storeApi = graphStore) {
+  stopGarbageCollector(storeApi);
   if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
   };
-  gcIntervalId = setInterval(() => runGarbageCollection(), getEngineOptions().gcInterval);
-  return () => stopGarbageCollector();
+  const intervalId = setInterval(
+    () => runGarbageCollection(storeApi),
+    getEngineOptions().gcInterval
+  );
+  gcIntervalsByStore.set(storeApi, intervalId);
+  return () => stopGarbageCollector(storeApi);
 }
-function restartGarbageCollector() {
-  startGarbageCollector();
+function restartGarbageCollector(storeApi = graphStore) {
+  startGarbageCollector(storeApi);
 }
 function configureEngine(opts) {
   engineOptions = { ...DEFAULT_OPTIONS, ...opts };
-  restartGarbageCollector();
+  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) {
+async function fetchEntity(opts, engineOpts, storeApi = graphStore) {
   const { type, id, fetch, normalize, sideEffects, idField = "id" } = opts;
   if (!id) return;
-  useGraphStore.getState().setEntityFetching(type, id, true);
+  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;
-      useGraphStore.getState().upsertEntity(type, resolvedId, normalized);
-      useGraphStore.getState().setEntityFetched(type, resolvedId);
-      if (sideEffects) sideEffects(raw, useGraphStore);
+      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));
@@ -953,16 +987,16 @@ async function fetchEntity(opts, engineOpts) {
         await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
         return attempt(retries + 1);
       }
-      useGraphStore.getState().setEntityError(type, id, error.message);
+      storeApi.getState().setEntityError(type, id, error.message);
       opts.onError?.(error);
     }
   };
-  await dedupe(`${type}:${id}`, () => attempt(0));
+  await dedupe(`${type}:${id}`, () => attempt(0), storeApi);
 }
-async function fetchList(opts, params, engineOpts, isLoadMore = false) {
+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 = useGraphStore.getState();
+  const store = storeApi.getState();
   if (!fetch || !normalize) return;
   if (isLoadMore) store.setListFetchingMore(key, true);
   else store.setListFetching(key, true);
@@ -970,13 +1004,13 @@ async function fetchList(opts, params, engineOpts, isLoadMore = false) {
     try {
       const response = await fetch(params);
       const normalized = response.items.map(normalize);
-      useGraphStore.getState().upsertEntities(type, normalized.map(({ id, data }) => ({ id, data })));
-      for (const { id } of normalized) useGraphStore.getState().setEntityFetched(type, id);
+      storeApi.getState().upsertEntities(type, normalized.map(({ id, data }) => ({ id, data })));
+      for (const { id } of normalized) storeApi.getState().setEntityFetched(type, id);
       const ids = normalized.map(({ id }) => id);
       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 };
-      if (mode === "append" && isLoadMore) useGraphStore.getState().appendListResult(key, ids, meta);
-      else useGraphStore.getState().setListResult(key, ids, meta);
-      if (sideEffects) sideEffects(response.items, useGraphStore);
+      if (mode === "append" && isLoadMore) storeApi.getState().appendListResult(key, ids, meta);
+      else storeApi.getState().setListResult(key, ids, meta);
+      if (sideEffects) sideEffects(response.items, storeApi);
       opts.onSuccess?.(response);
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
@@ -984,21 +1018,39 @@ async function fetchList(opts, params, engineOpts, isLoadMore = false) {
         await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
         return attempt(retries + 1);
       }
-      useGraphStore.getState().setListError(key, error.message);
+      storeApi.getState().setListError(key, error.message);
       opts.onError?.(error);
     }
   };
-  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0));
+  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0), storeApi);
 }
-var focusListenerAttached = false;
-function attachGlobalListeners() {
-  if (typeof window === "undefined" || focusListenerAttached) return;
-  focusListenerAttached = true;
-  restartGarbageCollector();
+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 = useGraphStore.getState();
-    for (const key of subscribers.keys()) {
-      if (!hasSubscribers(key)) continue;
+    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);
@@ -1006,65 +1058,83 @@ function attachGlobalListeners() {
       state.setEntityStale(type, id, true);
     }
   };
-  if (engineOptions.revalidateOnFocus) {
-    window.addEventListener("visibilitychange", () => {
-      if (document.visibilityState === "visible") revalidateAll();
-    });
+  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 (engineOptions.revalidateOnReconnect) window.addEventListener("online", 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();
-function createGraphTransaction() {
-  const baseline = cloneGraphData();
+function createGraphTransaction(storeApi = graphStore) {
+  const baseline = cloneGraphData(storeApi.getState());
   let closed = false;
   const tx = {
     upsertEntity(type, id, data) {
-      useGraphStore.getState().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() });
       }
       return tx;
     },
     replaceEntity(type, id, data) {
-      useGraphStore.getState().replaceEntity(type, id, data);
+      storeApi.getState().replaceEntity(type, id, data);
       return tx;
     },
     removeEntity(type, id) {
-      useGraphStore.getState().removeEntity(type, id);
+      storeApi.getState().removeEntity(type, id);
       return tx;
     },
     patchEntity(type, id, patch) {
-      useGraphStore.getState().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() });
       }
       return tx;
     },
     clearPatch(type, id) {
-      useGraphStore.getState().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() });
       }
       return tx;
     },
     insertIdInList(key, id, position) {
-      useGraphStore.getState().insertIdInList(key, id, position);
+      storeApi.getState().insertIdInList(key, id, position);
       return tx;
     },
     removeIdFromAllLists(type, id) {
-      useGraphStore.getState().removeIdFromAllLists(type, id);
+      storeApi.getState().removeIdFromAllLists(type, id);
       return tx;
     },
     setEntitySyncMetadata(type, id, metadata) {
-      useGraphStore.getState().setEntitySyncMetadata(type, id, metadata);
+      storeApi.getState().setEntitySyncMetadata(type, id, metadata);
       return tx;
     },
     markEntityPending(type, id, origin = "optimistic") {
-      useGraphStore.getState().setEntitySyncMetadata(type, id, {
+      storeApi.getState().setEntitySyncMetadata(type, id, {
         synced: false,
         origin,
         updatedAt: Date.now()
@@ -1072,7 +1142,7 @@ function createGraphTransaction() {
       return tx;
     },
     markEntitySynced(type, id, origin = "server") {
-      useGraphStore.getState().setEntitySyncMetadata(type, id, {
+      storeApi.getState().setEntitySyncMetadata(type, id, {
         synced: true,
         origin,
         updatedAt: Date.now()
@@ -1084,19 +1154,19 @@ function createGraphTransaction() {
     },
     rollback() {
       if (closed) return;
-      useGraphStore.setState(cloneGraphData(baseline));
+      storeApi.setState(cloneGraphData(baseline));
       closed = true;
     },
     snapshot() {
-      return cloneGraphData();
+      return cloneGraphData(storeApi.getState());
     }
   };
   return tx;
 }
 function createGraphAction(opts) {
   if (opts.key) {
-    graphActionReplayers.set(opts.key, async (record) => {
-      const tx = createGraphTransaction();
+    graphActionReplayers.set(opts.key, async (record, storeApi) => {
+      const tx = createGraphTransaction(storeApi);
       try {
         const result = await opts.run(tx, record.input);
         tx.commit();
@@ -1136,12 +1206,12 @@ function subscribeGraphActionEvents(listener) {
   graphActionListeners.add(listener);
   return () => graphActionListeners.delete(listener);
 }
-async function replayRegisteredGraphAction(record) {
+async function replayRegisteredGraphAction(record, storeApi = graphStore) {
   const replayer = graphActionReplayers.get(record.key);
   if (!replayer) throw new Error(`No graph action registered for key "${record.key}"`);
-  return replayer(record);
+  return replayer(record, storeApi);
 }
-function cloneGraphData(source = useGraphStore.getState()) {
+function cloneGraphData(source = graphStore.getState()) {
   return {
     entities: structuredClone(source.entities),
     patches: structuredClone(source.patches),
@@ -1323,7 +1393,7 @@ function createSchemaGraphTool(handler) {
   });
 }
 var DEFAULT_STORAGE_KEY = "prometheus:graph";
-var useGraphSyncStatusStore = create((set) => ({
+var graphSyncStatusStore = createStore()((set) => ({
   status: {
     phase: "idle",
     isOnline: true,
@@ -1342,19 +1412,20 @@ var useGraphSyncStatusStore = create((set) => ({
   }))
 }));
 var pendingActions = /* @__PURE__ */ new Map();
-function useGraphSyncStatus() {
-  return useGraphSyncStatusStore((state) => state.status);
+function getGraphSyncStatus() {
+  return graphSyncStatusStore.getState().status;
 }
 async function persistGraphToStorage(opts) {
+  const storeApi = opts.store ?? graphStore;
   const payload = {
     version: 1,
-    snapshot: cloneGraphSnapshot(),
+    snapshot: cloneGraphSnapshot(storeApi),
     pendingActions: opts.pendingActions ?? Array.from(pendingActions.values())
   };
   const json = JSON.stringify(payload);
   await opts.storage.set(opts.key, json);
   const persistedAt = (/* @__PURE__ */ new Date()).toISOString();
-  useGraphSyncStatusStore.getState().setStatus({
+  graphSyncStatusStore.getState().setStatus({
     lastPersistedAt: persistedAt,
     storageKey: opts.key,
     pendingActions: payload.pendingActions.length
@@ -1367,6 +1438,7 @@ async function persistGraphToStorage(opts) {
   };
 }
 async function hydrateGraphFromStorage(opts) {
+  const storeApi = opts.store ?? graphStore;
   const raw = await opts.storage.get(opts.key);
   if (!raw) {
     return {
@@ -1379,11 +1451,11 @@ async function hydrateGraphFromStorage(opts) {
   }
   try {
     const parsed = JSON.parse(raw);
-    useGraphStore.setState(parsed.snapshot);
+    storeApi.setState(parsed.snapshot);
     pendingActions.clear();
     for (const action of parsed.pendingActions ?? []) pendingActions.set(action.id, action);
     const hydratedAt = (/* @__PURE__ */ new Date()).toISOString();
-    useGraphSyncStatusStore.getState().setStatus({
+    graphSyncStatusStore.getState().setStatus({
       lastHydratedAt: hydratedAt,
       storageKey: opts.key,
       pendingActions: pendingActions.size,
@@ -1400,7 +1472,7 @@ async function hydrateGraphFromStorage(opts) {
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    useGraphSyncStatusStore.getState().setStatus({
+    graphSyncStatusStore.getState().setStatus({
       phase: "error",
       error: message,
       storageKey: opts.key
@@ -1415,9 +1487,10 @@ async function hydrateGraphFromStorage(opts) {
   }
 }
 function startLocalFirstGraph(opts) {
+  const storeApi = opts.store ?? graphStore;
   const key = opts.key ?? DEFAULT_STORAGE_KEY;
   const persistDebounceMs = opts.persistDebounceMs ?? 50;
-  const statusStore = useGraphSyncStatusStore.getState();
+  const statusStore = graphSyncStatusStore.getState();
   statusStore.setStatus({
     phase: "hydrating",
     storageKey: key,
@@ -1429,16 +1502,16 @@ function startLocalFirstGraph(opts) {
   const schedulePersist = () => {
     if (persistTimer) clearTimeout(persistTimer);
     persistTimer = setTimeout(() => {
-      void persistGraphToStorage({ storage: opts.storage, key });
+      void persistGraphToStorage({ storage: opts.storage, key, store: storeApi });
     }, persistDebounceMs);
   };
-  const graphUnsub = useGraphStore.subscribe(() => {
+  const graphUnsub = storeApi.subscribe(() => {
     schedulePersist();
   });
   const actionUnsub = subscribeGraphActionEvents((event) => {
     if (event.type === "enqueued") pendingActions.set(event.record.id, event.record);
     if (event.type === "settled") pendingActions.delete(event.record.id);
-    useGraphSyncStatusStore.getState().setStatus({
+    graphSyncStatusStore.getState().setStatus({
       pendingActions: pendingActions.size,
       isSynced: pendingActions.size === 0
     });
@@ -1446,27 +1519,27 @@ function startLocalFirstGraph(opts) {
   });
   const onlineSource = opts.onlineSource ?? getDefaultOnlineSource();
   const onlineUnsub = onlineSource.subscribe((online) => {
-    useGraphSyncStatusStore.getState().setStatus({
+    graphSyncStatusStore.getState().setStatus({
       isOnline: online,
       phase: online ? "ready" : "offline"
     });
   });
   const ready = (async () => {
-    const hydrated = await hydrateGraphFromStorage({ storage: opts.storage, key });
+    const hydrated = await hydrateGraphFromStorage({ storage: opts.storage, key, store: storeApi });
     if (opts.replayPendingActions && hydrated.ok && pendingActions.size > 0) {
-      useGraphSyncStatusStore.getState().setStatus({
+      graphSyncStatusStore.getState().setStatus({
         phase: "syncing",
         isSynced: false
       });
       const policy = resolveRetryPolicy(opts.retryPolicy);
       for (const action of Array.from(pendingActions.values())) {
-        await replayActionWithRetry(action, policy);
+        await replayActionWithRetry(action, policy, storeApi);
         pendingActions.delete(action.id);
       }
-      await persistGraphToStorage({ storage: opts.storage, key });
+      await persistGraphToStorage({ storage: opts.storage, key, store: storeApi });
     }
     const online = onlineSource.getIsOnline();
-    useGraphSyncStatusStore.getState().setStatus({
+    graphSyncStatusStore.getState().setStatus({
       phase: online ? "ready" : "offline",
       isOnline: online,
       isSynced: pendingActions.size === 0,
@@ -1482,18 +1555,18 @@ function startLocalFirstGraph(opts) {
       if (persistTimer) clearTimeout(persistTimer);
     },
     async persistNow() {
-      await persistGraphToStorage({ storage: opts.storage, key });
+      await persistGraphToStorage({ storage: opts.storage, key, store: storeApi });
     },
     hydrate() {
-      return hydrateGraphFromStorage({ storage: opts.storage, key });
+      return hydrateGraphFromStorage({ storage: opts.storage, key, store: storeApi });
     },
     getStatus() {
-      return useGraphSyncStatusStore.getState().status;
+      return graphSyncStatusStore.getState().status;
     }
   };
 }
-function cloneGraphSnapshot() {
-  const state = useGraphStore.getState();
+function cloneGraphSnapshot(storeApi) {
+  const state = storeApi.getState();
   return {
     entities: structuredClone(state.entities),
     patches: structuredClone(state.patches),
@@ -1531,11 +1604,11 @@ function sleep2(ms) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((r) => setTimeout(r, ms));
 }
-async function replayActionWithRetry(action, policy) {
+async function replayActionWithRetry(action, policy, storeApi = graphStore) {
   let lastError = null;
   for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
     try {
-      await replayRegisteredGraphAction(action);
+      await replayRegisteredGraphAction(action, storeApi);
       return { ok: true };
     } catch (error) {
       lastError = error;
@@ -1595,9 +1668,9 @@ function createDevtoolsEventBus(opts) {
     if (count < bufferSize) return buffer.slice(0, count);
     return [...buffer.slice(head), ...buffer.slice(0, head)];
   }
-  const subscribers2 = /* @__PURE__ */ new Set();
+  const subscribers = /* @__PURE__ */ new Set();
   function dispatchToSubscribers(event) {
-    const snap = [...subscribers2];
+    const snap = [...subscribers];
     for (const cb of snap) {
       try {
         cb(event);
@@ -1673,9 +1746,9 @@ function createDevtoolsEventBus(opts) {
           console.warn("[devtools-event-bus] subscriber threw during replay:", err);
         }
       }
-      subscribers2.add(cb);
+      subscribers.add(cb);
       return () => {
-        subscribers2.delete(cb);
+        subscribers.delete(cb);
       };
     },
     getBuffer,
@@ -1687,7 +1760,7 @@ function createDevtoolsEventBus(opts) {
       if (destroyed) return;
       destroyed = true;
       unsubscribeEngine();
-      subscribers2.clear();
+      subscribers.clear();
       pendingBurst = [];
       dispatchedCount = 0;
       flushScheduled = false;
@@ -1753,8 +1826,8 @@ function configureTimeTravel(opts) {
   if (ring.length > capacity) ring = ring.slice(-capacity);
   notify();
 }
-function recordGraphSnapshot(label) {
-  const s = useGraphStore.getState();
+function recordGraphSnapshot(label, storeApi = graphStore) {
+  const s = storeApi.getState();
   const snap = {
     seq: seqCounter++,
     at: Date.now(),
@@ -1767,23 +1840,23 @@ function recordGraphSnapshot(label) {
   notify();
   return snap.seq;
 }
-function restoreGraphSnapshot(index) {
+function restoreGraphSnapshot(index, storeApi = graphStore) {
   const snap = ring[index];
   if (!snap) return false;
   const clone2 = cloneSlice(snap.data);
-  useGraphStore.setState(clone2);
+  storeApi.setState(clone2);
   cursor = index;
   notify();
   return true;
 }
-function restoreGraphSnapshotBySeq(seq) {
+function restoreGraphSnapshotBySeq(seq, storeApi = graphStore) {
   const index = ring.findIndex((s) => s.seq === seq);
-  return index === -1 ? false : restoreGraphSnapshot(index);
+  return index === -1 ? false : restoreGraphSnapshot(index, storeApi);
 }
-function stepTimeTravel(delta) {
+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);
+  return restoreGraphSnapshot(target, storeApi);
 }
 function getTimeTravelState() {
   return {
@@ -2026,10 +2099,10 @@ function registerSchema(schema) {
 function getSchema(type) {
   return schemaRegistry2.get(type) ?? null;
 }
-function cascadeInvalidation(ctx) {
+function cascadeInvalidation(ctx, storeApi = graphStore) {
   const schema = schemaRegistry2.get(ctx.type);
   if (!schema) return;
-  const store = useGraphStore.getState();
+  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)) {
@@ -2062,10 +2135,10 @@ function cascadeInvalidation(ctx) {
     }
   }
 }
-function readRelations(type, entity) {
+function readRelations(type, entity, storeApi = graphStore) {
   const schema = schemaRegistry2.get(type);
   if (!schema?.relations) return {};
-  const store = useGraphStore.getState();
+  const store = storeApi.getState();
   const result = {};
   for (const [name, relation] of Object.entries(schema.relations)) {
     switch (relation.cardinality) {
@@ -2281,7 +2354,9 @@ var RealtimeManager = class {
   pendingListKeys = /* @__PURE__ */ new Set();
   flushTimer = null;
   opts;
+  store;
   constructor(opts = {}) {
+    this.store = opts.store ?? graphStore;
     this.opts = {
       flushInterval: opts.flushInterval ?? 16,
       onStatusChange: opts.onStatusChange ?? (() => {
@@ -2341,7 +2416,7 @@ var RealtimeManager = class {
     const changes = this.pendingChanges.splice(0);
     const listKeys = new Set(this.pendingListKeys);
     this.pendingListKeys.clear();
-    const store = useGraphStore.getState();
+    const store = this.store.getState();
     for (const change of coalesceChanges(changes)) {
       switch (change.op) {
         case "insert":
@@ -2390,6 +2465,13 @@ function coalesceChanges(changes) {
       continue;
     }
     if (existing.op === "delete") continue;
+    if (existing.op === "update" && c.op === "update") {
+      byKey.set(key, {
+        ...existing,
+        patch: { ...existing.patch ?? {}, ...c.patch ?? {} }
+      });
+      continue;
+    }
     byKey.set(key, { ...existing, op: "upsert", data: c.data ?? existing.data, patch: c.patch ? { ...existing.patch ?? {}, ...c.patch } : existing.patch });
   }
   return Array.from(byKey.values());
@@ -3753,6 +3835,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, createGraphTool, createGraphTransaction, createLoroMergeStrategy, createPGlitePersistenceAdapter, createRow, createSchemaGraphTool, createSupabaseRealtimeAdapter, createSurrealLiveAdapter, createTauriSqlPersistenceAdapter, createTenantScopedElectricAdapter, createWebSocketAdapter, dedupe, escapeHtml, exportGraphSnapshot, exportGraphSnapshotWithSchemas, fetchEntity, fetchList, findInsertionIndex, flattenClauses, getActiveSubscriberCount, getCoreRowModel, getRealtimeManager as getElectricRealtimeManager, getEngineOptions, getEntityJsonSchema, getEntityTransport, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getMergeStrategy, getPaginatedRowModel, getRealtimeManager, getRegisteredEntityTypes, getRegisteredStores, getSchema, getSelectedRowModel, getSortedRowModel, getTimeTravelState, getValueAtPath, hasCustomPredicates, hasMergeStrategy, humanizeFieldName, hydrateGraphFromStorage, inferSchemaFieldType, lwwStrategy, makeRestTransport, matchesFilter, matchesSearch, parseCreateTable, persistGraphToStorage, publishFlintMutation, queryOnce, readRelations, recordGraphSnapshot, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerMergeStrategy, registerRuntimeSchema, registerSchema, registerStore, registerSubscriber, registryKey, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, restoreGraphSnapshot, restoreGraphSnapshotBySeq, selectGraph, serializeKey, setDefaultMergeStrategy, setValueAtPath, sqlTypeToJsonSchema, startGarbageCollector, startLocalFirstGraph, stepTimeTravel, stopGarbageCollector, subscribeDevtoolsEvent, subscribeSubscriberStats, subscribeTimeTravel, toEntityError, toGraphQLVariables, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses, unregisterSubscriber, useGraphStore, useGraphSyncStatus };
+export { 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 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map