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

package/dist/devtools.mjs

@@ -0,0 +1,2019 @@
+import { registerGraphDevtoolsCompatibilityFactory, registerGraphDevtoolsCompatibilityDelegate, getRegisteredSchemas, serializeKey, EMPTY_ENTITY_STATE, EMPTY_SYNC_METADATA, EMPTY_LIST_STATE } from './chunk-BE3BMRKF.mjs';
+
+// src/devtools/protocol.ts
+var GRAPH_DEVTOOLS_PROTOCOL = "prometheus.entity-graph.devtools";
+var GRAPH_DEVTOOLS_PROTOCOL_VERSION = 1;
+
+// 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/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/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 notify = () => {
+    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);
+        notify();
+        return reference2;
+      }
+      let data;
+      let bytes;
+      try {
+        data = cloneGraphData(state);
+        bytes = encodedBytes(data);
+      } catch {
+        const reference2 = unavailable(cursor, capturedAt, eventSequence, "capture-failed", label);
+        notify();
+        return reference2;
+      }
+      if (bytes > options.snapshotBytesLimit) {
+        const unavailableReference = unavailable(cursor, capturedAt, eventSequence, "oversize", label);
+        notify();
+        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;
+      }
+      notify();
+      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);
+        notify();
+        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) notify();
+      return result;
+    },
+    inspectImport(candidate, storeId) {
+      importedCandidate = null;
+      const rejected = (reason, message) => {
+        notify();
+        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 };
+        notify();
+        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;
+      notify();
+      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;
+      notify();
+      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;
+      notify();
+      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;
+      }
+      notify();
+    },
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    clear() {
+      retained.length = 0;
+      compatibilityLabels.clear();
+      retainedBytes = 0;
+      clearedThroughCursor = latestCursor;
+      importedCandidate = null;
+      notify();
+    },
+    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();
+    }
+  };
+}
+
+export { GRAPH_DEVTOOLS_PROTOCOL, GRAPH_DEVTOOLS_PROTOCOL_VERSION, attachGraphDevtools, createGraphDevtoolsClient, getGraphDevtoolsController, projectGraphDevtoolsEntityRecords, projectGraphDevtoolsRelationships };
+//# sourceMappingURL=devtools.mjs.map
+//# sourceMappingURL=devtools.mjs.map