@temelj/workflow 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/client/create.mjs

@@ -1,12 +1,14 @@
 import { Registry } from "../registry.mjs";
-import { createWorkflowBundleRegistry } from "../bundle.mjs";
-import { createWorkflowClientAdminApi, createWorkflowClientHooksApi, createWorkflowClientLocksApi, createWorkflowClientMessagesApi, createWorkflowClientRunsApi, createWorkflowClientSchedulesApi, createWorkflowClientStreamsApi, createWorkflowClientWorkersApi } from "./facades.mjs";
+import { createClientAdminApi, createClientHooksApi, createClientLocksApi, createClientMessagesApi, createClientRunsApi, createClientSchedulesApi, createClientStreamsApi, createClientWorkersApi } from "./facades.mjs";
 import { createWorkflowEngine } from "../engine/create.mjs";
 //#region src/client/create.ts
 function createWorkflowClient(options = {}) {
 	return new WorkflowClient(options);
 }
-/** Workflow client facade implementation. */
+/** A client over an existing engine, so several clients and workers share one engine. Internal. */
+function clientForEngine(engine, options = {}) {
+	return new WorkflowClient(options, engine);
+}
 var WorkflowClient = class {
 	runs;
 	admin;
@@ -17,27 +19,34 @@ var WorkflowClient = class {
 	messages;
 	workers;
 	#engine;
-	#workerEngine;
 	#now;
 	#registry;
-	constructor(options = {}) {
-		const { engine, workerEngine, registry, workflows, now, ...engineOptions } = options;
+	constructor(options = {}, engine) {
+		const { registry, workflows, now, ...engineOptions } = options;
 		if (registry !== void 0 && workflows !== void 0) throw new TypeError("Workflow client options cannot include both registry and workflows");
 		this.#now = now ?? Temporal.Now.instant;
 		this.#engine = engine ?? createWorkflowEngine({
 			...engineOptions,
 			now: this.#now
 		});
-		this.#workerEngine = workerEngine ?? workflowWorkerEngineFromCandidate(this.#engine);
-		this.#registry = registry ?? (workflows === void 0 ? new Registry() : createWorkflowBundleRegistry(workflows));
-		this.runs = createWorkflowClientRunsApi(() => this.#engine, this.#now);
-		this.admin = createWorkflowClientAdminApi(() => this.#engine, this.#now);
-		this.schedules = createWorkflowClientSchedulesApi(() => this.#engine, this.#now);
-		this.locks = createWorkflowClientLocksApi(() => this.#engine);
-		this.hooks = createWorkflowClientHooksApi(() => this.#engine);
-		this.streams = createWorkflowClientStreamsApi(() => this.#engine);
-		this.messages = createWorkflowClientMessagesApi(() => this.#engine);
-		this.workers = createWorkflowClientWorkersApi(() => this.#workerEngine, () => this.#registry, this.#now);
+		this.#registry = registry ?? new Registry(workflows?.workflows);
+		this.runs = createClientRunsApi(this.#engine, this.#now, this.#registry);
+		this.admin = createClientAdminApi(this.#engine, this.#now);
+		this.schedules = createClientSchedulesApi(this.#engine, this.#now);
+		this.locks = createClientLocksApi(this.#engine);
+		this.hooks = createClientHooksApi(this.#engine);
+		this.streams = createClientStreamsApi(this.#engine);
+		this.messages = createClientMessagesApi(this.#engine);
+		this.workers = createClientWorkersApi(this.#engine, this.#registry, this.#now);
+	}
+	on(pattern, handler) {
+		return this.#engine.observation.on(pattern, handler);
+	}
+	once(pattern, handler) {
+		return this.#engine.observation.once(pattern, handler);
+	}
+	off(pattern, handler) {
+		this.#engine.observation.off(pattern, handler);
 	}
 	async close() {
 		await this.#engine.close?.();
@@ -49,21 +58,6 @@ var WorkflowClient = class {
 		if (this.#registry.get(implementation.definition) === implementation) return;
 		this.#registry.register(implementation);
 	}
-	workflow(definition, handler) {
-		this.#registry.implementWorkflow(definition, handler);
-		return {
-			definition,
-			run: (...runArgs) => this.runs.start(definition, ...runArgs)
-		};
-	}
 };
-function workflowWorkerEngineFromCandidate(engine) {
-	return isWorkflowWorkerEngine(engine) ? engine : void 0;
-}
-function isWorkflowWorkerEngine(candidate) {
-	const engine = candidate;
-	if (typeof engine.resumeWorkflow !== "function" || typeof engine.getRun !== "function" || typeof engine.getRunSummary !== "function" || typeof engine.listSchedules !== "function" || typeof engine.tickSchedules !== "function" || engine.store === void 0) return false;
-	return true;
-}
 //#endregion
-export { WorkflowClient, createWorkflowClient };
+export { WorkflowClient, clientForEngine, createWorkflowClient };

package/dist/client/facades.d.mts

@@ -1,21 +1,15 @@
 import { RegistryLike } from "../types/definition.mjs";
-import { LockManager, WorkflowCleanupAdmin, WorkflowHookManager, WorkflowMessageSender, WorkflowRunHandleReader, WorkflowRunMaintenance, WorkflowRunReader, WorkflowRunRerunner, WorkflowScheduler, WorkflowStarter, WorkflowStepAttemptReader, WorkflowStreamReader, WorkflowWorkerEngine } from "../types/engine.mjs";
-import { WorkflowClientAdminApi, WorkflowClientHooksApi, WorkflowClientLocksApi, WorkflowClientMessagesApi, WorkflowClientRunsApi, WorkflowClientSchedulesApi, WorkflowClientStreamsApi, WorkflowClientWorkersApi } from "../types/client.mjs";
+import { WorkflowEngine } from "../engine/create.mjs";
+import { ClientAdminApi, ClientHooksApi, ClientLocksApi, ClientMessagesApi, ClientRunsApi, ClientSchedulesApi, ClientStreamsApi, ClientWorkersApi } from "../types/client.mjs";
 //#region src/client/facades.d.ts
-type WorkflowRunHandleEngine = WorkflowRunMaintenance & WorkflowRunHandleReader & WorkflowStreamReader;
-type WorkflowClientRunsEngine = WorkflowStarter & WorkflowRunReader & WorkflowRunHandleEngine & WorkflowStepAttemptReader;
-type WorkflowClientAdminEngine = WorkflowCleanupAdmin & WorkflowRunRerunner & WorkflowRunHandleEngine;
-type WorkflowClientSchedulesEngine = WorkflowRunHandleEngine & WorkflowScheduler;
-type WorkflowWorkerEngineAccessor = () => WorkflowWorkerEngine | undefined;
-type WorkflowRegistryAccessor = () => RegistryLike;
-type WorkflowClockAccessor = () => Temporal.Instant;
-declare function createWorkflowClientRunsApi(getEngine: () => WorkflowClientRunsEngine, now: WorkflowClockAccessor): WorkflowClientRunsApi;
-declare function createWorkflowClientAdminApi(getEngine: () => WorkflowClientAdminEngine, now: WorkflowClockAccessor): WorkflowClientAdminApi;
-declare function createWorkflowClientSchedulesApi(getEngine: () => WorkflowClientSchedulesEngine, now: WorkflowClockAccessor): WorkflowClientSchedulesApi;
-declare function createWorkflowClientLocksApi(getEngine: () => LockManager): WorkflowClientLocksApi;
-declare function createWorkflowClientHooksApi(getEngine: () => WorkflowHookManager): WorkflowClientHooksApi;
-declare function createWorkflowClientStreamsApi(getEngine: () => WorkflowStreamReader): WorkflowClientStreamsApi;
-declare function createWorkflowClientMessagesApi(getEngine: () => WorkflowMessageSender): WorkflowClientMessagesApi;
-declare function createWorkflowClientWorkersApi(getEngine: WorkflowWorkerEngineAccessor, getRegistry: WorkflowRegistryAccessor, now: WorkflowClockAccessor): WorkflowClientWorkersApi;
+type ClockAccessor = () => Temporal.Instant;
+export declare function createClientRunsApi(engine: WorkflowEngine, now: ClockAccessor, registry: RegistryLike): ClientRunsApi;
+export declare function createClientAdminApi(engine: WorkflowEngine, now: ClockAccessor): ClientAdminApi;
+export declare function createClientSchedulesApi(engine: WorkflowEngine, now: ClockAccessor): ClientSchedulesApi;
+export declare function createClientLocksApi(engine: WorkflowEngine): ClientLocksApi;
+export declare function createClientHooksApi(engine: WorkflowEngine): ClientHooksApi;
+export declare function createClientStreamsApi(engine: WorkflowEngine): ClientStreamsApi;
+export declare function createClientMessagesApi(engine: WorkflowEngine): ClientMessagesApi;
+export declare function createClientWorkersApi(engine: WorkflowEngine, registry: RegistryLike, now: ClockAccessor): ClientWorkersApi;
 //#endregion
-export { createWorkflowClientAdminApi, createWorkflowClientHooksApi, createWorkflowClientLocksApi, createWorkflowClientMessagesApi, createWorkflowClientRunsApi, createWorkflowClientSchedulesApi, createWorkflowClientStreamsApi, createWorkflowClientWorkersApi };
+export {};

package/dist/client/facades.mjs

@@ -1,135 +1,144 @@
-import { resolvePositiveSafeIntegerOption } from "../utility.mjs";
-import { WorkflowCapabilityError } from "../errors/capability.mjs";
-import { defineWorkflowFromName, defineWorkflowFromTarget } from "../definition.mjs";
-import { resolveBroadcastMessageInput, resolveSendMessageInput } from "../message-options.mjs";
-import { createWorkflowRunHandle } from "./run-handle.mjs";
+import { WorkflowDefinitionError } from "../errors/definition.mjs";
+import "../errors/mod.mjs";
+import { getCompiledDefinition } from "../compiled-function.mjs";
+import { defineFromTarget } from "../definition.mjs";
+import { resolvePositiveSafeIntegerOption } from "../values.mjs";
+import { countRunStepAttempts, getRunStepAttemptSummary, getRunTimeline, getWorkflowRecoverySummary, pageRunStepAttempts } from "../engine/inspection.mjs";
+import { applyRetentionPolicy, cancelWorkflowRun, cleanupRuns, markWorkflowRunPermanentlyFailed, releaseStaleWorkflowRunLease, rescheduleWorkflowRun, retryFailedWorkflowRun, setRunAttributes, updateWorkflowRunMetadata } from "../engine/run-service.mjs";
+import { followStream, getStreamInfo, readStream, waitForStream, waitForStreamChunk, waitForStreamTerminal } from "../engine/stream-reader.mjs";
+import { createRunHandle } from "./run-handle.mjs";
 import { workerOptionsFromClientOptions, workerOptionsFromWakeOptions } from "./worker-options.mjs";
-import { resolveScheduleNextOptions } from "../engine/start-api.mjs";
-import { WorkflowWorker } from "../worker.mjs";
+import { broadcastMessageInput, sendMessageInput } from "../engine/message.mjs";
+import { disposeHook, getHookByToken, resumeHook } from "../engine/hooks.mjs";
+import { releaseStaleLock } from "../engine/lock.mjs";
+import { updateScheduleStatus, upsertSchedule } from "../engine/schedule.mjs";
+import { resolveScheduleNextOptions } from "../engine/start.mjs";
+import { WorkflowWorker } from "../worker/worker.mjs";
+import { isFunction } from "@temelj/value";
 //#region src/client/facades.ts
-function requireWorkflowWorkerEngine(engine) {
-	if (engine === void 0) WorkflowCapabilityError.unsupported("workflow worker engine");
-	return engine;
-}
-function createWorkflowClientRunsApi(getEngine, now) {
+function createClientRunsApi(engine, now, registry) {
+	const register = (implementation) => {
+		if (registry.get(implementation.definition) === void 0) registry.register(implementation);
+	};
+	async function start(workflow, ...args) {
+		if (isFunction(workflow)) {
+			const implementation = getCompiledDefinition(workflow);
+			if (implementation === void 0) WorkflowDefinitionError.compiledMetadataMissing();
+			register(implementation);
+			const handle = await engine.startWorkflow(implementation.definition, args);
+			return createRunHandle(engine, handle, now);
+		}
+		if (workflow.kind === "implementation") register(workflow);
+		const [input, options] = args;
+		const handle = await engine.startWorkflow(defineFromTarget(workflow), input, options);
+		return createRunHandle(engine, handle, now);
+	}
 	return {
-		async start(workflow, ...runArgs) {
-			const [input, runOptions] = runArgs;
-			const definition = defineWorkflowFromTarget(workflow);
-			const handle = await getEngine().startWorkflow(definition, input, runOptions);
-			return createWorkflowRunHandle(getEngine(), definition, handle.runId, now);
-		},
+		start,
+		getHandle: async (runId) => createRunHandle(engine, await engine.getRunRef(runId), now),
 		async startBatch(workflow, items) {
-			const definition = defineWorkflowFromTarget(workflow);
-			return (await getEngine().startWorkflows(definition, items)).map((handle) => createWorkflowRunHandle(getEngine(), definition, handle.runId, now));
+			const definition = defineFromTarget(workflow);
+			return (await engine.startWorkflows(definition, items)).map((handle) => createRunHandle(engine, handle, now));
 		},
-		get: async (runId) => await getEngine().getRun(runId),
-		events: async (runId) => await getEngine().getEvents(runId),
-		eventsPage: async (runId, options) => await getEngine().listEventsPage(runId, options),
-		list: async (options) => await getEngine().listRuns(options),
-		page: async (options) => await getEngine().listRunsPage(options),
-		count: async (options) => await getEngine().countRuns(options),
-		summary: async (options) => await getEngine().getRunSummary(options),
-		recovery: async (options) => await getEngine().getRecoverySummary(options),
-		timeline: async (runId) => await getEngine().getTimeline(runId),
-		listStepAttempts: async (runId, options) => await getEngine().listStepAttempts(runId, options),
-		listStepAttemptsPage: async (runId, options) => await getEngine().listStepAttemptsPage(runId, options),
-		countStepAttempts: async (runId, options) => await getEngine().countStepAttempts(runId, options),
-		stepAttemptSummary: async (runId, options) => await getEngine().getStepAttemptSummary(runId, options)
+		get: (runId) => engine.store.getRun(runId),
+		events: (runId) => engine.store.getEvents(runId),
+		list: (options) => engine.store.listRunsPage(options),
+		count: (options) => engine.store.countRuns(options),
+		summary: (options) => engine.getRunSummary(options),
+		recoverySummary: (options) => getWorkflowRecoverySummary({
+			store: engine.store,
+			now: engine.context.now(),
+			filters: options
+		}),
+		timeline: (runId) => getRunTimeline(engine.context, runId),
+		listStepAttempts: (runId, options) => pageRunStepAttempts(engine.context, runId, options),
+		countStepAttempts: (runId, options) => countRunStepAttempts(engine.context, runId, options),
+		stepAttemptSummary: (runId, options) => getRunStepAttemptSummary(engine.context, runId, options)
 	};
 }
-function createWorkflowClientAdminApi(getEngine, now) {
+function createClientAdminApi(engine, now) {
 	return {
-		cleanup: async (options) => await getEngine().cleanupRuns(options),
-		cleanupMarkers: async () => await getEngine().listCleanupMarkers(),
-		applyRetentionPolicy: async (options) => await getEngine().applyRetentionPolicy(options),
+		cleanup: (options) => cleanupRuns(engine.context, options),
+		cleanupMarkers: () => engine.store.listCleanupMarkers(),
+		applyRetentionPolicy: (options) => applyRetentionPolicy(engine.context, options),
 		rerun: async (runId, options) => {
-			const handle = await getEngine().rerunWorkflow(runId, options);
-			return createWorkflowRunHandle(getEngine(), defineWorkflowFromName(handle.workflowName, handle.workflowVersion), handle.runId, now);
+			const handle = await engine.rerunWorkflow(runId, options);
+			return createRunHandle(engine, handle, now);
 		},
-		reschedule: async (runId, options) => await getEngine().rescheduleRun(runId, options),
-		releaseStaleLease: async (runId, options) => await getEngine().releaseStaleRunLease(runId, options),
-		retryFailed: async (runId, options) => await getEngine().retryFailedRun(runId, options),
-		markPermanentlyFailed: async (runId, options) => await getEngine().markRunPermanentlyFailed(runId, options),
-		updateMetadata: async (runId, metadata) => await getEngine().updateRunMetadata(runId, metadata),
-		setAttributes: async (runId, attributes) => await getEngine().setRunAttributes(runId, attributes),
-		cancel: async (runId) => await getEngine().cancelRun(runId)
+		reschedule: (runId, options) => rescheduleWorkflowRun(engine.context, engine.lifecycle, runId, options),
+		releaseStaleLease: (runId, options) => releaseStaleWorkflowRunLease(engine.context, engine.lifecycle, runId, options),
+		retryFailed: (runId, options) => retryFailedWorkflowRun(engine.context, engine.lifecycle, runId, options),
+		markPermanentlyFailed: (runId, options) => markWorkflowRunPermanentlyFailed(engine.context, engine.lifecycle, runId, options),
+		setMetadata: (runId, metadata) => updateWorkflowRunMetadata(engine.context, engine.lifecycle, runId, metadata),
+		setAttributes: (runId, attributes) => setRunAttributes(engine.context, runId, attributes),
+		cancel: (runId) => cancelWorkflowRun(engine.context, engine.lifecycle, runId)
 	};
 }
-function createWorkflowClientSchedulesApi(getEngine, now) {
+function createClientSchedulesApi(engine, now) {
 	return {
 		async next(workflow, input, scheduleOptions) {
-			const definition = defineWorkflowFromTarget(workflow);
+			const definition = defineFromTarget(workflow);
 			const options = resolveScheduleNextOptions(scheduleOptions, now);
-			const handle = await getEngine().scheduleNextWorkflow(definition, input, options.schedule);
-			return createWorkflowRunHandle(getEngine(), definition, handle.runId, now);
+			const handle = await engine.scheduleNextWorkflow(definition, input, options.schedule);
+			return createRunHandle(engine, handle, now);
 		},
-		create: async (workflow, options) => await getEngine().createSchedule(workflow, options),
-		upsert: async (workflow, options) => await getEngine().upsertSchedule(workflow, options),
-		get: async (scheduleId) => await getEngine().getSchedule(scheduleId),
-		list: async (options) => await getEngine().listSchedules(options),
-		page: async (options) => await getEngine().listSchedulesPage(options),
-		pause: async (scheduleId) => await getEngine().pauseSchedule(scheduleId),
-		resume: async (scheduleId) => await getEngine().resumeSchedule(scheduleId),
-		archive: async (scheduleId) => await getEngine().archiveSchedule(scheduleId),
-		delete: async (scheduleId) => await getEngine().deleteSchedule(scheduleId),
-		tick: async (options) => await getEngine().tickSchedules(options)
+		create: (workflow, options) => engine.createSchedule(workflow, options),
+		upsert: (workflow, options) => upsertSchedule(engine.store, defineFromTarget(workflow), options, engine.context.now(), engine.context.limits),
+		get: (scheduleId) => engine.store.getSchedule(scheduleId),
+		list: (options) => engine.store.listSchedulesPage(options),
+		pause: (scheduleId) => updateScheduleStatus(engine.store, scheduleId, "paused", engine.context.now()),
+		resume: (scheduleId) => updateScheduleStatus(engine.store, scheduleId, "active", engine.context.now()),
+		archive: (scheduleId) => updateScheduleStatus(engine.store, scheduleId, "archived", engine.context.now()),
+		delete: (scheduleId) => updateScheduleStatus(engine.store, scheduleId, "deleted", engine.context.now()),
+		tick: (options) => engine.tickSchedules(options)
 	};
 }
-function createWorkflowClientLocksApi(getEngine) {
+function createClientLocksApi(engine) {
 	return {
-		acquire: async (key, options) => await getEngine().acquireLock(key, options),
-		get: async (key) => await getEngine().getLock(key),
-		list: async () => await getEngine().listLocks(),
-		release: async (key, options) => await getEngine().releaseLock(key, options),
-		releaseStale: async (key, options) => await getEngine().releaseStaleLock(key, options)
+		acquire: (key, options) => engine.acquireLock(key, options),
+		get: (key) => engine.store.getLock(key),
+		list: () => engine.store.listLocks(),
+		release: (key, options) => engine.releaseLock(key, options),
+		releaseStale: (key, options) => releaseStaleLock(engine.store, key, options?.now ?? engine.context.now())
 	};
 }
-function createWorkflowClientHooksApi(getEngine) {
+function createClientHooksApi(engine) {
 	return {
-		resume: async (token, options) => await getEngine().resumeHook(token, options),
-		resumeWebhook: async (token, options) => await getEngine().resumeWebhook(token, options),
-		dispose: async (token) => await getEngine().disposeHook(token),
-		disposeWebhook: async (token) => await getEngine().disposeWebhook(token),
-		getByToken: async (token) => await getEngine().getHookByToken(token)
+		resume: (token, options) => resumeHook(token, options, engine.context),
+		dispose: (token) => disposeHook(token, engine.context),
+		getByToken: (token) => getHookByToken(token, engine.store, engine.context.now())
 	};
 }
-function createWorkflowClientStreamsApi(getEngine) {
+function createClientStreamsApi(engine) {
 	return {
-		getInfo: async (runId, streamIdOrName) => await getEngine().getStreamInfo(runId, streamIdOrName),
-		follow: (runId, streamIdOrName, options) => getEngine().followStream(runId, streamIdOrName, options),
-		wait: async (runId, streamIdOrName, options) => await getEngine().waitForStream(runId, streamIdOrName, options),
-		waitForChunk: async (runId, streamIdOrName, afterIndex, options) => await getEngine().waitForStreamChunk(runId, streamIdOrName, afterIndex, options),
-		waitForTerminal: async (runId, streamIdOrName, options) => await getEngine().waitForStreamTerminal(runId, streamIdOrName, options),
-		read: async (runId, streamIdOrName, options) => await getEngine().readStream(runId, streamIdOrName, options),
-		readPage: async (runId, streamIdOrName, options) => await getEngine().readStreamPage(runId, streamIdOrName, options)
+		getInfo: (runId, streamIdOrName) => getStreamInfo(engine.context, runId, streamIdOrName),
+		follow: (runId, streamIdOrName, options) => followStream(engine.context, runId, streamIdOrName, options),
+		wait: (runId, streamIdOrName, options) => waitForStream(engine.context, runId, streamIdOrName, options),
+		waitForChunk: (runId, streamIdOrName, afterIndex, options) => waitForStreamChunk(engine.context, runId, streamIdOrName, afterIndex, options),
+		waitForTerminal: (runId, streamIdOrName, options) => waitForStreamTerminal(engine.context, runId, streamIdOrName, options),
+		read: (runId, streamIdOrName, options) => readStream(engine.context, runId, streamIdOrName, options)
 	};
 }
-function createWorkflowClientMessagesApi(getEngine) {
+function createClientMessagesApi(engine) {
 	return {
 		async send(runId, messageInput, channelOptions) {
-			const options = await resolveSendMessageInput(messageInput, channelOptions);
-			await getEngine().sendMessage(runId, options);
+			await sendMessageInput(engine.context, runId, messageInput, channelOptions);
 		},
 		async broadcast(messageInput, channelOptions) {
-			const options = await resolveBroadcastMessageInput(messageInput, channelOptions);
-			return getEngine().broadcastMessage(options);
+			return await broadcastMessageInput(engine.context, messageInput, channelOptions);
 		}
 	};
 }
-function createWorkflowClientWorkersApi(getEngine, getRegistry, now) {
+function createClientWorkersApi(engine, registry, now) {
 	return {
 		create: (options) => {
-			const engine = requireWorkflowWorkerEngine(getEngine());
-			return new WorkflowWorker(workerOptionsFromClientOptions(engine, getRegistry(), now, options));
+			return new WorkflowWorker(workerOptionsFromClientOptions(engine, registry, now, options));
 		},
 		processRun: async (runId, options) => {
-			const engine = requireWorkflowWorkerEngine(getEngine());
-			await new WorkflowWorker(workerOptionsFromClientOptions(engine, getRegistry(), now, workerOptionsFromWakeOptions(options))).processRun(runId);
+			await new WorkflowWorker(workerOptionsFromClientOptions(engine, registry, now, workerOptionsFromWakeOptions(options))).processRun(runId);
 		},
 		wakeDueRuns: async (options) => {
-			const engine = requireWorkflowWorkerEngine(getEngine());
-			const worker = new WorkflowWorker(workerOptionsFromClientOptions(engine, getRegistry(), now, workerOptionsFromWakeOptions(options)));
+			const worker = new WorkflowWorker(workerOptionsFromClientOptions(engine, registry, now, workerOptionsFromWakeOptions(options)));
 			const filters = options === void 0 ? {} : options;
 			const maxRuns = resolvePositiveSafeIntegerOption(options?.maxRuns, "Workflow worker maxRuns") ?? 1;
 			let processedRuns = 0;
@@ -142,4 +151,4 @@ function createWorkflowClientWorkersApi(getEngine, getRegistry, now) {
 	};
 }
 //#endregion
-export { createWorkflowClientAdminApi, createWorkflowClientHooksApi, createWorkflowClientLocksApi, createWorkflowClientMessagesApi, createWorkflowClientRunsApi, createWorkflowClientSchedulesApi, createWorkflowClientStreamsApi, createWorkflowClientWorkersApi };
+export { createClientAdminApi, createClientHooksApi, createClientLocksApi, createClientMessagesApi, createClientRunsApi, createClientSchedulesApi, createClientStreamsApi, createClientWorkersApi };

package/dist/client/mod.mjs

@@ -1,2 +1 @@
-import { createWorkflowClient } from "./create.mjs";
-export { createWorkflowClient };
+export { createWorkflowClient } from "./create.mjs";

package/dist/client/run-handle.d.mts

@@ -1,67 +1,30 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowDefinition } from "../types/definition.mjs";
-import { StreamIdOrName } from "../types/stream-id.mjs";
-import { FollowStreamOptions, ReadStreamOptions, ReadStreamPageOptions, StreamChunk, StreamInfo, StreamPage, StreamState, StreamUpdate, WaitStreamOptions } from "../types/stream.mjs";
-import { Timeline } from "../types/timeline.mjs";
+import { RunId } from "../types/ids.mjs";
 import { ResultOptions } from "../types/result.mjs";
-import { WorkflowAttributePatch, WorkflowRunRecord, WorkflowRunStatus } from "../types/run.mjs";
+import { AttributePatch, RunRecord, RunStatus } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowMarkRunPermanentlyFailedOptions, WorkflowReleaseStaleLeaseOptions, WorkflowRescheduleRunOptions, WorkflowRetryFailedRunOptions } from "../types/run-options.mjs";
-import { WorkflowRunHandleReader, WorkflowRunMaintenance, WorkflowStreamReader } from "../types/engine.mjs";
-import { WorkflowRunHandle as WorkflowRunHandle$1 } from "../types/client.mjs";
+import { RunRef } from "../engine/start.mjs";
+import { WorkflowEngine } from "../engine/create.mjs";
+import { Timeline } from "../types/timeline.mjs";
+import { RunStreamsApi, WorkflowRunHandle as WorkflowRunHandle$1 } from "../types/client.mjs";
 import "../mod.mjs";
-import { StorageValue } from "@temelj/storage";
 import "temporal-polyfill/global";
+import { StorageValue } from "@temelj/storage";
 //#region src/client/run-handle.d.ts
-type WorkflowRunHandleEngine = WorkflowRunHandleReader & WorkflowStreamReader & WorkflowRunMaintenance;
-declare function createWorkflowRunHandle<TOutput>(engine: WorkflowRunHandleEngine, definition: WorkflowDefinition<unknown, TOutput>, runId: RunId, now: () => Temporal.Instant): WorkflowRunHandle$1<TOutput>;
-declare class WorkflowRunHandle<TOutput> implements WorkflowRunHandle$1<TOutput> {
+export declare function createRunHandle<TOutput>(engine: WorkflowEngine, ref: RunRef<TOutput>, now: () => Temporal.Instant): WorkflowRunHandle$1<TOutput>;
+export declare class WorkflowRunHandle<TOutput> implements WorkflowRunHandle$1<TOutput> {
   #private;
-  /** @inheritdoc */
   readonly runId: RunId;
-  /** @inheritdoc */
   readonly workflowName: string;
-  /** @inheritdoc */
   readonly workflowVersion?: string;
-  constructor(engine: WorkflowRunHandleEngine, definition: WorkflowDefinition<unknown, TOutput>, runId: RunId, now: () => Temporal.Instant);
-  /** @inheritdoc */
-  getRun(): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  status(): Promise<WorkflowRunStatus>;
-  /** @inheritdoc */
+  readonly streams: RunStreamsApi;
+  constructor(engine: WorkflowEngine, ref: RunRef<TOutput>, now: () => Temporal.Instant);
+  getRun(): Promise<RunRecord<StorageValue, StorageValue>>;
+  status(): Promise<RunStatus>;
   events(): Promise<readonly EventRecord[]>;
-  /** @inheritdoc */
   timeline(): Promise<Timeline>;
-  /** @inheritdoc */
   result(options?: ResultOptions): Promise<TOutput>;
-  /** @inheritdoc */
-  getStreamInfo(streamIdOrName: StreamIdOrName): Promise<StreamInfo>;
-  /** @inheritdoc */
-  followStream<TChunk = unknown>(streamIdOrName: StreamIdOrName, followOptions?: FollowStreamOptions): AsyncIterable<StreamUpdate<TChunk>>;
-  /** @inheritdoc */
-  waitForStream(streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
-  /** @inheritdoc */
-  waitForStreamChunk<TChunk = unknown>(streamIdOrName: StreamIdOrName, afterIndex: number, waitOptions?: WaitStreamOptions): Promise<StreamChunk<TChunk> | undefined>;
-  /** @inheritdoc */
-  waitForStreamTerminal(streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
-  /** @inheritdoc */
-  readStream<TChunk = unknown>(streamIdOrName: StreamIdOrName, readOptions?: ReadStreamOptions): Promise<StreamState<TChunk>>;
-  /** @inheritdoc */
-  readStreamPage<TChunk = unknown>(streamIdOrName: StreamIdOrName, readOptions?: ReadStreamPageOptions): Promise<StreamPage<TChunk>>;
-  /** @inheritdoc */
-  reschedule(options?: WorkflowRescheduleRunOptions): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  releaseStaleLease(options?: WorkflowReleaseStaleLeaseOptions): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  retryFailed(options?: WorkflowRetryFailedRunOptions): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  markPermanentlyFailed(options: WorkflowMarkRunPermanentlyFailedOptions): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  setMetadata(metadata: unknown): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  setAttributes(attributes: WorkflowAttributePatch): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
-  /** @inheritdoc */
-  cancel(): Promise<WorkflowRunRecord<StorageValue, StorageValue>>;
+  setMetadata(metadata: StorageValue): Promise<RunRecord<StorageValue, StorageValue>>;
+  setAttributes(attributes: AttributePatch): Promise<RunRecord<StorageValue, StorageValue>>;
+  cancel(): Promise<RunRecord<StorageValue, StorageValue>>;
 }
-//#endregion
-export { WorkflowRunHandle, createWorkflowRunHandle };
+//#endregion