@workflow/web-shared 5.0.0-beta.40 → 5.0.0-beta.42

package/src/lib/duplicate-events.test.ts

@@ -0,0 +1,339 @@
+import type { Event, EventType } from '@workflow/world';
+import { DUPLICATE_EVENT_FIXTURES } from '@workflow/world/test-support/duplicate-event-fixtures.js';
+import { describe, expect, it } from 'vitest';
+import { findDuplicateEventIds } from './duplicate-events';
+
+const BASE_TIME = Date.parse('2026-01-01T00:00:00.000Z');
+
+const COMPLETE = { isCompleteHistory: true };
+
+let nextSlot = 0;
+
+function event(
+  eventType: EventType,
+  options: {
+    correlationId?: string;
+    /** Log position. Defaults to the order the fixture created the event in. */
+    slot?: number;
+    /** `createdAt`/`occurredAt`, in seconds after the fixture epoch. */
+    at?: number;
+    occurredAt?: number;
+  } = {}
+): Event {
+  nextSlot += 1;
+  const slot = options.slot ?? nextSlot;
+  const createdAt = new Date(BASE_TIME + (options.at ?? slot) * 1000);
+  return {
+    eventId: `evnt_${String(slot).padStart(26, '0')}`,
+    runId: 'run_1',
+    eventType,
+    correlationId: options.correlationId,
+    createdAt,
+    occurredAt:
+      options.occurredAt === undefined
+        ? createdAt
+        : new Date(BASE_TIME + options.occurredAt * 1000),
+    eventData: {},
+  } as unknown as Event;
+}
+
+/**
+ * The same event under the older ID scheme, whose IDs are ULIDs rather than
+ * slots. A backend serving such a log may order it by `(createdAt, eventId)`
+ * instead of by ID, so the ID alone does not fix the log position.
+ */
+function ulidEvent(...args: Parameters<typeof event>): Event {
+  const slotEvent = event(...args);
+  const slot = slotEvent.eventId.slice('evnt_'.length).replace(/^0+/, '');
+  return {
+    ...slotEvent,
+    eventId: `evnt_01K${slot.padStart(23, '0')}`,
+  } as Event;
+}
+
+describe('findDuplicateEventIds', () => {
+  it('returns nothing for a log with no repeats', () => {
+    const events = [
+      event('run_created'),
+      event('run_started'),
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+      event('step_completed', { correlationId: 'step_a' }),
+      event('run_completed'),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(new Set());
+  });
+
+  it('flags every repeat a finished entity collects', () => {
+    const created = event('step_created', { correlationId: 'step_a' });
+    const started = event('step_started', { correlationId: 'step_a' });
+    const completed = event('step_completed', { correlationId: 'step_a' });
+    const createdAgain = event('step_created', { correlationId: 'step_a' });
+    const startedAgain = event('step_started', { correlationId: 'step_a' });
+
+    expect(
+      findDuplicateEventIds(
+        [created, started, completed, createdAgain, startedAgain],
+        COMPLETE
+      )
+    ).toEqual(new Set([createdAgain.eventId, startedAgain.eventId]));
+  });
+
+  it('leaves a class the log has not recorded for the entity yet', () => {
+    // The step finished without a step_started in the log, so this one repeats
+    // nothing. The runtime reports that as divergence rather than passing it
+    // over, and the UI must not present it as a settled repeat.
+    const events = [
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_completed', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(new Set());
+  });
+
+  it('treats completed and failed as one terminal class', () => {
+    // A concurrent replay writing the other outcome does not move the step off
+    // the outcome the run acted on.
+    const failed = event('step_failed', { correlationId: 'step_a' });
+    const completed = event('step_completed', { correlationId: 'step_a' });
+
+    expect(findDuplicateEventIds([failed, completed], COMPLETE)).toEqual(
+      new Set([completed.eventId])
+    );
+  });
+
+  it('keys on the correlation id, so sibling entities never collide', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_created', { correlationId: 'step_b' }),
+      event('step_completed', { correlationId: 'step_a' }),
+      event('step_completed', { correlationId: 'step_b' }),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(new Set());
+  });
+
+  it('does not flag the repeated events of a retried step', () => {
+    // Each attempt legitimately records its own start, and each retryable
+    // failure its own step_retrying. The step's consumer is registered for the
+    // whole sequence and takes all of them.
+    const events = [
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+      event('step_retrying', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+      event('step_retrying', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+      event('step_completed', { correlationId: 'step_a' }),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(new Set());
+  });
+
+  it('does not flag a second step_created while the step is still open', () => {
+    // The step's consumer is registered and absorbs it, so the run does not
+    // read past this event.
+    const events = [
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(new Set());
+  });
+
+  it('does not flag repeated hook deliveries', () => {
+    const events = [
+      event('hook_created', { correlationId: 'hook_a' }),
+      event('hook_received', { correlationId: 'hook_a' }),
+      event('hook_received', { correlationId: 'hook_a' }),
+      event('hook_disposed', { correlationId: 'hook_a' }),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(new Set());
+  });
+
+  it('flags a second start of the run, which carries no correlation id', () => {
+    const started = event('run_started');
+    const startedAgain = event('run_started');
+
+    expect(findDuplicateEventIds([started, startedAgain], COMPLETE)).toEqual(
+      new Set([startedAgain.eventId])
+    );
+  });
+
+  it('leaves a second outcome for the run alone', () => {
+    // Nothing consumes the run's own terminal events: the runtime exits rather
+    // than replaying the body once the log holds one. A second is a fault
+    // worth seeing, not a repeat the run passed over.
+    const completed = event('run_completed');
+    const cancelled = event('run_cancelled');
+
+    expect(findDuplicateEventIds([completed, cancelled], COMPLETE)).toEqual(
+      new Set()
+    );
+  });
+
+  it('folds in log order, not in createdAt order', () => {
+    const created = event('wait_created', { correlationId: 'wait_a', at: 1 });
+    const completed = event('wait_completed', {
+      correlationId: 'wait_a',
+      at: 3,
+    });
+    // The repeat entered before the completion it lost to and only took its
+    // log position afterwards, so its createdAt is the earliest of the three.
+    const createdAgain = event('wait_created', {
+      correlationId: 'wait_a',
+      at: 0,
+    });
+
+    expect(
+      findDuplicateEventIds([created, completed, createdAgain], COMPLETE)
+    ).toEqual(new Set([createdAgain.eventId]));
+  });
+
+  it('folds in log order, not in occurredAt order', () => {
+    const created = event('wait_created', { correlationId: 'wait_a' });
+    const completed = event('wait_completed', { correlationId: 'wait_a' });
+    // occurredAt is measured on the writer's clock, which can run behind.
+    const createdAgain = event('wait_created', {
+      correlationId: 'wait_a',
+      occurredAt: -60,
+    });
+
+    expect(
+      findDuplicateEventIds([created, completed, createdAgain], COMPLETE)
+    ).toEqual(new Set([createdAgain.eventId]));
+  });
+
+  it('gives the same answer whichever way the caller sorted', () => {
+    const events = [
+      event('wait_created', { correlationId: 'wait_a' }),
+      event('wait_completed', { correlationId: 'wait_a' }),
+      event('wait_created', { correlationId: 'wait_a' }),
+    ];
+
+    const ascending = findDuplicateEventIds(events, COMPLETE);
+    const descending = findDuplicateEventIds([...events].reverse(), COMPLETE);
+
+    expect(ascending).toEqual(new Set([events[2].eventId]));
+    expect(descending).toEqual(ascending);
+  });
+
+  it('gives the same answer on tied timestamps whichever way the caller sorted', () => {
+    // Two replays that stamped the same millisecond. Only the log position
+    // separates them, so the answer must not depend on the caller's order.
+    const events = [
+      event('wait_created', { correlationId: 'wait_a', at: 5 }),
+      event('wait_completed', { correlationId: 'wait_a', at: 5 }),
+      event('wait_created', { correlationId: 'wait_a', at: 5 }),
+    ];
+
+    const ascending = findDuplicateEventIds(events, COMPLETE);
+    const descending = findDuplicateEventIds([...events].reverse(), COMPLETE);
+
+    expect(ascending).toEqual(new Set([events[2].eventId]));
+    expect(descending).toEqual(ascending);
+  });
+
+  it('classifies a ULID log whose timestamps corroborate its ids', () => {
+    const created = ulidEvent('wait_created', { correlationId: 'wait_a' });
+    const completed = ulidEvent('wait_completed', { correlationId: 'wait_a' });
+    const createdAgain = ulidEvent('wait_created', { correlationId: 'wait_a' });
+
+    expect(
+      findDuplicateEventIds([created, completed, createdAgain], COMPLETE)
+    ).toEqual(new Set([createdAgain.eventId]));
+  });
+
+  it('classifies nothing on a ULID log whose timestamps contradict its ids', () => {
+    // A ULID carries no log position: one backend returns such a log in
+    // createdAt order and another in id order, and createdAt is stamped when
+    // the write arrives rather than when it commits. With the two orders
+    // disagreeing, which wait_created the run acted on depends on the backend,
+    // so naming either would be a guess.
+    const created = ulidEvent('wait_created', { correlationId: 'wait_a' });
+    const completed = ulidEvent('wait_completed', { correlationId: 'wait_a' });
+    const createdAgain = ulidEvent('wait_created', {
+      correlationId: 'wait_a',
+      at: -60,
+    });
+
+    expect(
+      findDuplicateEventIds([created, completed, createdAgain], COMPLETE)
+    ).toEqual(new Set());
+  });
+
+  it('classifies nothing past the point the run diverged', () => {
+    // The step finished without a step_started, so the runtime reports
+    // divergence on the first trailing start and exits. The second start and
+    // the wait's repeat after it went unread, and neither is a repeat the run
+    // passed over. The wait's repeat before it still is.
+    const events = [
+      event('wait_created', { correlationId: 'wait_a' }),
+      event('wait_completed', { correlationId: 'wait_a' }),
+      event('wait_created', { correlationId: 'wait_a' }),
+      event('step_created', { correlationId: 'step_a' }),
+      event('step_completed', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+      event('step_started', { correlationId: 'step_a' }),
+      event('wait_created', { correlationId: 'wait_a' }),
+    ];
+
+    expect(findDuplicateEventIds(events, COMPLETE)).toEqual(
+      new Set([events[2].eventId])
+    );
+  });
+
+  it('classifies nothing when the caller holds part of the log', () => {
+    // A newest-first page can open on the repeat and omit the event it
+    // repeats, which would invert the answer.
+    const events = [
+      event('wait_completed', { correlationId: 'wait_a' }),
+      event('wait_created', { correlationId: 'wait_a' }),
+    ];
+
+    expect(findDuplicateEventIds(events, { isCompleteHistory: false })).toEqual(
+      new Set()
+    );
+  });
+
+  it('skips events with no id, which callers cannot match on', () => {
+    const anonymous = (eventType: EventType) =>
+      ({
+        ...event(eventType, { correlationId: 'wait_a' }),
+        eventId: undefined,
+      }) as unknown as Event;
+
+    expect(
+      findDuplicateEventIds(
+        [
+          anonymous('wait_created'),
+          anonymous('wait_completed'),
+          anonymous('wait_created'),
+        ],
+        COMPLETE
+      )
+    ).toEqual(new Set());
+  });
+});
+
+/**
+ * The other half of these runs against `EventsConsumer` in `@workflow/core`,
+ * so a fixture whose expectation moves fails on both sides.
+ */
+describe('shared duplicate-event fixtures', () => {
+  for (const fixture of DUPLICATE_EVENT_FIXTURES) {
+    it(`classifies the right events: ${fixture.name}`, () => {
+      const events = fixture.events.map((spec, index) =>
+        event(spec.eventType, { correlationId: spec.entity, slot: index + 1 })
+      );
+
+      expect(findDuplicateEventIds(events, COMPLETE)).toEqual(
+        new Set(fixture.ignoredIndices.map((index) => events[index].eventId))
+      );
+    });
+  }
+});

package/src/lib/duplicate-events.ts

@@ -0,0 +1,188 @@
+import {
+  type EntityEventClass,
+  type Event,
+  entityEventClass,
+  isSlotEventId,
+} from '@workflow/world';
+
+/**
+ * Identifies events a replay reads past.
+ *
+ * Concurrent replays of one run write to a shared log, so a replay working
+ * from a stale prefix can commit a second `step_created` / `step_started` /
+ * `wait_created` for an entity the log already records one of. Every replay
+ * reads the first event of that class at the same position, so a later one
+ * cannot change what the workflow observes.
+ *
+ * The classification mirrors `entityEventClass` in `@workflow/world`, which is
+ * what the runtime keys its own duplicate detection on. What it cannot mirror
+ * is consumer state: the runtime passes over an event only after every
+ * registered callback has declined it, and a callback registered for a
+ * still-open entity legitimately claims a repeat (each retry of a step writes
+ * another `step_started`, and a live step consumer absorbs a second
+ * `step_created`). So a repeat counts here only once a terminal event for the
+ * same entity sits earlier in the log, which is the point past which no
+ * consumer remains.
+ */
+
+/**
+ * Classes whose event closes its entity: no consumer is left for it after.
+ *
+ * The run's own terminal events are absent because `entityEventClass` gives
+ * them no class. The runtime exits rather than replaying the body once the log
+ * holds one, so nothing ever consumes them and nothing can repeat them.
+ */
+const TERMINAL_EVENT_CLASSES: ReadonlySet<EntityEventClass> = new Set([
+  'step_terminal',
+  'wait_completed',
+  'hook_disposed',
+]);
+
+/** Classes with no entity to close first: the log records one per run. */
+const SINGLETON_EVENT_CLASSES: ReadonlySet<EntityEventClass> = new Set([
+  'run_started',
+]);
+
+/** Entity key for events that carry no correlation ID (the run itself). */
+const RUN_ENTITY_KEY = '';
+
+/**
+ * Shown against an event this module reports. Deliberately says what the log
+ * shows rather than what the runtime did with it: tolerating these repeats is
+ * recent, and on a run recorded before it a repeat no consumer claimed failed
+ * the replay instead of being passed over.
+ */
+export const DUPLICATE_EVENT_MESSAGE =
+  'Written by a concurrent replay after an event of the same kind was already recorded and acted on. The run follows the earlier one.';
+
+/**
+ * Candidate log order, by event ID.
+ *
+ * Event IDs are fixed-width and monotonic within a run under both the ULID and
+ * the slot scheme. Length is compared first so a shorter ID never sorts after
+ * a longer one on a log that mixes widths.
+ *
+ * Whether this *is* the log order depends on the ID scheme, which is why
+ * {@link hasKnowableLogOrder} gates the fold. See its doc.
+ */
+function compareEventId(a: Event, b: Event): number {
+  if (a.eventId.length !== b.eventId.length) {
+    return a.eventId.length - b.eventId.length;
+  }
+  return a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0;
+}
+
+function createdAtMs(event: Event): number {
+  const createdAt = event.createdAt;
+  return createdAt instanceof Date
+    ? createdAt.getTime()
+    : new Date(createdAt as unknown as string).getTime();
+}
+
+/**
+ * Whether the order the run consumed its log in can be recovered from the
+ * events alone.
+ *
+ * Which occurrence of a class came first is the whole question here, so the
+ * fold needs the log's order, not an order. The backends do not agree on how
+ * to recover it for every ID scheme:
+ *
+ * - A **slot-numbered** run carries its position in the ID. The slot is drawn
+ *   at the publish, which is the linearization point, so slot order is log
+ *   order everywhere and the ID alone settles it.
+ * - A **ULID-numbered** run does not. One backend returns such a log in
+ *   `(createdAt, eventId)` order while another returns it keyed on the ID, and
+ *   `createdAt` is stamped when the write request arrives rather than when it
+ *   commits. Concurrent writers can therefore produce opposite timestamp and
+ *   ID orders, and the run consumed whichever its own backend served.
+ *
+ * So a ULID log is only knowable where the two orders agree. Where they
+ * contradict, the fold could name the surviving event and pass over the one
+ * the run acted on, which is worse than saying nothing.
+ */
+function hasKnowableLogOrder(orderedById: readonly Event[]): boolean {
+  if (orderedById.every((event) => isSlotEventId(event.eventId))) return true;
+
+  for (let index = 1; index < orderedById.length; index++) {
+    const previous = createdAtMs(orderedById[index - 1]);
+    const current = createdAtMs(orderedById[index]);
+    // A missing or unparseable timestamp leaves nothing to corroborate the ID
+    // order with, which is the same position as a contradiction.
+    if (Number.isNaN(previous) || Number.isNaN(current)) return false;
+    if (current < previous) return false;
+  }
+
+  return true;
+}
+
+/** The fold itself, over a log whose order is known. */
+function foldDuplicates(ordered: readonly Event[]): Set<string> {
+  const duplicates = new Set<string>();
+  const seenClasses = new Set<string>();
+  const closedEntities = new Set<string>();
+
+  for (const event of ordered) {
+    const eventClass = entityEventClass(event.eventType);
+    if (eventClass === undefined) continue;
+
+    const entity = event.correlationId ?? RUN_ENTITY_KEY;
+    const classKey = `${eventClass}:${entity}`;
+    const repeatsClass = seenClasses.has(classKey);
+    const entityWasClosed = closedEntities.has(entity);
+
+    if (TERMINAL_EVENT_CLASSES.has(eventClass)) {
+      closedEntities.add(entity);
+    }
+
+    if (!repeatsClass) {
+      // First of its class, but the entity already finished: no consumer is
+      // left to take it and it repeats nothing, so the runtime reports
+      // divergence here and exits. Everything past this point went unread, so
+      // the fold stops with it rather than recording the class and presenting
+      // a later event of it as a repeat the run passed over.
+      if (entityWasClosed) break;
+      seenClasses.add(classKey);
+      continue;
+    }
+
+    // The entity is still open, so a consumer is registered for it and takes
+    // this event: another attempt, not a repeat read past.
+    if (entityWasClosed || SINGLETON_EVENT_CLASSES.has(eventClass)) {
+      duplicates.add(event.eventId);
+    }
+  }
+
+  return duplicates;
+}
+
+/**
+ * The IDs of the events in `events` that repeat a class the log already
+ * records for the same entity, after that entity finished.
+ *
+ * `isCompleteHistory` must be false whenever the caller holds a subset of the
+ * run's log: one page of a paginated list, or the result of a search. Which
+ * occurrence of a class came first is a property of the whole log, so on a
+ * subset the earlier event may simply be missing, and the fold would report
+ * the surviving one. Nothing is classified in that case.
+ *
+ * Two other things make the answer unknowable and yield the same empty result:
+ * a log whose order cannot be recovered from the events (see
+ * {@link hasKnowableLogOrder}), and everything past the point the run
+ * diverged, since the run exited there and read no further.
+ */
+export function findDuplicateEventIds(
+  events: readonly Event[],
+  { isCompleteHistory }: { isCompleteHistory: boolean }
+): Set<string> {
+  if (!isCompleteHistory || events.length < 2) return new Set();
+
+  // Dropped before the sort, not during the fold: an event with no ID has no
+  // log position to order on, and the caller could not match it either.
+  const ordered = events
+    .filter((event) => Boolean(event.eventId))
+    .sort(compareEventId);
+
+  if (!hasKnowableLogOrder(ordered)) return new Set();
+
+  return foldDuplicates(ordered);
+}

package/src/lib/event-materialization.test.ts

@@ -0,0 +1,117 @@
+import type { Event, EventType } from '@workflow/world';
+import { describe, expect, it } from 'vitest';
+import { materializeSteps } from './event-materialization';
+
+const BASE_TIME = Date.parse('2026-01-01T00:00:00.000Z');
+
+let nextId = 0;
+
+function event(
+  eventType: EventType,
+  options: { correlationId?: string; at?: number } = {}
+): Event {
+  nextId += 1;
+  const offsetSeconds = options.at ?? nextId;
+  return {
+    eventId: `evt_${nextId}`,
+    runId: 'run_1',
+    eventType,
+    correlationId: options.correlationId,
+    createdAt: new Date(BASE_TIME + offsetSeconds * 1000),
+    occurredAt: new Date(BASE_TIME + offsetSeconds * 1000),
+    eventData: eventType === 'step_created' ? { stepName: 'doWork' } : {},
+  } as unknown as Event;
+}
+
+describe('materializeSteps', () => {
+  it('derives status and timings from the run of a well-formed step', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a', at: 1 }),
+      event('step_started', { correlationId: 'step_a', at: 2 }),
+      event('step_completed', { correlationId: 'step_a', at: 5 }),
+    ];
+
+    const [step] = materializeSteps(events);
+
+    expect(step.status).toBe('completed');
+    expect(step.attempt).toBe(1);
+    expect(step.startedAt?.getTime()).toBe(BASE_TIME + 2000);
+    expect(step.completedAt?.getTime()).toBe(BASE_TIME + 5000);
+  });
+
+  it('counts one attempt per start across retries', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a', at: 1 }),
+      event('step_started', { correlationId: 'step_a', at: 2 }),
+      event('step_retrying', { correlationId: 'step_a', at: 3 }),
+      event('step_started', { correlationId: 'step_a', at: 4 }),
+      event('step_completed', { correlationId: 'step_a', at: 6 }),
+    ];
+
+    const [step] = materializeSteps(events);
+
+    expect(step.attempt).toBe(2);
+    expect(step.status).toBe('completed');
+    // The first start is when the step went from queued to running.
+    expect(step.startedAt?.getTime()).toBe(BASE_TIME + 2000);
+  });
+
+  it('keeps the outcome the run acted on when a replay writes another one', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a', at: 1 }),
+      event('step_started', { correlationId: 'step_a', at: 2 }),
+      event('step_failed', { correlationId: 'step_a', at: 3 }),
+      // Written by a concurrent replay working from a stale prefix.
+      event('step_completed', { correlationId: 'step_a', at: 9 }),
+    ];
+
+    const [step] = materializeSteps(events, { isCompleteHistory: true });
+
+    expect(step.status).toBe('failed');
+    expect(step.completedAt?.getTime()).toBe(BASE_TIME + 3000);
+    expect(step.updatedAt.getTime()).toBe(BASE_TIME + 3000);
+  });
+
+  it('still lists the passed-over event on the entity', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a', at: 1 }),
+      event('step_started', { correlationId: 'step_a', at: 2 }),
+      event('step_failed', { correlationId: 'step_a', at: 3 }),
+      event('step_completed', { correlationId: 'step_a', at: 9 }),
+    ];
+
+    const [step] = materializeSteps(events, { isCompleteHistory: true });
+
+    expect(step.events).toHaveLength(4);
+  });
+
+  it('takes the last outcome when the log may be incomplete', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a', at: 1 }),
+      event('step_started', { correlationId: 'step_a', at: 2 }),
+      event('step_failed', { correlationId: 'step_a', at: 3 }),
+      event('step_completed', { correlationId: 'step_a', at: 9 }),
+    ];
+
+    // On a page of the log there is no telling which failure the run acted on,
+    // so nothing is passed over and the fold reports what it was given.
+    const [step] = materializeSteps(events);
+
+    expect(step.status).toBe('completed');
+  });
+
+  it('counts a repeated creation as one attempt while the step is open', () => {
+    const events = [
+      event('step_created', { correlationId: 'step_a', at: 1 }),
+      // A live step consumer claims this, so it is an attempt, not a repeat.
+      event('step_created', { correlationId: 'step_a', at: 2 }),
+      event('step_started', { correlationId: 'step_a', at: 3 }),
+    ];
+
+    const [step] = materializeSteps(events, { isCompleteHistory: true });
+
+    expect(step.events).toHaveLength(3);
+    expect(step.status).toBe('running');
+    expect(step.attempt).toBe(1);
+  });
+});