@elabs-ai/components-process 4.1.0

package/src/core/aggregate-performance.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, it } from "vitest";
+
+import { aggregatePerformance, DURATION_UNIT_MS, performanceValue } from "./aggregate-performance";
+import { discoverGraph, EDGE_KEY_SEPARATOR } from "./discover-graph";
+import { normalizeLog } from "./event-log";
+import type { DurationStats, EventLog } from "./types";
+
+const MINUTE = 60_000;
+
+/**
+ * Two cases, atomic events, one edge A→B whose gaps are 1 and 3 minutes.
+ *
+ * Small enough that every expected number below is arithmetic anyone can redo: the edge's
+ * samples are [60000, 180000], so median 120000, min 60000, max 180000, sum 240000.
+ */
+const twoGaps: EventLog = {
+  events: [
+    { caseId: "c1", activity: "A", timestamp: 0 },
+    { caseId: "c1", activity: "B", timestamp: MINUTE },
+    { caseId: "c2", activity: "A", timestamp: 0 },
+    { caseId: "c2", activity: "B", timestamp: 3 * MINUTE },
+  ],
+};
+
+/** One case of INTERVAL events, where waiting time and cycle time genuinely differ. */
+const interval: EventLog = {
+  events: [
+    { caseId: "c1", activity: "A", startTimestamp: 0, timestamp: 30_000 },
+    { caseId: "c1", activity: "B", startTimestamp: MINUTE, timestamp: 90_000 },
+  ],
+};
+
+const edgeKey = (source: string, target: string): string =>
+  `${source}${EDGE_KEY_SEPARATOR}${target}`;
+
+describe("performanceValue", () => {
+  const stats: DurationStats = {
+    min: 1,
+    max: 7,
+    mean: 3,
+    median: 2,
+    p90: 6,
+    sum: 12,
+    trimmedMean: 4,
+  };
+
+  it("maps every aggregate name to its own member", () => {
+    expect(performanceValue(stats, "min")).toBe(1);
+    expect(performanceValue(stats, "max")).toBe(7);
+    expect(performanceValue(stats, "mean")).toBe(3);
+    expect(performanceValue(stats, "median")).toBe(2);
+    expect(performanceValue(stats, "p90")).toBe(6);
+    expect(performanceValue(stats, "sum")).toBe(12);
+    // The snake_case wire spelling of `trimmedMean` — the mapping that is easy to get
+    // wrong and impossible to notice, because every value is a plausible duration.
+    expect(performanceValue(stats, "trimmed_mean")).toBe(4);
+  });
+});
+
+describe("aggregatePerformance unit conversion", () => {
+  const graph = discoverGraph(twoGaps);
+
+  it("converts every member of every DurationStats, not only the selected one", () => {
+    const layered = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "idle_time",
+      unit: "min",
+    });
+    const edge = layered.transitions.find((t) => t.source === "A" && t.target === "B");
+    const duration = edge?.duration as DurationStats;
+    // Member by member, and with a tolerance: a unit conversion is a float multiply, so
+    // p90 lands on 2.8000000000000003 and asserting the decimal literal would be a test
+    // that fails for the wrong reason.
+    const expected: DurationStats = {
+      min: 1,
+      max: 3,
+      mean: 2,
+      median: 2,
+      p90: 2.8,
+      sum: 4,
+      trimmedMean: 2,
+    };
+    for (const key of Object.keys(expected) as (keyof DurationStats)[]) {
+      expect(duration[key]).toBeCloseTo(expected[key], 9);
+    }
+  });
+
+  it("exposes the selected aggregate per element, in the requested unit", () => {
+    for (const [unit, divisor] of Object.entries(DURATION_UNIT_MS)) {
+      const layered = aggregatePerformance(graph, {
+        agg: "max",
+        flowTime: "idle_time",
+        unit: unit as keyof typeof DURATION_UNIT_MS,
+      });
+      expect(layered.performance.transitions[edgeKey("A", "B")]).toBeCloseTo(
+        (3 * MINUTE) / divisor,
+        9,
+      );
+    }
+  });
+
+  it("reports the domains a scale needs", () => {
+    const layered = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "idle_time",
+      unit: "min",
+    });
+    expect(layered.performance.transitionDomain).toEqual([2, 2]);
+    // Atomic events have no execution time of their own, so every activity measures zero.
+    expect(layered.performance.activityDomain).toEqual([0, 0]);
+  });
+
+  it("echoes the settings it was driven with, so a legend can read them back", () => {
+    const layered = aggregatePerformance(graph, {
+      agg: "p90",
+      flowTime: "inter_start_time",
+      unit: "h",
+    });
+    expect(layered.performance.agg).toBe("p90");
+    expect(layered.performance.flowTime).toBe("inter_start_time");
+    expect(layered.performance.unit).toBe("h");
+  });
+
+  it("does not mutate the graph it was handed", () => {
+    const before = structuredClone(graph);
+    aggregatePerformance(graph, { agg: "sum", flowTime: "idle_time", unit: "s" });
+    expect(graph).toEqual(before);
+  });
+});
+
+describe("aggregatePerformance flow time", () => {
+  it("re-derives waiting time vs cycle time when it is given the log", () => {
+    const graph = discoverGraph(interval); // discovered at the default idle_time
+    const idle = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "idle_time",
+      unit: "ms",
+      log: interval,
+    });
+    const cycle = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "inter_start_time",
+      unit: "ms",
+      log: interval,
+    });
+    // A ends at 30s and B starts at 60s → 30s of waiting; A starts at 0 → 60s of cycle.
+    expect(idle.performance.transitions[edgeKey("A", "B")]).toBe(30_000);
+    expect(cycle.performance.transitions[edgeKey("A", "B")]).toBe(60_000);
+  });
+
+  it("accepts an already-normalized log, and answers identically", () => {
+    const graph = discoverGraph(interval);
+    const fromRaw = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "inter_start_time",
+      unit: "s",
+      log: interval,
+    });
+    const fromNormalized = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "inter_start_time",
+      unit: "s",
+      log: normalizeLog(interval),
+    });
+    expect(fromNormalized).toEqual(fromRaw);
+  });
+
+  it("without a log, carries the graph's own samples through unchanged", () => {
+    const graph = discoverGraph(interval);
+    const layered = aggregatePerformance(graph, {
+      agg: "median",
+      flowTime: "inter_start_time",
+      unit: "ms",
+    });
+    // `flowTime` is a declaration here, not an instruction: the graph was discovered at
+    // idle_time, so 30s is what it still measures. This is the documented limitation.
+    expect(layered.performance.transitions[edgeKey("A", "B")]).toBe(30_000);
+  });
+
+  it("keeps a reduced graph's numbers derived from the FULL log", () => {
+    // The "sliders never change statistics" rule, one layer up: a performance layer over
+    // an abstracted graph must still describe everything that happened.
+    const log: EventLog = {
+      events: [
+        { caseId: "c1", activity: "A", timestamp: 0 },
+        { caseId: "c1", activity: "B", timestamp: MINUTE },
+        { caseId: "c2", activity: "A", timestamp: 0 },
+        { caseId: "c2", activity: "B", timestamp: 3 * MINUTE },
+        { caseId: "c3", activity: "A", timestamp: 0 },
+        { caseId: "c3", activity: "Rare", timestamp: 10 * MINUTE },
+      ],
+    };
+    const full = discoverGraph(log);
+    const reduced = {
+      ...full,
+      activities: full.activities.filter((a) => a.id !== "Rare"),
+      transitions: full.transitions.filter((t) => t.target !== "Rare"),
+    };
+    const layered = aggregatePerformance(reduced, {
+      agg: "median",
+      flowTime: "idle_time",
+      unit: "min",
+      log,
+    });
+    expect(layered.performance.transitions[edgeKey("A", "B")]).toBe(2);
+    expect(layered.activities.map((a) => a.id)).not.toContain("Rare");
+  });
+});

