@elabs-ai/components-process 4.1.0 → 5.0.0

package/src/core/cases-from-log.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+
+import { casesFromLog } from "./cases-from-log";
+import { extractVariants } from "./extract-variants";
+import fixture from "./fixtures/order-to-cash-small.json";
+import type { EventLog } from "./types";
+
+const orderToCash = fixture as EventLog;
+
+describe("casesFromLog", () => {
+  it("answers an empty log with an empty array", () => {
+    expect(casesFromLog({ events: [] })).toEqual([]);
+  });
+
+  it("summarizes each case's own extent, size and duration", () => {
+    const rows = casesFromLog(orderToCash);
+    expect(rows.map((r) => r.caseId)).toEqual(["case-1", "case-2", "case-3", "case-4", "case-5"]);
+
+    const case1 = rows.find((r) => r.caseId === "case-1");
+    expect(case1).toMatchObject({
+      start: "2026-01-05T09:00:00.000Z",
+      end: "2026-01-05T14:00:00.000Z",
+      durationMs: 18_000_000,
+      eventCount: 6,
+    });
+  });
+
+  it("assigns the SAME variantId extractVariants assigns the same case", () => {
+    const rows = casesFromLog(orderToCash);
+    const variants = extractVariants(orderToCash);
+
+    for (const row of rows) {
+      const variant = variants.find((v) => v.caseIds.includes(row.caseId));
+      expect(row.variantId).toBe(variant?.id);
+    }
+
+    // case-1 and case-2 share the five-step happy path — same variant id.
+    const case1 = rows.find((r) => r.caseId === "case-1");
+    const case2 = rows.find((r) => r.caseId === "case-2");
+    expect(case1?.variantId).toBe(case2?.variantId);
+    expect(case1?.variantId).toBeTruthy();
+
+    // case-3 (rejected early) follows a different path.
+    const case3 = rows.find((r) => r.caseId === "case-3");
+    expect(case3?.variantId).not.toBe(case1?.variantId);
+  });
+
+  it("never invents a conformance value", () => {
+    const rows = casesFromLog(orderToCash);
+    expect(rows.every((r) => r.conformance === undefined)).toBe(true);
+  });
+
+  it("carries per-case attributes through untouched", () => {
+    const log: EventLog = {
+      events: [{ caseId: "c1", activity: "A", timestamp: 0 }],
+      caseAttributes: { c1: { region: "EU", priority: 2 } },
+    };
+    const rows = casesFromLog(log);
+    expect(rows[0]?.attributes).toEqual({ region: "EU", priority: 2 });
+  });
+
+  it("answers an empty ISO start/end for a case with no resolvable extent", () => {
+    // A "complete" row whose activity never opened and no explicit startTimestamp still
+    // resolves — the only way to get NaN is an unparseable timestamp on every row.
+    const log: EventLog = {
+      events: [{ caseId: "c1", activity: "A", timestamp: "not-a-date" }],
+    };
+    const rows = casesFromLog(log);
+    expect(rows[0]?.start).toBe("");
+    expect(rows[0]?.end).toBe("");
+  });
+});

package/src/core/cases-from-log.ts

