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

package/dist/devtools.cjs

@@ -0,0 +1,2561 @@
+'use strict';
+
+var vanilla = require('zustand/vanilla');
+var middleware = require('zustand/middleware');
+var immer = require('zustand/middleware/immer');
+
+// src/devtools/protocol.ts
+var GRAPH_DEVTOOLS_PROTOCOL = "prometheus.entity-graph.devtools";
+var GRAPH_DEVTOOLS_PROTOCOL_VERSION = 1;
+
+// 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 getMergeStrategy(type) {
+  return byType.get(type) ?? globalDefault ?? lwwStrategy;
+}
+
+// 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 getNestedValue(obj, path) {
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+
+// src/graph.ts
+var EMPTY_IDS = [];
+var EMPTY_ENTITY_STATE = {
+  isFetching: false,
+  lastFetched: null,
+  error: null,
+  stale: false
+};
+var EMPTY_SYNC_METADATA = {
+  synced: true,
+  origin: "server",
+  updatedAt: null
+};
+var EMPTY_LIST_STATE = {
+  ids: EMPTY_IDS,
+  total: null,
+  nextCursor: null,
+  prevCursor: null,
+  hasNextPage: false,
+  hasPrevPage: false,
+  isFetching: false,
+  isFetchingMore: false,
+  error: null,
+  lastError: null,
+  lastFetched: null,
+  stale: false,
+  currentPage: null,
+  pageSize: null
+};
+function defaultEntityState() {
+  return { ...EMPTY_ENTITY_STATE };
+}
+function defaultSyncMetadata() {
+  return { ...EMPTY_SYNC_METADATA };
+}
+function defaultListState() {
+  return { ...EMPTY_LIST_STATE, ids: [] };
+}
+function ek(type, id) {
+  return `${type}:${id}`;
+}
+var snapshotCache = /* @__PURE__ */ new Map();
+function readCachedEntitySnapshot(type, id, base, patch, metadata) {
+  const key = ek(type, id);
+  const cached = snapshotCache.get(key);
+  if (cached && cached.base === base && cached.patch === patch && cached.metadata === metadata) {
+    return cached.snapshot;
+  }
+  const snapshot = {
+    ...patch ? { ...base, ...patch } : base,
+    $synced: metadata.synced,
+    $origin: metadata.origin,
+    $updatedAt: metadata.updatedAt
+  };
+  snapshotCache.set(key, { base, patch, metadata, snapshot });
+  return snapshot;
+}
+function createGraphStore() {
+  return 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();
+        }),
+        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
+          );
+        }
+      }))
+    )
+  );
+}
+createGraphStore();
+
+// src/devtools/projection.ts
+function countRecordEntries(record) {
+  return Object.keys(record).length;
+}
+function collectGraphDevtoolsCounts(state) {
+  let entities = 0;
+  let entityTypes = 0;
+  for (const bucket of Object.values(state.entities)) {
+    const count = Object.keys(bucket).length;
+    if (count > 0) entityTypes += 1;
+    entities += count;
+  }
+  let patchedEntities = 0;
+  for (const bucket of Object.values(state.patches)) {
+    for (const patch of Object.values(bucket)) {
+      if (Object.keys(patch).length > 0) patchedEntities += 1;
+    }
+  }
+  let listMemberships = 0;
+  let fetching = 0;
+  let stale = 0;
+  let errors = 0;
+  for (const list of Object.values(state.lists)) {
+    listMemberships += list.ids.length;
+    if (list.isFetching || list.isFetchingMore) fetching += 1;
+    if (list.stale) stale += 1;
+    if (list.error !== null || list.lastError !== null) errors += 1;
+  }
+  for (const entityState of Object.values(state.entityStates)) {
+    if (entityState.isFetching) fetching += 1;
+    if (entityState.stale) stale += 1;
+    if (entityState.error !== null) errors += 1;
+  }
+  return {
+    entityTypes,
+    entities,
+    patchedEntities,
+    entityStates: countRecordEntries(state.entityStates),
+    syncMetadata: countRecordEntries(state.syncMetadata),
+    lists: countRecordEntries(state.lists),
+    listMemberships,
+    fetching,
+    stale,
+    errors
+  };
+}
+function withValues(change, before, after, policy, storeId) {
+  if (policy.mode !== "include") return { ...change, valueState: "hidden-by-policy" };
+  const redact = policy.redact ?? ((value) => value);
+  const baseContext = {
+    storeId,
+    category: change.category,
+    key: change.key,
+    ...change.id !== void 0 ? { id: change.id } : {},
+    fieldPath: [],
+    destination: "history"
+  };
+  const projectValue = (value, side) => {
+    try {
+      return { value: toGraphDevtoolsTransportValue(redact(value, { ...baseContext, side })), failed: false };
+    } catch {
+      return { value: { $type: "redaction-error" }, failed: true };
+    }
+  };
+  const projectedBefore = before !== void 0 ? projectValue(before, "before") : void 0;
+  const projectedAfter = after !== void 0 ? projectValue(after, "after") : void 0;
+  return {
+    ...change,
+    valueState: projectedBefore?.failed || projectedAfter?.failed ? "redaction-error" : policy.redact ? "redacted" : "included",
+    ...projectedBefore ? { before: projectedBefore.value } : {},
+    ...projectedAfter ? { after: projectedAfter.value } : {}
+  };
+}
+function toGraphDevtoolsTransportValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "bigint") return { $type: "bigint", value: value.toString() };
+  if (typeof value === "undefined") return { $type: "undefined" };
+  if (typeof value === "function" || typeof value === "symbol") return { $type: typeof value };
+  if (value instanceof Date) return { $type: "date", value: value.toISOString() };
+  if (value instanceof Error) return { $type: "error", name: value.name, message: value.message };
+  if (typeof value !== "object") return String(value);
+  if (seen.has(value)) return { $type: "circular" };
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((item) => toGraphDevtoolsTransportValue(item, seen));
+    const normalized = {};
+    for (const [key, item] of Object.entries(value)) {
+      normalized[key] = toGraphDevtoolsTransportValue(item, seen);
+    }
+    return normalized;
+  } finally {
+    seen.delete(value);
+  }
+}
+function actionFor(before, after) {
+  if (before === void 0) return "added";
+  if (after === void 0) return "removed";
+  return "updated";
+}
+function diffNestedRecords(category, before, after, policy, storeId) {
+  const changes = [];
+  for (const type of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+    const beforeBucket = before[type] ?? {};
+    const afterBucket = after[type] ?? {};
+    if (beforeBucket === afterBucket) continue;
+    for (const id of /* @__PURE__ */ new Set([...Object.keys(beforeBucket), ...Object.keys(afterBucket)])) {
+      const previous = beforeBucket[id];
+      const current = afterBucket[id];
+      if (previous === current) continue;
+      changes.push(withValues({
+        category,
+        action: actionFor(previous, current),
+        key: type,
+        id
+      }, previous, current, policy, storeId));
+    }
+  }
+  return changes;
+}
+function diffFlatRecords(category, before, after, policy, storeId) {
+  const changes = [];
+  if (before === after) return changes;
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+    const previous = before[key];
+    const current = after[key];
+    if (previous === current) continue;
+    changes.push(withValues({
+      category,
+      action: actionFor(previous, current),
+      key
+    }, previous, current, policy, storeId));
+  }
+  return changes;
+}
+function diffLists(before, after, policy, storeId) {
+  const changes = [];
+  if (before === after) return changes;
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+    const previous = before[key];
+    const current = after[key];
+    if (previous === current) continue;
+    changes.push(withValues({
+      category: "list",
+      action: actionFor(previous, current),
+      key,
+      beforeCount: previous?.ids.length ?? 0,
+      afterCount: current?.ids.length ?? 0
+    }, previous, current, policy, storeId));
+  }
+  return changes;
+}
+function projectGraphDevtoolsChanges(before, after, policy, storeId) {
+  return [
+    ...diffNestedRecords("entity", before.entities, after.entities, policy, storeId),
+    ...diffNestedRecords("patch", before.patches, after.patches, policy, storeId),
+    ...diffFlatRecords("entity-state", before.entityStates, after.entityStates, policy, storeId),
+    ...diffFlatRecords("sync", before.syncMetadata, after.syncMetadata, policy, storeId),
+    ...diffLists(before.lists, after.lists, policy, storeId)
+  ];
+}
+
+// src/devtools/inspection.ts
+function wireEntityKey(type, id) {
+  return `${type}:${id}`;
+}
+function graphDevtoolsEntityIdentityKey(type, id) {
+  return JSON.stringify([type, id]);
+}
+function parseGraphDevtoolsEntityIdentityKey(key) {
+  try {
+    const value = JSON.parse(key);
+    if (Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "string") return { type: value[0], id: value[1] };
+  } catch {
+  }
+  return null;
+}
+function splitEntityKey(key) {
+  const separator = key.indexOf(":");
+  if (separator < 1 || separator === key.length - 1) return null;
+  return { type: key.slice(0, separator), id: key.slice(separator + 1) };
+}
+function graphDevtoolsEntityIdentitiesForStateKey(state, key) {
+  const matches = [];
+  const types = /* @__PURE__ */ new Set([...Object.keys(state.entities), ...Object.keys(state.patches)]);
+  for (const type of types) {
+    const ids = /* @__PURE__ */ new Set([
+      ...Object.keys(state.entities[type] ?? {}),
+      ...Object.keys(state.patches[type] ?? {})
+    ]);
+    for (const id of ids) {
+      if (wireEntityKey(type, id) === key) matches.push({ type, id });
+    }
+  }
+  if (matches.length > 0) return matches;
+  const fallback = splitEntityKey(key);
+  return fallback ? [fallback] : [];
+}
+function toIsoTimestamp(value) {
+  return value === null ? null : new Date(value).toISOString();
+}
+function compareEntityIdentity(left, right) {
+  if (left.type !== right.type) return left.type < right.type ? -1 : 1;
+  if (left.id === right.id) return 0;
+  return left.id < right.id ? -1 : 1;
+}
+function collectEntityIdentities(state) {
+  const identities = /* @__PURE__ */ new Map();
+  for (const [type, bucket] of Object.entries(state.entities)) {
+    for (const id of Object.keys(bucket)) {
+      identities.set(graphDevtoolsEntityIdentityKey(type, id), { type, id });
+    }
+  }
+  for (const [type, bucket] of Object.entries(state.patches)) {
+    for (const id of Object.keys(bucket)) {
+      identities.set(graphDevtoolsEntityIdentityKey(type, id), { type, id });
+    }
+  }
+  for (const key of [...Object.keys(state.entityStates), ...Object.keys(state.syncMetadata)]) {
+    for (const identity of graphDevtoolsEntityIdentitiesForStateKey(state, key)) {
+      identities.set(graphDevtoolsEntityIdentityKey(identity.type, identity.id), identity);
+    }
+  }
+  return [...identities.values()].sort(compareEntityIdentity);
+}
+function dirtyReasonsFor(canonical, patch, synced) {
+  const reasons = [];
+  for (const field of Object.keys(patch ?? {}).sort()) {
+    reasons.push({
+      kind: "local-patch",
+      field,
+      change: canonical && Object.hasOwn(canonical, field) ? "changed" : "added"
+    });
+  }
+  if (!synced) {
+    reasons.push({ kind: "sync-state", field: null, change: "unsynced" });
+  }
+  return reasons;
+}
+function projectGraphDevtoolsInspectionValue(value, policy, context) {
+  if (policy.mode !== "include") return { $type: "hidden-by-policy" };
+  try {
+    const projected = policy.redact ? policy.redact(value, {
+      ...context,
+      fieldPath: [],
+      side: "after",
+      destination: "inspection"
+    }) : value;
+    return toGraphDevtoolsTransportValue(projected);
+  } catch {
+    return { $type: "redaction-error" };
+  }
+}
+function recordFor(state, storeId, type, id, revisions, valuePolicy) {
+  const key = wireEntityKey(type, id);
+  const identityKey = graphDevtoolsEntityIdentityKey(type, id);
+  const canonical = state.entities[type]?.[id];
+  const storedPatch = state.patches[type]?.[id];
+  const patch = storedPatch && Object.keys(storedPatch).length > 0 ? storedPatch : void 0;
+  const entityState = state.entityStates[key] ?? EMPTY_ENTITY_STATE;
+  const sync = state.syncMetadata[key] ?? EMPTY_SYNC_METADATA;
+  const dirtyReasons = dirtyReasonsFor(canonical, patch, sync.synced);
+  return {
+    key,
+    type,
+    id,
+    presence: canonical ? "present" : "missing-canonical",
+    canonical: canonical ? projectGraphDevtoolsInspectionValue(canonical, valuePolicy, { storeId, category: "entity", key: type, id }) : null,
+    patch: patch ? projectGraphDevtoolsInspectionValue(patch, valuePolicy, { storeId, category: "patch", key: type, id }) : null,
+    merged: canonical ? projectGraphDevtoolsInspectionValue(
+      { ...canonical, ...patch ?? {} },
+      valuePolicy,
+      { storeId, category: "entity", key: type, id }
+    ) : null,
+    dirty: dirtyReasons.length > 0,
+    dirtyReasons,
+    entityState: {
+      isFetching: entityState.isFetching,
+      lastFetchedAt: toIsoTimestamp(entityState.lastFetched),
+      stale: entityState.stale,
+      error: entityState.error === null ? null : {
+        kind: "entity-fetch",
+        message: entityState.error,
+        retryable: null
+      }
+    },
+    sync: {
+      synced: sync.synced,
+      origin: sync.origin,
+      updatedAt: toIsoTimestamp(sync.updatedAt)
+    },
+    revision: revisions.get(identityKey) ?? 0,
+    viewIds: []
+  };
+}
+function projectGraphDevtoolsEntityRecords(state, storeId, revisions, valuePolicy = { mode: "metadata-only" }, viewIdsByEntity = /* @__PURE__ */ new Map()) {
+  return {
+    protocol: GRAPH_DEVTOOLS_PROTOCOL,
+    version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+    storeId,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entityRecords: collectEntityIdentities(state).map(({ type, id }) => {
+      const record = recordFor(state, storeId, type, id, revisions, valuePolicy);
+      return {
+        ...record,
+        viewIds: [...viewIdsByEntity.get(graphDevtoolsEntityIdentityKey(type, id)) ?? []]
+      };
+    })
+  };
+}
+function advanceGraphDevtoolsEntityRevisions(changes, revisions, state, valueRevisions) {
+  const touched = /* @__PURE__ */ new Set();
+  const valueTouched = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    if ((change.category === "entity" || change.category === "patch") && change.id !== void 0) {
+      const key = graphDevtoolsEntityIdentityKey(change.key, change.id);
+      touched.add(key);
+      valueTouched.add(key);
+      continue;
+    }
+    if (change.category === "entity-state" || change.category === "sync") {
+      for (const identity of graphDevtoolsEntityIdentitiesForStateKey(state, change.key)) {
+        touched.add(graphDevtoolsEntityIdentityKey(identity.type, identity.id));
+      }
+    }
+  }
+  for (const key of touched) revisions.set(key, (revisions.get(key) ?? 0) + 1);
+  if (valueRevisions) {
+    for (const key of valueTouched) valueRevisions.set(key, (valueRevisions.get(key) ?? 0) + 1);
+  }
+}
+
+// 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);
+}
+
+// src/crud/relations.ts
+var schemaRegistry = /* @__PURE__ */ new Map();
+function getRegisteredSchemas() {
+  return [...schemaRegistry.values()];
+}
+
+// src/devtools/relationships.ts
+function mergedEntity(state, type, id) {
+  const canonical = state.entities[type]?.[id];
+  if (!canonical) return null;
+  return { ...canonical, ...state.patches[type]?.[id] ?? {} };
+}
+function statusFor(state, type, id) {
+  return state.entities[type]?.[id] ? "resolved" : "missing-target";
+}
+function edge(relation, descriptor, direction, sourceType, sourceId, sourceField, targetType, targetId, state) {
+  return {
+    relation,
+    cardinality: descriptor.cardinality,
+    direction,
+    source: { type: sourceType, id: sourceId, field: sourceField },
+    target: { type: targetType, id: targetId },
+    status: statusFor(state, targetType, targetId)
+  };
+}
+function belongsToEdges(state, schemaType, relation, descriptor) {
+  const edges = [];
+  for (const id of Object.keys(state.entities[schemaType] ?? {})) {
+    const entity = mergedEntity(state, schemaType, id);
+    const targetId = entity?.[descriptor.foreignKey];
+    if (typeof targetId !== "string" || targetId.length === 0) continue;
+    edges.push(edge(
+      relation,
+      descriptor,
+      "outgoing",
+      schemaType,
+      id,
+      descriptor.foreignKey,
+      descriptor.targetType,
+      targetId,
+      state
+    ));
+  }
+  return edges;
+}
+function hasManyEdges(state, schemaType, relation, descriptor) {
+  const edges = [];
+  for (const parentId of Object.keys(state.entities[schemaType] ?? {})) {
+    const childIds = /* @__PURE__ */ new Set();
+    for (const childId of Object.keys(state.entities[descriptor.targetType] ?? {})) {
+      const child = mergedEntity(state, descriptor.targetType, childId);
+      if (child?.[descriptor.foreignKey] === parentId) childIds.add(childId);
+    }
+    const listKey = serializeKey(descriptor.listKeyPrefix(parentId));
+    for (const childId of state.lists[listKey]?.ids ?? []) {
+      if (!state.entities[descriptor.targetType]?.[childId]) childIds.add(childId);
+    }
+    for (const childId of childIds) {
+      edges.push(edge(
+        relation,
+        descriptor,
+        "reverse",
+        schemaType,
+        parentId,
+        null,
+        descriptor.targetType,
+        childId,
+        state
+      ));
+    }
+  }
+  return edges;
+}
+function manyToManyEdges(state, schemaType, relation, descriptor) {
+  const field = descriptor.localArrayField;
+  if (!field) return [];
+  const edges = [];
+  for (const id of Object.keys(state.entities[schemaType] ?? {})) {
+    const entity = mergedEntity(state, schemaType, id);
+    const targetIds = entity?.[field];
+    if (!Array.isArray(targetIds)) continue;
+    for (const targetId of new Set(targetIds)) {
+      if (typeof targetId !== "string" || targetId.length === 0) continue;
+      edges.push(edge(
+        relation,
+        descriptor,
+        "outgoing",
+        schemaType,
+        id,
+        field,
+        descriptor.targetType,
+        targetId,
+        state
+      ));
+    }
+  }
+  return edges;
+}
+function compareRelationships(left, right) {
+  const leftKey = [
+    left.source.type,
+    left.source.id,
+    left.relation,
+    left.direction,
+    left.target.type,
+    left.target.id
+  ].join("\0");
+  const rightKey = [
+    right.source.type,
+    right.source.id,
+    right.relation,
+    right.direction,
+    right.target.type,
+    right.target.id
+  ].join("\0");
+  if (leftKey === rightKey) return 0;
+  return leftKey < rightKey ? -1 : 1;
+}
+function projectGraphDevtoolsRelationships(state, storeId) {
+  const relationships = [];
+  for (const schema of getRegisteredSchemas()) {
+    for (const [name, descriptor] of Object.entries(schema.relations ?? {})) {
+      switch (descriptor.cardinality) {
+        case "belongsTo":
+          relationships.push(...belongsToEdges(state, schema.type, name, descriptor));
+          break;
+        case "hasMany":
+          relationships.push(...hasManyEdges(state, schema.type, name, descriptor));
+          break;
+        case "manyToMany":
+          relationships.push(...manyToManyEdges(state, schema.type, name, descriptor));
+          break;
+      }
+    }
+  }
+  relationships.sort(compareRelationships);
+  return {
+    protocol: GRAPH_DEVTOOLS_PROTOCOL,
+    version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+    storeId,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    relationships
+  };
+}
+
+// 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 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);
+  };
+}
+
+// src/devtools/time-travel.ts
+function cloneGraphData(data) {
+  return structuredClone({
+    entities: data.entities,
+    patches: data.patches,
+    entityStates: data.entityStates,
+    syncMetadata: data.syncMetadata,
+    lists: data.lists
+  });
+}
+function encodedBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function isRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object") return false;
+  if (ancestors.has(value)) return false;
+  ancestors.add(value);
+  const valid = Array.isArray(value) ? value.every((item) => isJsonValue(item, ancestors)) : isRecord(value) && Object.values(value).every((item) => isJsonValue(item, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isNullableFiniteNumber(value) {
+  return value === null || typeof value === "number" && Number.isFinite(value);
+}
+function isTimestamp(value) {
+  return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
+}
+function isEntityTable(value) {
+  return isRecord(value) && Object.values(value).every(
+    (entities) => isRecord(entities) && Object.values(entities).every(isRecord)
+  );
+}
+function isEntityStates(value) {
+  return isRecord(value) && Object.values(value).every((state) => isRecord(state) && typeof state.isFetching === "boolean" && isNullableFiniteNumber(state.lastFetched) && isNullableString(state.error) && typeof state.stale === "boolean");
+}
+function isSyncMetadata(value) {
+  return isRecord(value) && Object.values(value).every((metadata) => isRecord(metadata) && typeof metadata.synced === "boolean" && (metadata.origin === "server" || metadata.origin === "client" || metadata.origin === "optimistic") && isNullableFiniteNumber(metadata.updatedAt));
+}
+function isLists(value) {
+  return isRecord(value) && Object.values(value).every((list) => isRecord(list) && Array.isArray(list.ids) && list.ids.every((id) => typeof id === "string") && isNullableFiniteNumber(list.total) && isNullableString(list.nextCursor) && isNullableString(list.prevCursor) && typeof list.hasNextPage === "boolean" && typeof list.hasPrevPage === "boolean" && typeof list.isFetching === "boolean" && typeof list.isFetchingMore === "boolean" && isNullableString(list.error) && (list.lastError === null || isRecord(list.lastError)) && isNullableFiniteNumber(list.lastFetched) && typeof list.stale === "boolean" && isNullableFiniteNumber(list.currentPage) && isNullableFiniteNumber(list.pageSize));
+}
+function isGraphData(value) {
+  return isRecord(value) && isEntityTable(value.entities) && isEntityTable(value.patches) && isEntityStates(value.entityStates) && isSyncMetadata(value.syncMetadata) && isLists(value.lists);
+}
+function createGraphDevtoolsSnapshotHistory(options) {
+  const retained = [];
+  const compatibilityLabels = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshotLimit = options.snapshotLimit;
+  let retainedBytes = 0;
+  let latestCursor = 0;
+  let baselineCursor = null;
+  let lastUnavailable = null;
+  const unavailableReferences = /* @__PURE__ */ new Map();
+  let clearedThroughCursor = 0;
+  let mode = "live";
+  let activeCursor = null;
+  let activeSource = null;
+  let protectedLiveHead = null;
+  let importedCandidate = null;
+  let nextImportCandidate = 1;
+  let disposed = false;
+  const notify2 = () => {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const unavailable = (cursor, capturedAt, eventSequence, reason, label) => {
+    const reference = {
+      cursor,
+      capturedAt,
+      eventSequence,
+      ...label !== void 0 ? { label } : {},
+      status: "unavailable",
+      reason
+    };
+    lastUnavailable = reference;
+    unavailableReferences.set(cursor, reference);
+    while (unavailableReferences.size > Math.max(1, snapshotLimit)) {
+      const oldest = unavailableReferences.keys().next().value;
+      if (oldest === void 0) break;
+      unavailableReferences.delete(oldest);
+    }
+    return reference;
+  };
+  const expired = (cursor) => {
+    if (cursor > latestCursor) return null;
+    const status = history.getStatus();
+    const unavailableReference = unavailableReferences.get(cursor);
+    if (unavailableReference) {
+      return {
+        status: "expired-history",
+        cursor,
+        reason: "unavailable",
+        unavailableReason: unavailableReference.reason,
+        oldestCursor: status.oldestCursor,
+        newestCursor: status.newestCursor,
+        latestCursor: status.latestCursor
+      };
+    }
+    return {
+      status: "expired-history",
+      cursor,
+      reason: cursor <= clearedThroughCursor ? "cleared" : "evicted",
+      oldestCursor: status.oldestCursor,
+      newestCursor: status.newestCursor,
+      latestCursor: status.latestCursor
+    };
+  };
+  const enterRewind = (cursor, source, data, liveState, restore) => {
+    if (disposed || mode === "rewound" && protectedLiveHead === null) return null;
+    const previousCursor = activeCursor;
+    const previousSource = activeSource;
+    let target;
+    let nextLiveHead = protectedLiveHead;
+    try {
+      target = cloneGraphData(data);
+      if (mode === "live") nextLiveHead = cloneGraphData(liveState);
+      restore(target);
+    } catch {
+      return null;
+    }
+    protectedLiveHead = nextLiveHead;
+    mode = "rewound";
+    activeCursor = cursor;
+    activeSource = source;
+    return { status: "rewound", previousCursor, previousSource };
+  };
+  const history = {
+    capture(state, eventSequence, label) {
+      importedCandidate = null;
+      const cursor = ++latestCursor;
+      const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (baselineCursor === null) baselineCursor = cursor;
+      if (disposed || snapshotLimit === 0 || options.snapshotBytesLimit === 0) {
+        const reference2 = unavailable(cursor, capturedAt, eventSequence, "retention-disabled", label);
+        notify2();
+        return reference2;
+      }
+      let data;
+      let bytes;
+      try {
+        data = cloneGraphData(state);
+        bytes = encodedBytes(data);
+      } catch {
+        const reference2 = unavailable(cursor, capturedAt, eventSequence, "capture-failed", label);
+        notify2();
+        return reference2;
+      }
+      if (bytes > options.snapshotBytesLimit) {
+        const unavailableReference = unavailable(cursor, capturedAt, eventSequence, "oversize", label);
+        notify2();
+        return unavailableReference;
+      }
+      const reference = {
+        cursor,
+        capturedAt,
+        eventSequence,
+        ...label !== void 0 ? { label } : {},
+        status: "retained",
+        bytes
+      };
+      retained.push({ reference, data });
+      retainedBytes += bytes;
+      while (retained.length > snapshotLimit || retainedBytes > options.snapshotBytesLimit) {
+        const removed = retained.shift();
+        if (removed) compatibilityLabels.delete(removed.reference.cursor);
+        retainedBytes -= removed?.reference.bytes ?? 0;
+      }
+      notify2();
+      return reference;
+    },
+    captureCompatibility(state, label) {
+      const candidateCursor = mode === "live" ? latestCursor : activeSource === "retained" ? activeCursor : null;
+      const current = candidateCursor === null ? void 0 : retained.find(({ reference: reference2 }) => reference2.cursor === candidateCursor);
+      if (current && !compatibilityLabels.has(current.reference.cursor)) {
+        compatibilityLabels.set(current.reference.cursor, label);
+        notify2();
+        return {
+          ...current.reference,
+          ...label !== void 0 ? { label } : {}
+        };
+      }
+      const reference = history.capture(state, null, label);
+      if (reference.status === "retained") {
+        compatibilityLabels.set(reference.cursor, label);
+      }
+      return reference;
+    },
+    getStatus() {
+      return {
+        mode,
+        cursor: activeCursor,
+        source: activeSource,
+        retainedSnapshots: retained.length,
+        retainedBytes,
+        snapshotLimit,
+        byteLimit: options.snapshotBytesLimit,
+        baselineCursor,
+        oldestCursor: retained[0]?.reference.cursor ?? null,
+        newestCursor: retained.length > 0 ? retained[retained.length - 1].reference.cursor : null,
+        latestCursor: latestCursor === 0 ? null : latestCursor,
+        lastUnavailable,
+        importCandidate: importedCandidate ? {
+          candidateId: importedCandidate.candidateId,
+          snapshots: importedCandidate.snapshots.length,
+          bytes: importedCandidate.bytes
+        } : null
+      };
+    },
+    getReferences() {
+      return retained.map(({ reference }) => ({ ...reference }));
+    },
+    getCompatibilityReferences() {
+      return retained.filter(({ reference }) => compatibilityLabels.has(reference.cursor)).map(({ reference }) => {
+        const label = compatibilityLabels.get(reference.cursor);
+        return { ...reference, ...label !== void 0 ? { label } : {} };
+      });
+    },
+    read(cursor) {
+      const snapshot = retained.find((candidate) => candidate.reference.cursor === cursor);
+      return snapshot ? cloneGraphData(snapshot.data) : null;
+    },
+    rewind(cursor, liveState, restore) {
+      if (disposed) return null;
+      const snapshot = retained.find((candidate) => candidate.reference.cursor === cursor);
+      if (!snapshot) return expired(cursor);
+      const result = enterRewind(cursor, "retained", snapshot.data, liveState, restore);
+      if (result) notify2();
+      return result;
+    },
+    inspectImport(candidate, storeId) {
+      importedCandidate = null;
+      const rejected = (reason, message) => {
+        notify2();
+        return { status: "rejected", reason, message };
+      };
+      try {
+        if (!isRecord(candidate) || !isJsonValue(candidate) || candidate.protocol !== GRAPH_DEVTOOLS_PROTOCOL) {
+          return rejected("invalid-envelope", "Import must use the Prometheus entity-graph DevTools protocol");
+        }
+        if (candidate.version !== GRAPH_DEVTOOLS_PROTOCOL_VERSION) {
+          return rejected("unsupported-version", `Import protocol version ${String(candidate.version)} is unsupported`);
+        }
+        if (candidate.storeId !== storeId) {
+          return rejected("wrong-store", `Import targets ${String(candidate.storeId)}, not ${storeId}`);
+        }
+        if (!isTimestamp(candidate.exportedAt) || !Array.isArray(candidate.snapshots) || candidate.snapshots.length === 0) {
+          return rejected("invalid-envelope", "Import metadata and at least one snapshot are required");
+        }
+        if (candidate.snapshots.length > snapshotLimit) {
+          return rejected("snapshot-limit-exceeded", `Import contains ${candidate.snapshots.length} snapshots; limit is ${snapshotLimit}`);
+        }
+        const importBytes = encodedBytes(candidate);
+        if (importBytes > options.snapshotBytesLimit) {
+          return rejected("byte-limit-exceeded", `Import contains ${importBytes} bytes; limit is ${options.snapshotBytesLimit}`);
+        }
+        const snapshots = [];
+        let previousCursor = 0;
+        for (const value of candidate.snapshots) {
+          if (!isRecord(value)) return rejected("invalid-envelope", "Every imported snapshot must be an object");
+          const cursor = value.cursor;
+          const eventSequence = value.eventSequence;
+          if (typeof cursor !== "number" || !Number.isSafeInteger(cursor) || cursor <= previousCursor || !isTimestamp(value.capturedAt) || !(eventSequence === null || typeof eventSequence === "number" && Number.isSafeInteger(eventSequence) && eventSequence > 0) || !isGraphData(value.data)) {
+            return rejected("invalid-envelope", "Imported snapshots must have ordered stable cursors and valid graph data");
+          }
+          const data = cloneGraphData(value.data);
+          snapshots.push({
+            cursor,
+            capturedAt: value.capturedAt,
+            eventSequence,
+            bytes: encodedBytes(data),
+            data
+          });
+          previousCursor = cursor;
+        }
+        const candidateBytes = snapshots.reduce((total, snapshot) => total + snapshot.bytes, 0);
+        while (retained.length + snapshots.length > snapshotLimit || retainedBytes + candidateBytes > options.snapshotBytesLimit) {
+          const removed = retained.shift();
+          if (!removed) break;
+          compatibilityLabels.delete(removed.reference.cursor);
+          retainedBytes -= removed.reference.bytes;
+        }
+        const candidateId = `import-${nextImportCandidate++}`;
+        importedCandidate = { candidateId, bytes: candidateBytes, snapshots };
+        notify2();
+        const receipt = {
+          status: "awaiting-confirmation",
+          candidateId,
+          storeId,
+          protocolVersion: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+          inspectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          bytes: importBytes,
+          snapshots: snapshots.map(({ data: _data, ...metadata }) => metadata)
+        };
+        return receipt;
+      } catch {
+        return rejected("invalid-envelope", "Import could not be safely inspected or cloned");
+      }
+    },
+    restoreImport(candidateId, cursor, liveState, restore) {
+      if (!importedCandidate || importedCandidate.candidateId !== candidateId) {
+        return { status: "candidate-not-found" };
+      }
+      const snapshot = importedCandidate.snapshots.find((candidate) => candidate.cursor === cursor);
+      if (!snapshot) return { status: "snapshot-not-found" };
+      const restored = enterRewind(cursor, "import", snapshot.data, liveState, restore);
+      if (!restored) return { status: "restore-failed" };
+      importedCandidate = null;
+      notify2();
+      return restored;
+    },
+    returnToLive(restore) {
+      if (disposed || mode !== "rewound" || protectedLiveHead === null) return null;
+      const previousCursor = activeCursor;
+      const previousSource = activeSource;
+      if (previousCursor === null || previousSource === null) return null;
+      try {
+        restore(cloneGraphData(protectedLiveHead));
+      } catch {
+        return null;
+      }
+      mode = "live";
+      activeCursor = null;
+      activeSource = null;
+      protectedLiveHead = null;
+      notify2();
+      return { previousCursor, previousSource };
+    },
+    leaveRewindForMutation() {
+      if (mode !== "rewound") return null;
+      const previousCursor = activeCursor;
+      const previousSource = activeSource;
+      if (previousCursor === null || previousSource === null) return null;
+      mode = "live";
+      activeCursor = null;
+      activeSource = null;
+      protectedLiveHead = null;
+      notify2();
+      return { previousCursor, previousSource };
+    },
+    configureLimit(nextLimit) {
+      if (!Number.isFinite(nextLimit) || nextLimit <= 0) return;
+      snapshotLimit = Math.max(1, Math.floor(nextLimit));
+      while (retained.length > snapshotLimit) {
+        const removed = retained.shift();
+        if (removed) compatibilityLabels.delete(removed.reference.cursor);
+        retainedBytes -= removed?.reference.bytes ?? 0;
+      }
+      while (unavailableReferences.size > Math.max(1, snapshotLimit)) {
+        const oldest = unavailableReferences.keys().next().value;
+        if (oldest === void 0) break;
+        unavailableReferences.delete(oldest);
+      }
+      if (importedCandidate && retained.length + importedCandidate.snapshots.length > snapshotLimit) {
+        importedCandidate = null;
+      }
+      notify2();
+    },
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    clear() {
+      retained.length = 0;
+      compatibilityLabels.clear();
+      retainedBytes = 0;
+      clearedThroughCursor = latestCursor;
+      importedCandidate = null;
+      notify2();
+    },
+    dispose() {
+      disposed = true;
+      retained.length = 0;
+      compatibilityLabels.clear();
+      retainedBytes = 0;
+      lastUnavailable = null;
+      unavailableReferences.clear();
+      mode = "live";
+      activeCursor = null;
+      activeSource = null;
+      protectedLiveHead = null;
+      importedCandidate = null;
+      listeners.clear();
+    }
+  };
+  return history;
+}
+
+// src/devtools/views.ts
+function orderedUnique(values) {
+  return [...new Set(values)];
+}
+function sameValues(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function membershipFor(entry) {
+  const entityIds = /* @__PURE__ */ new Set();
+  for (const registration of entry.registrations.values()) {
+    for (const id of registration.entityIds) entityIds.add(id);
+  }
+  return [...entityIds].map((id) => ({ type: entry.definition.entityType, id }));
+}
+function viewRecord(entry, state) {
+  const membership = membershipFor(entry);
+  const registrations = [...entry.registrations.values()];
+  const lastRenderedAt = registrations.map((registration) => registration.lastRenderedAt).filter((value) => value !== null).sort().at(-1) ?? null;
+  const queryKey = entry.definition.queryKey ?? null;
+  const listState = queryKey === null ? EMPTY_LIST_STATE : state.lists[queryKey] ?? EMPTY_LIST_STATE;
+  return {
+    ...entry.definition,
+    queryKey,
+    registeredAt: entry.registeredAt,
+    lastRenderedAt,
+    renderCount: registrations.reduce((total, registration) => total + registration.renderCount, 0),
+    subscriberCount: registrations.length,
+    membership,
+    list: entry.definition.kind === "list" ? {
+      visibleCount: membership.length,
+      graphCount: listState.ids.length,
+      total: listState.total,
+      isFetching: listState.isFetching,
+      isFetchingMore: listState.isFetchingMore,
+      stale: listState.stale,
+      hasNextPage: listState.hasNextPage,
+      hasPreviousPage: listState.hasPrevPage
+    } : null
+  };
+}
+function allEntityIdentities(state, memberships) {
+  const identities = /* @__PURE__ */ new Map();
+  for (const [type, bucket] of Object.entries(state.entities)) {
+    for (const id of Object.keys(bucket)) {
+      identities.set(graphDevtoolsEntityIdentityKey(type, id), { type, id });
+    }
+  }
+  for (const [type, bucket] of Object.entries(state.patches)) {
+    for (const id of Object.keys(bucket)) {
+      identities.set(graphDevtoolsEntityIdentityKey(type, id), { type, id });
+    }
+  }
+  for (const key of [
+    ...Object.keys(state.entityStates),
+    ...Object.keys(state.syncMetadata)
+  ]) {
+    for (const identity of graphDevtoolsEntityIdentitiesForStateKey(state, key)) {
+      identities.set(graphDevtoolsEntityIdentityKey(identity.type, identity.id), identity);
+    }
+  }
+  for (const key of memberships.keys()) {
+    const identity = parseGraphDevtoolsEntityIdentityKey(key);
+    if (identity) identities.set(key, identity);
+  }
+  return [...identities.values()].sort((left, right) => {
+    if (left.type !== right.type) return left.type < right.type ? -1 : 1;
+    if (left.id === right.id) return 0;
+    return left.id < right.id ? -1 : 1;
+  });
+}
+function createGraphDevtoolsViewRegistry(storeId, getState, onViewChange) {
+  const entries = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const viewIdsByEntity = () => {
+    const result = /* @__PURE__ */ new Map();
+    for (const [viewId, entry] of entries) {
+      for (const membership of membershipFor(entry)) {
+        const key = graphDevtoolsEntityIdentityKey(membership.type, membership.id);
+        const viewIds = result.get(key) ?? [];
+        viewIds.push(viewId);
+        result.set(key, viewIds);
+      }
+    }
+    for (const viewIds of result.values()) viewIds.sort();
+    return result;
+  };
+  return {
+    register(definition) {
+      if (disposed) return { viewId: definition.viewId, updateMembership() {
+      }, unregister() {
+      } };
+      const token = Symbol(definition.viewId);
+      let entry = entries.get(definition.viewId);
+      const isNew = entry === void 0;
+      if (!entry) {
+        entry = {
+          definition: { ...definition, queryKey: definition.queryKey ?? null },
+          registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          registrations: /* @__PURE__ */ new Map()
+        };
+        entries.set(definition.viewId, entry);
+      }
+      entry.registrations.set(token, { entityIds: [], renderCount: 0, lastRenderedAt: null });
+      if (isNew) onViewChange({ state: "registered", viewId: definition.viewId, membershipCount: 0 });
+      let unregistered = false;
+      return {
+        viewId: definition.viewId,
+        updateMembership(entityIds) {
+          if (disposed || unregistered) return;
+          const currentEntry = entries.get(definition.viewId);
+          const registration = currentEntry?.registrations.get(token);
+          if (!currentEntry || !registration) return;
+          const before = membershipFor(currentEntry);
+          registration.entityIds = orderedUnique(entityIds);
+          registration.renderCount += 1;
+          registration.lastRenderedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const after = membershipFor(currentEntry);
+          const beforeKeys = before.map(({ type, id }) => graphDevtoolsEntityIdentityKey(type, id));
+          const afterKeys = after.map(({ type, id }) => graphDevtoolsEntityIdentityKey(type, id));
+          if (!sameValues(beforeKeys, afterKeys)) {
+            onViewChange({
+              state: "membership-changed",
+              viewId: definition.viewId,
+              membershipCount: after.length
+            });
+          }
+        },
+        unregister() {
+          if (disposed || unregistered) return;
+          unregistered = true;
+          const currentEntry = entries.get(definition.viewId);
+          if (!currentEntry) return;
+          const before = membershipFor(currentEntry);
+          currentEntry.registrations.delete(token);
+          if (currentEntry.registrations.size === 0) {
+            entries.delete(definition.viewId);
+            onViewChange({ state: "unregistered", viewId: definition.viewId, membershipCount: 0 });
+            return;
+          }
+          const after = membershipFor(currentEntry);
+          const beforeKeys = before.map(({ type, id }) => graphDevtoolsEntityIdentityKey(type, id));
+          const afterKeys = after.map(({ type, id }) => graphDevtoolsEntityIdentityKey(type, id));
+          if (!sameValues(beforeKeys, afterKeys)) {
+            onViewChange({
+              state: "membership-changed",
+              viewId: definition.viewId,
+              membershipCount: after.length
+            });
+          }
+        }
+      };
+    },
+    getSnapshot() {
+      const state = getState();
+      const memberships = viewIdsByEntity();
+      return {
+        protocol: GRAPH_DEVTOOLS_PROTOCOL,
+        version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+        storeId,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        views: [...entries.values()].map((entry) => viewRecord(entry, state)).sort((left, right) => left.viewId < right.viewId ? -1 : left.viewId > right.viewId ? 1 : 0),
+        entityViewMembership: allEntityIdentities(state, memberships).map(({ type, id }) => ({
+          type,
+          id,
+          viewIds: [...memberships.get(graphDevtoolsEntityIdentityKey(type, id)) ?? []]
+        }))
+      };
+    },
+    getViewIdsByEntity() {
+      return viewIdsByEntity();
+    },
+    dispose() {
+      disposed = true;
+      entries.clear();
+    }
+  };
+}
+
+// src/devtools/previews.ts
+function replaceEntityPatch(store, type, id, patch) {
+  store.setState((state) => {
+    const patches = { ...state.patches };
+    const bucket = { ...patches[type] ?? {} };
+    if (patch === void 0) delete bucket[id];
+    else bucket[id] = { ...patch };
+    if (Object.keys(bucket).length === 0) delete patches[type];
+    else patches[type] = bucket;
+    return { patches };
+  });
+}
+function createGraphDevtoolsPreviewController(store, storeId, valuePolicy, valueRevisionFor) {
+  const receipts = /* @__PURE__ */ new Map();
+  const activeByEntity = /* @__PURE__ */ new Map();
+  let nextPreview = 1;
+  let disposed = false;
+  const projectPatch = (type, id, value) => projectGraphDevtoolsInspectionValue(
+    value,
+    valuePolicy,
+    { storeId, category: "patch", key: type, id }
+  );
+  const removeReceipt = (receipt) => {
+    receipts.delete(receipt.previewId);
+    const key = graphDevtoolsEntityIdentityKey(receipt.type, receipt.id);
+    if (activeByEntity.get(key) === receipt.previewId) activeByEntity.delete(key);
+  };
+  return {
+    apply(type, id, patch) {
+      if (disposed || !store.getState().entities[type]?.[id]) return null;
+      const key = graphDevtoolsEntityIdentityKey(type, id);
+      const previousPreviewId = activeByEntity.get(key);
+      if (previousPreviewId) receipts.delete(previousPreviewId);
+      const storedPriorPatch = store.getState().patches[type]?.[id];
+      const priorPatch = storedPriorPatch === void 0 ? void 0 : { ...storedPriorPatch };
+      const previewPatch = { ...patch };
+      const baselineRevision = valueRevisionFor(type, id);
+      store.getState().patchEntity(type, id, previewPatch);
+      const appliedPatch = { ...store.getState().patches[type]?.[id] ?? {} };
+      const previewRevision = valueRevisionFor(type, id);
+      const receipt = {
+        previewId: `preview-${storeId}-${nextPreview++}`,
+        type,
+        id,
+        priorPatch,
+        previewPatch,
+        appliedPatch,
+        baselineRevision,
+        previewRevision,
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      receipts.set(receipt.previewId, receipt);
+      activeByEntity.set(key, receipt.previewId);
+      return {
+        previewId: receipt.previewId,
+        entity: { type, id },
+        priorPatch: priorPatch === void 0 ? null : projectPatch(type, id, priorPatch),
+        previewPatch: projectPatch(type, id, previewPatch),
+        appliedPatch: projectPatch(type, id, appliedPatch),
+        baselineRevision,
+        previewRevision,
+        appliedAt: receipt.appliedAt
+      };
+    },
+    restore(previewId) {
+      if (disposed) return null;
+      const receipt = receipts.get(previewId);
+      if (!receipt) return null;
+      const observedRevision = valueRevisionFor(receipt.type, receipt.id);
+      if (observedRevision !== receipt.previewRevision) {
+        const currentPatch = store.getState().patches[receipt.type]?.[receipt.id];
+        const conflict = {
+          previewId,
+          status: "conflict",
+          reason: "entity-changed-since-preview",
+          expectedRevision: receipt.previewRevision,
+          observedRevision,
+          currentPatch: currentPatch === void 0 ? null : projectPatch(receipt.type, receipt.id, currentPatch),
+          priorPatch: receipt.priorPatch === void 0 ? null : projectPatch(receipt.type, receipt.id, receipt.priorPatch)
+        };
+        removeReceipt(receipt);
+        return conflict;
+      }
+      replaceEntityPatch(store, receipt.type, receipt.id, receipt.priorPatch);
+      removeReceipt(receipt);
+      return {
+        previewId,
+        status: "restored",
+        restoredPatch: receipt.priorPatch === void 0 ? null : projectPatch(receipt.type, receipt.id, receipt.priorPatch),
+        observedRevision,
+        restoredAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    },
+    dispose() {
+      disposed = true;
+      receipts.clear();
+      activeByEntity.clear();
+    }
+  };
+}
+
+// src/devtools/controller.ts
+var controllers = /* @__PURE__ */ new WeakMap();
+var storeNumbers = /* @__PURE__ */ new WeakMap();
+var nextStoreNumber = 1;
+function nowDuration() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function boundedLimit(value, fallback, minimum = 0) {
+  const candidate = value ?? fallback;
+  return Number.isFinite(candidate) ? Math.max(minimum, Math.floor(candidate)) : fallback;
+}
+function storeIdFor(store) {
+  let number = storeNumbers.get(store);
+  if (number === void 0) {
+    number = nextStoreNumber++;
+    storeNumbers.set(store, number);
+  }
+  return `graph-${number}`;
+}
+function resultError(storeId, requestId, code, message) {
+  return {
+    protocol: GRAPH_DEVTOOLS_PROTOCOL,
+    version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+    requestId,
+    storeId,
+    ok: false,
+    error: { code, message }
+  };
+}
+function parseCommand(command) {
+  if (typeof command !== "object" || command === null) return null;
+  const candidate = command;
+  if (candidate.protocol !== GRAPH_DEVTOOLS_PROTOCOL || typeof candidate.version !== "number" || typeof candidate.requestId !== "string" || typeof candidate.storeId !== "string" || typeof candidate.command !== "string") return null;
+  return candidate;
+}
+function parsePreviewPayload(payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+  const candidate = payload;
+  if (typeof candidate.type !== "string" || candidate.type.length === 0 || typeof candidate.id !== "string" || candidate.id.length === 0 || typeof candidate.patch !== "object" || candidate.patch === null || Array.isArray(candidate.patch) || Object.keys(candidate.patch).length === 0) return null;
+  return candidate;
+}
+function parseRestorePreviewPayload(payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+  const previewId = payload.previewId;
+  return typeof previewId === "string" && previewId.length > 0 ? { previewId } : null;
+}
+function parseRewindPayload(payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+  const cursor = payload.cursor;
+  return typeof cursor === "number" && Number.isSafeInteger(cursor) && cursor > 0 ? { cursor } : null;
+}
+function parseInspectHistoryImportPayload(payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+  if (!Object.prototype.hasOwnProperty.call(payload, "candidate")) return null;
+  return { candidate: payload.candidate };
+}
+function parseConfirmHistoryImportPayload(payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+  const candidate = payload;
+  if (typeof candidate.candidateId !== "string" || candidate.candidateId.length === 0 || typeof candidate.cursor !== "number" || !Number.isSafeInteger(candidate.cursor) || candidate.cursor <= 0 || typeof candidate.confirm !== "boolean") return null;
+  return candidate;
+}
+function createController(store, options) {
+  const storeId = options.storeId ?? storeIdFor(store);
+  const historyLimit = boundedLimit(options.historyLimit, 500);
+  const historyBytesLimit = boundedLimit(options.historyBytesLimit, 5 * 1024 * 1024);
+  const eventBytesLimit = boundedLimit(options.eventBytesLimit, 256 * 1024, 1024);
+  const snapshotLimit = boundedLimit(options.snapshotLimit, 50);
+  const snapshotBytesLimit = boundedLimit(options.snapshotBytesLimit, 10 * 1024 * 1024);
+  const timeTravelEnabled = snapshotLimit > 0 && snapshotBytesLimit > 0;
+  const timeTravelCommands = timeTravelEnabled ? [
+    "get-time-travel-status",
+    "rewind",
+    "return-to-live",
+    "inspect-history-import",
+    "confirm-history-import"
+  ] : [];
+  const timeTravelFeatures = timeTravelEnabled ? ["snapshot-history", "time-travel", "history-import"] : [];
+  const valuePolicy = options.values ?? { mode: "metadata-only" };
+  const capabilities = {
+    protocolVersion: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+    metadataOnlyByDefault: true,
+    commands: [
+      "get-capabilities",
+      "get-snapshot",
+      "get-history",
+      "get-history-status",
+      "get-entity-records",
+      "get-views",
+      "get-relationships",
+      "preview-entity-patch",
+      "restore-entity-preview",
+      ...timeTravelCommands,
+      "clear-history"
+    ],
+    features: [
+      "semantic-events",
+      "diagnostic-events",
+      "bounded-history",
+      "multi-client",
+      "multi-store",
+      "entity-inspection",
+      "view-inspection",
+      "relationship-inspection",
+      "local-preview",
+      ...timeTravelFeatures
+    ],
+    limits: {
+      historyEvents: historyLimit,
+      historyBytes: historyBytesLimit,
+      eventBytes: eventBytesLimit,
+      snapshots: snapshotLimit,
+      snapshotBytes: snapshotBytesLimit
+    }
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const history = [];
+  const historySizes = [];
+  const entityRevisions = /* @__PURE__ */ new Map();
+  const entityValueRevisions = /* @__PURE__ */ new Map();
+  let retainedBytes = 0;
+  let sequence = 0;
+  let activeClients = 0;
+  let nextClientNumber = 1;
+  let disposed = false;
+  let projectionFailureRevision = 0;
+  let internalReplayDepth = 0;
+  const snapshotHistory = createGraphDevtoolsSnapshotHistory({
+    snapshotLimit,
+    snapshotBytesLimit
+  });
+  snapshotHistory.capture(store.getState(), null);
+  const nextBase = () => {
+    const current = ++sequence;
+    const eventId = `${storeId}:${current}`;
+    return {
+      protocol: GRAPH_DEVTOOLS_PROTOCOL,
+      version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+      storeId,
+      sequence: current,
+      eventId,
+      correlationId: eventId,
+      observedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  };
+  const encodedBytes2 = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  const boundEvent = (event) => {
+    if (event.type !== "mutation") return event;
+    if (encodedBytes2(event) <= eventBytesLimit) return event;
+    const valuesTruncated = event.payload.changes.some(
+      (change) => "before" in change || "after" in change
+    );
+    const withoutValues = {
+      ...event,
+      payload: {
+        ...event.payload,
+        valuesTruncated,
+        changes: event.payload.changes.map(({ before: _before, after: _after, ...change }) => ({
+          ...change,
+          valueState: change.valueState === "hidden-by-policy" || change.valueState === "redaction-error" ? change.valueState : "truncated"
+        }))
+      }
+    };
+    if (encodedBytes2(withoutValues) <= eventBytesLimit) return withoutValues;
+    let lower = 0;
+    let upper = withoutValues.payload.changes.length;
+    let bounded = {
+      ...withoutValues,
+      payload: {
+        ...withoutValues.payload,
+        changes: [],
+        changesOmitted: withoutValues.payload.changes.length
+      }
+    };
+    while (lower <= upper) {
+      const count = Math.floor((lower + upper) / 2);
+      const candidate = {
+        ...withoutValues,
+        payload: {
+          ...withoutValues.payload,
+          changes: withoutValues.payload.changes.slice(0, count),
+          changesOmitted: withoutValues.payload.changes.length - count
+        }
+      };
+      if (encodedBytes2(candidate) <= eventBytesLimit) {
+        bounded = candidate;
+        lower = count + 1;
+      } else {
+        upper = count - 1;
+      }
+    }
+    return bounded;
+  };
+  const publish = (candidate) => {
+    if (disposed) return;
+    const event = boundEvent(candidate);
+    if (historyLimit > 0 && historyBytesLimit > 0) {
+      const size = encodedBytes2(event);
+      history.push(event);
+      historySizes.push(size);
+      retainedBytes += size;
+      while (history.length > historyLimit || retainedBytes > historyBytesLimit) {
+        history.shift();
+        retainedBytes -= historySizes.shift() ?? 0;
+      }
+    }
+    for (const listener of [...listeners]) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  };
+  const publishLifecycle = (state, clientId) => {
+    publish({
+      ...nextBase(),
+      type: "lifecycle",
+      payload: {
+        state,
+        ...clientId !== void 0 ? { clientId } : {},
+        activeClients
+      }
+    });
+  };
+  const publishTimeTravel = (state, cursor, previousCursor, source, previousSource, reason) => {
+    const event = {
+      ...nextBase(),
+      type: "time-travel",
+      payload: { state, cursor, previousCursor, source, previousSource, reason }
+    };
+    publish(event);
+    return event;
+  };
+  const restoreGraphData = (data) => {
+    internalReplayDepth += 1;
+    try {
+      store.setState(data);
+    } finally {
+      internalReplayDepth -= 1;
+    }
+  };
+  const leaveRewindForMutation = () => {
+    const previous = snapshotHistory.leaveRewindForMutation();
+    if (previous === null) return;
+    projectionFailureRevision += 1;
+    publishTimeTravel(
+      "live",
+      null,
+      previous.previousCursor,
+      null,
+      previous.previousSource,
+      "mutation"
+    );
+  };
+  const viewRegistry = createGraphDevtoolsViewRegistry(storeId, () => store.getState(), (payload) => {
+    const event = { ...nextBase(), type: "view", payload };
+    publish(event);
+  });
+  const affectedProjection = (changes, previous, current) => {
+    const identities = /* @__PURE__ */ new Map();
+    const changedListKeys = /* @__PURE__ */ new Set();
+    for (const change of changes) {
+      if ((change.category === "entity" || change.category === "patch") && change.id !== void 0) {
+        identities.set(graphDevtoolsEntityIdentityKey(change.key, change.id), {
+          type: change.key,
+          id: change.id
+        });
+      } else if (change.category === "entity-state" || change.category === "sync") {
+        const stateIdentities = [
+          ...graphDevtoolsEntityIdentitiesForStateKey(previous, change.key),
+          ...graphDevtoolsEntityIdentitiesForStateKey(current, change.key)
+        ];
+        for (const identity of stateIdentities) {
+          identities.set(graphDevtoolsEntityIdentityKey(identity.type, identity.id), identity);
+        }
+      } else if (change.category === "list") {
+        changedListKeys.add(change.key);
+      }
+    }
+    const views = viewRegistry.getSnapshot().views;
+    const affectedViewIds = /* @__PURE__ */ new Set();
+    for (const view of views) {
+      if (view.queryKey !== null && changedListKeys.has(view.queryKey)) {
+        affectedViewIds.add(view.viewId);
+        const previousIds = previous.lists[view.queryKey]?.ids ?? [];
+        const currentIds = current.lists[view.queryKey]?.ids ?? [];
+        const previousPositions = new Map(previousIds.map((id, index) => [id, index]));
+        const currentPositions = new Map(currentIds.map((id, index) => [id, index]));
+        const ids = /* @__PURE__ */ new Set([...previousIds, ...currentIds]);
+        for (const id of ids) {
+          if (previousPositions.get(id) === currentPositions.get(id)) continue;
+          identities.set(graphDevtoolsEntityIdentityKey(view.entityType, id), {
+            type: view.entityType,
+            id
+          });
+        }
+      }
+      if (view.membership.some((member) => identities.has(graphDevtoolsEntityIdentityKey(member.type, member.id)))) {
+        affectedViewIds.add(view.viewId);
+      }
+    }
+    return {
+      affectedEntities: [...identities.values()],
+      affectedViewIds: [...affectedViewIds].sort()
+    };
+  };
+  const unsubscribeStore = store.subscribe((current, previous) => {
+    if (disposed || internalReplayDepth > 0) return;
+    const startedAt = nowDuration();
+    let changes;
+    try {
+      changes = projectGraphDevtoolsChanges(previous, current, valuePolicy, storeId);
+    } catch {
+      leaveRewindForMutation();
+      projectionFailureRevision += 1;
+      const base2 = nextBase();
+      const event2 = {
+        ...base2,
+        type: "diagnostic",
+        payload: {
+          code: "projection-failed",
+          message: "A graph publication could not be projected for DevTools.",
+          snapshot: snapshotHistory.capture(current, base2.sequence)
+        }
+      };
+      publish(event2);
+      return;
+    }
+    if (changes.length === 0) return;
+    leaveRewindForMutation();
+    advanceGraphDevtoolsEntityRevisions(changes, entityRevisions, current, entityValueRevisions);
+    const affected = affectedProjection(changes, previous, current);
+    const base = nextBase();
+    const event = {
+      ...base,
+      type: "mutation",
+      payload: {
+        snapshot: snapshotHistory.capture(current, base.sequence),
+        valuesTruncated: false,
+        changesOmitted: 0,
+        changes,
+        ...affected,
+        before: collectGraphDevtoolsCounts(previous),
+        after: collectGraphDevtoolsCounts(current),
+        projectionDurationMs: Math.max(0, nowDuration() - startedAt)
+      }
+    };
+    publish(event);
+  });
+  const previewController = createGraphDevtoolsPreviewController(
+    store,
+    storeId,
+    valuePolicy,
+    (type, id) => (entityValueRevisions.get(graphDevtoolsEntityIdentityKey(type, id)) ?? 0) + projectionFailureRevision
+  );
+  const controller = {
+    storeId,
+    capabilities,
+    getSnapshot() {
+      return {
+        protocol: GRAPH_DEVTOOLS_PROTOCOL,
+        version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+        storeId,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        counts: collectGraphDevtoolsCounts(store.getState()),
+        history: controller.getHistoryStatus(),
+        snapshots: controller.getSnapshotHistoryStatus()
+      };
+    },
+    getHistory() {
+      return [...history];
+    },
+    getHistoryStatus() {
+      return {
+        retainedEvents: history.length,
+        retainedBytes,
+        eventLimit: historyLimit,
+        byteLimit: historyBytesLimit,
+        oldestSequence: history[0]?.sequence ?? null,
+        newestSequence: history.length > 0 ? history[history.length - 1].sequence : null
+      };
+    },
+    getSnapshotHistoryStatus() {
+      return snapshotHistory.getStatus();
+    },
+    getSnapshotReferences() {
+      return snapshotHistory.getReferences();
+    },
+    getCompatibilitySnapshotReferences() {
+      return snapshotHistory.getCompatibilityReferences();
+    },
+    captureCompatibilitySnapshot(label) {
+      const reference = snapshotHistory.captureCompatibility(store.getState(), label);
+      return reference.status === "retained" ? reference.cursor : -1;
+    },
+    configureSnapshotLimit(nextSnapshotLimit) {
+      snapshotHistory.configureLimit(nextSnapshotLimit);
+      capabilities.limits.snapshots = snapshotHistory.getStatus().snapshotLimit;
+    },
+    subscribeSnapshotHistory(listener) {
+      return snapshotHistory.subscribe(listener);
+    },
+    clearSnapshotHistory() {
+      snapshotHistory.clear();
+    },
+    getEntityRecords() {
+      return projectGraphDevtoolsEntityRecords(
+        store.getState(),
+        storeId,
+        entityRevisions,
+        valuePolicy,
+        viewRegistry.getViewIdsByEntity()
+      );
+    },
+    getViews() {
+      return viewRegistry.getSnapshot();
+    },
+    getRelationships() {
+      return projectGraphDevtoolsRelationships(store.getState(), storeId);
+    },
+    registerView(definition) {
+      return viewRegistry.register(definition);
+    },
+    rewind(cursor) {
+      if (!timeTravelEnabled) return null;
+      const attempt = snapshotHistory.rewind(cursor, store.getState(), restoreGraphData);
+      if (attempt === null || attempt.status === "expired-history") return attempt;
+      projectionFailureRevision += 1;
+      const event = publishTimeTravel(
+        "rewound",
+        cursor,
+        attempt.previousCursor,
+        "retained",
+        attempt.previousSource,
+        "command"
+      );
+      return {
+        status: "rewound",
+        cursor,
+        source: "retained",
+        previousCursor: attempt.previousCursor,
+        previousSource: attempt.previousSource,
+        changedAt: event.observedAt
+      };
+    },
+    returnToLive() {
+      if (!timeTravelEnabled) return null;
+      const previous = snapshotHistory.returnToLive(restoreGraphData);
+      if (previous === null) return null;
+      projectionFailureRevision += 1;
+      const event = publishTimeTravel(
+        "live",
+        null,
+        previous.previousCursor,
+        null,
+        previous.previousSource,
+        "command"
+      );
+      return {
+        status: "live",
+        cursor: null,
+        previousCursor: previous.previousCursor,
+        previousSource: previous.previousSource,
+        reason: "command",
+        changedAt: event.observedAt
+      };
+    },
+    inspectHistoryImport(candidate) {
+      if (disposed) {
+        return { status: "rejected", reason: "disposed", message: "DevTools controller is disposed" };
+      }
+      if (!timeTravelEnabled) {
+        return {
+          status: "rejected",
+          reason: "time-travel-unavailable",
+          message: "Time travel is disabled for this controller"
+        };
+      }
+      return snapshotHistory.inspectImport(candidate, storeId);
+    },
+    confirmHistoryImport(candidateId, cursor) {
+      if (disposed) {
+        return { status: "rejected", reason: "disposed", message: "DevTools controller is disposed" };
+      }
+      if (!timeTravelEnabled) {
+        return {
+          status: "rejected",
+          reason: "time-travel-unavailable",
+          message: "Time travel is disabled for this controller"
+        };
+      }
+      const attempt = snapshotHistory.restoreImport(
+        candidateId,
+        cursor,
+        store.getState(),
+        restoreGraphData
+      );
+      if (attempt.status === "candidate-not-found") {
+        return {
+          status: "rejected",
+          reason: "candidate-not-found",
+          message: `Import candidate ${candidateId} is no longer awaiting confirmation`
+        };
+      }
+      if (attempt.status === "snapshot-not-found") {
+        return {
+          status: "rejected",
+          reason: "snapshot-not-found",
+          message: `Import candidate ${candidateId} does not contain cursor ${cursor}`
+        };
+      }
+      if (attempt.status === "restore-failed") {
+        return {
+          status: "rejected",
+          reason: "restore-failed",
+          message: `Import candidate ${candidateId} could not be restored through the graph boundary`
+        };
+      }
+      projectionFailureRevision += 1;
+      const event = publishTimeTravel(
+        "rewound",
+        cursor,
+        attempt.previousCursor,
+        "import",
+        attempt.previousSource,
+        "import"
+      );
+      const receipt = {
+        status: "rewound",
+        source: "import",
+        candidateId,
+        cursor,
+        previousCursor: attempt.previousCursor,
+        previousSource: attempt.previousSource,
+        changedAt: event.observedAt
+      };
+      return receipt;
+    },
+    clearHistory() {
+      history.length = 0;
+      historySizes.length = 0;
+      retainedBytes = 0;
+      snapshotHistory.clear();
+    },
+    subscribe(listener, replay = false) {
+      if (disposed) return () => {
+      };
+      if (replay) {
+        for (const event of [...history]) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+      }
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    connect(clientId = `client-${nextClientNumber++}`) {
+      if (disposed) return createDisposedTransport(storeId, clientId);
+      activeClients += 1;
+      publishLifecycle("client-connected", clientId);
+      let closed = false;
+      const connectionSubscriptions = /* @__PURE__ */ new Set();
+      return {
+        request(command) {
+          if (closed) {
+            const parsed = parseCommand(command);
+            return Promise.resolve(resultError(
+              storeId,
+              parsed?.requestId ?? "closed",
+              "disposed",
+              "DevTools client is disconnected"
+            ));
+          }
+          return Promise.resolve(controller.handleCommand(command));
+        },
+        subscribe(listener) {
+          if (closed) return () => {
+          };
+          const unsubscribe = controller.subscribe(listener);
+          connectionSubscriptions.add(unsubscribe);
+          return () => {
+            connectionSubscriptions.delete(unsubscribe);
+            unsubscribe();
+          };
+        },
+        close() {
+          if (closed) return;
+          closed = true;
+          for (const unsubscribe of connectionSubscriptions) unsubscribe();
+          connectionSubscriptions.clear();
+          activeClients = Math.max(0, activeClients - 1);
+          publishLifecycle("client-disconnected", clientId);
+        }
+      };
+    },
+    handleCommand(command) {
+      const parsed = parseCommand(command);
+      const requestId = parsed?.requestId ?? "invalid";
+      if (disposed) return resultError(storeId, requestId, "disposed", "DevTools controller is disposed");
+      if (!parsed) return resultError(storeId, requestId, "invalid-envelope", "Invalid DevTools command envelope");
+      if (parsed.version !== GRAPH_DEVTOOLS_PROTOCOL_VERSION) {
+        return resultError(storeId, parsed.requestId, "unsupported-version", `Unsupported DevTools protocol version ${parsed.version}`);
+      }
+      if (parsed.storeId !== storeId) {
+        return resultError(storeId, parsed.requestId, "wrong-store", `Command targets ${parsed.storeId}, not ${storeId}`);
+      }
+      let result;
+      switch (parsed.command) {
+        case "get-capabilities":
+          result = capabilities;
+          break;
+        case "get-snapshot":
+          result = controller.getSnapshot();
+          break;
+        case "get-history":
+          result = controller.getHistory();
+          break;
+        case "get-history-status":
+          result = controller.getHistoryStatus();
+          break;
+        case "get-entity-records":
+          result = controller.getEntityRecords();
+          break;
+        case "get-views":
+          result = controller.getViews();
+          break;
+        case "get-relationships":
+          result = controller.getRelationships();
+          break;
+        case "get-time-travel-status": {
+          if (!timeTravelEnabled) return resultError(storeId, parsed.requestId, "time-travel-unavailable", "Time travel is disabled for this controller");
+          result = controller.getSnapshotHistoryStatus();
+          break;
+        }
+        case "rewind": {
+          if (!timeTravelEnabled) return resultError(storeId, parsed.requestId, "time-travel-unavailable", "Time travel is disabled for this controller");
+          const payload = parseRewindPayload(parsed.payload);
+          if (!payload) return resultError(storeId, parsed.requestId, "invalid-payload", "Invalid rewind payload");
+          const receipt = controller.rewind(payload.cursor);
+          if (!receipt) return resultError(storeId, parsed.requestId, "snapshot-not-found", `Snapshot cursor ${payload.cursor} is not retained`);
+          result = receipt;
+          break;
+        }
+        case "return-to-live": {
+          if (!timeTravelEnabled) return resultError(storeId, parsed.requestId, "time-travel-unavailable", "Time travel is disabled for this controller");
+          const receipt = controller.returnToLive();
+          if (!receipt) return resultError(storeId, parsed.requestId, "not-rewound", "The graph is already live");
+          result = receipt;
+          break;
+        }
+        case "inspect-history-import": {
+          if (!timeTravelEnabled) return resultError(storeId, parsed.requestId, "time-travel-unavailable", "Time travel is disabled for this controller");
+          const payload = parseInspectHistoryImportPayload(parsed.payload);
+          if (!payload) return resultError(storeId, parsed.requestId, "invalid-payload", "Invalid history import inspection payload");
+          result = controller.inspectHistoryImport(payload.candidate);
+          break;
+        }
+        case "confirm-history-import": {
+          if (!timeTravelEnabled) return resultError(storeId, parsed.requestId, "time-travel-unavailable", "Time travel is disabled for this controller");
+          const payload = parseConfirmHistoryImportPayload(parsed.payload);
+          if (!payload) return resultError(storeId, parsed.requestId, "invalid-payload", "Invalid history import confirmation payload");
+          if (!payload.confirm) return resultError(storeId, parsed.requestId, "confirmation-required", "History import restore requires confirm: true");
+          result = controller.confirmHistoryImport(payload.candidateId, payload.cursor);
+          break;
+        }
+        case "preview-entity-patch": {
+          const payload = parsePreviewPayload(parsed.payload);
+          if (!payload) return resultError(storeId, parsed.requestId, "invalid-payload", "Invalid entity preview payload");
+          const receipt = previewController.apply(payload.type, payload.id, payload.patch);
+          if (!receipt) return resultError(storeId, parsed.requestId, "entity-not-found", `Entity ${payload.type}:${payload.id} was not found`);
+          result = receipt;
+          break;
+        }
+        case "restore-entity-preview": {
+          const payload = parseRestorePreviewPayload(parsed.payload);
+          if (!payload) return resultError(storeId, parsed.requestId, "invalid-payload", "Invalid preview restore payload");
+          const receipt = previewController.restore(payload.previewId);
+          if (!receipt) return resultError(storeId, parsed.requestId, "preview-not-found", `Preview ${payload.previewId} was not found`);
+          result = receipt;
+          break;
+        }
+        case "clear-history":
+          controller.clearHistory();
+          result = { cleared: true };
+          break;
+        default:
+          return resultError(storeId, parsed.requestId, "unsupported-command", `Unsupported DevTools command ${parsed.command}`);
+      }
+      return {
+        protocol: GRAPH_DEVTOOLS_PROTOCOL,
+        version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+        requestId: parsed.requestId,
+        storeId,
+        ok: true,
+        result
+      };
+    },
+    isDisposed() {
+      return disposed;
+    }
+  };
+  const unregisterCompatibility = registerGraphDevtoolsCompatibilityDelegate(store, {
+    configure(capacity) {
+      controller.configureSnapshotLimit(capacity);
+    },
+    capture(label) {
+      return controller.captureCompatibilitySnapshot(label);
+    },
+    restoreByIndex(index) {
+      if (!Number.isInteger(index)) return false;
+      const reference = controller.getCompatibilitySnapshotReferences()[index];
+      if (!reference) return false;
+      return controller.rewind(reference.cursor)?.status === "rewound";
+    },
+    restoreByCursor(cursor) {
+      return controller.rewind(cursor)?.status === "rewound";
+    },
+    step(delta) {
+      if (!Number.isInteger(delta)) return false;
+      const references = controller.getCompatibilitySnapshotReferences();
+      if (references.length === 0) return false;
+      const status = controller.getSnapshotHistoryStatus();
+      const activeIndex = status.source === "retained" && status.cursor !== null ? references.findIndex((reference) => reference.cursor === status.cursor) : -1;
+      const base = activeIndex === -1 ? references.length - 1 : activeIndex;
+      const target = Math.max(0, Math.min(references.length - 1, base + delta));
+      return controller.rewind(references[target].cursor)?.status === "rewound";
+    },
+    getState() {
+      const references = controller.getCompatibilitySnapshotReferences();
+      const status = controller.getSnapshotHistoryStatus();
+      const cursor = status.source === "retained" && status.cursor !== null ? references.findIndex((reference) => reference.cursor === status.cursor) : -1;
+      return {
+        snapshots: references.map((reference) => ({
+          seq: reference.cursor,
+          at: Date.parse(reference.capturedAt),
+          ...reference.label !== void 0 ? { label: reference.label } : {}
+        })),
+        cursor: cursor === -1 ? null : cursor,
+        capacity: status.snapshotLimit
+      };
+    },
+    subscribe(listener) {
+      return controller.subscribeSnapshotHistory(listener);
+    },
+    clear() {
+      controller.clearSnapshotHistory();
+    }
+  });
+  const dispose = () => {
+    if (disposed) return;
+    activeClients = 0;
+    publishLifecycle("disposed");
+    disposed = true;
+    unregisterCompatibility();
+    unsubscribeStore();
+    listeners.clear();
+    history.length = 0;
+    historySizes.length = 0;
+    retainedBytes = 0;
+    entityRevisions.clear();
+    entityValueRevisions.clear();
+    viewRegistry.dispose();
+    previewController.dispose();
+    snapshotHistory.dispose();
+  };
+  publishLifecycle("attached");
+  return { controller, dispose };
+}
+function createDisposedTransport(storeId, clientId) {
+  return {
+    request(command) {
+      const parsed = parseCommand(command);
+      return Promise.resolve(resultError(
+        storeId,
+        parsed?.requestId ?? clientId,
+        "disposed",
+        "DevTools controller is disposed"
+      ));
+    },
+    subscribe() {
+      return () => {
+      };
+    },
+    close() {
+    }
+  };
+}
+function attachGraphDevtools(store, options = {}) {
+  if (options.enabled === false) {
+    return { enabled: false, controller: null, detach() {
+    } };
+  }
+  let entry = controllers.get(store);
+  if (!entry || entry.controller.isDisposed()) {
+    entry = { ...createController(store, options), references: 0 };
+    controllers.set(store, entry);
+  }
+  entry.references += 1;
+  let detached = false;
+  return {
+    enabled: true,
+    controller: entry.controller,
+    detach() {
+      if (detached) return;
+      detached = true;
+      const current = controllers.get(store);
+      if (!current || current.controller !== entry?.controller) return;
+      current.references = Math.max(0, current.references - 1);
+      if (current.references === 0) {
+        current.dispose();
+        controllers.delete(store);
+      }
+    }
+  };
+}
+function getGraphDevtoolsController(store) {
+  const entry = controllers.get(store);
+  return entry && !entry.controller.isDisposed() ? entry.controller : null;
+}
+registerGraphDevtoolsCompatibilityFactory((store) => {
+  const attachment = attachGraphDevtools(store);
+  return () => attachment.detach();
+});
+
+// src/devtools/client.ts
+var nextRequest = 1;
+function createGraphDevtoolsClient(storeId, transport) {
+  let disconnected = false;
+  return {
+    storeId,
+    request(command, payload) {
+      const requestId = `request-${nextRequest++}`;
+      return transport.request({
+        protocol: GRAPH_DEVTOOLS_PROTOCOL,
+        version: GRAPH_DEVTOOLS_PROTOCOL_VERSION,
+        requestId,
+        storeId,
+        command,
+        ...payload !== void 0 ? { payload } : {}
+      });
+    },
+    subscribe(listener) {
+      if (disconnected) return () => {
+      };
+      return transport.subscribe(listener);
+    },
+    disconnect() {
+      if (disconnected) return;
+      disconnected = true;
+      transport.close();
+    }
+  };
+}
+
+exports.GRAPH_DEVTOOLS_PROTOCOL = GRAPH_DEVTOOLS_PROTOCOL;
+exports.GRAPH_DEVTOOLS_PROTOCOL_VERSION = GRAPH_DEVTOOLS_PROTOCOL_VERSION;
+exports.attachGraphDevtools = attachGraphDevtools;
+exports.createGraphDevtoolsClient = createGraphDevtoolsClient;
+exports.getGraphDevtoolsController = getGraphDevtoolsController;
+exports.projectGraphDevtoolsEntityRecords = projectGraphDevtoolsEntityRecords;
+exports.projectGraphDevtoolsRelationships = projectGraphDevtoolsRelationships;
+//# sourceMappingURL=devtools.cjs.map
+//# sourceMappingURL=devtools.cjs.map