package/src/core/aggregate-performance.ts

@@ -0,0 +1,200 @@
+/**
+ * The performance metric layer — RM-050.
+ *
+ * A process map is read twice: once for FREQUENCY (how often does this happen) and once
+ * for PERFORMANCE (how long does it take). The frequency numbers come straight off
+ * discovery; the performance numbers need three further decisions that only a reader can
+ * make — which aggregate (median, mean, p90 …), which elapsed time an edge measures
+ * (waiting or cycle), and which unit the answer is spoken in. This module applies all
+ * three to an already-discovered graph and hands back the scalar each node and edge
+ * should be painted with.
+ *
+ * The returned graph is a NEW object graph: unlike {@link abstractGraph}, which filters,
+ * this function re-expresses. The input is never mutated.
+ */
+import { discoverGraph } from "./discover-graph";
+import { EDGE_KEY_SEPARATOR } from "./discover-graph";
+import type { AnyLog } from "./event-log";
+import { minMax } from "./scale";
+import type {
+  ActivityStats,
+  DurationStats,
+  FlowTime,
+  PerformanceAgg,
+  ProcessGraph,
+  TransitionStats,
+} from "./types";
+
+/** The units a duration can be spoken in. Everything upstream is milliseconds. */
+export type DurationUnit = "ms" | "s" | "min" | "h" | "d";
+
+/** How many milliseconds each {@link DurationUnit} is worth. */
+export const DURATION_UNIT_MS: Readonly<Record<DurationUnit, number>> = Object.freeze({
+  ms: 1,
+  s: 1_000,
+  min: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+});
+
+/** Options for {@link aggregatePerformance}. */
+export interface PerformanceOptions {
+  /** Which member of a {@link DurationStats} the layer reads. */
+  agg: PerformanceAgg;
+  /**
+   * Which elapsed time an edge measures. Honoured only when `log` is supplied — a graph
+   * alone cannot be converted from waiting time to cycle time, because the two are not
+   * derivable from each other's summary statistics. Without `log` this field DECLARES
+   * what the graph already carries and nothing is re-derived.
+   */
+  flowTime: FlowTime;
+  /** The unit every returned duration is expressed in. */
+  unit: DurationUnit;
+  /**
+   * The log the graph came from. Supply it to re-derive edge durations at `flowTime`;
+   * pass an already-normalized log (see `asNormalizedLog`) to skip a second parse.
+   */
+  log?: AnyLog;
+  /**
+   * Reservoir capacity per activity and per edge when re-deriving. Order statistics
+   * (`median`, `p90`, `trimmedMean`) are ESTIMATES past this many samples per key; raise
+   * it when a threshold has to be exact. Only meaningful together with `log`.
+   */
+  maxDurationSamples?: number;
+}
+
+/** The per-element scalars a performance view paints with, plus the domains to scale them on. */
+export interface PerformanceLayer {
+  agg: PerformanceAgg;
+  flowTime: FlowTime;
+  unit: DurationUnit;
+  /** Activity id → the selected aggregate of its execution time, in `unit`. */
+  activities: Record<string, number>;
+  /** `source␁target` (see `EDGE_KEY_SEPARATOR`) → the selected aggregate, in `unit`. */
+  transitions: Record<string, number>;
+  /** `[min, max]` over `activities` — `[0, 0]` when there are none. */
+  activityDomain: [number, number];
+  /** `[min, max]` over `transitions` — `[0, 0]` when there are none. */
+  transitionDomain: [number, number];
+}
+
+/** What {@link aggregatePerformance} returns: a `ProcessGraph` plus its metric layer. */
+export interface PerformanceGraph extends ProcessGraph {
+  performance: PerformanceLayer;
+}
+
+/**
+ * Read the member of `stats` a {@link PerformanceAgg} names.
+ *
+ * The one place the mapping lives, so a control, a legend and a renderer cannot disagree
+ * about what "p90" is. `trimmed_mean` is the snake_case spelling of `trimmedMean` —
+ * the type is a wire/URL value, the field is a property name.
+ */
+export function performanceValue(stats: DurationStats, agg: PerformanceAgg): number {
+  switch (agg) {
+    case "mean":
+      return stats.mean;
+    case "min":
+      return stats.min;
+    case "max":
+      return stats.max;
+    case "sum":
+      return stats.sum;
+    case "p90":
+      return stats.p90;
+    case "trimmed_mean":
+      return stats.trimmedMean;
+    case "median":
+    default:
+      return stats.median;
+  }
+}
+
+/** Scale every member of `stats` by `factor`. Returns a new object; `stats` is untouched. */
+function scaleStats(stats: DurationStats, factor: number): DurationStats {
+  if (factor === 1) return { ...stats };
+  return {
+    min: stats.min * factor,
+    max: stats.max * factor,
+    mean: stats.mean * factor,
+    median: stats.median * factor,
+    p90: stats.p90 * factor,
+    sum: stats.sum * factor,
+    trimmedMean: stats.trimmedMean * factor,
+  };
+}
+
+function edgeKey(source: string, target: string): string {
+  return `${source}${EDGE_KEY_SEPARATOR}${target}`;
+}
+
+/**
+ * Express `graph`'s durations as a performance layer.
+ *
+ * Every `DurationStats` in the returned graph is converted to `opts.unit`, and
+ * `performance` carries the single scalar per activity and per transition that
+ * `opts.agg` selects, together with the two domains a scale needs.
+ *
+ * With `opts.log`, edge and activity durations are RE-DERIVED at `opts.flowTime` from the
+ * FULL log — which is what keeps a performance layer honest on an abstracted graph: the
+ * numbers describe everything that happened, not only the part currently drawn. Elements
+ * the re-derivation does not know about keep the statistics they arrived with.
+ *
+ * Order statistics past the reservoir cap are estimates (see `maxDurationSamples`);
+ * `sum`, `mean`, `min` and `max` are exact at any log size.
+ */
+export function aggregatePerformance(
+  graph: ProcessGraph,
+  opts: PerformanceOptions,
+): PerformanceGraph {
+  const factor = 1 / (DURATION_UNIT_MS[opts.unit] ?? 1);
+
+  let activitySource: Map<string, DurationStats> | undefined;
+  let transitionSource: Map<string, DurationStats> | undefined;
+  if (opts.log !== undefined) {
+    const derived = discoverGraph(opts.log, {
+      flowTime: opts.flowTime,
+      ...(opts.maxDurationSamples === undefined
+        ? {}
+        : { maxDurationSamples: opts.maxDurationSamples }),
+    });
+    activitySource = new Map(derived.activities.map((a) => [a.id, a.duration]));
+    transitionSource = new Map(
+      derived.transitions.map((t) => [edgeKey(t.source, t.target), t.duration]),
+    );
+  }
+
+  const activityValues: Record<string, number> = {};
+  const activities: ActivityStats[] = graph.activities.map((activity) => {
+    const source = activitySource?.get(activity.id) ?? activity.duration;
+    const duration = scaleStats(source, factor);
+    activityValues[activity.id] = performanceValue(duration, opts.agg);
+    return { ...activity, duration };
+  });
+
+  const transitionValues: Record<string, number> = {};
+  const transitions: TransitionStats[] = graph.transitions.map((edge) => {
+    const key = edgeKey(edge.source, edge.target);
+    const source = transitionSource?.get(key) ?? edge.duration;
+    const duration = scaleStats(source, factor);
+    transitionValues[key] = performanceValue(duration, opts.agg);
+    return { ...edge, duration };
+  });
+
+  return {
+    activities,
+    transitions,
+    startActivities: { ...graph.startActivities },
+    endActivities: { ...graph.endActivities },
+    totals: { ...graph.totals },
+    performance: {
+      agg: opts.agg,
+      flowTime: opts.flowTime,
+      unit: opts.unit,
+      activities: activityValues,
+      transitions: transitionValues,
+      activityDomain: minMax(Object.values(activityValues)),
+      transitionDomain: minMax(Object.values(transitionValues)),
+    },
+  };
+}