@@ -0,0 +1,85 @@
+/**
+ * casesFromLog — RM-055.
+ *
+ * A pure per-case summary over an event log: one {@link CaseRow} per case, shaped for
+ * `CaseTable`'s default columns and CSV export (`toCsv`). `variantId` is read off
+ * {@link extractVariants} rather than recomputed independently — `extractVariants` is the
+ * one place that disambiguates a 64-bit hash collision between two different sequences
+ * with a `-1`/`-2` suffix, so recomputing `variantId(sequence)` here directly would
+ * silently diverge from a variant explorer over the SAME log on the rare log where that
+ * disambiguation fires. Reading it off `extractVariants`'s own `caseIds` keeps the two
+ * views byte-identical always, not just usually.
+ *
+ * Framework-free, deterministic: no React, no `Date.now()`, no randomness. See
+ * `.claude/rules/data.md` — nothing under `src/core/` may import React or an
+ * `@elabs-ai/components-*` package.
+ */
+import { asNormalizedLog, type NormalizedCase } from "./event-log";
+import { extractVariants } from "./extract-variants";
+import type { EventLog } from "./types";
+
+/**
+ * One case's own summary — its extent, size and path identity, not its trace. The shape
+ * `CaseTable` (case-table/) renders one row per, and `CaseTimeline`'s own model reads a
+ * single case's raw `EventRow[]` separately (a summary row has no per-activity detail to
+ * build a Gantt row from).
+ */
+export interface CaseRow {
+  caseId: string;
+  /** ISO 8601. Empty string when the case has no resolvable extent — see `normalizeLog`. */
+  start: string;
+  end: string;
+  durationMs: number;
+  eventCount: number;
+  /** Identical to the `id` {@link extractVariants} assigns the SAME case over the SAME log. */
+  variantId: string;
+  /**
+   * Never set here: no conformance model lives in `/core` (`ProcessKpiStrip`'s own
+   * `conformance` prop treats it the same way — a fitted value the HOST supplies, never a
+   * number this package invents). A caller with a conformance result attaches it per row.
+   */
+  conformance?: "conforming" | "nonConforming" | "unknown";
+  /** Carried over from `EventLog.caseAttributes`, untouched. */
+  attributes?: Record<string, string | number | boolean | null>;
+}
+
+/** `NaN` (no resolvable extent) becomes `""`, never a thrown `RangeError` or `"Invalid Date"`. */
+function toIso(ms: number): string {
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : "";
+}
+
+function toCaseRow(kase: NormalizedCase, variantId: string): CaseRow {
+  const row: CaseRow = {
+    caseId: kase.caseId,
+    start: toIso(kase.start),
+    end: toIso(kase.end),
+    durationMs: Number.isFinite(kase.duration) ? kase.duration : 0,
+    eventCount: kase.events.length,
+    variantId,
+  };
+  if (kase.attributes !== undefined) {
+    row.attributes = kase.attributes as Record<string, string | number | boolean | null>;
+  }
+  return row;
+}
+
+/**
+ * One summary row per case in `log`, in the same first-appearance order `normalizeLog`
+ * produces. `variantId` is sourced from {@link extractVariants} over the identical log —
+ * see the module docblock for why that, and not a direct `variantId(sequence)` call, is
+ * what keeps a `CaseTable` and a variant explorer over the same log always agreeing on
+ * which cases share a path.
+ *
+ * An empty log answers an empty array.
+ */
+export function casesFromLog(log: EventLog): CaseRow[] {
+  const normalized = asNormalizedLog(log);
+  if (normalized.cases.length === 0) return [];
+
+  const variantIdByCase = new Map<string, string>();
+  for (const variant of extractVariants(normalized)) {
+    for (const caseId of variant.caseIds) variantIdByCase.set(caseId, variant.id);
+  }
+
+  return normalized.cases.map((kase) => toCaseRow(kase, variantIdByCase.get(kase.caseId) ?? ""));
+}

