@elabs-ai/components-process 4.1.0 → 5.0.0

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-import { Node, Edge, NodeProps, EdgeProps, XYPosition } from '@xyflow/react';
 import * as react from 'react';
-import { HTMLAttributes, KeyboardEvent } from 'react';
-import { FlowLayoutDirection } from '@elabs-ai/components-flow';
+import { CSSProperties, HTMLAttributes, KeyboardEvent, ReactNode } from 'react';
+import { Node, Edge, NodeProps, EdgeProps, XYPosition } from '@xyflow/react';
+import { LucideIcon } from 'lucide-react';
+import { FlowLayoutDirection, FlowEdgeToken } from '@elabs-ai/components-flow';
+import { ColumnDef } from '@elabs-ai/components-data';
+import { LocaleContextValue } from '@elabs-ai/components-ui';
 
 /**
  * The framework-free event-log and process-graph model — RM-049.
@@ -12,8 +15,8 @@ import { FlowLayoutDirection } from '@elabs-ai/components-flow';
  * additive: a required field added here is a breaking change for five items at once.
  *
  * NOTHING in this module — or anywhere under `src/core/` — may import React, React Flow,
- * visx, d3 or an `@elabs-ai/components-*` package. See `.claude/rules/process-components.md`
- * and `pnpm process:reuse:check`.
+ * visx, d3 or an `@elabs-ai/components-*` package. See `.claude/rules/data.md` ("Process
+ * mining" section) and `pnpm check --rule process-reuse`.
  */
 /**
  * One raw row of an event log, before normalization.
@@ -133,6 +136,380 @@ type FrequencyMode = "absolute" | "absolute_case" | "relative" | "relative_case"
 /** Which member of a {@link DurationStats} a performance view reads. */
 type PerformanceAgg = "median" | "mean" | "min" | "max" | "sum" | "p90" | "trimmed_mean";
 
+/**
+ * Activity colour scale — RM-054.
+ *
+ * One activity, one colour, across every process view. `ProcessMap` paints the colour as
+ * a small accent mark on the activity node; `VariantExplorer` paints it on the sequence
+ * chips. Both read the SAME scale instance built from one graph, so "Create Order" is the
+ * same swatch in the map and in the variant list.
+ *
+ * ## The colour budget
+ *
+ * The chart palette ships twelve series tokens (`--chart-1` … `--chart-12`). The eleven
+ * most frequent activities (ranked by the number of cases they occur in) take
+ * `--chart-1` … `--chart-11`; every remaining activity shares `--chart-12` and is flagged
+ * `pattern: "other"`, which the views render as a hatch so "other" never reads as a
+ * twelfth distinct activity. Colour is never the only channel: every view that paints a
+ * swatch also prints the activity label (or its two-letter {@link ActivityColorScale.codeFor}
+ * code) as text.
+ *
+ * Pure and framework-free: returns token NAMES, never resolved colours, so a theme switch
+ * re-inks every swatch with no recomputation.
+ */
+
+/** How many activities get a distinct palette slot before the rest share "other". */
+declare const ACTIVITY_COLOR_SLOTS = 11;
+/** The token every activity outside the top {@link ACTIVITY_COLOR_SLOTS} shares. */
+declare const ACTIVITY_OTHER_TOKEN = "--chart-12";
+/** The colour one activity is painted with. */
+interface ActivityColor {
+    /** A CSS custom-property NAME, e.g. `"--chart-3"`. Paint with `var(${token})`. */
+    token: string;
+    /** Present for the shared "other" bucket — render the hatch, not a flat swatch. */
+    pattern?: "other";
+}
+/** One legend entry, in rank order. */
+interface ActivityColorLegendEntry extends ActivityColor {
+    activityId: string;
+    label: string;
+    /** A two-character code unique within the scale, for abbreviated ("DNA strip") chips. */
+    code: string;
+}
+/** The shared activity→colour mapping. */
+interface ActivityColorScale {
+    /** The colour for an activity. An id the graph never contained is "other". */
+    colorFor(activityId: string): ActivityColor;
+    /** The two-character code for an activity; derived from the id when it is unknown. */
+    codeFor(activityId: string): string;
+    /** The activity's display label; the id itself when it is unknown. */
+    labelFor(activityId: string): string;
+    /** Every activity in the graph, ranked by case count descending, ties by id. */
+    legend: ActivityColorLegendEntry[];
+}
+/**
+ * Build the shared colour scale for a graph.
+ *
+ * Deterministic: the same graph always yields the same assignment, regardless of the
+ * order `graph.activities` arrives in. Build it from the FULL (unfiltered, unabstracted)
+ * graph so colours stay put while a reader filters or abstracts.
+ */
+declare function activityColorScale(graph: ProcessGraph): ActivityColorScale;
+
+/**
+ * How an activity's identity colour is painted (RM-054).
+ *
+ * The ONE place that turns an {@link ActivityColor} into CSS, shared by
+ * `ProcessActivityNode`'s accent swatch and `VariantExplorer`'s sequence chips — so the
+ * two views cannot drift into painting the same activity differently. Both endpoints are
+ * semantic tokens; no literal colour is authored.
+ *
+ * The shared "other" bucket is a diagonal hatch over a light wash of the same token, so
+ * it reads as "one of many" in greyscale too, never as a twelfth distinct activity.
+ */
+
+/** Inline style for an accent swatch painted with `color`. */
+declare function activityAccentStyle(color: ActivityColor): CSSProperties;
+
+/**
+ * Event-log normalization — RM-049.
+ *
+ * Turns a flat `EventRow[]` into per-case traces of INSTANCES: one entry per real
+ * activity execution, carrying a resolved `start` and `end` in epoch milliseconds. Every
+ * other module in `/core` consumes the normalized form, so the messy parts of a raw log
+ * (three timestamp encodings, lifecycle rows split across two lines, rows arriving out of
+ * order) are handled exactly once, here.
+ *
+ * Deterministic: same rows in, same traces out. No `Date.now()`, no randomness.
+ */
+
+/** One activity execution, with both ends resolved to epoch milliseconds. */
+interface NormalizedEvent {
+    activity: string;
+    /**
+     * Start of the execution. Equals `end` for an atomic event — an event with no
+     * `lifecycle` pair and no `startTimestamp` has no observed duration, and inventing one
+     * would put fabricated numbers into every downstream statistic.
+     */
+    start: number;
+    /** Completion of the execution. */
+    end: number;
+    /** `end - start`, never negative (a clock-skewed pair is floored at 0). */
+    duration: number;
+    resource?: string;
+    attributes?: Record<string, string | number | boolean | null>;
+    /**
+     * True when this instance came from a `lifecycle: "start"` row that never got a
+     * matching `"complete"`. Its `end` is provisional (it equals `start`), so a performance
+     * view can choose to exclude it.
+     */
+    isOpen: boolean;
+}
+/** One case (process instance): its trace, plus the case's own extent. */
+interface NormalizedCase {
+    caseId: string;
+    /** Instances in ascending `start` order. Never empty. */
+    events: NormalizedEvent[];
+    /** Earliest `start` in the trace. */
+    start: number;
+    /** Latest `end` in the trace. */
+    end: number;
+    /** `end - start` — the case's throughput time. */
+    duration: number;
+    /** Per-case attributes carried over from `EventLog.caseAttributes`, when present. */
+    attributes?: Record<string, unknown>;
+}
+/** A normalized log: cases in first-appearance order, plus totals. */
+interface NormalizedLog {
+    cases: NormalizedCase[];
+    totals: {
+        cases: number;
+        events: number;
+    };
+}
+/** A log in either shape. Every derivation entry point accepts both. */
+type AnyLog = EventLog | NormalizedLog;
+
+/**
+ * Reference model — RM-061.
+ *
+ * A HAPPY PATH (the prescribed sequence of activities an owner or auditor expects) lifted
+ * to the smallest workflow-net-like structure token replay can run against: one place
+ * between consecutive steps, one visible transition per step, a silent SKIP transition
+ * beside every optional step and a SELF-LOOP transition after every repeatable one.
+ *
+ * Scope boundary (analysis §9 risk 2): this is deliberately NOT a general Petri-net
+ * importer. No BPMN, no parallel gateways, no alignments beyond skip/repeat. A host that
+ * needs full alignment-based conformance brings a backend; this module never grows one.
+ *
+ * Framework-free, deterministic: no React, no `@elabs-ai/components-*` import.
+ */
+/** One prescribed step of a happy path. */
+interface HappyPathStep {
+    /** Activity name, matched exactly against `EventRow.activity`. */
+    activity: string;
+    /** The step may be left out without a deviation (a silent skip arc is added). */
+    optional?: boolean;
+    /** The step may run several times in a row without a deviation (a self-loop is added). */
+    repeatable?: boolean;
+}
+/** A prescribed process: an ordered list of steps. */
+interface HappyPath {
+    id: string;
+    label: string;
+    steps: HappyPathStep[];
+}
+
+/**
+ * Token-based replay — RM-061.
+ *
+ * Replays each case of an event log against a {@link ReplayModel} (a lifted happy path)
+ * and scores it with the classic produced / consumed / missing / remaining token counts:
+ *
+ *     fitness = ½ · (1 − missing / consumed) + ½ · (1 − remaining / produced)
+ *
+ * The replay procedure — seed the initial marking, fire an enabled transition per event,
+ * enable a disabled one through silent transitions first, force-insert missing tokens
+ * only when that fails, then consume the final marking and count what is left over —
+ * follows the token-based replay algorithm published in pm4js (BSD-3-Clause, credited in
+ * `scripts/attributions.sources.json`). It is re-typed in TypeScript for the restricted
+ * nets `liftHappyPath` builds; no pm4js code is copied, and nothing here derives from the
+ * AGPL Python reference implementation.
+ *
+ * Deviation typing is this module's own layer on top of the counts: every forced token
+ * (and every unreachable final token) is explained by at least one
+ * {@link Deviation}, so a violation list can say WHY a case lost fitness.
+ *
+ * Scope boundary (analysis §9 risk 2): no alignment search. Replay is greedy and
+ * single-pass per trace.
+ *
+ * Framework-free, deterministic: no React, no `@elabs-ai/components-*` import.
+ */
+
+/**
+ * Why a case lost fitness.
+ *
+ * - `undesired` — the activity is not in the model at all.
+ * - `skipped` — a required modelled activity was jumped over and never observed in the case.
+ * - `wrongOrder` — the activity is modelled but its preceding place was unmarked, and the
+ *   gap is not explained by an unobserved step (it ran too early, too late, or again).
+ * - `wrongStart` — the first event of the case is not one the initial marking enables.
+ * - `incomplete` — the case ended before reaching the model's final marking.
+ */
+type DeviationType = "undesired" | "skipped" | "wrongOrder" | "wrongStart" | "incomplete";
+/** One deviation found while replaying a case. */
+interface Deviation {
+    type: DeviationType;
+    /**
+     * The activity the deviation is about: the observed event for `undesired`/`wrongOrder`/
+     * `wrongStart`, the missing step for `skipped`, the last observed event for `incomplete`.
+     */
+    activity?: string;
+    /** The activity the model expected next at that point, when one is determinable. */
+    expected?: string;
+    /**
+     * Zero-based index into the case's ordered trace of the event where the deviation was
+     * detected. `incomplete` uses the trace length (the position after the last event).
+     */
+    at: number;
+}
+/** Replay result for one case. */
+interface TraceReplayResult {
+    caseId: string;
+    produced: number;
+    consumed: number;
+    missing: number;
+    remaining: number;
+    /** `½(1 − missing/consumed) + ½(1 − remaining/produced)`, in `[0, 1]`. */
+    fitness: number;
+    deviations: Deviation[];
+}
+
+/**
+ * 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.
+ */
+
+/** Log-level conformance of an event log against a reference model. */
+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;
+    }>;
+}
+/** One point of {@link conformanceRateSeries}. */
+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;
+}
+
+/**
+ * Conformance states on the process map — RM-062.
+ *
+ * Reads a `ConformanceResult` (RM-061's `tokenReplay`) as the three-colour overlay the
+ * analysis names (§2): every activity and every observed transition is in the log AND the
+ * model (`"both"`), in the log only (`"logOnly"`), or expected by the model but missing
+ * from the log (`"modelOnly"`).
+ *
+ * ## How the state is derived — without the reference model in hand
+ *
+ * A `ConformanceResult` does not carry the model it was replayed against, and it does not
+ * need to: token replay charges an `undesired` deviation to EVERY observed event whose
+ * activity the model does not contain, so an observed activity is outside the model
+ * exactly when it carries an `undesired` deviation. The rules, in precedence order:
+ *
+ * | element    | state        | when                                                         |
+ * | ---------- | ------------ | ------------------------------------------------------------ |
+ * | activity   | `logOnly`    | at least one `undesired` deviation names it                  |
+ * | activity   | `modelOnly`  | at least one `skipped` deviation names it (cases jumped it)   |
+ * | activity   | `both`       | otherwise                                                    |
+ * | transition | `logOnly`    | deviations are charged to it, or either endpoint is `logOnly` |
+ * | transition | `both`       | otherwise                                                    |
+ *
+ * A transition is never `modelOnly`: every edge on the map was observed. A model step
+ * that NO case ever reached is not on the graph at all, so it cannot be painted here —
+ * `ViolationList` still counts the cases that skipped it.
+ *
+ * ## Never colour alone (WCAG 1.4.1, analysis §5.4)
+ *
+ * Each state pairs a status tone with a distinct glyph AND a distinct line style —
+ * solid circle / hollow triangle / dashed square — so the three read apart in greyscale.
+ * {@link CONFORMANCE_STATE_ENCODING} is the one table every surface reads it from.
+ */
+
+/** Where an element sits relative to the reference model. */
+type ConformanceState = "both" | "logOnly" | "modelOnly";
+/** Every {@link ConformanceState}, in legend order. */
+declare const CONFORMANCE_STATES: readonly ConformanceState[];
+/** The status tone a state is painted with. */
+type ConformanceTone = "success" | "warning" | "destructive";
+/** The line style a state is drawn with — the second non-colour channel. */
+type ConformanceDash = "solid" | "dotted" | "dashed";
+/** Everything that encodes one state, colour included. */
+interface ConformanceStateEncoding {
+    tone: ConformanceTone;
+    /** Stable glyph name, mirrored to `data-glyph` so a test can assert distinctness. */
+    glyph: "circle" | "triangle" | "square";
+    /** Lucide glyph drawn for the state. */
+    icon: LucideIcon;
+    /** Whether the glyph is filled (`true`) or an outline. */
+    filled: boolean;
+    dash: ConformanceDash;
+    /** SVG `stroke-dasharray` for a transition stroke; `undefined` keeps the edge's own. */
+    strokeDasharray: string | undefined;
+    /** Mark (fill-rung) utility for a glyph or swatch. */
+    markClass: string;
+    /** Ink (`-text` rung) utility for coloured text. */
+    textClass: string;
+    /** Border utilities: the tone's fill rung plus the line style. */
+    borderClass: string;
+    /** CSS colour reference for a stroke or a `--border` override. */
+    colorVar: string;
+}
+/** The single source of truth for how each state looks. */
+declare const CONFORMANCE_STATE_ENCODING: Readonly<Record<ConformanceState, ConformanceStateEncoding>>;
+/** The words for each state. Override through a component's `labels` to localize. */
+interface ConformanceStateLabels {
+    both: string;
+    logOnly: string;
+    modelOnly: string;
+    /** The table twin's column header and the legend's title. */
+    column: string;
+}
+/** The shipped English words for each state. */
+declare const CONFORMANCE_STATE_DEFAULT_LABELS: Readonly<ConformanceStateLabels>;
+/** Per-element conformance states for one `ConformanceResult`. */
+interface ConformanceStates {
+    /** Keyed by activity id. An activity absent here is `"both"`. */
+    activities: ReadonlyMap<string, ConformanceState>;
+    /**
+     * Keyed `source + EDGE_KEY_SEPARATOR + target` — the id `discoverGraph` and the map give
+     * the transition. A transition absent here is resolved by {@link transitionConformance}.
+     */
+    transitions: ReadonlyMap<string, ConformanceState>;
+}
+/** Derive activity and transition states from a replay result. See this module's docblock. */
+declare function resolveConformanceStates(conformance: ConformanceResult): ConformanceStates;
+/** The state of one activity. */
+declare function activityConformance(states: ConformanceStates, activity: string): ConformanceState;
+/** The state of one observed transition. */
+declare function transitionConformance(states: ConformanceStates, source: string, target: string): ConformanceState;
+/**
+ * A map node with its conformance state folded in: `data.conformance` for the glyph and
+ * dash, `data-conformance` on React Flow's own node element (additive to
+ * `data-selection`), and the state's word appended to the accessible name — so the state
+ * reaches assistive technology as text, never as colour.
+ */
+declare function withActivityConformance(node: ProcessMapNode, states: ConformanceStates, labels?: ConformanceStateLabels): ProcessMapNode;
+/** A map edge with its conformance state folded in. See {@link withActivityConformance}. */
+declare function withTransitionConformance(edge: ProcessMapEdge, states: ConformanceStates, labels?: ConformanceStateLabels): ProcessMapEdge;
+
 /**
  * Rework detection — RM-050.
  *
@@ -240,6 +617,83 @@ type FilterSpec =
     ids: string[];
 };
 
+/** Options for {@link abstractGraph}. Both fractions are `0..1` and both are required. */
+interface AbstractionOptions {
+    /** Fraction of activities to KEEP, `0..1`. At least one activity is always kept. */
+    activities: number;
+    /** Fraction of paths (transitions) to KEEP, `0..1`, over the kept-activity subgraph. */
+    paths: number;
+    /**
+     * Re-add whatever it takes to keep every kept activity reachable from a start activity
+     * and able to reach an end activity. Defaults to `true` — an island reads as a broken
+     * process, not a simplified one.
+     */
+    keepConnected?: boolean;
+    /** Hide the MOST frequent instead of the least — the "what is rare here" view. */
+    invert?: boolean;
+}
+/** What {@link abstractGraph} returns: a `ProcessGraph` plus what it left out. */
+interface AbstractedGraph extends ProcessGraph {
+    hidden: {
+        /** Activities present in the input graph and absent from this one. */
+        activities: number;
+        /** Transitions present in the input graph and absent from this one. */
+        paths: number;
+    };
+}
+
+/**
+ * Object-centric directly-follows graph (OC-DFG) discovery — RM-066.
+ *
+ * An OC-DFG is one directly-follows graph PER OBJECT TYPE, drawn on one canvas: activities
+ * shared between types merge into a single node that keeps a per-type breakdown, while
+ * edges stay per type — an `order` following and an `item` following are different
+ * relations, so they are never summed into one arrow. The merge semantics (per-type
+ * projection, shared-activity join, per-type edges) follow pm4js's documented OC-DFG
+ * construction; see `ATTRIBUTION.md`. No pm4js code is copied, and nothing here derives
+ * from the AGPL Python reference implementation.
+ *
+ * Built entirely on `discoverGraph` and `abstractGraph`: every per-type number is exactly
+ * what the single-case pipeline would print for that type's projection.
+ */
+
+/** One object type's share of a merged activity. */
+interface ObjectTypeActivityCounts {
+    /** Occurrences in that type's projection (one per event × referenced object). */
+    instances: number;
+    /** Distinct objects of that type the activity touches. */
+    cases: number;
+}
+/** A merged activity: shared across object types, with a per-type breakdown. */
+interface ObjectCentricActivityStats extends Omit<ActivityStats, "instances" | "cases"> {
+    /**
+     * Distinct OCEL events of this activity across every type — an event that references an
+     * order and two items counts once. Falls back to the largest per-type `instances` when
+     * the logs carry no `__ocelEventId` (hand-built logs).
+     */
+    events: number;
+    /** Object type → counts, only for the types this activity occurs in. */
+    perType: Record<string, ObjectTypeActivityCounts>;
+}
+/** An object-centric directly-follows graph. */
+interface ObjectCentricGraph {
+    /** Merged activities, busiest (by `events`) first, ties by id. */
+    activities: ObjectCentricActivityStats[];
+    /** Object type → that type's own directly-follows edges. Never merged across types. */
+    transitionsByType: Record<string, TransitionStats[]>;
+    /** The object types, in the caller's order. */
+    objectTypes: string[];
+    /** Object type → the full per-type graph the merge was built from. */
+    graphsByType: Record<string, ProcessGraph>;
+}
+/** {@link abstractObjectCentricGraph}'s result — what each type's abstraction hid. */
+interface AbstractedObjectCentricGraph extends ObjectCentricGraph {
+    hiddenByType: Record<string, {
+        activities: number;
+        paths: number;
+    }>;
+}
+
 /**
  * map-model — the pure `ProcessGraph → React Flow nodes/edges` mapping (RM-051).
  *
@@ -392,6 +846,22 @@ interface ProcessActivityNodeData extends Record<string, unknown> {
     /** Repeat executions of this activity across the log; omitted when no rework data. */
     reworkCount?: number;
     selectionState: ProcessSelectionState;