package/src/core/detect-rework.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+
+import { detectRework } from "./detect-rework";
+import { normalizeLog } from "./event-log";
+import fixture from "./fixtures/order-to-cash-small.json";
+import { generateSyntheticLog } from "./fixtures/synthetic-log";
+import type { EventLog } from "./types";
+
+const orderToCash = fixture as EventLog;
+
+/**
+ * The five traces in `order-to-cash-small.json`, restated so the numbers below can be
+ * read against them without opening the fixture:
+ *
+ *   case-1  Create Order · Check Credit · Approve Order · Ship Order · Send Invoice · Receive Payment
+ *   case-2  Create Order · Check Credit · Approve Order · Ship Order · Send Invoice · Receive Payment
+ *   case-3  Create Order · Check Credit · Reject Order
+ *   case-4  Create Order · Check Credit · Amend Order · Check Credit · Approve Order · Ship Order ·
+ *           Send Invoice · Receive Payment
+ *   case-5  Create Order · Check Credit · Approve Order · Send Invoice · Ship Order · Receive Payment
+ *
+ * Exactly one repeat in the whole fixture: case-4's second Check Credit, with Amend Order
+ * in between — a LOOP, not a self-loop. Counted by hand, not read off the implementation.
+ */
+describe("detectRework on the 5-case order-to-cash fixture", () => {
+  it("finds the one non-adjacent repeat and no adjacent ones", () => {
+    const rework = detectRework(orderToCash);
+    expect(rework.selfLoops).toBe(0);
+    expect(rework.loops).toBe(1);
+    expect(rework.caseReworkRate).toBe(1 / 5);
+  });
+
+  it("attributes the loop to Check Credit and lists every other activity at zero", () => {
+    expect(detectRework(orderToCash).perActivity).toEqual({
+      "Amend Order": { selfLoops: 0, loops: 0 },
+      "Approve Order": { selfLoops: 0, loops: 0 },
+      "Check Credit": { selfLoops: 0, loops: 1 },
+      "Create Order": { selfLoops: 0, loops: 0 },
+      "Receive Payment": { selfLoops: 0, loops: 0 },
+      "Reject Order": { selfLoops: 0, loops: 0 },
+      "Send Invoice": { selfLoops: 0, loops: 0 },
+      "Ship Order": { selfLoops: 0, loops: 0 },
+    });
+  });
+
+  it("answers identically from an already-normalized log", () => {
+    expect(detectRework(normalizeLog(orderToCash))).toEqual(detectRework(orderToCash));
+  });
+});
+
+describe("detectRework classification", () => {
+  const traceLog = (activities: readonly string[][]): EventLog => ({
+    events: activities.flatMap((trace, caseIndex) =>
+      trace.map((activity, step) => ({
+        caseId: `case-${caseIndex}`,
+        activity,
+        timestamp: step * 1000,
+      })),
+    ),
+  });
+
+  it("counts an adjacent repeat as a self-loop", () => {
+    const rework = detectRework(traceLog([["A", "A", "B"]]));
+    expect(rework.selfLoops).toBe(1);
+    expect(rework.loops).toBe(0);
+    expect(rework.perActivity["A"]).toEqual({ selfLoops: 1, loops: 0 });
+  });
+
+  it("counts a return after another activity as a loop", () => {
+    const rework = detectRework(traceLog([["A", "B", "A"]]));
+    expect(rework.selfLoops).toBe(0);
+    expect(rework.loops).toBe(1);
+  });
+
+  it("splits a trace that does both, and never double-counts an occurrence", () => {
+    // A B A A B — occurrences beyond the first: the third A (loop), the fourth A
+    // (self-loop), the fifth B (loop). Three repeats, three tallies, no more.
+    const rework = detectRework(traceLog([["A", "B", "A", "A", "B"]]));
+    expect(rework.selfLoops).toBe(1);
+    expect(rework.loops).toBe(2);
+    expect(rework.perActivity["A"]).toEqual({ selfLoops: 1, loops: 1 });
+    expect(rework.perActivity["B"]).toEqual({ selfLoops: 0, loops: 1 });
+  });
+
+  it("counts a case once however much rework it carries", () => {
+    const rework = detectRework(
+      traceLog([
+        ["A", "A", "A", "A"],
+        ["B", "C"],
+      ]),
+    );
+    expect(rework.selfLoops).toBe(3);
+    expect(rework.caseReworkRate).toBe(1 / 2);
+  });
+
+  it("answers zeros for an empty log rather than dividing by zero", () => {
+    expect(detectRework({ events: [] })).toEqual({
+      selfLoops: 0,
+      loops: 0,
+      caseReworkRate: 0,
+      perActivity: {},
+    });
+  });
+
+  it("lists activities in ascending name order", () => {
+    const rework = detectRework(traceLog([["Zeta", "Alpha", "Mu"]]));
+    expect(Object.keys(rework.perActivity)).toEqual(["Alpha", "Mu", "Zeta"]);
+  });
+});
+
+describe("detectRework on the synthetic log", () => {
+  it("adds up: every repeat is exactly one of the two kinds", () => {
+    const log = generateSyntheticLog({ cases: 200, seed: 11 });
+    const normalized = normalizeLog(log);
+    const rework = detectRework(normalized);
+
+    // Counted independently: total executions minus distinct activities per case.
+    let repeats = 0;
+    for (const kase of normalized.cases) {
+      const distinct = new Set(kase.events.map((event) => event.activity));
+      repeats += kase.events.length - distinct.size;
+    }
+    expect(rework.selfLoops + rework.loops).toBe(repeats);
+    expect(repeats).toBeGreaterThan(0);
+    expect(rework.caseReworkRate).toBeGreaterThan(0);
+    expect(rework.caseReworkRate).toBeLessThanOrEqual(1);
+  });
+
+  it("is deterministic for a given seed", () => {
+    const first = detectRework(generateSyntheticLog({ cases: 50, seed: 3 }));
+    const second = detectRework(generateSyntheticLog({ cases: 50, seed: 3 }));
+    expect(second).toEqual(first);
+  });
+});