package/src/core/conformance.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+
+import { conformanceRateSeries } from "./conformance";
+import * as core from "./index";
+import { liftHappyPath } from "./reference-model";
+import type { EventLog, EventRow } from "./types";
+
+const model = liftHappyPath({
+  id: "p",
+  label: "Path",
+  steps: [{ activity: "A" }, { activity: "B" }, { activity: "C" }],
+});
+
+function caseRows(caseId: string, start: number, trace: string[]): EventRow[] {
+  return trace.map((activity, i) => ({ caseId, activity, timestamp: start + i * 3_600_000 }));
+}
+
+// Three months: January all conforming, February one of two, March one incomplete case.
+const log: EventLog = {
+  events: [
+    ...caseRows("jan-1", Date.UTC(2026, 0, 3), ["A", "B", "C"]),
+    ...caseRows("jan-2", Date.UTC(2026, 0, 20), ["A", "B", "C"]),
+    ...caseRows("feb-1", Date.UTC(2026, 1, 2), ["A", "B", "C"]),
+    ...caseRows("feb-2", Date.UTC(2026, 1, 14), ["A", "B"]),
+    ...caseRows("mar-1", Date.UTC(2026, 2, 30), ["A", "B"]),
+  ],
+};
+
+describe("conformanceRateSeries", () => {
+  it("returns one bucket per month whose case counts sum to the log total", () => {
+    const series = conformanceRateSeries(log, model, "month");
+    expect(series.map((p) => p.bucket)).toEqual(["2026-01", "2026-02", "2026-03"]);
+    expect(series.map((p) => p.caseCount)).toEqual([2, 2, 1]);
+    expect(series.reduce((sum, p) => sum + p.caseCount, 0)).toBe(5);
+    // A, B then stop: p=3, c=3, m=1, r=1 → ½(1−1/3) + ½(1−1/3) = 2/3.
+    expect(series[0]?.fitness).toBe(1);
+    expect(series[1]?.fitness).toBeCloseTo((1 + 2 / 3) / 2, 12);
+    expect(series[2]?.fitness).toBeCloseTo(2 / 3, 12);
+  });
+
+  it("buckets by UTC day and by the UTC Monday of the week", () => {
+    expect(conformanceRateSeries(log, model, "day").map((p) => p.bucket)).toEqual([
+      "2026-01-03",
+      "2026-01-20",
+      "2026-02-02",
+      "2026-02-14",
+      "2026-03-30",
+    ]);
+    // 2026-01-03 is a Saturday → week of Monday 2025-12-29; 2026-03-30 is itself a Monday.
+    expect(conformanceRateSeries(log, model, "week").map((p) => p.bucket)).toEqual([
+      "2025-12-29",
+      "2026-01-19",
+      "2026-02-02",
+      "2026-02-09",
+      "2026-03-30",
+    ]);
+  });
+
+  it("leaves out a case with no resolvable start instead of inventing a bucket", () => {
+    const withBad: EventLog = {
+      events: [...log.events, { caseId: "bad", activity: "A", timestamp: "garbage" }],
+    };
+    const total = conformanceRateSeries(withBad, model, "month").reduce(
+      (sum, p) => sum + p.caseCount,
+      0,
+    );
+    expect(total).toBe(5);
+  });
+});
+
+describe("core scope boundary (analysis §9 risk 2)", () => {
+  it("exports the replay API and no alignment search or BPMN import", () => {
+    expect(typeof core.liftHappyPath).toBe("function");
+    expect(typeof core.replayTrace).toBe("function");
+    expect(typeof core.tokenReplay).toBe("function");
+    expect(typeof core.conformanceRateSeries).toBe("function");
+    const forbidden = Object.keys(core).filter((name) => /align|bpmn|petri/i.test(name));
+    expect(forbidden).toEqual([]);
+  });
+});

package/src/core/conformance.ts