+    /**
+     * The activity's identity colour from a shared `ActivityColorScale` (RM-054), painted as
+     * a small accent swatch — never the card fill, which would fight the metric reading.
+     * Absent when the map was given no `colorScale`.
+     */
+    accent?: ActivityColor;
+    /**
+     * Where this activity sits against a reference model (RM-062). Set only when the map
+     * was given `conformance`; drives `data-conformance` plus its glyph and dash.
+     */
+    conformance?: ConformanceState;
+    /**
+     * Object-centric — RM-066. One entry per object type this activity occurs in, in the
+     * graph's type order. Set only in object-centric mode; drives the per-type chips.
+     */
+    objectTypes?: ProcessObjectTypeCount[];
 }
 /** `data` carried by every {@link ProcessMapEdge}. */
 interface ProcessTransitionEdgeData extends Record<string, unknown> {
@@ -409,6 +879,32 @@ interface ProcessTransitionEdgeData extends Record<string, unknown> {
     isSelfLoop: boolean;
     isBackEdge: boolean;
     selectionState: ProcessSelectionState;
+    /**
+     * This transition's composed accessible name ({@link transitionAriaLabel}), duplicated
+     * here from the edge object's own `ariaLabel` (#354). React Flow's `EdgeWrapper` reads
+     * `ariaLabel` off the edge OBJECT for the outer, non-focusable `<g>` — it never forwards
+     * it to the edge COMPONENT via `EdgeProps` (`@xyflow/react`'s `EdgeProps` type has no
+     * `ariaLabel` field) — so `ProcessTransitionEdge`, which only receives `data`, has no
+     * other channel to reach it. Read this field, never recompute the name locally, or the
+     * canvas and the `TableView` twin (`transitionRows`) can drift apart. Always set by
+     * {@link buildProcessMapModel} — optional only because it is filled in a step after the
+     * rest of this object (it is itself derived from this object).
+     */
+    ariaLabel?: string;
+    /**
+     * Where this transition sits against a reference model (RM-062). Set only when the map
+     * was given `conformance`; drives `data-conformance` plus its glyph and dash.
+     */
+    conformance?: ConformanceState;
+    /**
+     * Object-centric — RM-066. The object type this edge belongs to; per-type edges between
+     * the same two activities are drawn side by side (see `parallelIndex`/`parallelCount`).
+     */
+    objectType?: ProcessObjectTypeMark;
+    /** Object-centric — RM-066. This edge's slot among the per-type edges of its pair. */
+    parallelIndex?: number;
+    /** Object-centric — RM-066. How many per-type edges join this edge's pair. */
+    parallelCount?: number;
 }
 /** A process-map activity node. Register as `nodeTypes={{ "process-activity": … }}`. */
 type ProcessMapNode = Node<ProcessActivityNodeData, "process-activity">;
@@ -423,6 +919,8 @@ interface ProcessActivityRow {
     reworkCount?: number;
     role: string;
     selectionState: ProcessSelectionState;
+    /** Object-centric — RM-066. Per-type counts, as printed in the table twin. */
+    objectTypes?: string;
 }
 /** One row of the accessible `TableView` twin — transitions half. */
 interface ProcessTransitionRow {
@@ -433,6 +931,8 @@ interface ProcessTransitionRow {
     secondaryLabel?: string;
     shape: string;
     selectionState: ProcessSelectionState;
+    /** Object-centric — RM-066. The object type's display name. */
+    objectType?: string;
 }
 /** Everything the canvas and the table are both rendered from. */
 interface ProcessMapModel {
@@ -586,12 +1086,17 @@ interface BuildProcessMapModelOptions {
      * every edge starts `isBackEdge: false` exactly as `discoverGraph` leaves it.
      */
     backEdgeIds?: ReadonlySet<string>;
+    /**
+     * The shared activity colour scale (RM-054). When given, every node carries
+     * `data.accent`, so the map and `VariantExplorer` paint an activity identically.
+     */
+    colorScale?: ActivityColorScale;
 }
 /**
  * Map a discovered (or abstracted) graph plus a metric choice into everything both the
  * canvas and the table render. Pure: same inputs, same model, no clock and no DOM.
  */
-declare function buildProcessMapModel({ graph, metric, rework, selection, selectionStates, backEdgeIds, }: BuildProcessMapModelOptions): ProcessMapModel;
+declare function buildProcessMapModel({ graph, metric, rework, selection, selectionStates, backEdgeIds, colorScale, }: BuildProcessMapModelOptions): ProcessMapModel;
 /**
  * The word for an activity's position in the process — printed in the table's own column
  * and folded into the node's accessible name, so "this is where cases start" survives
@@ -624,31 +1129,67 @@ declare const PROCESS_SELECTION_STATE_MESSAGE_KEYS: Readonly<Partial<Record<Proc
 declare function activityAriaLabel(data: ProcessActivityNodeData): string;
 /** The accessible name of one transition edge. */
 declare function transitionAriaLabel(data: ProcessTransitionEdgeData, metricLabel: string): string;
-
-/** Options for {@link abstractGraph}. Both fractions are `0..1` and both are required. */
-interface AbstractionOptions {
-    /** Fraction of activities to KEEP, `0..1`. At least one activity is always kept. */
-    activities: number;
-    /** Fraction of paths (transitions) to KEEP, `0..1`, over the kept-activity subgraph. */
-    paths: number;
+/** How one object type is marked on the map: a name, a text code and a chart colour. */
+interface ProcessObjectTypeMark {
+    /** The object type's id, as keyed in the `ObjectCentricGraph`. */
+    type: string;
+    /** Display name. */
+    label: string;
+    /** Two-character code printed beside every swatch — the non-colour channel. */
+    code: string;
+    /** A categorical chart token from `objectTypeColorScale` (RM-054's scale, reused). */
+    color: ActivityColor;
+}
+/** One object type's share of an activity node. */
+interface ProcessObjectTypeCount extends ProcessObjectTypeMark {
+    instances: number;
+    /** Distinct objects of this type the activity touches. */
+    cases: number;
+    /** The chip's accessible name, e.g. "order: 2 objects, 3 occurrences". */
+    ariaLabel: string;
+}
+/** Every string the object-centric mode composes. Override for a non-English locale. */
+interface ObjectCentricMapLabels {
+    /** A node chip's accessible name and table text. */
+    typeCount: (type: string, objects: number, occurrences: number) => string;
+    /** Prefixes a per-type edge's accessible name. */
+    edgePrefix: (type: string) => string;
+    /** Activity-table column header. */
+    columnObjectTypes: string;
+    /** Transition-table column header. */
+    columnObjectType: string;
+    /** The canvas legend's title. */
+    legendTitle: string;
+}
+/** English defaults for {@link ObjectCentricMapLabels}. */
+declare const OBJECT_CENTRIC_MAP_DEFAULT_LABELS: Readonly<ObjectCentricMapLabels>;
+/** The id of one object type's edge: the merged edge id, the separator, the type. */
+declare function objectCentricEdgeId(source: string, target: string, type: string): string;
+/** Inputs to {@link buildObjectCentricMapModel}. */
+interface BuildObjectCentricMapModelOptions extends BuildProcessMapModelOptions {
     /**
-     * Re-add whatever it takes to keep every kept activity reachable from a start activity
-     * and able to reach an end activity. Defaults to `true` — an island reads as a broken
-     * process, not a simplified one.
+     * The object-centric graph `graph` was flattened from (`objectCentricProcessGraph`).
+     * Omit — or omit `objectTypeScale` — and this is exactly {@link buildProcessMapModel}.
      */
-    keepConnected?: boolean;
-    /** Hide the MOST frequent instead of the least — the "what is rare here" view. */
-    invert?: boolean;
-}
-/** What {@link abstractGraph} returns: a `ProcessGraph` plus what it left out. */
-interface AbstractedGraph extends ProcessGraph {
-    hidden: {
-        /** Activities present in the input graph and absent from this one. */
-        activities: number;
-        /** Transitions present in the input graph and absent from this one. */
-        paths: number;
-    };
+    objectCentric?: ObjectCentricGraph;
+    /** `objectTypeColorScale(objectCentric)`, built once from the FULL graph. */
+    objectTypeScale?: ActivityColorScale;
+    objectCentricLabels?: ObjectCentricMapLabels;
 }
+/**
+ * The object-centric process-map model: {@link buildProcessMapModel} over the flattened
+ * graph, then
+ *
+ * - every node gains `data.objectTypes` (one chip per type, each with a text code and a
+ *   real accessible name folded into the node's own), and
+ * - every merged edge is replaced by one edge PER OBJECT TYPE — its weight and printed
+ *   label read that type's own counts, its label is prefixed with the type's code, and its
+ *   stroke is the type's chart token. The edge-value colour ramp is never used here.
+ *
+ * A transition selection may name either a per-type edge or the merged pair; both select
+ * the pair's neighbourhood, and only the named per-type edge reads `"selected"`.
+ */
+declare function buildObjectCentricMapModel({ objectCentric, objectTypeScale, objectCentricLabels, ...options }: BuildObjectCentricMapModelOptions): ProcessMapModel;
 
 /**
  * The zoom the map refuses to open below, however big the process is.
@@ -704,11 +1245,66 @@ interface ProcessMapProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect
     tableView?: boolean;
     /** No graph yet. Renders the loading panel rather than an empty canvas. */
     loading?: boolean;
+    /**
+     * A shared activity colour scale (RM-054, `/core`'s `activityColorScale`). When given,
+     * each activity node shows its identity swatch — the same colour `VariantExplorer`
+     * paints that activity with. Build it once from the FULL graph and hand the same
+     * instance to both views. Omit for today's uncoloured nodes.
+     */
+    colorScale?: ActivityColorScale;
+    /**
+     * A replay result (RM-061's `tokenReplay`) to overlay (RM-062). When given, every node
+     * and edge carries `data-conformance="both" | "logOnly" | "modelOnly"` — additive to
+     * `data-selection` — painted as a status tone PLUS a glyph and a line style, with the
+     * state's word in the accessible name and a Conformance column in the table twin. Omit
+     * for today's map, unchanged. Usually reached through `ConformanceOverlay`.
+     */
+    conformance?: ConformanceResult;
+    /**
+     * Object-centric — RM-066. An object-centric graph (`discoverObjectCentricGraph`, e.g.
+     * over `fromOcel(…).logs`) to draw instead of `graph`/`log` — mutually exclusive with
+     * both, and it wins when given together (with a dev-mode console warning). Shared
+     * activities merge into one node carrying a chip per object type; edges are drawn once
+     * per object type in that type's chart colour, side by side. `abstraction` applies to
+     * every type alike; for per-type abstraction pass `abstractObjectCentricGraph(…)`'s
+     * result here instead.
+     */
+    objectCentric?: ObjectCentricGraph;
+    /** Object-centric — RM-066. Strings the object-centric mode composes. */
+    objectCentricLabels?: ObjectCentricMapLabels;
     /**
      * Accessible name for the canvas region. Defaults to the localized
      * `process.map.label` message.
      */
     label?: string;
+    /**
+     * The smallest zoom the OPENING fit may use. The default keeps activity names legible
+     * and, when the process does not fit at that size, opens on its start. A workspace that
+     * would rather open on the whole picture — a wide canvas, a reader who zooms in on what
+     * matters — lowers it. The reader can always zoom out further by hand.
+     * @default PROCESS_MAP_LEGIBLE_ZOOM
+     */
+    fitMinZoom?: number;
+    /**
+     * The fraction of the pane the opening fit keeps clear on every side. The default is
+     * generous because transition pills are drawn outside the fitted bounds; a pane that is
+     * short on the axis the process runs along can trade some of it for a larger picture.
+     * @default 0.15
+     */
+    fitPadding?: number;
+    /**
+     * Re-frames the map whenever this value changes. The map already re-fits when its own
+     * structure or direction changes; it cannot know that the pane around it just changed
+     * shape — a dock opened, a side panel closed. Pass anything that changes when that
+     * happens. Unset: no extra re-fits, the reader's viewport is left alone.
+     */
+    refitKey?: string | number;
+    /**
+     * The layout engine. `"elk"` lays the map out with `@elabs-ai/components-flow`'s
+     * `layoutFlowElk` — elkjs, an optional peer, loaded lazily on first use; when it is not
+     * installed the map falls back to dagre with a development-only warning. @default "dagre"
+     */
+    layoutEngine?: "dagre" | "elk";
 }
 /**
  * The process map.
@@ -718,7 +1314,7 @@ interface ProcessMapProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect
  * <ProcessMap log={log} metric={{ node: "absolute_case", edge: "absolute" }} />
  * ```
  */
-declare function ProcessMap({ graph, log, abstraction, metric, rework, selection, selectionStates, onSelect, onFilterIntent, direction, showMiniMap, showLegend, tableView, loading, label, className, ...props }: ProcessMapProps): react.JSX.Element;
+declare function ProcessMap({ graph, log, abstraction, metric, rework, selection, selectionStates, onSelect, onFilterIntent, direction, showMiniMap, showLegend, tableView, loading, colorScale, conformance, objectCentric, objectCentricLabels, label, layoutEngine, fitMinZoom, fitPadding, refitKey, className, ...props }: ProcessMapProps): react.JSX.Element;
 
 /** What the node and edge components read while something is hovered. */
 interface ProcessMapHoverState {
@@ -829,6 +1425,11 @@ interface UseProcessLayoutOptions {
     direction: FlowLayoutDirection;
     /** @default {@link DEFAULT_LAYOUT_DEBOUNCE_MS} */
     debounceMs?: number;
+    /**
+     * Which layout engine runs. `"elk"` calls `layoutFlowElk` (async, lazily loaded, falls
+     * back to dagre when elkjs is not installed) instead of `layoutFlow`. @default "dagre"
+     */
+    layoutEngine?: "dagre" | "elk";
 }
 /** What {@link useProcessLayout} answers. */
 interface UseProcessLayoutResult {
@@ -853,7 +1454,7 @@ declare function applyLayoutSnapshot(nodes: ProcessMapNode[], snapshot: ProcessL
  * @see {@link UseProcessLayoutResult.layoutRuns} — the observable proof that a metric-only
  * change does not re-run dagre.
  */
-declare function useProcessLayout({ nodes, edges, structureKey, direction, debounceMs, }: UseProcessLayoutOptions): UseProcessLayoutResult;
+declare function useProcessLayout({ nodes, edges, structureKey, direction, debounceMs, layoutEngine, }: UseProcessLayoutOptions): UseProcessLayoutResult;
 
 interface AbstractionControlsProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
     /** The current abstraction — both fractions, `invert`, and (read-only here) `keepConnected`. */
@@ -871,7 +1472,36 @@ interface AbstractionControlsProps extends Omit<HTMLAttributes<HTMLDivElement>,
     autoMaxActivities?: number;
     /** Accessible name for the control group. Default from locale. */
     label?: string;
+    /**
+     * Object-centric — RM-066. One slider pair per object type, keyed by type, rendered as
+     * collapsible rows under the global pair. A `linked` type (the default) follows the
+     * global sliders proportionally; toggle its link to abstract it on its own. Feed the
+     * result to `abstractObjectCentricGraph`.
+     */
+    perType?: Readonly<Record<string, ObjectTypeAbstraction>>;
+    /** Object-centric — RM-066. Called with the whole next per-type record. */
+    onPerTypeChange?(next: Record<string, ObjectTypeAbstraction>): void;
+    /** Object-centric — RM-066. Strings for the per-type rows. */
+    perTypeLabels?: ObjectTypeAbstractionLabels;
+}
+/** Object-centric — RM-066. One object type's abstraction fractions. */
+interface ObjectTypeAbstraction {
+    /** Fraction of this type's activities to keep, `0..1`. */
+    activities: number;
+    /** Fraction of this type's paths to keep, `0..1`. */
+    paths: number;
+    /** Follow the global sliders proportionally. @default true */
+    linked?: boolean;
 }
+/** Object-centric — RM-066. Strings for the per-type rows. */
+interface ObjectTypeAbstractionLabels {
+    section: string;
+    link: (type: string) => string;
+    activities: (type: string) => string;
+    paths: (type: string) => string;
+}
+/** English defaults for {@link ObjectTypeAbstractionLabels}. */
+declare const OBJECT_TYPE_ABSTRACTION_DEFAULT_LABELS: Readonly<ObjectTypeAbstractionLabels>;
 declare const AbstractionControls: react.ForwardRefExoticComponent<AbstractionControlsProps & react.RefAttributes<HTMLDivElement>>;
 
 /**
@@ -977,13 +1607,30 @@ interface ProcessKpiStripKpis {
 type ProcessKpiStripTrendKey = keyof ProcessKpiStripKpis | "conformance";
 interface ProcessKpiStripProps extends HTMLAttributes<HTMLDivElement> {
     kpis: ProcessKpiStripKpis;
-    /** `0..1`, or `null`/`undefined` when no conformance model has been fitted. */
-    conformance?: number | null;
+    /**
+     * `0..1`, a replay result (RM-061's `tokenReplay`, whose `overallFitness` the tile
+     * prints — RM-062), or `null`/`undefined` when no conformance model has been fitted.
+     */
+    conformance?: number | ConformanceResult | null;
     /** Optional per-tile trend series (oldest -> newest), keyed by KPI. */
     trends?: Partial<Record<ProcessKpiStripTrendKey, number[]>>;
+    /**
+     * Conformance rate over time (`conformanceRateSeries`), plotted as the conformance
+     * tile's sparkline — the rate-over-time reading (RM-062). Takes precedence over
+     * `trends.conformance`.
+     */
+    conformanceSeries?: ConformanceRatePoint[];
     loading?: boolean;
+    /**
+     * How the six numbers are laid out. `"grid"` (default) is the card grid a dashboard page
+     * opens with. `"inline"` is one dense ribbon — label, value and sparkline per cell, divided
+     * by hairlines, scrolling sideways when it runs out of room — for a workspace whose height
+     * belongs to the process map, not to its KPIs. Same numbers, same formats, same sparkline
+     * text alternatives in both.
+     */
+    layout?: "grid" | "inline";
 }
-declare function ProcessKpiStrip({ kpis, conformance, trends, loading, className, ...props }: ProcessKpiStripProps): react.JSX.Element;
+declare function ProcessKpiStrip({ kpis, conformance, trends, conformanceSeries, loading, layout, className, ...props }: ProcessKpiStripProps): react.JSX.Element;
 
 /**
  * Off-thread discovery — RM-050.
@@ -1052,9 +1699,15 @@ interface ProcessExplorerMetricSpec {
  * variant selection — a case a click on the process map can never produce, but a click on a
  * variant row can. The widening is local to this hook's own type alias; it does not touch
  * `ProcessFilterIntent` or `ProcessMap`'s menu, which still only ever emits the original four.
+ *
+ * `{ kind: "cases" }` joins it for the same reason: `DottedChart` (RM-059) and
+ * `PerformanceSpectrum` (RM-060) brush a set of case ids, so their `onFilterIntent` can be
+ * wired straight to `applyIntent`.
  */
 type FilterIntent = ProcessFilterIntent | Extract<FilterSpec, {
     kind: "variant";
+}> | Extract<FilterSpec, {
+    kind: "cases";
 }>;
 /** Options for {@link useProcessExplorer}. */
 interface ProcessExplorerOptions {
@@ -1095,6 +1748,17 @@ interface UseProcessExplorerResult {
     applyIntent(intent: FilterIntent): void;
     clearIntent(index: number): void;
     intents: FilterIntent[];
+    /**
+     * How many cases EACH active intent alone excludes — parallel to {@link intents} (same
+     * index), for `ProcessFilterBar` (RM-056, #205)'s per-chip "excluded N" count. For intent
+     * `i`, this is the case count filtered by every intent BEFORE `i` minus the case count
+     * filtered by every intent up to and including `i` — so it isolates what `i` itself
+     * removes from the chain, not what the whole chain removes. `[]` when no intents are
+     * active. Computed with one `filterNormalizedLog` call per prefix (`n + 1` calls for `n`
+     * intents, reusing each prefix's count for both the term it ends and the term it starts),
+     * never `n²` — additive field, `intents`/`applyIntent`/`clearIntent` are unchanged.
+     */
+    excludedByIntent: number[];
     filteredLog: EventLog;
     /**
      * Per-element states the active filter contributes — pass straight into `ProcessMap`'s
@@ -1150,4 +1814,1195 @@ interface UseProcessExplorerResult {
  */
 declare function useProcessExplorer(log: EventLog, opts?: ProcessExplorerOptions): UseProcessExplorerResult;
 
-export { AbstractionControls, type AbstractionControlsProps, type ActivityFrequencyMode, type AutoAbstractionOptions, type AutoAbstractionResult, type BuildProcessMapModelOptions, DEFAULT_LAYOUT_DEBOUNCE_MS, EMPTY_PROCESS_MAP_HOVER, type FilterIntent, GHOST_OPACITY, type MetricLayer, MetricLayerSwitch, type MetricLayerSwitchMetric, type MetricLayerSwitchProps, PROCESS_FILTER_INTENT_KINDS, PROCESS_FILTER_INTENT_LABELS, PROCESS_FILTER_INTENT_MESSAGE_KEYS, PROCESS_MAP_EDGE_SCALE_GROUP, PROCESS_MAP_LEGIBLE_ZOOM, PROCESS_MAP_NODE_MOTION_CLASS, PROCESS_SELECTION_STATE_MESSAGE_KEYS, ProcessActivityNode, type ProcessActivityNodeData, type ProcessActivityRow, type ProcessEdgeDenominators, type ProcessExplorerMetric, type ProcessExplorerMetricSpec, type ProcessExplorerOptions, type ProcessFilterIntent, ProcessKpiStrip, type ProcessKpiStripKpis, type ProcessKpiStripProps, type ProcessKpiStripTrendKey, type ProcessLayoutSnapshot, ProcessMap, type ProcessMapEdge, ProcessMapEdgeKeyContext, type ProcessMapEdgeKeyHandler, type ProcessMapExcludedCounts, ProcessMapHoverContext, type ProcessMapHoverState, type ProcessMapModel, type ProcessMapNode, type ProcessMapProps, type ProcessMetric, type ProcessMetricSpec, type ProcessSelection, type ProcessSelectionKind, type ProcessSelectionNeighbourhood, type ProcessSelectionState, type ProcessSelectionStates, ProcessTransitionEdge, type ProcessTransitionEdgeData, type ProcessTransitionRow, type TransitionFrequencyMode, type UseProcessExplorerResult, type UseProcessLayoutOptions, type UseProcessLayoutResult, activityAriaLabel, activityMetricValue, activityRole, applyLayoutSnapshot, buildProcessMapModel, computeAutoAbstraction, edgeMetricLabel, formatDurationMs, formatMetricValue, isPerformanceMetric, nodeMetricLabel, processEdgeDenominators, processEdgeId, processGraphStructureKey, resolveActivityFrequencyMode, resolveSelectionState, resolveTransitionFrequencyMode, selectionNeighbourhood, selectionStateLabel, transitionAriaLabel, transitionMetricValue, transitionShape, useProcessExplorer, useProcessLayout, useProcessMapEdgeKeys, useProcessMapHover };
+/**
+ * Pure helpers behind `VariantExplorer` (RM-054) — no React, so the selection semantics
+ * are unit-testable on their own and identical on every render.
+ */
+
+/** The optional numeric columns a variant row can show, in display order. */
+type VariantExplorerColumn = "cases" | "coverage" | "medianDuration";
+/** Every column, in the order the explorer renders them. */
+declare const VARIANT_EXPLORER_COLUMNS: readonly VariantExplorerColumn[];
+/**
+ * The smallest prefix of `variants` whose `cumulativeShare` reaches `target`.
+ *
+ * `variants` is expected in `extractVariants` order (count descending, fully tie-broken),
+ * so the prefix is the set of most frequent paths that together cover `target` of the
+ * cases. Deterministic: the same variants and target always yield the same id list. A
+ * target of `0` or less selects nothing; a target above the last variant's share selects
+ * every variant. A tiny epsilon absorbs float noise in `cumulativeShare` so a `0.5`
+ * target is met by a variant whose share prints as exactly 50 %.
+ */
+declare function selectVariantsByCoverage(variants: readonly Variant[], target: number): string[];
+
+/** Row height in px — fixed, so the virtualizer never has to measure. Matches `h-10`. */
+declare const VARIANT_EXPLORER_ROW_HEIGHT = 40;
+/** How a selection change applies: replace the whole selection, or flip these ids. */
+type VariantSelectMode = "replace" | "toggle";
+/**
+ * Every user-visible string. `{name}` placeholders are filled at render. Override any
+ * subset through `labels` to localize.
+ */
+interface VariantExplorerLabels {
+    /** Accessible name of the list. */
+    list: string;
+    columnVariant: string;
+    columnSequence: string;
+    columnCases: string;
+    columnCoverage: string;
+    columnMedianDuration: string;
+    columnState: string;
+    /** `{rank}`, `{activities}`, `{cases}`, `{coverage}` (a whole percent number). */
+    rowSummary: string;
+    /** `{activities}` — the sequence joined with commas. */
+    sequence: string;
+    activitiesOne: string;
+    activitiesOther: string;
+    casesOne: string;
+    casesOther: string;
+    selected: string;
+    excluded: string;
+    coverageTarget: string;
+    /** `{percent}`, `{count}`. */
+    coverageTargetValue: string;
+    filterToSelected: string;
+    tableCaption: string;
+    loading: string;
+    empty: string;
+    emptyBody: string;
+}
+/** The shipped English labels. */
+declare const VARIANT_EXPLORER_DEFAULT_LABELS: Readonly<VariantExplorerLabels>;
+/** Props for {@link VariantExplorer}. `onSelect` shadows the DOM handler, so it is omitted. */
+interface VariantExplorerProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** Variants in `extractVariants` order (count descending). */
+    variants: Variant[];
+    /** The shared colour scale — hand `ProcessMap` the same instance. */
+    colorScale: ActivityColorScale;
+    /** Tri-state per variant id; an absent key means `"associated"`. */
+    selectionStates?: ProcessSelectionStates;
+    /** Fires with the ids to select and how to apply them. The explorer never filters. */
+    onSelect: (variantIds: string[], mode: VariantSelectMode) => void;
+    /** When given, a button emits `{ kind: "variant", ids }` for the selected variants. */
+    onFilterIntent?: (intent: FilterIntent) => void;
+    /** Numeric columns to show. @default ["cases", "coverage", "medianDuration"] */
+    columns?: VariantExplorerColumn[];
+    /**
+     * Initial coverage target, `0..1`. When given, a slider selects the smallest prefix of
+     * variants whose cumulative share reaches the target (mode `"replace"`).
+     */
+    coverageTarget?: number;
+    /** "Variant DNA" strip: two-character codes instead of full activity labels. */
+    abbreviate?: boolean;
+    /**
+     * `"swatch"`: each step is one identity block with no text — the densest strip, for a
+     * narrow rail. The strip keeps its accessible name and every block its `title`.
+     * @default "text"
+     */
+    sequenceDisplay?: "text" | "swatch";
+    /** Render the accessible table twin instead of the list. @default false */
+    tableView?: boolean;
+    /** No variants yet. Renders the loading panel rather than an empty list. */
+    loading?: boolean;
+    /** Override any user-visible string. */
+    labels?: Partial<VariantExplorerLabels>;
+}
+/**
+ * The variant explorer.
+ *
+ * @example
+ * ```tsx
+ * const scale = useMemo(() => activityColorScale(fullGraph), [fullGraph]);
+ * <VariantExplorer
+ *   variants={explorer.variants}
+ *   colorScale={scale}
+ *   selectionStates={explorer.selectionStates}
+ *   onSelect={(ids) => explorer.applyIntent({ kind: "variant", ids })}
+ * />
+ * ```
+ */
+declare const VariantExplorer: react.ForwardRefExoticComponent<VariantExplorerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ProcessFilterBarProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The active filter chain — `useProcessExplorer`'s own `intents`, in order. */
+    intents: FilterIntent[];
+    /**
+     * How many cases EACH intent alone excludes, parallel to {@link intents} (same index) —
+     * `useProcessExplorer`'s own additive `excludedByIntent` field.
+     */
+    excludedByIntent: number[];
+    /** The unfiltered case count — the right half of the summary line's "X of Y". */
+    totalCases: number;
+    /** `useProcessExplorer`'s `kpis.cases` — the left half of the summary line's "X of Y". */
+    filteredCases: number;
+    /** What abstraction currently hides — `useProcessExplorer`'s own `hiddenCounts`. */
+    hiddenCounts?: {
+        activities: number;
+        paths: number;
+    };
+    /** Remove one intent by its index into {@link intents} — wire to `clearIntent`. */
+    onRemove(index: number): void;
+    /** Remove every intent at once. */
+    onClearAll(): void;
+    /** Accessible name for the chip row. Default from locale. */
+    label?: string;
+}
+/**
+ * Filter chain breadcrumbs: one removable chip per active intent, each carrying how many
+ * cases that intent alone excludes, plus a summary line stating what filtering and
+ * abstraction currently hide.
+ */
+declare const ProcessFilterBar: react.ForwardRefExoticComponent<ProcessFilterBarProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * 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).
+ */
+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>;
+}
+/**
+ * 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.
+ */
+declare function casesFromLog(log: EventLog): CaseRow[];
+
+interface CaseTableProps extends HTMLAttributes<HTMLDivElement> {
+    cases: CaseRow[];
+    /** Column configuration over `DataTable`. Defaults to `createCaseTableColumns`'s set. */
+    columns?: ColumnDef<CaseRow>[];
+    /** Fired when a row is activated (click, or Enter/Space on its keyboard activation target). */
+    onCaseOpen?: (caseId: string) => void;
+    /** File name for the CSV export. Default `"cases.csv"`. */
+    exportFileName?: string;
+    loading?: boolean;
+    /** Message shown when there are no cases and not loading. */
+    emptyMessage?: ReactNode;
+}
+declare const CaseTable: react.ForwardRefExoticComponent<CaseTableProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const CASE_TABLE_COLUMN_LABEL_KEYS: {
+    readonly caseId: "process.caseTable.columnCaseId";
+    readonly start: "process.caseTable.columnStart";
+    readonly end: "process.caseTable.columnEnd";
+    readonly duration: "process.caseTable.columnDuration";
+    readonly eventCount: "process.caseTable.columnEventCount";
+    readonly variantId: "process.caseTable.columnVariant";
+    readonly conformance: "process.caseTable.columnConformance";
+};
+interface CreateCaseTableColumnsOptions {
+    t: LocaleContextValue["t"];
+    formatDate: LocaleContextValue["formatDate"];
+}
+/** The default `CaseTable` column set. Reproduce this shape (or subset it) to customize. */
+declare function createCaseTableColumns({ t, formatDate, }: CreateCaseTableColumnsOptions): ColumnDef<CaseRow>[];
+
+interface CaseTimelineGap {
+    start: number;
+    end: number;
+    durationMs: number;
+}
+/** One activity EXECUTION in the case's trace. */
+interface CaseTimelineInstance {
+    /** Stable within one model build — the instance's position in chronological order. */
+    id: string;
+    activity: string;
+    start: number;
+    end: number;
+    resource?: string;
+    /** True for a `lifecycle: "start"` row that never got a matching `"complete"`. */
+    isOpen: boolean;
+    /** True when this instance's interval overlaps another by more than `parallelismThreshold`. */
+    isParallel: boolean;
+    /** Waiting time since the previous instance ended, when there was a gap. */
+    gap?: CaseTimelineGap;
+}
+interface CaseTimelineModelOptions {
+    /**
+     * Ms of overlap below which two instances are NOT flagged parallel. Default `0` — any
+     * genuine overlap (however small) counts.
+     */
+    parallelismThreshold?: number;
+}
+/**
+ * One case's trace as `CaseTimelineInstance[]`, in ascending `start` order — empty when
+ * `events` resolves to no case (e.g. every row has an empty `caseId`/`activity`).
+ */
+declare function buildCaseTimelineInstances(events: EventRow[], options?: CaseTimelineModelOptions): CaseTimelineInstance[];
+
+interface CaseTimelineProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect">, CaseTimelineModelOptions {
+    caseId: string;
+    /** This case's own events, straight from `core`'s `EventLog.events`. */
+    events: EventRow[];
+}
+declare const CaseTimeline: react.ForwardRefExoticComponent<CaseTimelineProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Pure model behind `DottedChart` (RM-059) — no React, no canvas, so the row order, the
+ * time transform and the brush enumeration are fixture-testable on their own.
+ *
+ * A dotted chart puts one ROW per case and one DOT per event. `computeDots` groups a log by
+ * case (through `/core`'s `normalizeLog`, so lifecycle pairs and the three timestamp
+ * encodings are resolved exactly once), orders the rows by `sort`, and places every event
+ * on the x axis according to `x`:
+ *
+ * - `absolute` — the event's own start time (epoch ms).
+ * - `relative` — milliseconds since the case's first event.
+ * - `relative_day` — time of day, `0 … 24 h` (UTC), so daily rhythms line up.
+ * - `relative_week` — time of week, `0 … 7 d`, weeks starting Monday 00:00 (UTC).
+ *
+ * The two cyclic modes use UTC on purpose: a chart whose dots move when the reviewer's
+ * machine changes time zone is not a deterministic fixture.
+ */
+
+/** How the x axis places an event. */
+type DottedChartX = "absolute" | "relative" | "relative_day" | "relative_week";
+/** How case rows are ordered, top to bottom. Every order is ascending and stable. */
+type DottedChartSort = "start" | "end" | "duration" | "start_day";
+/** One event, placed on the chart. */
+interface DottedChartDot {
+    kind: "dot";
+    caseId: string;
+    /** Index of this dot's row in {@link DottedChartModel.rows}. */
+    rowIndex: number;
+    /** The normalized event (activity, start, end, resource, attributes). */
+    event: NormalizedEvent;
+    /** The event's position on the x axis, in the unit `x` implies (always milliseconds). */
+    x: number;
+}
+/** One case, placed on the chart. */
+interface DottedChartRow {
+    kind: "row";
+    caseId: string;
+    /** Position in `rows` — top row is `0`. */
+    index: number;
+    start: number;
+    end: number;
+    duration: number;
+    eventCount: number;
+    firstActivity: string;
+    lastActivity: string;
+    /** This row's dots are `dots.slice(dotStart, dotEnd)`, in time order. */
+    dotStart: number;
+    dotEnd: number;
+}
+/** What {@link computeDots} returns. */
+interface DottedChartModel {
+    x: DottedChartX;
+    sort: DottedChartSort;
+    rows: DottedChartRow[];
+    /** Every dot, grouped by row in `rows` order, each row's dots in time order. */
+    dots: DottedChartDot[];
+    /** The x extent to scale against. Never zero-width. */
+    domain: [number, number];
+}
+interface ComputeDotsOptions {
+    x?: DottedChartX;
+    sort?: DottedChartSort;
+}
+/**
+ * Build the dotted-chart model for a log.
+ *
+ * Deterministic: the same log and options always yield the same rows, dots and domain.
+ * Events whose start could not be parsed are left out (they have no place on a time axis);
+ * a case left with no placeable event is left out too.
+ */
+declare function computeDots(log: AnyLog, options?: ComputeDotsOptions): DottedChartModel;
+/**
+ * Case ids of the rows a brush covers, in `rows` order.
+ *
+ * A row is covered when its index is in `[firstRow, lastRow]` (inclusive, either order) AND
+ * at least one of its dots lies in the x range `[x0, x1]` (inclusive, either order). The
+ * x test is what makes a brush over an empty stretch of time select nothing.
+ */
+declare function casesInBrush(model: DottedChartModel, rowRange: readonly [number, number], xRange: readonly [number, number]): string[];
+/** One entry of a {@link rankCategoryColors} legend. */
+interface DottedChartCategory extends ActivityColor {
+    key: string;
+    /** How many dots carry this category. */
+    count: number;
+}
+/**
+ * Colour arbitrary category keys (resources, a caller's own grouping) with the SAME budget
+ * `activityColorScale` uses: the {@link ACTIVITY_COLOR_SLOTS} most frequent keys take
+ * `--chart-1 …`, every other key shares {@link ACTIVITY_OTHER_TOKEN} and is flagged
+ * `pattern: "other"`. Ranked by count descending, ties by key. Returns token names only.
+ */
+declare function rankCategoryColors(keys: readonly string[]): DottedChartCategory[];
+
+/**
+ * Every user-visible string `DottedChart` (RM-059) renders. `{name}` placeholders are
+ * filled at render; override any subset through the component's `labels` prop to localize.
+ */
+interface DottedChartLabels {
+    /** Accessible name of the plot and its keyboard cursor. */
+    chart: string;
+    /** `{cases}`, `{events}`, `{from}`, `{to}`, `{sort}`, `{colorBy}` — the parallel summary. */
+    summary: string;
+    sortStart: string;
+    sortEnd: string;
+    sortDuration: string;
+    sortStartDay: string;
+    colorByActivity: string;
+    colorByResource: string;
+    colorByCustom: string;
+    /** `{caseId}`, `{events}`, `{duration}`, `{activities}` — spoken for a focused case row. */
+    row: string;
+    /** `{activity}`, `{time}`, `{caseId}` — spoken/shown for one event. */
+    dot: string;
+    /** `{resource}` — appended to a dot tooltip when the event has a resource. */
+    dotResource: string;
+    eventsOne: string;
+    eventsOther: string;
+    casesOne: string;
+    casesOther: string;
+    /** `{count}` more activities past the spoken prefix of a long trace. */
+    moreActivities: string;
+    /** `{cases}` — visible count of the current selection. */
+    selectionCount: string;
+    axisAbsolute: string;
+    axisRelative: string;
+    axisDay: string;
+    axisWeek: string;
+    /** The legend entry every category past the colour budget shares. */
+    other: string;
+    /** Category key for an event that carries no resource. */
+    noResource: string;
+    tableCaption: string;
+    columnCase: string;
+    columnFirstActivity: string;
+    columnLastActivity: string;
+    columnStart: string;
+    columnEnd: string;
+    columnDuration: string;
+    columnEvents: string;
+    columnState: string;
+    selected: string;
+    empty: string;
+    emptyBody: string;
+}
+/** The shipped English labels. */
+declare const DOTTED_CHART_DEFAULT_LABELS: Readonly<DottedChartLabels>;
+
+/** Dot radius in CSS pixels — a categorical marker, not an area encoding. */
+declare const DOTTED_CHART_DOT_RADIUS = 2;
+/** What a brush (or a committed keyboard range) emits. A subset of `/core`'s `FilterSpec`. */
+type DottedChartFilterIntent = Extract<FilterSpec, {
+    kind: "cases";
+}>;
+/** How dots are coloured. A function returns a CATEGORY KEY, never a colour. */
+type DottedChartColor = "activity" | "resource" | ((row: EventRow) => string);
+/** A datum under the cursor: a case row (keyboard) or one event dot (pointer). */
+type DottedChartDatum = DottedChartRow | DottedChartDot;
+interface DottedChartProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect" | "title" | "color"> {
+    log: EventLog;
+    /** How the x axis places an event. @default "absolute" */
+    x?: DottedChartX;
+    /** How case rows are ordered, top to bottom. @default "start" */
+    sort?: DottedChartSort;
+    /**
+     * What colours a dot. `"activity"` reads `colorScale`; `"resource"` and a function rank
+     * their category keys onto the same `--chart-1 …` budget. @default "activity"
+     */
+    color?: DottedChartColor;
+    /** The shared activity colour scale — hand `ProcessMap` the same instance. Built from `log` when omitted. */
+    colorScale?: ActivityColorScale;
+    /** Case ids to highlight; every other dot dims. */
+    selectedCaseIds?: readonly string[];
+    /** Fires with the case ids a click, brush or keyboard range selects. */
+    onSelect?: (caseIds: string[]) => void;
+    /** Fires once when a brush is released (or a keyboard range committed), with ids in row order. */
+    onFilterIntent?: (intent: DottedChartFilterIntent) => void;
+    /** Card title — write the conclusion, not "Dotted chart". */
+    title?: ReactNode;
+    /** Prose under the title. */
+    description?: ReactNode;
+    /** Body height in CSS pixels (legend + plot + axis). @default 360 */
+    height?: number;
+    /** Render the accessible table twin instead of the plot. @default false */
+    tableView?: boolean;
+    /** No log yet. Renders the frame's skeleton. */
+    loading?: boolean;
+    /** Override any user-visible string. */
+    labels?: Partial<DottedChartLabels>;
+}
+/**
+ * The dotted chart.
+ *
+ * @example
+ * ```tsx
+ * const scale = useMemo(() => activityColorScale(fullGraph), [fullGraph]);
+ * <DottedChart
+ *   log={explorer.filteredLog}
+ *   colorScale={scale}
+ *   sort="duration"
+ *   onFilterIntent={explorer.applyIntent}
+ * />
+ * ```
+ */
+declare const DottedChart: react.ForwardRefExoticComponent<DottedChartProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Segment occurrences — RM-060.
+ *
+ * A performance spectrum (ProM's PSM) draws one line per case through a FIXED, chosen
+ * sequence of segments, where a segment is one directly-follows pair `from → to`. That
+ * needs something `TransitionStats` does not carry: the individual, time-ordered
+ * OCCURRENCES of a pair (which case, when it entered, when it left), not one aggregate
+ * across the whole log. Batching, FIFO violations and queue build-up are visible only
+ * in the occurrences.
+ *
+ * ## What an occurrence measures
+ *
+ * `start` is the moment the `from` event COMPLETES and `end` the moment the `to` event
+ * STARTS — the same idle-time reading `discoverGraph` defaults to, so a spectrum row and
+ * the map's edge median agree about one pair. For atomic events (the common case) start
+ * and completion coincide, so this is simply the two event timestamps. Overlapping
+ * (parallel) events would give `end < start`; `end` is clamped to `start`, so `duration`
+ * is never negative and a line never runs backwards.
+ *
+ * Deterministic and framework-free: no React, no `@elabs-ai/components-*`.
+ */
+
+/** One row of a spectrum: the directly-follows pair `from → to`. */
+interface SegmentDefinition {
+    from: string;
+    to: string;
+    /** Display label. Defaults to `"from → to"` in a view. */
+    label?: string;
+}
+/** One case passing through one segment. */
+interface SegmentOccurrence {
+    /** The segment's key — {@link segmentKey}`(from, to)`. */
+    segment: string;
+    caseId: string;
+    /** When the `from` event completed, epoch ms. */
+    start: number;
+    /** When the `to` event started, epoch ms. Never before `start`. */
+    end: number;
+    /** `end - start`, in ms. */
+    duration: number;
+}
+/** A duration quartile, `1` = fastest quarter, `4` = slowest. */
+type DurationQuartile = 1 | 2 | 3 | 4;
+
+/**
+ * The pure model behind `PerformanceSpectrum` — RM-060.
+ *
+ * Everything here is React-free and unit-tested on its own: grouping occurrences into
+ * rows (with each occurrence's quartile read against ITS OWN segment), the aggregated
+ * mode's time bins, the shared time domain and ticks, and the brush's case lookup. The
+ * component only lays these out and paints them.
+ */
+
+/** One occurrence, ready to paint: its quartile is already resolved. */
+interface SpectrumLine extends SegmentOccurrence {
+    quartile: DurationQuartile;
+}
+/** One `binSize` bucket of one row in aggregated mode. */
+interface SpectrumBin {
+    segment: string;
+    /** Bucket start, epoch ms (inclusive). */
+    start: number;
+    /** Bucket end, epoch ms (exclusive). */
+    end: number;
+    /** Occurrences entering the segment inside the bucket. */
+    count: number;
+    /** Median duration of those occurrences, ms. */
+    medianDuration: number;
+    /** The median of their quartiles, rounded up — the bar's fill. */
+    quartile: DurationQuartile;
+}
+/** One spectrum row: a segment and everything drawn in it. */
+interface SpectrumRow {
+    key: string;
+    definition: SegmentDefinition;
+    /** Sorted by `start`, then `end`, then `caseId` — the keyboard cursor's walk order. */
+    lines: SpectrumLine[];
+    /** Distinct cases with at least one occurrence. */
+    caseCount: number;
+    medianDuration: number;
+    p90Duration: number;
+}
+/**
+ * Groups `occurrences` into one row per definition in `order` (duplicates dropped),
+ * resolving each occurrence's quartile against its own segment's distribution.
+ */
+declare function buildSpectrumRows(order: readonly SegmentDefinition[], occurrences: readonly SegmentOccurrence[]): SpectrumRow[];
+/**
+ * The aggregated mode's bars for one row: occurrences bucketed by the time they ENTER the
+ * segment, `binSize` ms wide, aligned to `origin`. Only non-empty buckets are returned,
+ * in time order, so a sparse year at a one-minute bin costs nothing for the empty minutes.
+ */
+declare function aggregateSegmentBins(row: SpectrumRow, binSize: number, origin: number): SpectrumBin[];
+/**
+ * The shared time domain `[min start, max end]` across every row. A degenerate domain
+ * (one instant, or nothing at all) is widened by one second so a scale never divides by 0.
+ */
+declare function spectrumDomain(rows: readonly SpectrumRow[]): [number, number];
+/** `count` evenly spaced tick instants across `domain`, both ends included. */
+declare function spectrumTicks(domain: readonly [number, number], count?: number): number[];
+/**
+ * Case ids with at least one occurrence overlapping `[from, to]` (inclusive), in the order
+ * they are first met walking rows top to bottom and each row in time order.
+ */
+declare function casesInRange(rows: readonly SpectrumRow[], from: number, to: number): string[];
+
+/** Every user-visible string `PerformanceSpectrum` renders. `{name}` placeholders fill. */
+interface PerformanceSpectrumLabels {
+    /** Accessible name of the whole view. */
+    label: string;
+    /** `{from}`, `{to}` — a row's accessible name and default visible label. */
+    segment: string;
+    /** Appended to a selected row's accessible name. */
+    selected: string;
+    /** `{count}`, `{cases}`, `{median}`, `{p90}` — a row's parallel summary. */
+    rowSummary: string;
+    /** `{caseId}`, `{start}`, `{end}`, `{duration}`, `{quartile}` — one line, spoken. */
+    occurrence: string;
+    /** `{start}`, `{end}`, `{count}`, `{median}`, `{quartile}` — one aggregated bar, spoken. */
+    bin: string;
+    tooltipSegment: string;
+    tooltipStart: string;
+    tooltipEnd: string;
+    tooltipDuration: string;
+    tooltipQuartile: string;
+    tooltipCount: string;
+    tooltipMedian: string;
+    /** `{n}` — a quartile's short name. */
+    quartile: string;
+    quartileFastest: string;
+    quartileSlowest: string;
+    /** Heading of the colour key. */
+    legend: string;
+    /** Accessible name of the time-axis brush track. */
+    brush: string;
+    brushHint: string;
+    /** `{start}`, `{end}`, `{count}` — announced when a range is set. */
+    brushRange: string;
+    columnSegment: string;
+    columnCases: string;
+    columnMedian: string;
+    columnP90: string;
+    tableCaption: string;
+    loading: string;
+    empty: string;
+    emptyBody: string;
+}
+/** The shipped English labels. */
+declare const PERFORMANCE_SPECTRUM_DEFAULT_LABELS: Readonly<PerformanceSpectrumLabels>;
+
+/** One day in ms — the aggregated mode's default bucket. */
+declare const PERFORMANCE_SPECTRUM_DEFAULT_BIN_SIZE = 86400000;
+/** Default row height in CSS px when `height` is not given. */
+declare const PERFORMANCE_SPECTRUM_ROW_HEIGHT = 56;
+/** Default number of segment rows. */
+declare const PERFORMANCE_SPECTRUM_SEGMENT_LIMIT = 12;
+/** Which segments a spectrum shows, in row order. */
+type PerformanceSpectrumOrder = SegmentDefinition[] | "frequency" | {
+    variantId: string;
+};
+/** The one intent the spectrum emits — a `/core` `FilterSpec`, straight into `filterLog`. */
+type PerformanceSpectrumFilterIntent = Extract<FilterSpec, {
+    kind: "cases";
+}>;
+/** Props for {@link PerformanceSpectrum}. */
+interface PerformanceSpectrumProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    log: EventLog;
+    /** Row order: explicit segments, the busiest transitions, or one variant's path. @default "frequency" */
+    order?: PerformanceSpectrumOrder;
+    /** At most this many rows, whichever `order` is used. @default 12 */
+    segmentLimit?: number;
+    /** One line per occurrence, or one bar per time bucket. @default "lines" */
+    mode?: "lines" | "aggregated";
+    /** Bucket width in ms, aggregated mode only. @default 86_400_000 (1 day) */
+    binSize?: number;
+    /** Rows whose segment is (or touches) the selected transition/activity are marked. */
+    selection?: ProcessSelection | null;
+    /** When given, the time axis becomes a brush that emits `{ kind: "cases", ids }`. */
+    onFilterIntent?: (intent: PerformanceSpectrumFilterIntent) => void;
+    /** Click or `Enter` on an occurrence (lines) or on a bar's first case (aggregated). */
+    onCaseSelect?: (caseId: string, occurrence: SpectrumLine) => void;
+    /** Total plot height in CSS px, split evenly across rows (min 24 px a row). */
+    height?: number;
+    /** Render the accessible table twin instead of the chart. @default false */
+    tableView?: boolean;
+    /** Data not ready yet — renders the loading panel. */
+    loading?: boolean;
+    /** Override any user-visible string. */
+    labels?: Partial<PerformanceSpectrumLabels>;
+}
+/**
+ * The performance spectrum.
+ *
+ * @example
+ * ```tsx
+ * <PerformanceSpectrum
+ *   log={explorer.filteredLog}
+ *   order="frequency"
+ *   onFilterIntent={(intent) => setCaseFilter(intent)}
+ * />
+ * ```
+ */
+declare const PerformanceSpectrum: react.ForwardRefExoticComponent<PerformanceSpectrumProps & react.RefAttributes<HTMLDivElement>>;
+
+/** The metric the overlay paints when none is given: case frequency on both marks. */
+declare const CONFORMANCE_OVERLAY_DEFAULT_METRIC: ProcessMetricSpec;
+/** Props for {@link ConformanceOverlay}. `onSelect` shadows the DOM handler, so it is omitted. */
+interface ConformanceOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** The discovered graph to overlay. */
+    graph: ProcessGraph;
+    /** The replay result (`tokenReplay`) against the reference model. */
+    conformance: ConformanceResult;
+    /** Which readings the nodes and edges print. @default case frequency */
+    metric?: ProcessMetricSpec;
+    /** @default "TB" */
+    direction?: FlowLayoutDirection;
+    /** Controlled selection, passed straight to `ProcessMap`. */
+    selection?: ProcessSelection | null;
+    onSelect?: ProcessMapProps["onSelect"];
+    onFilterIntent?: ProcessMapProps["onFilterIntent"];
+    /** Render the accessible table twin instead of the canvas. @default false */
+    tableView?: boolean;
+    /** No graph or replay yet. Renders the map's loading panel and hides the legend. */
+    loading?: boolean;
+    /** Override the legend's words. */
+    labels?: Partial<ConformanceStateLabels>;
+}
+/**
+ * The conformance overlay.
+ *
+ * @example
+ * ```tsx
+ * const model = useMemo(() => liftHappyPath(happyPath), [happyPath]);
+ * const conformance = useMemo(() => tokenReplay(log, model), [log, model]);
+ * <ConformanceOverlay graph={graph} conformance={conformance} />
+ * ```
+ */
+declare const ConformanceOverlay: react.ForwardRefExoticComponent<ConformanceOverlayProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link ConformanceStateMark}. */
+interface ConformanceStateMarkProps extends HTMLAttributes<HTMLSpanElement> {
+    state: ConformanceState;
+    /** Override the state's word. */
+    labels?: Partial<ConformanceStateLabels>;
+}
+/**
+ * One state as glyph + coloured word — the text form a table cell prints. The glyph is
+ * `aria-hidden`; the word is the accessible reading.
+ */
+declare const ConformanceStateMark: react.ForwardRefExoticComponent<ConformanceStateMarkProps & react.RefAttributes<HTMLSpanElement>>;
+/** Props for {@link ConformanceLegend}. */
+interface ConformanceLegendProps extends HTMLAttributes<HTMLDivElement> {
+    /** Override any state word or the title. */
+    labels?: Partial<ConformanceStateLabels>;
+}
+/** The three-state key: tone + glyph + dash + word per entry. */
+declare const ConformanceLegend: react.ForwardRefExoticComponent<ConformanceLegendProps & react.RefAttributes<HTMLDivElement>>;
+
+/** What a row stands for: a deviation type, or the cases with none. */
+type ViolationRowKind = DeviationType | "conforming";
+/** One row of {@link ViolationList}. */
+interface ViolationRow {
+    kind: ViolationRowKind;
+    /** Deviations of this type across all cases (`0` for `"conforming"`). */
+    deviations: number;
+    /** Ids of the cases carrying at least one deviation of this type, in log order. */
+    caseIds: string[];
+    /** `caseIds.length / traces.length`; `0` for an empty log. */
+    share: number;
+}
+/** The filter a row emits — a strict subset of `/core`'s `FilterSpec`. */
+type ViolationFilterIntent = Extract<FilterSpec, {
+    kind: "cases";
+}>;
+/**
+ * The rows {@link ViolationList} renders, in order: every type with deviations, by count
+ * descending, then `"conforming"`.
+ */
+declare function violationRows(conformance: ConformanceResult): ViolationRow[];
+/** Every user-visible string. `{name}` placeholders are filled at render. */
+interface ViolationListLabels {
+    undesired: string;
+    skipped: string;
+    wrongOrder: string;
+    wrongStart: string;
+    incomplete: string;
+    conforming: string;
+    columnType: string;
+    columnShare: string;
+    columnCases: string;
+    /** `{conforming}`, `{total}`. */
+    caption: string;
+    /** Appended to the caption when rows can be chosen. */
+    captionFilter: string;
+    loading: string;
+    empty: string;
+    emptyBody: string;
+}
+/** The shipped English labels. */
+declare const VIOLATION_LIST_DEFAULT_LABELS: Readonly<ViolationListLabels>;
+/** Props for {@link ViolationList}. */
+interface ViolationListProps extends HTMLAttributes<HTMLDivElement> {
+    /** The replay result (`tokenReplay`). */
+    conformance: ConformanceResult;
+    /** When given, each row emits `{ kind: "cases", ids }` for its cases. */
+    onFilterIntent?: (intent: ViolationFilterIntent) => void;
+    /** No replay yet. Renders the loading panel rather than an empty table. */
+    loading?: boolean;
+    /** Override any user-visible string. */
+    labels?: Partial<ViolationListLabels>;
+}
+/**
+ * The violation list.
+ *
+ * @example
+ * ```tsx
+ * <ViolationList
+ *   conformance={tokenReplay(log, liftHappyPath(path))}
+ *   onFilterIntent={(intent) => explorer.applyIntent(intent)}
+ * />
+ * ```
+ */
+declare const ViolationList: react.ForwardRefExoticComponent<ViolationListProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Every user-visible string of the editor. `{name}` placeholders are filled at render. */
+interface HappyPathEditorLabels {
+    /** Accessible name of the canvas. `{path}` — the happy path's label. */
+    canvas: string;
+    /** Eyebrow above a step. `{n}` — the one-based position. */
+    step: string;
+    /** Accessible name of a step node. `{n}`, `{activity}`, `{flags}`. */
+    stepName: string;
+    /** Shown as a step's title while its activity is empty. */
+    untitled: string;
+    /** Accessible name of a step's activity field. `{n}`. */
+    activity: string;
+    /** Placeholder of the free-text activity field. */
+    activityPlaceholder: string;
+    optional: string;
+    repeatable: string;
+    /** Accessible name of a step's optional switch. `{activity}`. */
+    optionalFor: string;
+    /** Accessible name of a step's repeatable switch. `{activity}`. */
+    repeatableFor: string;
+    remove: string;
+    /** Accessible name of a step's remove button. `{activity}`. */
+    removeFor: string;
+    /** Accessible name of an edge's insert button. `{before}`, `{after}`. */
+    insertStep: string;
+    /** Label of the tail placeholder that appends a step. */
+    addStep: string;
+}
+/** The shipped English labels. */
+declare const HAPPY_PATH_EDITOR_DEFAULT_LABELS: Readonly<HappyPathEditorLabels>;
+/** What a step node reads from its editor. */
+interface HappyPathEditorContextValue {
+    labels: HappyPathEditorLabels;
+    availableActivities: readonly string[] | undefined;
+    updateStep: (index: number, patch: Partial<HappyPathStep>) => void;
+    removeStep: (index: number) => void;
+}
+/** Provided by `HappyPathEditor`; a step rendered on its own reads inert defaults. */
+declare const HappyPathEditorContext: react.Context<HappyPathEditorContextValue>;
+/** Read the editor's labels and actions. */
+declare function useHappyPathEditor(): HappyPathEditorContextValue;
+
+/** Id of the node for the step at `index`. */
+declare function happyPathStepNodeId(index: number): string;
+/**
+ * The activity a newly inserted step starts with: the first available activity the path
+ * does not use yet, else the first available one, else empty (typed in afterwards).
+ */
+declare function nextHappyPathActivity(path: HappyPath, availableActivities: readonly string[] | undefined): string;
+/** `path` with a new step inserted at `index`. */
+declare function insertHappyPathStep(path: HappyPath, index: number, step: HappyPathStep): HappyPath;
+/** `path` without the step at `index`. The neighbours become consecutive. */
+declare function removeHappyPathStep(path: HappyPath, index: number): HappyPath;
+/** `path` with the step at `index` patched. `false` flags are dropped, not stored. */
+declare function updateHappyPathStep(path: HappyPath, index: number, patch: Partial<HappyPathStep>): HappyPath;
+/** Props for {@link HappyPathEditor}. `onChange` carries a path, so the DOM one is omitted. */
+interface HappyPathEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    value: HappyPath;
+    /** Fires with the complete path after every edit. */
+    onChange: (path: HappyPath) => void;
+    /** Activities a step may pick from (e.g. the log's). Omit for free-text activities. */
+    availableActivities?: string[];
+    /** Override any user-visible string. */
+    labels?: Partial<HappyPathEditorLabels>;
+}
+/**
+ * The happy-path editor.
+ *
+ * @example
+ * ```tsx
+ * const [path, setPath] = useState<HappyPath>({ id: "p", label: "Order", steps: [] });
+ * const conformance = useMemo(() => tokenReplay(log, liftHappyPath(path)), [log, path]);
+ * <HappyPathEditor value={path} onChange={setPath} availableActivities={activities} />
+ * ```
+ */
+declare const HappyPathEditor: react.ForwardRefExoticComponent<HappyPathEditorProps & react.RefAttributes<HTMLDivElement>>;
+
+/** `data` carried by a {@link HappyPathStepFlowNode}. */
+interface HappyPathStepNodeData extends Record<string, unknown> {
+    /** Zero-based position in the path. */
+    index: number;
+    step: HappyPathStep;
+}
+/** A happy-path step node. Register as `nodeTypes={{ "happy-path-step": … }}`. */
+type HappyPathStepFlowNode = Node<HappyPathStepNodeData, "happy-path-step">;
+/** One step of the happy-path editor. */
+declare function HappyPathStepNode(props: NodeProps<HappyPathStepFlowNode>): react.JSX.Element;
+
+/** One side of the comparison. */
+interface ProcessCompareSide {
+    /** How this side is named in headers, the KPI strip and the diff legend/labels. */
+    label: string;
+    /** A discovered graph. `undefined` while this side is still loading. */
+    graph: ProcessGraph | undefined;
+    /** The raw log, for `CompareKpiStrip`'s median-throughput reading. Optional. */
+    log?: EventLog;
+}
+type ProcessCompareMode = "side-by-side" | "superimposed";
+interface ProcessCompareProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    a: ProcessCompareSide;
+    b: ProcessCompareSide;
+    /** @default "side-by-side" */
+    mode?: ProcessCompareMode;
+    metric: ProcessMapProps["metric"];
+    /** Shared abstraction, synced across both sides (or the one superimposed map). */
+    abstraction: AbstractionOptions;
+    onAbstractionChange(next: Partial<AbstractionOptions>): void;
+    /** @default "TB" */
+    direction?: FlowLayoutDirection;
+    /** Neither side has a graph yet. Renders every map's own loading panel. @default false */
+    loading?: boolean;
+    /** Accessible name for the region. Defaults to the localized `process.compare.label`. */
+    label?: string;
+}
+/**
+ * Side-by-side or superimposed diff of two process maps.
+ *
+ * @example
+ * ```tsx
+ * <ProcessCompare
+ *   a={{ label: "Before", graph: beforeGraph }}
+ *   b={{ label: "After", graph: afterGraph }}
+ *   metric={{ node: "absolute_case", edge: "absolute" }}
+ *   abstraction={abstraction}
+ *   onAbstractionChange={setAbstraction}
+ * />
+ * ```
+ */
+declare const ProcessCompare: react.ForwardRefExoticComponent<ProcessCompareProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CompareSideProps extends HTMLAttributes<HTMLDivElement> {
+    /** The host-supplied name for this side ("Before", "Q1", the log's own file name, …). */
+    label: string;
+    /** Forwarded to `ProcessMap` verbatim — everything this side's canvas needs. */
+    map: Omit<ProcessMapProps, "className">;
+}
+/** One heading + one `ProcessMap`, stacked to fill its panel. */
+declare const CompareSide: react.ForwardRefExoticComponent<CompareSideProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Which side(s) of the diff an activity or transition survives in. */
+type DiffState = "common" | "aOnly" | "bOnly";
+/** One activity's or transition's diff — its identity, its state, and (when `"common"`) its delta. */
+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. */
+interface ProcessGraphDiff {
+    activities: DiffEntry<ActivityStats>[];
+    transitions: DiffEntry<TransitionStats>[];
+    totals: {
+        a: ProcessGraph["totals"];
+        b: ProcessGraph["totals"];
+    };
+}
+
+/** One side's raw input — a discovered graph, an event log, or (loading) neither. */
+interface CompareSideInput {
+    graph?: ProcessGraph;
+    log?: EventLog;
+}
+/** The two numbers {@link CompareKpiStrip} reads for one side. */
+interface CompareSideKpis {
+    cases: number;
+    /** Median case throughput, ms. Omitted when the side has no `log` to derive it from. */
+    medianThroughput?: number;
+}
+/**
+ * Cases and median throughput for one side, mirroring `useProcessExplorer`'s own `kpis`
+ * derivation (`cases`/`medianThroughput` from a normalized log's per-case durations).
+ * `medianThroughput` needs case-level duration samples that a bare `ProcessGraph` does not
+ * carry (only per-activity/per-transition aggregates do) — so it is only derivable when the
+ * caller also handed this side a `log`; a `graph`-only side reports cases alone.
+ */
+declare function resolveCompareKpis(side: CompareSideInput): CompareSideKpis;
+
+interface CompareKpiStripSide {
+    /** The host-supplied name for this side ("Before", "Q1", the log's own file name, …). */
+    label: string;
+    kpis: CompareSideKpis;
+}
+interface CompareKpiStripProps extends HTMLAttributes<HTMLDivElement> {
+    a: CompareKpiStripSide;
+    b: CompareKpiStripSide;
+    loading?: boolean;
+}
+/** Compact KPI pairs for `ProcessCompare`: cases and median throughput, A vs B. */
+declare const CompareKpiStrip: react.ForwardRefExoticComponent<CompareKpiStripProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * diffToProcessGraph — turn a `ProcessGraphDiff` (`/core`'s `diffGraphs`, RM-064) into the
+ * ONE `ProcessGraph` `ProcessCompare`'s superimposed mode hands to a single `ProcessMap`,
+ * plus a synthetic `ActivityColorScale` that paints by diff state instead of by identity.
+ *
+ * `ProcessMap` (RM-051) is never forked or given a new prop for this: its existing
+ * `colorScale` prop (RM-054) is the only per-activity colour hook it exposes, and
+ * `ActivityColorScale` is a plain interface — nothing stops a second caller building one
+ * keyed by diff state rather than by rank. Pure, no React; lives beside `process-compare.tsx`
+ * rather than under `/core` because it is presentation shaping for ONE component (label
+ * suffixes, colour tokens), not a reusable process-mining derivation.
+ */
+
+/** Empty graph — the identity input for a side that has not discovered anything yet. */
+declare const EMPTY_PROCESS_GRAPH: ProcessGraph;
+/**
+ * The three diff tokens the design asks for (RM-064's spec): `common` reads as success,
+ * `aOnly` as the first chart series, `bOnly` as destructive. Semantic tokens only — no
+ * literal colour is authored (`.claude/rules/conventions.md`'s styling rule).
+ */
+declare const DIFF_STATE_TOKEN: Record<DiffState, string>;
+/**
+ * The ONE `ProcessGraph` a superimposed `ProcessMap` renders: every activity/transition
+ * either side ever saw, painted with whichever side's stats are the "current" reading (`b`
+ * when present, `a` otherwise). `startActivities`/`endActivities` are recomputed from the
+ * represented activities themselves, so they can never disagree with what `activities`
+ * above actually carries. `totals` prefers `b`'s (the "current" period) and falls back to
+ * `a`'s only when `b` measured nothing at all (e.g. a `b` side still loading).
+ */
+declare function diffToProcessGraph(diff: ProcessGraphDiff): ProcessGraph;
+/** Diff state per activity id, straight off {@link ProcessGraphDiff.activities}. */
+declare function diffStateByActivity(diff: ProcessGraphDiff): ReadonlyMap<string, DiffState>;
+/**
+ * A synthetic `ActivityColorScale` that paints every activity by its DIFF STATE rather
+ * than its identity. `colorFor` is the only method `ProcessMap` itself calls (see
+ * `map-model.ts`'s `buildProcessMapModel`); `codeFor`/`labelFor`/`legend` exist only to
+ * satisfy the shared interface.
+ */
+declare function diffColorScale(diff: ProcessGraphDiff): ActivityColorScale;
+
+/** One case travelling one edge. Times are relative to {@link ReplayTimeline.origin}. */
+interface ReplaySegment {
+    caseId: string;
+    /** `source + EDGE_KEY_SEPARATOR + target`. */
+    edgeId: string;
+    source: string;
+    target: string;
+    /** The source activity's completion. */
+    enterAt: number;
+    /** The target activity's start — never before {@link enterAt}. */
+    exitAt: number;
+}
+/** One case's token on one edge at a playhead. */
+interface ReplayFrameToken {
+    caseId: string;
+    edgeId: string;
+    /** 0 at the source end, 1 at the target end. */
+    progress: number;
+}
+/** The replay at one playhead. */
+interface ReplayFrame {
+    /** Playhead, relative to the timeline origin. */
+    t: number;
+    /** One token per in-flight case, in segment order. */
+    tokens: ReplayFrameToken[];
+    /** Edge id → distinct cases on that edge during the bucket starting at `t`. Zero edges are omitted. */
+    congestion: Record<string, number>;
+}
+/** A replay-ready timeline. */
+interface ReplayTimeline {
+    /** Epoch ms of `t = 0` in wall-clock mode; `0` in synchronized-start mode. */
+    origin: number;
+    /** Last relative instant any case reaches. `0` for an empty log. */
+    duration: number;
+    /** The bucket width actually used. */
+    bucketMs: number;
+    synchronizedStart: boolean;
+    /** Every edge move of every case, ordered by `enterAt` then case order. */
+    segments: ReplaySegment[];
+    /** One frame per bucket, `frames[i].t === i * bucketMs`, covering `[0, duration]`. */
+    frames: ReplayFrame[];
+    /** Highest congestion any edge reaches in any bucket. `0` when nothing moves. */
+    peakCongestion: number;
+}
+
+/** Every user-visible string in `ProcessReplay` and its parts. `{…}` are placeholders. */
+interface ProcessReplayLabels {
+    /** Accessible name of the replay region. */
+    region: string;
+    /** Accessible name of the map canvas. */
+    map: string;
+    play: string;
+    pause: string;
+    /** The time slider. */
+    time: string;
+    /** The speed select. */
+    speed: string;
+    /** `{speed}` — one speed option. */
+    speedOption: string;
+    /** `{time}`, `{count}` — the readout and the paused announcement. */
+    readout: string;
+    /** Announced while the replay runs (the time is not announced frame by frame). */
+    playing: string;
+    /** `{duration}` — a playhead in synchronized-start mode. */
+    relativeTime: string;
+    congestionTitle: string;
+    /** `{source}`, `{target}`. */
+    congestionTransition: string;
+    /** `{peak}`, `{time}` — one ranked transition. */
+    congestionPeak: string;
+    /** `{source}`, `{target}`, `{peak}`, `{time}` — the one-line summary of the busiest transition. */
+    congestionSummary: string;
+    congestionEmpty: string;
+    loading: string;
+    empty: string;
+    emptyBody: string;
+}
+/** The shipped English labels. */
+declare const PROCESS_REPLAY_DEFAULT_LABELS: Readonly<ProcessReplayLabels>;
+/**
+ * Formats a playhead: a medium date and short time in wall-clock mode, `+duration` since each
+ * case's start in synchronized-start mode.
+ */
+declare function useReplayTimeFormatter(timeline: Pick<ReplayTimeline, "origin" | "synchronizedStart">, relativeTemplate?: string): (t: number) => string;
+
+/** Wall-clock length of a full replay at 1×, in ms. */
+declare const REPLAY_PLAYBACK_MS = 30000;
+/** The metric the map paints when none is given: case frequency on both marks. */
+declare const PROCESS_REPLAY_DEFAULT_METRIC: ProcessMetricSpec;
+/** Props for {@link ProcessReplay}. `onSelect` is not offered: the map is read-only. */
+interface ProcessReplayProps extends HTMLAttributes<HTMLDivElement> {
+    /** The discovered graph to replay over. */
+    graph: ProcessGraph;
+    /** The log the graph came from — tokens need per-case timing, not just the aggregate. */
+    log: EventLog;
+    /** Align every case's start to `t = 0` instead of the wall clock. @default false */
+    synchronizedStart?: boolean;
+    /** Bucket width in ms for congestion. @default the log span / 300 */
+    bucketMs?: number;
+    /** Which readings the nodes and edges print. @default case frequency */
+    metric?: ProcessMetricSpec;
+    /** @default "TB" */
+    direction?: FlowLayoutDirection;
+    /** Controlled playing state. Held while reduced motion is on until the reader presses play. */
+    playing?: boolean;
+    /** Initial playing state when uncontrolled. Ignored under reduced motion. @default false */
+    defaultPlaying?: boolean;
+    onPlayingChange?: (playing: boolean) => void;
+    /** Controlled playhead, ms relative to the timeline origin. */
+    time?: number;
+    /** @default 0 */
+    defaultTime?: number;
+    onTimeChange?: (time: number) => void;
+    /** Controlled playback multiplier. */
+    speed?: number;
+    /** @default 1 */
+    defaultSpeed?: number;
+    onSpeedChange?: (speed: number) => void;
+    /** How many transitions the congestion list ranks. @default 5 */
+    congestionLimit?: number;
+    /** No log yet. Renders the loading panel. */
+    loading?: boolean;
+    /** Override any user-visible string. */
+    labels?: Partial<ProcessReplayLabels>;
+}
+/**
+ * The process replay.
+ *
+ * @example
+ * ```tsx
+ * const graph = useMemo(() => discoverGraph(log), [log]);
+ * <ProcessReplay graph={graph} log={log} synchronizedStart />
+ * ```
+ */
+declare const ProcessReplay: react.ForwardRefExoticComponent<ProcessReplayProps & react.RefAttributes<HTMLDivElement>>;
+
+/** The speed multipliers the select offers. */
+declare const REPLAY_SPEEDS: readonly [0.5, 1, 2, 4];
+/** Props for {@link ReplayControls}. */
+interface ReplayControlsProps extends HTMLAttributes<HTMLDivElement> {
+    playing: boolean;
+    onPlayingChange: (playing: boolean) => void;
+    /** Playhead, ms relative to the timeline origin. */
+    time: number;
+    onTimeChange: (time: number) => void;
+    /** Timeline length in ms — the slider's maximum. */
+    duration: number;
+    /** Slider step in ms (one bucket). */
+    step: number;
+    speed: number;
+    onSpeedChange: (speed: number) => void;
+    /** Cases in flight at {@link time}. */
+    inFlight: number;
+    /** Formats a playhead for the readout and the slider's value text. */
+    formatTime: (time: number) => string;
+    /** Disable every control (an empty timeline). */
+    disabled?: boolean;
+    labels?: Partial<ProcessReplayLabels>;
+}
+/** Play/pause, time slider, speed select and a readout. */
+declare const ReplayControls: react.ForwardRefExoticComponent<ReplayControlsProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link CongestionHeat}. */
+interface CongestionHeatProps extends HTMLAttributes<HTMLElement> {
+    /** The replay timeline (`replayTimeline`). */
+    timeline: ReplayTimeline;
+    /** How many transitions to list. @default 5 */
+    limit?: number;
+    labels?: Partial<ProcessReplayLabels>;
+}
+/** The most congested transitions of a replay, ranked. */
+declare const CongestionHeat: react.ForwardRefExoticComponent<CongestionHeatProps & react.RefAttributes<HTMLElement>>;
+
+/** Edge id → the tokens on that edge right now. An edge with no entry carries none. */
+type ProcessReplayTokens = ReadonlyMap<string, readonly FlowEdgeToken[]>;
+/** Provided by `ProcessReplay`. `null` (the default) means no replay is running. */
+declare const ProcessReplayTokensContext: react.Context<ProcessReplayTokens | null>;
+/** The tokens on one edge, or `undefined` outside a replay. */
+declare function useProcessReplayEdgeTokens(edgeId: string): readonly FlowEdgeToken[] | undefined;
+
+export { ACTIVITY_COLOR_SLOTS, ACTIVITY_OTHER_TOKEN, type AbstractedObjectCentricGraph, AbstractionControls, type AbstractionControlsProps, type ActivityColor, type ActivityColorLegendEntry, type ActivityColorScale, type ActivityFrequencyMode, type AutoAbstractionOptions, type AutoAbstractionResult, type BuildObjectCentricMapModelOptions, type BuildProcessMapModelOptions, CASE_TABLE_COLUMN_LABEL_KEYS, CONFORMANCE_OVERLAY_DEFAULT_METRIC, CONFORMANCE_STATES, CONFORMANCE_STATE_DEFAULT_LABELS, CONFORMANCE_STATE_ENCODING, type CaseRow, CaseTable, type CaseTableProps, CaseTimeline, type CaseTimelineGap, type CaseTimelineInstance, type CaseTimelineModelOptions, type CaseTimelineProps, CompareKpiStrip, type CompareKpiStripProps, type CompareKpiStripSide, CompareSide, type CompareSideInput, type CompareSideKpis, type CompareSideProps, type ComputeDotsOptions, type ConformanceDash, ConformanceLegend, type ConformanceLegendProps, ConformanceOverlay, type ConformanceOverlayProps, type ConformanceState, type ConformanceStateEncoding, type ConformanceStateLabels, ConformanceStateMark, type ConformanceStateMarkProps, type ConformanceStates, type ConformanceTone, CongestionHeat, type CongestionHeatProps, type CreateCaseTableColumnsOptions, DEFAULT_LAYOUT_DEBOUNCE_MS, DIFF_STATE_TOKEN, DOTTED_CHART_DEFAULT_LABELS, DOTTED_CHART_DOT_RADIUS, DottedChart, type DottedChartCategory, type DottedChartColor, type DottedChartDatum, type DottedChartDot, type DottedChartFilterIntent, type DottedChartLabels, type DottedChartModel, type DottedChartProps, type DottedChartRow, type DottedChartSort, type DottedChartX, EMPTY_PROCESS_GRAPH, EMPTY_PROCESS_MAP_HOVER, type FilterIntent, GHOST_OPACITY, HAPPY_PATH_EDITOR_DEFAULT_LABELS, HappyPathEditor, HappyPathEditorContext, type HappyPathEditorContextValue, type HappyPathEditorLabels, type HappyPathEditorProps, type HappyPathStepFlowNode, HappyPathStepNode, type HappyPathStepNodeData, type MetricLayer, MetricLayerSwitch, type MetricLayerSwitchMetric, type MetricLayerSwitchProps, OBJECT_CENTRIC_MAP_DEFAULT_LABELS, OBJECT_TYPE_ABSTRACTION_DEFAULT_LABELS, type ObjectCentricActivityStats, type ObjectCentricGraph, type ObjectCentricMapLabels, type ObjectTypeAbstraction, type ObjectTypeAbstractionLabels, type ObjectTypeActivityCounts, PERFORMANCE_SPECTRUM_DEFAULT_BIN_SIZE, PERFORMANCE_SPECTRUM_DEFAULT_LABELS, PERFORMANCE_SPECTRUM_ROW_HEIGHT, PERFORMANCE_SPECTRUM_SEGMENT_LIMIT, PROCESS_FILTER_INTENT_KINDS, PROCESS_FILTER_INTENT_LABELS, PROCESS_FILTER_INTENT_MESSAGE_KEYS, PROCESS_MAP_EDGE_SCALE_GROUP, PROCESS_MAP_LEGIBLE_ZOOM, PROCESS_MAP_NODE_MOTION_CLASS, PROCESS_REPLAY_DEFAULT_LABELS, PROCESS_REPLAY_DEFAULT_METRIC, PROCESS_SELECTION_STATE_MESSAGE_KEYS, PerformanceSpectrum, type PerformanceSpectrumFilterIntent, type PerformanceSpectrumLabels, type PerformanceSpectrumOrder, type PerformanceSpectrumProps, ProcessActivityNode, type ProcessActivityNodeData, type ProcessActivityRow, ProcessCompare, type ProcessCompareMode, type ProcessCompareProps, type ProcessCompareSide, type ProcessEdgeDenominators, type ProcessExplorerMetric, type ProcessExplorerMetricSpec, type ProcessExplorerOptions, ProcessFilterBar, type ProcessFilterBarProps, type ProcessFilterIntent, ProcessKpiStrip, type ProcessKpiStripKpis, type ProcessKpiStripProps, type ProcessKpiStripTrendKey, type ProcessLayoutSnapshot, ProcessMap, type ProcessMapEdge, ProcessMapEdgeKeyContext, type ProcessMapEdgeKeyHandler, type ProcessMapExcludedCounts, ProcessMapHoverContext, type ProcessMapHoverState, type ProcessMapModel, type ProcessMapNode, type ProcessMapProps, type ProcessMetric, type ProcessMetricSpec, type ProcessObjectTypeCount, type ProcessObjectTypeMark, ProcessReplay, type ProcessReplayLabels, type ProcessReplayProps, type ProcessReplayTokens, ProcessReplayTokensContext, type ProcessSelection, type ProcessSelectionKind, type ProcessSelectionNeighbourhood, type ProcessSelectionState, type ProcessSelectionStates, ProcessTransitionEdge, type ProcessTransitionEdgeData, type ProcessTransitionRow, REPLAY_PLAYBACK_MS, REPLAY_SPEEDS, ReplayControls, type ReplayControlsProps, type SpectrumBin, type SpectrumLine, type SpectrumRow, type TransitionFrequencyMode, type UseProcessExplorerResult, type UseProcessLayoutOptions, type UseProcessLayoutResult, VARIANT_EXPLORER_COLUMNS, VARIANT_EXPLORER_DEFAULT_LABELS, VARIANT_EXPLORER_ROW_HEIGHT, VIOLATION_LIST_DEFAULT_LABELS, VariantExplorer, type VariantExplorerColumn, type VariantExplorerLabels, type VariantExplorerProps, type VariantSelectMode, type ViolationFilterIntent, ViolationList, type ViolationListLabels, type ViolationListProps, type ViolationRow, type ViolationRowKind, activityAccentStyle, activityAriaLabel, activityColorScale, activityConformance, activityMetricValue, activityRole, aggregateSegmentBins, applyLayoutSnapshot, buildCaseTimelineInstances, buildObjectCentricMapModel, buildProcessMapModel, buildSpectrumRows, casesFromLog, casesInBrush, casesInRange, computeAutoAbstraction, computeDots, createCaseTableColumns, diffColorScale, diffStateByActivity, diffToProcessGraph, edgeMetricLabel, formatDurationMs, formatMetricValue, happyPathStepNodeId, insertHappyPathStep, isPerformanceMetric, nextHappyPathActivity, nodeMetricLabel, objectCentricEdgeId, processEdgeDenominators, processEdgeId, processGraphStructureKey, rankCategoryColors, removeHappyPathStep, resolveActivityFrequencyMode, resolveCompareKpis, resolveConformanceStates, resolveSelectionState, resolveTransitionFrequencyMode, selectVariantsByCoverage, selectionNeighbourhood, selectionStateLabel, spectrumDomain, spectrumTicks, transitionAriaLabel, transitionConformance, transitionMetricValue, transitionShape, updateHappyPathStep, useHappyPathEditor, useProcessExplorer, useProcessLayout, useProcessMapEdgeKeys, useProcessMapHover, useProcessReplayEdgeTokens, useReplayTimeFormatter, violationRows, withActivityConformance, withTransitionConformance };