@elabs-ai/components-process 4.2.0 → 5.0.0

package/dist/core/index.js

@@ -1506,47 +1506,1381 @@ function createProcessWorker(options = {}) {
     }
   };
 }
+
+// src/core/activity-color-scale.ts
+var ACTIVITY_COLOR_SLOTS = 11;
+var ACTIVITY_OTHER_TOKEN = "--chart-12";
+var OTHER = Object.freeze({ token: ACTIVITY_OTHER_TOKEN, pattern: "other" });
+function alphanumerics(label) {
+  return label.replace(/[^\p{L}\p{N}]/gu, "").toUpperCase();
+}
+function codeCandidates(label) {
+  const out = [];
+  const words = label.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  const first = words[0];
+  const second = words[1];
+  if (first && second) out.push(`${first[0]}${second[0]}`.toUpperCase());
+  const letters = alphanumerics(label);
+  const head = letters[0] ?? "?";
+  if (letters.length >= 2) out.push(letters.slice(0, 2));
+  for (let i = 2; i < letters.length; i += 1) out.push(`${head}${letters[i]}`);
+  for (let digit = 1; digit <= 9; digit += 1) out.push(`${head}${digit}`);
+  return out;
+}
+function uniqueCode(label, taken) {
+  for (const candidate of codeCandidates(label)) {
+    if (!taken.has(candidate)) return candidate;
+  }
+  for (let n = 0; n < 36 * 36; n += 1) {
+    const candidate = n.toString(36).toUpperCase().padStart(2, "0");
+    if (!taken.has(candidate)) return candidate;
+  }
+  return (alphanumerics(label).slice(0, 2) || "??").padEnd(2, "?");
+}
+function activityColorScale(graph) {
+  const ranked = [...graph.activities].sort(
+    (a, b) => b.cases - a.cases || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
+  const colors = /* @__PURE__ */ new Map();
+  const codes = /* @__PURE__ */ new Map();
+  const labels = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Set();
+  const legend = ranked.map((activity, index2) => {
+    const color = index2 < ACTIVITY_COLOR_SLOTS ? { token: `--chart-${index2 + 1}` } : OTHER;
+    const label = activity.label || activity.id;
+    const code = uniqueCode(label, taken);
+    taken.add(code);
+    colors.set(activity.id, color);
+    codes.set(activity.id, code);
+    labels.set(activity.id, label);
+    return { activityId: activity.id, label, code, ...color };
+  });
+  return {
+    colorFor: (activityId) => colors.get(activityId) ?? OTHER,
+    codeFor: (activityId) => codes.get(activityId) ?? (alphanumerics(activityId).slice(0, 2) || "??").padEnd(2, "?"),
+    labelFor: (activityId) => labels.get(activityId) ?? activityId,
+    legend
+  };
+}
+
+// src/core/cases-from-log.ts
+function toIso(ms) {
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : "";
+}
+function toCaseRow(kase, variantId2) {
+  const row = {
+    caseId: kase.caseId,
+    start: toIso(kase.start),
+    end: toIso(kase.end),
+    durationMs: Number.isFinite(kase.duration) ? kase.duration : 0,
+    eventCount: kase.events.length,
+    variantId: variantId2
+  };
+  if (kase.attributes !== void 0) {
+    row.attributes = kase.attributes;
+  }
+  return row;
+}
+function casesFromLog(log) {
+  const normalized = asNormalizedLog(log);
+  if (normalized.cases.length === 0) return [];
+  const variantIdByCase = /* @__PURE__ */ new Map();
+  for (const variant of extractVariants(normalized)) {
+    for (const caseId of variant.caseIds) variantIdByCase.set(caseId, variant.id);
+  }
+  return normalized.cases.map((kase) => toCaseRow(kase, variantIdByCase.get(kase.caseId) ?? ""));
+}
+
+// src/core/reference-model.ts
+function placeName(index2) {
+  return `p${index2}`;
+}
+function liftHappyPath(path) {
+  const steps = path.steps;
+  const places = [];
+  for (let i = 0; i <= steps.length; i += 1) places.push(placeName(i));
+  const transitions = [];
+  steps.forEach((step, i) => {
+    const before = placeName(i);
+    const after = placeName(i + 1);
+    transitions.push({
+      id: `t${i}`,
+      activity: step.activity,
+      kind: "step",
+      consumes: [before],
+      produces: [after]
+    });
+    if (step.optional) {
+      transitions.push({
+        id: `skip${i}`,
+        activity: step.activity,
+        kind: "skip",
+        consumes: [before],
+        produces: [after]
+      });
+    }
+    if (step.repeatable) {
+      transitions.push({
+        id: `repeat${i}`,
+        activity: step.activity,
+        kind: "repeat",
+        consumes: [after],
+        produces: [after]
+      });
+    }
+  });
+  return {
+    places,
+    initialMarking: [placeName(0)],
+    finalMarking: [placeName(steps.length)],
+    transitions
+  };
+}
+
+// src/core/token-replay.ts
+var DEVIATION_TYPES = [
+  "undesired",
+  "skipped",
+  "wrongOrder",
+  "wrongStart",
+  "incomplete"
+];
+var compiled = /* @__PURE__ */ new WeakMap();
+function pushTo(map, key, value) {
+  const list = map.get(key);
+  if (list === void 0) map.set(key, [value]);
+  else list.push(value);
+}
+function compile(model) {
+  const cached = compiled.get(model);
+  if (cached !== void 0) return cached;
+  const byActivity = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  const silentOutgoing = /* @__PURE__ */ new Map();
+  const steps = [];
+  const silent = model.transitions.filter((t) => t.kind === "skip");
+  const visible = model.transitions.filter((t) => t.kind !== "skip");
+  for (const t of [...visible].sort((a, b) => rank(a) - rank(b))) {
+    pushTo(byActivity, t.activity, t);
+  }
+  for (const t of visible) if (t.kind === "step") steps.push(t);
+  for (const t of [...silent, ...visible]) {
+    if (t.consumes.length !== 1 || t.kind === "repeat") continue;
+    const from = t.consumes[0];
+    pushTo(outgoing, from, t);
+    if (t.kind === "skip") pushTo(silentOutgoing, from, t);
+  }
+  const result = { model, byActivity, outgoing, silentOutgoing, steps };
+  compiled.set(model, result);
+  return result;
+}
+function rank(t) {
+  return t.kind === "step" ? 0 : 1;
+}
+function tokens(marking, place) {
+  return marking.get(place) ?? 0;
+}
+function isEnabled(marking, t) {
+  const need = /* @__PURE__ */ new Map();
+  for (const place of t.consumes) need.set(place, (need.get(place) ?? 0) + 1);
+  for (const [place, count] of need) if (tokens(marking, place) < count) return false;
+  return true;
+}
+function fire(marking, t) {
+  for (const place of t.consumes) marking.set(place, tokens(marking, place) - 1);
+  for (const place of t.produces) marking.set(place, tokens(marking, place) + 1);
+}
+function shortestChain(marking, target, edges) {
+  if (tokens(marking, target) > 0) return [];
+  const parent = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const [place, count] of marking) {
+    if (count > 0 && !parent.has(place)) {
+      parent.set(place, null);
+      queue.push(place);
+    }
+  }
+  for (let head = 0; head < queue.length; head += 1) {
+    const place = queue[head];
+    for (const t of edges.get(place) ?? []) {
+      for (const next of t.produces) {
+        if (parent.has(next)) continue;
+        parent.set(next, t);
+        if (next === target) return unwind(parent, target);
+        queue.push(next);
+      }
+    }
+  }
+  return void 0;
+}
+function unwind(parent, target) {
+  const chain = [];
+  let at = parent.get(target);
+  while (at !== null && at !== void 0) {
+    chain.unshift(at);
+    at = parent.get(at.consumes[0]);
+  }
+  return chain;
+}
+function enableSilently(cm, marking, places, counters) {
+  const trial = new Map(marking);
+  let produced = 0;
+  let consumed = 0;
+  for (const place of places) {
+    if (tokens(trial, place) > 0) continue;
+    const chain = shortestChain(trial, place, cm.silentOutgoing);
+    if (chain === void 0) return false;
+    for (const t of chain) {
+      if (!isEnabled(trial, t)) return false;
+      fire(trial, t);
+      consumed += t.consumes.length;
+      produced += t.produces.length;
+    }
+  }
+  for (const [place, count] of trial) marking.set(place, count);
+  counters.produced += produced;
+  counters.consumed += consumed;
+  return true;
+}
+function expectedNext(cm, marking) {
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const [place, count] of marking) {
+    if (count > 0) {
+      reachable.add(place);
+      queue.push(place);
+    }
+  }
+  for (let head = 0; head < queue.length; head += 1) {
+    for (const t of cm.silentOutgoing.get(queue[head]) ?? []) {
+      for (const next of t.produces) {
+        if (reachable.has(next)) continue;
+        reachable.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  for (const t of cm.steps) {
+    if (t.consumes.every((place) => reachable.has(place))) return t.activity;
+  }
+  return void 0;
+}
+function fitnessOf(c) {
+  const missingTerm = c.consumed > 0 ? 1 - c.missing / c.consumed : 1;
+  const remainingTerm = c.produced > 0 ? 1 - c.remaining / c.produced : 1;
+  return Math.min(1, Math.max(0, 0.5 * missingTerm + 0.5 * remainingTerm));
+}
+function replayActivities(caseId, trace, model) {
+  const cm = compile(model);
+  const marking = /* @__PURE__ */ new Map();
+  const counters = { produced: 0, consumed: 0, missing: 0 };
+  const deviations = [];
+  const observed = new Set(trace);
+  for (const place of model.initialMarking) {
+    marking.set(place, tokens(marking, place) + 1);
+    counters.produced += 1;
+  }
+  trace.forEach((activity, at) => {
+    const candidates = cm.byActivity.get(activity);
+    if (candidates === void 0 || candidates.length === 0) {
+      deviations.push({ type: "undesired", activity, expected: expectedNext(cm, marking), at });
+      counters.missing += 1;
+      counters.consumed += 1;
+      return;
+    }
+    const enabled = candidates.find((t) => isEnabled(marking, t)) ?? candidates.find((t) => enableSilently(cm, marking, t.consumes, counters));
+    if (enabled !== void 0) {
+      fire(marking, enabled);
+      counters.consumed += enabled.consumes.length;
+      counters.produced += enabled.produces.length;
+      return;
+    }
+    const expected2 = expectedNext(cm, marking);
+    let chosen = candidates[0];
+    let chain;
+    for (const t of candidates) {
+      const gap = t.consumes.find((place) => tokens(marking, place) === 0);
+      if (gap === void 0) continue;
+      const found = shortestChain(marking, gap, cm.outgoing);
+      if (found !== void 0 && (chain === void 0 || found.length < chain.length)) {
+        chain = found;
+        chosen = t;
+      }
+    }
+    if (at === 0) {
+      deviations.push({ type: "wrongStart", activity, expected: expected2, at });
+    } else {
+      const unobserved = (chain ?? []).filter(
+        (t) => t.kind === "step" && !observed.has(t.activity)
+      );
+      if (unobserved.length > 0) {
+        const seen = /* @__PURE__ */ new Set();
+        for (const t of unobserved) {
+          if (seen.has(t.activity)) continue;
+          seen.add(t.activity);
+          deviations.push({ type: "skipped", activity: t.activity, expected: t.activity, at });
+        }
+      } else {
+        deviations.push({ type: "wrongOrder", activity, expected: expected2, at });
+      }
+    }
+    for (const place of chosen.consumes) {
+      if (tokens(marking, place) === 0) {
+        marking.set(place, 1);
+        counters.missing += 1;
+      }
+    }
+    fire(marking, chosen);
+    counters.consumed += chosen.consumes.length;
+    counters.produced += chosen.produces.length;
+  });
+  enableSilently(cm, marking, model.finalMarking, counters);
+  const expected = expectedNext(cm, marking);
+  let reachedEnd = true;
+  for (const place of model.finalMarking) {
+    if (tokens(marking, place) > 0) marking.set(place, tokens(marking, place) - 1);
+    else {
+      counters.missing += 1;
+      reachedEnd = false;
+    }
+    counters.consumed += 1;
+  }
+  if (!reachedEnd) {
+    deviations.push({
+      type: "incomplete",
+      activity: trace.length > 0 ? trace[trace.length - 1] : void 0,
+      expected,
+      at: trace.length
+    });
+  }
+  let remaining = 0;
+  for (const count of marking.values()) remaining += count;
+  const result = { caseId, ...counters, remaining };
+  return { ...result, fitness: fitnessOf(result), deviations };
+}
+function activitiesOf(events) {
+  return events.map((event) => event.activity);
+}
+function replayTrace(events, model) {
+  const normalized = normalizeLog({ events });
+  const instances = normalized.cases.flatMap((kase) => kase.events);
+  if (normalized.cases.length > 1) instances.sort((a, b) => a.start - b.start);
+  const caseId = normalized.cases[0]?.caseId ?? events[0]?.caseId ?? "";
+  return replayActivities(caseId, activitiesOf(instances), model);
+}
+function emptyDeviationCounts() {
+  return { undesired: 0, skipped: 0, wrongOrder: 0, wrongStart: 0, incomplete: 0 };
+}
+function tokenReplay(log, model) {
+  const normalized = asNormalizedLog(log);
+  const traces = [];
+  const deviationCounts = emptyDeviationCounts();
+  const perActivity = /* @__PURE__ */ Object.create(null);
+  const perEdge = /* @__PURE__ */ Object.create(null);
+  let fitnessSum = 0;
+  for (const kase of normalized.cases) {
+    const trace = activitiesOf(kase.events);
+    const result = replayActivities(kase.caseId, trace, model);
+    traces.push(result);
+    fitnessSum += result.fitness;
+    for (const deviation of result.deviations) {
+      deviationCounts[deviation.type] += 1;
+      if (deviation.activity !== void 0) {
+        const entry = perActivity[deviation.activity] ??= { deviations: 0 };
+        entry.deviations += 1;
+      }
+      if (deviation.at > 0 && deviation.at < trace.length) {
+        const key = `${trace[deviation.at - 1]}${EDGE_KEY_SEPARATOR}${trace[deviation.at]}`;
+        const entry = perEdge[key] ??= { deviations: 0 };
+        entry.deviations += 1;
+      }
+    }
+  }
+  return {
+    overallFitness: traces.length > 0 ? fitnessSum / traces.length : 0,
+    traces,
+    deviationCounts,
+    perActivity,
+    perEdge
+  };
+}
+
+// src/core/conformance.ts
+var DAY_MS = 864e5;
+function bucketOf(ms, bucket) {
+  const date = new Date(ms);
+  if (bucket === "week") {
+    const offset = (date.getUTCDay() + 6) % 7;
+    const monday = new Date(
+      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) - offset * DAY_MS
+    );
+    return monday.toISOString().slice(0, 10);
+  }
+  const iso = date.toISOString();
+  return bucket === "month" ? iso.slice(0, 7) : iso.slice(0, 10);
+}
+function conformanceRateSeries(log, model, bucket) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const kase of asNormalizedLog(log).cases) {
+    if (!Number.isFinite(kase.start)) continue;
+    const key = bucketOf(kase.start, bucket);
+    const trace = kase.events.map((event) => event.activity);
+    const { fitness } = replayActivities(kase.caseId, trace, model);
+    const entry = totals.get(key);
+    if (entry === void 0) totals.set(key, { sum: fitness, count: 1 });
+    else {
+      entry.sum += fitness;
+      entry.count += 1;
+    }
+  }
+  return [...totals.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, { sum, count }]) => ({ bucket: key, fitness: sum / count, caseCount: count }));
+}
+
+// src/core/adapters/xes.ts
+var XmlSyntaxError = class extends Error {
+};
+var NAME_STOP = /[\s/>=]/;
+var ENTITY_NAMES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+function decodeXmlEntities(text) {
+  return text.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (match, body) => {
+    if (body[0] === "#") {
+      const isHex = body[1] === "x" || body[1] === "X";
+      const codePoint = Number.parseInt(body.slice(isHex ? 2 : 1), isHex ? 16 : 10);
+      return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : match;
+    }
+    return ENTITY_NAMES[body] ?? match;
+  });
+}
+function parseXmlDocument(text) {
+  let i = 0;
+  const n = text.length;
+  const skipWhitespace = () => {
+    while (i < n && /\s/.test(text[i])) i += 1;
+  };
+  const skipUntil = (marker, what) => {
+    const at = text.indexOf(marker, i);
+    if (at === -1) throw new XmlSyntaxError(`unterminated ${what}`);
+    i = at + marker.length;
+  };
+  const readName = () => {
+    const start = i;
+    while (i < n && !NAME_STOP.test(text[i])) i += 1;
+    if (i === start) throw new XmlSyntaxError(`expected a name at offset ${start}`);
+    return text.slice(start, i);
+  };
+  const readAttrs = () => {
+    const attrs = {};
+    for (; ; ) {
+      skipWhitespace();
+      const c = text[i];
+      if (c === void 0) throw new XmlSyntaxError("unexpected end of input in a start tag");
+      if (c === "/" || c === ">") return attrs;
+      const name = readName();
+      skipWhitespace();
+      if (text[i] !== "=") throw new XmlSyntaxError(`expected "=" after attribute "${name}"`);
+      i += 1;
+      skipWhitespace();
+      const quote = text[i];
+      if (quote !== '"' && quote !== "'") {
+        throw new XmlSyntaxError(`expected a quoted value for attribute "${name}"`);
+      }
+      i += 1;
+      const start = i;
+      while (i < n && text[i] !== quote) i += 1;
+      if (i >= n) throw new XmlSyntaxError(`unterminated value for attribute "${name}"`);
+      attrs[name] = decodeXmlEntities(text.slice(start, i));
+      i += 1;
+    }
+  };
+  const readElement = () => {
+    i += 1;
+    const tag = readName();
+    const attrs = readAttrs();
+    skipWhitespace();
+    if (text[i] === "/" && text[i + 1] === ">") {
+      i += 2;
+      return { tag, attrs, children: [] };
+    }
+    if (text[i] !== ">") throw new XmlSyntaxError(`expected ">" closing "<${tag}>"`);
+    i += 1;
+    const children = [];
+    for (; ; ) {
+      const lt = text.indexOf("<", i);
+      if (lt === -1) throw new XmlSyntaxError(`unterminated element "<${tag}>"`);
+      i = lt;
+      if (text.startsWith("<!--", i)) {
+        skipUntil("-->", "comment");
+        continue;
+      }
+      if (text.startsWith("<![CDATA[", i)) {
+        skipUntil("]]>", "CDATA section");
+        continue;
+      }
+      if (text.startsWith("</", i)) {
+        i += 2;
+        const closeName = readName();
+        skipWhitespace();
+        if (text[i] !== ">") throw new XmlSyntaxError(`expected ">" closing "</${closeName}>"`);
+        i += 1;
+        if (closeName !== tag) {
+          throw new XmlSyntaxError(
+            `mismatched closing tag: expected "</${tag}>", found "</${closeName}>"`
+          );
+        }
+        return { tag, attrs, children };
+      }
+      children.push(readElement());
+    }
+  };
+  for (; ; ) {
+    skipWhitespace();
+    if (i >= n) throw new XmlSyntaxError("empty document");
+    if (text.startsWith("<?", i)) {
+      skipUntil("?>", "processing instruction");
+      continue;
+    }
+    if (text.startsWith("<!--", i)) {
+      skipUntil("-->", "comment");
+      continue;
+    }
+    if (text.startsWith("<!", i)) {
+      skipUntil(">", "declaration");
+      continue;
+    }
+    break;
+  }
+  if (text[i] !== "<") throw new XmlSyntaxError("expected a root element");
+  return readElement();
+}
+var XES_VALUE_TAGS = /* @__PURE__ */ new Set(["string", "date", "int", "float", "boolean"]);
+function readXesValue(element) {
+  const raw = element.attrs.value;
+  if (raw === void 0) return null;
+  if (element.tag === "int") {
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) ? value : raw;
+  }
+  if (element.tag === "float") {
+    const value = Number.parseFloat(raw);
+    return Number.isFinite(value) ? value : raw;
+  }
+  if (element.tag === "boolean") return raw.trim().toLowerCase() === "true";
+  return raw;
+}
+function readAttributeChildren(children) {
+  const result = {};
+  for (const child of children) {
+    if (!XES_VALUE_TAGS.has(child.tag)) continue;
+    const key = child.attrs.key;
+    if (key === void 0) continue;
+    result[key] = readXesValue(child);
+  }
+  return result;
+}
+function withDefaults(own, defaults) {
+  return defaults === void 0 ? own : { ...defaults, ...own };
+}
+function collectGlobalDefaults(root, scope) {
+  let defaults;
+  for (const child of root.children) {
+    if (child.tag !== "global" || child.attrs.scope !== scope) continue;
+    defaults = withDefaults(readAttributeChildren(child.children), defaults);
+  }
+  return defaults;
+}
+function resolveClassifierKeys(root, options) {
+  if (options?.classifiers !== void 0 && options.classifiers.length > 0) {
+    return options.classifiers;
+  }
+  const classifier = root.children.find((child) => child.tag === "classifier");
+  const keys = classifier?.attrs.keys?.trim();
+  if (keys !== void 0 && keys !== "") return keys.split(/\s+/);
+  return ["concept:name"];
+}
+function mapLifecycle(raw, model) {
+  if (typeof raw !== "string" || model === "none") return void 0;
+  const value = raw.trim().toLowerCase();
+  if (value === "") return void 0;
+  return value === "start" ? "start" : "complete";
+}
+function fromXes(source, options) {
+  let root;
+  try {
+    root = parseXmlDocument(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, errors: [{ type: "malformed_xml", message }] };
+  }
+  const lifecycleModel = options?.lifecycleModel ?? "standard";
+  const classifierKeys = resolveClassifierKeys(root, options);
+  const consumedKeys = /* @__PURE__ */ new Set([
+    ...classifierKeys,
+    "time:timestamp",
+    "org:resource",
+    "lifecycle:transition"
+  ]);
+  const eventDefaults = collectGlobalDefaults(root, "event");
+  const traceDefaults = collectGlobalDefaults(root, "trace");
+  const errors = [];
+  const events = [];
+  let caseAttributes;
+  const traces = root.children.filter((child) => child.tag === "trace");
+  traces.forEach((trace, traceIndex) => {
+    const traceEvents = trace.children.filter((child) => child.tag === "event");
+    if (traceEvents.length === 0) {
+      errors.push({ type: "missing_trace", message: "trace has no events", traceIndex });
+      return;
+    }
+    const { "concept:name": rawCaseId, ...traceValues } = withDefaults(
+      readAttributeChildren(trace.children),
+      traceDefaults
+    );
+    const caseId = typeof rawCaseId === "string" && rawCaseId !== "" ? rawCaseId : `trace-${traceIndex}`;
+    if (Object.keys(traceValues).length > 0) {
+      caseAttributes ??= {};
+      caseAttributes[caseId] = traceValues;
+    }
+    traceEvents.forEach((eventElement, eventIndex) => {
+      const values = withDefaults(readAttributeChildren(eventElement.children), eventDefaults);
+      const activityParts = [];
+      let missingActivityKey = false;
+      for (const key of classifierKeys) {
+        const value = values[key];
+        if (value === void 0 || value === null) {
+          missingActivityKey = true;
+          break;
+        }
+        activityParts.push(String(value));
+      }
+      if (missingActivityKey) {
+        errors.push({
+          type: "missing_concept_name",
+          message: "event is missing its classifier key(s)",
+          traceIndex,
+          eventIndex
+        });
+        return;
+      }
+      const rawTimestamp = values["time:timestamp"];
+      if (rawTimestamp === void 0 || rawTimestamp === null) {
+        errors.push({
+          type: "missing_timestamp",
+          message: "event is missing time:timestamp",
+          traceIndex,
+          eventIndex
+        });
+        return;
+      }
+      const row = {
+        caseId,
+        activity: activityParts.join("+"),
+        timestamp: String(rawTimestamp)
+      };
+      const resource = values["org:resource"];
+      if (typeof resource === "string" && resource !== "") row.resource = resource;
+      const lifecycle = mapLifecycle(values["lifecycle:transition"], lifecycleModel);
+      if (lifecycle !== void 0) row.lifecycle = lifecycle;
+      const attributes = {};
+      let anyAttribute = false;
+      for (const [key, value] of Object.entries(values)) {
+        if (consumedKeys.has(key)) continue;
+        attributes[key] = value;
+        anyAttribute = true;
+      }
+      if (anyAttribute) row.attributes = attributes;
+      events.push(row);
+    });
+  });
+  if (errors.length > 0) return { ok: false, errors };
+  const log = { events };
+  if (caseAttributes !== void 0) log.caseAttributes = caseAttributes;
+  return { ok: true, log };
+}
+
+// src/core/segments.ts
+function segmentKey(from, to) {
+  return `${from}${EDGE_KEY_SEPARATOR}${to}`;
+}
+function segmentsFor(log, order) {
+  const wanted = /* @__PURE__ */ new Set();
+  for (const def of order) wanted.add(segmentKey(def.from, def.to));
+  const out = [];
+  if (wanted.size === 0) return out;
+  for (const kase of asNormalizedLog(log).cases) {
+    const trace = kase.events;
+    for (let i = 1; i < trace.length; i += 1) {
+      const previous = trace[i - 1];
+      const event = trace[i];
+      const key = segmentKey(previous.activity, event.activity);
+      if (!wanted.has(key)) continue;
+      const start = previous.end;
+      if (!Number.isFinite(start) || !Number.isFinite(event.start)) continue;
+      const end = Math.max(start, event.start);
+      out.push({ segment: key, caseId: kase.caseId, start, end, duration: end - start });
+    }
+  }
+  return out;
+}
+function segmentOrderByFrequency(graph, limit = Number.POSITIVE_INFINITY) {
+  const n = Math.max(0, Math.floor(limit));
+  return graph.transitions.slice(0, n).map((t) => ({ from: t.source, to: t.target }));
+}
+function segmentOrderForVariant(variant) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 1; i < variant.sequence.length; i += 1) {
+    const from = variant.sequence[i - 1];
+    const to = variant.sequence[i];
+    const key = segmentKey(from, to);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ from, to });
+  }
+  return out;
+}
+function durationQuartileThresholds(durations) {
+  const sorted = [];
+  for (const d of durations) if (Number.isFinite(d)) sorted.push(d);
+  sorted.sort(ascending);
+  if (sorted.length === 0) return [0, 0, 0];
+  return [quantileSorted(sorted, 0.25), quantileSorted(sorted, 0.5), quantileSorted(sorted, 0.75)];
+}
+function quartileOf(duration, thresholds) {
+  if (duration <= thresholds[0]) return 1;
+  if (duration <= thresholds[1]) return 2;
+  if (duration <= thresholds[2]) return 3;
+  return 4;
+}
+function durationQuartile(occurrence, allDurationsForSegment) {
+  return quartileOf(occurrence.duration, durationQuartileThresholds(allDurationsForSegment));
+}
+
+// src/core/diff-graphs.ts
+function transitionKey2(transition) {
+  return `${transition.source}${EDGE_KEY_SEPARATOR}${transition.target}`;
+}
+function unionIds(first, second) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of first) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  for (const id of second) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+function diffEntries(aById, bById, ids, referenceValue) {
+  return ids.map((id) => {
+    const a = aById.get(id);
+    const b = bById.get(id);
+    const state = a !== void 0 && b !== void 0 ? "common" : a ? "aOnly" : "bOnly";
+    const entry = { id, state };
+    if (a !== void 0) entry.a = a;
+    if (b !== void 0) entry.b = b;
+    if (a !== void 0 && b !== void 0) {
+      const aValue = referenceValue(a);
+      const bValue = referenceValue(b);
+      entry.delta = bValue - aValue;
+      if (aValue > 0) entry.ratio = bValue / aValue;
+    }
+    return entry;
+  });
+}
+function diffGraphs(a, b) {
+  const aActivities = new Map(a.activities.map((activity) => [activity.id, activity]));
+  const bActivities = new Map(b.activities.map((activity) => [activity.id, activity]));
+  const activityIds = unionIds(
+    a.activities.map((activity) => activity.id),
+    b.activities.map((activity) => activity.id)
+  );
+  const aTransitions = new Map(a.transitions.map((t) => [transitionKey2(t), t]));
+  const bTransitions = new Map(b.transitions.map((t) => [transitionKey2(t), t]));
+  const transitionIds = unionIds(
+    a.transitions.map((t) => transitionKey2(t)),
+    b.transitions.map((t) => transitionKey2(t))
+  );
+  return {
+    activities: diffEntries(aActivities, bActivities, activityIds, (stats) => stats.instances),
+    transitions: diffEntries(aTransitions, bTransitions, transitionIds, (stats) => stats.count),
+    totals: { a: a.totals, b: b.totals }
+  };
+}
+
+// src/core/replay-timeline.ts
+var REPLAY_TARGET_FRAMES = 300;
+var REPLAY_MAX_FRAMES = 5e3;
+function defaultReplayBucketMs(duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return 1;
+  return Math.max(1, duration / REPLAY_TARGET_FRAMES);
+}
+function buildSegments(log, synchronizedStart) {
+  const { cases } = asNormalizedLog(log);
+  if (cases.length === 0) return { origin: 0, duration: 0, segments: [] };
+  const origin = synchronizedStart ? 0 : Math.min(...cases.map((c) => c.start));
+  const segments = [];
+  let duration = 0;
+  for (const trace of cases) {
+    const base = synchronizedStart ? trace.start : origin;
+    duration = Math.max(duration, trace.end - base);
+    for (let i = 1; i < trace.events.length; i++) {
+      const from = trace.events[i - 1];
+      const to = trace.events[i];
+      const enterAt = from.end - base;
+      segments.push({
+        caseId: trace.caseId,
+        edgeId: `${from.activity}${EDGE_KEY_SEPARATOR}${to.activity}`,
+        source: from.activity,
+        target: to.activity,
+        enterAt,
+        exitAt: Math.max(enterAt, to.start - base)
+      });
+    }
+  }
+  segments.sort((a, b) => a.enterAt - b.enterAt);
+  return { origin, duration, segments };
+}
+function tokensAt(segments, t) {
+  const tokens2 = [];
+  for (const segment of segments) {
+    if (segment.enterAt > t) break;
+    if (t >= segment.exitAt) continue;
+    tokens2.push({
+      caseId: segment.caseId,
+      edgeId: segment.edgeId,
+      progress: (t - segment.enterAt) / (segment.exitAt - segment.enterAt)
+    });
+  }
+  return tokens2;
+}
+function congestionIn(segments, start, end) {
+  const casesByEdge = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    if (segment.enterAt >= end) break;
+    const overlaps = segment.exitAt > start || segment.enterAt >= start;
+    if (!overlaps) continue;
+    let cases = casesByEdge.get(segment.edgeId);
+    if (!cases) casesByEdge.set(segment.edgeId, cases = /* @__PURE__ */ new Set());
+    cases.add(segment.caseId);
+  }
+  const congestion = {};
+  for (const [edgeId, cases] of casesByEdge) congestion[edgeId] = cases.size;
+  return congestion;
+}
+function replayTimeline(log, options = {}) {
+  const synchronizedStart = options.synchronizedStart ?? false;
+  const { origin, duration, segments } = buildSegments(log, synchronizedStart);
+  const requested = options.bucketMs !== void 0 && Number.isFinite(options.bucketMs) && options.bucketMs > 0 ? options.bucketMs : defaultReplayBucketMs(duration);
+  const bucketMs = Math.max(requested, duration / (REPLAY_MAX_FRAMES - 1));
+  const frameCount = Math.floor(duration / bucketMs) + 1;
+  const frames = [];
+  let peakCongestion = 0;
+  for (let i = 0; i < frameCount; i++) {
+    const t = i * bucketMs;
+    const congestion = congestionIn(segments, t, t + bucketMs);
+    for (const count of Object.values(congestion)) peakCongestion = Math.max(peakCongestion, count);
+    frames.push({ t, tokens: tokensAt(segments, t), congestion });
+  }
+  return { origin, duration, bucketMs, synchronizedStart, segments, frames, peakCongestion };
+}
+function replayFrameAt(timeline, t) {
+  const clamped = Math.min(Math.max(Number.isFinite(t) ? t : 0, 0), timeline.duration);
+  const bucket = Math.min(Math.floor(clamped / timeline.bucketMs), timeline.frames.length - 1);
+  return {
+    t: clamped,
+    tokens: tokensAt(timeline.segments, clamped),
+    congestion: timeline.frames[Math.max(bucket, 0)]?.congestion ?? {}
+  };
+}
+function rankReplayCongestion(timeline, limit = Number.POSITIVE_INFINITY) {
+  const ends = /* @__PURE__ */ new Map();
+  for (const s of timeline.segments) ends.set(s.edgeId, { source: s.source, target: s.target });
+  const byEdge = /* @__PURE__ */ new Map();
+  for (const frame of timeline.frames) {
+    for (const [edgeId, count] of Object.entries(frame.congestion)) {
+      let entry = byEdge.get(edgeId);
+      if (!entry) {
+        const { source, target } = ends.get(edgeId);
+        byEdge.set(edgeId, entry = { edgeId, source, target, peak: 0, peakAt: 0, mean: 0 });
+      }
+      if (count > entry.peak) {
+        entry.peak = count;
+        entry.peakAt = frame.t;
+      }
+      entry.mean += count;
+    }
+  }
+  const frameCount = Math.max(timeline.frames.length, 1);
+  return [...byEdge.values()].map((entry) => ({ ...entry, mean: entry.mean / frameCount })).sort(
+    (a, b) => b.peak - a.peak || b.mean - a.mean || (a.edgeId < b.edgeId ? -1 : a.edgeId > b.edgeId ? 1 : 0)
+  ).slice(0, limit);
+}
+var REPLAY_TOKEN_RADIUS_RANGE = Object.freeze([3, 8]);
+function replayTokenRadius(congestion, peak) {
+  const [min, max] = REPLAY_TOKEN_RADIUS_RANGE;
+  if (!(peak > 0) || !(congestion > 0)) return min;
+  const share = Math.min(congestion / peak, 1);
+  return min + (max - min) * Math.sqrt(share);
+}
+
+// src/core/adapters/ocel.ts
+var OCEL_EVENT_ID_ATTRIBUTE = "__ocelEventId";
+var OCEL_OBJECT_REFS_ATTRIBUTE = "__objectRefs";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isScalar(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function objectAttributes(object) {
+  if (!Array.isArray(object.attributes)) return void 0;
+  const latest = /* @__PURE__ */ new Map();
+  for (const raw of object.attributes) {
+    if (!isRecord(raw) || !nonEmptyString(raw.name) || !isScalar(raw.value)) continue;
+    const parsed = typeof raw.time === "string" ? Date.parse(raw.time) : Number.NEGATIVE_INFINITY;
+    const time = Number.isNaN(parsed) ? Number.NEGATIVE_INFINITY : parsed;
+    const previous = latest.get(raw.name);
+    if (previous === void 0 || time >= previous.time) {
+      latest.set(raw.name, { time, value: raw.value });
+    }
+  }
+  if (latest.size === 0) return void 0;
+  const out = {};
+  for (const [name, entry] of latest) out[name] = entry.value;
+  return out;
+}
+function fromOcel(input, options) {
+  let document = input;
+  if (typeof input === "string") {
+    try {
+      document = JSON.parse(input);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { ok: false, errors: [{ type: "malformed_json", message }] };
+    }
+  }
+  if (!isRecord(document) || !Array.isArray(document.objectTypes) || !Array.isArray(document.objects) || !Array.isArray(document.events)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          type: "invalid_document",
+          message: "expected an object with objectTypes, objects and events arrays"
+        }
+      ]
+    };
+  }
+  const errors = [];
+  const declaredTypes = [];
+  for (const declaration of document.objectTypes) {
+    if (isRecord(declaration) && nonEmptyString(declaration.name)) {
+      if (!declaredTypes.includes(declaration.name)) declaredTypes.push(declaration.name);
+    }
+  }
+  const projected = options?.objectTypes ?? declaredTypes;
+  for (const type of projected) {
+    if (!declaredTypes.includes(type)) {
+      errors.push({
+        type: "unknown_object_type",
+        message: `object type "${type}" is not declared in objectTypes`
+      });
+    }
+  }
+  const projectedSet = new Set(projected);
+  const typeOfObject = /* @__PURE__ */ new Map();
+  const attributesOfObject = /* @__PURE__ */ new Map();
+  document.objects.forEach((object, objectIndex) => {
+    if (!isRecord(object) || !nonEmptyString(object.id) || !nonEmptyString(object.type)) {
+      errors.push({
+        type: "invalid_document",
+        message: "object is missing its id or type",
+        objectIndex
+      });
+      return;
+    }
+    if (!declaredTypes.includes(object.type)) {
+      errors.push({
+        type: "unknown_object_type",
+        message: `object "${object.id}" has undeclared type "${object.type}"`,
+        objectIndex
+      });
+      return;
+    }
+    typeOfObject.set(object.id, object.type);
+    const attributes = objectAttributes(object);
+    if (attributes !== void 0) attributesOfObject.set(object.id, attributes);
+  });
+  const rowsByType = new Map(projected.map((type) => [type, []]));
+  const activities = [];
+  const seenActivities = /* @__PURE__ */ new Set();
+  document.events.forEach((event, eventIndex) => {
+    if (!isRecord(event)) {
+      errors.push({ type: "invalid_document", message: "event is not an object", eventIndex });
+      return;
+    }
+    if (!nonEmptyString(event.id)) {
+      errors.push({ type: "missing_event_id", message: "event is missing its id", eventIndex });
+      return;
+    }
+    if (!nonEmptyString(event.type)) {
+      errors.push({
+        type: "missing_event_type",
+        message: `event "${event.id}" is missing its type`,
+        eventIndex
+      });
+      return;
+    }
+    if (!nonEmptyString(event.time) || Number.isNaN(Date.parse(event.time))) {
+      errors.push({
+        type: "missing_timestamp",
+        message: `event "${event.id}" has no parsable time`,
+        eventIndex
+      });
+      return;
+    }
+    const refs = {};
+    let broken = false;
+    const relationships = Array.isArray(event.relationships) ? event.relationships : [];
+    for (const relationship of relationships) {
+      if (!isRecord(relationship) || !nonEmptyString(relationship.objectId)) continue;
+      const type = typeOfObject.get(relationship.objectId);
+      if (type === void 0) {
+        errors.push({
+          type: "unknown_object",
+          message: `event "${event.id}" references undeclared object "${relationship.objectId}"`,
+          eventIndex
+        });
+        broken = true;
+        continue;
+      }
+      const ids = refs[type] ??= [];
+      if (!ids.includes(relationship.objectId)) ids.push(relationship.objectId);
+    }
+    if (broken) return;
+    if (!seenActivities.has(event.type)) {
+      seenActivities.add(event.type);
+      activities.push(event.type);
+    }
+    let attributes;
+    if (Array.isArray(event.attributes)) {
+      for (const attribute of event.attributes) {
+        if (!isRecord(attribute) || !nonEmptyString(attribute.name)) continue;
+        if (!isScalar(attribute.value)) continue;
+        attributes ??= {};
+        attributes[attribute.name] = attribute.value;
+      }
+    }
+    const encodedRefs = JSON.stringify(refs);
+    for (const [type, objectIds] of Object.entries(refs)) {
+      if (!projectedSet.has(type)) continue;
+      const rows = rowsByType.get(type);
+      for (const objectId of objectIds) {
+        rows.push({
+          caseId: objectId,
+          activity: event.type,
+          timestamp: event.time,
+          attributes: {
+            ...attributes,
+            [OCEL_EVENT_ID_ATTRIBUTE]: event.id,
+            [OCEL_OBJECT_REFS_ATTRIBUTE]: encodedRefs
+          }
+        });
+      }
+    }
+  });
+  if (errors.length > 0) return { ok: false, errors };
+  const logs = {};
+  for (const type of projected) {
+    const events = rowsByType.get(type);
+    const log = { events };
+    let caseAttributes;
+    for (const row of events) {
+      const attributes = attributesOfObject.get(row.caseId);
+      if (attributes === void 0 || caseAttributes?.[row.caseId] !== void 0) continue;
+      caseAttributes ??= {};
+      caseAttributes[row.caseId] = attributes;
+    }
+    if (caseAttributes !== void 0) log.caseAttributes = caseAttributes;
+    logs[type] = log;
+  }
+  return { ok: true, logs, activities, objectTypes: [...projected] };
+}
+function readObjectRefs(row) {
+  const raw = row.attributes?.[OCEL_OBJECT_REFS_ATTRIBUTE];
+  if (typeof raw !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) return void 0;
+    const out = {};
+    for (const [type, ids] of Object.entries(parsed)) {
+      if (Array.isArray(ids)) out[type] = ids.filter((id) => typeof id === "string");
+    }
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/discover-object-centric-graph.ts
+function compareStrings3(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function countDistinctEvents(logs) {
+  const ids = /* @__PURE__ */ new Map();
+  let any = false;
+  for (const log of logs) {
+    for (const row of log.events) {
+      const id = row.attributes?.[OCEL_EVENT_ID_ATTRIBUTE];
+      if (typeof id !== "string") continue;
+      any = true;
+      let set = ids.get(row.activity);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        ids.set(row.activity, set);
+      }
+      set.add(id);
+    }
+  }
+  if (!any) return void 0;
+  const out = /* @__PURE__ */ new Map();
+  for (const [activity, set] of ids) out.set(activity, set.size);
+  return out;
+}
+function mergeObjectCentricGraphs(graphsByType, objectTypes = Object.keys(graphsByType), eventCounts) {
+  const merged = /* @__PURE__ */ new Map();
+  const bestInstances = /* @__PURE__ */ new Map();
+  const transitionsByType = {};
+  const types = objectTypes.filter((type) => graphsByType[type] !== void 0);
+  for (const type of types) {
+    const graph = graphsByType[type];
+    transitionsByType[type] = graph.transitions;
+    for (const activity of graph.activities) {
+      let entry = merged.get(activity.id);
+      if (entry === void 0) {
+        entry = {
+          id: activity.id,
+          label: activity.label,
+          isStart: false,
+          isEnd: false,
+          duration: activity.duration,
+          events: 0,
+          perType: {}
+        };
+        merged.set(activity.id, entry);
+      }
+      entry.perType[type] = { instances: activity.instances, cases: activity.cases };
+      entry.isStart ||= activity.isStart;
+      entry.isEnd ||= activity.isEnd;
+      if (activity.instances > (bestInstances.get(activity.id) ?? -1)) {
+        bestInstances.set(activity.id, activity.instances);
+        entry.duration = activity.duration;
+      }
+    }
+  }
+  const activities = [...merged.values()];
+  for (const activity of activities) {
+    activity.events = eventCounts?.get(activity.id) ?? bestInstances.get(activity.id) ?? 0;
+  }
+  activities.sort((a, b) => b.events - a.events || compareStrings3(a.id, b.id));
+  const graphs = {};
+  for (const type of types) graphs[type] = graphsByType[type];
+  return { activities, transitionsByType, objectTypes: types, graphsByType: graphs };
+}
+function discoverObjectCentricGraph(logsByType, options = {}) {
+  const { objectTypes = Object.keys(logsByType), ...discoverOptions } = options;
+  const types = objectTypes.filter((type) => logsByType[type] !== void 0);
+  const graphsByType = {};
+  for (const type of types) {
+    graphsByType[type] = discoverGraph(logsByType[type], discoverOptions);
+  }
+  const eventCounts = countDistinctEvents(types.map((type) => logsByType[type]));
+  return mergeObjectCentricGraphs(graphsByType, types, eventCounts);
+}
+function abstractObjectCentricGraph(graph, perType = {}, fallback) {
+  const graphsByType = {};
+  const hiddenByType = {};
+  for (const type of graph.objectTypes) {
+    const source = graph.graphsByType[type];
+    const options = perType[type] ?? fallback;
+    if (options === void 0) {
+      graphsByType[type] = source;
+      hiddenByType[type] = { activities: 0, paths: 0 };
+      continue;
+    }
+    const { hidden, ...abstracted } = abstractGraph(source, options);
+    graphsByType[type] = abstracted;
+    hiddenByType[type] = hidden;
+  }
+  const eventCounts = new Map(graph.activities.map((activity) => [activity.id, activity.events]));
+  return {
+    ...mergeObjectCentricGraphs(graphsByType, graph.objectTypes, eventCounts),
+    hiddenByType
+  };
+}
+function objectCentricProcessGraph(graph) {
+  const activities = graph.activities.map((activity) => {
+    let cases = 0;
+    for (const counts of Object.values(activity.perType)) cases += counts.cases;
+    return {
+      id: activity.id,
+      label: activity.label,
+      instances: activity.events,
+      cases,
+      isStart: activity.isStart,
+      isEnd: activity.isEnd,
+      duration: activity.duration
+    };
+  });
+  const transitions = /* @__PURE__ */ new Map();
+  const startActivities = {};
+  const endActivities = {};
+  const totals = { cases: 0, events: 0, variants: 0 };
+  for (const activity of graph.activities) totals.events += activity.events;
+  for (const type of graph.objectTypes) {
+    const typeGraph = graph.graphsByType[type];
+    totals.cases += typeGraph.totals.cases;
+    totals.variants += typeGraph.totals.variants;
+    for (const [id, count] of Object.entries(typeGraph.startActivities)) {
+      startActivities[id] = (startActivities[id] ?? 0) + count;
+    }
+    for (const [id, count] of Object.entries(typeGraph.endActivities)) {
+      endActivities[id] = (endActivities[id] ?? 0) + count;
+    }
+    for (const transition of graph.transitionsByType[type] ?? []) {
+      const key = `${transition.source}${EDGE_KEY_SEPARATOR}${transition.target}`;
+      const existing = transitions.get(key);
+      if (existing === void 0) {
+        transitions.set(key, { ...transition });
+        continue;
+      }
+      if (transition.count > existing.count) existing.duration = transition.duration;
+      existing.count += transition.count;
+      existing.caseCount += transition.caseCount;
+    }
+  }
+  const transitionList = [...transitions.values()].sort(
+    (a, b) => b.count - a.count || compareStrings3(a.source, b.source) || compareStrings3(a.target, b.target)
+  );
+  const sorted = (record) => {
+    const out = {};
+    for (const key of Object.keys(record).sort()) out[key] = record[key];
+    return out;
+  };
+  return {
+    activities,
+    transitions: transitionList,
+    startActivities: sorted(startActivities),
+    endActivities: sorted(endActivities),
+    totals
+  };
+}
+function objectTypeColorScale(graph) {
+  const zero = { min: 0, max: 0, mean: 0, median: 0, p90: 0, sum: 0, trimmedMean: 0 };
+  const activities = graph.objectTypes.map((type) => {
+    const typeGraph = graph.graphsByType[type];
+    return {
+      id: type,
+      label: type,
+      instances: typeGraph.totals.events,
+      cases: typeGraph.totals.cases,
+      isStart: false,
+      isEnd: false,
+      duration: zero
+    };
+  });
+  return activityColorScale({
+    activities,
+    transitions: [],
+    startActivities: {},
+    endActivities: {},
+    totals: { cases: 0, events: 0, variants: 0 }
+  });
+}
 export {
+  ACTIVITY_COLOR_SLOTS,
+  ACTIVITY_OTHER_TOKEN,
   BPI_2012_ACTIVITIES,
   BPI_2012_SUBSET_EPOCH,
   DEFAULT_LIFECYCLE_VALUES,
+  DEVIATION_TYPES,
   DURATION_SAMPLE_CAP,
   DURATION_UNIT_MS,
   DurationSampler,
   EDGE_KEY_SEPARATOR,
   EMPTY_DURATION_STATS,
+  OCEL_EVENT_ID_ATTRIBUTE,
+  OCEL_OBJECT_REFS_ATTRIBUTE,
+  REPLAY_MAX_FRAMES,
+  REPLAY_TARGET_FRAMES,
+  REPLAY_TOKEN_RADIUS_RANGE,
   SYNTHETIC_ACTIVITIES,
   SYNTHETIC_LOG_EPOCH,
   TRIM_FRACTION,
   VARIANT_KEY_SEPARATOR,
   abstractGraph,
+  abstractObjectCentricGraph,
+  activityColorScale,
   aggregatePerformance,
   asNormalizedLog,
   caseMatchesFilters,
+  casesFromLog,
   clampWidth,
+  conformanceRateSeries,
   createProcessWorker,
+  defaultReplayBucketMs,
   detectRework,
+  diffGraphs,
   discoverGraph,
+  discoverObjectCentricGraph,
+  durationQuartile,
+  durationQuartileThresholds,
   durationStats,
+  emptyDeviationCounts,
   emptyDurationStats,
   extractVariants,
   filterLog,
   filterNormalizedLog,
   fromCsv,
   fromFlatRows,
+  fromOcel,
+  fromXes,
   generateBpi2012Subset,
   generateSyntheticLog,
   handleProcessRequest,
   isNormalizedLog,
+  liftHappyPath,
+  mergeObjectCentricGraphs,
   minMax,
   normalizeLifecycle,
   normalizeLog,
+  objectCentricProcessGraph,
+  objectTypeColorScale,
   parseDelimited,
   performanceValue,
   quantile,
   quantileSorted,
+  quartileOf,
+  rankReplayCongestion,
+  readObjectRefs,
   reconcileGraph,
+  replayActivities,
+  replayFrameAt,
+  replayTimeline,
+  replayTokenRadius,
+  replayTrace,
+  segmentKey,
+  segmentOrderByFrequency,
+  segmentOrderForVariant,
+  segmentsFor,
   toEpochMs,
+  tokenReplay,
   variantId,
   variantKey
 };