@@ -0,0 +1,91 @@
+/**
+ * Conformance model — RM-061.
+ *
+ * The log-level result of replaying an event log against a reference model
+ * ({@link ConformanceResult}, produced by `tokenReplay`) and the fitness-over-time series a
+ * KPI sparkline plots ({@link conformanceRateSeries}).
+ *
+ * Scope boundary (analysis §9 risk 2): token replay against a lifted happy path only — no
+ * alignments, no BPMN import. A host needing either brings a backend.
+ *
+ * Framework-free, deterministic: no React, no `Date.now()`, no `@elabs-ai/components-*`
+ * import.
+ */
+import { asNormalizedLog, type AnyLog } from "./event-log";
+import type { ReplayModel } from "./reference-model";
+import { replayActivities, type DeviationType, type TraceReplayResult } from "./token-replay";
+
+/** Log-level conformance of an event log against a reference model. */
+export interface ConformanceResult {
+  /** Mean trace fitness in `[0, 1]`; `0` for an empty log. */
+  overallFitness: number;
+  /** One result per case, in the log's case order. */
+  traces: TraceReplayResult[];
+  /** Total deviations per type across all cases; every type is present. */
+  deviationCounts: Record<DeviationType, number>;
+  /** Deviations charged to each activity. Sums to the total deviation count. */
+  perActivity: Record<string, { deviations: number }>;
+  /**
+   * Deviations charged to each OBSERVED directly-follows edge, keyed
+   * `source + EDGE_KEY_SEPARATOR + target` — the same key `discoverGraph` gives the edge.
+   * Sums to at most the total deviation count.
+   */
+  perEdge: Record<string, { deviations: number }>;
+}
+
+/** Calendar granularity of {@link conformanceRateSeries}. All buckets are UTC. */
+export type ConformanceBucket = "day" | "week" | "month";
+
+/** One point of {@link conformanceRateSeries}. */
+export interface ConformanceRatePoint {
+  /** `YYYY-MM-DD` (day; for week, the UTC Monday that starts it) or `YYYY-MM` (month). */
+  bucket: string;
+  /** Mean fitness of the cases that started in this bucket. */
+  fitness: number;
+  caseCount: number;
+}
+
+const DAY_MS = 86_400_000;
+
+function bucketOf(ms: number, bucket: ConformanceBucket): string {
+  const date = new Date(ms);
+  if (bucket === "week") {
+    // getUTCDay(): 0 = Sunday … 6 = Saturday; shift so Monday is day 0.
+    const offset = (date.getUTCDay() + 6) % 7;
+    const monday = new Date(
+      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) - offset * DAY_MS,
+    );
+    return monday.toISOString().slice(0, 10);
+  }
+  const iso = date.toISOString();
+  return bucket === "month" ? iso.slice(0, 7) : iso.slice(0, 10);
+}
+
+/**
+ * Mean replay fitness per calendar bucket, keyed by each case's START time, in ascending
+ * bucket order. Empty buckets are not emitted. A case with no resolvable start timestamp
+ * cannot be placed in time and is left out, so `caseCount`s sum to the number of cases
+ * with a valid start.
+ */
+export function conformanceRateSeries(
+  log: AnyLog,
+  model: ReplayModel,
+  bucket: ConformanceBucket,
+): ConformanceRatePoint[] {
+  const totals = new Map<string, { sum: number; count: number }>();
+  for (const kase of asNormalizedLog(log).cases) {
+    if (!Number.isFinite(kase.start)) continue;
+    const key = bucketOf(kase.start, bucket);
+    const trace = kase.events.map((event) => event.activity);
+    const { fitness } = replayActivities(kase.caseId, trace, model);
+    const entry = totals.get(key);
+    if (entry === undefined) totals.set(key, { sum: fitness, count: 1 });
+    else {
+      entry.sum += fitness;
+      entry.count += 1;
+    }
+  }
+  return [...totals.entries()]
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([key, { sum, count }]) => ({ bucket: key, fitness: sum / count, caseCount: count }));
+}

