@workflow/web-shared 5.0.0-beta.46 → 5.0.0-beta.48

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;AAYzB,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,CA8Cf"}
+{"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;AACzB,OAAO,EACL,KAAK,iBAAiB,EAOvB,MAAM,uDAAuD,CAAC;AAI/D,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;AAuED,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,EACE,iBAAyB,EACzB,iBAAiB,GAClB,GAAE;IACD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CAClC,GACL,aAAa,CA+Cf"}

package/dist/lib/trace-builder.js

@@ -87,14 +87,14 @@ function computeLatestKnownTime(events, run) {
     }
     return new Date(latest);
 }
-function buildSpans(run, groupedEvents, now, latestKnownTime) {
+function buildSpans(run, groupedEvents, now, latestKnownTime, getStepAttributes) {
     // Active child spans cap at latestKnownTime so they don't extend into
     // unknown territory. Even when the run is completed, we may not have loaded
     // all events yet, so always use the latest event we've actually seen.
     const childMaxEnd = latestKnownTime;
     const runMaxEnd = run.completedAt ?? now;
     const stepSpans = Array.from(groupedEvents.eventsByStepId.values())
-        .map((events) => stepToSpan(events, childMaxEnd))
+        .map((events) => stepToSpan(events, childMaxEnd, getStepAttributes))
         .filter((span) => span !== null);
     const hookSpans = Array.from(groupedEvents.hookEvents.values())
         .map((events) => hookToSpan(events, childMaxEnd))
@@ -131,7 +131,7 @@ export function buildTrace(run, events, now,
  * from the only copy the caller was given, and dropping the wrong one moves
  * a span. See {@link findDuplicateEventIds}.
  */
-{ isCompleteHistory = false } = {}) {
+{ isCompleteHistory = false, getStepAttributes, } = {}) {
     // Span geometry comes from what the run acted on. A repeat of a class the
     // log already records is read past by every replay, and letting one through
     // here would stretch a span to whenever a concurrent replay committed it.
@@ -146,7 +146,7 @@ export function buildTrace(run, events, now,
     const actedOnEvents = events.filter((event) => !duplicateEventIds.has(event.eventId) && !isSealedNoopEvent(event));
     const groupedEvents = groupEventsByCorrelation(actedOnEvents);
     const latestKnownTime = computeLatestKnownTime(actedOnEvents, run);
-    const { runSpan, spans } = buildSpans(run, groupedEvents, now, latestKnownTime);
+    const { runSpan, spans } = buildSpans(run, groupedEvents, now, latestKnownTime, getStepAttributes);
     const sortedCascadingSpans = cascadeSpans(runSpan, spans);
     // Compute known duration relative to trace start
     const traceStartMs = otelTimeToMs(runSpan.startTime);
@@ -167,4 +167,4 @@ export function buildTrace(run, events, now,
         duplicateEventIds,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace-builder.js","sourceRoot":"","sources":["../../src/lib/trace-builder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Builds a complete trace from a WorkflowRun and its Events.\n *\n * This module groups raw events by correlation ID and entity type,\n * converts each group into an OpenTelemetry-style Span, and returns\n * a fully-formed Trace ready for the trace viewer.\n */\n\nimport {\n  type Event,\n  isHookLifecycleEventType,\n  isStepEventType,\n  isWaitEventType,\n  type WorkflowRun,\n} from '@workflow/world';\nimport {\n  getEventTimestamp,\n  hookToSpan,\n  runToSpan,\n  stepToSpan,\n  WORKFLOW_LIBRARY,\n  waitToSpan,\n} from '../components/workflow-traces/trace-span-construction';\nimport { otelTimeToMs } from '../components/workflow-traces/trace-time-utils';\nimport { findDuplicateEventIds } from './duplicate-events';\nimport { isSealedNoopEvent } from './sealed-events';\nimport type { Span } from './trace-types';\n\n/**\n * Events that belong to the run root span rather than a child entity span.\n * Mirrors the fallthrough logic in {@link groupEventsByCorrelation}: events\n * without a correlationId (run lifecycle) plus correlated events that aren't\n * step/timer/hook events (e.g. `attr_set`, whose correlationId is a dedup\n * token rather than a child entity ID).\n */\nexport const isRunLevelEvent = (event: Event): boolean =>\n  !event.correlationId ||\n  (!isWaitEventType(event.eventType) &&\n    !isHookLifecycleEventType(event.eventType) &&\n    !isStepEventType(event.eventType));\n\n/**\n * Filter the raw event list down to the events for a selected span.\n * For the run root span this returns run-level events (see\n * {@link isRunLevelEvent}); for child spans it returns the events\n * correlated to that span's ID.\n */\nexport function filterSpanRawEvents(\n  events: Event[],\n  resource: string | undefined,\n  spanId: string | undefined\n): Event[] {\n  if (resource === 'run') {\n    return events.filter(isRunLevelEvent);\n  }\n  if (!spanId) return [];\n  return events.filter((e) => e.correlationId === spanId);\n}\n\n// ---------------------------------------------------------------------------\n// Event grouping\n// ---------------------------------------------------------------------------\n\nexport type GroupedEvents = {\n  eventsByStepId: Map<string, Event[]>;\n  runLevelEvents: Event[];\n  timerEvents: Map<string, Event[]>;\n  hookEvents: Map<string, Event[]>;\n};\n\nfunction pushEvent(\n  map: Map<string, Event[]>,\n  correlationId: string,\n  event: Event\n) {\n  const existing = map.get(correlationId);\n  if (existing) {\n    existing.push(event);\n    return;\n  }\n  map.set(correlationId, [event]);\n}\n\nexport function groupEventsByCorrelation(events: Event[]): GroupedEvents {\n  const eventsByStepId = new Map<string, Event[]>();\n  const runLevelEvents: Event[] = [];\n  const timerEvents = new Map<string, Event[]>();\n  const hookEvents = new Map<string, Event[]>();\n\n  for (const event of events) {\n    const correlationId = event.correlationId;\n    if (!correlationId) {\n      runLevelEvents.push(event);\n      continue;\n    }\n\n    if (isWaitEventType(event.eventType)) {\n      pushEvent(timerEvents, correlationId, event);\n      continue;\n    }\n\n    if (isHookLifecycleEventType(event.eventType)) {\n      pushEvent(hookEvents, correlationId, event);\n      continue;\n    }\n\n    if (isStepEventType(event.eventType)) {\n      pushEvent(eventsByStepId, correlationId, event);\n      continue;\n    }\n\n    runLevelEvents.push(event);\n  }\n\n  return { eventsByStepId, runLevelEvents, timerEvents, hookEvents };\n}\n\n// ---------------------------------------------------------------------------\n// Trace construction\n// ---------------------------------------------------------------------------\n\n/**\n * Computes the latest known event time from the events list.\n * Active (in-progress) child spans are capped at this time instead of `now`,\n * so they only extend as far as our data goes.\n */\nfunction computeLatestKnownTime(events: Event[], run: WorkflowRun): Date {\n  let latest = new Date(run.createdAt).getTime();\n  for (const event of events) {\n    const t = (getEventTimestamp(event) ?? new Date(event.createdAt)).getTime();\n    if (t > latest) latest = t;\n  }\n  return new Date(latest);\n}\n\nfunction buildSpans(\n  run: WorkflowRun,\n  groupedEvents: GroupedEvents,\n  now: Date,\n  latestKnownTime: Date\n) {\n  // Active child spans cap at latestKnownTime so they don't extend into\n  // unknown territory. Even when the run is completed, we may not have loaded\n  // all events yet, so always use the latest event we've actually seen.\n  const childMaxEnd = latestKnownTime;\n  const runMaxEnd = run.completedAt ?? now;\n\n  const stepSpans = Array.from(groupedEvents.eventsByStepId.values())\n    .map((events) => stepToSpan(events, childMaxEnd))\n    .filter((span): span is Span => span !== null);\n\n  const hookSpans = Array.from(groupedEvents.hookEvents.values())\n    .map((events) => hookToSpan(events, childMaxEnd))\n    .filter((span): span is Span => span !== null);\n\n  const waitSpans = Array.from(groupedEvents.timerEvents.values())\n    .map((events) => waitToSpan(events, childMaxEnd, runMaxEnd))\n    .filter((span): span is Span => span !== null);\n\n  return {\n    runSpan: runToSpan(run, groupedEvents.runLevelEvents, now),\n    spans: [...stepSpans, ...hookSpans, ...waitSpans],\n  };\n}\n\nfunction cascadeSpans(runSpan: Span, spans: Span[]) {\n  const sortedSpans = [\n    runSpan,\n    ...spans.slice().sort((a, b) => {\n      const aStart = otelTimeToMs(a.startTime);\n      const bStart = otelTimeToMs(b.startTime);\n      return aStart - bStart;\n    }),\n  ];\n\n  return sortedSpans.map((span, index) => {\n    const parentSpanId =\n      index === 0 ? undefined : String(sortedSpans[index - 1].spanId);\n    return {\n      ...span,\n      parentSpanId,\n    };\n  });\n}\n\nexport interface TraceWithMeta {\n  traceId: string;\n  rootSpanId: string;\n  spans: Span[];\n  resources: { name: string; attributes: Record<string, string> }[];\n  /** Duration in ms from trace start to the latest known event. */\n  knownDurationMs: number;\n  /**\n   * The events left out of the span geometry as repeats. Empty unless the\n   * caller vouched for the log being complete. See\n   * {@link findDuplicateEventIds}.\n   */\n  duplicateEventIds: ReadonlySet<string>;\n}\n\nexport function buildTrace(\n  run: WorkflowRun,\n  events: Event[],\n  now: Date,\n  /**\n   * Whether `events` is the run's whole log. Defaults to false, which builds\n   * the trace from every event: on a subset there is no way to tell a repeat\n   * from the only copy the caller was given, and dropping the wrong one moves\n   * a span. See {@link findDuplicateEventIds}.\n   */\n  { isCompleteHistory = false }: { isCompleteHistory?: boolean } = {}\n): TraceWithMeta {\n  // Span geometry comes from what the run acted on. A repeat of a class the\n  // log already records is read past by every replay, and letting one through\n  // here would stretch a span to whenever a concurrent replay committed it.\n  // Sealed-position noops are excluded for the same reason with a different\n  // clock: a noop's createdAt is the sealer's wall time, which can postdate\n  // every real event around it, so feeding it into span grouping or the\n  // latest-known-time bound would chart the sealer's schedule instead of the\n  // run's. The event lists still show both, marked with the reason.\n  const duplicateEventIds = findDuplicateEventIds(events, {\n    isCompleteHistory,\n  });\n  const actedOnEvents = events.filter(\n    (event) =>\n      !duplicateEventIds.has(event.eventId) && !isSealedNoopEvent(event)\n  );\n\n  const groupedEvents = groupEventsByCorrelation(actedOnEvents);\n  const latestKnownTime = computeLatestKnownTime(actedOnEvents, run);\n  const { runSpan, spans } = buildSpans(\n    run,\n    groupedEvents,\n    now,\n    latestKnownTime\n  );\n  const sortedCascadingSpans = cascadeSpans(runSpan, spans);\n\n  // Compute known duration relative to trace start\n  const traceStartMs = otelTimeToMs(runSpan.startTime);\n  const knownDurationMs = latestKnownTime.getTime() - traceStartMs;\n\n  return {\n    traceId: run.runId,\n    rootSpanId: run.runId,\n    spans: sortedCascadingSpans,\n    resources: [\n      {\n        name: 'workflow',\n        attributes: {\n          'service.name': WORKFLOW_LIBRARY.name,\n        },\n      },\n    ],\n    knownDurationMs: Math.max(0, knownDurationMs),\n    duplicateEventIds,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace-builder.js","sourceRoot":"","sources":["../../src/lib/trace-builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAEL,wBAAwB,EACxB,eAAe,EACf,eAAe,GAEhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEL,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,UAAU,GACX,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAY,EAAW,EAAE,CACvD,CAAC,KAAK,CAAC,aAAa;IACpB,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC;QAChC,CAAC,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC;QAC1C,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAe,EACf,QAA4B,EAC5B,MAA0B;IAE1B,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,KAAK,MAAM,CAAC,CAAC;AAC1D,CAAC;AAaD,SAAS,SAAS,CAChB,GAAyB,EACzB,aAAqB,EACrB,KAAY;IAEZ,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IACxC,IAAI,QAAQ,EAAE,CAAC;QACb,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,OAAO;IACT,CAAC;IACD,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,MAAe;IACtD,MAAM,cAAc,GAAG,IAAI,GAAG,EAAmB,CAAC;IAClD,MAAM,cAAc,GAAY,EAAE,CAAC;IACnC,MAAM,WAAW,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC/C,MAAM,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE9C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAC1C,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC3B,SAAS;QACX,CAAC;QAED,IAAI,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YACrC,SAAS,CAAC,WAAW,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;YAC7C,SAAS;QACX,CAAC;QAED,IAAI,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9C,SAAS,CAAC,UAAU,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;YAC5C,SAAS;QACX,CAAC;QAED,IAAI,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YACrC,SAAS,CAAC,cAAc,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;YAChD,SAAS;QACX,CAAC;QAED,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC;AACrE,CAAC;AAED,8EAA8E;AAC9E,qBAAqB;AACrB,8EAA8E;AAE9E;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,MAAe,EAAE,GAAgB;IAC/D,IAAI,MAAM,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;IAC/C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QAC5E,IAAI,CAAC,GAAG,MAAM;YAAE,MAAM,GAAG,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;AAC1B,CAAC;AAED,SAAS,UAAU,CACjB,GAAgB,EAChB,aAA4B,EAC5B,GAAS,EACT,eAAqB,EACrB,iBAAqC;IAErC,sEAAsE;IACtE,4EAA4E;IAC5E,sEAAsE;IACtE,MAAM,WAAW,GAAG,eAAe,CAAC;IACpC,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC;IAEzC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;SAChE,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,iBAAiB,CAAC,CAAC;SACnE,MAAM,CAAC,CAAC,IAAI,EAAgB,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAEjD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;SAC5D,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;SAChD,MAAM,CAAC,CAAC,IAAI,EAAgB,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAEjD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;SAC7D,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;SAC3D,MAAM,CAAC,CAAC,IAAI,EAAgB,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAEjD,OAAO;QACL,OAAO,EAAE,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,cAAc,EAAE,GAAG,CAAC;QAC1D,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,GAAG,SAAS,EAAE,GAAG,SAAS,CAAC;KAClD,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,OAAa,EAAE,KAAa;IAChD,MAAM,WAAW,GAAG;QAClB,OAAO;QACP,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YAC7B,MAAM,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YACzC,OAAO,MAAM,GAAG,MAAM,CAAC;QACzB,CAAC,CAAC;KACH,CAAC;IAEF,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QACrC,MAAM,YAAY,GAChB,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAClE,OAAO;YACL,GAAG,IAAI;YACP,YAAY;SACb,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAiBD,MAAM,UAAU,UAAU,CACxB,GAAgB,EAChB,MAAe,EACf,GAAS;AACT;;;;;GAKG;AACH,EACE,iBAAiB,GAAG,KAAK,EACzB,iBAAiB,MAIf,EAAE;IAEN,0EAA0E;IAC1E,4EAA4E;IAC5E,0EAA0E;IAC1E,0EAA0E;IAC1E,0EAA0E;IAC1E,sEAAsE;IACtE,2EAA2E;IAC3E,kEAAkE;IAClE,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,EAAE;QACtD,iBAAiB;KAClB,CAAC,CAAC;IACH,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CACjC,CAAC,KAAK,EAAE,EAAE,CACR,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CACrE,CAAC;IAEF,MAAM,aAAa,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAAC;IAC9D,MAAM,eAAe,GAAG,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;IACnE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,UAAU,CACnC,GAAG,EACH,aAAa,EACb,GAAG,EACH,eAAe,EACf,iBAAiB,CAClB,CAAC;IACF,MAAM,oBAAoB,GAAG,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAE1D,iDAAiD;IACjD,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACrD,MAAM,eAAe,GAAG,eAAe,CAAC,OAAO,EAAE,GAAG,YAAY,CAAC;IAEjE,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,KAAK;QAClB,UAAU,EAAE,GAAG,CAAC,KAAK;QACrB,KAAK,EAAE,oBAAoB;QAC3B,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,UAAU;gBAChB,UAAU,EAAE;oBACV,cAAc,EAAE,gBAAgB,CAAC,IAAI;iBACtC;aACF;SACF;QACD,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,eAAe,CAAC;QAC7C,iBAAiB;KAClB,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Builds a complete trace from a WorkflowRun and its Events.\n *\n * This module groups raw events by correlation ID and entity type,\n * converts each group into an OpenTelemetry-style Span, and returns\n * a fully-formed Trace ready for the trace viewer.\n */\n\nimport {\n  type Event,\n  isHookLifecycleEventType,\n  isStepEventType,\n  isWaitEventType,\n  type WorkflowRun,\n} from '@workflow/world';\nimport {\n  type GetStepAttributes,\n  getEventTimestamp,\n  hookToSpan,\n  runToSpan,\n  stepToSpan,\n  WORKFLOW_LIBRARY,\n  waitToSpan,\n} from '../components/workflow-traces/trace-span-construction';\nimport { otelTimeToMs } from '../components/workflow-traces/trace-time-utils';\nimport { findDuplicateEventIds } from './duplicate-events';\nimport { isSealedNoopEvent } from './sealed-events';\nimport type { Span } from './trace-types';\n\n/**\n * Events that belong to the run root span rather than a child entity span.\n * Mirrors the fallthrough logic in {@link groupEventsByCorrelation}: events\n * without a correlationId (run lifecycle) plus correlated events that aren't\n * step/timer/hook events (e.g. `attr_set`, whose correlationId is a dedup\n * token rather than a child entity ID).\n */\nexport const isRunLevelEvent = (event: Event): boolean =>\n  !event.correlationId ||\n  (!isWaitEventType(event.eventType) &&\n    !isHookLifecycleEventType(event.eventType) &&\n    !isStepEventType(event.eventType));\n\n/**\n * Filter the raw event list down to the events for a selected span.\n * For the run root span this returns run-level events (see\n * {@link isRunLevelEvent}); for child spans it returns the events\n * correlated to that span's ID.\n */\nexport function filterSpanRawEvents(\n  events: Event[],\n  resource: string | undefined,\n  spanId: string | undefined\n): Event[] {\n  if (resource === 'run') {\n    return events.filter(isRunLevelEvent);\n  }\n  if (!spanId) return [];\n  return events.filter((e) => e.correlationId === spanId);\n}\n\n// ---------------------------------------------------------------------------\n// Event grouping\n// ---------------------------------------------------------------------------\n\nexport type GroupedEvents = {\n  eventsByStepId: Map<string, Event[]>;\n  runLevelEvents: Event[];\n  timerEvents: Map<string, Event[]>;\n  hookEvents: Map<string, Event[]>;\n};\n\nfunction pushEvent(\n  map: Map<string, Event[]>,\n  correlationId: string,\n  event: Event\n) {\n  const existing = map.get(correlationId);\n  if (existing) {\n    existing.push(event);\n    return;\n  }\n  map.set(correlationId, [event]);\n}\n\nexport function groupEventsByCorrelation(events: Event[]): GroupedEvents {\n  const eventsByStepId = new Map<string, Event[]>();\n  const runLevelEvents: Event[] = [];\n  const timerEvents = new Map<string, Event[]>();\n  const hookEvents = new Map<string, Event[]>();\n\n  for (const event of events) {\n    const correlationId = event.correlationId;\n    if (!correlationId) {\n      runLevelEvents.push(event);\n      continue;\n    }\n\n    if (isWaitEventType(event.eventType)) {\n      pushEvent(timerEvents, correlationId, event);\n      continue;\n    }\n\n    if (isHookLifecycleEventType(event.eventType)) {\n      pushEvent(hookEvents, correlationId, event);\n      continue;\n    }\n\n    if (isStepEventType(event.eventType)) {\n      pushEvent(eventsByStepId, correlationId, event);\n      continue;\n    }\n\n    runLevelEvents.push(event);\n  }\n\n  return { eventsByStepId, runLevelEvents, timerEvents, hookEvents };\n}\n\n// ---------------------------------------------------------------------------\n// Trace construction\n// ---------------------------------------------------------------------------\n\n/**\n * Computes the latest known event time from the events list.\n * Active (in-progress) child spans are capped at this time instead of `now`,\n * so they only extend as far as our data goes.\n */\nfunction computeLatestKnownTime(events: Event[], run: WorkflowRun): Date {\n  let latest = new Date(run.createdAt).getTime();\n  for (const event of events) {\n    const t = (getEventTimestamp(event) ?? new Date(event.createdAt)).getTime();\n    if (t > latest) latest = t;\n  }\n  return new Date(latest);\n}\n\nfunction buildSpans(\n  run: WorkflowRun,\n  groupedEvents: GroupedEvents,\n  now: Date,\n  latestKnownTime: Date,\n  getStepAttributes?: GetStepAttributes\n) {\n  // Active child spans cap at latestKnownTime so they don't extend into\n  // unknown territory. Even when the run is completed, we may not have loaded\n  // all events yet, so always use the latest event we've actually seen.\n  const childMaxEnd = latestKnownTime;\n  const runMaxEnd = run.completedAt ?? now;\n\n  const stepSpans = Array.from(groupedEvents.eventsByStepId.values())\n    .map((events) => stepToSpan(events, childMaxEnd, getStepAttributes))\n    .filter((span): span is Span => span !== null);\n\n  const hookSpans = Array.from(groupedEvents.hookEvents.values())\n    .map((events) => hookToSpan(events, childMaxEnd))\n    .filter((span): span is Span => span !== null);\n\n  const waitSpans = Array.from(groupedEvents.timerEvents.values())\n    .map((events) => waitToSpan(events, childMaxEnd, runMaxEnd))\n    .filter((span): span is Span => span !== null);\n\n  return {\n    runSpan: runToSpan(run, groupedEvents.runLevelEvents, now),\n    spans: [...stepSpans, ...hookSpans, ...waitSpans],\n  };\n}\n\nfunction cascadeSpans(runSpan: Span, spans: Span[]) {\n  const sortedSpans = [\n    runSpan,\n    ...spans.slice().sort((a, b) => {\n      const aStart = otelTimeToMs(a.startTime);\n      const bStart = otelTimeToMs(b.startTime);\n      return aStart - bStart;\n    }),\n  ];\n\n  return sortedSpans.map((span, index) => {\n    const parentSpanId =\n      index === 0 ? undefined : String(sortedSpans[index - 1].spanId);\n    return {\n      ...span,\n      parentSpanId,\n    };\n  });\n}\n\nexport interface TraceWithMeta {\n  traceId: string;\n  rootSpanId: string;\n  spans: Span[];\n  resources: { name: string; attributes: Record<string, string> }[];\n  /** Duration in ms from trace start to the latest known event. */\n  knownDurationMs: number;\n  /**\n   * The events left out of the span geometry as repeats. Empty unless the\n   * caller vouched for the log being complete. See\n   * {@link findDuplicateEventIds}.\n   */\n  duplicateEventIds: ReadonlySet<string>;\n}\n\nexport function buildTrace(\n  run: WorkflowRun,\n  events: Event[],\n  now: Date,\n  /**\n   * Whether `events` is the run's whole log. Defaults to false, which builds\n   * the trace from every event: on a subset there is no way to tell a repeat\n   * from the only copy the caller was given, and dropping the wrong one moves\n   * a span. See {@link findDuplicateEventIds}.\n   */\n  {\n    isCompleteHistory = false,\n    getStepAttributes,\n  }: {\n    isCompleteHistory?: boolean;\n    getStepAttributes?: GetStepAttributes;\n  } = {}\n): TraceWithMeta {\n  // Span geometry comes from what the run acted on. A repeat of a class the\n  // log already records is read past by every replay, and letting one through\n  // here would stretch a span to whenever a concurrent replay committed it.\n  // Sealed-position noops are excluded for the same reason with a different\n  // clock: a noop's createdAt is the sealer's wall time, which can postdate\n  // every real event around it, so feeding it into span grouping or the\n  // latest-known-time bound would chart the sealer's schedule instead of the\n  // run's. The event lists still show both, marked with the reason.\n  const duplicateEventIds = findDuplicateEventIds(events, {\n    isCompleteHistory,\n  });\n  const actedOnEvents = events.filter(\n    (event) =>\n      !duplicateEventIds.has(event.eventId) && !isSealedNoopEvent(event)\n  );\n\n  const groupedEvents = groupEventsByCorrelation(actedOnEvents);\n  const latestKnownTime = computeLatestKnownTime(actedOnEvents, run);\n  const { runSpan, spans } = buildSpans(\n    run,\n    groupedEvents,\n    now,\n    latestKnownTime,\n    getStepAttributes\n  );\n  const sortedCascadingSpans = cascadeSpans(runSpan, spans);\n\n  // Compute known duration relative to trace start\n  const traceStartMs = otelTimeToMs(runSpan.startTime);\n  const knownDurationMs = latestKnownTime.getTime() - traceStartMs;\n\n  return {\n    traceId: run.runId,\n    rootSpanId: run.runId,\n    spans: sortedCascadingSpans,\n    resources: [\n      {\n        name: 'workflow',\n        attributes: {\n          'service.name': WORKFLOW_LIBRARY.name,\n        },\n      },\n    ],\n    knownDurationMs: Math.max(0, knownDurationMs),\n    duplicateEventIds,\n  };\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@workflow/web-shared",
   "description": "Shared components for Workflow Observability UI",
-  "version": "5.0.0-beta.46",
+  "version": "5.0.0-beta.48",
   "private": false,
   "files": [
     "dist",
@@ -42,6 +42,9 @@
     "@radix-ui/react-tooltip": "1.2.8",
     "@tailwindcss/postcss": "4",
     "@tootallnate/zstd-wasm": "0.0.2",
+    "@workflow/core": "5.0.0-beta.48",
+    "@workflow/utils": "5.0.0-beta.10",
+    "@workflow/world": "5.0.0-beta.33",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "date-fns": "4.1.0",
@@ -54,21 +57,18 @@
     "sonner": "2.0.7",
     "streamdown": "2.3.0",
     "tailwind-merge": "3.5.0",
-    "tailwindcss": "4",
-    "@workflow/core": "5.0.0-beta.46",
-    "@workflow/utils": "5.0.0-beta.9",
-    "@workflow/world": "5.0.0-beta.31"
+    "tailwindcss": "4"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",
     "@types/node": "22.19.0",
     "@types/react": "19",
     "@types/react-dom": "19",
+    "@workflow/errors": "5.0.0-beta.20",
+    "@workflow/tsconfig": "5.0.0-beta.0",
     "ai": "6.0.116",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.10",
-    "@workflow/errors": "5.0.0-beta.18",
-    "@workflow/tsconfig": "5.0.0-beta.0"
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "build": "tsc && cp src/components/trace-viewer/components/*.module.css dist/components/trace-viewer/components/ && cp src/styles.css dist/styles.css",

package/src/components/event-list-view.tsx

@@ -1007,10 +1007,10 @@ export function EventRow({
   }, []);
 
   // When encryption key changes and this event was previously loaded,
-  // re-load to get decrypted data
+  // re-load to get decrypted data. Keep the encrypted value visible until the
+  // refreshed data arrives so the payload does not flash empty while decrypting.
   useEffect(() => {
     if (encryptionKey && hasAttemptedLoad && onLoadEventData) {
-      setLoadedEventData(null);
       setHasAttemptedLoad(false);
       onLoadEventData(event)
         .then((data) => {

package/src/components/trace-viewer/components/use-alt-held.ts

@@ -0,0 +1,54 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+
+function isAltModifierKey(key: string): boolean {
+  return key === 'Alt' || key === 'AltGraph';
+}
+
+function isTypingTarget(target: EventTarget | null): boolean {
+  return (
+    target instanceof HTMLInputElement ||
+    target instanceof HTMLTextAreaElement ||
+    (target instanceof HTMLElement && target.isContentEditable)
+  );
+}
+
+/**
+ * Whether Alt/Option is held, for the timeline delta overlay.
+ *
+ * preventDefault stops Chrome from taking the menu bar (which kills hover).
+ * Capture-phase keys; pointermove recovers if keydown was missed; blur
+ * clears after Alt+Tab.
+ */
+export function useAltHeld(): { altHeld: boolean } {
+  const [altHeld, setAltHeld] = useState(false);
+
+  useEffect(() => {
+    const onKeyDown = (e: KeyboardEvent): void => {
+      if (!isAltModifierKey(e.key)) return;
+      if (!isTypingTarget(e.target)) {
+        e.preventDefault();
+      }
+      setAltHeld(true);
+    };
+    const onKeyUp = (e: KeyboardEvent): void => {
+      if (isAltModifierKey(e.key)) setAltHeld(false);
+    };
+    const onBlur = (): void => setAltHeld(false);
+    const onPointerMove = (e: PointerEvent): void => setAltHeld(e.altKey);
+
+    window.addEventListener('keydown', onKeyDown, true);
+    window.addEventListener('keyup', onKeyUp, true);
+    window.addEventListener('blur', onBlur);
+    window.addEventListener('pointermove', onPointerMove, true);
+    return () => {
+      window.removeEventListener('keydown', onKeyDown, true);
+      window.removeEventListener('keyup', onKeyUp, true);
+      window.removeEventListener('blur', onBlur);
+      window.removeEventListener('pointermove', onPointerMove, true);
+    };
+  }, []);
+
+  return { altHeld };
+}

package/src/components/trace-viewer/trace-viewer.tsx

@@ -27,6 +27,7 @@ import {
   type TimelineHover,
 } from './components/timeline';
 import { TraceShortcutHelper } from './components/trace-shortcut-helper';
+import { useAltHeld } from './components/use-alt-held';
 import { ROW_HEIGHT_PX, scrollRowIntoView } from './components/use-row-window';
 import { ActiveSpanProvider, useActiveSpan } from './context';
 import { searchSpans } from './search';
@@ -370,29 +371,16 @@ function TraceViewerContent({
     [setActiveSpan, scrollSpanIntoView, cancelPendingZoom, focusViewportOnSpan]
   );
 
-  const [altHeld, setAltHeld] = useState(false);
+  const { altHeld } = useAltHeld();
 
   useEffect(() => {
     const onKeyDown = (e: KeyboardEvent): void => {
       if (e.key === 'Escape') {
         handleClearActiveSpan();
-      } else if (e.key === 'Alt') {
-        setAltHeld(true);
       }
     };
-    const onKeyUp = (e: KeyboardEvent): void => {
-      if (e.key === 'Alt') setAltHeld(false);
-    };
-    const onBlur = (): void => setAltHeld(false);
-
     window.addEventListener('keydown', onKeyDown);
-    window.addEventListener('keyup', onKeyUp);
-    window.addEventListener('blur', onBlur);
-    return () => {
-      window.removeEventListener('keydown', onKeyDown);
-      window.removeEventListener('keyup', onKeyUp);
-      window.removeEventListener('blur', onBlur);
-    };
+    return () => window.removeEventListener('keydown', onKeyDown);
   }, [handleClearActiveSpan]);
 
   const timelineRef = useRef<HTMLDivElement>(null);

package/src/components/trace-viewer.tsx

@@ -8,6 +8,7 @@ import {
 } from './sidebar/sidebar-data-context';
 import { TraceViewerSkeleton } from './trace-viewer/components/trace-viewer-skeleton';
 import { TraceViewer as TraceViewerComponent } from './trace-viewer/trace-viewer';
+import type { GetStepAttributes } from './workflow-traces/trace-span-construction';
 
 const TraceViewer = ({
   run,
@@ -17,6 +18,7 @@ const TraceViewer = ({
   hasMore,
   isLoadingMore,
   loading = false,
+  getStepAttributes,
 }: {
   run: WorkflowRun;
   events: Event[];
@@ -25,6 +27,8 @@ const TraceViewer = ({
   hasMore?: boolean;
   isLoadingMore?: boolean;
   loading?: boolean;
+  /** Adds product-specific attributes to event-derived step span data. */
+  getStepAttributes?: GetStepAttributes;
 }) => {
   const trace: TraceWithMeta | undefined = useMemo(() => {
     if (!run?.runId) {
@@ -35,9 +39,10 @@ const TraceViewer = ({
     // repeats with the whole log in hand.
     return buildTrace(run, events, new Date(), {
       isCompleteHistory: !hasMore,
+      getStepAttributes,
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps -- `new Date()` is intentionally not a dep
-  }, [run, events, hasMore]);
+  }, [run, events, hasMore, getStepAttributes]);
 
   // The sidebar shows one entity's slice of the log, so it takes the trace's
   // answer rather than recomputing one from the slice.

package/src/components/ui/data-inspector.tsx

@@ -344,7 +344,7 @@ function BytesDisplayValue({ display }: { display: BytesDisplay }) {
 // Tree renderer
 // ---------------------------------------------------------------------------
 
-type Entry = [field: string | undefined, value: unknown];
+type Entry = [field: string | undefined, value: unknown, key?: string | number];
 
 interface NodeContext {
   level: number;
@@ -357,10 +357,51 @@ function formatField(field: string): string {
   return field === '' ? '""' : field;
 }
 
+function isGenericIterable(
+  value: unknown
+): value is object & Iterable<unknown> {
+  if (
+    value === null ||
+    (typeof value !== 'object' && typeof value !== 'function') ||
+    Array.isArray(value) ||
+    value instanceof Map ||
+    value instanceof Set
+  ) {
+    return false;
+  }
+  return (
+    typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] ===
+    'function'
+  );
+}
+
+function isEntryIterable(
+  value: object & Iterable<unknown>
+): value is object & Iterable<unknown> & { entries(): Iterable<unknown> } {
+  return typeof (value as { entries?: unknown }).entries === 'function';
+}
+
+function collectEntries(
+  iterable: Iterable<unknown>,
+  asPairs: boolean
+): Entry[] {
+  return Array.from(iterable, (item, index) => {
+    if (asPairs && Array.isArray(item) && item.length >= 2) {
+      return [String(item[0]), collapseRefs(item[1]), index];
+    }
+    return [undefined, collapseRefs(item), index];
+  });
+}
+
+function isSelfIterableIterator(value: object & Iterable<unknown>): boolean {
+  return Object.is(value[Symbol.iterator](), value);
+}
+
 /**
- * Describe an object/array/map/set as an expandable container. Returns null for
- * values that should render as a primitive. `prefix` carries a class name shown
- * before the opening bracket (Map/Set and named class instances).
+ * Describe an object/array/iterable as an expandable container. Returns null
+ * for values that should render as a primitive. `prefix` carries a class name
+ * shown before the opening bracket (Map/Set, generic iterables, and named class
+ * instances).
  */
 function describeContainer(
   value: unknown
@@ -391,6 +432,25 @@ function describeContainer(
       prefix: 'Set',
     };
   }
+  if (isGenericIterable(value)) {
+    const name = (value as { constructor?: { name?: string } }).constructor
+      ?.name;
+    const prefix = name && name !== 'Object' ? name : undefined;
+    if (isEntryIterable(value)) {
+      return {
+        entries: collectEntries(value.entries(), true),
+        open: '{',
+        close: '}',
+        prefix,
+      };
+    }
+    return {
+      entries: collectEntries(value, false),
+      open: '[',
+      close: ']',
+      prefix,
+    };
+  }
   if (value !== null && typeof value === 'object') {
     const name = (value as { constructor?: { name?: string } }).constructor
       ?.name;
@@ -616,9 +676,9 @@ function ExpandableContainer({
       {expanded ? (
         // biome-ignore lint/a11y/useSemanticElements: ARIA tree group is the correct role here
         <ul id={contentsId} className={CLS.childFields} role="group">
-          {entries.map(([childField, childValue], index) => (
+          {entries.map(([childField, childValue, entryKey], index) => (
             <DataRender
-              key={childField ?? index}
+              key={entryKey ?? childField ?? index}
               field={childField}
               value={childValue}
               isLast={index === lastIndex}
@@ -820,8 +880,8 @@ function makeBytesDisplay(display: FormattedStreamChunkDisplay): unknown {
  * non-expandable versions so the renderer doesn't show their internals.
  * Only recurses into plain objects and arrays to avoid stripping class
  * instances (Date, Error, URL, Headers, etc.) that have their own rendering.
- * Map and Set containers are preserved while their contents are prepared for
- * display.
+ * Map and Set contents are prepared here; other iterable contents are prepared
+ * when the renderer traverses them.
  *
  * Exported for testing the typed-array detection path used by hydrated
  * AI agent stream chunks (e.g. `{ delta: new Uint8Array(...) }`).
@@ -962,7 +1022,28 @@ function isSameBytesDisplay(a: BytesDisplay, b: BytesDisplay): boolean {
   );
 }
 
-function isDeepEqual(a: unknown, b: unknown, seen = new WeakMap()): boolean {
+function haveSameIterableValues(
+  a: Iterable<unknown>,
+  b: Iterable<unknown>,
+  seen: WeakMap<object, object>
+): boolean {
+  const aIterator = a[Symbol.iterator]();
+  const bIterator = b[Symbol.iterator]();
+  while (true) {
+    const aResult = aIterator.next();
+    const bResult = bIterator.next();
+    if (aResult.done || bResult.done) {
+      return aResult.done === bResult.done;
+    }
+    if (!isDeepEqual(aResult.value, bResult.value, seen)) return false;
+  }
+}
+
+export function isDeepEqual(
+  a: unknown,
+  b: unknown,
+  seen = new WeakMap()
+): boolean {
   if (Object.is(a, b)) return true;
 
   if (isBytesDisplay(a) || isBytesDisplay(b)) {
@@ -977,6 +1058,21 @@ function isDeepEqual(a: unknown, b: unknown, seen = new WeakMap()): boolean {
     return a.source === b.source && a.flags === b.flags;
   }
 
+  if (isGenericIterable(a) || isGenericIterable(b)) {
+    if (!isGenericIterable(a) || !isGenericIterable(b)) return false;
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+    if (isSelfIterableIterator(a) || isSelfIterableIterator(b)) return false;
+    if (seen.get(a) === b) return true;
+    seen.set(a, b);
+    const aHasEntries = isEntryIterable(a);
+    const bHasEntries = isEntryIterable(b);
+    if (aHasEntries !== bHasEntries) return false;
+    if (aHasEntries && bHasEntries) {
+      return haveSameIterableValues(a.entries(), b.entries(), seen);
+    }
+    return haveSameIterableValues(a, b, seen);
+  }
+
   if (a instanceof Map && b instanceof Map) {
     if (a.size !== b.size) return false;
     for (const [key, value] of a.entries()) {

package/src/components/workflow-traces/trace-span-construction.ts

@@ -150,6 +150,10 @@ export function waitToSpan(
   };
 }
 
+export type GetStepAttributes = (
+  events: Event[]
+) => Record<string, unknown> | undefined;
+
 export const stepEventsToStepEntity = (
   events: Event[]
 ): {
@@ -231,7 +235,11 @@ export const stepEventsToStepEntity = (
 /**
  * Converts step events to an OpenTelemetry Span
  */
-export function stepToSpan(stepEvents: Event[], maxEndTime: Date): Span | null {
+export function stepToSpan(
+  stepEvents: Event[],
+  maxEndTime: Date,
+  getStepAttributes?: GetStepAttributes
+): Span | null {
   const step = stepEventsToStepEntity(stepEvents);
   if (!step) {
     return null;
@@ -242,7 +250,11 @@ export function stepToSpan(stepEvents: Event[], maxEndTime: Date): Span | null {
 
   const attributes = {
     resource: 'step' as const,
-    data: step,
+    data: {
+      ...getStepAttributes?.(stepEvents),
+      // Canonical event-derived fields cannot be overridden by extensions.
+      ...step,
+    },
   };
 
   const resource = 'step';

package/src/lib/duplicate-events.ts

@@ -1,8 +1,9 @@
 import {
+  classifyEntityEvent,
   type EntityEventClass,
   type Event,
-  entityEventClass,
   isSlotEventId,
+  TERMINAL_EVENT_CLASSES,
 } from '@workflow/world';
 
 /**
@@ -10,13 +11,13 @@ import {
  *
  * 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.
+ * `wait_created` / `attr_set` 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
+ * The classification comes from `classifyEntityEvent` in `@workflow/world`,
+ * the same function the runtime keys its own duplicate detection on. What it
+ * cannot share 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
@@ -25,27 +26,11 @@ import {
  * 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
@@ -122,10 +107,13 @@ function foldDuplicates(ordered: readonly Event[]): Set<string> {
   const closedEntities = new Set<string>();
 
   for (const event of ordered) {
-    const eventClass = entityEventClass(event.eventType);
-    if (eventClass === undefined) continue;
+    // Shared with the runtime's own duplicate detection, deliberately: an
+    // event it tracks under no class is one it never reads past, so naming it
+    // here would grey out an event the run acted on.
+    const classification = classifyEntityEvent(event);
+    if (classification === undefined) continue;
 
-    const entity = event.correlationId ?? RUN_ENTITY_KEY;
+    const { eventClass, entity } = classification;
     const classKey = `${eventClass}:${entity}`;
     const repeatsClass = seenClasses.has(classKey);
     const entityWasClosed = closedEntities.has(entity);

package/src/lib/hydration.ts

@@ -228,6 +228,18 @@ export function getWebRevivers(): Revivers {
       if (value.stack !== undefined) error.stack = value.stack;
       return error;
     },
+    StreamError: (value) => {
+      const opts = 'cause' in value ? { cause: value.cause } : undefined;
+      const error = new Error(value.message, opts) as Error & {
+        status?: number;
+        url?: string;
+      };
+      error.name = 'StreamError';
+      if (value.status !== undefined) error.status = value.status;
+      if (value.url !== undefined) error.url = value.url;
+      if (value.stack !== undefined) error.stack = value.stack;
+      return error;
+    },
     DOMException: (value) => {
       // Modern browsers and Node 18+ expose `DOMException` on globalThis.
       // `AbortController.abort()` with no argument synthesizes one as the