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

package/dist/{index.js → index.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var zustand = require('zustand');
+var vanilla = require('zustand/vanilla');
 var middleware = require('zustand/middleware');
 var immer = require('zustand/middleware/immer');
 
@@ -485,183 +485,187 @@ function readCachedEntitySnapshot(type, id, base, patch, metadata) {
   snapshotCache.set(key, { base, patch, metadata, snapshot });
   return snapshot;
 }
-var useGraphStore = zustand.create()(
-  middleware.subscribeWithSelector(
-    immer.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 vanilla.createStore()(
+    middleware.subscribeWithSelector(
+      immer.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) {
@@ -710,13 +714,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`.",
@@ -820,8 +828,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);
@@ -831,23 +848,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,
@@ -863,9 +890,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();
@@ -886,9 +913,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 = [];
@@ -897,7 +924,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];
@@ -913,41 +940,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));
@@ -955,16 +989,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);
@@ -972,13 +1006,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));
@@ -986,21 +1020,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);
@@ -1008,65 +1060,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()
@@ -1074,7 +1144,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()
@@ -1086,19 +1156,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();
@@ -1138,12 +1208,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),
@@ -1325,7 +1395,7 @@ function createSchemaGraphTool(handler) {
   });
 }
 var DEFAULT_STORAGE_KEY = "prometheus:graph";
-var useGraphSyncStatusStore = zustand.create((set) => ({
+var graphSyncStatusStore = vanilla.createStore()((set) => ({
   status: {
     phase: "idle",
     isOnline: true,
@@ -1344,19 +1414,20 @@ var useGraphSyncStatusStore = zustand.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
@@ -1369,6 +1440,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 {
@@ -1381,11 +1453,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,
@@ -1402,7 +1474,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
@@ -1417,9 +1489,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,
@@ -1431,16 +1504,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
     });
@@ -1448,27 +1521,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,
@@ -1484,18 +1557,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),
@@ -1533,11 +1606,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;
@@ -1597,9 +1670,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);
@@ -1675,9 +1748,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,
@@ -1689,7 +1762,7 @@ function createDevtoolsEventBus(opts) {
       if (destroyed) return;
       destroyed = true;
       unsubscribeEngine();
-      subscribers2.clear();
+      subscribers.clear();
       pendingBurst = [];
       dispatchedCount = 0;
       flushScheduled = false;
@@ -1755,8 +1828,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(),
@@ -1769,23 +1842,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 {
@@ -2028,10 +2101,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)) {
@@ -2064,10 +2137,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) {
@@ -2283,7 +2356,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 ?? (() => {
@@ -2343,7 +2418,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":
@@ -2392,6 +2467,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());
@@ -3784,6 +3866,7 @@ exports.createFlintAdapter = createFlintAdapter;
 exports.createGraphAction = createGraphAction;
 exports.createGraphEffect = createGraphEffect;
 exports.createGraphQLSubscriptionAdapter = createGraphQLSubscriptionAdapter;
+exports.createGraphStore = createGraphStore;
 exports.createGraphTool = createGraphTool;
 exports.createGraphTransaction = createGraphTransaction;
 exports.createLoroMergeStrategy = createLoroMergeStrategy;
@@ -3814,6 +3897,7 @@ exports.getFacetedMinMaxValues = getFacetedMinMaxValues;
 exports.getFacetedRowModel = getFacetedRowModel;
 exports.getFacetedUniqueValues = getFacetedUniqueValues;
 exports.getFilteredRowModel = getFilteredRowModel;
+exports.getGraphSyncStatus = getGraphSyncStatus;
 exports.getGroupedRowModel = getGroupedRowModel;
 exports.getMergeStrategy = getMergeStrategy;
 exports.getPaginatedRowModel = getPaginatedRowModel;
@@ -3825,6 +3909,8 @@ exports.getSelectedRowModel = getSelectedRowModel;
 exports.getSortedRowModel = getSortedRowModel;
 exports.getTimeTravelState = getTimeTravelState;
 exports.getValueAtPath = getValueAtPath;
+exports.graphStore = graphStore;
+exports.graphSyncStatusStore = graphSyncStatusStore;
 exports.hasCustomPredicates = hasCustomPredicates;
 exports.hasMergeStrategy = hasMergeStrategy;
 exports.humanizeFieldName = humanizeFieldName;
@@ -3874,6 +3960,5 @@ exports.toRestParams = toRestParams;
 exports.toSQLClauses = toSQLClauses;
 exports.unregisterSubscriber = unregisterSubscriber;
 exports.useGraphStore = useGraphStore;
-exports.useGraphSyncStatus = useGraphSyncStatus;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map