package/src/core/diff-graphs.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "vitest";
+import { diffGraphs } from "./diff-graphs";
+import type { ActivityStats, ProcessGraph, TransitionStats } from "./types";
+
+const DURATION = {
+  min: 1,
+  max: 10,
+  mean: 5,
+  median: 5,
+  p90: 9,
+  sum: 50,
+  trimmedMean: 5,
+};
+
+function activity(id: string, overrides: Partial<ActivityStats> = {}): ActivityStats {
+  return {
+    id,
+    label: id,
+    instances: 10,
+    cases: 5,
+    isStart: false,
+    isEnd: false,
+    duration: DURATION,
+    ...overrides,
+  };
+}
+
+function transition(
+  source: string,
+  target: string,
+  overrides: Partial<TransitionStats> = {},
+): TransitionStats {
+  return {
+    source,
+    target,
+    count: 10,
+    caseCount: 5,
+    duration: DURATION,
+    isSelfLoop: source === target,
+    isBackEdge: false,
+    ...overrides,
+  };
+}
+
+function graph(overrides: Partial<ProcessGraph> = {}): ProcessGraph {
+  return {
+    activities: [],
+    transitions: [],
+    startActivities: {},
+    endActivities: {},
+    totals: { cases: 0, events: 0, variants: 0 },
+    ...overrides,
+  };
+}
+
+describe("diffGraphs", () => {
+  it("marks every entry common with delta 0 on two identical graphs", () => {
+    const a = graph({
+      activities: [activity("Create", { isStart: true }), activity("Ship", { isEnd: true })],
+      transitions: [transition("Create", "Ship")],
+    });
+    const b = graph({
+      activities: [activity("Create", { isStart: true }), activity("Ship", { isEnd: true })],
+      transitions: [transition("Create", "Ship")],
+    });
+
+    const diff = diffGraphs(a, b);
+
+    expect(diff.activities).toHaveLength(2);
+    for (const entry of diff.activities) {
+      expect(entry.state).toBe("common");
+      expect(entry.delta).toBe(0);
+      expect(entry.ratio).toBe(1);
+    }
+    expect(diff.transitions).toHaveLength(1);
+    expect(diff.transitions[0]!.state).toBe("common");
+    expect(diff.transitions[0]!.delta).toBe(0);
+  });
+
+  it("marks every entry aOnly or bOnly on fully disjoint graphs", () => {
+    const a = graph({
+      activities: [activity("Create")],
+      transitions: [transition("Create", "Create")],
+    });
+    const b = graph({
+      activities: [activity("Cancel")],
+      transitions: [transition("Cancel", "Cancel")],
+    });
+
+    const diff = diffGraphs(a, b);
+
+    expect(diff.activities).toHaveLength(2);
+    // A one-sided entry never sets its ABSENT side's key at all (no `b: undefined` noise) —
+    // check presence/absence directly rather than via `toMatchObject`, which treats an
+    // expected `undefined` value inconsistently with a genuinely missing key.
+    const createEntry = diff.activities.find((e) => e.id === "Create");
+    expect(createEntry).toMatchObject({ state: "aOnly", a: expect.any(Object) });
+    expect(createEntry?.b).toBeUndefined();
+    expect(createEntry?.delta).toBeUndefined();
+    const cancelEntry = diff.activities.find((e) => e.id === "Cancel");
+    expect(cancelEntry).toMatchObject({ state: "bOnly", b: expect.any(Object) });
+    expect(cancelEntry?.a).toBeUndefined();
+    expect(cancelEntry?.delta).toBeUndefined();
+    expect(diff.transitions).toHaveLength(2);
+    for (const entry of diff.transitions) {
+      expect(["aOnly", "bOnly"]).toContain(entry.state);
+      expect(entry.delta).toBeUndefined();
+    }
+  });
+
+  it("computes delta and ratio for a common entry whose value changed", () => {
+    const a = graph({ activities: [activity("Create", { instances: 20 })] });
+    const b = graph({ activities: [activity("Create", { instances: 30 })] });
+
+    const diff = diffGraphs(a, b);
+
+    expect(diff.activities[0]).toMatchObject({ state: "common", delta: 10, ratio: 1.5 });
+  });
+
+  it("omits ratio (never Infinity) when a's reference value is zero", () => {
+    const a = graph({ activities: [activity("Create", { instances: 0 })] });
+    const b = graph({ activities: [activity("Create", { instances: 5 })] });
+
+    const diff = diffGraphs(a, b);
+
+    expect(diff.activities[0]!.delta).toBe(5);
+    expect(diff.activities[0]!.ratio).toBeUndefined();
+  });
+
+  it("carries each side's own totals through untouched", () => {
+    const a = graph({ totals: { cases: 3, events: 9, variants: 1 } });
+    const b = graph({ totals: { cases: 7, events: 21, variants: 2 } });
+
+    const diff = diffGraphs(a, b);
+
+    expect(diff.totals).toEqual({
+      a: { cases: 3, events: 9, variants: 1 },
+      b: { cases: 7, events: 21, variants: 2 },
+    });
+  });
+
+  it("keys a transition by source+target, not by object identity", () => {
+    const a = graph({ transitions: [transition("A", "B", { count: 4 })] });
+    const b = graph({ transitions: [transition("A", "B", { count: 9 })] });
+
+    const diff = diffGraphs(a, b);
+
+    expect(diff.transitions).toHaveLength(1);
+    expect(diff.transitions[0]).toMatchObject({ state: "common", delta: 5 });
+  });
+});

package/src/core/diff-graphs.ts