package/src/core/detect-rework.ts

@@ -0,0 +1,100 @@
+/**
+ * Rework detection — RM-050.
+ *
+ * "Rework" is the part of a process that happens more than once inside a single case: a
+ * step retried immediately (a SELF-LOOP), or a step the case comes back to after going
+ * somewhere else (a LOOP). Both are repeats, and separating them matters — a self-loop is
+ * usually a retry or a batch, a loop is usually a rejection sending work backwards, and
+ * the two lead to different conversations about the process.
+ *
+ * Counted per OCCURRENCE, over the normalized trace: the first execution of an activity in
+ * a case is never rework, and every later one is exactly one of the two kinds. So
+ * `selfLoops + loops` is precisely the number of repeated executions in the log.
+ *
+ * Deterministic and framework-free, like everything else in `/core`.
+ */
+import { asNormalizedLog, type AnyLog } from "./event-log";
+
+/** Per-activity rework tallies. */
+export interface ActivityRework {
+  /** Repeats of this activity immediately after itself. */
+  selfLoops: number;
+  /** Repeats of this activity later in the same case, with something else in between. */
+  loops: number;
+}
+
+/** What {@link detectRework} answers. */
+export interface ReworkStats {
+  /** Adjacent repeats across the whole log. */
+  selfLoops: number;
+  /** Non-adjacent repeats across the whole log. */
+  loops: number;
+  /** Fraction of cases carrying at least one self-loop or loop. `0` for an empty log. */
+  caseReworkRate: number;
+  /**
+   * Every activity in the log, in ascending name order, with its own two tallies. An
+   * activity that never repeats is present with zeros — a renderer joining this against
+   * a graph's activities never has to distinguish "no rework" from "unknown activity".
+   */
+  perActivity: Record<string, ActivityRework>;
+}
+
+/**
+ * Count rework in `log`.
+ *
+ * Accepts a raw or an already-normalized log and normalizes at most once
+ * ({@link asNormalizedLog} is idempotent), so a caller that has already normalized for
+ * `discoverGraph` pays nothing here.
+ */
+export function detectRework(log: AnyLog): ReworkStats {
+  const normalized = asNormalizedLog(log);
+
+  const tallies = new Map<string, ActivityRework>();
+  let selfLoops = 0;
+  let loops = 0;
+  let casesWithRework = 0;
+
+  const seen = new Set<string>();
+  for (const kase of normalized.cases) {
+    seen.clear();
+    let caseHasRework = false;
+    let previous: string | undefined;
+
+    for (const event of kase.events) {
+      const name = event.activity;
+      let tally = tallies.get(name);
+      if (tally === undefined) {
+        tally = { selfLoops: 0, loops: 0 };
+        tallies.set(name, tally);
+      }
+
+      if (seen.has(name)) {
+        caseHasRework = true;
+        if (name === previous) {
+          tally.selfLoops += 1;
+          selfLoops += 1;
+        } else {
+          tally.loops += 1;
+          loops += 1;
+        }
+      } else {
+        seen.add(name);
+      }
+      previous = name;
+    }
+
+    if (caseHasRework) casesWithRework += 1;
+  }
+
+  const perActivity: Record<string, ActivityRework> = {};
+  for (const name of [...tallies.keys()].sort()) {
+    perActivity[name] = tallies.get(name) as ActivityRework;
+  }
+
+  return {
+    selfLoops,
+    loops,
+    caseReworkRate: normalized.cases.length === 0 ? 0 : casesWithRework / normalized.cases.length,
+    perActivity,
+  };
+}