@temelj/workflow 0.0.0-alpha.1

package/dist/engine/state.mjs

@@ -0,0 +1,464 @@
+import { WorkflowStateError } from "../errors/base.mjs";
+import { WorkflowRunCanceledError, WorkflowRunCancellationError, WorkflowRunDeadlineExceededError, WorkflowRunMismatchError } from "../errors/run.mjs";
+import { getRequiredRun, isPositiveSafeInteger } from "../utility.mjs";
+import { applyWorkflowAttributePatch } from "../attributes.mjs";
+import "./retry-policy.mjs";
+import { serializeError } from "./serialization.mjs";
+import { WorkflowHistory } from "../history/mod.mjs";
+import { enforceWorkflowEventHistoryNextLimit } from "./retry.mjs";
+import { readRunResult } from "./run-utils.mjs";
+//#region src/engine/state.ts
+function requireDefinitionMatchesRun(definition, run) {
+	if (definition.name !== run.workflowName) WorkflowRunMismatchError.mismatch({
+		runId: run.id,
+		expectedWorkflowName: definition.name,
+		actualWorkflowName: run.workflowName
+	});
+	if (definition.version !== run.workflowVersion) WorkflowRunMismatchError.mismatch({
+		runId: run.id,
+		expectedWorkflowName: definition.version === void 0 ? definition.name : `${definition.name}@${definition.version}`,
+		actualWorkflowName: run.workflowVersion === void 0 ? run.workflowName : `${run.workflowName}@${run.workflowVersion}`
+	});
+}
+async function appendEventIfCurrentExecution(store, history, event, executionOwner, limits, beforeAppend, afterAppend) {
+	let appendedEvents;
+	await history.append(async () => {
+		beforeAppend?.();
+		enforceWorkflowEventHistoryNextLimit(history.events, limits);
+		const events = await store.appendEventIfRunCurrent(executionOwner, event);
+		if (events === void 0) WorkflowStaleExecutionError.stale(executionOwner.id);
+		appendedEvents = events;
+		return events;
+	});
+	if (appendedEvents !== void 0) afterAppend?.(event, appendedEvents);
+}
+async function requireCurrentExecutionOwner(store, runId, executionOwner) {
+	const current = await store.getRun(runId);
+	if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) WorkflowStaleExecutionError.stale(runId);
+}
+async function patchRun(store, current, patch) {
+	const next = {
+		...current,
+		...patch
+	};
+	return await store.updateRun(next);
+}
+async function patchRunIfCurrent(store, current, patch) {
+	return await store.updateRunIfCurrent(current, {
+		...current,
+		...patch
+	});
+}
+async function updateRunMetadataIfCurrent(store, runId, metadata, timestamp) {
+	for (let attempt = 0; attempt < 16; attempt++) {
+		const updated = await patchRunIfCurrent(store, await getRequiredRun(store, runId), {
+			metadata,
+			updatedAt: timestamp
+		});
+		if (updated !== void 0) return updated;
+	}
+	WorkflowStateError.failedRunMetadataUpdate(runId);
+}
+async function setRunAttributesIfCurrent(store, runId, attributes, timestamp) {
+	for (let attempt = 0; attempt < 16; attempt++) {
+		const current = await getRequiredRun(store, runId);
+		const updated = await patchRunIfCurrent(store, current, {
+			attributes: applyWorkflowAttributePatch(current.attributes, attributes),
+			updatedAt: timestamp
+		});
+		if (updated !== void 0) return updated;
+	}
+	WorkflowStateError.failedRunAttributesUpdate(runId);
+}
+async function patchCurrentExecutionRun(store, executionOwner, patch) {
+	const current = await store.getRun(executionOwner.id);
+	if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return;
+	return await patchRunIfCurrent(store, current, patch);
+}
+async function patchCurrentExecutionRunAttributes(store, executionOwner, attributes, timestamp) {
+	const current = await store.getRun(executionOwner.id);
+	if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return;
+	return await patchRunIfCurrent(store, current, {
+		attributes: applyWorkflowAttributePatch(current.attributes, attributes),
+		updatedAt: timestamp
+	});
+}
+function transitionRunToMissingImplementationWait(run, error, timestamp, availableAt, retryAttempt) {
+	return {
+		...run,
+		status: "waiting",
+		error,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "missing_implementation",
+		availableAt,
+		retryAt: availableAt,
+		retryReason: "missing_implementation",
+		retryAttempt,
+		retryStepId: void 0,
+		retryStepName: void 0,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		deadlineAt: run.deadlineAt,
+		output: void 0,
+		finishedAt: void 0
+	};
+}
+function transitionRunToFailed(run, error, timestamp, lastTransitionReason, deadlineAt) {
+	return {
+		...run,
+		status: "failed",
+		error,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason,
+		finishedAt: timestamp,
+		output: void 0,
+		availableAt: void 0,
+		retryAt: void 0,
+		retryReason: void 0,
+		retryAttempt: void 0,
+		retryStepId: void 0,
+		retryStepName: void 0,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		deadlineAt: deadlineAt ?? run.deadlineAt
+	};
+}
+function transitionRunToRunning(run, timestamp, attempts) {
+	return {
+		...run,
+		status: "running",
+		attempts,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "started",
+		startedAt: run.startedAt ?? timestamp,
+		availableAt: void 0,
+		error: void 0,
+		output: void 0,
+		finishedAt: void 0,
+		retryAt: void 0,
+		retryReason: void 0,
+		retryAttempt: void 0,
+		retryStepId: void 0,
+		retryStepName: void 0
+	};
+}
+function transitionRunToCompleted(run, output, timestamp) {
+	return {
+		...run,
+		status: "completed",
+		...output === void 0 ? { output: void 0 } : { output },
+		error: void 0,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "completed",
+		finishedAt: timestamp,
+		availableAt: void 0,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		retryAt: void 0,
+		retryReason: void 0,
+		retryAttempt: void 0,
+		retryStepId: void 0,
+		retryStepName: void 0
+	};
+}
+function transitionRunToExecutionWait(run, timestamp, availableAt, options = {}) {
+	return {
+		...run,
+		status: "waiting",
+		availableAt,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: options.retryReason === void 0 ? "waiting" : "retry",
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		retryAt: options.retryAt,
+		retryReason: options.retryReason,
+		retryAttempt: options.retryAttempt,
+		retryStepId: options.retryStepId,
+		retryStepName: options.retryStepName,
+		error: options.error,
+		output: void 0,
+		finishedAt: void 0
+	};
+}
+function transitionRunToWaiting(run, timestamp, availableAt) {
+	return {
+		...run,
+		status: "waiting",
+		availableAt,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "waiting",
+		deadlineAt: run.deadlineAt,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		error: void 0,
+		output: void 0,
+		finishedAt: void 0
+	};
+}
+function transitionRunToRescheduled(run, timestamp, availableAt) {
+	return {
+		...run,
+		availableAt,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "rescheduled",
+		deadlineAt: run.deadlineAt,
+		leaseExpiresAt: void 0,
+		workerId: void 0,
+		retryAt: run.retryReason === void 0 ? void 0 : availableAt,
+		retryReason: run.retryReason,
+		retryAttempt: run.retryAttempt,
+		retryStepId: run.retryStepId,
+		retryStepName: run.retryStepName,
+		error: void 0,
+		output: void 0,
+		finishedAt: void 0
+	};
+}
+function transitionRunAfterStaleLeaseRelease(run, timestamp, availableAt) {
+	return {
+		...transitionRunToWaiting(run, timestamp, availableAt),
+		lastTransitionReason: "lease_released",
+		retryAt: void 0,
+		retryReason: void 0,
+		retryAttempt: void 0,
+		retryStepId: void 0,
+		retryStepName: void 0,
+		deadlineAt: run.deadlineAt,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp
+	};
+}
+function transitionRunToManualRetry(run, timestamp, availableAt, retryAttempt) {
+	return {
+		...run,
+		status: "pending",
+		availableAt,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "manual_retry",
+		deadlineAt: run.deadlineAt,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		retryAt: availableAt,
+		retryReason: run.retryReason ?? "workflow",
+		retryAttempt,
+		retryStepId: run.retryStepId,
+		retryStepName: run.retryStepName,
+		error: void 0,
+		output: void 0,
+		finishedAt: void 0
+	};
+}
+function transitionRunToPermanentFailure(run, error, timestamp) {
+	return {
+		...run,
+		status: "failed",
+		error,
+		output: void 0,
+		availableAt: void 0,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "permanent_failure",
+		deadlineAt: run.deadlineAt,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		retryAt: void 0,
+		retryReason: void 0,
+		retryAttempt: void 0,
+		retryStepId: void 0,
+		retryStepName: void 0,
+		finishedAt: timestamp
+	};
+}
+function transitionRunToCanceled(run, error, timestamp) {
+	return {
+		...run,
+		status: "canceled",
+		error,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "canceled",
+		finishedAt: timestamp,
+		availableAt: void 0,
+		output: void 0,
+		workerId: void 0,
+		leaseExpiresAt: void 0,
+		retryAt: void 0,
+		retryReason: void 0,
+		retryAttempt: void 0,
+		retryStepId: void 0,
+		retryStepName: void 0
+	};
+}
+function transitionRunAfterParentWake(run, timestamp) {
+	return {
+		...run,
+		availableAt: timestamp,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "waiting",
+		deadlineAt: run.deadlineAt,
+		retryAt: run.retryAt,
+		startedAt: run.startedAt ?? timestamp,
+		error: void 0,
+		output: void 0,
+		finishedAt: void 0
+	};
+}
+function isCurrentExecutionOwner(current, execution) {
+	return current.status === "running" && current.workerId === execution.workerId && current.attempts === execution.attempts;
+}
+async function cancelRunWithChildren(store, runId, canceledAt) {
+	const run = await getRequiredRun(store, runId);
+	if (run.status === "completed" || run.status === "failed") WorkflowRunCancellationError.cannotCancel(runId, run.status);
+	if (run.status === "canceled") return run;
+	const canceledRun = await patchRunIfCurrent(store, run, transitionRunToCanceled(run, serializeError(WorkflowRunCanceledError.create(runId)), canceledAt));
+	if (canceledRun === void 0) {
+		const latest = await getRequiredRun(store, runId);
+		if (latest.status === "completed" || latest.status === "failed") WorkflowRunCancellationError.cannotCancel(runId, latest.status);
+		if (latest.status === "canceled") return latest;
+		return await cancelRunWithChildren(store, runId, canceledAt);
+	}
+	await releaseLocksForRun(store, run.id, canceledAt);
+	await cancelActiveChildRuns(store, run.id, canceledAt);
+	await wakeParentRunForTerminalChild(store, canceledRun, canceledAt);
+	return canceledRun;
+}
+async function cancelActiveChildRuns(store, parentRunId, canceledAt) {
+	const attempts = await store.listStepAttempts(parentRunId, {
+		kind: "workflow",
+		status: "running"
+	});
+	const childRunIds = /* @__PURE__ */ new Set();
+	for (const attempt of attempts) if (attempt.childRunId !== void 0 && (attempt.cancellation ?? "cascade") === "cascade" && await parentHasActiveChildWorkflowEventForAttempt(store, parentRunId, attempt)) childRunIds.add(attempt.childRunId);
+	for (const childRunId of childRunIds) {
+		const child = await store.getRun(childRunId);
+		if (child === void 0) continue;
+		if (!await parentHasActiveChildWorkflowAttemptForRun(store, parentRunId, child)) continue;
+		if (child.status === "completed" || child.status === "failed" || child.status === "canceled") continue;
+		await cancelRunWithChildren(store, child.id, canceledAt);
+	}
+}
+async function wakeParentRunForTerminalChild(store, childRun, timestamp) {
+	if (childRun.parentRunId === void 0) return;
+	const parentRun = await store.getRun(childRun.parentRunId);
+	if (parentRun === void 0 || parentRun.status !== "waiting") return;
+	if (!await parentHasActiveChildWorkflowAttemptForRun(store, parentRun.id, childRun)) return;
+	const wakeAt = timestamp;
+	if (parentRun.availableAt !== void 0 && Temporal.Instant.compare(parentRun.availableAt, wakeAt) <= 0) return;
+	await patchRun(store, parentRun, transitionRunAfterParentWake(parentRun, timestamp));
+}
+async function wakeParentRunForWaitingChild(store, childRun, availableAt) {
+	if (childRun.parentRunId === void 0) return;
+	const parentRun = await store.getRun(childRun.parentRunId);
+	if (parentRun === void 0 || parentRun.status !== "waiting") return;
+	if (!await parentHasActiveChildWorkflowAttemptForRun(store, parentRun.id, childRun)) return;
+	const wakeAt = availableAt;
+	if (parentRun.availableAt !== void 0 && Temporal.Instant.compare(parentRun.availableAt, wakeAt) <= 0) return;
+	await patchRun(store, parentRun, transitionRunAfterParentWake(parentRun, availableAt));
+}
+async function parentHasActiveChildWorkflowAttemptForRun(store, parentRunId, childRun) {
+	if (childRun.parentRunId !== parentRunId) return false;
+	const attempts = await store.listStepAttempts(parentRunId, {
+		kind: "workflow",
+		status: "running",
+		childRunId: childRun.id
+	});
+	for (const attempt of attempts) if (childRun.parentRunId === parentRunId && childRun.parentStepId === attempt.stepId && childRun.parentStepName === attempt.stepName && childRun.parentStepAttempt === attempt.attempt && attempt.childRunId === childRun.id && attempt.workflowName === childRun.workflowName && attempt.workflowVersion === childRun.workflowVersion && await parentHasActiveChildWorkflowEventForAttempt(store, parentRunId, attempt)) return true;
+	return false;
+}
+async function parentHasActiveChildWorkflowEventForAttempt(store, parentRunId, attempt) {
+	if (attempt.childRunId === void 0) return false;
+	const lifecycle = new WorkflowHistory(await store.getEvents(parentRunId)).childWorkflowLifecycleForAttempt(attempt);
+	if (lifecycle.started === void 0) return false;
+	if (!isPositiveSafeInteger(lifecycle.started.attempt)) return false;
+	return !lifecycle.hasTerminalAfterStarted;
+}
+async function failRunForDeadline(store, run, deadlineAt, failedAt, executionOwner) {
+	const serialized = serializeError(WorkflowRunDeadlineExceededError.create(run.id, deadlineAt));
+	if (executionOwner !== void 0) {
+		const current = await store.getRun(run.id);
+		if (current === void 0 || !isCurrentExecutionOwner(current, executionOwner)) return await readRunResult(store, run.id, failedAt);
+	}
+	await cancelActiveChildRuns(store, run.id, failedAt);
+	const failedRun = executionOwner === void 0 ? await patchRun(store, run, transitionRunToFailed(run, serialized, failedAt, "deadline")) : await patchCurrentExecutionRun(store, executionOwner, transitionRunToFailed(executionOwner, serialized, failedAt, "deadline"));
+	if (failedRun === void 0) return await readRunResult(store, run.id, failedAt);
+	if (await store.appendEventIfRunCurrent(failedRun, {
+		kind: "workflow_failed",
+		timestamp: failedAt
+	}) === void 0) return await readRunResult(store, run.id, failedAt);
+	await releaseLocksForRun(store, run.id, failedAt);
+	await wakeParentRunForTerminalChild(store, failedRun, failedAt);
+	return {
+		kind: "failed",
+		run: failedRun,
+		error: serialized
+	};
+}
+async function releaseLocksForRun(store, runId, releasedAt) {
+	const timestamp = releasedAt;
+	const locks = await store.listLocks();
+	await Promise.all(locks.filter((lock) => lock.releasedAt === void 0 && lock.holderRunId === runId).map(async (lock) => {
+		await store.updateLockIfCurrent(lock, {
+			...lock,
+			releasedAt: timestamp
+		});
+	}));
+}
+var WorkflowSuspended = class WorkflowSuspended extends Error {
+	availableAt;
+	retryAt;
+	retryReason;
+	retryAttempt;
+	retryStep;
+	constructor(availableAt, context) {
+		super(`Workflow suspended until ${availableAt.toString()}`);
+		this.name = "WorkflowSuspended";
+		this.availableAt = availableAt;
+		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
+	}
+	static until(availableAt) {
+		throw new WorkflowSuspended(availableAt, WorkflowSuspended.until);
+	}
+	static forStepRetry(retryAt, retryStep, retryAttempt) {
+		const suspended = new WorkflowSuspended(retryAt, WorkflowSuspended.forStepRetry);
+		Object.defineProperties(suspended, {
+			retryAt: {
+				value: retryAt,
+				enumerable: true
+			},
+			retryReason: {
+				value: "step",
+				enumerable: true
+			},
+			retryAttempt: {
+				value: retryAttempt,
+				enumerable: true
+			},
+			retryStep: {
+				value: retryStep,
+				enumerable: true
+			}
+		});
+		throw suspended;
+	}
+};
+var WorkflowStaleExecutionError = class WorkflowStaleExecutionError extends Error {
+	constructor(runId, context) {
+		super(`Workflow execution no longer owns run: ${runId}`);
+		this.name = "WorkflowStaleExecutionError";
+		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
+	}
+	static stale(runId) {
+		throw new WorkflowStaleExecutionError(runId, WorkflowStaleExecutionError.stale);
+	}
+};
+//#endregion
+export { WorkflowStaleExecutionError, WorkflowSuspended, appendEventIfCurrentExecution, cancelActiveChildRuns, cancelRunWithChildren, failRunForDeadline, getRequiredRun, isCurrentExecutionOwner, parentHasActiveChildWorkflowAttemptForRun, parentHasActiveChildWorkflowEventForAttempt, patchCurrentExecutionRun, patchCurrentExecutionRunAttributes, patchRun, patchRunIfCurrent, releaseLocksForRun, requireCurrentExecutionOwner, requireDefinitionMatchesRun, setRunAttributesIfCurrent, transitionRunAfterParentWake, transitionRunAfterStaleLeaseRelease, transitionRunToCanceled, transitionRunToCompleted, transitionRunToExecutionWait, transitionRunToFailed, transitionRunToManualRetry, transitionRunToMissingImplementationWait, transitionRunToPermanentFailure, transitionRunToRescheduled, transitionRunToRunning, transitionRunToWaiting, updateRunMetadataIfCurrent, wakeParentRunForTerminalChild, wakeParentRunForWaitingChild };

