@outputai/cli 0.8.2-next.edf06bb.0 → 0.9.1-dev.000c5f3.0

package/dist/api/generated/api.d.ts

@@ -452,6 +452,26 @@ export type GetWorkflowIdRunsRidHistory200 = {
     /** @nullable */
     nextPageToken?: string | null;
 };
+export type GetWorkflowIdHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
+export type GetWorkflowIdRunsRidHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
 export type GetWorkflowCatalogId200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
@@ -1043,6 +1063,65 @@ export type getWorkflowIdRunsRidHistoryResponseError = (getWorkflowIdRunsRidHist
 export type getWorkflowIdRunsRidHistoryResponse = (getWorkflowIdRunsRidHistoryResponseSuccess | getWorkflowIdRunsRidHistoryResponseError);
 export declare const getGetWorkflowIdRunsRidHistoryUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams) => string;
 export declare const getWorkflowIdRunsRidHistory: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryResponse>;
+/**
+ * Opens a persistent SSE connection that delivers Temporal workflow history events in real time. Emits named events: `workflow` (metadata, once), `history` (event batches), `done` (terminal state), `server_error` (post-flush errors). The `done` event carries `{ reason, newRunId? }` where `reason` is the terminal Temporal event type (`WORKFLOW_EXECUTION_COMPLETED`, `WORKFLOW_EXECUTION_FAILED`, `WORKFLOW_EXECUTION_TIMED_OUT`, `WORKFLOW_EXECUTION_CANCELED`, `WORKFLOW_EXECUTION_TERMINATED`, `WORKFLOW_EXECUTION_CONTINUED_AS_NEW`) and `newRunId` is present only when the terminal event chains a follow-on run. `server_error` carries `{ error, message, workflowId, runId }`. Errors before the stream opens are returned as JSON HTTP responses (400/404); once open, failures arrive as a `server_error` event. Supports reconnect via `Last-Event-ID` header or `lastEventId` query param.
+
+ * @summary Stream workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdHistoryStreamResponseSuccess = (getWorkflowIdHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponseError = (getWorkflowIdHistoryStreamResponse400 | getWorkflowIdHistoryStreamResponse404 | getWorkflowIdHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponse = (getWorkflowIdHistoryStreamResponseSuccess | getWorkflowIdHistoryStreamResponseError);
+export declare const getGetWorkflowIdHistoryStreamUrl: (id: string, params?: GetWorkflowIdHistoryStreamParams) => string;
+export declare const getWorkflowIdHistoryStream: (id: string, params?: GetWorkflowIdHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdHistoryStreamResponse>;
+/**
+ * Same as /workflow/{id}/history/stream but targets a specific run ID.
+ * @summary Stream pinned-run workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdRunsRidHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseSuccess = (getWorkflowIdRunsRidHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseError = (getWorkflowIdRunsRidHistoryStreamResponse400 | getWorkflowIdRunsRidHistoryStreamResponse404 | getWorkflowIdRunsRidHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse = (getWorkflowIdRunsRidHistoryStreamResponseSuccess | getWorkflowIdRunsRidHistoryStreamResponseError);
+export declare const getGetWorkflowIdRunsRidHistoryStreamUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams) => string;
+export declare const getWorkflowIdRunsRidHistoryStream: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryStreamResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */

package/dist/api/generated/api.js

@@ -231,6 +231,38 @@ export const getWorkflowIdRunsRidHistory = async (id, rid, params, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdHistoryStreamUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/history/stream?${stringifiedParams}` : `/workflow/${id}/history/stream`;
+};
+export const getWorkflowIdHistoryStream = async (id, params, options) => {
+    return customFetchInstance(getGetWorkflowIdHistoryStreamUrl(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidHistoryStreamUrl = (id, rid, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/runs/${rid}/history/stream?${stringifiedParams}` : `/workflow/${id}/runs/${rid}/history/stream`;
+};
+export const getWorkflowIdRunsRidHistoryStream = async (id, rid, params, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidHistoryStreamUrl(id, rid, params), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.edf06bb.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.9.1-dev.000c5f3.0}
     init: true
     networks:
       - main

package/dist/commands/workflow/history.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class WorkflowHistory extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'run-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        raw: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'include-payloads': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        width: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        color: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private buildHeader;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/history.js