@@ -0,0 +1,118 @@
+/**
+ * diffGraphs — RM-064's pure diff between two discovered `ProcessGraph`s, the model
+ * `ProcessCompare` renders (side-by-side or superimposed).
+ *
+ * Activities are matched by `id` (the activity name — the same identity `/core` uses
+ * everywhere else); transitions are matched by `source`+{@link EDGE_KEY_SEPARATOR}+`target`,
+ * exactly the key `reconcileGraph`'s own `transitionKey` builds, so a transition that moved
+ * between the two graphs is never mistaken for two unrelated ones. An element present on
+ * both sides is `"common"`; present only in `a` is `"aOnly"`; present only in `b` is
+ * `"bOnly"` — every element in the union appears in exactly one of the three states.
+ *
+ * `delta`/`ratio` are computed once BOTH sides have the element (a `"common"` entry) —
+ * comparing a real reading against nothing would be a fabricated number, not a diff. The
+ * reference metric is each element's plain occurrence count — `instances` for an activity,
+ * `count` for a transition — because those are the only two fields every `ActivityStats`/
+ * `TransitionStats` always carries (never derived, never optional), so a delta is always
+ * well-defined for a `"common"` entry, whatever metric a downstream view happens to paint
+ * with. `ratio` is omitted rather than `Infinity` when `a`'s value is `0`.
+ *
+ * Pure, deterministic, framework-free — see the module-level rule in `types.ts`.
+ */
+import { EDGE_KEY_SEPARATOR } from "./discover-graph";
+import type { ActivityStats, ProcessGraph, TransitionStats } from "./types";
+
+/** Which side(s) of the diff an activity or transition survives in. */
+export type DiffState = "common" | "aOnly" | "bOnly";
+
+/** One activity's or transition's diff — its identity, its state, and (when `"common"`) its delta. */
+export interface DiffEntry<Stats> {
+  id: string;
+  state: DiffState;
+  /** Present unless the element is `"bOnly"`. */
+  a?: Stats;
+  /** Present unless the element is `"aOnly"`. */
+  b?: Stats;
+  /** `b`'s reference value minus `a`'s. Only set for a `"common"` entry. */
+  delta?: number;
+  /** `b`'s reference value divided by `a`'s. Only set for a `"common"` entry with `a > 0`. */
+  ratio?: number;
+}
+
+/** The full diff between two graphs. */
+export interface ProcessGraphDiff {
+  activities: DiffEntry<ActivityStats>[];
+  transitions: DiffEntry<TransitionStats>[];
+  totals: { a: ProcessGraph["totals"]; b: ProcessGraph["totals"] };
+}
+
+/** `source`+{@link EDGE_KEY_SEPARATOR}+`target` — the same key `reconcileGraph` builds. */
+function transitionKey(transition: Pick<TransitionStats, "source" | "target">): string {
+  return `${transition.source}${EDGE_KEY_SEPARATOR}${transition.target}`;
+}
+
+/** Every id in `first`, in order, then every id `second` adds that `first` did not have. */
+function unionIds(first: string[], second: string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const id of first) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  for (const id of second) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
+function diffEntries<Stats>(
+  aById: ReadonlyMap<string, Stats>,
+  bById: ReadonlyMap<string, Stats>,
+  ids: string[],
+  referenceValue: (stats: Stats) => number,
+): DiffEntry<Stats>[] {
+  return ids.map((id) => {
+    const a = aById.get(id);
+    const b = bById.get(id);
+    const state: DiffState = a !== undefined && b !== undefined ? "common" : a ? "aOnly" : "bOnly";
+    const entry: DiffEntry<Stats> = { id, state };
+    if (a !== undefined) entry.a = a;
+    if (b !== undefined) entry.b = b;
+    if (a !== undefined && b !== undefined) {
+      const aValue = referenceValue(a);
+      const bValue = referenceValue(b);
+      entry.delta = bValue - aValue;
+      if (aValue > 0) entry.ratio = bValue / aValue;
+    }
+    return entry;
+  });
+}
+
+/**
+ * Diff two discovered graphs. Neither input is mutated; the entries reference the original
+ * `ActivityStats`/`TransitionStats` objects, never copies.
+ */
+export function diffGraphs(a: ProcessGraph, b: ProcessGraph): ProcessGraphDiff {
+  const aActivities = new Map(a.activities.map((activity) => [activity.id, activity]));
+  const bActivities = new Map(b.activities.map((activity) => [activity.id, activity]));
+  const activityIds = unionIds(
+    a.activities.map((activity) => activity.id),
+    b.activities.map((activity) => activity.id),
+  );
+
+  const aTransitions = new Map(a.transitions.map((t) => [transitionKey(t), t]));
+  const bTransitions = new Map(b.transitions.map((t) => [transitionKey(t), t]));
+  const transitionIds = unionIds(
+    a.transitions.map((t) => transitionKey(t)),
+    b.transitions.map((t) => transitionKey(t)),
+  );
+
+  return {
+    activities: diffEntries(aActivities, bActivities, activityIds, (stats) => stats.instances),
+    transitions: diffEntries(aTransitions, bTransitions, transitionIds, (stats) => stats.count),
+    totals: { a: a.totals, b: b.totals },
+  };
+}