package/dist/engine/step-api.d.mts

@@ -0,0 +1,9 @@
+import { WorkflowDeterministicApi, WorkflowStepApi } from "../types/step.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { WorkflowChildWorkflowEngine } from "./child-workflow.mjs";
+import { WorkflowStepLockEngine } from "./lock.mjs";
+//#region src/engine/step-api.d.ts
+type WorkflowStepRuntime = WorkflowChildWorkflowEngine & WorkflowStepLockEngine;
+declare function createStepApi(environment: WorkflowExecutionEnvironment, engine: WorkflowStepRuntime, executionSignal: AbortSignal, deterministic: WorkflowDeterministicApi): WorkflowStepApi;
+//#endregion
+export { createStepApi };

package/dist/engine/step-api.mjs

@@ -0,0 +1,25 @@
+import { createWorkflowStepWorkflowApi } from "./child-workflow.mjs";
+import { createWorkflowStepMessageApi } from "./message.mjs";
+import { createWorkflowStepHookApi } from "./hooks.mjs";
+import { createWorkflowStepLockApi } from "./lock.mjs";
+import { createWorkflowRunDataApi } from "./run-data.mjs";
+import { createWorkflowStepStreamApi } from "./stream.mjs";
+import { createWorkflowStepTaskApi } from "./task.mjs";
+//#region src/engine/step-api.ts
+function createStepApi(environment, engine, executionSignal, deterministic) {
+	const task = createWorkflowStepTaskApi(environment, executionSignal);
+	const runTask = async (config, callback) => await task.run(config, callback);
+	return {
+		log: environment.logger,
+		task,
+		workflow: createWorkflowStepWorkflowApi(environment, engine),
+		message: createWorkflowStepMessageApi(environment),
+		lock: createWorkflowStepLockApi(environment, engine, runTask),
+		runData: createWorkflowRunDataApi(environment),
+		deterministic,
+		stream: createWorkflowStepStreamApi(environment),
+		hook: createWorkflowStepHookApi(environment)
+	};
+}
+//#endregion
+export { createStepApi };

