@temelj/workflow 0.0.0-alpha.1

package/dist/engine/stream.mjs

@@ -0,0 +1,333 @@
+import { WorkflowOptionsError } from "../errors/base.mjs";
+import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
+import { getRequiredRun, isNonNegativeSafeInteger } from "../utility.mjs";
+import { WorkflowStreamError, WorkflowStreamNotFoundError } from "../errors/stream.mjs";
+import "../errors/mod.mjs";
+import { nonNegativeTimerDelay } from "../timer.mjs";
+import { serializeError, toOptionalPersistedValue, toPersistedValue } from "./serialization.mjs";
+import { WorkflowHistory } from "../history/mod.mjs";
+import "./state.mjs";
+import { makeStreamChunkCursorKey, pageItems } from "../pagination.mjs";
+import { resolveWorkflowCommandIdentity } from "./command-identity.mjs";
+import { appendDurableStepStartedEvent, appendDurableStepTerminalEvent } from "./durable-command.mjs";
+import { deepEquals } from "@temelj/value";
+//#region src/engine/stream.ts
+const DEFAULT_MAXIMUM_STREAM_CHUNKS = 1e3;
+const DEFAULT_STREAM_FOLLOW_POLL_INTERVAL = Temporal.Duration.from({ milliseconds: 100 });
+async function getStreamInfoForRun(service, runId, streamIdOrName) {
+	await getRequiredRun(service.store, runId);
+	return getStreamInfoFromHistory(runId, new WorkflowHistory(await service.store.getEvents(runId)), streamIdOrName);
+}
+async function readStreamForRun(service, runId, streamIdOrName, readOptions) {
+	await getRequiredRun(service.store, runId);
+	return readStreamFromHistory(runId, new WorkflowHistory(await service.store.getEvents(runId)), streamIdOrName, readOptions);
+}
+async function readStreamPageForRun(service, runId, streamIdOrName, readOptions) {
+	const stream = await readStreamForRun(service, runId, streamIdOrName, readOptions);
+	return {
+		...stream,
+		chunks: pageItems(stream.chunks, readOptions, "Workflow stream page", makeStreamChunkCursorKey)
+	};
+}
+function followStreamForRun(service, runId, streamIdOrName, followOptions) {
+	return followStream(async (readOptions) => await readStreamForRun(service, runId, streamIdOrName, readOptions), followOptions, { waitForChange: async ({ signal }) => await waitForStreamStorageChange(service, runId, signal) });
+}
+async function waitForStreamForRun(service, runId, streamIdOrName, waitOptions) {
+	return await waitForStream(async () => await getStreamInfoForRun(service, runId, streamIdOrName), waitOptions, { waitForChange: async ({ signal }) => await waitForStreamStorageChange(service, runId, signal) });
+}
+async function waitForStreamChunkForRun(service, runId, streamIdOrName, afterIndex, waitOptions) {
+	return await waitForStreamChunk(async (readOptions) => await readStreamForRun(service, runId, streamIdOrName, readOptions), afterIndex, waitOptions, { waitForChange: async ({ signal }) => await waitForStreamStorageChange(service, runId, signal) });
+}
+async function waitForStreamTerminalForRun(service, runId, streamIdOrName, waitOptions) {
+	return await waitForStreamTerminal(async () => await getStreamInfoForRun(service, runId, streamIdOrName), waitOptions, { waitForChange: async ({ signal }) => await waitForStreamStorageChange(service, runId, signal) });
+}
+async function waitForStreamStorageChange(service, runId, signal) {
+	await service.store.waitForEventHistoryChange(runId, { signal });
+}
+function createWorkflowStepStreamApi(environment) {
+	const { history } = environment;
+	return { create(commandId, options = {}) {
+		return createStream(environment, resolveWorkflowCommandIdentity(history, "stream", commandId), commandId, options);
+	} };
+}
+function createStream(environment, identity, name, options = {}) {
+	return new Stream(environment, identity, name, options);
+}
+var Stream = class {
+	id;
+	name;
+	contentType;
+	metadata;
+	#environment;
+	#identity;
+	#maximumChunks;
+	#persistedMetadata;
+	#nextChunkIndex = 0;
+	constructor(environment, identity, name, options = {}) {
+		const streamId = options.id ?? name;
+		const maximumChunks = options.maximumChunks !== void 0 ? options.maximumChunks : environment.limits.maximumStreamChunks ?? DEFAULT_MAXIMUM_STREAM_CHUNKS;
+		const persistedMetadata = toOptionalPersistedValue(options.metadata, `workflow stream ${streamId} metadata`, environment.limits);
+		const started = environment.history.startedStream(identity.id);
+		if (started !== void 0) requireStreamReplayMatches(identity, started, {
+			streamId,
+			contentType: options.contentType,
+			metadata: persistedMetadata
+		});
+		this.#environment = environment;
+		this.#identity = identity;
+		this.id = streamId;
+		this.name = name;
+		if (options.contentType !== void 0) this.contentType = options.contentType;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+		this.#maximumChunks = maximumChunks;
+		this.#persistedMetadata = persistedMetadata;
+	}
+	async write(chunk) {
+		await ensureStreamStarted(this.#environment, this.#identity, this.id, this.contentType, this.#persistedMetadata);
+		const persistedChunk = toPersistedValue(chunk, `workflow stream ${this.id} chunk`, this.#environment.limits);
+		const existing = this.#environment.history.streamChunk(this.#identity.id, this.#nextChunkIndex);
+		const index = this.#nextChunkIndex;
+		this.#nextChunkIndex++;
+		if (existing !== void 0) {
+			requireStreamChunkReplayMatches(this.#identity, existing.index, existing.chunk, persistedChunk);
+			return;
+		}
+		requireStreamOpen(this.#environment, this.#identity.id, this.id);
+		if (index >= this.#maximumChunks) WorkflowStreamError.chunkLimitExceeded(this.id, this.#maximumChunks);
+		await appendDurableStepTerminalEvent(this.#environment, {
+			kind: "stream_chunk",
+			timestamp: this.#environment.now(),
+			stepId: this.#identity.id,
+			stepName: this.#identity.name,
+			streamId: this.id,
+			index,
+			chunk: persistedChunk
+		});
+	}
+	async close() {
+		await ensureStreamStarted(this.#environment, this.#identity, this.id, this.contentType, this.#persistedMetadata);
+		if (this.#environment.history.closedStream(this.#identity.id) !== void 0) return;
+		requireStreamOpen(this.#environment, this.#identity.id, this.id);
+		await appendDurableStepTerminalEvent(this.#environment, {
+			kind: "stream_closed",
+			timestamp: this.#environment.now(),
+			stepId: this.#identity.id,
+			stepName: this.#identity.name,
+			streamId: this.id
+		});
+	}
+	async error(error) {
+		await ensureStreamStarted(this.#environment, this.#identity, this.id, this.contentType, this.#persistedMetadata);
+		if (this.#environment.history.failedStream(this.#identity.id) !== void 0) return;
+		requireStreamOpen(this.#environment, this.#identity.id, this.id);
+		await appendDurableStepTerminalEvent(this.#environment, {
+			kind: "stream_failed",
+			timestamp: this.#environment.now(),
+			stepId: this.#identity.id,
+			stepName: this.#identity.name,
+			streamId: this.id,
+			error: serializeError(error)
+		});
+	}
+};
+function readStream(runId, events, streamIdOrName, options = {}) {
+	return readStreamFromHistory(runId, new WorkflowHistory(events), streamIdOrName, options);
+}
+function readStreamFromHistory(runId, history, streamIdOrName, options = {}) {
+	if (options.fromIndex !== void 0 && options.fromTail !== void 0) WorkflowStreamError.readOffsetConflict();
+	const projection = requireStreamProjectionFromHistory(history, streamIdOrName);
+	const info = getStreamInfoFromProjection(runId, projection);
+	const fromIndex = options.fromTail === void 0 ? options.fromIndex ?? 0 : Math.max(0, info.chunkCount - options.fromTail);
+	const chunks = projection.chunks.filter((chunk) => chunk.event.index >= fromIndex).map((chunk) => ({
+		index: chunk.event.index,
+		timestamp: chunk.event.timestamp,
+		value: chunk.event.chunk
+	})).sort((left, right) => left.index - right.index).slice(0, options.maxChunks);
+	return {
+		...info,
+		chunks
+	};
+}
+async function* followStream(read, options = {}, waitOptions = {}) {
+	if (options.fromIndex !== void 0 && options.fromTail !== void 0) WorkflowStreamError.readOffsetConflict();
+	const pollInterval = options.pollInterval ?? DEFAULT_STREAM_FOLLOW_POLL_INTERVAL;
+	const maxChunks = options.pageSize ?? options.maxChunks;
+	let nextIndex = options.fromIndex;
+	let initialFromTail = options.fromTail;
+	while (true) {
+		if (options.signal?.aborted) return;
+		const stream = await read({
+			...nextIndex === void 0 ? {} : { fromIndex: nextIndex },
+			...nextIndex === void 0 && initialFromTail !== void 0 ? { fromTail: initialFromTail } : {},
+			...maxChunks === void 0 ? {} : { maxChunks }
+		});
+		initialFromTail = void 0;
+		for (const chunk of stream.chunks) {
+			if (options.signal?.aborted) return;
+			nextIndex = chunk.index + 1;
+			yield {
+				kind: "chunk",
+				runId: stream.runId,
+				streamId: stream.id,
+				streamName: stream.name,
+				chunk
+			};
+		}
+		if (nextIndex !== void 0 && nextIndex < stream.chunkCount) continue;
+		if (stream.status !== "open") {
+			if (options.includeTerminal !== false) yield {
+				kind: stream.status,
+				runId: stream.runId,
+				streamId: stream.id,
+				streamName: stream.name,
+				info: {
+					runId: stream.runId,
+					id: stream.id,
+					name: stream.name,
+					status: stream.status,
+					createdAt: stream.createdAt,
+					updatedAt: stream.updatedAt,
+					...stream.contentType === void 0 ? {} : { contentType: stream.contentType },
+					...stream.metadata === void 0 ? {} : { metadata: stream.metadata },
+					chunkCount: stream.chunkCount,
+					...stream.lastIndex === void 0 ? {} : { lastIndex: stream.lastIndex },
+					...stream.error === void 0 ? {} : { error: stream.error }
+				}
+			};
+			return;
+		}
+		await waitForStreamChangeOrPoll(nonNegativeTimerDelay(pollInterval, "Workflow stream follow pollInterval").clampedDelay, options.signal, waitOptions.waitForChange);
+	}
+}
+async function waitForStream(readInfo, options = {}, waitOptions = {}) {
+	while (true) {
+		if (options.signal?.aborted) return;
+		try {
+			return await readInfo();
+		} catch (error) {
+			if (!WorkflowStreamNotFoundError.isNotFound(error)) throw error;
+		}
+		await waitForStreamChangeOrPoll(nonNegativeTimerDelay(options.pollInterval ?? DEFAULT_STREAM_FOLLOW_POLL_INTERVAL, "Workflow stream wait pollInterval").clampedDelay, options.signal, waitOptions.waitForChange);
+	}
+}
+async function waitForStreamChunk(read, afterIndex, options = {}, waitOptions = {}) {
+	if (!isNonNegativeSafeInteger(afterIndex)) WorkflowOptionsError.nonNegativeSafeInteger("Workflow stream chunk wait afterIndex");
+	while (true) {
+		if (options.signal?.aborted) return;
+		const stream = await read({ fromIndex: afterIndex + 1 });
+		const chunk = stream.chunks[0];
+		if (chunk !== void 0) return chunk;
+		if (stream.status !== "open") return;
+		await waitForStreamChangeOrPoll(nonNegativeTimerDelay(options.pollInterval ?? DEFAULT_STREAM_FOLLOW_POLL_INTERVAL, "Workflow stream wait pollInterval").clampedDelay, options.signal, waitOptions.waitForChange);
+	}
+}
+async function waitForStreamTerminal(readInfo, options = {}, waitOptions = {}) {
+	while (true) {
+		if (options.signal?.aborted === true) return;
+		const info = await readInfo();
+		if (info.status !== "open") return info;
+		await waitForStreamChangeOrPoll(nonNegativeTimerDelay(options.pollInterval ?? DEFAULT_STREAM_FOLLOW_POLL_INTERVAL, "Workflow stream wait pollInterval").clampedDelay, options.signal, waitOptions.waitForChange);
+	}
+}
+function getStreamInfo(runId, events, streamIdOrName) {
+	return getStreamInfoFromHistory(runId, new WorkflowHistory(events), streamIdOrName);
+}
+function getStreamInfoFromHistory(runId, history, streamIdOrName) {
+	return getStreamInfoFromProjection(runId, requireStreamProjectionFromHistory(history, streamIdOrName));
+}
+function requireStreamProjectionFromHistory(history, streamIdOrName) {
+	const projection = history.streamProjection(streamIdOrName);
+	if (projection === void 0) WorkflowStreamNotFoundError.notFound(streamIdOrName);
+	return projection;
+}
+function getStreamInfoFromProjection(runId, projection) {
+	const { started, chunks, closed, failed } = projection;
+	requireStreamEventOrder(projection);
+	const latestChunk = chunks.at(-1)?.event;
+	return {
+		runId,
+		id: started.streamId,
+		name: started.stepName,
+		status: failed === void 0 ? closed === void 0 ? "open" : "closed" : "failed",
+		createdAt: started.timestamp,
+		updatedAt: failed?.event.timestamp ?? closed?.event.timestamp ?? latestChunk?.timestamp ?? started.timestamp,
+		...started.contentType === void 0 ? {} : { contentType: started.contentType },
+		...started.metadata === void 0 ? {} : { metadata: started.metadata },
+		chunkCount: chunks.length,
+		...latestChunk === void 0 ? {} : { lastIndex: latestChunk.index },
+		...failed === void 0 ? {} : { error: failed.event.error }
+	};
+}
+function requireStreamEventOrder(projection) {
+	const { started, chunks, closed, failed } = projection;
+	for (const [index, chunk] of chunks.entries()) if (chunk.event.index !== index) WorkflowStreamError.nonContiguousChunkIndex(started.streamId, chunk.event.index, index);
+	const terminal = earliestStreamTerminalEvent(closed, failed);
+	if (terminal === void 0) return;
+	const lateChunk = chunks.find((chunk) => chunk.index > terminal.index);
+	if (lateChunk !== void 0) WorkflowStreamError.chunkAfterTerminal(started.streamId, lateChunk.event.index, terminal.event.kind);
+}
+function earliestStreamTerminalEvent(closed, failed) {
+	if (closed === void 0) return failed;
+	if (failed === void 0) return closed;
+	return closed.index <= failed.index ? closed : failed;
+}
+async function ensureStreamStarted(environment, identity, streamId, contentType, metadata) {
+	if (environment.history.startedStream(identity.id) !== void 0) return;
+	await appendDurableStepStartedEvent(environment, {
+		kind: "stream_started",
+		timestamp: environment.now(),
+		stepId: identity.id,
+		stepName: identity.name,
+		count: identity.count,
+		streamId,
+		...contentType === void 0 ? {} : { contentType },
+		...metadata === void 0 ? {} : { metadata }
+	});
+}
+async function sleepForStreamFollow(milliseconds, signal) {
+	if (milliseconds === 0 || signal?.aborted) return;
+	await new Promise((resolve) => {
+		const timer = setTimeout(resolve, milliseconds);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			resolve();
+		}, { once: true });
+	});
+}
+async function waitForStreamChangeOrPoll(milliseconds, signal, waitForChange) {
+	if (waitForChange === void 0) {
+		await sleepForStreamFollow(milliseconds, signal);
+		return;
+	}
+	const controller = new AbortController();
+	const abort = () => {
+		controller.abort();
+	};
+	signal?.addEventListener("abort", abort, { once: true });
+	try {
+		if (signal?.aborted === true) return;
+		await Promise.race([sleepForStreamFollow(milliseconds, controller.signal), waitForChange({ signal: controller.signal })]);
+	} finally {
+		signal?.removeEventListener("abort", abort);
+		controller.abort();
+	}
+}
+function requireStreamOpen(environment, stepId, streamId) {
+	if (environment.history.closedStream(stepId) !== void 0 || environment.history.failedStream(stepId) !== void 0) WorkflowStreamError.alreadyClosed(streamId);
+}
+function requireStreamReplayMatches(identity, recorded, next) {
+	if (recorded.stepId === identity.id && recorded.stepName === identity.name && recorded.streamId === next.streamId && recorded.contentType === next.contentType && deepEquals(recorded.metadata, next.metadata)) return;
+	WorkflowReplayDivergenceError.diverged(`recorded stream ${recorded.stepId} does not match replayed stream ${identity.id}`, {
+		expectedStepId: recorded.stepId,
+		actualStepId: identity.id
+	});
+}
+function requireStreamChunkReplayMatches(identity, index, recorded, next) {
+	if (deepEquals(recorded, next)) return;
+	WorkflowReplayDivergenceError.diverged(`recorded stream ${identity.id} chunk ${index} does not match replayed chunk`, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+//#endregion
+export { createStream, createWorkflowStepStreamApi, followStream, followStreamForRun, getStreamInfo, getStreamInfoForRun, readStream, readStreamForRun, readStreamPageForRun, waitForStream, waitForStreamChunk, waitForStreamChunkForRun, waitForStreamForRun, waitForStreamTerminal, waitForStreamTerminalForRun };

package/dist/engine/summary/active-events.d.mts

@@ -0,0 +1,34 @@
+import { MessageId } from "../../types/message-id.mjs";
+import { StepId } from "../../types/step-id.mjs";
+import { StreamId } from "../../types/stream-id.mjs";
+import "../../types/step.mjs";
+import { EventRecord } from "../../types/events.mjs";
+//#region src/engine/summary/active-events.d.ts
+interface ActiveWorkflowStreamSummary {
+  readonly stepId: StepId;
+  readonly stepName: string;
+  readonly streamId: StreamId;
+  readonly startedAt: Temporal.Instant;
+  readonly chunkCount: number;
+}
+interface ActiveWorkflowHookSummary {
+  readonly stepId: StepId;
+  readonly name: string;
+  readonly messageId: MessageId;
+  readonly source: "hook" | "webhook";
+  readonly startedAt: Temporal.Instant;
+  readonly timeoutAt?: Temporal.Instant;
+}
+interface ActiveWorkflowEventSummary {
+  readonly streams: readonly ActiveWorkflowStreamSummary[];
+  readonly hooks: readonly ActiveWorkflowHookSummary[];
+}
+interface ActiveWorkflowEventSummaryReducer {
+  addEvent(event: EventRecord): void;
+  finish(): ActiveWorkflowEventSummary;
+}
+/** Creates a reducer for active stream and hook events within a single workflow run. */
+declare function createActiveWorkflowEventSummaryReducer(): ActiveWorkflowEventSummaryReducer;
+declare function activeWorkflowEvents(events: readonly EventRecord[]): ActiveWorkflowEventSummary;
+//#endregion
+export { ActiveWorkflowEventSummary, ActiveWorkflowEventSummaryReducer, ActiveWorkflowHookSummary, ActiveWorkflowStreamSummary, activeWorkflowEvents, createActiveWorkflowEventSummaryReducer };

package/dist/engine/summary/active-events.mjs

@@ -0,0 +1,69 @@
+//#region src/engine/summary/active-events.ts
+/** Creates a reducer for active stream and hook events within a single workflow run. */
+function createActiveWorkflowEventSummaryReducer() {
+	const streams = /* @__PURE__ */ new Map();
+	const terminalStreamStepIds = /* @__PURE__ */ new Set();
+	const hooks = /* @__PURE__ */ new Map();
+	const terminalHookStepIds = /* @__PURE__ */ new Set();
+	return {
+		addEvent(event) {
+			addActiveStreamEvent(streams, terminalStreamStepIds, event);
+			addActiveHookEvent(hooks, terminalHookStepIds, event);
+		},
+		finish() {
+			return {
+				streams: [...streams.values()].filter((stream) => isActiveStream(stream, terminalStreamStepIds)),
+				hooks: [...hooks.values()].filter((hook) => isActiveHook(hook, terminalHookStepIds))
+			};
+		}
+	};
+}
+function activeWorkflowEvents(events) {
+	const reducer = createActiveWorkflowEventSummaryReducer();
+	for (const event of events) reducer.addEvent(event);
+	return reducer.finish();
+}
+function addActiveStreamEvent(streams, terminalStreamStepIds, event) {
+	if (event.kind === "stream_started") {
+		streams.set(event.stepId, {
+			stepId: event.stepId,
+			stepName: event.stepName,
+			streamId: event.streamId,
+			startedAt: event.timestamp,
+			chunkCount: 0
+		});
+		return;
+	}
+	if (event.kind === "stream_chunk") {
+		const stream = streams.get(event.stepId);
+		if (stream !== void 0) streams.set(event.stepId, {
+			...stream,
+			chunkCount: stream.chunkCount + 1
+		});
+		return;
+	}
+	if (event.kind === "stream_closed" || event.kind === "stream_failed") terminalStreamStepIds.add(event.stepId);
+}
+function isActiveStream(stream, terminalStreamStepIds) {
+	return !terminalStreamStepIds.has(stream.stepId);
+}
+function addActiveHookEvent(hooks, terminalHookStepIds, event) {
+	if (event.kind === "message_wait_started") {
+		if (event.source !== "hook" && event.source !== "webhook") return;
+		hooks.set(event.stepId, {
+			stepId: event.stepId,
+			name: event.stepName,
+			messageId: event.messageId,
+			source: event.source,
+			startedAt: event.timestamp,
+			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt }
+		});
+		return;
+	}
+	if (event.kind === "message_wait_completed" || event.kind === "message_wait_failed") terminalHookStepIds.add(event.stepId);
+}
+function isActiveHook(hook, terminalHookStepIds) {
+	return !terminalHookStepIds.has(hook.stepId);
+}
+//#endregion
+export { activeWorkflowEvents, createActiveWorkflowEventSummaryReducer };

package/dist/engine/summary/child-workflow-runs.d.mts

@@ -0,0 +1,24 @@
+import { RunId } from "../../types/run-id.mjs";
+import { WorkflowRunFailureSummary, WorkflowRunRetrySummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import { WorkflowRunRecord, WorkflowRunStatus } from "../../types/run.mjs";
+import { WorkflowRunReaderRepository } from "../../types/store.mjs";
+//#region src/engine/summary/child-workflow-runs.d.ts
+interface WorkflowChildWorkflowRunSummaryFields {
+  readonly childStatus: Record<WorkflowRunStatus, number>;
+  readonly retryChildRunIds?: readonly string[];
+  readonly failedChildRunIds?: readonly string[];
+  readonly canceledChildRunIds?: readonly string[];
+  readonly childRetry?: WorkflowRunRetrySummary;
+  readonly childFailure?: WorkflowRunFailureSummary;
+}
+interface WorkflowChildWorkflowRunSummaryReducer {
+  addRun(run: WorkflowRunRecord): void;
+  finish(): WorkflowChildWorkflowRunSummaryFields;
+}
+declare function getChildRunsForAttempts(store: WorkflowRunReaderRepository, parentRunId: RunId, attempts: readonly WorkflowStepAttemptRecord[]): Promise<readonly WorkflowRunRecord[]>;
+/** Creates a reducer for child workflow run state embedded in active child workflow waits. */
+declare function createWorkflowChildWorkflowRunSummaryReducer(): WorkflowChildWorkflowRunSummaryReducer;
+declare function summarizeChildWorkflowRuns(runs: readonly WorkflowRunRecord[]): WorkflowChildWorkflowRunSummaryFields;
+//#endregion
+export { WorkflowChildWorkflowRunSummaryFields, WorkflowChildWorkflowRunSummaryReducer, createWorkflowChildWorkflowRunSummaryReducer, getChildRunsForAttempts, summarizeChildWorkflowRuns };

package/dist/engine/summary/child-workflow-runs.mjs

@@ -0,0 +1,138 @@
+import { greatestOptionalNumber, isScheduledWorkflowRunStatus, isWorkflowRunStatus } from "../../utility.mjs";
+import { optionalProperty, optionalSortedStringSetProperty, sortedStringSet } from "../../collection.mjs";
+import { latestOptionalTimestamp } from "../../temporal.mjs";
+import { createWorkflowRunRetryReasonCounts, createWorkflowRunStatusCounts } from "./run-metrics.mjs";
+//#region src/engine/summary/child-workflow-runs.ts
+async function getChildRunsForAttempts(store, parentRunId, attempts) {
+	const childRunIds = [...new Set(attempts.flatMap((attempt) => attempt.childRunId === void 0 ? [] : [attempt.childRunId]))];
+	return (await Promise.all(childRunIds.map(async (runId) => await store.getRun(runId)))).filter((run) => run !== void 0 && attempts.some((attempt) => isChildRunForWorkflowStepAttempt(run, parentRunId, attempt)));
+}
+/** Creates a reducer for child workflow run state embedded in active child workflow waits. */
+function createWorkflowChildWorkflowRunSummaryReducer() {
+	const childStatus = createWorkflowRunStatusCounts();
+	const retry = createWorkflowChildWorkflowRunRetryAccumulator();
+	const failure = createWorkflowChildWorkflowRunFailureAccumulator();
+	const failedChildRunIds = /* @__PURE__ */ new Set();
+	const canceledChildRunIds = /* @__PURE__ */ new Set();
+	return {
+		addRun(run) {
+			if (!isWorkflowRunStatus(run.status)) return;
+			const runStatus = run.status;
+			childStatus[runStatus]++;
+			addWorkflowChildWorkflowRunRetry(retry, run, runStatus);
+			if (runStatus === "failed") {
+				addWorkflowChildWorkflowRunFailure(failure, run);
+				failedChildRunIds.add(run.id);
+			}
+			if (runStatus === "canceled") canceledChildRunIds.add(run.id);
+		},
+		finish() {
+			return {
+				childStatus,
+				...optionalSortedStringSetProperty("retryChildRunIds", retry.retryRunIds),
+				...optionalSortedStringSetProperty("failedChildRunIds", failedChildRunIds),
+				...optionalSortedStringSetProperty("canceledChildRunIds", canceledChildRunIds),
+				...finishWorkflowChildWorkflowRunRetrySummary(retry),
+				...finishWorkflowChildWorkflowRunFailureSummary(failure)
+			};
+		}
+	};
+}
+function summarizeChildWorkflowRuns(runs) {
+	const reducer = createWorkflowChildWorkflowRunSummaryReducer();
+	for (const run of runs) reducer.addRun(run);
+	return reducer.finish();
+}
+function isChildRunForWorkflowStepAttempt(run, parentRunId, attempt) {
+	return run.parentRunId === parentRunId && run.parentStepId === attempt.stepId && run.parentStepName === attempt.stepName && run.parentStepAttempt === attempt.attempt && attempt.childRunId === run.id && attempt.workflowName === run.workflowName && attempt.workflowVersion === run.workflowVersion;
+}
+function createWorkflowChildWorkflowRunRetryAccumulator() {
+	return {
+		total: 0,
+		reason: createWorkflowRunRetryReasonCounts(),
+		retryRunIds: /* @__PURE__ */ new Set(),
+		retryStepIds: /* @__PURE__ */ new Set(),
+		retryStepNames: /* @__PURE__ */ new Set()
+	};
+}
+function createWorkflowChildWorkflowRunFailureAccumulator() {
+	return {
+		total: 0,
+		errors: /* @__PURE__ */ new Map(),
+		failedRunIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowChildWorkflowRunRetry(retry, run, runStatus) {
+	const retryReason = workflowChildWorkflowRunRetryReason(run);
+	if (!isScheduledWorkflowRunStatus(runStatus) || retryReason === void 0) return;
+	retry.total++;
+	retry.retryRunIds.add(run.id);
+	addWorkflowChildWorkflowRunRetryMetadata(retry, run);
+	retry.reason[retryReason]++;
+	setWorkflowChildWorkflowRunHighestAttempt(retry, run);
+	setWorkflowChildWorkflowRunNextRetry(retry, run);
+}
+function setWorkflowChildWorkflowRunHighestAttempt(retry, run) {
+	retry.highestAttempt = greatestOptionalNumber(retry.highestAttempt, run.retryAttempt);
+}
+function addWorkflowChildWorkflowRunRetryMetadata(retry, run) {
+	if (run.retryStepId !== void 0) retry.retryStepIds.add(run.retryStepId);
+	if (run.retryStepName !== void 0) retry.retryStepNames.add(run.retryStepName);
+}
+function setWorkflowChildWorkflowRunNextRetry(retry, run) {
+	if (run.retryAt === void 0 || retry.nextRetryAt !== void 0 && Temporal.Instant.compare(run.retryAt, retry.nextRetryAt) >= 0) return;
+	retry.nextRetryAt = run.retryAt;
+	retry.nextRetryRunId = run.id;
+}
+function workflowChildWorkflowRunRetryReason(run) {
+	return run.retryReason === "workflow" || run.retryReason === "step" || run.retryReason === "missing_implementation" ? run.retryReason : void 0;
+}
+function addWorkflowChildWorkflowRunFailure(failure, run) {
+	failure.total++;
+	failure.failedRunIds.add(run.id);
+	failure.latestFailedAt = latestOptionalTimestamp(failure.latestFailedAt, run.finishedAt);
+	addWorkflowChildWorkflowRunFailureError(failure, run);
+}
+function addWorkflowChildWorkflowRunFailureError(failure, run) {
+	const errorName = run.error?.name ?? "Error";
+	const current = failure.errors.get(errorName) ?? {
+		count: 0,
+		failedRunIds: /* @__PURE__ */ new Set()
+	};
+	current.count++;
+	current.failedRunIds.add(run.id);
+	current.latestFailedAt = latestOptionalTimestamp(current.latestFailedAt, run.finishedAt);
+	failure.errors.set(errorName, current);
+}
+function finishWorkflowChildWorkflowRunRetrySummary(retry) {
+	return retry.total === 0 ? {} : { childRetry: {
+		total: retry.total,
+		retryRunIds: sortedStringSet(retry.retryRunIds),
+		retryStepIds: sortedStringSet(retry.retryStepIds),
+		retryStepNames: sortedStringSet(retry.retryStepNames),
+		reason: retry.reason,
+		...retry.nextRetryAt === void 0 ? {} : {
+			nextRetryAt: retry.nextRetryAt,
+			...optionalProperty("nextRetryRunId", retry.nextRetryRunId)
+		},
+		...optionalProperty("highestAttempt", retry.highestAttempt)
+	} };
+}
+function finishWorkflowChildWorkflowRunFailureSummary(failure) {
+	return failure.total === 0 ? {} : { childFailure: {
+		total: failure.total,
+		failedRunIds: sortedStringSet(failure.failedRunIds),
+		errors: finishWorkflowChildWorkflowRunFailureErrors(failure.errors),
+		...optionalProperty("latestFailedAt", failure.latestFailedAt)
+	} };
+}
+function finishWorkflowChildWorkflowRunFailureErrors(errors) {
+	return [...errors.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, summary]) => ({
+		name,
+		count: summary.count,
+		failedRunIds: sortedStringSet(summary.failedRunIds),
+		...optionalProperty("latestFailedAt", summary.latestFailedAt)
+	}));
+}
+//#endregion
+export { createWorkflowChildWorkflowRunSummaryReducer, getChildRunsForAttempts, summarizeChildWorkflowRuns };

package/dist/engine/summary/child-workflow-waits.d.mts

@@ -0,0 +1,21 @@
+import { RunId } from "../../types/run-id.mjs";
+import { WorkflowRunChildWorkflowSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/child-workflow-waits.d.ts
+interface WorkflowRunChildWorkflowWaitInput {
+  readonly runId: RunId;
+  readonly attempts: readonly WorkflowStepAttemptRecord[];
+  readonly childRuns: readonly WorkflowRunRecord[];
+}
+interface WorkflowRunChildWorkflowWaitSummary {
+  readonly childWorkflow?: WorkflowRunChildWorkflowSummary;
+}
+interface WorkflowRunChildWorkflowWaitSummaryReducer {
+  addChildWorkflowAttempts(runId: RunId, attempts: readonly WorkflowStepAttemptRecord[], childRuns: readonly WorkflowRunRecord[]): void;
+  finish(): WorkflowRunChildWorkflowWaitSummary;
+}
+/** Creates a reducer for active child workflow waits across workflow runs. */
+declare function createWorkflowRunChildWorkflowWaitSummaryReducer(): WorkflowRunChildWorkflowWaitSummaryReducer;
+//#endregion
+export { WorkflowRunChildWorkflowWaitInput, WorkflowRunChildWorkflowWaitSummaryReducer, createWorkflowRunChildWorkflowWaitSummaryReducer };