@elabs-ai/components-process 4.1.0

package/src/core/fixtures/generate-bpi-2012-subset.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+
+import { BPI_2012_ACTIVITIES, generateBpi2012Subset } from "./generate-bpi-2012-subset";
+
+describe("generateBpi2012Subset", () => {
+  it("is deterministic — the same seed produces a byte-identical log", () => {
+    const a = generateBpi2012Subset({ cases: 50, seed: 42 });
+    const b = generateBpi2012Subset({ cases: 50, seed: 42 });
+    expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+  });
+
+  it("a different seed produces a different log", () => {
+    const a = generateBpi2012Subset({ cases: 50, seed: 1 });
+    const b = generateBpi2012Subset({ cases: 50, seed: 2 });
+    expect(JSON.stringify(a)).not.toBe(JSON.stringify(b));
+  });
+
+  it("every case starts with A_SUBMITTED", () => {
+    const log = generateBpi2012Subset({ cases: 30, seed: 3 });
+    const firstByCase = new Map<string, string>();
+    for (const event of log.events) {
+      if (!firstByCase.has(event.caseId)) firstByCase.set(event.caseId, event.activity);
+    }
+    for (const activity of firstByCase.values()) expect(activity).toBe("A_SUBMITTED");
+  });
+
+  it("emits exactly the declared BPI-2012 vocabulary — set equality in both directions (#228)", () => {
+    // A large case count so every branch of buildTrace() — including the low-probability
+    // O_CANCELLED path — has run at least once. Checking BOTH directions (declared ⊆
+    // emitted AND emitted ⊆ declared) is the point: a subset-only check in either direction
+    // cannot catch the constant and the generator silently drifting apart.
+    const log = generateBpi2012Subset({ cases: 5_000, seed: 5 });
+    const declared = new Set<string>(BPI_2012_ACTIVITIES);
+    const emitted = new Set<string>(log.events.map((event) => event.activity));
+    for (const activity of emitted) expect(declared.has(activity)).toBe(true);
+    for (const activity of declared) expect(emitted.has(activity)).toBe(true);
+  });
+
+  it("cases below 1 yield an empty log", () => {
+    expect(generateBpi2012Subset({ cases: 0, seed: 1 })).toEqual({ events: [] });
+  });
+
+  it("produces a well-formed 13 000-case log within a reasonable time", () => {
+    const started = performance.now();
+    const log = generateBpi2012Subset({ cases: 13_000, seed: 1 });
+    const elapsed = performance.now() - started;
+    expect(log.events.length).toBeGreaterThan(100_000);
+    expect(elapsed).toBeLessThan(2000);
+  });
+});

package/src/core/fixtures/generate-bpi-2012-subset.ts

