@workflow/web-shared 5.0.0-beta.41 → 5.0.0-beta.43

package/dist/components/ui/spinner.js

@@ -34,24 +34,18 @@ export function Spinner({ size = 14, color, }) {
                 lineW: size * 0.24,
                 lineH: size * 0.08,
             };
-    return (_jsxs("span", { style: {
-            display: 'inline-flex',
-            position: 'relative',
+    return (_jsxs("span", { className: "relative inline-flex", style: {
             width: size,
             height: size,
-        }, children: [_jsx("style", { dangerouslySetInnerHTML: { __html: KEYFRAMES } }), config.delays.map((delay, i) => (_jsx("span", { style: {
-                    position: 'absolute',
-                    left: '50%',
-                    top: '50%',
+        }, children: [_jsx("style", { dangerouslySetInnerHTML: { __html: KEYFRAMES } }), config.delays.map((delay, i) => (_jsx("span", { className: "absolute top-1/2 left-1/2 rounded-[1px] bg-gray-700 [animation-iteration-count:infinite] [animation-name:wf-spinner-fade] [animation-timing-function:linear]", style: {
                     width: config.lineW,
                     height: config.lineH,
                     marginLeft: -config.lineW / 2,
                     marginTop: -config.lineH / 2,
-                    borderRadius: 1,
-                    backgroundColor: color ?? 'var(--ds-gray-700)',
+                    backgroundColor: color,
                     transform: `rotate(${i * config.angle}deg) translate(${size * 0.36}px)`,
-                    animation: `wf-spinner-fade ${config.duration}ms linear infinite`,
+                    animationDuration: `${config.duration}ms`,
                     animationDelay: `${delay}ms`,
                 } }, delay)))] }));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { parseStepName, parseWorkflowName, } from '@workflow/utils/parse-name';
 export type { Event, Hook, Step, WorkflowRun } from '@workflow/world';
 export * from './components';
 export { hookEventsToHookEntity, stepEventsToStepEntity, waitEventsToWaitEntity, } from './components/workflow-traces/trace-span-construction';
+export { DUPLICATE_EVENT_MESSAGE, findDuplicateEventIds, } from './lib/duplicate-events';
 export type { EventAnalysis } from './lib/event-analysis';
 export { analyzeEvents, hasPendingHooksFromEvents, hasPendingStepsFromEvents, isTerminalStatus, shouldShowReenqueueButton, } from './lib/event-analysis';
 export type { MaterializedEntities, MaterializedHook, MaterializedStep, MaterializedWait, } from './lib/event-materialization';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EACL,aAAa,EACb,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACtE,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sDAAsD,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,yBAAyB,EACzB,gBAAgB,EAChB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,8BAA8B,EAC9B,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACtD,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EACL,aAAa,EACb,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACtE,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sDAAsD,CAAC;AAC9D,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,yBAAyB,EACzB,gBAAgB,EAChB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,8BAA8B,EAC9B,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACtD,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -1,10 +1,11 @@
 export { parseStepName, parseWorkflowName, } from '@workflow/utils/parse-name';
 export * from './components';
 export { hookEventsToHookEntity, stepEventsToStepEntity, waitEventsToWaitEntity, } from './components/workflow-traces/trace-span-construction';
+export { DUPLICATE_EVENT_MESSAGE, findDuplicateEventIds, } from './lib/duplicate-events';
 export { analyzeEvents, hasPendingHooksFromEvents, hasPendingStepsFromEvents, isTerminalStatus, shouldShowReenqueueButton, } from './lib/event-analysis';
 export { materializeAll, materializeHooks, materializeSteps, materializeWaits, } from './lib/event-materialization';
 export { looksLikeWorkflowIdSearchInput, parseExactWorkflowSearchId, } from './lib/exact-event-search-id';
 export { CLASS_INSTANCE_REF_TYPE, ClassInstanceRef, ENCRYPTED_PLACEHOLDER, extractStreamIds, getWebRevivers, hasEncryptedFields, hydrateResourceIO, hydrateResourceIOAsync, hydrateResourceIOWithKey, isClassInstanceRef, isEncryptedMarker, isStreamId, isStreamRef, STREAM_REF_TYPE, truncateId, } from './lib/hydration';
 export { ToastProvider, useToast } from './lib/toast';
 export { extractConversation, formatDuration, formatDurationPrecise, identifyStreamSteps, isDoStreamStep, } from './lib/utils';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/duplicate-events.d.ts

@@ -0,0 +1,27 @@
+import { type Event } from '@workflow/world';
+/**
+ * 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 declare 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.";
+/**
+ * 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 declare function findDuplicateEventIds(events: readonly Event[], { isCompleteHistory }: {
+    isCompleteHistory: boolean;
+}): Set<string>;
+//# sourceMappingURL=duplicate-events.d.ts.map

package/dist/lib/duplicate-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-events.d.ts","sourceRoot":"","sources":["../../src/lib/duplicate-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAGX,MAAM,iBAAiB,CAAC;AA2CzB;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,uIACkG,CAAC;AAsGvI;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,EAAE,iBAAiB,EAAE,EAAE;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,GACpD,GAAG,CAAC,MAAM,CAAC,CAYb"}

package/dist/lib/duplicate-events.js

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

package/dist/lib/event-materialization.d.ts

@@ -54,8 +54,19 @@ export interface MaterializedEntities {
  *
  * Handles partial event lists gracefully: a step may only have a
  * step_created event with no completion yet.
+ *
+ * The derived status and timestamps come from the events the run acted on. A
+ * repeat of a class the log already records is read past by every replay, so
+ * a second terminal event written by a concurrent replay does not move a step
+ * off the outcome the first one recorded. Every event stays on the entity's
+ * `events` list.
+ *
+ * That reduction needs the whole log to be sound, so it only runs when
+ * `isCompleteHistory` says `events` is it. See {@link findDuplicateEventIds}.
  */
-export declare function materializeSteps(events: Event[]): MaterializedStep[];
+export declare function materializeSteps(events: Event[], { isCompleteHistory }?: {
+    isCompleteHistory?: boolean;
+}): MaterializedStep[];
 /**
  * Group hook_* events by correlationId and build Hook-like entities.
  */
@@ -68,5 +79,7 @@ export declare function materializeWaits(events: Event[]): MaterializedWait[];
  * Convenience function that materializes all entity types from a flat
  * event list.
  */
-export declare function materializeAll(events: Event[]): MaterializedEntities;
+export declare function materializeAll(events: Event[], options?: {
+    isCompleteHistory?: boolean;
+}): MaterializedEntities;
 //# sourceMappingURL=event-materialization.d.ts.map

package/dist/lib/event-materialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-materialization.d.ts","sourceRoot":"","sources":["../../src/lib/event-materialization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,KAAK,EAIV,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAMzB,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,mDAAmD;IACnD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,mDAAmD;IACnD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,GAAG,WAAW,CAAC;IAChC,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,mDAAmD;IACnD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC3B;AAqCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,gBAAgB,EAAE,CA2DpE;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,gBAAgB,EAAE,CA8BpE;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,gBAAgB,EAAE,CAyBpE;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,oBAAoB,CAMpE"}
+{"version":3,"file":"event-materialization.d.ts","sourceRoot":"","sources":["../../src/lib/event-materialization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,KAAK,EAIV,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAOzB,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,mDAAmD;IACnD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,mDAAmD;IACnD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,GAAG,WAAW,CAAC;IAChC,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,mDAAmD;IACnD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC3B;AAqCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,KAAK,EAAE,EACf,EAAE,iBAAyB,EAAE,GAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GAClE,gBAAgB,EAAE,CA+DpB;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,gBAAgB,EAAE,CA8BpE;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,gBAAgB,EAAE,CAyBpE;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,KAAK,EAAE,EACf,OAAO,GAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5C,oBAAoB,CAMtB"}

package/dist/lib/event-materialization.js

@@ -10,6 +10,7 @@
  * of making separate API calls for each entity type.
  */
 import { isHookLifecycleEventType, isStepEventType, isWaitEventType, } from '@workflow/world';
+import { findDuplicateEventIds } from './duplicate-events';
 // ---------------------------------------------------------------------------
 // Helper: group events by correlationId
 // ---------------------------------------------------------------------------
@@ -46,9 +47,21 @@ function getEventTimestamp(event) {
  *
  * Handles partial event lists gracefully: a step may only have a
  * step_created event with no completion yet.
+ *
+ * The derived status and timestamps come from the events the run acted on. A
+ * repeat of a class the log already records is read past by every replay, so
+ * a second terminal event written by a concurrent replay does not move a step
+ * off the outcome the first one recorded. Every event stays on the entity's
+ * `events` list.
+ *
+ * That reduction needs the whole log to be sound, so it only runs when
+ * `isCompleteHistory` says `events` is it. See {@link findDuplicateEventIds}.
  */
-export function materializeSteps(events) {
+export function materializeSteps(events, { isCompleteHistory = false } = {}) {
     const groups = groupByCorrelationId(events, isStepEventType);
+    const duplicateEventIds = findDuplicateEventIds(events, {
+        isCompleteHistory,
+    });
     const steps = [];
     for (const [correlationId, stepEvents] of groups) {
         const created = stepEvents.find((e) => e.eventType === 'step_created');
@@ -60,6 +73,8 @@ export function materializeSteps(events) {
         let completedAt;
         let updatedAt = getEventTimestamp(created) ?? created.createdAt;
         for (const e of stepEvents) {
+            if (duplicateEventIds.has(e.eventId))
+                continue;
             switch (e.eventType) {
                 case 'step_started':
                     status = 'running';
@@ -169,11 +184,11 @@ export function materializeWaits(events) {
  * Convenience function that materializes all entity types from a flat
  * event list.
  */
-export function materializeAll(events) {
+export function materializeAll(events, options = {}) {
     return {
-        steps: materializeSteps(events),
+        steps: materializeSteps(events, options),
         hooks: materializeHooks(events),
         waits: materializeWaits(events),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-materialization.js","sourceRoot":"","sources":["../../src/lib/event-materialization.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Event materialization helpers.\n *\n * These functions convert a flat list of workflow events into entity-like\n * objects (steps, hooks, waits) by grouping events by correlationId and\n * stitching together lifecycle events.\n *\n * This enables a \"top-down\" data fetching pattern where the client fetches\n * all events for a run once, then materializes entities client-side instead\n * of making separate API calls for each entity type.\n */\n\nimport {\n  type Event,\n  isHookLifecycleEventType,\n  isStepEventType,\n  isWaitEventType,\n  type StepStatus,\n} from '@workflow/world';\n\n// ---------------------------------------------------------------------------\n// Materialized entity types\n// ---------------------------------------------------------------------------\n\nexport interface MaterializedStep {\n  stepId: string;\n  runId: string;\n  stepName: string;\n  status: StepStatus;\n  attempt: number;\n  createdAt: Date;\n  startedAt?: Date;\n  completedAt?: Date;\n  updatedAt: Date;\n  /** All events for this step, in insertion order */\n  events: Event[];\n}\n\nexport interface MaterializedHook {\n  hookId: string;\n  runId: string;\n  token?: string;\n  createdAt: Date;\n  receivedCount: number;\n  lastReceivedAt?: Date;\n  disposedAt?: Date;\n  /** All events for this hook, in insertion order */\n  events: Event[];\n}\n\nexport interface MaterializedWait {\n  waitId: string;\n  runId: string;\n  status: 'waiting' | 'completed';\n  createdAt: Date;\n  resumeAt?: Date;\n  completedAt?: Date;\n  /** All events for this wait, in insertion order */\n  events: Event[];\n}\n\nexport interface MaterializedEntities {\n  steps: MaterializedStep[];\n  hooks: MaterializedHook[];\n  waits: MaterializedWait[];\n}\n\n// ---------------------------------------------------------------------------\n// Helper: group events by correlationId\n// ---------------------------------------------------------------------------\n\nfunction groupByCorrelationId(\n  events: Event[],\n  matchesEventType: (eventType: string) => boolean\n): Map<string, Event[]> {\n  const groups = new Map<string, Event[]>();\n  for (const event of events) {\n    const cid = event.correlationId;\n    if (!cid) continue;\n    if (!matchesEventType(event.eventType)) continue;\n    const existing = groups.get(cid);\n    if (existing) {\n      existing.push(event);\n    } else {\n      groups.set(cid, [event]);\n    }\n  }\n  return groups;\n}\n\nfunction getEventTimestamp(event: Event | undefined): Date | undefined {\n  const value = event?.occurredAt ?? event?.createdAt;\n  if (!value) return undefined;\n\n  const date = value instanceof Date ? value : new Date(value);\n  return Number.isNaN(date.getTime()) ? undefined : date;\n}\n\n// ---------------------------------------------------------------------------\n// materializeSteps\n// ---------------------------------------------------------------------------\n\n/**\n * Group step_* events by correlationId and build Step-like entities.\n *\n * Handles partial event lists gracefully: a step may only have a\n * step_created event with no completion yet.\n */\nexport function materializeSteps(events: Event[]): MaterializedStep[] {\n  const groups = groupByCorrelationId(events, isStepEventType);\n  const steps: MaterializedStep[] = [];\n\n  for (const [correlationId, stepEvents] of groups) {\n    const created = stepEvents.find((e) => e.eventType === 'step_created');\n    if (!created) continue;\n\n    let status: StepStatus = 'pending';\n    let attempt = 0;\n    let startedAt: Date | undefined;\n    let completedAt: Date | undefined;\n    let updatedAt = getEventTimestamp(created) ?? created.createdAt;\n\n    for (const e of stepEvents) {\n      switch (e.eventType) {\n        case 'step_started':\n          status = 'running';\n          attempt += 1;\n          if (!startedAt) startedAt = getEventTimestamp(e) ?? e.createdAt;\n          completedAt = undefined;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n        case 'step_completed':\n          status = 'completed';\n          completedAt = getEventTimestamp(e) ?? e.createdAt;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n        case 'step_failed':\n          status = 'failed';\n          completedAt = getEventTimestamp(e) ?? e.createdAt;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n        case 'step_retrying':\n          status = 'pending';\n          completedAt = undefined;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n      }\n    }\n\n    steps.push({\n      stepId: correlationId,\n      runId: created.runId,\n      stepName:\n        created.eventType === 'step_created'\n          ? (created.eventData?.stepName ?? correlationId)\n          : correlationId,\n      status,\n      attempt,\n      createdAt: getEventTimestamp(created) ?? created.createdAt,\n      startedAt,\n      completedAt,\n      updatedAt,\n      events: stepEvents,\n    });\n  }\n\n  return steps;\n}\n\n// ---------------------------------------------------------------------------\n// materializeHooks\n// ---------------------------------------------------------------------------\n\n/**\n * Group hook_* events by correlationId and build Hook-like entities.\n */\nexport function materializeHooks(events: Event[]): MaterializedHook[] {\n  const groups = groupByCorrelationId(events, isHookLifecycleEventType);\n  const hooks: MaterializedHook[] = [];\n\n  for (const [correlationId, hookEvents] of groups) {\n    const created = hookEvents.find((e) => e.eventType === 'hook_created');\n    if (!created) continue;\n\n    const receivedEvents = hookEvents.filter(\n      (e) => e.eventType === 'hook_received'\n    );\n    const disposed = hookEvents.find((e) => e.eventType === 'hook_disposed');\n    const lastReceived = receivedEvents.at(-1);\n\n    hooks.push({\n      hookId: correlationId,\n      runId: created.runId,\n      token:\n        created.eventType === 'hook_created'\n          ? created.eventData?.token\n          : undefined,\n      createdAt: getEventTimestamp(created) ?? created.createdAt,\n      receivedCount: receivedEvents.length,\n      lastReceivedAt: getEventTimestamp(lastReceived),\n      disposedAt: getEventTimestamp(disposed),\n      events: hookEvents,\n    });\n  }\n\n  return hooks;\n}\n\n// ---------------------------------------------------------------------------\n// materializeWaits\n// ---------------------------------------------------------------------------\n\n/**\n * Group wait_* events by correlationId and build Wait-like entities.\n */\nexport function materializeWaits(events: Event[]): MaterializedWait[] {\n  const groups = groupByCorrelationId(events, isWaitEventType);\n  const waits: MaterializedWait[] = [];\n\n  for (const [correlationId, waitEvents] of groups) {\n    const created = waitEvents.find((e) => e.eventType === 'wait_created');\n    if (!created) continue;\n\n    const completed = waitEvents.find((e) => e.eventType === 'wait_completed');\n\n    waits.push({\n      waitId: correlationId,\n      runId: created.runId,\n      status: completed ? 'completed' : 'waiting',\n      createdAt: getEventTimestamp(created) ?? created.createdAt,\n      resumeAt:\n        created.eventType === 'wait_created'\n          ? created.eventData?.resumeAt\n          : undefined,\n      completedAt: getEventTimestamp(completed),\n      events: waitEvents,\n    });\n  }\n\n  return waits;\n}\n\n// ---------------------------------------------------------------------------\n// materializeAll\n// ---------------------------------------------------------------------------\n\n/**\n * Convenience function that materializes all entity types from a flat\n * event list.\n */\nexport function materializeAll(events: Event[]): MaterializedEntities {\n  return {\n    steps: materializeSteps(events),\n    hooks: materializeHooks(events),\n    waits: materializeWaits(events),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-materialization.js","sourceRoot":"","sources":["../../src/lib/event-materialization.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Event materialization helpers.\n *\n * These functions convert a flat list of workflow events into entity-like\n * objects (steps, hooks, waits) by grouping events by correlationId and\n * stitching together lifecycle events.\n *\n * This enables a \"top-down\" data fetching pattern where the client fetches\n * all events for a run once, then materializes entities client-side instead\n * of making separate API calls for each entity type.\n */\n\nimport {\n  type Event,\n  isHookLifecycleEventType,\n  isStepEventType,\n  isWaitEventType,\n  type StepStatus,\n} from '@workflow/world';\nimport { findDuplicateEventIds } from './duplicate-events';\n\n// ---------------------------------------------------------------------------\n// Materialized entity types\n// ---------------------------------------------------------------------------\n\nexport interface MaterializedStep {\n  stepId: string;\n  runId: string;\n  stepName: string;\n  status: StepStatus;\n  attempt: number;\n  createdAt: Date;\n  startedAt?: Date;\n  completedAt?: Date;\n  updatedAt: Date;\n  /** All events for this step, in insertion order */\n  events: Event[];\n}\n\nexport interface MaterializedHook {\n  hookId: string;\n  runId: string;\n  token?: string;\n  createdAt: Date;\n  receivedCount: number;\n  lastReceivedAt?: Date;\n  disposedAt?: Date;\n  /** All events for this hook, in insertion order */\n  events: Event[];\n}\n\nexport interface MaterializedWait {\n  waitId: string;\n  runId: string;\n  status: 'waiting' | 'completed';\n  createdAt: Date;\n  resumeAt?: Date;\n  completedAt?: Date;\n  /** All events for this wait, in insertion order */\n  events: Event[];\n}\n\nexport interface MaterializedEntities {\n  steps: MaterializedStep[];\n  hooks: MaterializedHook[];\n  waits: MaterializedWait[];\n}\n\n// ---------------------------------------------------------------------------\n// Helper: group events by correlationId\n// ---------------------------------------------------------------------------\n\nfunction groupByCorrelationId(\n  events: Event[],\n  matchesEventType: (eventType: string) => boolean\n): Map<string, Event[]> {\n  const groups = new Map<string, Event[]>();\n  for (const event of events) {\n    const cid = event.correlationId;\n    if (!cid) continue;\n    if (!matchesEventType(event.eventType)) continue;\n    const existing = groups.get(cid);\n    if (existing) {\n      existing.push(event);\n    } else {\n      groups.set(cid, [event]);\n    }\n  }\n  return groups;\n}\n\nfunction getEventTimestamp(event: Event | undefined): Date | undefined {\n  const value = event?.occurredAt ?? event?.createdAt;\n  if (!value) return undefined;\n\n  const date = value instanceof Date ? value : new Date(value);\n  return Number.isNaN(date.getTime()) ? undefined : date;\n}\n\n// ---------------------------------------------------------------------------\n// materializeSteps\n// ---------------------------------------------------------------------------\n\n/**\n * Group step_* events by correlationId and build Step-like entities.\n *\n * Handles partial event lists gracefully: a step may only have a\n * step_created event with no completion yet.\n *\n * The derived status and timestamps come from the events the run acted on. A\n * repeat of a class the log already records is read past by every replay, so\n * a second terminal event written by a concurrent replay does not move a step\n * off the outcome the first one recorded. Every event stays on the entity's\n * `events` list.\n *\n * That reduction needs the whole log to be sound, so it only runs when\n * `isCompleteHistory` says `events` is it. See {@link findDuplicateEventIds}.\n */\nexport function materializeSteps(\n  events: Event[],\n  { isCompleteHistory = false }: { isCompleteHistory?: boolean } = {}\n): MaterializedStep[] {\n  const groups = groupByCorrelationId(events, isStepEventType);\n  const duplicateEventIds = findDuplicateEventIds(events, {\n    isCompleteHistory,\n  });\n  const steps: MaterializedStep[] = [];\n\n  for (const [correlationId, stepEvents] of groups) {\n    const created = stepEvents.find((e) => e.eventType === 'step_created');\n    if (!created) continue;\n\n    let status: StepStatus = 'pending';\n    let attempt = 0;\n    let startedAt: Date | undefined;\n    let completedAt: Date | undefined;\n    let updatedAt = getEventTimestamp(created) ?? created.createdAt;\n\n    for (const e of stepEvents) {\n      if (duplicateEventIds.has(e.eventId)) continue;\n      switch (e.eventType) {\n        case 'step_started':\n          status = 'running';\n          attempt += 1;\n          if (!startedAt) startedAt = getEventTimestamp(e) ?? e.createdAt;\n          completedAt = undefined;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n        case 'step_completed':\n          status = 'completed';\n          completedAt = getEventTimestamp(e) ?? e.createdAt;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n        case 'step_failed':\n          status = 'failed';\n          completedAt = getEventTimestamp(e) ?? e.createdAt;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n        case 'step_retrying':\n          status = 'pending';\n          completedAt = undefined;\n          updatedAt = getEventTimestamp(e) ?? e.createdAt;\n          break;\n      }\n    }\n\n    steps.push({\n      stepId: correlationId,\n      runId: created.runId,\n      stepName:\n        created.eventType === 'step_created'\n          ? (created.eventData?.stepName ?? correlationId)\n          : correlationId,\n      status,\n      attempt,\n      createdAt: getEventTimestamp(created) ?? created.createdAt,\n      startedAt,\n      completedAt,\n      updatedAt,\n      events: stepEvents,\n    });\n  }\n\n  return steps;\n}\n\n// ---------------------------------------------------------------------------\n// materializeHooks\n// ---------------------------------------------------------------------------\n\n/**\n * Group hook_* events by correlationId and build Hook-like entities.\n */\nexport function materializeHooks(events: Event[]): MaterializedHook[] {\n  const groups = groupByCorrelationId(events, isHookLifecycleEventType);\n  const hooks: MaterializedHook[] = [];\n\n  for (const [correlationId, hookEvents] of groups) {\n    const created = hookEvents.find((e) => e.eventType === 'hook_created');\n    if (!created) continue;\n\n    const receivedEvents = hookEvents.filter(\n      (e) => e.eventType === 'hook_received'\n    );\n    const disposed = hookEvents.find((e) => e.eventType === 'hook_disposed');\n    const lastReceived = receivedEvents.at(-1);\n\n    hooks.push({\n      hookId: correlationId,\n      runId: created.runId,\n      token:\n        created.eventType === 'hook_created'\n          ? created.eventData?.token\n          : undefined,\n      createdAt: getEventTimestamp(created) ?? created.createdAt,\n      receivedCount: receivedEvents.length,\n      lastReceivedAt: getEventTimestamp(lastReceived),\n      disposedAt: getEventTimestamp(disposed),\n      events: hookEvents,\n    });\n  }\n\n  return hooks;\n}\n\n// ---------------------------------------------------------------------------\n// materializeWaits\n// ---------------------------------------------------------------------------\n\n/**\n * Group wait_* events by correlationId and build Wait-like entities.\n */\nexport function materializeWaits(events: Event[]): MaterializedWait[] {\n  const groups = groupByCorrelationId(events, isWaitEventType);\n  const waits: MaterializedWait[] = [];\n\n  for (const [correlationId, waitEvents] of groups) {\n    const created = waitEvents.find((e) => e.eventType === 'wait_created');\n    if (!created) continue;\n\n    const completed = waitEvents.find((e) => e.eventType === 'wait_completed');\n\n    waits.push({\n      waitId: correlationId,\n      runId: created.runId,\n      status: completed ? 'completed' : 'waiting',\n      createdAt: getEventTimestamp(created) ?? created.createdAt,\n      resumeAt:\n        created.eventType === 'wait_created'\n          ? created.eventData?.resumeAt\n          : undefined,\n      completedAt: getEventTimestamp(completed),\n      events: waitEvents,\n    });\n  }\n\n  return waits;\n}\n\n// ---------------------------------------------------------------------------\n// materializeAll\n// ---------------------------------------------------------------------------\n\n/**\n * Convenience function that materializes all entity types from a flat\n * event list.\n */\nexport function materializeAll(\n  events: Event[],\n  options: { isCompleteHistory?: boolean } = {}\n): MaterializedEntities {\n  return {\n    steps: materializeSteps(events, options),\n    hooks: materializeHooks(events),\n    waits: materializeWaits(events),\n  };\n}\n"]}

package/dist/lib/trace-builder.d.ts

@@ -39,6 +39,21 @@ export interface TraceWithMeta {
     }[];
     /** Duration in ms from trace start to the latest known event. */
     knownDurationMs: number;
+    /**
+     * The events left out of the span geometry as repeats. Empty unless the
+     * caller vouched for the log being complete. See
+     * {@link findDuplicateEventIds}.
+     */
+    duplicateEventIds: ReadonlySet<string>;
 }
-export declare function buildTrace(run: WorkflowRun, events: Event[], now: Date): TraceWithMeta;
+export declare function buildTrace(run: WorkflowRun, events: Event[], now: Date, 
+/**
+ * Whether `events` is the run's whole log. Defaults to false, which builds
+ * the trace from every event: on a subset there is no way to tell a repeat
+ * from the only copy the caller was given, and dropping the wrong one moves
+ * a span. See {@link findDuplicateEventIds}.
+ */
+{ isCompleteHistory }?: {
+    isCompleteHistory?: boolean;
+}): TraceWithMeta;
 //# sourceMappingURL=trace-builder.d.ts.map

package/dist/lib/trace-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-builder.d.ts","sourceRoot":"","sources":["../../src/lib/trace-builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,KAAK,EAIV,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,KAAK,KAAG,OAIT,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,KAAK,EAAE,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,KAAK,EAAE,CAMT;AAMD,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IACrC,cAAc,EAAE,KAAK,EAAE,CAAC;IACxB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IAClC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;CAClC,CAAC;AAeF,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,aAAa,CAgCvE;AAsED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,EAAE,CAAC;IAClE,iEAAiE;IACjE,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,UAAU,CACxB,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,KAAK,EAAE,EACf,GAAG,EAAE,IAAI,GACR,aAAa,CA6Bf"}
+{"version":3,"file":"trace-builder.d.ts","sourceRoot":"","sources":["../../src/lib/trace-builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,KAAK,EAIV,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AAWzB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,KAAK,KAAG,OAIT,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,KAAK,EAAE,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,KAAK,EAAE,CAMT;AAMD,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IACrC,cAAc,EAAE,KAAK,EAAE,CAAC;IACxB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IAClC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;CAClC,CAAC;AAeF,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,aAAa,CAgCvE;AAsED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,EAAE,CAAC;IAClE,iEAAiE;IACjE,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACxC;AAED,wBAAgB,UAAU,CACxB,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,KAAK,EAAE,EACf,GAAG,EAAE,IAAI;AACT;;;;;GAKG;AACH,EAAE,iBAAyB,EAAE,GAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GAClE,aAAa,CA0Cf"}