package/dist/engine/stream.d.mts

@@ -0,0 +1,55 @@
+import { RunId } from "../types/run-id.mjs";
+import { StreamIdOrName } from "../types/stream-id.mjs";
+import { CreateStreamOptions, FollowStreamOptions, ReadStreamOptions, ReadStreamPageOptions, Stream as Stream$1, StreamChunk, StreamInfo, StreamPage, StreamState, StreamUpdate, WaitStreamOptions } from "../types/stream.mjs";
+import { WorkflowStepStreamApi } from "../types/step.mjs";
+import { WorkflowStepIdentity } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowEventHistoryWatcher, WorkflowEventReader, WorkflowRunReaderRepository } from "../types/store.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+//#region src/engine/stream.d.ts
+interface WorkflowStreamReader<TChunk> {
+  (options?: ReadStreamOptions): Promise<StreamState<TChunk>>;
+}
+interface WorkflowStreamInfoReader {
+  (): Promise<StreamInfo>;
+}
+interface WorkflowStreamChangeWaiter {
+  (options: {
+    readonly signal?: AbortSignal;
+  }): Promise<void>;
+}
+interface WorkflowStreamWaitOptions {
+  readonly waitForChange?: WorkflowStreamChangeWaiter;
+}
+type WorkflowStreamStore = WorkflowRunReaderRepository & WorkflowEventReader & WorkflowEventHistoryWatcher;
+interface WorkflowStreamServiceOptions {
+  readonly store: WorkflowStreamStore;
+}
+declare function getStreamInfoForRun(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName): Promise<StreamInfo>;
+declare function readStreamForRun<TChunk = unknown>(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName, readOptions?: ReadStreamOptions): Promise<StreamState<TChunk>>;
+declare function readStreamPageForRun<TChunk = unknown>(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName, readOptions?: ReadStreamPageOptions): Promise<StreamPage<TChunk>>;
+declare function followStreamForRun<TChunk = unknown>(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName, followOptions?: FollowStreamOptions): AsyncIterable<StreamUpdate<TChunk>>;
+declare function waitForStreamForRun(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
+declare function waitForStreamChunkForRun<TChunk = unknown>(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName, afterIndex: number, waitOptions?: WaitStreamOptions): Promise<StreamChunk<TChunk> | undefined>;
+declare function waitForStreamTerminalForRun(service: WorkflowStreamServiceOptions, runId: RunId, streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
+declare function createWorkflowStepStreamApi(environment: WorkflowExecutionEnvironment): WorkflowStepStreamApi;
+declare function createStream<TChunk>(environment: WorkflowExecutionEnvironment, identity: WorkflowStepIdentity<"stream">, name: string, options?: CreateStreamOptions): Stream<TChunk>;
+declare class Stream<TChunk> implements Stream$1<TChunk> {
+  #private;
+  readonly id: string;
+  readonly name: string;
+  readonly contentType?: string;
+  readonly metadata?: unknown;
+  constructor(environment: WorkflowExecutionEnvironment, identity: WorkflowStepIdentity<"stream">, name: string, options?: CreateStreamOptions);
+  write(chunk: TChunk): Promise<void>;
+  close(): Promise<void>;
+  error(error: unknown): Promise<void>;
+}
+declare function readStream<TChunk = unknown>(runId: RunId, events: readonly EventRecord[], streamIdOrName: StreamIdOrName, options?: ReadStreamOptions): StreamState<TChunk>;
+declare function followStream<TChunk = unknown>(read: WorkflowStreamReader<TChunk>, options?: FollowStreamOptions, waitOptions?: WorkflowStreamWaitOptions): AsyncIterable<StreamUpdate<TChunk>>;
+declare function waitForStream(readInfo: WorkflowStreamInfoReader, options?: WaitStreamOptions, waitOptions?: WorkflowStreamWaitOptions): Promise<StreamInfo | undefined>;
+declare function waitForStreamChunk<TChunk = unknown>(read: WorkflowStreamReader<TChunk>, afterIndex: number, options?: WaitStreamOptions, waitOptions?: WorkflowStreamWaitOptions): Promise<StreamChunk<TChunk> | undefined>;
+declare function waitForStreamTerminal(readInfo: WorkflowStreamInfoReader, options?: WaitStreamOptions, waitOptions?: WorkflowStreamWaitOptions): Promise<StreamInfo | undefined>;
+declare function getStreamInfo(runId: RunId, events: readonly EventRecord[], streamIdOrName: StreamIdOrName): StreamInfo;
+//#endregion
+export { createStream, createWorkflowStepStreamApi, followStream, followStreamForRun, getStreamInfo, getStreamInfoForRun, readStream, readStreamForRun, readStreamPageForRun, waitForStream, waitForStreamChunk, waitForStreamChunkForRun, waitForStreamForRun, waitForStreamTerminal, waitForStreamTerminalForRun };