@@ -0,0 +1,216 @@
+/**
+ * Seeded BPI-2012-shaped event-log generator — RM-053.
+ *
+ * A SEPARATE generator from `synthetic-log.ts` (RM-049), not a second copy of it: RM-049's
+ * `generateSyntheticLog` produces an order-to-cash shaped log (Create Order, Check Credit,
+ * Ship Order, …); this one produces a log shaped like the public BPI Challenge 2012 event
+ * log (van Dongen, 2012) — a Dutch financial institution's loan-application process, whose
+ * activity vocabulary follows the dataset's own three-lifecycle-prefix convention
+ * (`A_` application state, `O_` offer state, `W_` work item). The BPI Challenge datasets are
+ * a public academic research corpus published for the annual Business Process Intelligence
+ * Challenge; naming one here names a published research artifact, not a commercial vendor.
+ *
+ * This is what analysis §4 R21 asks for: a ~13,000-case fixture large enough to exercise
+ * `discoverGraph`'s performance budget (already covered by RM-049's own
+ * `generateSyntheticLog({ cases: 13_000 })` in `discover-graph.test.ts`) and, from RM-051
+ * onward, a Storybook "LargeGraph" story that wants a visually denser, more tangled graph
+ * than the order-to-cash shape produces (more branching, more rework, a wider activity
+ * vocabulary).
+ *
+ * Determinism is the whole contract, exactly as in `synthetic-log.ts`:
+ * `generateBpi2012Subset({ cases: n, seed: s })` returns a byte-identical log on every run.
+ *
+ * ## This module is BROWSER-SAFE — no Node built-ins
+ *
+ * Deliberately: `discoverGraph`/`extractVariants` demos (the RM-053 placeholder Storybook
+ * story, and any future browser-rendered fixture preview) import this module directly, and
+ * Storybook's story tests run in a real browser (`@storybook/addon-vitest`'s Playwright
+ * provider) where `node:fs`/`node:path`/`node:url` are externalized and throw on access. So
+ * this file exports the PURE generator only — no filesystem write, no `import.meta.url`
+ * resolution, no `process.argv` read. The file that writes the on-disk fixture is the
+ * sibling `generate-bpi-2012-subset.write.ts` (see below), which is the only place those
+ * Node-only imports appear.
+ *
+ * ## Producing the on-disk fixture
+ *
+ * The 13k-case output is a ~250k-row JSON document — too large to commit as a binary (see
+ * the repo's "no committed large binary fixture" convention, already followed by
+ * `synthetic-log.ts`). It is a GENERATED artifact: run
+ *
+ * ```
+ * pnpm --filter @elabs-ai/components-process generate:fixtures
+ * ```
+ *
+ * which writes `bpi-2012-subset.json` next to this file (git-ignored — see the repo root
+ * `.gitignore`), via `generate-bpi-2012-subset.write.ts` (run through `vitest`, not `tsx` —
+ * see that file's docblock for why). A consumer of the generated JSON should treat it as a
+ * build artifact, not a checked-in fixture; import {@link generateBpi2012Subset} directly
+ * wherever possible instead of reading the file.
+ */
+import type { EventLog, EventRow } from "../types";
+
+/** Epoch ms the first case starts at: 2012-01-02T08:00:00.000Z, a Monday morning. */
+export const BPI_2012_SUBSET_EPOCH = 1325487600000;
+
+const MINUTE = 60_000;
+
+/** Options for {@link generateBpi2012Subset}. */
+export interface Bpi2012SubsetOptions {
+  /** How many cases to generate. Values below 1 yield an empty log. */
+  cases: number;
+  /** PRNG seed. The same seed always produces the same log. */
+  seed?: number;
+  /** Epoch ms the first case starts at. Defaults to {@link BPI_2012_SUBSET_EPOCH}. */
+  startTime?: number;
+}
+
+/**
+ * A deterministic 32-bit PRNG (mulberry32).
+ *
+ * Deliberately its OWN copy rather than one imported from `synthetic-log.ts`: that file's
+ * `mulberry32` is intentionally unexported (its own doc comment explains why — a fixture
+ * generator's output must not shift because an unrelated generator's internals changed), and
+ * this generator's output is equally a byte-identical fixture contract. Same reasoning,
+ * same repo convention, independently applied.
+ */
+function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 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;
+  };
+}
+
+const RESOURCES = [
+  "Loan Officer 1",
+  "Loan Officer 2",
+  "Loan Officer 3",
+  "Credit Assessor",
+  "Automated System",
+] as const;
+
+/**
+ * Activity vocabulary, following the public BPI Challenge 2012 log's own naming convention:
+ * `A_` (application), `O_` (offer) and `W_` (work item) lifecycle prefixes.
+ */
+export const 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",
+] as const;
+
+/** One activity name from {@link BPI_2012_ACTIVITIES}. */
+export type Bpi2012Activity = (typeof BPI_2012_ACTIVITIES)[number];
+
+/** Build the activity sequence of a single case. Pure given `random`. */
+function buildTrace(random: () => number): Bpi2012Activity[] {
+  const trace: Bpi2012Activity[] = ["A_SUBMITTED", "A_PARTLYSUBMITTED"];
+
+  if (random() < 0.06) {
+    trace.push("A_DECLINED");
+    return trace;
+  }
+
+  trace.push("A_PREACCEPTED", "W_Completeren aanvraag");
+
+  // Rework: an incomplete dossier sends the applicant back through completion, at most twice.
+  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",
+  );
+
+  // About a quarter of offers are sent back at least once before acceptance.
+  if (random() < 0.25) trace.push("O_SENT_BACK", "O_SENT", "W_Nabellen offertes");
+
+  // About 1 in 10 offers ends without acceptance: most are declined outright, a smaller
+  // share are withdrawn (O_CANCELLED) while still outstanding — both close the case, one
+  // via A_CANCELLED and the other via either terminal state, mirroring the public BPI 2012
+  // log's own O_CANCELLED lifecycle event (#228 — this branch is what makes it reachable;
+  // see generate-bpi-2012-subset.test.ts's vocabulary set-equality test).
+  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;
+}
+
+/**
+ * Generate a synthetic BPI-2012-shaped loan-application log.
+ *
+ * Every event is an INTERVAL event (`startTimestamp` + `timestamp`), and cases are emitted
+ * as `caseId`s of the form `bpi-000001`, zero-padded so lexical and numeric order agree —
+ * the same shape `generateSyntheticLog` uses, so downstream consumers do not need a second
+ * case-id convention.
+ */
+export function generateBpi2012Subset(options: Bpi2012SubsetOptions): EventLog {
+  const total = Math.max(0, Math.floor(options.cases));
+  const random = mulberry32(options.seed ?? 1);
+  const epoch = options.startTime ?? BPI_2012_SUBSET_EPOCH;
+
+  const events: EventRow[] = [];
+  const pad = String(total).length;
+
+  for (let index = 0; index < total; index += 1) {
+    const caseId = `bpi-${String(index + 1).padStart(Math.max(6, pad), "0")}`;
+    const trace = buildTrace(random);
+
+    let cursor = epoch + index * 47 * MINUTE + Math.floor(random() * 30) * MINUTE;
+
+    for (const activity of trace) {
+      const idle = Math.floor(random() * 240) * MINUTE;
+      const work = (1 + Math.floor(random() * 20)) * MINUTE;
+      const start = cursor + idle;
+      const end = start + work;
+      events.push({
+        caseId,
+        activity,
+        timestamp: end,
+        startTimestamp: start,
+        resource: RESOURCES[Math.floor(random() * RESOURCES.length)] as string,
+      });
+      cursor = end;
+    }
+  }
+
+  return { events };
+}