@@ -0,0 +1,99 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { fetchWorkflowHistory } from '#services/workflow_history.js';
+import buildSpanLabels from '#utils/span_labels.js';
+import renderWaterfall, { formatDurationLabel } from '#utils/waterfall.js';
+import { handleApiError } from '#utils/error_handler.js';
+const DEFAULT_WIDTH = 80;
+const OUTPUT_FORMAT = { JSON: 'json', TEXT: 'text' };
+export default class WorkflowHistory extends Command {
+    static description = 'Show a workflow run\'s step timeline as a waterfall (durations and start times)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345',
+        '<%= config.bin %> <%= command.id %> wf-12345 --run-id 2fe0b36b-...',
+        '<%= config.bin %> <%= command.id %> wf-12345 --format json',
+        '<%= config.bin %> <%= command.id %> wf-12345 --raw --include-payloads'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to show history for',
+            required: true
+        })
+    };
+    static flags = {
+        'run-id': Flags.string({
+            char: 'r',
+            description: 'Show a specific run (defaults to the latest run)'
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.TEXT, OUTPUT_FORMAT.JSON],
+            default: OUTPUT_FORMAT.TEXT
+        }),
+        raw: Flags.boolean({
+            description: 'Print the history endpoint\'s raw response (workflow + events)',
+            default: false
+        }),
+        'include-payloads': Flags.boolean({
+            description: 'Include decoded step input/output payloads',
+            default: false
+        }),
+        width: Flags.integer({
+            description: 'Override the detected terminal width'
+        }),
+        color: Flags.boolean({
+            description: 'Colorize the waterfall (use --no-color to disable)',
+            default: true,
+            allowNo: true
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowHistory);
+        const result = await fetchWorkflowHistory({
+            workflowId: args.workflowId,
+            runId: flags['run-id'],
+            includePayloads: flags['include-payloads']
+        });
+        if (flags.raw) {
+            this.log(JSON.stringify({
+                workflow: result.workflow,
+                runId: result.runId,
+                events: result.events
+            }, null, 2));
+            return;
+        }
+        if (flags.format === OUTPUT_FORMAT.JSON) {
+            this.log(JSON.stringify({
+                workflow: result.workflow,
+                runId: result.runId,
+                totalDurationMs: result.totalDurationMs,
+                spans: result.spans
+            }, null, 2));
+            return;
+        }
+        const labels = buildSpanLabels(result.spans);
+        const width = flags.width ?? process.stdout.columns ?? DEFAULT_WIDTH;
+        const color = flags.color && !process.env.NO_COLOR &&
+            (!!process.env.FORCE_COLOR || process.stdout.isTTY === true);
+        this.log(renderWaterfall(result.spans, result.totalDurationMs, {
+            width,
+            color,
+            labels,
+            header: this.buildHeader(args.workflowId, result.runId, result.workflow?.status, result.totalDurationMs)
+        }));
+        // Failure reasons live in the payloads the server strips by default, so a
+        // failed run shows red bars but no messages until payloads are requested.
+        if (!flags['include-payloads'] && result.spans.some(span => span.status === 'failed')) {
+            this.log('\nSome steps failed — re-run with --include-payloads to see their error messages.');
+        }
+    }
+    buildHeader(workflowId, runId, status, totalDurationMs) {
+        const shortRun = runId ? runId.slice(0, 8) : 'unknown';
+        return `${workflowId} · run ${shortRun} · ${status ?? 'unknown'} · ${formatDurationLabel(totalDurationMs)}`;
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow ID.'
+        });
+    }
+}

package/dist/commands/workflow/history.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/workflow/history.spec.js

@@ -0,0 +1,26 @@
+import { describe, it, expect, vi } from 'vitest';
+// Isolate the command module from the API/service layer at import time.
+vi.mock('../../services/workflow_history.js', () => ({
+    fetchWorkflowHistory: vi.fn()
+}));
+describe('workflow history command', () => {
+    it('exports a valid OCLIF command with a workflowId arg', async () => {
+        const WorkflowHistory = (await import('./history.js')).default;
+        expect(WorkflowHistory).toBeDefined();
+        expect(WorkflowHistory.description).toContain('waterfall');
+        expect(WorkflowHistory.args).toHaveProperty('workflowId');
+        expect(WorkflowHistory.args.workflowId.required).toBe(true);
+    });
+    it('declares the expected flags and defaults', async () => {
+        const WorkflowHistory = (await import('./history.js')).default;
+        const flags = WorkflowHistory.flags;
+        expect(flags).toHaveProperty('run-id');
+        expect(flags).toHaveProperty('raw');
+        expect(flags).toHaveProperty('include-payloads');
+        expect(flags).toHaveProperty('color');
+        expect(flags).toHaveProperty('width');
+        expect(flags.format.options).toEqual(['text', 'json']);
+        expect(flags.format.default).toBe('text');
+        expect(flags.raw.default).toBe(false);
+    });
+});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.8.2-next.edf06bb.0"
+    "framework": "0.9.1-dev.000c5f3.0"
 }

