@elabs-ai/components-process 4.1.0

package/dist/core/index.js

@@ -0,0 +1,1553 @@
+// 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/adapters/flat.ts
+var DEFAULT_LIFECYCLE_VALUES = {
+  start: ["start", "started", "begin", "assign", "schedule"],
+  complete: ["complete", "completed", "end", "finish", "finished", "done"]
+};
+function readString(row, column) {
+  if (column === void 0) return void 0;
+  const value = row[column];
+  if (value === void 0 || value === null) return void 0;
+  const text = typeof value === "string" ? value.trim() : String(value);
+  return text === "" ? void 0 : text;
+}
+function readTimestamp(row, column) {
+  if (column === void 0) return void 0;
+  const value = row[column];
+  if (value === void 0 || value === null) return void 0;
+  if (value instanceof Date || typeof value === "number") return value;
+  const text = String(value).trim();
+  return text === "" ? void 0 : text;
+}
+function readAttribute(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) return value.toISOString();
+  return String(value);
+}
+function normalizeLifecycle(raw, values = DEFAULT_LIFECYCLE_VALUES) {
+  if (raw === void 0) return void 0;
+  const needle = raw.trim().toLowerCase();
+  if (needle === "") return void 0;
+  const starts = values.start ?? DEFAULT_LIFECYCLE_VALUES.start;
+  const completes = values.complete ?? DEFAULT_LIFECYCLE_VALUES.complete;
+  for (const candidate of starts) if (candidate.toLowerCase() === needle) return "start";
+  for (const candidate of completes) if (candidate.toLowerCase() === needle) return "complete";
+  return void 0;
+}
+function fromFlatRows(rows, mapping) {
+  const events = [];
+  let caseAttributes;
+  for (const row of rows) {
+    if (row === null || typeof row !== "object") continue;
+    const caseId = readString(row, mapping.caseId);
+    const activity = readString(row, mapping.activity);
+    const timestamp = readTimestamp(row, mapping.timestamp);
+    if (caseId === void 0 || activity === void 0 || timestamp === void 0) continue;
+    const event = { caseId, activity, timestamp };
+    const startTimestamp = readTimestamp(row, mapping.startTimestamp);
+    if (startTimestamp !== void 0) event.startTimestamp = startTimestamp;
+    const resource = readString(row, mapping.resource);
+    if (resource !== void 0) event.resource = resource;
+    const lifecycle = normalizeLifecycle(
+      readString(row, mapping.lifecycle),
+      mapping.lifecycleValues
+    );
+    if (lifecycle !== void 0) event.lifecycle = lifecycle;
+    if (mapping.attributes !== void 0 && mapping.attributes.length > 0) {
+      const attributes = {};
+      let any = false;
+      for (const column of mapping.attributes) {
+        if (!(column in row)) continue;
+        attributes[column] = readAttribute(row[column]);
+        any = true;
+      }
+      if (any) event.attributes = attributes;
+    }
+    if (mapping.caseAttributes !== void 0 && mapping.caseAttributes.length > 0) {
+      caseAttributes ??= {};
+      const bucket = caseAttributes[caseId] ??= {};
+      for (const column of mapping.caseAttributes) {
+        if (bucket[column] !== void 0) continue;
+        const value = readString(row, column);
+        if (value !== void 0) bucket[column] = value;
+      }
+    }
+    events.push(event);
+  }
+  const log = { events };
+  if (caseAttributes !== void 0) log.caseAttributes = caseAttributes;
+  return log;
+}
+
+// src/core/adapters/csv.ts
+var QUOTE = '"';
+var CR = "\r";
+var LF = "\n";
+function parseDelimited(text, delimiter = ",") {
+  const source = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  const records = [];
+  let record = [];
+  let field = "";
+  let quoted = false;
+  let dirty = false;
+  const delimiterChar = delimiter.length > 0 ? delimiter[0] : ",";
+  const endField = () => {
+    record.push(field);
+    field = "";
+    dirty = true;
+  };
+  const endRecord = () => {
+    endField();
+    records.push(record);
+    record = [];
+    dirty = false;
+  };
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    if (quoted) {
+      if (char === QUOTE) {
+        if (source[i + 1] === QUOTE) {
+          field += QUOTE;
+          i += 1;
+        } else {
+          quoted = false;
+        }
+      } else {
+        field += char;
+      }
+      continue;
+    }
+    if (char === QUOTE && field === "") {
+      quoted = true;
+      dirty = true;
+      continue;
+    }
+    if (char === delimiterChar) {
+      endField();
+      continue;
+    }
+    if (char === CR) {
+      if (source[i + 1] === LF) i += 1;
+      endRecord();
+      continue;
+    }
+    if (char === LF) {
+      endRecord();
+      continue;
+    }
+    field += char;
+    dirty = true;
+  }
+  if (field !== "" || dirty) endRecord();
+  return records;
+}
+function toObjects(records, header) {
+  const rows = [];
+  for (const record of records) {
+    const row = {};
+    for (let i = 0; i < header.length; i += 1) {
+      row[header[i]] = record[i] ?? "";
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function fromCsv(text, mapping) {
+  const records = parseDelimited(text, mapping.delimiter ?? ",");
+  let header = mapping.header;
+  let body = records;
+  if (header === void 0) {
+    const first = records[0];
+    if (first === void 0) return { events: [] };
+    header = first.map((name) => name.trim());
+    body = records.slice(1);
+  }
+  return fromFlatRows(toObjects(body, header), mapping);
+}
+
+// src/core/scale.ts
+function ascending(a, b) {
+  return a - b;
+}
+function finiteOnly(values) {
+  const out = [];
+  for (const v of values) if (Number.isFinite(v)) out.push(v);
+  return out;
+}
+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);
+}
+function quantile(values, q) {
+  return quantileSorted(finiteOnly(values).sort(ascending), q);
+}
+function clampWidth(value, domain, range) {
+  const [d0, d1] = domain;
+  const [r0, r1] = range;
+  if (!Number.isFinite(value)) return r0;
+  const span = d1 - d0;
+  if (span === 0) return r0;
+  const t = (value - d0) / span;
+  const clamped = t < 0 ? 0 : t > 1 ? 1 : t;
+  return r0 + (r1 - r0) * clamped;
+}
+
+// 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/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/fixtures/synthetic-log.ts
+var SYNTHETIC_LOG_EPOCH = 17676e8;
+var MINUTE = 6e4;
+function mulberry322(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 RESOURCES = [
+  "A. Novak",
+  "B. Ferreira",
+  "C. Okafor",
+  "D. Lindqvist",
+  "E. Haddad",
+  "Credit Service",
+  "Warehouse Robot"
+];
+var REGIONS = ["North", "South", "East", "West"];
+var SEGMENTS = ["Enterprise", "Mid-market", "SMB"];
+var SYNTHETIC_ACTIVITIES = [
+  "Create Order",
+  "Check Credit",
+  "Amend Order",
+  "Approve Order",
+  "Reject Order",
+  "Reserve Stock",
+  "Cancel Order",
+  "Pick Items",
+  "Ship Order",
+  "Send Invoice",
+  "Receive Payment"
+];
+function buildTrace(random) {
+  const trace = ["Create Order", "Check Credit"];
+  let reworks = 0;
+  while (reworks < 2 && random() < 0.14) {
+    trace.push("Amend Order", "Check Credit");
+    reworks += 1;
+  }
+  if (random() < 0.09) {
+    trace.push("Reject Order");
+    return trace;
+  }
+  trace.push("Approve Order", "Reserve Stock");
+  if (random() < 0.05) {
+    trace.push("Cancel Order");
+    return trace;
+  }
+  trace.push("Pick Items");
+  if (random() < 0.07) trace.push("Pick Items");
+  if (random() < 0.32) trace.push("Send Invoice", "Ship Order");
+  else trace.push("Ship Order", "Send Invoice");
+  trace.push("Receive Payment");
+  return trace;
+}
+function generateSyntheticLog(options) {
+  const total = Math.max(0, Math.floor(options.cases));
+  const random = mulberry322(options.seed ?? 1);
+  const epoch = options.startTime ?? SYNTHETIC_LOG_EPOCH;
+  const events = [];
+  const caseAttributes = {};
+  const pad = String(total).length;
+  for (let index2 = 0; index2 < total; index2 += 1) {
+    const caseId = `case-${String(index2 + 1).padStart(Math.max(5, pad), "0")}`;
+    const trace = buildTrace(random);
+    caseAttributes[caseId] = {
+      region: REGIONS[Math.floor(random() * REGIONS.length)],
+      segment: SEGMENTS[Math.floor(random() * SEGMENTS.length)],
+      // Whole euros, so a table can render the value without a rounding decision.
+      orderValue: 250 + Math.floor(random() * 9750)
+    };
+    let cursor = epoch + index2 * 61 * MINUTE + Math.floor(random() * 40) * MINUTE;
+    for (const activity of trace) {
+      const idle = Math.floor(random() * 180) * MINUTE;
+      const work = (2 + Math.floor(random() * 44)) * MINUTE;
+      const start = cursor + idle;
+      const end = start + work;
+      events.push({
+        caseId,
+        activity,
+        timestamp: end,
+        startTimestamp: start,
+        resource: RESOURCES[Math.floor(random() * RESOURCES.length)]
+      });
+      cursor = end;
+    }
+  }
+  return { events, caseAttributes };
+}
+
+// src/core/fixtures/generate-bpi-2012-subset.ts
+var BPI_2012_SUBSET_EPOCH = 13254876e5;
+var MINUTE2 = 6e4;
+function mulberry323(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 RESOURCES2 = [
+  "Loan Officer 1",
+  "Loan Officer 2",
+  "Loan Officer 3",
+  "Credit Assessor",
+  "Automated System"
+];
+var BPI_2012_ACTIVITIES = [
+  "A_SUBMITTED",
+  "A_PARTLYSUBMITTED",
+  "A_PREACCEPTED",
+  "W_Completeren aanvraag",
+  "A_ACCEPTED",
+  "O_SELECTED",
+  "A_FINALIZED",
+  "O_CREATED",
+  "O_SENT",
+  "W_Nabellen offertes",
+  "O_SENT_BACK",
+  "A_REGISTERED",
+  "A_APPROVED",
+  "A_ACTIVATED",
+  "O_ACCEPTED",
+  "A_DECLINED",
+  "O_DECLINED",
+  "O_CANCELLED",
+  "A_CANCELLED"
+];
+function buildTrace2(random) {
+  const trace = ["A_SUBMITTED", "A_PARTLYSUBMITTED"];
+  if (random() < 0.06) {
+    trace.push("A_DECLINED");
+    return trace;
+  }
+  trace.push("A_PREACCEPTED", "W_Completeren aanvraag");
+  let reworks = 0;
+  while (reworks < 2 && random() < 0.18) {
+    trace.push("W_Completeren aanvraag");
+    reworks += 1;
+  }
+  if (random() < 0.08) {
+    trace.push("A_CANCELLED");
+    return trace;
+  }
+  trace.push(
+    "A_ACCEPTED",
+    "O_SELECTED",
+    "A_FINALIZED",
+    "O_CREATED",
+    "O_SENT",
+    "W_Nabellen offertes"
+  );
+  if (random() < 0.25) trace.push("O_SENT_BACK", "O_SENT", "W_Nabellen offertes");
+  if (random() < 0.1) {
+    if (random() < 0.3) {
+      trace.push("O_CANCELLED", "A_CANCELLED");
+    } else {
+      trace.push("O_DECLINED", random() < 0.5 ? "A_CANCELLED" : "A_DECLINED");
+    }
+    return trace;
+  }
+  trace.push("O_ACCEPTED", "A_REGISTERED", "A_APPROVED", "A_ACTIVATED");
+  return trace;
+}
+function generateBpi2012Subset(options) {
+  const total = Math.max(0, Math.floor(options.cases));
+  const random = mulberry323(options.seed ?? 1);
+  const epoch = options.startTime ?? BPI_2012_SUBSET_EPOCH;
+  const events = [];
+  const pad = String(total).length;
+  for (let index2 = 0; index2 < total; index2 += 1) {
+    const caseId = `bpi-${String(index2 + 1).padStart(Math.max(6, pad), "0")}`;
+    const trace = buildTrace2(random);
+    let cursor = epoch + index2 * 47 * MINUTE2 + Math.floor(random() * 30) * MINUTE2;
+    for (const activity of trace) {
+      const idle = Math.floor(random() * 240) * MINUTE2;
+      const work = (1 + Math.floor(random() * 20)) * MINUTE2;
+      const start = cursor + idle;
+      const end = start + work;
+      events.push({
+        caseId,
+        activity,
+        timestamp: end,
+        startTimestamp: start,
+        resource: RESOURCES2[Math.floor(random() * RESOURCES2.length)]
+      });
+      cursor = end;
+    }
+  }
+  return { events };
+}
+
+// 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/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/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;
+  }
+}
+function scaleStats(stats, factor) {
+  if (factor === 1) return { ...stats };
+  return {
+    min: stats.min * factor,
+    max: stats.max * factor,
+    mean: stats.mean * factor,
+    median: stats.median * factor,
+    p90: stats.p90 * factor,
+    sum: stats.sum * factor,
+    trimmedMean: stats.trimmedMean * factor
+  };
+}
+function edgeKey2(source, target) {
+  return `${source}${EDGE_KEY_SEPARATOR}${target}`;
+}
+function aggregatePerformance(graph, opts) {
+  const factor = 1 / (DURATION_UNIT_MS[opts.unit] ?? 1);
+  let activitySource;
+  let transitionSource;
+  if (opts.log !== void 0) {
+    const derived = discoverGraph(opts.log, {
+      flowTime: opts.flowTime,
+      ...opts.maxDurationSamples === void 0 ? {} : { maxDurationSamples: opts.maxDurationSamples }
+    });
+    activitySource = new Map(derived.activities.map((a) => [a.id, a.duration]));
+    transitionSource = new Map(
+      derived.transitions.map((t) => [edgeKey2(t.source, t.target), t.duration])
+    );
+  }
+  const activityValues = {};
+  const activities = graph.activities.map((activity) => {
+    const source = activitySource?.get(activity.id) ?? activity.duration;
+    const duration = scaleStats(source, factor);
+    activityValues[activity.id] = performanceValue(duration, opts.agg);
+    return { ...activity, duration };
+  });
+  const transitionValues = {};
+  const transitions = graph.transitions.map((edge) => {
+    const key = edgeKey2(edge.source, edge.target);
+    const source = transitionSource?.get(key) ?? edge.duration;
+    const duration = scaleStats(source, factor);
+    transitionValues[key] = performanceValue(duration, opts.agg);
+    return { ...edge, duration };
+  });
+  return {
+    activities,
+    transitions,
+    startActivities: { ...graph.startActivities },
+    endActivities: { ...graph.endActivities },
+    totals: { ...graph.totals },
+    performance: {
+      agg: opts.agg,
+      flowTime: opts.flowTime,
+      unit: opts.unit,
+      activities: activityValues,
+      transitions: transitionValues,
+      activityDomain: minMax(Object.values(activityValues)),
+      transitionDomain: minMax(Object.values(transitionValues))
+    }
+  };
+}
+
+// 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/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/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("./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;
+    }
+  };
+}
+export {
+  BPI_2012_ACTIVITIES,
+  BPI_2012_SUBSET_EPOCH,
+  DEFAULT_LIFECYCLE_VALUES,
+  DURATION_SAMPLE_CAP,
+  DURATION_UNIT_MS,
+  DurationSampler,
+  EDGE_KEY_SEPARATOR,
+  EMPTY_DURATION_STATS,
+  SYNTHETIC_ACTIVITIES,
+  SYNTHETIC_LOG_EPOCH,
+  TRIM_FRACTION,
+  VARIANT_KEY_SEPARATOR,
+  abstractGraph,
+  aggregatePerformance,
+  asNormalizedLog,
+  caseMatchesFilters,
+  clampWidth,
+  createProcessWorker,
+  detectRework,
+  discoverGraph,
+  durationStats,
+  emptyDurationStats,
+  extractVariants,
+  filterLog,
+  filterNormalizedLog,
+  fromCsv,
+  fromFlatRows,
+  generateBpi2012Subset,
+  generateSyntheticLog,
+  handleProcessRequest,
+  isNormalizedLog,
+  minMax,
+  normalizeLifecycle,
+  normalizeLog,
+  parseDelimited,
+  performanceValue,
+  quantile,
+  quantileSorted,
+  reconcileGraph,
+  toEpochMs,
+  variantId,
+  variantKey
+};
+//# sourceMappingURL=index.js.map