package/src/core/fixtures/generate-bpi-2012-subset.write.ts

@@ -0,0 +1,40 @@
+/**
+ * Fixture writer for {@link generateBpi2012Subset} — RM-053.
+ *
+ * Invoked via `pnpm --filter @elabs-ai/components-process generate:fixtures`, which runs
+ * `vitest run --config vitest.fixtures.config.ts` against exactly this file. Deliberately
+ * NOT `tsx` (tried, then reverted — a fixtures change should not carry a repo-wide
+ * `esbuild`/build-tool bump for a package's own dev script): `vitest` is already a
+ * devDependency of this package and executes TypeScript directly, so it is the toolchain
+ * already on hand for running one script.
+ *
+ * This file is a genuine vitest test (a `describe`/`it` pair, with a real assertion) so
+ * `vitest run` accepts it as a normal test file — the write to disk is the test's side
+ * effect. It is named `.write.ts`, not `.test.ts`/`.spec.ts`, so the package's real
+ * `vitest.config.ts` (whose default `include` only matches `*.test.*`/`*.spec.*`) never
+ * picks it up: `pnpm test` never runs this file, and `pnpm generate:fixtures` never runs
+ * the package's real test suite. `vitest.fixtures.config.ts`'s `test.include` names this
+ * file explicitly, which is what makes it reachable at all.
+ */
+import { writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { generateBpi2012Subset } from "./generate-bpi-2012-subset";
+
+/** Resolved path of the generated (git-ignored) fixture file, next to this module. */
+export const BPI_2012_SUBSET_OUTPUT_PATH = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "bpi-2012-subset.json",
+);
+
+describe("generate:fixtures", () => {
+  it("writes the BPI-2012-shaped 13k-case fixture to disk", () => {
+    const log = generateBpi2012Subset({ cases: 13_000, seed: 1 });
+    writeFileSync(BPI_2012_SUBSET_OUTPUT_PATH, JSON.stringify(log));
+    console.log(
+      `Wrote ${BPI_2012_SUBSET_OUTPUT_PATH} (${log.events.length} events across 13000 cases).`,
+    );
+    expect(log.events.length).toBeGreaterThan(0);
+  });
+});