package/dist/services/workflow_history/correlator.d.ts

@@ -0,0 +1,26 @@
+export type SpanStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type SpanKind = 'activity' | 'child_workflow';
+export interface Span {
+    id: string;
+    name: string;
+    technicalName: string;
+    description: string | null;
+    status: SpanStatus;
+    kind: SpanKind;
+    attempt: number;
+    startedAt: string | null;
+    scheduledAt: string | null;
+    completedAt: string | null;
+    startOffsetMs: number;
+    endOffsetMs: number;
+    durationMs: number;
+    failureMessage: string | null;
+    input?: unknown;
+    output?: unknown;
+}
+export type HistoryEvent = Record<string, unknown>;
+/**
+ * @param events - flat Temporal history events, in chronological order
+ * @param workflowStartTimeMs - epoch ms used as the timeline origin (0 offset)
+ */
+export declare function correlate(events: HistoryEvent[], workflowStartTimeMs: number | null): Span[];

package/dist/services/workflow_history/correlator.js

@@ -0,0 +1,261 @@
+/**
+ * Correlates a flat list of Temporal history events into per-activity spans.
+ *
+ * Each ACTIVITY_TASK_SCHEDULED event opens a span (its eventId IS the
+ * scheduledEventId every subsequent ACTIVITY_TASK_* event for the same activity
+ * references). STARTED, COMPLETED, FAILED, TIMED_OUT, and CANCELED events extend
+ * that span. Spans without a terminal event are 'running' (if STARTED was seen)
+ * or 'pending'.
+ *
+ * Child workflows follow the same pattern but with their own event family:
+ * START_CHILD_WORKFLOW_EXECUTION_INITIATED opens the span, then
+ * CHILD_WORKFLOW_EXECUTION_STARTED / _COMPLETED / _FAILED / _TIMED_OUT /
+ * _CANCELED / _TERMINATED reference it via `initiatedEventId`.
+ *
+ * Pure function — no I/O. A TypeScript port of Atlas's
+ * `OutputWorkflows::WorkflowHistory::Correlator` (Ruby). Kept structurally
+ * faithful so the two stay easy to diff. The CLI has no step catalog, so a
+ * span's display name is the humanized step name rather than a catalog label.
+ */
+import { capitalCase } from 'change-case';
+// Framework-level activities the user doesn't care about — Output's own trace
+// destination resolution and the lifecycle webhook back to Atlas.
+const NOISE_STEP_PREFIXES = ['__internal#'];
+const NOISE_STEP_EXACT = ['$shared#callWebhook'];
+const ACTIVITY_TERMINAL_TYPES = [
+    'ACTIVITY_TASK_COMPLETED', 'ACTIVITY_TASK_FAILED',
+    'ACTIVITY_TASK_TIMED_OUT', 'ACTIVITY_TASK_CANCELED'
+];
+const CHILD_TERMINAL_TYPES = [
+    'CHILD_WORKFLOW_EXECUTION_COMPLETED', 'CHILD_WORKFLOW_EXECUTION_FAILED',
+    'CHILD_WORKFLOW_EXECUTION_TIMED_OUT', 'CHILD_WORKFLOW_EXECUTION_CANCELED',
+    'CHILD_WORKFLOW_EXECUTION_TERMINATED', 'START_CHILD_WORKFLOW_EXECUTION_FAILED'
+];
+function eventTypeName(event) {
+    return event.eventTypeName ?? '';
+}
+function eventId(event) {
+    return String(event.eventId);
+}
+function eventAttributes(event) {
+    const key = event && Object.keys(event).find(k => k.endsWith('EventAttributes'));
+    return key ? event[key] : undefined;
+}
+// Temporal's int64 fields arrive as either a String (the API serializer
+// stringifies scheduledEventId / startedEventId) or a raw protobuf Long struct
+// `{ low, high, unsigned }` (initiatedEventId, etc). Normalize to a String key
+// so both shapes match the opener event's stringified eventId.
+function normalizeEventId(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value || null;
+    }
+    if (typeof value === 'object' && 'low' in value) {
+        const low = value.low;
+        return low === null || low === undefined ? null : String(low);
+    }
+    return String(value) || null;
+}
+function scheduledEventIdFor(event) {
+    return normalizeEventId(eventAttributes(event)?.scheduledEventId);
+}
+function initiatedEventIdFor(event) {
+    return normalizeEventId(eventAttributes(event)?.initiatedEventId);
+}
+// For the noise filter: the full `workflow#step` name (prefixes/exacts match it).
+function fullStepName(scheduled) {
+    const attrs = eventAttributes(scheduled) ?? {};
+    return attrs.activityType?.name ??
+        attrs.stepName ??
+        'unknown';
+}
+// For display: the bare step name (segment after `#`). The API serializer
+// already exposes this as `stepName`; fall back to splitting `activityType.name`.
+function cleanStepName(scheduled) {
+    const attrs = eventAttributes(scheduled) ?? {};
+    const explicit = attrs.stepName;
+    if (explicit) {
+        return explicit;
+    }
+    const full = attrs.activityType?.name;
+    if (full) {
+        return full.includes('#') ? full.split('#').pop() : full;
+    }
+    return 'unknown';
+}
+function isNoise(stepName) {
+    return NOISE_STEP_EXACT.includes(stepName) ||
+        NOISE_STEP_PREFIXES.some(prefix => stepName.startsWith(prefix));
+}
+function failureMessageOf(attrs) {
+    const failure = attrs.failure;
+    return failure?.message ?? null;
+}
+function attemptFor(started) {
+    return eventAttributes(started ?? undefined)?.attempt ?? 1;
+}
+function statusFor(started, terminalStatus) {
+    if (terminalStatus) {
+        return terminalStatus;
+    }
+    return started ? 'running' : 'pending';
+}
+function parseTime(value) {
+    if (value === null || value === undefined || value === '') {
+        return null;
+    }
+    return String(value);
+}
+function toMs(iso) {
+    if (!iso) {
+        return null;
+    }
+    const ms = Date.parse(iso);
+    return Number.isNaN(ms) ? null : ms;
+}
+// Offset math relative to the workflow start (timeline origin). Mirrors
+// Atlas's Span#start_offset_ms / #end_offset_ms / #duration_ms.
+function withOffsets(span, startMs) {
+    const startAnchor = toMs(span.startedAt) ?? toMs(span.scheduledAt);
+    const startOffsetMs = startMs !== null && startAnchor !== null ? Math.round(startAnchor - startMs) : 0;
+    const endAnchor = toMs(span.completedAt) ?? toMs(span.startedAt);
+    const endOffsetMs = startMs !== null && endAnchor !== null ? Math.round(endAnchor - startMs) : startOffsetMs;
+    return { ...span, startOffsetMs, endOffsetMs, durationMs: endOffsetMs - startOffsetMs };
+}
+function resolveActivityTerminal(terminal) {
+    if (!terminal) {
+        return {};
+    }
+    const attrs = eventAttributes(terminal) ?? {};
+    const completedAt = parseTime(terminal.eventTime);
+    switch (eventTypeName(terminal)) {
+        case 'ACTIVITY_TASK_COMPLETED':
+            return { status: 'completed', completedAt, output: attrs.result };
+        case 'ACTIVITY_TASK_FAILED':
+            return { status: 'failed', completedAt, failureMessage: failureMessageOf(attrs) };
+        case 'ACTIVITY_TASK_TIMED_OUT':
+            return { status: 'failed', completedAt, failureMessage: 'Timed out' };
+        case 'ACTIVITY_TASK_CANCELED':
+            return { status: 'failed', completedAt, failureMessage: 'Canceled' };
+        default:
+            return {};
+    }
+}
+function resolveChildTerminal(terminal) {
+    if (!terminal) {
+        return {};
+    }
+    const attrs = eventAttributes(terminal) ?? {};
+    const completedAt = parseTime(terminal.eventTime);
+    switch (eventTypeName(terminal)) {
+        case 'CHILD_WORKFLOW_EXECUTION_COMPLETED':
+            return { status: 'completed', completedAt, output: attrs.result };
+        case 'CHILD_WORKFLOW_EXECUTION_FAILED':
+            return { status: 'failed', completedAt, failureMessage: failureMessageOf(attrs) };
+        case 'CHILD_WORKFLOW_EXECUTION_TIMED_OUT':
+            return { status: 'failed', completedAt, failureMessage: 'Timed out' };
+        case 'CHILD_WORKFLOW_EXECUTION_CANCELED':
+            return { status: 'failed', completedAt, failureMessage: 'Canceled' };
+        case 'CHILD_WORKFLOW_EXECUTION_TERMINATED':
+            return { status: 'failed', completedAt, failureMessage: 'Terminated' };
+        case 'START_CHILD_WORKFLOW_EXECUTION_FAILED':
+            return { status: 'failed', completedAt, failureMessage: attrs.cause || 'Failed to start' };
+        default:
+            return {};
+    }
+}
+function buildActivitySpan(id, slot, startMs) {
+    const { scheduled, started, terminal } = slot;
+    const scheduledAttrs = eventAttributes(scheduled) ?? {};
+    const terminalFields = resolveActivityTerminal(terminal);
+    return withOffsets({
+        id,
+        name: capitalCase(cleanStepName(scheduled)),
+        technicalName: fullStepName(scheduled),
+        description: null,
+        status: statusFor(started, terminalFields.status),
+        kind: 'activity',
+        attempt: attemptFor(started),
+        input: scheduledAttrs.input,
+        output: terminalFields.output,
+        startedAt: parseTime(started?.eventTime),
+        scheduledAt: parseTime(scheduled.eventTime),
+        completedAt: terminalFields.completedAt ?? null,
+        failureMessage: terminalFields.failureMessage ?? null
+    }, startMs);
+}
+// Child workflow spans render from the initiated event time so the full child
+// duration is visible (matching Temporal's own UI). Pending children anchor at
+// initiated time rather than null, else they'd all stack at offset 0.
+function buildChildSpan(id, slot, startMs) {
+    const { scheduled, started, terminal } = slot;
+    const scheduledAttrs = eventAttributes(scheduled) ?? {};
+    const workflowType = scheduledAttrs.workflowType?.name ??
+        'child_workflow';
+    const terminalFields = resolveChildTerminal(terminal);
+    return withOffsets({
+        id: `child-${id}`,
+        name: capitalCase(workflowType),
+        technicalName: workflowType,
+        description: null,
+        status: statusFor(started, terminalFields.status),
+        kind: 'child_workflow',
+        attempt: 1,
+        input: scheduledAttrs.input,
+        output: terminalFields.output,
+        startedAt: parseTime(scheduled.eventTime),
+        scheduledAt: parseTime(scheduled.eventTime),
+        completedAt: terminalFields.completedAt ?? null,
+        failureMessage: terminalFields.failureMessage ?? null
+    }, startMs);
+}
+function emptySlot(opener) {
+    return { scheduled: opener, started: null, terminal: null };
+}
+function attach(slots, event, key) {
+    if (!key) {
+        return;
+    }
+    const slot = slots.get(key);
+    if (!slot) {
+        return;
+    }
+    if (eventTypeName(event).endsWith('_STARTED')) {
+        slot.started = event;
+    }
+    else {
+        slot.terminal = event;
+    }
+}
+/**
+ * @param events - flat Temporal history events, in chronological order
+ * @param workflowStartTimeMs - epoch ms used as the timeline origin (0 offset)
+ */
+export function correlate(events, workflowStartTimeMs) {
+    const activities = new Map();
+    const children = new Map();
+    for (const event of events) {
+        const type = eventTypeName(event);
+        if (type === 'ACTIVITY_TASK_SCHEDULED') {
+            activities.set(eventId(event), emptySlot(event));
+        }
+        else if (type === 'ACTIVITY_TASK_STARTED' || ACTIVITY_TERMINAL_TYPES.includes(type)) {
+            attach(activities, event, scheduledEventIdFor(event));
+        }
+        else if (type === 'START_CHILD_WORKFLOW_EXECUTION_INITIATED') {
+            children.set(eventId(event), emptySlot(event));
+        }
+        else if (type === 'CHILD_WORKFLOW_EXECUTION_STARTED' || CHILD_TERMINAL_TYPES.includes(type)) {
+            attach(children, event, initiatedEventIdFor(event));
+        }
+    }
+    const activitySpans = [...activities.entries()]
+        .filter(([, slot]) => !isNoise(fullStepName(slot.scheduled)))
+        .map(([id, slot]) => buildActivitySpan(id, slot, workflowStartTimeMs));
+    const childSpans = [...children.entries()]
+        .map(([id, slot]) => buildChildSpan(id, slot, workflowStartTimeMs))
+        .filter(span => !isNoise(span.technicalName));
+    return [...activitySpans, ...childSpans].sort((a, b) => a.startOffsetMs - b.startOffsetMs);
+}

package/dist/services/workflow_history/correlator.spec.d.ts

@@ -0,0 +1 @@
+export {};