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

package/dist/index.cjs

@@ -4,6 +4,13 @@ var vanilla = require('zustand/vanilla');
 var middleware = require('zustand/middleware');
 var immer = require('zustand/middleware/immer');
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/errors.ts
 var TerminalError = class _TerminalError extends Error {
   kind = "terminal";
@@ -70,6 +77,88 @@ function getRegisteredEntityTypes() {
   return Array.from(transports.keys());
 }
 
+// src/active-store.ts
+var moduleActiveStore = null;
+var asyncScope = null;
+var asyncScopeAttempted = false;
+function isNodeLike() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function resolveAsyncScope() {
+  if (asyncScopeAttempted) return asyncScope;
+  asyncScopeAttempted = true;
+  if (!isNodeLike()) return null;
+  try {
+    const req = typeof module !== "undefined" && typeof module.require === "function" ? module.require : typeof __require === "function" ? __require : null;
+    if (!req) return null;
+    const { AsyncLocalStorage } = req("node:async_hooks");
+    asyncScope = new AsyncLocalStorage();
+  } catch {
+    asyncScope = null;
+  }
+  return asyncScope;
+}
+async function prepareGraphStoreScope() {
+  if (asyncScope) return true;
+  if (!isNodeLike()) {
+    asyncScopeAttempted = true;
+    return false;
+  }
+  if (resolveAsyncScope()) return true;
+  try {
+    const specifier = "node:async_hooks";
+    const mod = await import(
+      /* @vite-ignore */
+      specifier
+    );
+    asyncScope = new mod.AsyncLocalStorage();
+    asyncScopeAttempted = true;
+    return true;
+  } catch {
+    asyncScopeAttempted = true;
+    return false;
+  }
+}
+function setActiveGraphStore(store) {
+  const previous = moduleActiveStore;
+  moduleActiveStore = store;
+  return () => {
+    moduleActiveStore = previous;
+  };
+}
+var warnedUnscopedFallback = false;
+function warnUnscopedRequestFallback() {
+  if (warnedUnscopedFallback || !isNodeLike()) return;
+  warnedUnscopedFallback = true;
+  console.warn(
+    "[entity-graph-core] runWithGraphStore() could not load node:async_hooks, so it fell back to a module-level store. Concurrent requests will NOT be isolated. Await prepareGraphStoreScope() once during server startup."
+  );
+}
+function runWithGraphStore(store, fn) {
+  const scope = resolveAsyncScope();
+  if (!scope) {
+    warnUnscopedRequestFallback();
+    const restore = setActiveGraphStore(store);
+    try {
+      return fn();
+    } finally {
+      restore();
+    }
+  }
+  return scope.run(store, fn);
+}
+function resolveActiveGraphStore(fallback) {
+  const scoped = resolveAsyncScope()?.getStore();
+  if (scoped) return scoped;
+  return moduleActiveStore ?? fallback;
+}
+function __resetActiveGraphStore() {
+  moduleActiveStore = null;
+  asyncScope = null;
+  asyncScopeAttempted = false;
+  warnedUnscopedFallback = false;
+}
+
 // src/view/prisma-compile.ts
 function nestWhereField(parts, leaf) {
   if (parts.length === 0) return {};
@@ -950,6 +1039,7 @@ function collectDirtyPaths(current, original, prefix = "", acc = /* @__PURE__ */
 
 // src/merge/loro.ts
 var ROOT_MAP = "entity";
+var LORO_MODULE_SPECIFIER = "loro-crdt";
 var docs = /* @__PURE__ */ new Map();
 function ek2(type, id) {
   return `${type}:${id}`;
@@ -959,7 +1049,7 @@ async function createLoroMergeStrategy(loadLoro) {
   try {
     const loaded = loadLoro ? await loadLoro() : await import(
       /* @vite-ignore */
-      'loro-crdt'
+      LORO_MODULE_SPECIFIER
     );
     if (typeof loaded.LoroDoc !== "function") {
       throw new TypeError("loro-crdt did not export a LoroDoc constructor");
@@ -1061,405 +1151,159 @@ function applySelection(row, select) {
   return picked;
 }
 
-// src/engine.ts
-function serializeKey(key) {
-  return JSON.stringify(key, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort()) : v);
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var inflightByStore = /* @__PURE__ */ new WeakMap();
-function inflightFor(store) {
-  let inflight = inflightByStore.get(store);
-  if (!inflight) {
-    inflight = /* @__PURE__ */ new Map();
-    inflightByStore.set(store, inflight);
-  }
-  return inflight;
-}
-function dedupe(key, fn, store = graphStore) {
-  const inflight = inflightFor(store);
-  if (inflight.has(key)) return inflight.get(key);
-  const p = fn().finally(() => inflight.delete(key));
-  inflight.set(key, p);
-  return p;
-}
-var subscriberStatsListeners = /* @__PURE__ */ new Set();
-function emitSubscriberStatsChange() {
-  for (const cb of subscriberStatsListeners) cb();
-}
-var subscribersByStore = /* @__PURE__ */ new WeakMap();
-function subscribersFor(store) {
-  let subscribers = subscribersByStore.get(store);
-  if (!subscribers) {
-    subscribers = /* @__PURE__ */ new Map();
-    subscribersByStore.set(store, subscribers);
+// src/legacy-devtools.ts
+var listeners = /* @__PURE__ */ new Set();
+function publish(event) {
+  if (listeners.size === 0) return;
+  for (const listener of [...listeners]) {
+    try {
+      listener(event);
+    } catch {
+      console.warn("[engine] devtools subscriber threw");
+    }
   }
-  return subscribers;
-}
-function registerSubscriber(key, store = graphStore) {
-  const subscribers = subscribersFor(store);
-  const token = Symbol(key);
-  if (!subscribers.has(key)) subscribers.set(key, /* @__PURE__ */ new Set());
-  subscribers.get(key).add(token);
-  emitSubscriberStatsChange();
-  return token;
-}
-function unregisterSubscriber(key, token, store = graphStore) {
-  const subscribers = subscribersFor(store);
-  const set = subscribers.get(key);
-  if (!set) return;
-  set.delete(token);
-  if (set.size === 0) subscribers.delete(key);
-  emitSubscriberStatsChange();
-}
-function hasSubscribers(key, store = graphStore) {
-  return (subscribersFor(store).get(key)?.size ?? 0) > 0;
 }
-var DEFAULT_OPTIONS = {
-  defaultStaleTime: 3e4,
-  defaultGcTime: 3e5,
-  gcInterval: 6e4,
-  maxRetries: 3,
-  retryBaseDelay: 1e3,
-  revalidateOnFocus: true,
-  revalidateOnReconnect: true
-};
-var engineOptions = { ...DEFAULT_OPTIONS };
-function subscribeSubscriberStats(onChange) {
-  subscriberStatsListeners.add(onChange);
-  return () => subscriberStatsListeners.delete(onChange);
+function subscribeLegacyDevtoolsEvent(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
 }
-function getActiveSubscriberCount(store = graphStore) {
-  let n = 0;
-  for (const set of subscribersFor(store).values()) n += set.size;
-  return n;
+function emitLegacyDevtoolsEvent(event) {
+  publish(event);
 }
-var devtoolsSubscribers = /* @__PURE__ */ new Set();
-function subscribeDevtoolsEvent(cb) {
-  devtoolsSubscribers.add(cb);
-  return () => {
-    devtoolsSubscribers.delete(cb);
+
+// src/graph-actions.ts
+var graphActionListeners = /* @__PURE__ */ new Set();
+var graphActionReplayers = /* @__PURE__ */ new Map();
+function createGraphTransaction(storeApi = graphStore) {
+  const baseline = cloneGraphData(storeApi.getState());
+  let closed = false;
+  const tx = {
+    upsertEntity(type, id, data) {
+      storeApi.getState().upsertEntity(type, id, data);
+      if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
+        emitLegacyDevtoolsEvent({ kind: "upsert", type, id, data, at: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      return tx;
+    },
+    replaceEntity(type, id, data) {
+      storeApi.getState().replaceEntity(type, id, data);
+      return tx;
+    },
+    removeEntity(type, id) {
+      storeApi.getState().removeEntity(type, id);
+      return tx;
+    },
+    patchEntity(type, id, patch) {
+      storeApi.getState().patchEntity(type, id, patch);
+      if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
+        emitLegacyDevtoolsEvent({ kind: "patch", type, id, patch, at: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      return tx;
+    },
+    clearPatch(type, id) {
+      storeApi.getState().clearPatch(type, id);
+      if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
+        emitLegacyDevtoolsEvent({ kind: "clearPatch", type, id, at: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      return tx;
+    },
+    insertIdInList(key, id, position) {
+      storeApi.getState().insertIdInList(key, id, position);
+      return tx;
+    },
+    removeIdFromAllLists(type, id) {
+      storeApi.getState().removeIdFromAllLists(type, id);
+      return tx;
+    },
+    setEntitySyncMetadata(type, id, metadata) {
+      storeApi.getState().setEntitySyncMetadata(type, id, metadata);
+      return tx;
+    },
+    markEntityPending(type, id, origin = "optimistic") {
+      storeApi.getState().setEntitySyncMetadata(type, id, {
+        synced: false,
+        origin,
+        updatedAt: Date.now()
+      });
+      return tx;
+    },
+    markEntitySynced(type, id, origin = "server") {
+      storeApi.getState().setEntitySyncMetadata(type, id, {
+        synced: true,
+        origin,
+        updatedAt: Date.now()
+      });
+      return tx;
+    },
+    commit() {
+      closed = true;
+    },
+    rollback() {
+      if (closed) return;
+      storeApi.setState(cloneGraphData(baseline));
+      closed = true;
+    },
+    snapshot() {
+      return cloneGraphData(storeApi.getState());
+    }
   };
+  return tx;
 }
-function notifyDevtools(event) {
-  if (devtoolsSubscribers.size === 0) return;
-  const listeners2 = [...devtoolsSubscribers];
-  for (const cb of listeners2) {
+function createGraphAction(opts) {
+  if (opts.key) {
+    graphActionReplayers.set(opts.key, async (record, storeApi) => {
+      const tx = createGraphTransaction(storeApi);
+      try {
+        const result = await opts.run(tx, record.input);
+        tx.commit();
+        return result;
+      } catch (error) {
+        tx.rollback();
+        throw error;
+      }
+    });
+  }
+  return async (input) => {
+    const tx = createGraphTransaction();
+    const record = opts.key ? {
+      id: `${opts.key}:${Date.now()}`,
+      key: opts.key,
+      input: structuredClone(input),
+      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    } : null;
     try {
-      cb(event);
-    } catch (err) {
-      console.warn("[engine] devtools subscriber threw:", err);
+      if (record) emitGraphActionEvent({ type: "enqueued", record });
+      opts.optimistic?.(tx, input);
+      const result = await opts.run(tx, input);
+      opts.onSuccess?.(result, input, tx);
+      tx.commit();
+      if (record) emitGraphActionEvent({ type: "settled", record });
+      return result;
+    } catch (error) {
+      tx.rollback();
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      if (record) emitGraphActionEvent({ type: "settled", record });
+      opts.onError?.(normalized, input);
+      throw normalized;
     }
-  }
+  };
 }
-var gcIntervalsByStore = /* @__PURE__ */ new Map();
-function runGarbageCollection(storeApi = graphStore) {
-  const store = storeApi.getState();
-  const { defaultGcTime: gcTime } = getEngineOptions();
-  const now = Date.now();
-  const toRemove = [];
-  for (const type of Object.keys(store.entities)) {
-    const bucket = store.entities[type];
-    if (!bucket) continue;
-    for (const id of Object.keys(bucket)) {
-      const key = `${type}:${id}`;
-      if (hasSubscribers(key, storeApi)) continue;
-      const patch = store.patches[type]?.[id];
-      if (patch !== void 0 && Object.keys(patch).length > 0) continue;
-      const entityState = store.entityStates[key];
-      if (entityState?.isFetching) continue;
-      const lastFetched = entityState?.lastFetched;
-      if (lastFetched == null) continue;
-      if (now - lastFetched <= gcTime) continue;
-      toRemove.push({ type, id });
-    }
-  }
-  for (const { type, id } of toRemove) {
-    store.removeEntity(type, id);
-    store.removeIdFromAllLists(type, id);
-  }
+function subscribeGraphActionEvents(listener) {
+  graphActionListeners.add(listener);
+  return () => graphActionListeners.delete(listener);
 }
-function stopGarbageCollector(storeApi = graphStore) {
-  const intervalId = gcIntervalsByStore.get(storeApi);
-  if (intervalId != null && typeof clearInterval !== "undefined") {
-    clearInterval(intervalId);
-    gcIntervalsByStore.delete(storeApi);
-  }
+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, storeApi);
 }
-function startGarbageCollector(storeApi = graphStore) {
-  stopGarbageCollector(storeApi);
-  if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
-  };
-  const intervalId = setInterval(
-    () => runGarbageCollection(storeApi),
-    getEngineOptions().gcInterval
-  );
-  gcIntervalsByStore.set(storeApi, intervalId);
-  return () => stopGarbageCollector(storeApi);
-}
-function restartGarbageCollector(storeApi = graphStore) {
-  startGarbageCollector(storeApi);
-}
-function configureEngine(opts) {
-  engineOptions = { ...DEFAULT_OPTIONS, ...opts };
-  const activeStores = [...gcIntervalsByStore.keys()];
-  if (activeStores.length === 0) restartGarbageCollector();
-  else for (const storeApi of activeStores) restartGarbageCollector(storeApi);
-}
-function getEngineOptions() {
-  return engineOptions;
-}
-async function fetchEntity(opts, engineOpts, storeApi = graphStore) {
-  const { type, id, fetch, normalize, sideEffects, idField = "id" } = opts;
-  if (!id) return;
-  storeApi.getState().setEntityFetching(type, id, true);
-  const attempt = async (retries) => {
-    try {
-      const raw = await fetch(id);
-      const normalized = normalize(raw);
-      const resolvedId = normalized[idField] ?? id;
-      storeApi.getState().upsertEntity(type, resolvedId, normalized);
-      storeApi.getState().setEntityFetched(type, resolvedId);
-      if (sideEffects) sideEffects(raw, storeApi);
-      opts.onSuccess?.(normalized);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      storeApi.getState().setEntityError(type, id, error.message);
-      opts.onError?.(error);
-    }
-  };
-  await dedupe(`${type}:${id}`, () => attempt(0), storeApi);
-}
-async function fetchList(opts, params, engineOpts, isLoadMore = false, storeApi = graphStore) {
-  const { type, queryKey, fetch, normalize, sideEffects, mode = "replace" } = opts;
-  const key = serializeKey(queryKey);
-  const store = storeApi.getState();
-  if (!fetch || !normalize) return;
-  if (isLoadMore) store.setListFetchingMore(key, true);
-  else store.setListFetching(key, true);
-  const attempt = async (retries) => {
-    try {
-      const response = await fetch(params);
-      const normalized = response.items.map(normalize);
-      const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
-      storeApi.getState().ingestFetchedList(
-        type,
-        normalized.map(({ id, data }) => ({ id, data })),
-        { lists: [{ key, mode: mode === "append" && isLoadMore ? "append" : "replace", meta }] }
-      );
-      if (sideEffects) sideEffects(response.items, storeApi);
-      opts.onSuccess?.(response);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      storeApi.getState().setListError(key, error.message);
-      opts.onError?.(error);
-    }
-  };
-  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0), storeApi);
-}
-var globalListenerAttachments = /* @__PURE__ */ new WeakMap();
-function releaseGlobalListenerAttachment(storeApi, attachment) {
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    const current = globalListenerAttachments.get(storeApi);
-    if (current !== attachment) return;
-    current.references -= 1;
-    if (current.references > 0) return;
-    current.dispose();
-    globalListenerAttachments.delete(storeApi);
-  };
-}
-function attachGlobalListeners(storeApi = graphStore) {
-  if (typeof window === "undefined") return () => {
-  };
-  const existing = globalListenerAttachments.get(storeApi);
-  if (existing) {
-    existing.references += 1;
-    return releaseGlobalListenerAttachment(storeApi, existing);
-  }
-  const stopGc = startGarbageCollector(storeApi);
-  const revalidateAll = () => {
-    const state = storeApi.getState();
-    for (const key of subscribersFor(storeApi).keys()) {
-      if (!hasSubscribers(key, storeApi)) continue;
-      const colonIdx = key.indexOf(":");
-      if (colonIdx === -1) continue;
-      const type = key.slice(0, colonIdx);
-      const id = key.slice(colonIdx + 1);
-      state.setEntityStale(type, id, true);
-    }
-  };
-  const revalidateWhenVisible = () => {
-    if (document.visibilityState === "visible") revalidateAll();
-  };
-  const revalidateOnFocus = engineOptions.revalidateOnFocus;
-  const revalidateOnReconnect = engineOptions.revalidateOnReconnect;
-  if (revalidateOnFocus) {
-    window.addEventListener("visibilitychange", revalidateWhenVisible);
-    window.addEventListener("focus", revalidateAll);
-  }
-  if (revalidateOnReconnect) window.addEventListener("online", revalidateAll);
-  const attachment = {
-    references: 1,
-    dispose: () => {
-      if (revalidateOnFocus) {
-        window.removeEventListener("visibilitychange", revalidateWhenVisible);
-        window.removeEventListener("focus", revalidateAll);
-      }
-      if (revalidateOnReconnect) {
-        window.removeEventListener("online", revalidateAll);
-      }
-      stopGc();
-    }
-  };
-  globalListenerAttachments.set(storeApi, attachment);
-  return releaseGlobalListenerAttachment(storeApi, attachment);
-}
-
-// src/graph-actions.ts
-var graphActionListeners = /* @__PURE__ */ new Set();
-var graphActionReplayers = /* @__PURE__ */ new Map();
-function createGraphTransaction(storeApi = graphStore) {
-  const baseline = cloneGraphData(storeApi.getState());
-  let closed = false;
-  const tx = {
-    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) {
-      storeApi.getState().replaceEntity(type, id, data);
-      return tx;
-    },
-    removeEntity(type, id) {
-      storeApi.getState().removeEntity(type, id);
-      return tx;
-    },
-    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) {
-      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) {
-      storeApi.getState().insertIdInList(key, id, position);
-      return tx;
-    },
-    removeIdFromAllLists(type, id) {
-      storeApi.getState().removeIdFromAllLists(type, id);
-      return tx;
-    },
-    setEntitySyncMetadata(type, id, metadata) {
-      storeApi.getState().setEntitySyncMetadata(type, id, metadata);
-      return tx;
-    },
-    markEntityPending(type, id, origin = "optimistic") {
-      storeApi.getState().setEntitySyncMetadata(type, id, {
-        synced: false,
-        origin,
-        updatedAt: Date.now()
-      });
-      return tx;
-    },
-    markEntitySynced(type, id, origin = "server") {
-      storeApi.getState().setEntitySyncMetadata(type, id, {
-        synced: true,
-        origin,
-        updatedAt: Date.now()
-      });
-      return tx;
-    },
-    commit() {
-      closed = true;
-    },
-    rollback() {
-      if (closed) return;
-      storeApi.setState(cloneGraphData(baseline));
-      closed = true;
-    },
-    snapshot() {
-      return cloneGraphData(storeApi.getState());
-    }
-  };
-  return tx;
-}
-function createGraphAction(opts) {
-  if (opts.key) {
-    graphActionReplayers.set(opts.key, async (record, storeApi) => {
-      const tx = createGraphTransaction(storeApi);
-      try {
-        const result = await opts.run(tx, record.input);
-        tx.commit();
-        return result;
-      } catch (error) {
-        tx.rollback();
-        throw error;
-      }
-    });
-  }
-  return async (input) => {
-    const tx = createGraphTransaction();
-    const record = opts.key ? {
-      id: `${opts.key}:${Date.now()}`,
-      key: opts.key,
-      input: structuredClone(input),
-      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString()
-    } : null;
-    try {
-      if (record) emitGraphActionEvent({ type: "enqueued", record });
-      opts.optimistic?.(tx, input);
-      const result = await opts.run(tx, input);
-      opts.onSuccess?.(result, input, tx);
-      tx.commit();
-      if (record) emitGraphActionEvent({ type: "settled", record });
-      return result;
-    } catch (error) {
-      tx.rollback();
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      if (record) emitGraphActionEvent({ type: "settled", record });
-      opts.onError?.(normalized, input);
-      throw normalized;
-    }
-  };
-}
-function subscribeGraphActionEvents(listener) {
-  graphActionListeners.add(listener);
-  return () => graphActionListeners.delete(listener);
-}
-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, storeApi);
-}
-function cloneGraphData(source = graphStore.getState()) {
-  return {
-    entities: structuredClone(source.entities),
-    patches: structuredClone(source.patches),
-    entityStates: structuredClone(source.entityStates),
-    syncMetadata: structuredClone(source.syncMetadata),
-    lists: structuredClone(source.lists)
+function cloneGraphData(source = graphStore.getState()) {
+  return {
+    entities: structuredClone(source.entities),
+    patches: structuredClone(source.patches),
+    entityStates: structuredClone(source.entityStates),
+    syncMetadata: structuredClone(source.syncMetadata),
+    lists: structuredClone(source.lists)
   };
 }
 function emitGraphActionEvent(event) {
@@ -1842,7 +1686,7 @@ function computeDelay(policy, attempt) {
       return base / 2 + Math.random() * (base / 2);
   }
 }
-function sleep2(ms) {
+function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -1855,7 +1699,7 @@ async function replayActionWithRetry(action, policy, storeApi = graphStore) {
     } catch (error) {
       lastError = error;
       if (attempt >= policy.maxAttempts) break;
-      await sleep2(computeDelay(policy, attempt));
+      await sleep(computeDelay(policy, attempt));
     }
   }
   try {
@@ -1887,11 +1731,275 @@ function getDefaultOnlineSource() {
   };
 }
 
+// src/engine.ts
+function serializeKey(key) {
+  return JSON.stringify(key, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort()) : v);
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var inflightByStore = /* @__PURE__ */ new WeakMap();
+function inflightFor(store) {
+  let inflight = inflightByStore.get(store);
+  if (!inflight) {
+    inflight = /* @__PURE__ */ new Map();
+    inflightByStore.set(store, inflight);
+  }
+  return inflight;
+}
+function dedupe(key, fn, store = graphStore) {
+  const inflight = inflightFor(store);
+  if (inflight.has(key)) return inflight.get(key);
+  const p = fn().finally(() => inflight.delete(key));
+  inflight.set(key, p);
+  return p;
+}
+var globalSubscriberStatsListeners = /* @__PURE__ */ new Set();
+var subscriberStatsListenersByStore = /* @__PURE__ */ new WeakMap();
+function subscriberStatsListenersFor(store) {
+  let listeners2 = subscriberStatsListenersByStore.get(store);
+  if (!listeners2) {
+    listeners2 = /* @__PURE__ */ new Set();
+    subscriberStatsListenersByStore.set(store, listeners2);
+  }
+  return listeners2;
+}
+function emitSubscriberStatsChange(store) {
+  for (const cb of /* @__PURE__ */ new Set([
+    ...globalSubscriberStatsListeners,
+    ...subscriberStatsListenersFor(store)
+  ])) cb();
+}
+var subscribersByStore = /* @__PURE__ */ new WeakMap();
+function subscribersFor(store) {
+  let subscribers = subscribersByStore.get(store);
+  if (!subscribers) {
+    subscribers = /* @__PURE__ */ new Map();
+    subscribersByStore.set(store, subscribers);
+  }
+  return subscribers;
+}
+function registerSubscriber(key, store = graphStore) {
+  const subscribers = subscribersFor(store);
+  const token = Symbol(key);
+  if (!subscribers.has(key)) subscribers.set(key, /* @__PURE__ */ new Set());
+  subscribers.get(key).add(token);
+  emitSubscriberStatsChange(store);
+  return token;
+}
+function unregisterSubscriber(key, token, store = graphStore) {
+  const subscribers = subscribersFor(store);
+  const set = subscribers.get(key);
+  if (!set) return;
+  set.delete(token);
+  if (set.size === 0) subscribers.delete(key);
+  emitSubscriberStatsChange(store);
+}
+function hasSubscribers(key, store = graphStore) {
+  return (subscribersFor(store).get(key)?.size ?? 0) > 0;
+}
+var DEFAULT_OPTIONS = {
+  defaultStaleTime: 3e4,
+  defaultGcTime: 3e5,
+  gcInterval: 6e4,
+  maxRetries: 3,
+  retryBaseDelay: 1e3,
+  revalidateOnFocus: true,
+  revalidateOnReconnect: true
+};
+var engineOptions = { ...DEFAULT_OPTIONS };
+function subscribeSubscriberStats(onChange, store) {
+  const listeners2 = store ? subscriberStatsListenersFor(store) : globalSubscriberStatsListeners;
+  listeners2.add(onChange);
+  return () => listeners2.delete(onChange);
+}
+function getActiveSubscriberCount(store = graphStore) {
+  let n = 0;
+  for (const set of subscribersFor(store).values()) n += set.size;
+  return n;
+}
+function subscribeDevtoolsEvent(cb) {
+  return subscribeLegacyDevtoolsEvent(cb);
+}
+var gcIntervalsByStore = /* @__PURE__ */ new Map();
+function runGarbageCollection(storeApi = graphStore) {
+  const store = storeApi.getState();
+  const { defaultGcTime: gcTime } = getEngineOptions();
+  const now = Date.now();
+  const toRemove = [];
+  for (const type of Object.keys(store.entities)) {
+    const bucket = store.entities[type];
+    if (!bucket) continue;
+    for (const id of Object.keys(bucket)) {
+      const key = `${type}:${id}`;
+      if (hasSubscribers(key, storeApi)) continue;
+      const patch = store.patches[type]?.[id];
+      if (patch !== void 0 && Object.keys(patch).length > 0) continue;
+      const entityState = store.entityStates[key];
+      if (entityState?.isFetching) continue;
+      const lastFetched = entityState?.lastFetched;
+      if (lastFetched == null) continue;
+      if (now - lastFetched <= gcTime) continue;
+      toRemove.push({ type, id });
+    }
+  }
+  for (const { type, id } of toRemove) {
+    store.removeEntity(type, id);
+    store.removeIdFromAllLists(type, id);
+  }
+}
+function stopGarbageCollector(storeApi = graphStore) {
+  const intervalId = gcIntervalsByStore.get(storeApi);
+  if (intervalId != null && typeof clearInterval !== "undefined") {
+    clearInterval(intervalId);
+    gcIntervalsByStore.delete(storeApi);
+  }
+}
+function startGarbageCollector(storeApi = graphStore) {
+  stopGarbageCollector(storeApi);
+  if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
+  };
+  const intervalId = setInterval(
+    () => runGarbageCollection(storeApi),
+    getEngineOptions().gcInterval
+  );
+  gcIntervalsByStore.set(storeApi, intervalId);
+  return () => stopGarbageCollector(storeApi);
+}
+function restartGarbageCollector(storeApi = graphStore) {
+  startGarbageCollector(storeApi);
+}
+function configureEngine(opts) {
+  engineOptions = { ...DEFAULT_OPTIONS, ...opts };
+  const activeStores = [...gcIntervalsByStore.keys()];
+  if (activeStores.length === 0) restartGarbageCollector();
+  else for (const storeApi of activeStores) restartGarbageCollector(storeApi);
+}
+function getEngineOptions() {
+  return engineOptions;
+}
+async function fetchEntity(opts, engineOpts, storeApi = graphStore) {
+  const { type, id, fetch, normalize, sideEffects, idField = "id" } = opts;
+  if (!id) return;
+  storeApi.getState().setEntityFetching(type, id, true);
+  const attempt = async (retries) => {
+    try {
+      const raw = await fetch(id);
+      const normalized = normalize(raw);
+      const resolvedId = normalized[idField] ?? id;
+      storeApi.getState().upsertEntity(type, resolvedId, normalized);
+      storeApi.getState().setEntityFetched(type, resolvedId);
+      if (sideEffects) sideEffects(raw, storeApi);
+      opts.onSuccess?.(normalized);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (retries < engineOpts.maxRetries) {
+        await sleep2(engineOpts.retryBaseDelay * Math.pow(2, retries));
+        return attempt(retries + 1);
+      }
+      storeApi.getState().setEntityError(type, id, error.message);
+      opts.onError?.(error);
+    }
+  };
+  await dedupe(`${type}:${id}`, () => attempt(0), storeApi);
+}
+async function fetchList(opts, params, engineOpts, isLoadMore = false, storeApi = graphStore) {
+  const { type, queryKey, fetch, normalize, sideEffects, mode = "replace" } = opts;
+  const key = serializeKey(queryKey);
+  const store = storeApi.getState();
+  if (!fetch || !normalize) return;
+  if (isLoadMore) store.setListFetchingMore(key, true);
+  else store.setListFetching(key, true);
+  const attempt = async (retries) => {
+    try {
+      const response = await fetch(params);
+      const normalized = response.items.map(normalize);
+      const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
+      storeApi.getState().ingestFetchedList(
+        type,
+        normalized.map(({ id, data }) => ({ id, data })),
+        { lists: [{ key, mode: mode === "append" && isLoadMore ? "append" : "replace", meta }] }
+      );
+      if (sideEffects) sideEffects(response.items, storeApi);
+      opts.onSuccess?.(response);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (retries < engineOpts.maxRetries) {
+        await sleep2(engineOpts.retryBaseDelay * Math.pow(2, retries));
+        return attempt(retries + 1);
+      }
+      storeApi.getState().setListError(key, error.message);
+      opts.onError?.(error);
+    }
+  };
+  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0), storeApi);
+}
+var globalListenerAttachments = /* @__PURE__ */ new WeakMap();
+function releaseGlobalListenerAttachment(storeApi, attachment) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const current = globalListenerAttachments.get(storeApi);
+    if (current !== attachment) return;
+    current.references -= 1;
+    if (current.references > 0) return;
+    current.dispose();
+    globalListenerAttachments.delete(storeApi);
+  };
+}
+function attachGlobalListeners(storeApi = graphStore) {
+  if (typeof window === "undefined") return () => {
+  };
+  const existing = globalListenerAttachments.get(storeApi);
+  if (existing) {
+    existing.references += 1;
+    return releaseGlobalListenerAttachment(storeApi, existing);
+  }
+  const stopGc = startGarbageCollector(storeApi);
+  const revalidateAll = () => {
+    const state = storeApi.getState();
+    for (const key of subscribersFor(storeApi).keys()) {
+      if (!hasSubscribers(key, storeApi)) continue;
+      const colonIdx = key.indexOf(":");
+      if (colonIdx === -1) continue;
+      const type = key.slice(0, colonIdx);
+      const id = key.slice(colonIdx + 1);
+      state.setEntityStale(type, id, true);
+    }
+  };
+  const revalidateWhenVisible = () => {
+    if (document.visibilityState === "visible") revalidateAll();
+  };
+  const revalidateOnFocus = engineOptions.revalidateOnFocus;
+  const revalidateOnReconnect = engineOptions.revalidateOnReconnect;
+  if (revalidateOnFocus) {
+    window.addEventListener("visibilitychange", revalidateWhenVisible);
+    window.addEventListener("focus", revalidateAll);
+  }
+  if (revalidateOnReconnect) window.addEventListener("online", revalidateAll);
+  const attachment = {
+    references: 1,
+    dispose: () => {
+      if (revalidateOnFocus) {
+        window.removeEventListener("visibilitychange", revalidateWhenVisible);
+        window.removeEventListener("focus", revalidateAll);
+      }
+      if (revalidateOnReconnect) {
+        window.removeEventListener("online", revalidateAll);
+      }
+      stopGc();
+    }
+  };
+  globalListenerAttachments.set(storeApi, attachment);
+  return releaseGlobalListenerAttachment(storeApi, attachment);
+}
+
 // src/devtools-event-bus.ts
 var _busInjectMap = /* @__PURE__ */ new WeakMap();
-var registry = /* @__PURE__ */ new Map();
+var registries = /* @__PURE__ */ new Map();
 function __resetStoreRegistry() {
-  registry.clear();
+  registries.clear();
 }
 function createDevtoolsEventBus(opts) {
   const bufferSize = opts?.bufferSize ?? 500;
@@ -2006,8 +2114,10 @@ function createDevtoolsEventBus(opts) {
       pendingBurst = [];
       dispatchedCount = 0;
       flushScheduled = false;
-      for (const entry of registry.values()) {
-        if (entry.bus === bus && entry.active) {
+      const registry = registries.get(bus);
+      if (registry) {
+        for (const entry of registry.values()) {
+          if (!entry.active) continue;
           entry.active = false;
           try {
             entry.unsubscribeSrc();
@@ -2015,12 +2125,19 @@ function createDevtoolsEventBus(opts) {
           }
         }
       }
+      registries.delete(bus);
+      _busInjectMap.delete(bus);
     }
   };
   _busInjectMap.set(bus, handleEngineEvent);
   return bus;
 }
 function registerStore(bus, source, name) {
+  let registry = registries.get(bus);
+  if (!registry) {
+    registry = /* @__PURE__ */ new Map();
+    registries.set(bus, registry);
+  }
   if (registry.get(name)?.active === true) {
     throw new Error(
       `[devtools-store-registry] Store name "${name}" is already registered and active`
@@ -2041,75 +2158,77 @@ function registerStore(bus, source, name) {
     unsubscribeSrc();
   };
 }
-function getRegisteredStores() {
-  return Array.from(registry.values()).map((e) => ({ name: e.name, active: e.active }));
+function getRegisteredStores(bus) {
+  const entries = bus ? [...registries.get(bus)?.values() ?? []] : [...registries.values()].flatMap((registry) => [...registry.values()]);
+  return entries.map((entry) => ({ name: entry.name, active: entry.active }));
 }
 
-// src/devtools-time-travel.ts
-var capacity = 50;
-var ring = [];
-var seqCounter = 0;
-var cursor = null;
-var listeners = /* @__PURE__ */ new Set();
-function notify() {
-  for (const l of listeners) l();
+// src/devtools-compatibility-bridge.ts
+var BRIDGE_KEY = /* @__PURE__ */ Symbol.for("prometheus.entity-graph.devtools.compatibility.v1");
+var bridgeHost = globalThis;
+var existingBridge = bridgeHost[BRIDGE_KEY];
+var bridgeState = existingBridge?.version === 1 ? existingBridge : { version: 1, entries: /* @__PURE__ */ new WeakMap(), factory: null };
+bridgeHost[BRIDGE_KEY] = bridgeState;
+function getOrCreateEntry(store) {
+  let entry = bridgeState.entries.get(store);
+  if (!entry) {
+    entry = {
+      delegate: null,
+      listeners: /* @__PURE__ */ new Set(),
+      unsubscribeDelegate: null,
+      compatibilityDetach: null
+    };
+    bridgeState.entries.set(store, entry);
+  }
+  return entry;
 }
-function cloneSlice(s) {
-  return {
-    entities: structuredClone(s.entities),
-    patches: structuredClone(s.patches),
-    entityStates: structuredClone(s.entityStates),
-    syncMetadata: structuredClone(s.syncMetadata),
-    lists: structuredClone(s.lists)
+function ensureDelegate(store, entry) {
+  const factory = bridgeState.factory;
+  if (entry.delegate || entry.compatibilityDetach || !factory) return;
+  entry.compatibilityDetach = factory(store);
+}
+function getGraphDevtoolsCompatibilityDelegate(store) {
+  const entry = getOrCreateEntry(store);
+  ensureDelegate(store, entry);
+  return entry.delegate;
+}
+function subscribeGraphDevtoolsCompatibility(store, listener) {
+  const entry = getOrCreateEntry(store);
+  entry.listeners.add(listener);
+  ensureDelegate(store, entry);
+  return () => {
+    entry.listeners.delete(listener);
+    if (entry.listeners.size === 0 && entry.delegate === null) bridgeState.entries.delete(store);
   };
 }
-function configureTimeTravel(opts) {
-  if (opts.capacity && opts.capacity > 0) capacity = opts.capacity;
-  if (ring.length > capacity) ring = ring.slice(-capacity);
-  notify();
+
+// src/devtools-time-travel.ts
+function configureTimeTravel(opts, storeApi = graphStore) {
+  if (opts.capacity && opts.capacity > 0) {
+    getGraphDevtoolsCompatibilityDelegate(storeApi)?.configure(opts.capacity);
+  }
 }
 function recordGraphSnapshot(label, storeApi = graphStore) {
-  const s = storeApi.getState();
-  const snap = {
-    seq: seqCounter++,
-    at: Date.now(),
-    ...label !== void 0 ? { label } : {},
-    data: cloneSlice(s)
-  };
-  ring.push(snap);
-  if (ring.length > capacity) ring = ring.slice(-capacity);
-  cursor = null;
-  notify();
-  return snap.seq;
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.capture(label) ?? -1;
 }
 function restoreGraphSnapshot(index, storeApi = graphStore) {
-  const snap = ring[index];
-  if (!snap) return false;
-  const clone2 = cloneSlice(snap.data);
-  storeApi.setState(clone2);
-  cursor = index;
-  notify();
-  return true;
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.restoreByIndex(index) ?? false;
 }
 function restoreGraphSnapshotBySeq(seq, storeApi = graphStore) {
-  const index = ring.findIndex((s) => s.seq === seq);
-  return index === -1 ? false : restoreGraphSnapshot(index, storeApi);
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.restoreByCursor(seq) ?? false;
 }
 function stepTimeTravel(delta, storeApi = graphStore) {
-  const base = cursor ?? ring.length - 1;
-  const target = Math.max(0, Math.min(ring.length - 1, base + delta));
-  return restoreGraphSnapshot(target, storeApi);
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.step(delta) ?? false;
 }
-function getTimeTravelState() {
-  return {
-    snapshots: ring.map(({ data: _data, ...meta }) => meta),
-    cursor,
-    capacity
+function getTimeTravelState(storeApi = graphStore) {
+  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.getState() ?? {
+    snapshots: [],
+    cursor: null,
+    capacity: 50
   };
 }
-function subscribeTimeTravel(cb) {
-  listeners.add(cb);
-  return () => listeners.delete(cb);
+function subscribeTimeTravel(cb, storeApi = graphStore) {
+  return subscribeGraphDevtoolsCompatibility(storeApi, cb);
 }
 
 // src/view/incremental.ts
@@ -3956,6 +4075,7 @@ exports.IncrementalView = IncrementalView;
 exports.RealtimeManager = RealtimeManager;
 exports.TerminalError = TerminalError;
 exports.TransientError = TransientError;
+exports.__resetActiveGraphStore = __resetActiveGraphStore;
 exports.__resetEntityTransports = __resetEntityTransports;
 exports.__resetStoreRegistry = __resetStoreRegistry;
 exports.applyAgUiDelta = applyAgUiDelta;
@@ -4033,6 +4153,7 @@ exports.matchesFilter = matchesFilter;
 exports.matchesSearch = matchesSearch;
 exports.parseCreateTable = parseCreateTable;
 exports.persistGraphToStorage = persistGraphToStorage;
+exports.prepareGraphStoreScope = prepareGraphStoreScope;
 exports.publishFlintMutation = publishFlintMutation;
 exports.queryOnce = queryOnce;
 exports.readRelations = readRelations;
@@ -4049,10 +4170,13 @@ exports.registryKey = registryKey;
 exports.renderMarkdownToHtml = renderMarkdownToHtml;
 exports.replayActionWithRetry = replayActionWithRetry;
 exports.resetRealtimeManager = resetRealtimeManager;
+exports.resolveActiveGraphStore = resolveActiveGraphStore;
 exports.restoreGraphSnapshot = restoreGraphSnapshot;
 exports.restoreGraphSnapshotBySeq = restoreGraphSnapshotBySeq;
+exports.runWithGraphStore = runWithGraphStore;
 exports.selectGraph = selectGraph;
 exports.serializeKey = serializeKey;
+exports.setActiveGraphStore = setActiveGraphStore;
 exports.setDefaultMergeStrategy = setDefaultMergeStrategy;
 exports.setValueAtPath = setValueAtPath;
 exports.sqlTypeToJsonSchema = sqlTypeToJsonSchema;