@remnic/core 9.69.38 → 9.69.40

package/src/testing/subjects/startup-discovery-lifecycle.test.ts

@@ -0,0 +1,273 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { parseConfig } from "../../config.js";
+import { Orchestrator } from "../../orchestrator.js";
+import { type LifecycleSubject, type MatrixRow, runLifecycleMatrix } from "../lifecycle-matrix.js";
+
+interface DynamicNamespaceRecord {
+  namespace: string;
+  identityToken: string;
+  kind: "project";
+  createdAt: string;
+  storageDir: string;
+  discoveredBy: "write";
+}
+
+interface StartupDiscoveryLifecycleState {
+  readonly memoryDir: string;
+  readonly configuredNamespaces: string[];
+  readonly dynamicRecord: DynamicNamespaceRecord;
+  readonly firstChecks: string[];
+  readonly secondChecks: string[];
+  readonly orchestrators: Orchestrator[];
+  readonly originalTimeout: string | undefined;
+  readonly firstQmd: object;
+  releaseFirstDiscovery: ((records: unknown[]) => void) | undefined;
+  firstInitSettled?: boolean;
+  firstInitGateSettled?: boolean;
+  firstDiscoveryTimedOut?: boolean;
+  firstWasFailOpen?: boolean;
+  secondInitSettled?: boolean;
+  secondInitGateSettled?: boolean;
+  secondWasFailOpen?: boolean;
+  firstChecksBeforeRelease?: string[];
+  secondChecksBeforeRelease?: string[];
+}
+
+async function withTestDeadline<T>(
+  promise: Promise<T>,
+  timeoutMs = 1_500,
+): Promise<T | "deadline"> {
+  let timer: NodeJS.Timeout | undefined;
+  const deadline = new Promise<"deadline">((resolve) => {
+    timer = setTimeout(() => resolve("deadline"), timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([promise, deadline]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+function startupDiscoveryConfig(memoryDir: string) {
+  return parseConfig({
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    qmdEnabled: true,
+    qmdMaintenanceEnabled: false,
+    namespacesEnabled: true,
+    namespaceCatalogEnabled: true,
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+    embeddingFallbackEnabled: false,
+    identityContinuityEnabled: false,
+    transcriptEnabled: false,
+    hourlySummariesEnabled: false,
+    compoundingEnabled: false,
+    knowledgeIndexEnabled: false,
+  });
+}
+
+function enabledQmd(): object {
+  return {
+    probe: async () => true,
+    debugStatus: () => "startup-discovery-lifecycle-qmd",
+    isAvailable: () => true,
+    search: async () => [],
+  };
+}
+
+function installCollectionCheckRecorder(orchestrator: Orchestrator, checks: string[]): void {
+  const internal = orchestrator as any;
+  internal.namespaceSearchRouter.clearCache = () => undefined;
+  internal.namespaceSearchRouter.ensureNamespaceCollection = async (namespace: string) => {
+    checks.push(namespace);
+    return "present";
+  };
+}
+
+async function initializeWithGate(orchestrator: Orchestrator): Promise<{
+  initialize: "settled" | "deadline";
+  initGate: "settled" | "deadline";
+}> {
+  const initPromise = (orchestrator as any).initPromise as Promise<void>;
+  const [initialize, initGate] = await Promise.all([
+    withTestDeadline(orchestrator.initialize().then(() => "settled" as const)),
+    withTestDeadline(initPromise.then(() => "settled" as const)),
+  ]);
+  return { initialize, initGate };
+}
+
+const subject: LifecycleSubject<StartupDiscoveryLifecycleState> = {
+  appliesTo(row: MatrixRow): boolean | string {
+    switch (row.id) {
+      case "restart-reload-recovery":
+        return true;
+      case "explicit-provider-identity":
+        return "startup discovery accepts configured/catalog namespaces, not a session/provider identity";
+      case "sparse-metadata-with-binding":
+        return "startup discovery has no session metadata or remembered provider/session binding contract";
+      case "sparse-metadata-without-binding":
+        return "startup discovery has no sparse session metadata resolution surface";
+      case "provider-rebinding":
+        return "startup discovery neither owns nor mutates a provider binding";
+      case "compaction-flush":
+        return "startup discovery has no compaction or flush operation";
+      case "before-reset":
+        return "startup timeout is a readiness boundary, not a buffer before_reset flush";
+      case "session-end":
+        return "startup discovery has no session-end transition or shutdown-drain contract";
+      case "dedupe-replay":
+        return "ignoring a late discovery result is a stale-startup boundary, not a dedupe or replay contract";
+    }
+  },
+
+  async setup(): Promise<StartupDiscoveryLifecycleState> {
+    const originalTimeout = process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+    const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-startup-discovery-lifecycle-"));
+    const orchestrators: Orchestrator[] = [];
+    const firstChecks: string[] = [];
+    const secondChecks: string[] = [];
+    const dynamicRecord: DynamicNamespaceRecord = {
+      namespace: "dynamic",
+      identityToken: "dynamic",
+      kind: "project",
+      createdAt: new Date(0).toISOString(),
+      storageDir: path.join(memoryDir, "namespaces", "dynamic"),
+      discoveredBy: "write",
+    };
+    let releaseFirstDiscovery: ((records: unknown[]) => void) | undefined;
+
+    try {
+      process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = "1000";
+      const first = new Orchestrator(startupDiscoveryConfig(memoryDir));
+      orchestrators.push(first);
+      const firstQmd = enabledQmd();
+      (first as any).qmd = firstQmd;
+      await mkdir(path.join(dynamicRecord.storageDir, "state"), { recursive: true });
+      (first as any).passiveCorrectionService = () => ({
+        recoverStaleApplyingPlans: async () => 0,
+      });
+      let firstCatalogCalls = 0;
+      const firstDiscovery = new Promise<unknown[]>((resolve) => {
+        releaseFirstDiscovery = resolve;
+      });
+      (first as any).namespaceCatalog.listNamespaces = () => {
+        firstCatalogCalls += 1;
+        return firstCatalogCalls === 1 ? Promise.resolve([dynamicRecord]) : firstDiscovery;
+      };
+      installCollectionCheckRecorder(first, firstChecks);
+      const configuredNamespaces = (first as any).configuredNamespaceList() as string[];
+
+      return {
+        memoryDir,
+        configuredNamespaces,
+        dynamicRecord,
+        firstChecks,
+        secondChecks,
+        orchestrators,
+        originalTimeout,
+        firstQmd,
+        releaseFirstDiscovery,
+      };
+    } catch (error) {
+      releaseFirstDiscovery?.([dynamicRecord]);
+      if (originalTimeout === undefined) delete process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+      else process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = originalTimeout;
+      await Promise.all(orchestrators.map((orchestrator) => orchestrator.destroy().catch(() => undefined)));
+      await rm(memoryDir, { recursive: true, force: true });
+      throw error;
+    }
+  },
+
+  async exercise(state: StartupDiscoveryLifecycleState): Promise<void> {
+    const first = state.orchestrators[0];
+    assert.ok(first, "the first startup epoch must exist");
+    const firstResult = await initializeWithGate(first);
+    state.firstInitSettled = firstResult.initialize === "settled";
+    state.firstInitGateSettled = firstResult.initGate === "settled";
+    state.firstDiscoveryTimedOut = state.firstChecks.length === state.configuredNamespaces.length;
+    state.firstWasFailOpen = (first as any).qmd === state.firstQmd;
+
+    assert.equal(firstResult.initialize, "settled", "initial startup must not wait forever for catalog discovery");
+    assert.equal(firstResult.initGate, "settled", "the real initPromise gate must settle after fallback discovery");
+    assert.deepEqual(
+      state.firstChecks,
+      state.configuredNamespaces,
+      "the timed-out first epoch must check only configured namespaces",
+    );
+    assert.equal(state.firstWasFailOpen, true, "an unknown startup check must keep QMD enabled fail-open");
+
+    await first.destroy();
+
+    const second = new Orchestrator(startupDiscoveryConfig(state.memoryDir));
+    state.orchestrators.push(second);
+    const secondQmd = enabledQmd();
+    (second as any).qmd = secondQmd;
+    (second as any).passiveCorrectionService = () => ({
+      recoverStaleApplyingPlans: async () => 0,
+    });
+    (second as any).namespaceCatalog.listNamespaces = () => Promise.resolve([state.dynamicRecord]);
+    installCollectionCheckRecorder(second, state.secondChecks);
+
+    const secondResult = await initializeWithGate(second);
+    state.secondInitSettled = secondResult.initialize === "settled";
+    state.secondInitGateSettled = secondResult.initGate === "settled";
+    state.secondWasFailOpen = (second as any).qmd === secondQmd;
+    const completeNamespaces = [...state.configuredNamespaces, state.dynamicRecord.namespace];
+
+    assert.equal(secondResult.initialize, "settled", "a fresh reload must initialize after complete discovery");
+    assert.equal(secondResult.initGate, "settled", "the fresh instance's init gate must settle");
+    assert.deepEqual(
+      state.secondChecks,
+      completeNamespaces,
+      "the fresh epoch must discover and check the dynamic namespace",
+    );
+    assert.equal(state.secondWasFailOpen, true, "the fresh instance must retain its enabled QMD facade");
+
+    state.firstChecksBeforeRelease = [...state.firstChecks];
+    state.secondChecksBeforeRelease = [...state.secondChecks];
+    state.releaseFirstDiscovery?.([state.dynamicRecord]);
+    await Promise.resolve();
+    await Promise.resolve();
+  },
+
+  async invariants(state: StartupDiscoveryLifecycleState): Promise<void> {
+    assert.equal(state.firstInitSettled, true);
+    assert.equal(state.firstInitGateSettled, true);
+    assert.equal(state.firstDiscoveryTimedOut, true);
+    assert.equal(state.firstWasFailOpen, true);
+    assert.deepEqual(state.firstChecksBeforeRelease, state.configuredNamespaces);
+    assert.deepEqual(
+      state.firstChecks,
+      state.firstChecksBeforeRelease,
+      "the old catalog promise must not stage a stale dynamic check after its epoch is destroyed",
+    );
+
+    const completeNamespaces = [...state.configuredNamespaces, state.dynamicRecord.namespace];
+    assert.equal(state.secondInitSettled, true);
+    assert.equal(state.secondInitGateSettled, true);
+    assert.equal(state.secondWasFailOpen, true);
+    assert.deepEqual(state.secondChecksBeforeRelease, completeNamespaces);
+    assert.deepEqual(
+      state.secondChecks,
+      state.secondChecksBeforeRelease,
+      "releasing the old epoch must not schedule collection work on the fresh instance",
+    );
+  },
+
+  async teardown(state: StartupDiscoveryLifecycleState): Promise<void> {
+    state.releaseFirstDiscovery?.([state.dynamicRecord]);
+    if (state.originalTimeout === undefined) delete process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+    else process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = state.originalTimeout;
+    await Promise.all(state.orchestrators.map((orchestrator) => orchestrator.destroy().catch(() => undefined)));
+    await rm(state.memoryDir, { recursive: true, force: true });
+  },
+};
+
+runLifecycleMatrix("startup-discovery-lifecycle", subject);

package/src/trust-score-recall-paths.test.ts

@@ -175,7 +175,7 @@ test("TrustScore quarantine excludes a contradicted memory from injection but su
 
 test("X-ray capture preserves recent-scan serving while recording post-trust applied and pre-trust headroom", async () => {
   const { orchestrator, memoryDir } = await makeOrchestrator({
-    qmdMaxResults: 2,
+    qmdMaxResults: 1,
   });
   const now = Date.now();
   try {

package/src/types.ts

@@ -1541,6 +1541,7 @@ export interface PluginConfig
   workProjectIndexEnabled: boolean;
   workIndexAutoRebuildEnabled: boolean;
   workIndexAutoRebuildDebounceMs: number;
+
   // Observability
   /** If true, log slow operations (local LLM + related I/O) with durations and metadata (no content). */
   slowLogEnabled: boolean;

package/dist/chunk-255PC37A.js

@@ -1,120 +0,0 @@
-import {
-  coerceBooleanLike
-} from "./chunk-PQVCH2AE.js";
-
-// src/recall-state-view.ts
-var DEFAULT_RECALL_STATE_VIEWS = false;
-var CHANGE_WORDS = ["switch", "switches", "switched", "switching", "change", "changes", "changed", "changing"];
-var CHANGE_PHRASE_RE = /\bwhen\s+did\b|\bused\s+to\b/;
-var CHANGE_WORD_RE = new RegExp(`\\b(?:${CHANGE_WORDS.join("|")})\\b`);
-var EVENT_POINTER_RE = /\b(?:before|after)\s+(?:the|a|an|this|that|these|those)\b/;
-function parseRecallStateViews(raw) {
-  return coerceBooleanLike(raw, "recallStateViews") === true;
-}
-function isChangeOrientedQuery(query) {
-  const lower = query.toLowerCase();
-  return CHANGE_PHRASE_RE.test(lower) || CHANGE_WORD_RE.test(lower) || EVENT_POINTER_RE.test(lower);
-}
-function shouldWidenSuperseded(successorId, candidateIds) {
-  return typeof successorId === "string" && successorId.length > 0 && candidateIds.has(successorId);
-}
-function formatSupersededPrefix(date, successorId) {
-  return `[superseded ${date} by ${successorId}]`;
-}
-function resultStateViewId(result) {
-  return result.id ?? result.docid ?? "";
-}
-function buildSuccessorMap(results, chains) {
-  const byPred = /* @__PURE__ */ new Map();
-  for (const chain of chains) {
-    if (chain.predecessorId && chain.successorId) {
-      byPred.set(chain.predecessorId, chain.successorId);
-    }
-  }
-  for (const result of results) {
-    const id = resultStateViewId(result);
-    if (id && result.supersededBy) byPred.set(id, result.supersededBy);
-  }
-  return byPred;
-}
-function labelFor(id, result, byPred, admittedIds, asOfMs) {
-  const successorId = result.supersededBy ?? byPred.get(id);
-  const isPred = shouldWidenSuperseded(successorId, admittedIds);
-  let isSucc = false;
-  for (const [predId, succId] of byPred) {
-    if (succId === id && admittedIds.has(predId)) {
-      isSucc = true;
-      break;
-    }
-  }
-  if (isPred && isSucc) return "transition";
-  if (isPred) return "historical";
-  if (isSucc) return "current";
-  if (result.status === "superseded") {
-    return asOfMs === null ? "historical" : snapshotStateLabel(result, asOfMs);
-  }
-  return "current";
-}
-function snapshotStateLabel(result, asOfMs) {
-  const supersededAtMs = Date.parse(result.supersededAt ?? "");
-  return Number.isFinite(supersededAtMs) && supersededAtMs <= asOfMs ? "historical" : "current";
-}
-function annotateStateView(results, query, chains, options = {}) {
-  const enabled = options.enabled === true;
-  if (!enabled || !isChangeOrientedQuery(query)) return results;
-  const asOfMs = typeof options.asOfMs === "number" && Number.isFinite(options.asOfMs) ? options.asOfMs : null;
-  const byPred = buildSuccessorMap(results, chains);
-  const candidateIds = /* @__PURE__ */ new Set();
-  for (const result of results) {
-    const id = resultStateViewId(result);
-    if (id) candidateIds.add(id);
-  }
-  const isSupersededRow = (result) => {
-    const id = resultStateViewId(result);
-    return {
-      superseded: result.status === "superseded" || Boolean(result.supersededBy) || byPred.has(id),
-      successorId: result.supersededBy ?? byPred.get(id)
-    };
-  };
-  let admitted;
-  if (asOfMs !== null) {
-    admitted = results.slice();
-  } else {
-    admitted = [];
-    for (const result of results) {
-      const { superseded, successorId } = isSupersededRow(result);
-      if (!superseded || shouldWidenSuperseded(successorId, candidateIds)) {
-        admitted.push(result);
-      }
-    }
-    let admittedIds2 = new Set(admitted.map(resultStateViewId).filter(Boolean));
-    for (let changed = true; changed; ) {
-      changed = false;
-      for (let i = admitted.length - 1; i >= 0; i -= 1) {
-        const row = admitted[i];
-        const { superseded, successorId } = isSupersededRow(row);
-        if (superseded && !shouldWidenSuperseded(successorId, admittedIds2)) {
-          admitted.splice(i, 1);
-          changed = true;
-        }
-      }
-      if (changed) admittedIds2 = new Set(admitted.map(resultStateViewId).filter(Boolean));
-    }
-  }
-  const admittedIds = new Set(admitted.map(resultStateViewId).filter(Boolean));
-  return admitted.map((result) => {
-    const id = resultStateViewId(result);
-    return { ...result, stateLabel: labelFor(id, result, byPred, admittedIds, asOfMs) };
-  });
-}
-
-export {
-  DEFAULT_RECALL_STATE_VIEWS,
-  parseRecallStateViews,
-  isChangeOrientedQuery,
-  shouldWidenSuperseded,
-  formatSupersededPrefix,
-  resultStateViewId,
-  annotateStateView
-};
-//# sourceMappingURL=chunk-255PC37A.js.map

package/dist/chunk-255PC37A.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/recall-state-view.ts"],"sourcesContent":["/**\n * Recall state views (issue #1952).\n *\n * Config key: `recallStateViews` (default false). When false, annotateStateView\n * is identity: same array reference, no `stateLabel`. config.ts is at its\n * fileSizeGrandfather ceiling, so parseConfig wiring waits for a later PR.\n * Call `parseRecallStateViews` at the recall seam when that lands.\n *\n * Change-intent morphology lives here (do not grow intent.ts). A superseded\n * memory is admitted only when its successor is also in the candidate set.\n */\nimport { coerceBooleanLike } from \"./connectors/coerce.js\";\n\nexport type StateLabel = \"current\" | \"historical\" | \"transition\";\n\nexport interface StateViewChain {\n  predecessorId: string;\n  successorId: string;\n  supersededAt?: string;\n}\n\nexport interface StateViewResult {\n  id?: string;\n  docid?: string;\n  status?: string;\n  supersededBy?: string;\n  supersededAt?: string;\n  stateLabel?: StateLabel;\n}\n\nexport const DEFAULT_RECALL_STATE_VIEWS = false;\n\nconst CHANGE_WORDS = [\"switch\", \"switches\", \"switched\", \"switching\", \"change\", \"changes\", \"changed\", \"changing\"];\n\n// Phrase matches are token-bounded: \"when Didi\" must not fire the\n// \"when did\" phrase, and \"confused to\" must not fire \"used to\".\nconst CHANGE_PHRASE_RE = /\\bwhen\\s+did\\b|\\bused\\s+to\\b/;\nconst CHANGE_WORD_RE = new RegExp(`\\\\b(?:${CHANGE_WORDS.join(\"|\")})\\\\b`);\n// Bare \"before\"/\"after\" are ordinary sequencing (\"before lunch\",\n// \"after install\"). They carry change intent only when they point at a\n// specific event through a determiner (\"before the move\", \"after the\n// cutover\").\nconst EVENT_POINTER_RE = /\\b(?:before|after)\\s+(?:the|a|an|this|that|these|those)\\b/;\n\nexport function parseRecallStateViews(raw: unknown): boolean {\n  return coerceBooleanLike(raw, \"recallStateViews\") === true;\n}\n\nexport function isChangeOrientedQuery(query: string): boolean {\n  const lower = query.toLowerCase();\n  return CHANGE_PHRASE_RE.test(lower) || CHANGE_WORD_RE.test(lower) || EVENT_POINTER_RE.test(lower);\n}\n\nexport function shouldWidenSuperseded(\n  successorId: string | undefined,\n  candidateIds: ReadonlySet<string>,\n): boolean {\n  return typeof successorId === \"string\" && successorId.length > 0 && candidateIds.has(successorId);\n}\n\nexport function formatSupersededPrefix(date: string, successorId: string): string {\n  return `[superseded ${date} by ${successorId}]`;\n}\n\nexport function resultStateViewId(result: StateViewResult): string {\n  return result.id ?? result.docid ?? \"\";\n}\n\nfunction buildSuccessorMap(results: readonly StateViewResult[], chains: readonly StateViewChain[]): Map<string, string> {\n  const byPred = new Map<string, string>();\n  for (const chain of chains) {\n    if (chain.predecessorId && chain.successorId) {\n      byPred.set(chain.predecessorId, chain.successorId);\n    }\n  }\n  for (const result of results) {\n    const id = resultStateViewId(result);\n    if (id && result.supersededBy) byPred.set(id, result.supersededBy);\n  }\n  return byPred;\n}\n\nfunction labelFor(\n  id: string,\n  result: StateViewResult,\n  byPred: Map<string, string>,\n  admittedIds: ReadonlySet<string>,\n  asOfMs: number | null,\n): StateLabel {\n  const successorId = result.supersededBy ?? byPred.get(id);\n  const isPred = shouldWidenSuperseded(successorId, admittedIds);\n  let isSucc = false;\n  for (const [predId, succId] of byPred) {\n    if (succId === id && admittedIds.has(predId)) {\n      isSucc = true;\n      break;\n    }\n  }\n  if (isPred && isSucc) return \"transition\";\n  if (isPred) return \"historical\";\n  if (isSucc) return \"current\";\n  if (result.status === \"superseded\") {\n    // #1952 asOf mode: the successor is legitimately absent under the\n    // historical pin. The row was the live fact at the snapshot when the\n    // recorded supersession postdates the pin (\"current\" relative to\n    // the snapshot); already replaced at the pin is \"historical\".\n    return asOfMs === null ? \"historical\" : snapshotStateLabel(result, asOfMs);\n  }\n  return \"current\";\n}\n\nfunction snapshotStateLabel(result: StateViewResult, asOfMs: number): StateLabel {\n  const supersededAtMs = Date.parse(result.supersededAt ?? \"\");\n  return Number.isFinite(supersededAtMs) && supersededAtMs <= asOfMs\n    ? \"historical\"\n    : \"current\";\n}\n\nexport function annotateStateView<T extends StateViewResult>(\n  results: T[],\n  query: string,\n  chains: readonly StateViewChain[],\n  options: { enabled?: boolean; asOfMs?: number } = {},\n): T[] {\n  const enabled = options.enabled === true;\n  if (!enabled || !isChangeOrientedQuery(query)) return results;\n  // #1952 asOf mode: under a historical pin the pipeline's isValidAsOf\n  // gate already decided validity at the pinned instant, so a predecessor\n  // must not be discarded merely because its successor is absent under\n  // the same filter. A valid asOf result is never emptied here.\n  const asOfMs =\n    typeof options.asOfMs === \"number\" && Number.isFinite(options.asOfMs)\n      ? options.asOfMs\n      : null;\n\n  const byPred = buildSuccessorMap(results, chains);\n  const candidateIds = new Set<string>();\n  for (const result of results) {\n    const id = resultStateViewId(result);\n    if (id) candidateIds.add(id);\n  }\n\n  const isSupersededRow = (result: T): { superseded: boolean; successorId: string | undefined } => {\n    const id = resultStateViewId(result);\n    return {\n      superseded: result.status === \"superseded\" || Boolean(result.supersededBy) || byPred.has(id),\n      successorId: result.supersededBy ?? byPred.get(id),\n    };\n  };\n\n  let admitted: T[];\n  if (asOfMs !== null) {\n    admitted = results.slice();\n  } else {\n    admitted = [];\n    for (const result of results) {\n      const { superseded, successorId } = isSupersededRow(result);\n      if (!superseded || shouldWidenSuperseded(successorId, candidateIds)) {\n        admitted.push(result);\n      }\n    }\n\n    // #1952 contract: superseded never appears without its successor. A\n    // successor can itself be dropped (filtered elsewhere, or transitively\n    // orphaned), so reconcile to a fixpoint instead of trusting the first pass.\n    let admittedIds = new Set(admitted.map(resultStateViewId).filter(Boolean));\n    for (let changed = true; changed; ) {\n      changed = false;\n      for (let i = admitted.length - 1; i >= 0; i -= 1) {\n        const row = admitted[i]!;\n        const { superseded, successorId } = isSupersededRow(row);\n        if (superseded && !shouldWidenSuperseded(successorId, admittedIds)) {\n          admitted.splice(i, 1);\n          changed = true;\n        }\n      }\n      if (changed) admittedIds = new Set(admitted.map(resultStateViewId).filter(Boolean));\n    }\n  }\n\n  const admittedIds = new Set(admitted.map(resultStateViewId).filter(Boolean));\n  return admitted.map((result) => {\n    const id = resultStateViewId(result);\n    return { ...result, stateLabel: labelFor(id, result, byPred, admittedIds, asOfMs) };\n  });\n}\n"],"mappings":";;;;;AA8BO,IAAM,6BAA6B;AAE1C,IAAM,eAAe,CAAC,UAAU,YAAY,YAAY,aAAa,UAAU,WAAW,WAAW,UAAU;AAI/G,IAAM,mBAAmB;AACzB,IAAM,iBAAiB,IAAI,OAAO,SAAS,aAAa,KAAK,GAAG,CAAC,MAAM;AAKvE,IAAM,mBAAmB;AAElB,SAAS,sBAAsB,KAAuB;AAC3D,SAAO,kBAAkB,KAAK,kBAAkB,MAAM;AACxD;AAEO,SAAS,sBAAsB,OAAwB;AAC5D,QAAM,QAAQ,MAAM,YAAY;AAChC,SAAO,iBAAiB,KAAK,KAAK,KAAK,eAAe,KAAK,KAAK,KAAK,iBAAiB,KAAK,KAAK;AAClG;AAEO,SAAS,sBACd,aACA,cACS;AACT,SAAO,OAAO,gBAAgB,YAAY,YAAY,SAAS,KAAK,aAAa,IAAI,WAAW;AAClG;AAEO,SAAS,uBAAuB,MAAc,aAA6B;AAChF,SAAO,eAAe,IAAI,OAAO,WAAW;AAC9C;AAEO,SAAS,kBAAkB,QAAiC;AACjE,SAAO,OAAO,MAAM,OAAO,SAAS;AACtC;AAEA,SAAS,kBAAkB,SAAqC,QAAwD;AACtH,QAAM,SAAS,oBAAI,IAAoB;AACvC,aAAW,SAAS,QAAQ;AAC1B,QAAI,MAAM,iBAAiB,MAAM,aAAa;AAC5C,aAAO,IAAI,MAAM,eAAe,MAAM,WAAW;AAAA,IACnD;AAAA,EACF;AACA,aAAW,UAAU,SAAS;AAC5B,UAAM,KAAK,kBAAkB,MAAM;AACnC,QAAI,MAAM,OAAO,aAAc,QAAO,IAAI,IAAI,OAAO,YAAY;AAAA,EACnE;AACA,SAAO;AACT;AAEA,SAAS,SACP,IACA,QACA,QACA,aACA,QACY;AACZ,QAAM,cAAc,OAAO,gBAAgB,OAAO,IAAI,EAAE;AACxD,QAAM,SAAS,sBAAsB,aAAa,WAAW;AAC7D,MAAI,SAAS;AACb,aAAW,CAAC,QAAQ,MAAM,KAAK,QAAQ;AACrC,QAAI,WAAW,MAAM,YAAY,IAAI,MAAM,GAAG;AAC5C,eAAS;AACT;AAAA,IACF;AAAA,EACF;AACA,MAAI,UAAU,OAAQ,QAAO;AAC7B,MAAI,OAAQ,QAAO;AACnB,MAAI,OAAQ,QAAO;AACnB,MAAI,OAAO,WAAW,cAAc;AAKlC,WAAO,WAAW,OAAO,eAAe,mBAAmB,QAAQ,MAAM;AAAA,EAC3E;AACA,SAAO;AACT;AAEA,SAAS,mBAAmB,QAAyB,QAA4B;AAC/E,QAAM,iBAAiB,KAAK,MAAM,OAAO,gBAAgB,EAAE;AAC3D,SAAO,OAAO,SAAS,cAAc,KAAK,kBAAkB,SACxD,eACA;AACN;AAEO,SAAS,kBACd,SACA,OACA,QACA,UAAkD,CAAC,GAC9C;AACL,QAAM,UAAU,QAAQ,YAAY;AACpC,MAAI,CAAC,WAAW,CAAC,sBAAsB,KAAK,EAAG,QAAO;AAKtD,QAAM,SACJ,OAAO,QAAQ,WAAW,YAAY,OAAO,SAAS,QAAQ,MAAM,IAChE,QAAQ,SACR;AAEN,QAAM,SAAS,kBAAkB,SAAS,MAAM;AAChD,QAAM,eAAe,oBAAI,IAAY;AACrC,aAAW,UAAU,SAAS;AAC5B,UAAM,KAAK,kBAAkB,MAAM;AACnC,QAAI,GAAI,cAAa,IAAI,EAAE;AAAA,EAC7B;AAEA,QAAM,kBAAkB,CAAC,WAAwE;AAC/F,UAAM,KAAK,kBAAkB,MAAM;AACnC,WAAO;AAAA,MACL,YAAY,OAAO,WAAW,gBAAgB,QAAQ,OAAO,YAAY,KAAK,OAAO,IAAI,EAAE;AAAA,MAC3F,aAAa,OAAO,gBAAgB,OAAO,IAAI,EAAE;AAAA,IACnD;AAAA,EACF;AAEA,MAAI;AACJ,MAAI,WAAW,MAAM;AACnB,eAAW,QAAQ,MAAM;AAAA,EAC3B,OAAO;AACL,eAAW,CAAC;AACZ,eAAW,UAAU,SAAS;AAC5B,YAAM,EAAE,YAAY,YAAY,IAAI,gBAAgB,MAAM;AAC1D,UAAI,CAAC,cAAc,sBAAsB,aAAa,YAAY,GAAG;AACnE,iBAAS,KAAK,MAAM;AAAA,MACtB;AAAA,IACF;AAKA,QAAIA,eAAc,IAAI,IAAI,SAAS,IAAI,iBAAiB,EAAE,OAAO,OAAO,CAAC;AACzE,aAAS,UAAU,MAAM,WAAW;AAClC,gBAAU;AACV,eAAS,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG;AAChD,cAAM,MAAM,SAAS,CAAC;AACtB,cAAM,EAAE,YAAY,YAAY,IAAI,gBAAgB,GAAG;AACvD,YAAI,cAAc,CAAC,sBAAsB,aAAaA,YAAW,GAAG;AAClE,mBAAS,OAAO,GAAG,CAAC;AACpB,oBAAU;AAAA,QACZ;AAAA,MACF;AACA,UAAI,QAAS,CAAAA,eAAc,IAAI,IAAI,SAAS,IAAI,iBAAiB,EAAE,OAAO,OAAO,CAAC;AAAA,IACpF;AAAA,EACF;AAEA,QAAM,cAAc,IAAI,IAAI,SAAS,IAAI,iBAAiB,EAAE,OAAO,OAAO,CAAC;AAC3E,SAAO,SAAS,IAAI,CAAC,WAAW;AAC9B,UAAM,KAAK,kBAAkB,MAAM;AACnC,WAAO,EAAE,GAAG,QAAQ,YAAY,SAAS,IAAI,QAAQ,QAAQ,aAAa,MAAM,EAAE;AAAA,EACpF,CAAC;AACH;","names":["admittedIds"]}