package/src/core/fixtures/order-to-cash-small.json

@@ -0,0 +1,200 @@
+{
+  "events": [
+    {
+      "caseId": "case-1",
+      "activity": "Create Order",
+      "timestamp": "2026-01-05T09:00:00.000Z",
+      "resource": "A. Novak"
+    },
+    {
+      "caseId": "case-1",
+      "activity": "Check Credit",
+      "timestamp": "2026-01-05T10:00:00.000Z",
+      "resource": "Credit Service"
+    },
+    {
+      "caseId": "case-1",
+      "activity": "Approve Order",
+      "timestamp": "2026-01-05T11:00:00.000Z",
+      "resource": "C. Okafor"
+    },
+    {
+      "caseId": "case-1",
+      "activity": "Ship Order",
+      "timestamp": "2026-01-05T12:00:00.000Z",
+      "resource": "Warehouse Robot"
+    },
+    {
+      "caseId": "case-1",
+      "activity": "Send Invoice",
+      "timestamp": "2026-01-05T13:00:00.000Z",
+      "resource": "D. Lindqvist"
+    },
+    {
+      "caseId": "case-1",
+      "activity": "Receive Payment",
+      "timestamp": "2026-01-05T14:00:00.000Z",
+      "resource": "E. Haddad"
+    },
+    {
+      "caseId": "case-2",
+      "activity": "Create Order",
+      "timestamp": "2026-01-06T09:00:00.000Z",
+      "resource": "A. Novak"
+    },
+    {
+      "caseId": "case-2",
+      "activity": "Check Credit",
+      "timestamp": "2026-01-06T10:00:00.000Z",
+      "resource": "Credit Service"
+    },
+    {
+      "caseId": "case-2",
+      "activity": "Approve Order",
+      "timestamp": "2026-01-06T11:00:00.000Z",
+      "resource": "C. Okafor"
+    },
+    {
+      "caseId": "case-2",
+      "activity": "Ship Order",
+      "timestamp": "2026-01-06T12:00:00.000Z",
+      "resource": "Warehouse Robot"
+    },
+    {
+      "caseId": "case-2",
+      "activity": "Send Invoice",
+      "timestamp": "2026-01-06T13:00:00.000Z",
+      "resource": "D. Lindqvist"
+    },
+    {
+      "caseId": "case-2",
+      "activity": "Receive Payment",
+      "timestamp": "2026-01-06T14:00:00.000Z",
+      "resource": "E. Haddad"
+    },
+    {
+      "caseId": "case-3",
+      "activity": "Create Order",
+      "timestamp": "2026-01-07T09:00:00.000Z",
+      "resource": "A. Novak"
+    },
+    {
+      "caseId": "case-3",
+      "activity": "Check Credit",
+      "timestamp": "2026-01-07T10:00:00.000Z",
+      "resource": "Credit Service"
+    },
+    {
+      "caseId": "case-3",
+      "activity": "Reject Order",
+      "timestamp": "2026-01-07T11:00:00.000Z",
+      "resource": "C. Okafor"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Create Order",
+      "timestamp": "2026-01-08T09:00:00.000Z",
+      "resource": "A. Novak"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Check Credit",
+      "timestamp": "2026-01-08T10:00:00.000Z",
+      "resource": "Credit Service"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Amend Order",
+      "timestamp": "2026-01-08T11:00:00.000Z",
+      "resource": "B. Ferreira"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Check Credit",
+      "timestamp": "2026-01-08T12:00:00.000Z",
+      "resource": "Credit Service"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Approve Order",
+      "timestamp": "2026-01-08T13:00:00.000Z",
+      "resource": "C. Okafor"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Ship Order",
+      "timestamp": "2026-01-08T14:00:00.000Z",
+      "resource": "Warehouse Robot"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Send Invoice",
+      "timestamp": "2026-01-08T15:00:00.000Z",
+      "resource": "D. Lindqvist"
+    },
+    {
+      "caseId": "case-4",
+      "activity": "Receive Payment",
+      "timestamp": "2026-01-08T16:00:00.000Z",
+      "resource": "E. Haddad"
+    },
+    {
+      "caseId": "case-5",
+      "activity": "Create Order",
+      "timestamp": "2026-01-09T09:00:00.000Z",
+      "resource": "A. Novak"
+    },
+    {
+      "caseId": "case-5",
+      "activity": "Check Credit",
+      "timestamp": "2026-01-09T11:00:00.000Z",
+      "resource": "Credit Service"
+    },
+    {
+      "caseId": "case-5",
+      "activity": "Approve Order",
+      "timestamp": "2026-01-09T13:00:00.000Z",
+      "resource": "C. Okafor"
+    },
+    {
+      "caseId": "case-5",
+      "activity": "Send Invoice",
+      "timestamp": "2026-01-09T15:00:00.000Z",
+      "resource": "D. Lindqvist"
+    },
+    {
+      "caseId": "case-5",
+      "activity": "Ship Order",
+      "timestamp": "2026-01-09T17:00:00.000Z",
+      "resource": "Warehouse Robot"
+    },
+    {
+      "caseId": "case-5",
+      "activity": "Receive Payment",
+      "timestamp": "2026-01-09T19:00:00.000Z",
+      "resource": "E. Haddad"
+    }
+  ],
+  "caseAttributes": {
+    "case-1": {
+      "region": "North",
+      "segment": "Enterprise"
+    },
+    "case-2": {
+      "region": "South",
+      "segment": "SMB"
+    },
+    "case-3": {
+      "region": "East",
+      "segment": "SMB"
+    },
+    "case-4": {
+      "region": "West",
+      "segment": "Mid-market"
+    },
+    "case-5": {
+      "region": "North",
+      "segment": "Enterprise"
+    }
+  }
+}

