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

package/dist/chunk-BE3BMRKF.mjs

@@ -0,0 +1,938 @@
+import { createStore } from 'zustand/vanilla';
+import { subscribeWithSelector } from 'zustand/middleware';
+import { immer } from '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/merge/lww.ts
+var lwwStrategy = (prev, next) => {
+  return prev ? { ...prev, ...next } : { ...next };
+};
+
+// src/merge/registry.ts
+var byType = /* @__PURE__ */ new Map();
+var globalDefault = null;
+function registerMergeStrategy(type, strategy) {
+  byType.set(type, strategy);
+}
+function setDefaultMergeStrategy(strategy) {
+  globalDefault = strategy;
+}
+function getMergeStrategy(type) {
+  return byType.get(type) ?? globalDefault ?? lwwStrategy;
+}
+function hasMergeStrategy(type) {
+  return byType.has(type) || globalDefault !== null;
+}
+
+// src/view/evaluator.ts
+function matchesFilter(entity, filter) {
+  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
+  return matchesGroup(entity, filter);
+}
+function matchesGroup(entity, group) {
+  const { logic, clauses } = group;
+  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
+  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
+}
+function matchesClause(entity, clause) {
+  const { field, op, value, predicate } = clause;
+  const fv = getNestedValue(entity, field);
+  switch (op) {
+    case "eq":
+      return fv === value;
+    case "neq":
+      return fv !== value;
+    case "gt":
+      return fv > value;
+    case "gte":
+      return fv >= value;
+    case "lt":
+      return fv < value;
+    case "lte":
+      return fv <= value;
+    case "in":
+      return Array.isArray(value) && value.includes(fv);
+    case "nin":
+      return Array.isArray(value) && !value.includes(fv);
+    case "isNull":
+      return fv == null;
+    case "isNotNull":
+      return fv != null;
+    case "contains":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
+    case "startsWith":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
+    case "endsWith":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
+    case "between": {
+      const [lo, hi] = value;
+      return fv >= lo && fv <= hi;
+    }
+    case "arrayContains":
+      return Array.isArray(fv) && fv.includes(value);
+    case "arrayOverlaps":
+      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
+    case "matches":
+      return typeof fv === "string" && new RegExp(value).test(fv);
+    case "custom":
+      return predicate ? predicate(fv, entity) : true;
+    default:
+      return true;
+  }
+}
+function matchesSearch(entity, query, fields) {
+  if (!query.trim()) return true;
+  const lq = query.toLowerCase();
+  return fields.some((field) => {
+    const v = getNestedValue(entity, field);
+    return typeof v === "string" && v.toLowerCase().includes(lq);
+  });
+}
+function compareEntities(a, b, sort) {
+  for (const clause of sort) {
+    const r = compareByClause(a, b, clause);
+    if (r !== 0) return r;
+  }
+  return 0;
+}
+function compareByClause(a, b, clause) {
+  const { field, direction, nulls = "last", comparator } = clause;
+  const av = getNestedValue(a, field);
+  const bv = getNestedValue(b, field);
+  const aNull = av == null;
+  const bNull = bv == null;
+  if (aNull && bNull) return 0;
+  if (aNull) return nulls === "first" ? -1 : 1;
+  if (bNull) return nulls === "first" ? 1 : -1;
+  let cmp;
+  if (comparator) cmp = comparator(av, bv);
+  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
+  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
+  else cmp = String(av).localeCompare(String(bv));
+  return direction === "desc" ? -cmp : cmp;
+}
+function findInsertionIndex(entity, sortedIds, getEntity, sort) {
+  let lo = 0;
+  let hi = sortedIds.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const me = getEntity(sortedIds[mid]);
+    if (!me) {
+      lo = mid + 1;
+      continue;
+    }
+    if (compareEntities(entity, me, sort) <= 0) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+}
+function applyView(ids, getEntity, filter, sort, search) {
+  let entries = [];
+  for (const id of ids) {
+    const entity = getEntity(id);
+    if (!entity) continue;
+    entries.push({ id, entity });
+  }
+  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
+  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
+  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
+  return entries.map((e) => e.id);
+}
+function checkCompleteness(loadedCount, total, hasNextPage) {
+  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
+  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
+  return { isComplete: true, reason: "no-more-pages" };
+}
+function getNestedValue(obj, path) {
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+var EMPTY_IDS = [];
+var EMPTY_ENTITY_STATE = {
+  isFetching: false,
+  lastFetched: null,
+  error: null,
+  stale: false
+};
+var EMPTY_SYNC_METADATA = {
+  synced: true,
+  origin: "server",
+  updatedAt: null
+};
+var EMPTY_LIST_STATE = {
+  ids: EMPTY_IDS,
+  total: null,
+  nextCursor: null,
+  prevCursor: null,
+  hasNextPage: false,
+  hasPrevPage: false,
+  isFetching: false,
+  isFetchingMore: false,
+  error: null,
+  lastError: null,
+  lastFetched: null,
+  stale: false,
+  currentPage: null,
+  pageSize: null
+};
+function defaultEntityState() {
+  return { ...EMPTY_ENTITY_STATE };
+}
+function defaultSyncMetadata() {
+  return { ...EMPTY_SYNC_METADATA };
+}
+function defaultListState() {
+  return { ...EMPTY_LIST_STATE, ids: [] };
+}
+function ek(type, id) {
+  return `${type}:${id}`;
+}
+var snapshotCache = /* @__PURE__ */ new Map();
+function readCachedEntitySnapshot(type, id, base, patch, metadata) {
+  const key = ek(type, id);
+  const cached = snapshotCache.get(key);
+  if (cached && cached.base === base && cached.patch === patch && cached.metadata === metadata) {
+    return cached.snapshot;
+  }
+  const snapshot = {
+    ...patch ? { ...base, ...patch } : base,
+    $synced: metadata.synced,
+    $origin: metadata.origin,
+    $updatedAt: metadata.updatedAt
+  };
+  snapshotCache.set(key, { base, patch, metadata, snapshot });
+  return snapshot;
+}
+function createGraphStore() {
+  return createStore()(
+    subscribeWithSelector(
+      immer((set, get) => ({
+        entities: {},
+        patches: {},
+        entityStates: {},
+        syncMetadata: {},
+        lists: {},
+        upsertEntity: (type, id, data) => set((s) => {
+          if (!s.entities[type]) s.entities[type] = {};
+          const key = ek(type, id);
+          const strategy = getMergeStrategy(type);
+          const ctx = { type, id, origin: s.syncMetadata[key]?.origin ?? "server", updatedAt: Date.now() };
+          s.entities[type][id] = strategy(s.entities[type][id], data, ctx);
+          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
+        }),
+        upsertEntities: (type, entries) => set((s) => {
+          if (!s.entities[type]) s.entities[type] = {};
+          const strategy = getMergeStrategy(type);
+          for (const { id, data } of entries) {
+            const key = ek(type, id);
+            const ctx = { type, id, origin: s.syncMetadata[key]?.origin ?? "server", updatedAt: Date.now() };
+            s.entities[type][id] = strategy(s.entities[type][id], data, ctx);
+            if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
+          }
+        }),
+        ingestFetchedList: (type, entries, options = {}) => set((s) => {
+          const fetchedAt = Date.now();
+          const ids = entries.map(({ id }) => id);
+          const batches = [
+            { type, entries },
+            ...options.sideBatches ?? []
+          ];
+          const origins = /* @__PURE__ */ new Map();
+          for (const batch of batches) {
+            if (!s.entities[batch.type]) s.entities[batch.type] = {};
+            for (const { id } of batch.entries) {
+              const key = ek(batch.type, id);
+              if (!origins.has(key)) {
+                origins.set(key, s.syncMetadata[key]?.origin ?? "server");
+              }
+            }
+          }
+          for (const batch of batches) {
+            const strategy = getMergeStrategy(batch.type);
+            for (const { id, data } of batch.entries) {
+              const key = ek(batch.type, id);
+              const ctx = {
+                type: batch.type,
+                id,
+                origin: origins.get(key) ?? "server",
+                updatedAt: fetchedAt
+              };
+              s.entities[batch.type][id] = strategy(s.entities[batch.type][id], data, ctx);
+            }
+          }
+          const completed = /* @__PURE__ */ new Set();
+          for (const batch of batches) {
+            for (const { id } of batch.entries) {
+              const key = ek(batch.type, id);
+              if (completed.has(key)) continue;
+              completed.add(key);
+              if (!s.entityStates[key]) s.entityStates[key] = defaultEntityState();
+              s.entityStates[key].lastFetched = fetchedAt;
+              s.entityStates[key].isFetching = false;
+              s.entityStates[key].error = null;
+              s.entityStates[key].stale = false;
+              s.syncMetadata[key] = {
+                ...s.syncMetadata[key] ?? defaultSyncMetadata(),
+                synced: true,
+                origin: "server",
+                updatedAt: fetchedAt
+              };
+            }
+          }
+          const readDraftEntity = (id) => {
+            const base = s.entities[type]?.[id];
+            if (!base) return null;
+            const patch = s.patches[type]?.[id];
+            const metadata = s.syncMetadata[ek(type, id)] ?? defaultSyncMetadata();
+            return {
+              ...base,
+              ...patch ?? {},
+              $synced: metadata.synced,
+              $origin: metadata.origin,
+              $updatedAt: metadata.updatedAt
+            };
+          };
+          for (const target of options.lists ?? []) {
+            const existing = s.lists[target.key] ?? defaultListState();
+            const targetIds = target.ids ?? ids;
+            const nextIds = target.mode === "append" ? Array.from(/* @__PURE__ */ new Set([...existing.ids, ...targetIds])) : targetIds;
+            s.lists[target.key] = {
+              ...existing,
+              ...target.meta ?? {},
+              ids: nextIds,
+              isFetching: false,
+              isFetchingMore: false,
+              error: null,
+              lastError: null,
+              stale: false,
+              lastFetched: fetchedAt
+            };
+          }
+          for (const projection of options.projections ?? []) {
+            const existing = s.lists[projection.key] ?? defaultListState();
+            const nextIds = [...existing.ids];
+            const { filter, sort, search } = projection.view;
+            for (const id of new Set(ids)) {
+              if (nextIds.includes(id)) continue;
+              const entity = readDraftEntity(id);
+              if (!entity) continue;
+              const matches = (!filter || matchesFilter(entity, filter)) && (!search?.query || matchesSearch(entity, search.query, search.fields));
+              if (!matches) continue;
+              if (sort && sort.length > 0) {
+                const index = findInsertionIndex(entity, nextIds, readDraftEntity, sort);
+                nextIds.splice(index, 0, id);
+              } else {
+                nextIds.unshift(id);
+              }
+            }
+            s.lists[projection.key] = projection.completeFetch ? {
+              ...existing,
+              ids: nextIds,
+              isFetching: false,
+              isFetchingMore: false,
+              error: null,
+              lastError: null,
+              stale: false,
+              lastFetched: fetchedAt
+            } : { ...existing, ids: nextIds };
+          }
+          for (const key of options.finishListFetches ?? []) {
+            if (!s.lists[key]) s.lists[key] = defaultListState();
+            s.lists[key].isFetching = false;
+          }
+        }),
+        replaceEntity: (type, id, data) => set((s) => {
+          if (!s.entities[type]) s.entities[type] = {};
+          s.entities[type][id] = data;
+          const key = ek(type, id);
+          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
+        }),
+        removeEntity: (type, id) => set((s) => {
+          delete s.entities[type]?.[id];
+          delete s.patches[type]?.[id];
+          delete s.entityStates[ek(type, id)];
+          delete s.syncMetadata[ek(type, id)];
+        }),
+        patchEntity: (type, id, patch) => set((s) => {
+          if (!s.patches[type]) s.patches[type] = {};
+          s.patches[type][id] = { ...s.patches[type][id] ?? {}, ...patch };
+        }),
+        unpatchEntity: (type, id, keys) => set((s) => {
+          const p = s.patches[type]?.[id];
+          if (!p) return;
+          for (const k of keys) delete p[k];
+        }),
+        clearPatch: (type, id) => set((s) => {
+          delete s.patches[type]?.[id];
+        }),
+        setEntityFetching: (type, id, fetching) => set((s) => {
+          const k = ek(type, id);
+          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+          s.entityStates[k].isFetching = fetching;
+        }),
+        setEntityError: (type, id, error) => set((s) => {
+          const k = ek(type, id);
+          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+          s.entityStates[k].error = error;
+          s.entityStates[k].isFetching = false;
+        }),
+        setEntityFetched: (type, id) => set((s) => {
+          const k = ek(type, id);
+          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+          s.entityStates[k].lastFetched = Date.now();
+          s.entityStates[k].isFetching = false;
+          s.entityStates[k].error = null;
+          s.entityStates[k].stale = false;
+          s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), synced: true, origin: "server", updatedAt: Date.now() };
+        }),
+        setEntityStale: (type, id, stale) => set((s) => {
+          const k = ek(type, id);
+          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+          s.entityStates[k].stale = stale;
+        }),
+        setEntitySyncMetadata: (type, id, metadata) => set((s) => {
+          const k = ek(type, id);
+          s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), ...metadata };
+        }),
+        clearEntitySyncMetadata: (type, id) => set((s) => {
+          delete s.syncMetadata[ek(type, id)];
+        }),
+        setListResult: (key, ids, meta) => set((s) => {
+          const ex = s.lists[key] ?? defaultListState();
+          s.lists[key] = { ...ex, ...meta, ids, isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
+        }),
+        appendListResult: (key, ids, meta) => set((s) => {
+          const ex = s.lists[key] ?? defaultListState();
+          s.lists[key] = { ...ex, ...meta, ids: Array.from(/* @__PURE__ */ new Set([...ex.ids, ...ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
+        }),
+        prependListResult: (key, ids, meta) => set((s) => {
+          const ex = s.lists[key] ?? defaultListState();
+          s.lists[key] = { ...ex, ...meta ?? {}, ids: Array.from(/* @__PURE__ */ new Set([...ids, ...ex.ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
+        }),
+        removeIdFromAllLists: (_type, id) => set((s) => {
+          for (const key of Object.keys(s.lists)) {
+            const list = s.lists[key];
+            const idx = list.ids.indexOf(id);
+            if (idx !== -1) {
+              list.ids.splice(idx, 1);
+              if (list.total !== null) list.total -= 1;
+            }
+          }
+        }),
+        insertIdInList: (key, id, position) => set((s) => {
+          if (!s.lists[key]) s.lists[key] = defaultListState();
+          const ids = s.lists[key].ids;
+          const ex = ids.indexOf(id);
+          if (ex !== -1) ids.splice(ex, 1);
+          if (position === "start") ids.unshift(id);
+          else if (position === "end") ids.push(id);
+          else ids.splice(position, 0, id);
+        }),
+        setListFetching: (key, fetching) => set((s) => {
+          if (!s.lists[key]) s.lists[key] = defaultListState();
+          s.lists[key].isFetching = fetching;
+        }),
+        setListFetchingMore: (key, fetchingMore) => set((s) => {
+          if (!s.lists[key]) s.lists[key] = defaultListState();
+          s.lists[key].isFetchingMore = fetchingMore;
+        }),
+        setListError: (key, error, typed) => set((s) => {
+          if (!s.lists[key]) s.lists[key] = defaultListState();
+          s.lists[key].error = error;
+          s.lists[key].lastError = typed ?? (error === null ? null : s.lists[key].lastError);
+          s.lists[key].isFetching = false;
+          s.lists[key].isFetchingMore = false;
+          s.lists[key].lastFetched = Date.now();
+          s.lists[key].stale = false;
+        }),
+        setListStale: (key, stale) => set((s) => {
+          if (!s.lists[key]) s.lists[key] = defaultListState();
+          s.lists[key].stale = stale;
+        }),
+        invalidateEntity: (type, id) => set((s) => {
+          if (id) {
+            const k = ek(type, id);
+            if (s.entityStates[k]) s.entityStates[k].stale = true;
+          } else {
+            for (const k of Object.keys(s.entityStates)) if (k.startsWith(`${type}:`)) s.entityStates[k].stale = true;
+          }
+        }),
+        invalidateLists: (matcher) => set((s) => {
+          const pred = typeof matcher === "string" ? (k) => k.startsWith(matcher) : matcher;
+          for (const key of Object.keys(s.lists)) if (pred(key)) s.lists[key].stale = true;
+        }),
+        invalidateType: (type) => {
+          get().invalidateEntity(type);
+          get().invalidateLists(type);
+        },
+        readEntity: (type, id) => {
+          const s = get();
+          const base = s.entities[type]?.[id];
+          if (!base) return null;
+          const patch = s.patches[type]?.[id];
+          return patch ? { ...base, ...patch } : base;
+        },
+        readEntitySnapshot: (type, id) => {
+          const s = get();
+          const base = s.entities[type]?.[id];
+          if (!base) {
+            snapshotCache.delete(ek(type, id));
+            return null;
+          }
+          const patch = s.patches[type]?.[id];
+          const metadata = s.syncMetadata[ek(type, id)] ?? EMPTY_SYNC_METADATA;
+          return readCachedEntitySnapshot(
+            type,
+            id,
+            base,
+            patch,
+            metadata
+          );
+        }
+      }))
+    )
+  );
+}
+var graphStore = createGraphStore();
+var useGraphStore = graphStore;
+
+// src/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");
+    }
+  }
+}
+function subscribeLegacyDevtoolsEvent(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function emitLegacyDevtoolsEvent(event) {
+  publish(event);
+}
+
+// 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 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 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/crud/relations.ts
+var schemaRegistry = /* @__PURE__ */ new Map();
+function registerSchema(schema) {
+  schemaRegistry.set(schema.type, schema);
+}
+function getSchema(type) {
+  return schemaRegistry.get(type) ?? null;
+}
+function getRegisteredSchemas() {
+  return [...schemaRegistry.values()];
+}
+function cascadeInvalidation(ctx, storeApi = graphStore) {
+  const schema = schemaRegistry.get(ctx.type);
+  if (!schema) return;
+  const store = storeApi.getState();
+  if (schema.globalListKeys) for (const key of schema.globalListKeys) store.invalidateLists(key);
+  if (!schema.relations) return;
+  for (const [, relation] of Object.entries(schema.relations)) {
+    switch (relation.cardinality) {
+      case "belongsTo": {
+        const prevFk = ctx.previous?.[relation.foreignKey];
+        const nextFk = ctx.next?.[relation.foreignKey];
+        if (prevFk && prevFk !== nextFk && relation.invalidateTargetLists) for (const kp of relation.invalidateTargetLists) store.invalidateLists((k) => k.startsWith(kp) && k.includes(prevFk));
+        if (nextFk && relation.invalidateTargetLists) for (const kp of relation.invalidateTargetLists) store.invalidateLists((k) => k.startsWith(kp) && k.includes(nextFk));
+        if (prevFk) store.invalidateEntity(relation.targetType, prevFk);
+        if (nextFk) store.invalidateEntity(relation.targetType, nextFk);
+        break;
+      }
+      case "hasMany":
+        store.invalidateLists(serializeKey(relation.listKeyPrefix(ctx.id)));
+        break;
+      case "manyToMany": {
+        const prevIds = ctx.previous?.[relation.localArrayField ?? ""];
+        const nextIds = ctx.next?.[relation.localArrayField ?? ""];
+        for (const relatedId of /* @__PURE__ */ new Set([...prevIds ?? [], ...nextIds ?? []])) store.invalidateLists(serializeKey(relation.listKeyPrefix(relatedId)));
+        break;
+      }
+    }
+  }
+  for (const [, otherSchema] of schemaRegistry) {
+    if (!otherSchema.relations) continue;
+    for (const [, rel] of Object.entries(otherSchema.relations)) {
+      if (rel.targetType !== ctx.type) continue;
+      if (rel.cardinality === "hasMany") store.invalidateLists(serializeKey(rel.listKeyPrefix(ctx.id)));
+    }
+  }
+}
+function readRelations(type, entity, storeApi = graphStore) {
+  const schema = schemaRegistry.get(type);
+  if (!schema?.relations) return {};
+  const store = storeApi.getState();
+  const result = {};
+  for (const [name, relation] of Object.entries(schema.relations)) {
+    switch (relation.cardinality) {
+      case "belongsTo": {
+        const fkValue = entity[relation.foreignKey];
+        result[name] = fkValue ? store.readEntity(relation.targetType, fkValue) : null;
+        break;
+      }
+      case "hasMany": {
+        const listKey = serializeKey(relation.listKeyPrefix(entity.id));
+        const listState = store.lists[listKey];
+        result[name] = listState ? listState.ids.map((id) => store.readEntity(relation.targetType, id)).filter(Boolean) : [];
+        break;
+      }
+      case "manyToMany": {
+        const ids = entity[relation.localArrayField ?? ""];
+        result[name] = ids ? ids.map((id) => store.readEntity(relation.targetType, id)).filter(Boolean) : [];
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/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 ensureDelegate(store, entry) {
+  const factory = bridgeState.factory;
+  if (entry.delegate || entry.compatibilityDetach || !factory) return;
+  entry.compatibilityDetach = factory(store);
+}
+function registerGraphDevtoolsCompatibilityFactory(factory) {
+  bridgeState.factory = factory;
+}
+function notify(entry) {
+  for (const listener of [...entry.listeners]) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function registerGraphDevtoolsCompatibilityDelegate(store, delegate) {
+  const entry = getOrCreateEntry(store);
+  entry.unsubscribeDelegate?.();
+  entry.delegate = delegate;
+  entry.unsubscribeDelegate = delegate.subscribe(() => notify(entry));
+  notify(entry);
+  let unregistered = false;
+  return () => {
+    if (unregistered || entry.delegate !== delegate) return;
+    unregistered = true;
+    entry.unsubscribeDelegate?.();
+    entry.unsubscribeDelegate = null;
+    entry.delegate = null;
+    notify(entry);
+    if (entry.listeners.size === 0) bridgeState.entries.delete(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);
+  };
+}
+
+export { EMPTY_ENTITY_STATE, EMPTY_IDS, EMPTY_LIST_STATE, EMPTY_SYNC_METADATA, __require, applyView, attachGlobalListeners, cascadeInvalidation, checkCompleteness, compareEntities, configureEngine, createGraphStore, dedupe, emitLegacyDevtoolsEvent, fetchEntity, fetchList, findInsertionIndex, getActiveSubscriberCount, getEngineOptions, getGraphDevtoolsCompatibilityDelegate, getMergeStrategy, getRegisteredSchemas, getSchema, graphStore, hasMergeStrategy, lwwStrategy, matchesFilter, matchesSearch, readRelations, registerGraphDevtoolsCompatibilityDelegate, registerGraphDevtoolsCompatibilityFactory, registerMergeStrategy, registerSchema, registerSubscriber, serializeKey, setDefaultMergeStrategy, startGarbageCollector, stopGarbageCollector, subscribeDevtoolsEvent, subscribeGraphDevtoolsCompatibility, subscribeSubscriberStats, unregisterSubscriber, useGraphStore };
+//# sourceMappingURL=chunk-BE3BMRKF.mjs.map
+//# sourceMappingURL=chunk-BE3BMRKF.mjs.map