@elabs-ai/components-process 4.1.0

package/dist/index.js

@@ -0,0 +1,3146 @@
+"use client";
+
+// src/core/scale.ts
+function ascending(a, b) {
+  return a - b;
+}
+function minMax(values) {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  let seen = false;
+  for (const v of values) {
+    if (!Number.isFinite(v)) continue;
+    seen = true;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  return seen ? [min, max] : [0, 0];
+}
+function quantileSorted(sorted, q) {
+  const n = sorted.length;
+  if (n === 0) return 0;
+  if (n === 1) return sorted[0];
+  const clamped = q < 0 ? 0 : q > 1 ? 1 : q;
+  const pos = clamped * (n - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  const loValue = sorted[lo];
+  if (lo === hi) return loValue;
+  const hiValue = sorted[hi];
+  return loValue + (hiValue - loValue) * (pos - lo);
+}
+
+// src/core/duration-stats.ts
+var TRIM_FRACTION = 0.1;
+var EMPTY_DURATION_STATS = Object.freeze({
+  min: 0,
+  max: 0,
+  mean: 0,
+  median: 0,
+  p90: 0,
+  sum: 0,
+  trimmedMean: 0
+});
+function emptyDurationStats() {
+  return { ...EMPTY_DURATION_STATS };
+}
+function durationStats(samples) {
+  const sorted = [];
+  for (const s of samples) if (Number.isFinite(s)) sorted.push(s);
+  const n = sorted.length;
+  if (n === 0) return emptyDurationStats();
+  sorted.sort(ascending);
+  let sum = 0;
+  for (const s of sorted) sum += s;
+  const trim = Math.floor(n * TRIM_FRACTION);
+  const lo = trim;
+  const hi = n - trim;
+  let trimmedMean;
+  if (hi - lo <= 0) {
+    trimmedMean = sum / n;
+  } else {
+    let trimmedSum = 0;
+    for (let i = lo; i < hi; i += 1) trimmedSum += sorted[i];
+    trimmedMean = trimmedSum / (hi - lo);
+  }
+  return {
+    min: sorted[0],
+    max: sorted[n - 1],
+    mean: sum / n,
+    median: quantileSorted(sorted, 0.5),
+    p90: quantileSorted(sorted, 0.9),
+    sum,
+    trimmedMean
+  };
+}
+var DURATION_SAMPLE_CAP = 4096;
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var DurationSampler = class {
+  capacity;
+  random;
+  reservoir = [];
+  /** Number of finite samples offered, including those the reservoir discarded. */
+  seen = 0;
+  total = 0;
+  lowest = Number.POSITIVE_INFINITY;
+  highest = Number.NEGATIVE_INFINITY;
+  constructor(seed = 2654435769, capacity = DURATION_SAMPLE_CAP) {
+    this.capacity = capacity > 0 ? capacity : 1;
+    this.random = mulberry32(seed);
+  }
+  /** Offer one sample. Non-finite values are ignored. */
+  add(sample) {
+    if (!Number.isFinite(sample)) return;
+    this.total += sample;
+    if (sample < this.lowest) this.lowest = sample;
+    if (sample > this.highest) this.highest = sample;
+    if (this.reservoir.length < this.capacity) {
+      this.reservoir.push(sample);
+    } else {
+      const j = Math.floor(this.random() * (this.seen + 1));
+      if (j < this.capacity) this.reservoir[j] = sample;
+    }
+    this.seen += 1;
+  }
+  /** True number of finite samples offered. */
+  get size() {
+    return this.seen;
+  }
+  /**
+   * Summarize what was collected. `sum`, `mean`, `min` and `max` are EXACT even past the
+   * cap (they are accumulated, not read off the reservoir); the remaining three are
+   * computed from the retained sample.
+   */
+  stats() {
+    if (this.seen === 0) return emptyDurationStats();
+    const fromReservoir = durationStats(this.reservoir);
+    return {
+      ...fromReservoir,
+      min: this.lowest,
+      max: this.highest,
+      sum: this.total,
+      mean: this.total / this.seen
+    };
+  }
+};
+
+// src/core/event-log.ts
+function isNormalizedLog(log) {
+  return Array.isArray(log.cases);
+}
+function asNormalizedLog(log) {
+  return isNormalizedLog(log) ? log : normalizeLog(log);
+}
+function toEpochMs(value) {
+  if (value === void 0 || value === null) return Number.NaN;
+  if (typeof value === "number") return Number.isFinite(value) ? value : Number.NaN;
+  if (value instanceof Date) return value.getTime();
+  const parsed = Date.parse(value);
+  if (!Number.isNaN(parsed)) return parsed;
+  const asNumber = Number(value);
+  return Number.isFinite(asNumber) && value.trim() !== "" ? asNumber : Number.NaN;
+}
+function byTimestamp(a, b) {
+  if (Number.isNaN(a.at) || Number.isNaN(b.at)) return 0;
+  return a.at - b.at;
+}
+function normalizeLog(log) {
+  const staged = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const row of log.events) {
+    if (!row || typeof row.caseId !== "string" || row.caseId === "") continue;
+    if (typeof row.activity !== "string" || row.activity === "") continue;
+    let bucket = staged.get(row.caseId);
+    if (bucket === void 0) {
+      bucket = [];
+      staged.set(row.caseId, bucket);
+      order.push(row.caseId);
+    }
+    bucket.push({ at: toEpochMs(row.timestamp), row });
+  }
+  const cases = [];
+  let events = 0;
+  for (const caseId of order) {
+    const bucket = staged.get(caseId);
+    bucket.sort(byTimestamp);
+    const instances = [];
+    const open = /* @__PURE__ */ new Map();
+    for (const { at, row } of bucket) {
+      if (row.lifecycle === "start") {
+        const index2 = instances.length;
+        instances.push(makeInstance(row, at, at, true));
+        const queue = open.get(row.activity);
+        if (queue === void 0) open.set(row.activity, [index2]);
+        else queue.push(index2);
+        continue;
+      }
+      if (row.lifecycle === "complete") {
+        const queue = open.get(row.activity);
+        const index2 = queue?.shift();
+        if (index2 !== void 0) {
+          const instance = instances[index2];
+          instance.end = at;
+          instance.duration = durationOf(instance.start, at);
+          instance.isOpen = false;
+          if (instance.resource === void 0 && row.resource !== void 0) {
+            instance.resource = row.resource;
+          }
+          if (instance.attributes === void 0 && row.attributes !== void 0) {
+            instance.attributes = row.attributes;
+          }
+          continue;
+        }
+      }
+      const end = at;
+      const explicitStart = toEpochMs(row.startTimestamp);
+      const start = Number.isNaN(explicitStart) ? end : explicitStart;
+      instances.push(makeInstance(row, start, end, false));
+    }
+    if (instances.length === 0) continue;
+    instances.sort(byStart);
+    let caseStart = Number.POSITIVE_INFINITY;
+    let caseEnd = Number.NEGATIVE_INFINITY;
+    for (const instance of instances) {
+      if (Number.isFinite(instance.start) && instance.start < caseStart) caseStart = instance.start;
+      if (Number.isFinite(instance.end) && instance.end > caseEnd) caseEnd = instance.end;
+    }
+    const hasExtent = caseStart !== Number.POSITIVE_INFINITY && caseEnd !== Number.NEGATIVE_INFINITY;
+    const normalizedCase = {
+      caseId,
+      events: instances,
+      start: hasExtent ? caseStart : Number.NaN,
+      end: hasExtent ? caseEnd : Number.NaN,
+      duration: hasExtent ? durationOf(caseStart, caseEnd) : Number.NaN
+    };
+    const caseAttributes = log.caseAttributes?.[caseId];
+    if (caseAttributes !== void 0) normalizedCase.attributes = caseAttributes;
+    cases.push(normalizedCase);
+    events += instances.length;
+  }
+  return { cases, totals: { cases: cases.length, events } };
+}
+function byStart(a, b) {
+  if (Number.isNaN(a.start) || Number.isNaN(b.start)) return 0;
+  return a.start - b.start;
+}
+function durationOf(start, end) {
+  const delta = end - start;
+  if (!Number.isFinite(delta)) return Number.NaN;
+  return delta < 0 ? 0 : delta;
+}
+function makeInstance(row, start, end, isOpen) {
+  const instance = {
+    activity: row.activity,
+    start,
+    end,
+    duration: durationOf(start, end),
+    isOpen
+  };
+  if (row.resource !== void 0) instance.resource = row.resource;
+  if (row.attributes !== void 0) instance.attributes = row.attributes;
+  return instance;
+}
+
+// src/core/extract-variants.ts
+var VARIANT_KEY_SEPARATOR = "
";
+function variantKey(sequence) {
+  return sequence.join(VARIANT_KEY_SEPARATOR);
+}
+function fnv1a32(text, basis) {
+  let hash = basis >>> 0;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash >>> 0;
+}
+function hex8(value) {
+  return (value >>> 0).toString(16).padStart(8, "0");
+}
+function variantId(sequence) {
+  const key = variantKey(sequence);
+  return `v${hex8(fnv1a32(key, 2166136261))}${hex8(fnv1a32(key, 2216829733))}`;
+}
+function extractVariants(log) {
+  const normalized = asNormalizedLog(log);
+  const totalCases = normalized.cases.length;
+  if (totalCases === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const kase of normalized.cases) {
+    const sequence = sequenceOf(kase);
+    const key = variantKey(sequence);
+    let group = groups.get(key);
+    if (group === void 0) {
+      group = { key, sequence, caseIds: [], durations: [] };
+      groups.set(key, group);
+    }
+    group.caseIds.push(kase.caseId);
+    group.durations.push(kase.duration);
+  }
+  const ranked = [...groups.values()].sort(
+    (a, b) => b.caseIds.length - a.caseIds.length || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
+  );
+  const taken = /* @__PURE__ */ new Set();
+  const variants = [];
+  let cumulativeCount = 0;
+  for (const group of ranked) {
+    const count = group.caseIds.length;
+    cumulativeCount += count;
+    let id = variantId(group.sequence);
+    if (taken.has(id)) {
+      let suffix = 1;
+      while (taken.has(`${id}-${suffix}`)) suffix += 1;
+      id = `${id}-${suffix}`;
+    }
+    taken.add(id);
+    variants.push({
+      id,
+      sequence: group.sequence,
+      count,
+      share: count / totalCases,
+      cumulativeShare: cumulativeCount / totalCases,
+      caseIds: group.caseIds,
+      duration: durationStats(group.durations)
+    });
+  }
+  return variants;
+}
+function sequenceOf(kase) {
+  const sequence = new Array(kase.events.length);
+  for (let i = 0; i < kase.events.length; i += 1) {
+    sequence[i] = kase.events[i].activity;
+  }
+  return sequence;
+}
+
+// src/core/discover-graph.ts
+var EDGE_KEY_SEPARATOR = VARIANT_KEY_SEPARATOR;
+function discoverGraph(log, options = {}) {
+  const flowTime = options.flowTime ?? "idle_time";
+  const capacity = options.maxDurationSamples ?? DURATION_SAMPLE_CAP;
+  const normalized = asNormalizedLog(log);
+  const activities = /* @__PURE__ */ new Map();
+  const transitions = /* @__PURE__ */ new Map();
+  const startActivities = /* @__PURE__ */ new Map();
+  const endActivities = /* @__PURE__ */ new Map();
+  const variantKeys = /* @__PURE__ */ new Set();
+  let samplerIndex = 0;
+  const nextSeed = () => {
+    samplerIndex += 1;
+    return (2654435769 ^ Math.imul(samplerIndex, 2654435761)) >>> 0;
+  };
+  let events = 0;
+  const seenActivities = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const kase of normalized.cases) {
+    const trace = kase.events;
+    if (trace.length === 0) continue;
+    events += trace.length;
+    seenActivities.clear();
+    seenEdges.clear();
+    const sequence = new Array(trace.length);
+    for (let i = 0; i < trace.length; i += 1) {
+      const event = trace[i];
+      const name = event.activity;
+      sequence[i] = name;
+      let activity = activities.get(name);
+      if (activity === void 0) {
+        activity = { instances: 0, cases: 0, duration: new DurationSampler(nextSeed(), capacity) };
+        activities.set(name, activity);
+      }
+      activity.instances += 1;
+      activity.duration.add(event.duration);
+      if (!seenActivities.has(name)) {
+        seenActivities.add(name);
+        activity.cases += 1;
+      }
+      if (i === 0) continue;
+      const previous = trace[i - 1];
+      const source = previous.activity;
+      const key = `${source}${EDGE_KEY_SEPARATOR}${name}`;
+      let edge = transitions.get(key);
+      if (edge === void 0) {
+        edge = {
+          source,
+          target: name,
+          count: 0,
+          caseCount: 0,
+          duration: new DurationSampler(nextSeed(), capacity)
+        };
+        transitions.set(key, edge);
+      }
+      edge.count += 1;
+      edge.duration.add(
+        flowTime === "inter_start_time" ? event.start - previous.start : event.start - previous.end
+      );
+      if (!seenEdges.has(key)) {
+        seenEdges.add(key);
+        edge.caseCount += 1;
+      }
+    }
+    const first = trace[0];
+    const last = trace[trace.length - 1];
+    startActivities.set(first.activity, (startActivities.get(first.activity) ?? 0) + 1);
+    endActivities.set(last.activity, (endActivities.get(last.activity) ?? 0) + 1);
+    variantKeys.add(sequence.join(VARIANT_KEY_SEPARATOR));
+  }
+  const activityList = [];
+  for (const [id, accumulator] of activities) {
+    activityList.push({
+      id,
+      label: id,
+      instances: accumulator.instances,
+      cases: accumulator.cases,
+      isStart: startActivities.has(id),
+      isEnd: endActivities.has(id),
+      duration: accumulator.duration.stats()
+    });
+  }
+  activityList.sort((a, b) => b.instances - a.instances || compareStrings(a.id, b.id));
+  const transitionList = [];
+  for (const accumulator of transitions.values()) {
+    transitionList.push({
+      source: accumulator.source,
+      target: accumulator.target,
+      count: accumulator.count,
+      caseCount: accumulator.caseCount,
+      duration: accumulator.duration.stats(),
+      isSelfLoop: accumulator.source === accumulator.target,
+      isBackEdge: false
+    });
+  }
+  transitionList.sort(
+    (a, b) => b.count - a.count || compareStrings(a.source, b.source) || compareStrings(a.target, b.target)
+  );
+  return {
+    activities: activityList,
+    transitions: transitionList,
+    startActivities: toSortedRecord(startActivities),
+    endActivities: toSortedRecord(endActivities),
+    totals: { cases: normalized.cases.length, events, variants: variantKeys.size }
+  };
+}
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function toSortedRecord(counts) {
+  const out = {};
+  for (const key of [...counts.keys()].sort()) out[key] = counts.get(key);
+  return out;
+}
+
+// src/core/aggregate-performance.ts
+var DURATION_UNIT_MS = Object.freeze({
+  ms: 1,
+  s: 1e3,
+  min: 6e4,
+  h: 36e5,
+  d: 864e5
+});
+function performanceValue(stats, agg) {
+  switch (agg) {
+    case "mean":
+      return stats.mean;
+    case "min":
+      return stats.min;
+    case "max":
+      return stats.max;
+    case "sum":
+      return stats.sum;
+    case "p90":
+      return stats.p90;
+    case "trimmed_mean":
+      return stats.trimmedMean;
+    case "median":
+    default:
+      return stats.median;
+  }
+}
+
+// src/process-map/map-model.ts
+var PROCESS_FILTER_INTENT_KINDS = ["with", "without", "startsWith", "endsWith"];
+var PROCESS_FILTER_INTENT_LABELS = Object.freeze({
+  with: "Keep cases containing",
+  without: "Keep cases without",
+  startsWith: "Keep cases starting with",
+  endsWith: "Keep cases ending with"
+});
+var PROCESS_FILTER_INTENT_MESSAGE_KEYS = Object.freeze({
+  with: "process.map.filterIntentWith",
+  without: "process.map.filterIntentWithout",
+  startsWith: "process.map.filterIntentStartsWith",
+  endsWith: "process.map.filterIntentEndsWith"
+});
+var GHOST_OPACITY = 0.35;
+function resolveActivityFrequencyMode(mode) {
+  switch (mode) {
+    case "absolute_case":
+      return "absolute_case";
+    case "relative":
+      return "relative";
+    case "relative_case":
+    case "relative_antecedent":
+    case "relative_consequent":
+      return "relative_case";
+    case "max_repetitions":
+    case "absolute":
+    default:
+      return "absolute";
+  }
+}
+function resolveTransitionFrequencyMode(mode) {
+  return mode === "max_repetitions" ? "absolute" : mode;
+}
+var PERFORMANCE_AGGS = /* @__PURE__ */ new Set([
+  "median",
+  "mean",
+  "min",
+  "max",
+  "sum",
+  "p90",
+  "trimmed_mean"
+]);
+function isPerformanceMetric(metric) {
+  return PERFORMANCE_AGGS.has(metric);
+}
+var PERFORMANCE_AGG_LABELS = Object.freeze({
+  median: "Median duration",
+  mean: "Mean duration",
+  min: "Fastest",
+  max: "Slowest",
+  sum: "Total duration",
+  p90: "90th percentile duration",
+  trimmed_mean: "Trimmed mean duration"
+});
+var ACTIVITY_FREQUENCY_LABELS = Object.freeze({
+  absolute: "Occurrences",
+  absolute_case: "Cases",
+  relative: "Share of events",
+  relative_case: "Share of cases"
+});
+var TRANSITION_FREQUENCY_LABELS = Object.freeze({
+  absolute: "Transitions",
+  absolute_case: "Cases",
+  relative: "Share of transitions",
+  relative_case: "Share of cases",
+  relative_antecedent: "Share of source traffic",
+  relative_consequent: "Share of target traffic"
+});
+function nodeMetricLabel(metric) {
+  return isPerformanceMetric(metric) ? PERFORMANCE_AGG_LABELS[metric] : ACTIVITY_FREQUENCY_LABELS[resolveActivityFrequencyMode(metric)];
+}
+function edgeMetricLabel(metric) {
+  return isPerformanceMetric(metric) ? PERFORMANCE_AGG_LABELS[metric] : TRANSITION_FREQUENCY_LABELS[resolveTransitionFrequencyMode(metric)];
+}
+function isShare(metric) {
+  if (isPerformanceMetric(metric)) return false;
+  const resolved = resolveTransitionFrequencyMode(metric);
+  return resolved !== "absolute" && resolved !== "absolute_case";
+}
+function activityMetricValue(activity, metric, totals) {
+  if (isPerformanceMetric(metric)) return performanceValue(activity.duration, metric);
+  switch (resolveActivityFrequencyMode(metric)) {
+    case "absolute_case":
+      return activity.cases;
+    case "relative":
+      return totals.events === 0 ? 0 : activity.instances / totals.events;
+    case "relative_case":
+      return totals.cases === 0 ? 0 : activity.cases / totals.cases;
+    case "absolute":
+    default:
+      return activity.instances;
+  }
+}
+function processEdgeDenominators(transitions) {
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const t of transitions) {
+    total += t.count;
+    outgoing.set(t.source, (outgoing.get(t.source) ?? 0) + t.count);
+    incoming.set(t.target, (incoming.get(t.target) ?? 0) + t.count);
+  }
+  return { total, outgoing, incoming };
+}
+function ratio(numerator, denominator) {
+  return denominator === 0 ? 0 : numerator / denominator;
+}
+function transitionMetricValue(transition, metric, totals, denominators) {
+  if (isPerformanceMetric(metric)) return performanceValue(transition.duration, metric);
+  switch (resolveTransitionFrequencyMode(metric)) {
+    case "absolute_case":
+      return transition.caseCount;
+    case "relative":
+      return ratio(transition.count, denominators.total);
+    case "relative_case":
+      return ratio(transition.caseCount, totals.cases);
+    case "relative_antecedent":
+      return ratio(transition.count, denominators.outgoing.get(transition.source) ?? 0);
+    case "relative_consequent":
+      return ratio(transition.count, denominators.incoming.get(transition.target) ?? 0);
+    case "absolute":
+    default:
+      return transition.count;
+  }
+}
+var DURATION_LADDER = [
+  [864e5, "d"],
+  [36e5, "h"],
+  [6e4, "min"],
+  [1e3, "s"]
+];
+function formatDurationMs(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "\u2014";
+  if (ms === 0) return "0 s";
+  for (const [size, unit] of DURATION_LADDER) {
+    if (ms >= size) {
+      const scaled = ms / size;
+      return `${scaled < 10 ? scaled.toFixed(1) : Math.round(scaled)} ${unit}`;
+    }
+  }
+  return `${Math.round(ms)} ms`;
+}
+function formatMetricValue(value, metric) {
+  if (isPerformanceMetric(metric)) return formatDurationMs(value);
+  if (!Number.isFinite(value)) return "\u2014";
+  if (isShare(metric)) return `${(value * 100).toFixed(1)}%`;
+  return value.toLocaleString();
+}
+function processEdgeId(source, target) {
+  return `${source}${EDGE_KEY_SEPARATOR}${target}`;
+}
+function processGraphStructureKey(graph) {
+  const activities = graph.activities.map((a) => a.id).sort();
+  const transitions = graph.transitions.map((t) => processEdgeId(t.source, t.target)).sort();
+  return `${activities.join(EDGE_KEY_SEPARATOR)}|${transitions.join(EDGE_KEY_SEPARATOR)}`;
+}
+function selectionNeighbourhood(graph, selection) {
+  if (!selection) return null;
+  const activities = /* @__PURE__ */ new Set();
+  const transitions = /* @__PURE__ */ new Set();
+  if (selection.kind === "activity") {
+    activities.add(selection.id);
+    for (const t of graph.transitions) {
+      if (t.source !== selection.id && t.target !== selection.id) continue;
+      transitions.add(processEdgeId(t.source, t.target));
+      activities.add(t.source);
+      activities.add(t.target);
+    }
+    return { activities, transitions };
+  }
+  for (const t of graph.transitions) {
+    if (processEdgeId(t.source, t.target) !== selection.id) continue;
+    transitions.add(selection.id);
+    activities.add(t.source);
+    activities.add(t.target);
+  }
+  return { activities, transitions };
+}
+function resolveSelectionState(id, kind, selection, neighbourhood, states) {
+  if (selection && selection.kind === kind && selection.id === id) return "selected";
+  const namespace = kind === "activity" ? states?.activities : states?.transitions;
+  const filterState = namespace?.[id];
+  if (filterState === "excluded") return "excluded";
+  if (selection && neighbourhood) {
+    const kept = kind === "activity" ? neighbourhood.activities : neighbourhood.transitions;
+    if (!kept.has(id)) return "excluded";
+  }
+  if (filterState !== void 0) return filterState;
+  return "associated";
+}
+function buildProcessMapModel({
+  graph,
+  metric,
+  rework,
+  selection,
+  selectionStates,
+  backEdgeIds
+}) {
+  const neighbourhood = selectionNeighbourhood(graph, selection);
+  const denominators = processEdgeDenominators(graph.transitions);
+  const nodeValues = graph.activities.map((a) => activityMetricValue(a, metric.node, graph.totals));
+  const nodeDomain = minMax(nodeValues);
+  const edgeValues = graph.transitions.map(
+    (t) => transitionMetricValue(t, metric.edge, graph.totals, denominators)
+  );
+  const edgeDomain = minMax(edgeValues);
+  const resolvedNodeMetricLabel = nodeMetricLabel(metric.node);
+  const resolvedEdgeMetricLabel = edgeMetricLabel(metric.edge);
+  const nodeSpan = nodeDomain[1] - nodeDomain[0];
+  const nodes = graph.activities.map((activity, index2) => {
+    const primaryValue = nodeValues[index2];
+    const secondaryLabel = metric.secondary === void 0 ? void 0 : formatMetricValue(
+      activityMetricValue(activity, metric.secondary, graph.totals),
+      metric.secondary
+    );
+    const reworkEntry = rework?.perActivity[activity.id];
+    const reworkCount = reworkEntry === void 0 ? void 0 : reworkEntry.selfLoops + reworkEntry.loops;
+    const selectionState = resolveSelectionState(
+      activity.id,
+      "activity",
+      selection,
+      neighbourhood,
+      selectionStates
+    );
+    const data = {
+      title: activity.label || activity.id,
+      metricLabel: resolvedNodeMetricLabel,
+      primaryLabel: formatMetricValue(primaryValue, metric.node),
+      primaryValue,
+      secondaryLabel,
+      // A single-activity graph (or a flat metric) has no domain to sit in; half
+      // saturation is the honest answer — "no comparison available" — rather than a
+      // full-strength fill claiming this is the busiest node in a set of one.
+      saturation: nodeSpan === 0 ? 0.5 : (primaryValue - nodeDomain[0]) / nodeSpan,
+      isStart: activity.isStart,
+      isEnd: activity.isEnd,
+      reworkCount,
+      selectionState
+    };
+    return {
+      id: activity.id,
+      type: "process-activity",
+      position: { x: 0, y: 0 },
+      data,
+      draggable: false,
+      // React Flow reads a node's accessible name from the node OBJECT, not from the
+      // component — the same seam `withWeightedEdgeAria` exists for on the edge side
+      // (#285). Without this the node announces only its id and the metric the map
+      // exists to show reaches no assistive technology.
+      ariaLabel: activityAriaLabel(data),
+      // No `aria-disabled` here even when `selectionState === "excluded"` — an excluded
+      // node stays fully operable (clicking it is how a reader filters it back in), and
+      // `activityAriaLabel` already appends the word "excluded" to its accessible name, so
+      // assistive technology gets the state as real text rather than a lie about
+      // disablement. See `ProcessSelectionState`'s own doc comment.
+      domAttributes: {
+        "data-selection": selectionState,
+        "data-activity": activity.id
+      }
+    };
+  });
+  const edges = graph.transitions.map((transition, index2) => {
+    const value = edgeValues[index2];
+    const id = processEdgeId(transition.source, transition.target);
+    const secondaryLabel = metric.secondary === void 0 ? void 0 : formatMetricValue(
+      transitionMetricValue(transition, metric.secondary, graph.totals, denominators),
+      metric.secondary
+    );
+    const selectionState = resolveSelectionState(
+      id,
+      "transition",
+      selection,
+      neighbourhood,
+      selectionStates
+    );
+    const data = {
+      source: transition.source,
+      target: transition.target,
+      weight: value,
+      value,
+      valueDomain: edgeDomain,
+      label: formatMetricValue(value, metric.edge),
+      secondaryLabel,
+      isSelfLoop: transition.isSelfLoop,
+      isBackEdge: backEdgeIds?.has(id) ?? transition.isBackEdge,
+      selectionState
+    };
+    return {
+      id,
+      source: transition.source,
+      target: transition.target,
+      type: "process-transition",
+      data,
+      ariaLabel: transitionAriaLabel(data, resolvedEdgeMetricLabel)
+    };
+  });
+  const activityRows = nodes.map((node) => ({
+    id: node.id,
+    title: node.data.title,
+    primaryLabel: node.data.primaryLabel,
+    secondaryLabel: node.data.secondaryLabel,
+    reworkCount: node.data.reworkCount,
+    role: activityRole(node.data),
+    selectionState: node.data.selectionState
+  }));
+  const transitionRows = edges.map((edge) => {
+    const data = edge.data;
+    return {
+      id: edge.id,
+      source: data.source,
+      target: data.target,
+      primaryLabel: data.label,
+      secondaryLabel: data.secondaryLabel,
+      shape: transitionShape(data),
+      selectionState: data.selectionState
+    };
+  });
+  const excludedCounts = {
+    activities: nodes.reduce((n, node) => n + (node.data.selectionState === "excluded" ? 1 : 0), 0),
+    totalActivities: nodes.length,
+    transitions: edges.reduce(
+      (n, edge) => n + (edge.data.selectionState === "excluded" ? 1 : 0),
+      0
+    ),
+    totalTransitions: edges.length
+  };
+  return {
+    nodes,
+    edges,
+    nodeDomain,
+    edgeDomain,
+    nodeMetricLabel: resolvedNodeMetricLabel,
+    edgeMetricLabel: resolvedEdgeMetricLabel,
+    activityRows,
+    transitionRows,
+    formatEdgeValue: (value) => formatMetricValue(value, metric.edge),
+    excludedCounts
+  };
+}
+function activityRole(data) {
+  if (data.isStart && data.isEnd) return "Start and end";
+  if (data.isStart) return "Start";
+  if (data.isEnd) return "End";
+  return "Step";
+}
+function transitionShape(data) {
+  if (data.isSelfLoop) return "Self-loop";
+  if (data.isBackEdge) return "Back edge";
+  return "Forward";
+}
+function selectionStateLabel(state) {
+  if (state === "selected") return "Selected";
+  if (state === "excluded") return "Excluded";
+  return "";
+}
+var PROCESS_SELECTION_STATE_MESSAGE_KEYS = Object.freeze({
+  selected: "process.map.stateSelected",
+  excluded: "process.map.stateExcluded"
+});
+function activityAriaLabel(data) {
+  const parts = [`${data.title} \u2014 ${activityRole(data).toLowerCase()}`];
+  parts.push(`${data.metricLabel} ${data.primaryLabel}`);
+  if (data.secondaryLabel) parts.push(data.secondaryLabel);
+  if (data.reworkCount) parts.push(`${data.reworkCount} repeated executions`);
+  if (data.selectionState !== "associated") parts.push(data.selectionState);
+  return parts.join(", ");
+}
+function transitionAriaLabel(data, metricLabel) {
+  const parts = [
+    data.isSelfLoop ? `Self-loop on ${data.source}` : `${data.isBackEdge ? "Back edge" : "Transition"} from ${data.source} to ${data.target}`,
+    `${metricLabel} ${data.label}`
+  ];
+  if (data.secondaryLabel) parts.push(data.secondaryLabel);
+  if (data.selectionState !== "associated") parts.push(data.selectionState);
+  return parts.join(", ");
+}
+
+// src/process-map/process-map.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useMemo as useMemo4,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { Filter } from "lucide-react";
+import {
+  Button,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  StatePanel,
+  Table,
+  TableBody,
+  TableCaption,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+  useLocale
+} from "@elabs-ai/components-ui";
+import { cn as cn2 } from "@elabs-ai/components-ui/lib/cn";
+import {
+  CanvasShell,
+  FlowMiniMap,
+  Legend,
+  ZoomControls
+} from "@elabs-ai/components-flow";
+
+// src/core/abstract-graph.ts
+function edgeKey(source, target) {
+  return `${source}${EDGE_KEY_SEPARATOR}${target}`;
+}
+function compareStrings2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function clampFraction(value) {
+  if (!Number.isFinite(value)) return 1;
+  return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function countToKeep(total, fraction, atLeast) {
+  if (total === 0) return 0;
+  const kept = Math.round(total * fraction);
+  return kept < atLeast ? Math.min(atLeast, total) : kept;
+}
+var MinHeap = class {
+  nodes = [];
+  costs = [];
+  get size() {
+    return this.nodes.length;
+  }
+  push(node, cost) {
+    this.nodes.push(node);
+    this.costs.push(cost);
+    let i = this.nodes.length - 1;
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this.costs[parent] <= this.costs[i]) break;
+      this.swap(i, parent);
+      i = parent;
+    }
+  }
+  pop() {
+    if (this.nodes.length === 0) return void 0;
+    const node = this.nodes[0];
+    const cost = this.costs[0];
+    const lastNode = this.nodes.pop();
+    const lastCost = this.costs.pop();
+    if (this.nodes.length > 0) {
+      this.nodes[0] = lastNode;
+      this.costs[0] = lastCost;
+      let i = 0;
+      for (; ; ) {
+        const left = i * 2 + 1;
+        const right = left + 1;
+        let smallest = i;
+        const size = this.nodes.length;
+        if (left < size && this.costs[left] < this.costs[smallest]) {
+          smallest = left;
+        }
+        if (right < size && this.costs[right] < this.costs[smallest]) {
+          smallest = right;
+        }
+        if (smallest === i) break;
+        this.swap(i, smallest);
+        i = smallest;
+      }
+    }
+    return { node, cost };
+  }
+  swap(a, b) {
+    const node = this.nodes[a];
+    this.nodes[a] = this.nodes[b];
+    this.nodes[b] = node;
+    const cost = this.costs[a];
+    this.costs[a] = this.costs[b];
+    this.costs[b] = cost;
+  }
+};
+function abstractGraph(graph, opts) {
+  const keepConnected = opts.keepConnected ?? true;
+  const invert = opts.invert ?? false;
+  const activityFraction = clampFraction(opts.activities);
+  const pathFraction = clampFraction(opts.paths);
+  const rankedActivities = [...graph.activities].sort(
+    (a, b) => b.cases - a.cases || b.instances - a.instances || compareStrings2(a.id, b.id)
+  );
+  const activityKeepCount = countToKeep(rankedActivities.length, activityFraction, 1);
+  const keptActivities = new Set(
+    (invert ? rankedActivities.slice(rankedActivities.length - activityKeepCount) : rankedActivities.slice(0, activityKeepCount)).map((activity) => activity.id)
+  );
+  const candidateEdges = graph.transitions.filter(
+    (edge) => keptActivities.has(edge.source) && keptActivities.has(edge.target)
+  );
+  const rankedEdges = [...candidateEdges].sort(
+    (a, b) => b.count - a.count || b.caseCount - a.caseCount || compareStrings2(a.source, b.source) || compareStrings2(a.target, b.target)
+  );
+  const edgeKeepCount = countToKeep(rankedEdges.length, pathFraction, 0);
+  const keptEdges = new Set(
+    (invert ? rankedEdges.slice(rankedEdges.length - edgeKeepCount) : rankedEdges.slice(0, edgeKeepCount)).map((edge) => edgeKey(edge.source, edge.target))
+  );
+  if (keepConnected && keptActivities.size > 0) {
+    reconnect(graph, keptActivities, keptEdges);
+  }
+  const activities = graph.activities.filter(
+    (activity) => keptActivities.has(activity.id)
+  );
+  const transitions = graph.transitions.filter(
+    (edge) => keptEdges.has(edgeKey(edge.source, edge.target))
+  );
+  return {
+    activities,
+    transitions,
+    startActivities: pick(graph.startActivities, keptActivities),
+    endActivities: pick(graph.endActivities, keptActivities),
+    // Passed through by reference: totals describe the LOG, and abstraction is a view.
+    totals: graph.totals,
+    hidden: {
+      activities: graph.activities.length - activities.length,
+      paths: graph.transitions.length - transitions.length
+    }
+  };
+}
+function pick(record, keep) {
+  const out = {};
+  for (const name of Object.keys(record)) {
+    if (keep.has(name)) out[name] = record[name];
+  }
+  return out;
+}
+function reconnect(graph, keptActivities, keptEdges) {
+  const forward = /* @__PURE__ */ new Map();
+  const backward = /* @__PURE__ */ new Map();
+  let maxCount = 1;
+  for (const edge of graph.transitions) {
+    if (edge.count > maxCount) maxCount = edge.count;
+    index(forward, edge.source, edge);
+    index(backward, edge.target, edge);
+  }
+  const logMax = Math.log(maxCount);
+  const cost = (count) => count > 0 ? logMax - Math.log(count) : logMax;
+  const bound = graph.activities.length + graph.transitions.length + 2;
+  for (let round = 0; round < bound; round += 1) {
+    const before = keptActivities.size + keptEdges.size;
+    repairDirection(graph.startActivities, forward, true);
+    repairDirection(graph.endActivities, backward, false);
+    if (keptActivities.size + keptEdges.size === before) break;
+  }
+  function repairDirection(seedCounts, adjacency, downstream) {
+    const allSeeds = Object.keys(seedCounts);
+    if (allSeeds.length === 0) return;
+    if (!allSeeds.some((id) => keptActivities.has(id))) anchor(seedCounts, keptActivities);
+    const keptSeeds = allSeeds.filter((id) => keptActivities.has(id));
+    if (keptSeeds.length === 0) return;
+    const reached = spread(keptSeeds, adjacency, downstream);
+    for (const activity of graph.activities) {
+      if (!keptActivities.has(activity.id) || reached.has(activity.id)) continue;
+      const route = shortestRoute(keptSeeds, activity.id, adjacency, downstream, true) ?? shortestRoute(keptSeeds, activity.id, adjacency, downstream, false) ?? shortestRoute(allSeeds, activity.id, adjacency, downstream, false);
+      if (route === void 0) continue;
+      for (const id of route.activities) keptActivities.add(id);
+      for (const key of route.edges) keptEdges.add(key);
+      for (const id of spread([...route.activities], adjacency, downstream)) reached.add(id);
+    }
+  }
+  function spread(seeds, adjacency, downstream) {
+    const seen = new Set(seeds.filter((id) => keptActivities.has(id)));
+    const queue = [...seen];
+    for (let head = 0; head < queue.length; head += 1) {
+      const node = queue[head];
+      for (const edge of adjacency.get(node) ?? []) {
+        const next = downstream ? edge.target : edge.source;
+        if (!keptActivities.has(next)) continue;
+        if (!keptEdges.has(edgeKey(edge.source, edge.target))) continue;
+        if (seen.has(next)) continue;
+        seen.add(next);
+        queue.push(next);
+      }
+    }
+    return seen;
+  }
+  function shortestRoute(seeds, target, adjacency, downstream, keptOnly) {
+    const distance = /* @__PURE__ */ new Map();
+    const previous = /* @__PURE__ */ new Map();
+    const settled = /* @__PURE__ */ new Set();
+    const heap = new MinHeap();
+    for (const seed of seeds) {
+      distance.set(seed, 0);
+      heap.push(seed, 0);
+    }
+    while (heap.size > 0) {
+      const top = heap.pop();
+      if (settled.has(top.node)) continue;
+      settled.add(top.node);
+      if (top.node === target) break;
+      for (const edge of adjacency.get(top.node) ?? []) {
+        const next = downstream ? edge.target : edge.source;
+        if (next === top.node) continue;
+        if (keptOnly && !keptActivities.has(next)) continue;
+        const candidate = top.cost + cost(edge.count);
+        const known = distance.get(next);
+        if (known !== void 0 && known <= candidate) continue;
+        distance.set(next, candidate);
+        previous.set(next, edge);
+        heap.push(next, candidate);
+      }
+    }
+    if (!settled.has(target)) return void 0;
+    const route = { activities: /* @__PURE__ */ new Set([target]), edges: /* @__PURE__ */ new Set() };
+    let cursor = target;
+    for (; ; ) {
+      const edge = previous.get(cursor);
+      if (edge === void 0) break;
+      route.edges.add(edgeKey(edge.source, edge.target));
+      route.activities.add(edge.source);
+      route.activities.add(edge.target);
+      cursor = downstream ? edge.source : edge.target;
+    }
+    return route;
+  }
+  function anchor(counts, kept) {
+    const names = Object.keys(counts);
+    if (names.length === 0) return;
+    if (names.some((name) => kept.has(name))) return;
+    let best = names[0];
+    for (const name of names) {
+      const value = counts[name];
+      const bestValue = counts[best];
+      if (value > bestValue || value === bestValue && compareStrings2(name, best) < 0) best = name;
+    }
+    kept.add(best);
+  }
+}
+function index(map, key, edge) {
+  const bucket = map.get(key);
+  if (bucket === void 0) map.set(key, [edge]);
+  else bucket.push(edge);
+}
+
+// src/core/detect-rework.ts
+function detectRework(log) {
+  const normalized = asNormalizedLog(log);
+  const tallies = /* @__PURE__ */ new Map();
+  let selfLoops = 0;
+  let loops = 0;
+  let casesWithRework = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const kase of normalized.cases) {
+    seen.clear();
+    let caseHasRework = false;
+    let previous;
+    for (const event of kase.events) {
+      const name = event.activity;
+      let tally = tallies.get(name);
+      if (tally === void 0) {
+        tally = { selfLoops: 0, loops: 0 };
+        tallies.set(name, tally);
+      }
+      if (seen.has(name)) {
+        caseHasRework = true;
+        if (name === previous) {
+          tally.selfLoops += 1;
+          selfLoops += 1;
+        } else {
+          tally.loops += 1;
+          loops += 1;
+        }
+      } else {
+        seen.add(name);
+      }
+      previous = name;
+    }
+    if (caseHasRework) casesWithRework += 1;
+  }
+  const perActivity = {};
+  for (const name of [...tallies.keys()].sort()) {
+    perActivity[name] = tallies.get(name);
+  }
+  return {
+    selfLoops,
+    loops,
+    caseReworkRate: normalized.cases.length === 0 ? 0 : casesWithRework / normalized.cases.length,
+    perActivity
+  };
+}
+
+// src/process-map/process-activity-node.tsx
+import { useMemo } from "react";
+import { CircleDot, Flag, Play, RefreshCw } from "lucide-react";
+import { Badge } from "@elabs-ai/components-ui";
+import { cn } from "@elabs-ai/components-ui/lib/cn";
+import { FlowNode } from "@elabs-ai/components-flow";
+
+// src/process-map/process-map-context.ts
+import { createContext, use } from "react";
+var EMPTY_PROCESS_MAP_HOVER = Object.freeze({
+  activityId: null,
+  incidentEdgeIds: /* @__PURE__ */ new Set()
+});
+var ProcessMapHoverContext = createContext(EMPTY_PROCESS_MAP_HOVER);
+function useProcessMapHover() {
+  return use(ProcessMapHoverContext);
+}
+var NOOP_EDGE_KEY_HANDLER = () => {
+};
+var ProcessMapEdgeKeyContext = createContext(NOOP_EDGE_KEY_HANDLER);
+function useProcessMapEdgeKeys() {
+  return use(ProcessMapEdgeKeyContext);
+}
+
+// src/process-map/process-activity-node.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var GHOST_FRAME_STYLE = {
+  "--border": "var(--border-strong)",
+  "--flow-node": "color-mix(in oklab, var(--card) 60%, var(--surface-muted) 40%)"
+};
+function meterFill(saturation) {
+  const percent = Math.round(Math.min(1, Math.max(0, saturation)) * 100);
+  return `color-mix(in oklab, var(--primary) ${percent}%, var(--surface-muted))`;
+}
+function roleIcon(isStart, isEnd) {
+  if (isStart && isEnd) return CircleDot;
+  if (isStart) return Play;
+  if (isEnd) return Flag;
+  return void 0;
+}
+function ProcessActivityNode(props) {
+  const { data } = props;
+  const hover = useProcessMapHover();
+  const RoleIcon = roleIcon(data.isStart, data.isEnd);
+  const isHovered = hover.activityId === props.id;
+  const isDimmed = data.selectionState === "excluded";
+  const percent = Math.round(Math.min(1, Math.max(0, data.saturation)) * 100);
+  const flowData = useMemo(
+    () => ({
+      title: data.title,
+      kind: data.metricLabel,
+      subtitle: data.secondaryLabel ? `${data.primaryLabel} \xB7 ${data.secondaryLabel}` : data.primaryLabel,
+      icon: RoleIcon ? /* @__PURE__ */ jsx(RoleIcon, { "aria-hidden": "true" }) : void 0,
+      // `tone` is a COLOUR axis in FlowNode. The process map never uses it to carry a
+      // metric — the fill would then be the only channel — so it stays default and the
+      // role/rework signals are carried by the glyph, the badge and the accessible name.
+      tone: "default",
+      // The metric's second, colour-free channel: bar LENGTH. `aria-hidden` because the
+      // same number is already printed in the subtitle above and repeated in the node's
+      // accessible name — a third announcement would be noise, not access. The fill (not
+      // the text) is the one thing here that still dims at the shared ghost rung.
+      footer: /* @__PURE__ */ jsx(
+        "div",
+        {
+          "aria-hidden": "true",
+          "data-slot": "process-activity-node-meter",
+          "data-percent": percent,
+          className: "h-1.5 w-full overflow-hidden rounded-full bg-surface-muted transition-opacity duration-fast ease-standard motion-reduce:transition-none",
+          style: isDimmed ? { opacity: GHOST_OPACITY } : void 0,
+          children: /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "h-full rounded-full transition-[width] duration-base ease-standard motion-reduce:transition-none",
+              style: { width: `${percent}%`, background: meterFill(data.saturation) }
+            }
+          )
+        }
+      )
+    }),
+    [
+      data.title,
+      data.metricLabel,
+      data.primaryLabel,
+      data.secondaryLabel,
+      data.saturation,
+      RoleIcon,
+      percent,
+      isDimmed
+    ]
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "process-activity-node",
+      "data-selection": data.selectionState,
+      "data-role": activityRole(data).toLowerCase(),
+      "data-hover": isHovered ? "true" : void 0,
+      className: cn("relative", isHovered && "z-10"),
+      children: [
+        data.reworkCount ? /* @__PURE__ */ jsxs(
+          Badge,
+          {
+            variant: "warning",
+            "data-slot": "process-activity-node-rework",
+            className: "absolute -end-2 -top-2 z-10 gap-1 px-1.5 py-0 text-meta tabular-nums",
+            children: [
+              /* @__PURE__ */ jsx(RefreshCw, { "aria-hidden": "true", className: "size-3" }),
+              /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: data.reworkCount }),
+              /* @__PURE__ */ jsxs("span", { className: "sr-only", children: [
+                data.reworkCount,
+                " repeated executions"
+              ] })
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsx("div", { "data-slot": "process-activity-node-frame", style: isDimmed ? GHOST_FRAME_STYLE : void 0, children: /* @__PURE__ */ jsx(FlowNode, { ...props, type: "brand", data: flowData }) })
+      ]
+    }
+  );
+}
+
+// src/process-map/process-transition-edge.tsx
+import { useMemo as useMemo2 } from "react";
+import {
+  FlowSelfLoopEdge,
+  FlowWeightedEdge
+} from "@elabs-ai/components-flow";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PROCESS_MAP_EDGE_SCALE_GROUP = "process-map";
+var RESTING_OPACITY = 1;
+var UNRELATED_OPACITY = 0.25;
+var EXCLUDED_LABEL_PROPS = { className: "border-dashed", "data-selection": "excluded" };
+function ProcessTransitionEdge(props) {
+  const { data } = props;
+  const hover = useProcessMapHover();
+  const onEdgeKey = useProcessMapEdgeKeys();
+  const isExcluded = data?.selectionState === "excluded";
+  const labelProps = isExcluded ? EXCLUDED_LABEL_PROPS : void 0;
+  const weightedData = useMemo2(
+    () => ({
+      weight: data?.weight,
+      scaleGroup: PROCESS_MAP_EDGE_SCALE_GROUP,
+      value: data?.value,
+      valueDomain: data?.valueDomain,
+      label: data?.label,
+      secondaryLabel: data?.secondaryLabel,
+      variant: data?.isBackEdge ? "back" : "forward",
+      labelProps
+    }),
+    [
+      data?.weight,
+      data?.value,
+      data?.valueDomain,
+      data?.label,
+      data?.secondaryLabel,
+      data?.isBackEdge,
+      labelProps
+    ]
+  );
+  const selfLoopData = useMemo2(
+    () => ({
+      weight: data?.weight,
+      scaleGroup: PROCESS_MAP_EDGE_SCALE_GROUP,
+      label: data?.label,
+      secondaryLabel: data?.secondaryLabel,
+      labelProps
+    }),
+    [data?.weight, data?.label, data?.secondaryLabel, labelProps]
+  );
+  const opacity = isExcluded ? GHOST_OPACITY : hover.activityId !== null && !hover.incidentEdgeIds.has(props.id) ? UNRELATED_OPACITY : RESTING_OPACITY;
+  return /* @__PURE__ */ jsx2(
+    "g",
+    {
+      "data-slot": "process-transition-edge",
+      "data-shape": data?.isSelfLoop ? "self-loop" : data?.isBackEdge ? "back" : "forward",
+      "data-selection": data?.selectionState,
+      "data-incident": hover.incidentEdgeIds.has(props.id) ? "true" : void 0,
+      className: "transition-opacity duration-fast ease-standard motion-reduce:transition-none",
+      style: { opacity },
+      onKeyDown: (event) => onEdgeKey(props.id, event),
+      children: data?.isSelfLoop ? /* @__PURE__ */ jsx2(FlowSelfLoopEdge, { ...props, type: "self-loop", data: selfLoopData }) : /* @__PURE__ */ jsx2(FlowWeightedEdge, { ...props, type: "weighted", data: weightedData })
+    }
+  );
+}
+
+// src/process-map/use-process-layout.ts
+import { useCallback, useEffect, useMemo as useMemo3, useRef, useState } from "react";
+import { layoutFlow } from "@elabs-ai/components-flow";
+var NODE_SPACING = 72;
+var RANK_SPACING = { TB: 72, BT: 72, LR: 120, RL: 120 };
+var DEFAULT_LAYOUT_DEBOUNCE_MS = 80;
+var PROCESS_MAP_NODE_MOTION_CLASS = "[&_div[data-id]:not([data-handlepos])]:transition-transform [&_div[data-id]:not([data-handlepos])]:duration-base [&_div[data-id]:not([data-handlepos])]:ease-standard motion-reduce:[&_div[data-id]:not([data-handlepos])]:transition-none";
+var EMPTY_SET = /* @__PURE__ */ new Set();
+function toSnapshot(result, durationMs) {
+  const positions = {};
+  const sourcePosition = {};
+  const targetPosition = {};
+  for (const node of result.nodes) {
+    positions[node.id] = node.position;
+    sourcePosition[node.id] = node.sourcePosition;
+    targetPosition[node.id] = node.targetPosition;
+  }
+  return {
+    positions,
+    sourcePosition,
+    targetPosition,
+    backEdges: result.backEdges,
+    selfLoops: result.selfLoops,
+    durationMs
+  };
+}
+function applyLayoutSnapshot(nodes, snapshot) {
+  return nodes.map((node) => {
+    const position = snapshot.positions[node.id];
+    if (!position) return node;
+    return {
+      ...node,
+      position,
+      sourcePosition: snapshot.sourcePosition[node.id],
+      targetPosition: snapshot.targetPosition[node.id]
+    };
+  });
+}
+function useProcessLayout({
+  nodes,
+  edges,
+  structureKey,
+  direction,
+  debounceMs = DEFAULT_LAYOUT_DEBOUNCE_MS
+}) {
+  const cacheKey = `${structureKey}::${direction}`;
+  const cache = useRef(/* @__PURE__ */ new Map());
+  const runs = useRef(0);
+  const [applied, setApplied] = useState(
+    null
+  );
+  const compute = useCallback(
+    (key, currentNodes, currentEdges) => {
+      const started = performance.now();
+      const result = layoutFlow(currentNodes, currentEdges, {
+        direction,
+        nodeSpacing: NODE_SPACING,
+        rankSpacing: RANK_SPACING[direction]
+      });
+      const snapshot2 = toSnapshot(result, performance.now() - started);
+      runs.current += 1;
+      cache.current.set(key, snapshot2);
+      setApplied({ key, snapshot: snapshot2 });
+    },
+    [direction]
+  );
+  const latest = useRef({ nodes, edges });
+  latest.current = { nodes, edges };
+  const cachedForKey = cache.current.get(cacheKey);
+  const hasLayout = applied?.key === cacheKey || cachedForKey !== void 0;
+  useEffect(() => {
+    const cached = cache.current.get(cacheKey);
+    if (cached) {
+      setApplied(
+        (current) => current?.key === cacheKey ? current : { key: cacheKey, snapshot: cached }
+      );
+      return;
+    }
+    if (latest.current.nodes.length === 0) {
+      setApplied({
+        key: cacheKey,
+        snapshot: {
+          positions: {},
+          sourcePosition: {},
+          targetPosition: {},
+          backEdges: [],
+          selfLoops: [],
+          durationMs: 0
+        }
+      });
+      return;
+    }
+    if (runs.current === 0 || debounceMs <= 0) {
+      compute(cacheKey, latest.current.nodes, latest.current.edges);
+      return;
+    }
+    const timer = setTimeout(
+      () => compute(cacheKey, latest.current.nodes, latest.current.edges),
+      debounceMs
+    );
+    return () => clearTimeout(timer);
+  }, [cacheKey, compute, debounceMs]);
+  const snapshot = applied?.key === cacheKey ? applied.snapshot : cachedForKey;
+  const positionedNodes = useMemo3(
+    () => snapshot ? applyLayoutSnapshot(nodes, snapshot) : nodes,
+    [nodes, snapshot]
+  );
+  const backEdgeIds = useMemo3(
+    () => snapshot ? new Set(snapshot.backEdges) : EMPTY_SET,
+    [snapshot]
+  );
+  const selfLoopIds = useMemo3(
+    () => snapshot ? new Set(snapshot.selfLoops) : EMPTY_SET,
+    [snapshot]
+  );
+  return {
+    nodes: positionedNodes,
+    backEdgeIds,
+    selfLoopIds,
+    layoutRuns: runs.current,
+    lastLayoutMs: snapshot?.durationMs ?? 0,
+    pending: !hasLayout && nodes.length > 0
+  };
+}
+
+// src/process-map/process-map.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var NODE_TYPES = { "process-activity": ProcessActivityNode };
+var EDGE_TYPES = { "process-transition": ProcessTransitionEdge };
+var PROCESS_MAP_LEGIBLE_ZOOM = 0.75;
+var FIT_VIEW_OPTIONS = {
+  padding: 0.15,
+  maxZoom: 1,
+  minZoom: PROCESS_MAP_LEGIBLE_ZOOM
+};
+var MIN_ZOOM = 0.1;
+function useResolvedGraph(graph, log, abstraction) {
+  const discovered = useMemo4(
+    () => graph ? void 0 : log ? discoverGraph(log) : void 0,
+    [graph, log]
+  );
+  const base = graph ?? discovered;
+  const activities = abstraction?.activities;
+  const paths = abstraction?.paths;
+  return useMemo4(() => {
+    if (!base) return void 0;
+    if (activities === void 0 && paths === void 0) return base;
+    return abstractGraph(base, { activities: activities ?? 1, paths: paths ?? 1 });
+  }, [base, activities, paths]);
+}
+function ProcessMap({
+  graph,
+  log,
+  abstraction,
+  metric,
+  rework,
+  selection,
+  selectionStates,
+  onSelect,
+  onFilterIntent,
+  direction = "TB",
+  showMiniMap = true,
+  showLegend = true,
+  tableView = false,
+  loading = false,
+  label,
+  className,
+  ...props
+}) {
+  const { t } = useLocale();
+  const mapLabel = label ?? t("process.map.label");
+  const selectionStateText = useCallback2(
+    (state) => {
+      const key = PROCESS_SELECTION_STATE_MESSAGE_KEYS[state];
+      return key ? t(key) : "";
+    },
+    [t]
+  );
+  const resolved = useResolvedGraph(graph, log, abstraction);
+  const derivedRework = useMemo4(
+    () => rework ? void 0 : log ? detectRework(log) : void 0,
+    [rework, log]
+  );
+  const activeRework = rework ?? derivedRework;
+  const isControlled = selection !== void 0;
+  const [ownSelection, setOwnSelection] = useState2(null);
+  const activeSelection = isControlled ? selection ?? null : ownSelection;
+  const applySelection = useCallback2(
+    (next) => {
+      if (!isControlled) setOwnSelection(next);
+      onSelect?.(next);
+    },
+    [isControlled, onSelect]
+  );
+  const structureKey = useMemo4(
+    () => resolved ? processGraphStructureKey(resolved) : "",
+    [resolved]
+  );
+  const firstPass = useMemo4(
+    () => resolved ? buildProcessMapModel({
+      graph: resolved,
+      metric,
+      rework: activeRework,
+      selection: activeSelection,
+      selectionStates
+    }) : null,
+    [resolved, metric, activeRework, activeSelection, selectionStates]
+  );
+  const [nodeSizes, setNodeSizes] = useState2({});
+  const handleNodesChange = useCallback2((changes) => {
+    setNodeSizes((current) => {
+      let next = null;
+      for (const change of changes) {
+        if (change.type !== "dimensions" || !change.dimensions) continue;
+        const previous = current[change.id];
+        if (previous?.width === change.dimensions.width && previous.height === change.dimensions.height) {
+          continue;
+        }
+        next ??= { ...current };
+        next[change.id] = { width: change.dimensions.width, height: change.dimensions.height };
+      }
+      return next ?? current;
+    });
+  }, []);
+  const layoutNodes = useMemo4(() => {
+    const source = firstPass?.nodes ?? EMPTY_NODES;
+    let changed = false;
+    const next = source.map((node) => {
+      const measured = nodeSizes[node.id];
+      if (!measured) return node;
+      changed = true;
+      return { ...node, measured };
+    });
+    return changed ? next : source;
+  }, [firstPass, nodeSizes]);
+  const sizeKey = useMemo4(() => {
+    let width = 0;
+    let height = 0;
+    for (const size of Object.values(nodeSizes)) {
+      if (size.width > width) width = size.width;
+      if (size.height > height) height = size.height;
+    }
+    if (width === 0 && height === 0) return "unmeasured";
+    return `${Math.round(width / 8)}x${Math.round(height / 8)}`;
+  }, [nodeSizes]);
+  const layoutKey = `${structureKey}::${sizeKey}`;
+  const layout = useProcessLayout({
+    nodes: layoutNodes,
+    edges: firstPass?.edges ?? EMPTY_EDGES,
+    structureKey: layoutKey,
+    direction
+  });
+  const model = useMemo4(
+    () => resolved ? buildProcessMapModel({
+      graph: resolved,
+      metric,
+      rework: activeRework,
+      selection: activeSelection,
+      selectionStates,
+      backEdgeIds: layout.backEdgeIds
+    }) : null,
+    [resolved, metric, activeRework, activeSelection, selectionStates, layout.backEdgeIds]
+  );
+  const positionedNodes = useMemo4(
+    () => model ? applyPositions(model, layout, direction) : EMPTY_NODES,
+    [model, layout, direction]
+  );
+  const [hover, setHover] = useState2(EMPTY_PROCESS_MAP_HOVER);
+  const edgesRef = useRef2([]);
+  edgesRef.current = model?.edges ?? [];
+  const handleNodeEnter = useCallback2((_event, node) => {
+    const incident = /* @__PURE__ */ new Set();
+    for (const edge of edgesRef.current) {
+      if (edge.source === node.id || edge.target === node.id) incident.add(edge.id);
+    }
+    setHover({ activityId: node.id, incidentEdgeIds: incident });
+  }, []);
+  const handleNodeLeave = useCallback2(() => setHover(EMPTY_PROCESS_MAP_HOVER), []);
+  const [menuTarget, setMenuTarget] = useState2(null);
+  const menuOpen = menuTarget !== null;
+  const returnFocusRef = useRef2(null);
+  const openMenuFor = useCallback2(
+    (target, restoreFocus = null) => {
+      if (!target) return;
+      returnFocusRef.current = restoreFocus;
+      setMenuTarget(target);
+    },
+    []
+  );
+  const menuActivities = useMemo4(() => {
+    if (!menuTarget) return [];
+    if (menuTarget.kind === "activity") return [menuTarget.id];
+    const edge = (model?.edges ?? []).find((e) => e.id === menuTarget.id);
+    if (!edge) return [];
+    return edge.source === edge.target ? [edge.source] : [edge.source, edge.target];
+  }, [menuTarget, model]);
+  const targetOfEvent = useCallback2(
+    (element) => {
+      const focusedId = element?.closest("[data-id]")?.dataset.id;
+      if (!focusedId) return activeSelection;
+      return model?.edges.some((edge) => edge.id === focusedId) ? { kind: "transition", id: focusedId } : { kind: "activity", id: focusedId };
+    },
+    [activeSelection, model]
+  );
+  const handleElementKey = useCallback2(
+    (event, target) => {
+      if (!target) return false;
+      if (event.metaKey || event.ctrlKey || event.altKey) return false;
+      if (event.key === "Enter" || event.key === " ") {
+        applySelection(
+          activeSelection?.kind === target.kind && activeSelection.id === target.id ? null : target
+        );
+        return true;
+      }
+      if (event.key !== "f" && event.key !== "F") return false;
+      event.preventDefault();
+      const active = event.target?.ownerDocument.activeElement;
+      openMenuFor(target, active instanceof HTMLElement ? focusRestorer(active) : null);
+      return true;
+    },
+    [activeSelection, applySelection, openMenuFor]
+  );
+  const handleKeyDown = useCallback2(
+    (event) => {
+      const element = event.target;
+      if (element?.closest("input, textarea, [contenteditable='true']")) return;
+      const onFlowElement = Boolean(element?.closest("[data-id]"));
+      if ((event.key === "Enter" || event.key === " ") && !onFlowElement) return;
+      handleElementKey(event, targetOfEvent(element));
+    },
+    [handleElementKey, targetOfEvent]
+  );
+  const handleEdgeKey = useCallback2(
+    (edgeId, event) => {
+      if (handleElementKey(event, { kind: "transition", id: edgeId })) event.stopPropagation();
+    },
+    [handleElementKey]
+  );
+  const emitIntent = useCallback2(
+    (kind, activity) => {
+      onFilterIntent?.({ kind, activity });
+      setMenuTarget(null);
+    },
+    [onFilterIntent]
+  );
+  useEffect2(() => {
+    if (!menuTarget || !model) return;
+    const stillThere = menuTarget.kind === "activity" ? model.nodes.some((n) => n.id === menuTarget.id) : model.edges.some((e) => e.id === menuTarget.id);
+    if (!stillThere) setMenuTarget(null);
+  }, [menuTarget, model]);
+  if (loading) {
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        "data-slot": "process-map",
+        "data-state": "loading",
+        className: cn2("relative size-full min-h-64", className),
+        ...props,
+        children: /* @__PURE__ */ jsx3(StatePanel, { kind: "loading", title: t("process.map.loading") })
+      }
+    );
+  }
+  if (!model || model.nodes.length === 0) {
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        "data-slot": "process-map",
+        "data-state": "empty",
+        className: cn2("relative size-full min-h-64", className),
+        ...props,
+        children: /* @__PURE__ */ jsx3(
+          StatePanel,
+          {
+            kind: "empty",
+            title: t("process.map.empty"),
+            description: t("process.map.emptyBody")
+          }
+        )
+      }
+    );
+  }
+  const filterMenu = /* @__PURE__ */ jsxs2(
+    DropdownMenu,
+    {
+      modal: false,
+      open: menuOpen,
+      onOpenChange: (open) => {
+        if (!open) setMenuTarget(null);
+      },
+      children: [
+        /* @__PURE__ */ jsx3(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs2(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            "data-slot": "process-map-filter-trigger",
+            "aria-keyshortcuts": "f",
+            onClick: () => {
+              if (menuOpen) return;
+              openMenuFor(activeSelection ?? { kind: "activity", id: model.nodes[0].id });
+            },
+            children: [
+              /* @__PURE__ */ jsx3(Filter, { "aria-hidden": "true", className: "size-4" }),
+              t("process.map.filter")
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsx3(
+          DropdownMenuContent,
+          {
+            align: "end",
+            "data-slot": "process-map-filter-menu",
+            onCloseAutoFocus: (event) => {
+              const restore = returnFocusRef.current;
+              returnFocusRef.current = null;
+              if (!restore) return;
+              event.preventDefault();
+              restore();
+            },
+            children: menuActivities.map((activity, index2) => /* @__PURE__ */ jsxs2("div", { children: [
+              index2 > 0 ? /* @__PURE__ */ jsx3(DropdownMenuSeparator, {}) : null,
+              /* @__PURE__ */ jsx3(DropdownMenuLabel, { children: activity }),
+              PROCESS_FILTER_INTENT_KINDS.map((kind) => /* @__PURE__ */ jsx3(
+                DropdownMenuItem,
+                {
+                  "aria-label": t(PROCESS_FILTER_INTENT_MESSAGE_KEYS[kind], { activity }),
+                  onSelect: () => emitIntent(kind, activity),
+                  children: PROCESS_FILTER_INTENT_LABELS[kind]
+                },
+                kind
+              ))
+            ] }, activity))
+          }
+        )
+      ]
+    }
+  );
+  const excludedActivityNames = model.activityRows.filter((row) => row.selectionState === "excluded").map((row) => row.title).sort((a, b) => a.localeCompare(b));
+  const excludedTransitionNames = model.transitionRows.filter((row) => row.selectionState === "excluded").map((row) => `${row.source} \u2192 ${row.target}`).sort((a, b) => a.localeCompare(b));
+  const selectionSummary = [
+    t("process.map.excludedActivities", {
+      count: model.excludedCounts.activities,
+      total: model.excludedCounts.totalActivities
+    }),
+    excludedActivityNames.length > 0 ? t("process.map.excludedActivityNames", { names: excludedActivityNames.join(", ") }) : null,
+    t("process.map.excludedTransitions", {
+      count: model.excludedCounts.transitions,
+      total: model.excludedCounts.totalTransitions
+    }),
+    excludedTransitionNames.length > 0 ? t("process.map.excludedTransitionNames", { names: excludedTransitionNames.join(", ") }) : null
+  ].filter((part) => Boolean(part)).join(" \xB7 ");
+  if (tableView) {
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        "data-slot": "process-map",
+        "data-view": "table",
+        className: cn2("flex size-full flex-col gap-4", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx3(
+            "p",
+            {
+              "data-slot": "process-map-selection-summary",
+              role: "status",
+              "aria-live": "polite",
+              className: "sr-only",
+              children: selectionSummary
+            }
+          ),
+          /* @__PURE__ */ jsx3("div", { className: "flex items-center justify-end", children: filterMenu }),
+          /* @__PURE__ */ jsxs2(Table, { "data-slot": "process-map-activity-table", children: [
+            /* @__PURE__ */ jsx3(TableCaption, { children: t("process.map.activityCaption", { metric: model.nodeMetricLabel.toLowerCase() }) }),
+            /* @__PURE__ */ jsx3(TableHeader, { children: /* @__PURE__ */ jsxs2(TableRow, { children: [
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnActivity") }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnRole") }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: model.nodeMetricLabel }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnRework") }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnState") })
+            ] }) }),
+            /* @__PURE__ */ jsx3(TableBody, { children: model.activityRows.map((row) => /* @__PURE__ */ jsxs2(
+              TableRow,
+              {
+                "data-selection": row.selectionState,
+                "data-state": row.selectionState === "selected" ? "selected" : void 0,
+                children: [
+                  /* @__PURE__ */ jsx3(TableCell, { children: row.title }),
+                  /* @__PURE__ */ jsx3(TableCell, { children: row.role }),
+                  /* @__PURE__ */ jsx3(TableCell, { className: "tabular-nums", children: row.secondaryLabel ? `${row.primaryLabel} \xB7 ${row.secondaryLabel}` : row.primaryLabel }),
+                  /* @__PURE__ */ jsx3(TableCell, { className: "tabular-nums", children: row.reworkCount ?? 0 }),
+                  /* @__PURE__ */ jsx3(TableCell, { children: selectionStateText(row.selectionState) })
+                ]
+              },
+              row.id
+            )) })
+          ] }),
+          /* @__PURE__ */ jsxs2(Table, { "data-slot": "process-map-transition-table", children: [
+            /* @__PURE__ */ jsx3(TableCaption, { children: t("process.map.transitionCaption", {
+              metric: model.edgeMetricLabel.toLowerCase()
+            }) }),
+            /* @__PURE__ */ jsx3(TableHeader, { children: /* @__PURE__ */ jsxs2(TableRow, { children: [
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnFrom") }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnTo") }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnShape") }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: model.edgeMetricLabel }),
+              /* @__PURE__ */ jsx3(TableHead, { scope: "col", children: t("process.map.columnState") })
+            ] }) }),
+            /* @__PURE__ */ jsx3(TableBody, { children: model.transitionRows.map((row) => /* @__PURE__ */ jsxs2(
+              TableRow,
+              {
+                "data-selection": row.selectionState,
+                "data-state": row.selectionState === "selected" ? "selected" : void 0,
+                children: [
+                  /* @__PURE__ */ jsx3(TableCell, { children: row.source }),
+                  /* @__PURE__ */ jsx3(TableCell, { children: row.target }),
+                  /* @__PURE__ */ jsx3(TableCell, { children: row.shape }),
+                  /* @__PURE__ */ jsx3(TableCell, { className: "tabular-nums", children: row.secondaryLabel ? `${row.primaryLabel} \xB7 ${row.secondaryLabel}` : row.primaryLabel }),
+                  /* @__PURE__ */ jsx3(TableCell, { children: selectionStateText(row.selectionState) })
+                ]
+              },
+              row.id
+            )) })
+          ] })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      "data-slot": "process-map",
+      "data-view": "canvas",
+      "data-direction": direction,
+      className: cn2("relative size-full min-h-64", className),
+      onKeyDown: handleKeyDown,
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx3(
+          "p",
+          {
+            "data-slot": "process-map-selection-summary",
+            role: "status",
+            "aria-live": "polite",
+            className: "sr-only",
+            children: selectionSummary
+          }
+        ),
+        /* @__PURE__ */ jsx3(ProcessMapHoverContext, { value: hover, children: /* @__PURE__ */ jsx3(ProcessMapEdgeKeyContext, { value: handleEdgeKey, children: /* @__PURE__ */ jsxs2(
+          CanvasShell,
+          {
+            nodes: positionedNodes,
+            edges: model.edges,
+            nodeTypes: NODE_TYPES,
+            edgeTypes: EDGE_TYPES,
+            fitViewKey: `${layoutKey}::${direction}::${layout.layoutRuns}`,
+            fitViewKeyOptions: FIT_VIEW_OPTIONS,
+            minZoom: MIN_ZOOM,
+            nodesDraggable: false,
+            nodesConnectable: false,
+            edgesFocusable: false,
+            className: PROCESS_MAP_NODE_MOTION_CLASS,
+            "aria-label": mapLabel,
+            onNodeClick: (_event, node) => applySelection(
+              activeSelection?.kind === "activity" && activeSelection.id === node.id ? null : { kind: "activity", id: node.id }
+            ),
+            onEdgeClick: (_event, edge) => applySelection(
+              activeSelection?.kind === "transition" && activeSelection.id === edge.id ? null : { kind: "transition", id: edge.id }
+            ),
+            onNodeMouseEnter: handleNodeEnter,
+            onNodeMouseLeave: handleNodeLeave,
+            onNodeContextMenu: (event, node) => {
+              event.preventDefault();
+              openMenuFor({ kind: "activity", id: node.id });
+            },
+            onEdgeContextMenu: (event, edge) => {
+              event.preventDefault();
+              openMenuFor({ kind: "transition", id: edge.id });
+            },
+            onPaneClick: () => applySelection(null),
+            onNodesChange: handleNodesChange,
+            children: [
+              /* @__PURE__ */ jsx3(ZoomControls, { position: "bottom-left" }),
+              showMiniMap ? /* @__PURE__ */ jsx3(FlowMiniMap, { pannable: true, zoomable: true }) : null
+            ]
+          }
+        ) }) }),
+        /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            "data-slot": "process-map-top-rail",
+            className: "pointer-events-none absolute inset-x-3 top-3 flex items-start justify-between gap-3",
+            children: [
+              showLegend ? /* @__PURE__ */ jsx3(
+                Legend,
+                {
+                  variant: "scale",
+                  kind: "width",
+                  domain: model.edgeDomain,
+                  format: model.formatEdgeValue,
+                  title: model.edgeMetricLabel,
+                  className: "pointer-events-auto"
+                }
+              ) : /* @__PURE__ */ jsx3("span", {}),
+              /* @__PURE__ */ jsx3("div", { className: "pointer-events-auto", children: filterMenu })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function focusRestorer(element) {
+  const flowId = element.closest("[data-id]")?.dataset.id;
+  const slot = element.dataset.slot;
+  const layer = element.closest(".react-flow__edgelabel-renderer");
+  const peers = slot && layer ? [...layer.querySelectorAll(`[data-slot="${slot}"]`)] : [];
+  const index2 = peers.indexOf(element);
+  const root = element.closest('[data-slot="process-map"]');
+  return () => {
+    if (element.isConnected) {
+      element.focus();
+      return;
+    }
+    if (flowId && root) {
+      root.querySelector(`[data-id="${CSS.escape(flowId)}"]`)?.focus();
+      return;
+    }
+    if (slot && index2 >= 0 && layer?.isConnected) {
+      layer.querySelectorAll(`[data-slot="${slot}"]`)[index2]?.focus();
+    }
+  };
+}
+var EMPTY_NODES = [];
+var EMPTY_EDGES = [];
+function applyPositions(model, layout, direction) {
+  const byId = new Map(layout.nodes.map((node) => [node.id, node]));
+  const positioned = model.nodes.map((node) => {
+    const laidOut = byId.get(node.id);
+    if (!laidOut) return node;
+    return {
+      ...node,
+      position: laidOut.position,
+      sourcePosition: laidOut.sourcePosition,
+      targetPosition: laidOut.targetPosition
+    };
+  });
+  const alongFlow = direction === "LR" || direction === "RL" ? "x" : "y";
+  const acrossFlow = alongFlow === "x" ? "y" : "x";
+  const sign = direction === "BT" || direction === "RL" ? -1 : 1;
+  return positioned.sort((a, b) => {
+    const along = sign * (a.position[alongFlow] - b.position[alongFlow]);
+    if (along !== 0) return along;
+    const across = a.position[acrossFlow] - b.position[acrossFlow];
+    if (across !== 0) return across;
+    return a.id.localeCompare(b.id);
+  });
+}
+
+// src/abstraction-controls/abstraction-controls.tsx
+import { forwardRef, useCallback as useCallback3, useId } from "react";
+import { Sparkles } from "lucide-react";
+import { Button as Button2, Label, Slider, Switch, useLocale as useLocale2 } from "@elabs-ai/components-ui";
+import { cn as cn3 } from "@elabs-ai/components-ui/lib/cn";
+
+// src/abstraction-controls/auto-abstraction.ts
+var DEFAULT_MAX_ACTIVITIES = 25;
+var DEFAULT_MAX_STEPS = 8;
+var DEFAULT_MIN_FRACTION = 0.05;
+function keptActivityCount(total, fraction) {
+  return Math.max(1, Math.round(total * fraction));
+}
+function computeAutoAbstraction(totalActivities, opts = {}) {
+  const maxActivities = opts.maxActivities ?? DEFAULT_MAX_ACTIVITIES;
+  const maxSteps = opts.maxSteps ?? DEFAULT_MAX_STEPS;
+  const minFraction = opts.minFraction ?? DEFAULT_MIN_FRACTION;
+  const total = totalActivities;
+  if (total === 0 || keptActivityCount(total, 1) <= maxActivities) {
+    return { activities: 1, steps: 0 };
+  }
+  if (keptActivityCount(total, minFraction) > maxActivities) {
+    return { activities: minFraction, steps: 1 };
+  }
+  let lo = minFraction;
+  let hi = 1;
+  let best = minFraction;
+  for (let step = 1; step <= maxSteps; step += 1) {
+    const mid = (lo + hi) / 2;
+    if (keptActivityCount(total, mid) <= maxActivities) {
+      best = mid;
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+    if (step === maxSteps) {
+      return { activities: best, steps: step };
+    }
+  }
+  return { activities: best, steps: maxSteps };
+}
+
+// src/abstraction-controls/abstraction-controls.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var TICKS = [25, 50, 75, 100];
+var SLIDER_MIN = 0;
+var SLIDER_MAX = 100;
+function tickOffsetPercent(percent) {
+  return (percent - SLIDER_MIN) / (SLIDER_MAX - SLIDER_MIN) * 100;
+}
+var AUTO_PATHS_OFFSET = 0.2;
+function toPercent(fraction) {
+  return Math.round(fraction * 100);
+}
+function fromPercent(percent) {
+  return percent / 100;
+}
+function Tick({
+  percent,
+  active,
+  onSelect
+}) {
+  const offsetPercent = tickOffsetPercent(percent);
+  return /* @__PURE__ */ jsxs3(
+    "button",
+    {
+      type: "button",
+      "data-slot": "abstraction-controls-tick",
+      "aria-pressed": active,
+      onClick: () => onSelect(percent),
+      style: { left: `${offsetPercent}%` },
+      className: cn3(
+        "focus-ring absolute top-0 rounded-sm text-meta text-muted-foreground transition-colors duration-fast ease-standard hover:text-foreground",
+        offsetPercent <= 0 ? "translate-x-0" : offsetPercent >= 100 ? "-translate-x-full" : "-translate-x-1/2",
+        active && "font-semibold text-foreground"
+      ),
+      children: [
+        percent,
+        "%"
+      ]
+    }
+  );
+}
+var AbstractionControls = forwardRef(
+  function AbstractionControls2({
+    abstraction,
+    onAbstractionChange,
+    graph,
+    hiddenCounts,
+    autoMaxActivities = 25,
+    label,
+    className,
+    ...props
+  }, ref) {
+    const { t } = useLocale2();
+    const activitiesId = useId();
+    const pathsId = useId();
+    const activitiesPercent = toPercent(abstraction.activities);
+    const pathsPercent = toPercent(abstraction.paths);
+    const setActivitiesPercent = useCallback3(
+      (percent) => onAbstractionChange({ activities: fromPercent(percent) }),
+      [onAbstractionChange]
+    );
+    const setPathsPercent = useCallback3(
+      (percent) => onAbstractionChange({ paths: fromPercent(percent) }),
+      [onAbstractionChange]
+    );
+    const handleAuto = useCallback3(() => {
+      const totalActivities = graph.activities.length + hiddenCounts.activities;
+      const result = computeAutoAbstraction(totalActivities, {
+        maxActivities: autoMaxActivities
+      });
+      onAbstractionChange({
+        activities: result.activities,
+        paths: Math.min(1, result.activities + AUTO_PATHS_OFFSET)
+      });
+    }, [graph.activities.length, hiddenCounts.activities, autoMaxActivities, onAbstractionChange]);
+    const hiddenSummary = `${t("process.abstractionControls.hiddenActivities", {
+      count: hiddenCounts.activities
+    })} \xB7 ${t("process.abstractionControls.hiddenPaths", { count: hiddenCounts.paths })}`;
+    return /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        ref,
+        "data-slot": "abstraction-controls",
+        role: "group",
+        "aria-label": label ?? t("process.abstractionControls.label"),
+        className: cn3("flex flex-col gap-4", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxs3(
+            "div",
+            {
+              "data-slot": "abstraction-controls-activities",
+              role: "group",
+              "aria-labelledby": `${activitiesId}-label`,
+              className: "flex flex-col gap-1.5",
+              children: [
+                /* @__PURE__ */ jsxs3("div", { className: "flex items-center justify-between gap-2", children: [
+                  /* @__PURE__ */ jsx4(Label, { id: `${activitiesId}-label`, htmlFor: activitiesId, className: "text-body", children: t("process.abstractionControls.activities") }),
+                  /* @__PURE__ */ jsxs3("span", { className: "text-meta text-muted-foreground tabular-nums", children: [
+                    activitiesPercent,
+                    "%"
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx4(
+                  Slider,
+                  {
+                    id: activitiesId,
+                    min: SLIDER_MIN,
+                    max: SLIDER_MAX,
+                    step: 1,
+                    value: [activitiesPercent],
+                    onValueChange: ([next]) => setActivitiesPercent(next ?? activitiesPercent),
+                    "aria-label": t("process.abstractionControls.activities")
+                  }
+                ),
+                /* @__PURE__ */ jsx4("div", { className: "relative h-4", children: TICKS.map((percent) => /* @__PURE__ */ jsx4(
+                  Tick,
+                  {
+                    percent,
+                    active: activitiesPercent === percent,
+                    onSelect: setActivitiesPercent
+                  },
+                  percent
+                )) })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs3(
+            "div",
+            {
+              "data-slot": "abstraction-controls-paths",
+              role: "group",
+              "aria-labelledby": `${pathsId}-label`,
+              className: "flex flex-col gap-1.5",
+              children: [
+                /* @__PURE__ */ jsxs3("div", { className: "flex items-center justify-between gap-2", children: [
+                  /* @__PURE__ */ jsx4(Label, { id: `${pathsId}-label`, htmlFor: pathsId, className: "text-body", children: t("process.abstractionControls.paths") }),
+                  /* @__PURE__ */ jsxs3("span", { className: "text-meta text-muted-foreground tabular-nums", children: [
+                    pathsPercent,
+                    "%"
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx4(
+                  Slider,
+                  {
+                    id: pathsId,
+                    min: SLIDER_MIN,
+                    max: SLIDER_MAX,
+                    step: 1,
+                    value: [pathsPercent],
+                    onValueChange: ([next]) => setPathsPercent(next ?? pathsPercent),
+                    "aria-label": t("process.abstractionControls.paths")
+                  }
+                ),
+                /* @__PURE__ */ jsx4("div", { className: "relative h-4", children: TICKS.map((percent) => /* @__PURE__ */ jsx4(
+                  Tick,
+                  {
+                    percent,
+                    active: pathsPercent === percent,
+                    onSelect: setPathsPercent
+                  },
+                  percent
+                )) })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs3(
+            "div",
+            {
+              "data-slot": "abstraction-controls-footer",
+              className: "flex items-center justify-between gap-3",
+              children: [
+                /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx4(
+                    Switch,
+                    {
+                      id: `${activitiesId}-invert`,
+                      checked: abstraction.invert ?? false,
+                      onCheckedChange: (checked) => onAbstractionChange({ invert: checked })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx4(Label, { htmlFor: `${activitiesId}-invert`, className: "text-body", children: t("process.abstractionControls.invert") })
+                ] }),
+                /* @__PURE__ */ jsxs3(
+                  Button2,
+                  {
+                    type: "button",
+                    variant: "outline",
+                    size: "sm",
+                    onClick: handleAuto,
+                    "data-slot": "abstraction-controls-auto",
+                    children: [
+                      /* @__PURE__ */ jsx4(Sparkles, { "aria-hidden": "true" }),
+                      t("process.abstractionControls.auto")
+                    ]
+                  }
+                )
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            "p",
+            {
+              "data-slot": "abstraction-controls-hidden-summary",
+              role: "status",
+              "aria-live": "polite",
+              className: "text-meta text-muted-foreground",
+              children: hiddenSummary
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+
+// src/metric-layer-switch/metric-layer-switch.tsx
+import { forwardRef as forwardRef2, useCallback as useCallback4, useId as useId2, useState as useState3 } from "react";
+import { Lock, LockOpen } from "lucide-react";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Toggle,
+  ToggleGroup,
+  ToggleGroupItem,
+  useLocale as useLocale3
+} from "@elabs-ai/components-ui";
+import { cn as cn4 } from "@elabs-ai/components-ui/lib/cn";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var FREQUENCY_NODE_OPTIONS = [
+  "absolute",
+  "absolute_case",
+  "relative",
+  "relative_case"
+];
+var FREQUENCY_EDGE_OPTIONS_LOCKED = FREQUENCY_NODE_OPTIONS;
+var FREQUENCY_EDGE_OPTIONS_UNLOCKED = [
+  "absolute",
+  "absolute_case",
+  "relative",
+  "relative_case",
+  "relative_antecedent",
+  "relative_consequent"
+];
+var PERFORMANCE_OPTIONS = [
+  "median",
+  "mean",
+  "min",
+  "max",
+  "sum",
+  "p90",
+  "trimmed_mean"
+];
+var MetricLayerSwitch = forwardRef2(
+  function MetricLayerSwitch2({
+    layer,
+    onLayerChange,
+    metric,
+    onMetricChange,
+    locked: lockedProp,
+    defaultLocked = true,
+    onLockedChange,
+    label,
+    className,
+    ...props
+  }, ref) {
+    const { t } = useLocale3();
+    const nodeId = useId2();
+    const edgeId = useId2();
+    const [uncontrolledLocked, setUncontrolledLocked] = useState3(defaultLocked);
+    const locked = lockedProp ?? uncontrolledLocked;
+    const setLocked = useCallback4(
+      (next) => {
+        if (lockedProp === void 0) setUncontrolledLocked(next);
+        onLockedChange?.(next);
+      },
+      [lockedProp, onLockedChange]
+    );
+    const isRework = layer === "rework";
+    const isPerformance = layer === "performance";
+    const nodeOptions = isPerformance ? PERFORMANCE_OPTIONS : FREQUENCY_NODE_OPTIONS;
+    const edgeOptions = isPerformance ? PERFORMANCE_OPTIONS : locked ? FREQUENCY_EDGE_OPTIONS_LOCKED : FREQUENCY_EDGE_OPTIONS_UNLOCKED;
+    const handleLayerChange = useCallback4(
+      (next) => {
+        if (!next) return;
+        const nextLayer = next;
+        onLayerChange(nextLayer);
+        if (nextLayer === "performance" && !isPerformanceMetric(metric.node)) {
+          onMetricChange({ node: "median", edge: "median" });
+        } else if (nextLayer === "frequency" && isPerformanceMetric(metric.node)) {
+          onMetricChange({ node: "absolute", edge: "absolute" });
+        }
+      },
+      [onLayerChange, onMetricChange, metric.node]
+    );
+    const handleNodeChange = useCallback4(
+      (value) => {
+        const next = value;
+        onMetricChange(locked ? { node: next, edge: next } : { node: next });
+      },
+      [onMetricChange, locked]
+    );
+    const handleEdgeChange = useCallback4(
+      (value) => {
+        const next = value;
+        onMetricChange(locked ? { node: next, edge: next } : { edge: next });
+      },
+      [onMetricChange, locked]
+    );
+    const handleLockToggle = useCallback4(
+      (pressed) => {
+        setLocked(pressed);
+        if (pressed && metric.edge !== metric.node) {
+          onMetricChange({ edge: metric.node });
+        }
+      },
+      [setLocked, metric.edge, metric.node, onMetricChange]
+    );
+    return /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        ref,
+        "data-slot": "metric-layer-switch",
+        role: "group",
+        "aria-label": label ?? t("process.metricLayerSwitch.label"),
+        className: cn4("flex flex-col gap-3", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxs4(
+            ToggleGroup,
+            {
+              type: "single",
+              variant: "segmented",
+              value: layer,
+              onValueChange: handleLayerChange,
+              "aria-label": t("process.metricLayerSwitch.layer"),
+              children: [
+                /* @__PURE__ */ jsx5(ToggleGroupItem, { value: "frequency", children: t("process.metricLayerSwitch.frequency") }),
+                /* @__PURE__ */ jsx5(ToggleGroupItem, { value: "performance", children: t("process.metricLayerSwitch.performance") }),
+                /* @__PURE__ */ jsx5(ToggleGroupItem, { value: "rework", children: t("process.metricLayerSwitch.rework") })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs4("div", { className: "flex items-end gap-2", children: [
+            /* @__PURE__ */ jsxs4(
+              "div",
+              {
+                "data-slot": "metric-layer-switch-node",
+                className: "flex min-w-0 flex-1 flex-col gap-1.5",
+                children: [
+                  /* @__PURE__ */ jsx5("label", { htmlFor: nodeId, className: "text-meta text-muted-foreground", children: t("process.metricLayerSwitch.node") }),
+                  /* @__PURE__ */ jsxs4(Select, { value: metric.node, onValueChange: handleNodeChange, disabled: isRework, children: [
+                    /* @__PURE__ */ jsx5(SelectTrigger, { id: nodeId, "aria-label": t("process.metricLayerSwitch.node"), children: /* @__PURE__ */ jsx5(SelectValue, {}) }),
+                    /* @__PURE__ */ jsx5(SelectContent, { children: nodeOptions.map((option) => /* @__PURE__ */ jsx5(SelectItem, { value: option, children: nodeMetricLabel(option) }, option)) })
+                  ] })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              Toggle,
+              {
+                pressed: locked,
+                onPressedChange: handleLockToggle,
+                disabled: isRework,
+                "aria-label": locked ? t("process.metricLayerSwitch.lockOn") : t("process.metricLayerSwitch.lockOff"),
+                "data-slot": "metric-layer-switch-lock",
+                children: locked ? /* @__PURE__ */ jsx5(Lock, { "aria-hidden": "true" }) : /* @__PURE__ */ jsx5(LockOpen, { "aria-hidden": "true" })
+              }
+            ),
+            /* @__PURE__ */ jsxs4(
+              "div",
+              {
+                "data-slot": "metric-layer-switch-edge",
+                className: "flex min-w-0 flex-1 flex-col gap-1.5",
+                children: [
+                  /* @__PURE__ */ jsx5("label", { htmlFor: edgeId, className: "text-meta text-muted-foreground", children: t("process.metricLayerSwitch.edge") }),
+                  /* @__PURE__ */ jsxs4(Select, { value: metric.edge, onValueChange: handleEdgeChange, disabled: isRework, children: [
+                    /* @__PURE__ */ jsx5(SelectTrigger, { id: edgeId, "aria-label": t("process.metricLayerSwitch.edge"), children: /* @__PURE__ */ jsx5(SelectValue, {}) }),
+                    /* @__PURE__ */ jsx5(SelectContent, { children: edgeOptions.map((option) => /* @__PURE__ */ jsx5(SelectItem, { value: option, children: edgeMetricLabel(option) }, option)) })
+                  ] })
+                ]
+              }
+            )
+          ] })
+        ]
+      }
+    );
+  }
+);
+
+// src/process-kpi-strip/process-kpi-strip.tsx
+import "react";
+import { CircleSlash2 } from "lucide-react";
+import { MetricCard } from "@elabs-ai/components-ui";
+import { useLocale as useLocale4 } from "@elabs-ai/components-ui";
+import { MetricGrid } from "@elabs-ai/components-charts";
+import { Sparkline } from "@elabs-ai/components-charts";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function trendDirectionKey(first, last) {
+  if (last > first) return "process.kpiStrip.trendRising";
+  if (last < first) return "process.kpiStrip.trendFalling";
+  return "process.kpiStrip.trendSteady";
+}
+function formatTrendValue(formatNumber, value, format) {
+  switch (format) {
+    case "duration":
+      return formatDurationMs(value);
+    case "percent":
+      return formatNumber(value, { style: "percent", maximumFractionDigits: 1 });
+    case "count":
+    default:
+      return formatNumber(value);
+  }
+}
+function trendVisual(values, subject, format, t, formatNumber) {
+  if (!values || values.length === 0) return void 0;
+  const first = values[0];
+  const last = values[values.length - 1];
+  const label = t("process.kpiStrip.trendAlt", {
+    subject,
+    periods: values.length,
+    direction: t(trendDirectionKey(first, last)),
+    first: formatTrendValue(formatNumber, first, format),
+    last: formatTrendValue(formatNumber, last, format)
+  });
+  return /* @__PURE__ */ jsx6(Sparkline, { values, label });
+}
+function ProcessKpiStrip({
+  kpis,
+  conformance,
+  trends,
+  loading = false,
+  className,
+  ...props
+}) {
+  const { t, formatNumber } = useLocale4();
+  const hasConformance = conformance !== null && conformance !== void 0;
+  const conformanceHint = t("process.kpiStrip.conformanceUnavailableHint");
+  return /* @__PURE__ */ jsx6("div", { "data-slot": "process-kpi-strip", className, ...props, children: /* @__PURE__ */ jsxs5(MetricGrid, { columns: 3, loading, children: [
+    /* @__PURE__ */ jsx6(
+      MetricCard,
+      {
+        label: t("process.kpiStrip.cases"),
+        value: kpis.cases,
+        announceLoading: false,
+        visual: trendVisual(trends?.cases, t("process.kpiStrip.cases"), "count", t, formatNumber)
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      MetricCard,
+      {
+        label: t("process.kpiStrip.events"),
+        value: kpis.events,
+        announceLoading: false,
+        visual: trendVisual(
+          trends?.events,
+          t("process.kpiStrip.events"),
+          "count",
+          t,
+          formatNumber
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      MetricCard,
+      {
+        label: t("process.kpiStrip.variants"),
+        value: kpis.variants,
+        announceLoading: false,
+        visual: trendVisual(
+          trends?.variants,
+          t("process.kpiStrip.variants"),
+          "count",
+          t,
+          formatNumber
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      MetricCard,
+      {
+        label: t("process.kpiStrip.medianThroughput"),
+        value: formatDurationMs(kpis.medianThroughput),
+        announceLoading: false,
+        visual: trendVisual(
+          trends?.medianThroughput,
+          t("process.kpiStrip.medianThroughput"),
+          "duration",
+          t,
+          formatNumber
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      MetricCard,
+      {
+        label: t("process.kpiStrip.reworkRate"),
+        value: kpis.reworkRate,
+        valueFormat: "percent",
+        announceLoading: false,
+        visual: trendVisual(
+          trends?.reworkRate,
+          t("process.kpiStrip.reworkRate"),
+          "percent",
+          t,
+          formatNumber
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      MetricCard,
+      {
+        label: t("process.kpiStrip.conformance"),
+        value: hasConformance ? conformance : /* @__PURE__ */ jsxs5(
+          "span",
+          {
+            "data-slot": "process-kpi-strip-conformance-unavailable",
+            className: "text-title inline-flex items-center gap-1.5 text-muted-foreground",
+            children: [
+              /* @__PURE__ */ jsx6(CircleSlash2, { "aria-hidden": "true", className: "size-5" }),
+              t("process.kpiStrip.conformanceUnavailable")
+            ]
+          }
+        ),
+        valueFormat: hasConformance ? "percent" : void 0,
+        description: hasConformance ? (
+          // Same slot, same height, every state (F3) — invisible rather than absent, so
+          // the tile's box never reflows depending on whether conformance was measured.
+          /* @__PURE__ */ jsx6("span", { "aria-hidden": "true", className: "invisible", children: conformanceHint })
+        ) : conformanceHint,
+        announceLoading: false,
+        visual: hasConformance ? trendVisual(
+          trends?.conformance,
+          t("process.kpiStrip.conformance"),
+          "percent",
+          t,
+          formatNumber
+        ) : void 0
+      }
+    )
+  ] }) });
+}
+
+// src/use-process-explorer/use-process-explorer.ts
+import { useCallback as useCallback5, useEffect as useEffect3, useMemo as useMemo5, useRef as useRef3, useState as useState4 } from "react";
+
+// src/core/filter-log.ts
+function sequenceOf2(kase) {
+  const sequence = new Array(kase.events.length);
+  for (let i = 0; i < kase.events.length; i += 1) {
+    sequence[i] = kase.events[i].activity;
+  }
+  return sequence;
+}
+function valuesFor(kase, key) {
+  const attributes = kase.attributes;
+  if (attributes !== void 0 && Object.hasOwn(attributes, key)) return [attributes[key]];
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of kase.events) {
+    const value = key === "resource" ? event.resource : event.attributes?.[key];
+    if (value === void 0) continue;
+    if (seen.has(value)) continue;
+    seen.add(value);
+    values.push(value);
+  }
+  return values;
+}
+function ordered(left, right, wantGreater) {
+  if (typeof left === "number" && typeof right === "number") {
+    return wantGreater ? left > right : left < right;
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return wantGreater ? left > right : left < right;
+  }
+  return false;
+}
+function matchesAttribute(kase, spec) {
+  const values = valuesFor(kase, spec.key);
+  switch (spec.op) {
+    case "eq":
+      return values.some((value) => Object.is(value, spec.value));
+    // `ne` is the negation of `eq`, not "some value differs" — otherwise a case offering
+    // two resources would satisfy both `eq` and `ne` against the same value.
+    case "ne":
+      return !values.some((value) => Object.is(value, spec.value));
+    case "gt":
+      return values.some((value) => ordered(value, spec.value, true));
+    case "lt":
+      return values.some((value) => ordered(value, spec.value, false));
+    case "in": {
+      if (!Array.isArray(spec.value)) return false;
+      const allowed = spec.value;
+      return values.some((value) => allowed.some((candidate) => Object.is(value, candidate)));
+    }
+    default:
+      return false;
+  }
+}
+function matchesOne(kase, sequence, spec) {
+  switch (spec.kind) {
+    case "with":
+      return sequence.includes(spec.activity);
+    case "without":
+      return !sequence.includes(spec.activity);
+    case "startsWith":
+      return sequence[0] === spec.activity;
+    case "endsWith":
+      return sequence[sequence.length - 1] === spec.activity;
+    case "follower": {
+      if (spec.direct === true) {
+        for (let i = 0; i + 1 < sequence.length; i += 1) {
+          if (sequence[i] === spec.a && sequence[i + 1] === spec.b) return true;
+        }
+        return false;
+      }
+      const first = sequence.indexOf(spec.a);
+      if (first < 0) return false;
+      return sequence.indexOf(spec.b, first + 1) >= 0;
+    }
+    case "attribute":
+      return matchesAttribute(kase, spec);
+    case "duration": {
+      if (spec.min === void 0 && spec.max === void 0) return true;
+      if (!Number.isFinite(kase.duration)) return false;
+      if (spec.min !== void 0 && kase.duration < spec.min) return false;
+      if (spec.max !== void 0 && kase.duration > spec.max) return false;
+      return true;
+    }
+    case "variant":
+      return spec.ids.includes(variantId(sequence));
+    case "cases":
+      return spec.ids.includes(kase.caseId);
+    default:
+      return true;
+  }
+}
+function caseMatchesFilters(kase, specs) {
+  if (specs.length === 0) return true;
+  const sequence = sequenceOf2(kase);
+  for (const spec of specs) {
+    if (!matchesOne(kase, sequence, spec)) return false;
+  }
+  return true;
+}
+function filterNormalizedLog(log, specs) {
+  const normalized = asNormalizedLog(log);
+  if (specs.length === 0) return normalized;
+  const cases = [];
+  let events = 0;
+  for (const kase of normalized.cases) {
+    if (!caseMatchesFilters(kase, specs)) continue;
+    cases.push(kase);
+    events += kase.events.length;
+  }
+  return { cases, totals: { cases: cases.length, events } };
+}
+function filterLog(log, specs) {
+  if (specs.length === 0) return log;
+  const kept = /* @__PURE__ */ new Set();
+  for (const kase of filterNormalizedLog(log, specs).cases) kept.add(kase.caseId);
+  const filtered = { events: log.events.filter((row) => kept.has(row?.caseId)) };
+  if (log.caseAttributes !== void 0) {
+    const caseAttributes = {};
+    for (const caseId of Object.keys(log.caseAttributes)) {
+      if (kept.has(caseId)) {
+        caseAttributes[caseId] = log.caseAttributes[caseId];
+      }
+    }
+    filtered.caseAttributes = caseAttributes;
+  }
+  return filtered;
+}
+
+// src/core/reconcile-graph.ts
+function transitionKey(transition) {
+  return `${transition.source}${EDGE_KEY_SEPARATOR}${transition.target}`;
+}
+function reconcileGraph(presented, filtered) {
+  const filteredActivities = new Map(
+    filtered.activities.map((activity) => [activity.id, activity])
+  );
+  const filteredTransitions = new Map(
+    filtered.transitions.map((transition) => [transitionKey(transition), transition])
+  );
+  const excludedActivities = [];
+  const activities = presented.activities.map((activity) => {
+    const survivor = filteredActivities.get(activity.id);
+    if (survivor) return survivor;
+    excludedActivities.push(activity.id);
+    return {
+      ...activity,
+      instances: 0,
+      cases: 0,
+      isStart: false,
+      isEnd: false,
+      duration: emptyDurationStats()
+    };
+  });
+  const excludedTransitions = [];
+  const transitions = presented.transitions.map((transition) => {
+    const key = transitionKey(transition);
+    const survivor = filteredTransitions.get(key);
+    if (survivor) return survivor;
+    excludedTransitions.push(key);
+    return {
+      ...transition,
+      count: 0,
+      caseCount: 0,
+      duration: emptyDurationStats()
+    };
+  });
+  const graph = {
+    ...presented,
+    activities,
+    transitions,
+    startActivities: filtered.startActivities,
+    endActivities: filtered.endActivities,
+    totals: filtered.totals
+  };
+  return { graph, excludedActivities, excludedTransitions };
+}
+
+// src/core/worker/process-worker.ts
+function handleProcessRequest(request) {
+  try {
+    if (request.kind === "discover") {
+      return {
+        id: request.id,
+        ok: true,
+        kind: "discover",
+        graph: discoverGraph(request.log, request.options ?? {})
+      };
+    }
+    return { id: request.id, ok: true, kind: "variants", variants: extractVariants(request.log) };
+  } catch (error) {
+    return { id: request.id, ok: false, error: describe(error) };
+  }
+}
+function describe(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function inWorkerScope() {
+  const scope = globalThis;
+  const constructor = scope.WorkerGlobalScope;
+  if (typeof constructor !== "function") return false;
+  return scope.self instanceof constructor;
+}
+if (inWorkerScope()) {
+  const scope = self;
+  scope.addEventListener("message", (event) => {
+    scope.postMessage(handleProcessRequest(event.data));
+  });
+}
+
+// src/core/worker/create-process-worker.ts
+function workerConstructible() {
+  return typeof Worker !== "undefined" && typeof URL !== "undefined";
+}
+function createProcessWorker(options = {}) {
+  const construct = options.createWorker;
+  let inline = options.forceInline === true || construct === void 0 && !workerConstructible();
+  let terminated = false;
+  let worker;
+  let nextId = 0;
+  const pending = /* @__PURE__ */ new Map();
+  function degrade() {
+    inline = true;
+    const stale = [...pending.values()];
+    pending.clear();
+    if (worker !== void 0) {
+      const dying = worker;
+      worker = void 0;
+      try {
+        dying.terminate();
+      } catch {
+      }
+    }
+    for (const entry of stale) entry.settle(handleProcessRequest(entry.request));
+  }
+  function onMessage(event) {
+    const response = event.data;
+    if (response === void 0 || typeof response.id !== "number") return;
+    const entry = pending.get(response.id);
+    if (entry === void 0) return;
+    pending.delete(response.id);
+    entry.settle(response);
+  }
+  function ensureWorker() {
+    if (inline || terminated) return void 0;
+    if (worker !== void 0) return worker;
+    try {
+      worker = construct === void 0 ? new Worker(new URL("./core/process-worker.js", import.meta.url), {
+        type: "module"
+      }) : construct();
+    } catch {
+      degrade();
+      return void 0;
+    }
+    worker.addEventListener("message", onMessage);
+    worker.addEventListener("error", degrade);
+    worker.addEventListener("messageerror", degrade);
+    return worker;
+  }
+  function send(build) {
+    if (terminated) return Promise.reject(new Error("process worker terminated"));
+    nextId += 1;
+    const request = build(nextId);
+    const active = ensureWorker();
+    if (active === void 0) {
+      return Promise.resolve().then(() => handleProcessRequest(request));
+    }
+    return new Promise((resolve, reject) => {
+      pending.set(request.id, { request, settle: resolve });
+      try {
+        active.postMessage(request);
+      } catch {
+        pending.delete(request.id);
+        degrade();
+        try {
+          resolve(handleProcessRequest(request));
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    });
+  }
+  function unwrap(response, read) {
+    if (!response.ok) throw new Error(response.error);
+    return read(response);
+  }
+  return {
+    async discover(log, discoverOptions) {
+      const response = await send(
+        (id) => discoverOptions === void 0 ? { id, kind: "discover", log } : { id, kind: "discover", log, options: discoverOptions }
+      );
+      return unwrap(response, (ok) => ok.graph);
+    },
+    async variants(log) {
+      const response = await send((id) => ({ id, kind: "variants", log }));
+      return unwrap(response, (ok) => ok.variants);
+    },
+    terminate() {
+      terminated = true;
+      const stale = [...pending.values()];
+      pending.clear();
+      for (const entry of stale) {
+        entry.settle({ id: entry.request.id, ok: false, error: "process worker terminated" });
+      }
+      if (worker !== void 0) {
+        const dying = worker;
+        worker = void 0;
+        try {
+          dying.terminate();
+        } catch {
+        }
+      }
+    },
+    get inline() {
+      return inline;
+    }
+  };
+}
+
+// src/use-process-explorer/use-process-explorer.ts
+var DEFAULT_ABSTRACTION = {
+  activities: 1,
+  paths: 1,
+  invert: false,
+  keepConnected: true
+};
+var DEFAULT_METRIC = { node: "absolute", edge: "absolute" };
+var DEFAULT_WORKER_THRESHOLD = 5e4;
+var EMPTY_GRAPH = {
+  activities: [],
+  transitions: [],
+  startActivities: {},
+  endActivities: {},
+  totals: { cases: 0, events: 0, variants: 0 }
+};
+function discoverInline(log) {
+  return { graph: discoverGraph(log), variants: extractVariants(log) };
+}
+function countDistinctVariants(normalized) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const kase of normalized.cases) {
+    keys.add(variantKey(kase.events.map((event) => event.activity)));
+  }
+  return keys.size;
+}
+function useLogDiscovery(targetLog, workerThreshold, getHandle) {
+  const useWorkerPath = targetLog !== null && targetLog.events.length > workerThreshold;
+  const syncResult = useMemo5(
+    () => targetLog === null || useWorkerPath ? null : discoverInline(targetLog),
+    [targetLog, useWorkerPath]
+  );
+  const [asyncState, setAsyncState] = useState4(
+    null
+  );
+  const [loading, setLoading] = useState4(false);
+  const requestIdRef = useRef3(0);
+  useEffect3(() => {
+    const requestId = requestIdRef.current += 1;
+    if (targetLog === null || !useWorkerPath) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    const handle = getHandle();
+    Promise.all([handle.discover(targetLog), handle.variants(targetLog)]).then(([graph, variants]) => {
+      if (requestIdRef.current !== requestId) return;
+      setAsyncState({ log: targetLog, result: { graph, variants } });
+      setLoading(false);
+    }).catch(() => {
+      if (requestIdRef.current !== requestId) return;
+      setAsyncState({ log: targetLog, result: discoverInline(targetLog) });
+      setLoading(false);
+    });
+  }, [targetLog, useWorkerPath]);
+  const asyncResult = asyncState !== null && asyncState.log === targetLog ? asyncState.result : null;
+  const targetUnsettled = useWorkerPath && (asyncState === null || asyncState.log !== targetLog);
+  return {
+    result: syncResult ?? asyncResult ?? { graph: EMPTY_GRAPH, variants: [] },
+    loading: loading || targetUnsettled,
+    settled: syncResult !== null || asyncResult !== null
+  };
+}
+function useProcessExplorer(log, opts = {}) {
+  const workerThreshold = opts.workerThreshold ?? DEFAULT_WORKER_THRESHOLD;
+  const workerOptionsRef = useRef3(opts.worker);
+  workerOptionsRef.current = opts.worker;
+  const handleRef = useRef3(null);
+  function getHandle() {
+    if (handleRef.current === null) {
+      handleRef.current = createProcessWorker(workerOptionsRef.current);
+    }
+    return handleRef.current;
+  }
+  useEffect3(
+    () => () => {
+      handleRef.current?.terminate();
+    },
+    []
+  );
+  const [abstraction, setAbstractionState] = useState4(() => ({
+    ...DEFAULT_ABSTRACTION,
+    ...opts.abstraction
+  }));
+  const [metric, setMetricState] = useState4(() => ({
+    ...DEFAULT_METRIC,
+    ...opts.metric
+  }));
+  const [layer, setLayerState] = useState4(opts.layer ?? "frequency");
+  const [selection, setSelection] = useState4(null);
+  const [intents, setIntents] = useState4([]);
+  const setAbstraction = useCallback5((next) => {
+    setAbstractionState((prev) => ({ ...prev, ...next }));
+  }, []);
+  const setMetric = useCallback5((next) => {
+    setMetricState((prev) => ({ ...prev, ...next }));
+  }, []);
+  const setLayer = useCallback5((next) => setLayerState(next), []);
+  const onSelect = useCallback5((next) => setSelection(next), []);
+  const applyIntent = useCallback5((intent) => {
+    setIntents((prev) => [...prev, intent]);
+  }, []);
+  const clearIntent = useCallback5((index2) => {
+    setIntents((prev) => prev.filter((_, i) => i !== index2));
+  }, []);
+  const filteredLog = useMemo5(
+    () => intents.length === 0 ? log : filterLog(log, intents),
+    [log, intents]
+  );
+  const sameLog = filteredLog === log;
+  const fullDiscovery = useLogDiscovery(log, workerThreshold, getHandle);
+  const filteredOwnDiscovery = useLogDiscovery(
+    sameLog ? null : filteredLog,
+    workerThreshold,
+    getHandle
+  );
+  const filteredDiscovery = sameLog || !filteredOwnDiscovery.settled ? fullDiscovery : filteredOwnDiscovery;
+  const loading = fullDiscovery.loading || filteredOwnDiscovery.loading;
+  const presented = useMemo5(
+    () => abstractGraph(fullDiscovery.result.graph, abstraction),
+    [fullDiscovery.result.graph, abstraction]
+  );
+  const reconciled = useMemo5(
+    () => reconcileGraph(presented, filteredDiscovery.result.graph),
+    [presented, filteredDiscovery.result.graph]
+  );
+  const graph = reconciled.graph;
+  const selectionStates = useMemo5(
+    () => ({
+      activities: Object.fromEntries(
+        reconciled.excludedActivities.map((id) => [id, "excluded"])
+      ),
+      transitions: Object.fromEntries(
+        reconciled.excludedTransitions.map((key) => [key, "excluded"])
+      ),
+      // Decision §1.4 step 5 (RM-052 round 3, #227, G2): there is no click channel for a
+      // variant, so `"selected"` here is intent-derived — every id named by an active
+      // `{ kind: "variant" }` intent, read by `VariantExplorer` (RM-054), not by
+      // `ProcessMap`. This namespace was declared on `ProcessSelectionStates` from round 2
+      // onward and never populated until this fix.
+      variants: Object.fromEntries(
+        intents.flatMap((intent) => intent.kind === "variant" ? intent.ids : []).map((id) => [id, "selected"])
+      )
+    }),
+    [reconciled, intents]
+  );
+  const excludedCounts = useMemo5(
+    () => ({
+      activities: reconciled.excludedActivities.length,
+      paths: reconciled.excludedTransitions.length
+    }),
+    [reconciled]
+  );
+  const rework = useMemo5(() => detectRework(filteredLog), [filteredLog]);
+  const kpis = useMemo5(() => {
+    const normalized = asNormalizedLog(filteredLog);
+    const medianThroughput = durationStats(normalized.cases.map((kase) => kase.duration)).median;
+    return {
+      cases: normalized.totals.cases,
+      events: normalized.totals.events,
+      variants: countDistinctVariants(normalized),
+      medianThroughput,
+      reworkRate: rework.caseReworkRate
+    };
+  }, [filteredLog, rework]);
+  return {
+    graph,
+    variants: filteredDiscovery.result.variants,
+    abstraction,
+    setAbstraction,
+    metric,
+    setMetric,
+    layer,
+    setLayer,
+    selection,
+    onSelect,
+    applyIntent,
+    clearIntent,
+    intents,
+    filteredLog,
+    selectionStates,
+    hiddenCounts: graph.hidden,
+    excludedCounts,
+    kpis,
+    rework,
+    loading
+  };
+}
+export {
+  AbstractionControls,
+  DEFAULT_LAYOUT_DEBOUNCE_MS,
+  EMPTY_PROCESS_MAP_HOVER,
+  GHOST_OPACITY,
+  MetricLayerSwitch,
+  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,
+  ProcessKpiStrip,
+  ProcessMap,
+  ProcessMapEdgeKeyContext,
+  ProcessMapHoverContext,
+  ProcessTransitionEdge,
+  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
+};
+//# sourceMappingURL=index.js.map