package/src/core/fixtures/synthetic-log.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+
+import { discoverGraph } from "../discover-graph";
+import { normalizeLog } from "../event-log";
+import { extractVariants } from "../extract-variants";
+import { generateSyntheticLog, SYNTHETIC_ACTIVITIES, SYNTHETIC_LOG_EPOCH } from "./synthetic-log";
+
+describe("generateSyntheticLog", () => {
+  it("is deterministic — the same seed produces a byte-identical log", () => {
+    expect(generateSyntheticLog({ cases: 50, seed: 4 })).toEqual(
+      generateSyntheticLog({ cases: 50, seed: 4 }),
+    );
+  });
+
+  it("produces a different log for a different seed", () => {
+    expect(generateSyntheticLog({ cases: 50, seed: 4 })).not.toEqual(
+      generateSyntheticLog({ cases: 50, seed: 5 }),
+    );
+  });
+
+  it("emits exactly the requested number of cases, in order", () => {
+    const log = generateSyntheticLog({ cases: 25, seed: 1 });
+    const normalized = normalizeLog(log);
+    expect(normalized.totals.cases).toBe(25);
+    expect(normalized.cases[0]?.caseId).toBe("case-00001");
+    expect(normalized.cases[24]?.caseId).toBe("case-00025");
+    // Zero-padded so lexical and numeric order agree.
+    expect([...normalized.cases.map((c) => c.caseId)].sort()).toEqual(
+      normalized.cases.map((c) => c.caseId),
+    );
+  });
+
+  it("uses only the declared activity vocabulary", () => {
+    const vocabulary = new Set<string>(SYNTHETIC_ACTIVITIES);
+    for (const event of generateSyntheticLog({ cases: 300, seed: 2 }).events) {
+      expect(vocabulary.has(event.activity)).toBe(true);
+    }
+  });
+
+  it("starts at the fixed epoch and never reads a wall clock", () => {
+    const log = generateSyntheticLog({ cases: 3, seed: 1 });
+    const first = log.events[0];
+    expect(typeof first?.timestamp).toBe("number");
+    expect(first?.timestamp as number).toBeGreaterThanOrEqual(SYNTHETIC_LOG_EPOCH);
+    // Ten years of headroom: a wall-clock leak would land far outside this.
+    expect(first?.timestamp as number).toBeLessThan(SYNTHETIC_LOG_EPOCH + 315_360_000_000);
+  });
+
+  it("honours an explicit start time", () => {
+    const log = generateSyntheticLog({ cases: 1, seed: 1, startTime: 0 });
+    expect(log.events[0]?.startTimestamp as number).toBeLessThan(315_360_000_000);
+  });
+
+  it("emits interval events, so activity durations are real", () => {
+    const graph = discoverGraph(generateSyntheticLog({ cases: 300, seed: 6 }));
+    for (const activity of graph.activities) {
+      expect(activity.duration.min).toBeGreaterThan(0);
+    }
+    expect(graph.transitions.some((edge) => edge.duration.max > 0)).toBe(true);
+  });
+
+  it("always starts a case with Create Order and orders events in time", () => {
+    for (const kase of normalizeLog(generateSyntheticLog({ cases: 200, seed: 8 })).cases) {
+      expect(kase.events[0]?.activity).toBe("Create Order");
+      for (let i = 1; i < kase.events.length; i += 1) {
+        expect(kase.events[i]?.start).toBeGreaterThanOrEqual(kase.events[i - 1]?.start ?? 0);
+      }
+    }
+  });
+
+  it("contains the shapes a process view has to handle: branching, rework and a self-loop", () => {
+    const graph = discoverGraph(generateSyntheticLog({ cases: 1000, seed: 1 }));
+    const ids = new Set(graph.activities.map((a) => a.id));
+    // Two exception branches, both reachable.
+    expect(ids.has("Reject Order")).toBe(true);
+    expect(ids.has("Cancel Order")).toBe(true);
+    // A rework loop back to an earlier activity.
+    expect(
+      graph.transitions.some((e) => e.source === "Amend Order" && e.target === "Check Credit"),
+    ).toBe(true);
+    // And a genuine self-loop.
+    expect(graph.transitions.some((e) => e.isSelfLoop)).toBe(true);
+    // More than one ending, because not every order completes.
+    expect(Object.keys(graph.endActivities).length).toBeGreaterThan(1);
+  });
+
+  it("produces a long-tailed variant distribution, not one path repeated", () => {
+    const variants = extractVariants(generateSyntheticLog({ cases: 1000, seed: 1 }));
+    expect(variants.length).toBeGreaterThan(5);
+    // The most common path is dominant but far from the whole log.
+    expect(variants[0]?.share).toBeGreaterThan(0.2);
+    expect(variants[0]?.share).toBeLessThan(0.8);
+  });
+
+  it("attaches case attributes to every case", () => {
+    const log = generateSyntheticLog({ cases: 10, seed: 1 });
+    expect(Object.keys(log.caseAttributes ?? {})).toHaveLength(10);
+    expect(log.caseAttributes?.["case-00001"]).toMatchObject({
+      region: expect.any(String),
+      segment: expect.any(String),
+      orderValue: expect.any(Number),
+    });
+  });
+
+  it("answers a non-positive case count with an empty log", () => {
+    expect(generateSyntheticLog({ cases: 0 }).events).toEqual([]);
+    expect(generateSyntheticLog({ cases: -5 }).events).toEqual([]);
+  });
+});