@temelj/workflow 0.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tin Rabzelj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+<p align="center">
+  <h1 align="center" style="text-decoration:none;">@temelj/workflow</h1>
+  <br/>
+  <p align="center">
+    Durable, vendor-agnostic workflows for TypeScript.
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://twitter.com/tinrab" rel="nofollow"><img src="https://img.shields.io/badge/created%20by-@tinrab-1d9bf0.svg" alt="Created by Tin Rabzelj"></a>
+  <a href="https://jsr.io/@temelj/workflow" rel="nofollow"><img src="https://jsr.io/badges/@temelj/workflow" alt="jsr"></a>
+  <a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/tinrab/temelj" alt="License"></a>
+</p>
+
+<div align="center">
+  <a href="https://jsr.io/@temelj/workflow">jsr</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://www.npmjs.com/package/@temelj/workflow">npm</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/tinrab/temelj/issues/new">Issues</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/tinrab">@tinrab</a>
+  <br />
+</div>
+
+<br/>
+<br/>
+
+## Installation
+
+```sh
+# npm
+$ npm install @temelj/workflow
+# pnpm
+$ pnpm add @temelj/workflow
+# jsr
+$ deno add jsr:@temelj/workflow # or jsr add @temelj/workflow
+```

package/dist/attributes.d.mts

@@ -0,0 +1,15 @@
+import { WorkflowAttributePatch, WorkflowRunAttributes } from "./types/run.mjs";
+import { EventRecord } from "./types/events.mjs";
+//#region src/attributes.d.ts
+interface WorkflowAttributeEventPatch {
+  readonly attributes?: WorkflowRunAttributes;
+  readonly removeAttributes?: readonly string[];
+}
+declare function normalizeWorkflowAttributePatch(value: WorkflowAttributePatch): WorkflowAttributePatch;
+declare function workflowAttributeEventPatch(patch: WorkflowAttributePatch): WorkflowAttributeEventPatch;
+declare function workflowAttributePatchFromEvent(event: Extract<EventRecord, {
+  readonly kind: "attributes_set";
+}>): WorkflowAttributePatch;
+declare function applyWorkflowAttributePatch(current: WorkflowRunAttributes | undefined, patch: WorkflowAttributePatch): WorkflowRunAttributes | undefined;
+//#endregion
+export { WorkflowAttributeEventPatch, applyWorkflowAttributePatch, normalizeWorkflowAttributePatch, workflowAttributeEventPatch, workflowAttributePatchFromEvent };

package/dist/attributes.mjs

@@ -0,0 +1,30 @@
+import { workflowAttributePatchSchema } from "./types/run.mjs";
+//#region src/attributes.ts
+function normalizeWorkflowAttributePatch(value) {
+	workflowAttributePatchSchema.parse(value);
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+}
+function workflowAttributeEventPatch(patch) {
+	const attributes = Object.fromEntries(Object.entries(patch).filter((entry) => entry[1] !== void 0));
+	const removeAttributes = Object.entries(patch).filter(([, value]) => value === void 0).map(([key]) => key);
+	return {
+		...Object.keys(attributes).length > 0 && { attributes },
+		...removeAttributes.length > 0 && { removeAttributes }
+	};
+}
+function workflowAttributePatchFromEvent(event) {
+	return {
+		...event.attributes,
+		...Object.fromEntries((event.removeAttributes ?? []).map((key) => [key, void 0]))
+	};
+}
+function applyWorkflowAttributePatch(current, patch) {
+	const next = { ...current };
+	for (const [key, value] of Object.entries(patch)) if (value === void 0) delete next[key];
+	else next[key] = value;
+	const entries = Object.entries(next).sort(([left], [right]) => left.localeCompare(right));
+	if (entries.length === 0) return;
+	return Object.fromEntries(entries);
+}
+//#endregion
+export { applyWorkflowAttributePatch, normalizeWorkflowAttributePatch, workflowAttributeEventPatch, workflowAttributePatchFromEvent };

package/dist/client/create.d.mts

@@ -0,0 +1,31 @@
+import { RegistryLike, WorkflowDefinition, WorkflowHandler, WorkflowImplementation } from "../types/definition.mjs";
+import { CreateWorkflowEngineOptions } from "../types/engine-options.mjs";
+import { WorkflowClientEngine, WorkflowWorkerEngine } from "../types/engine.mjs";
+import { WorkflowClient as WorkflowClient$1, WorkflowClientAdminApi, WorkflowClientHooksApi, WorkflowClientLocksApi, WorkflowClientMessagesApi, WorkflowClientRunsApi, WorkflowClientSchedulesApi, WorkflowClientStreamsApi, WorkflowClientWorkersApi, WorkflowRunnable } from "../types/client.mjs";
+//#region src/client/create.d.ts
+type WorkflowClientEngineOptions = Omit<CreateWorkflowEngineOptions, "storage" | "store">;
+interface CreateWorkflowClientOptions extends WorkflowClientEngineOptions {
+  readonly engine?: WorkflowClientEngine;
+  readonly workerEngine?: WorkflowWorkerEngine;
+  readonly registry?: RegistryLike;
+}
+declare function createWorkflowClient(options?: CreateWorkflowClientOptions): WorkflowClient$1;
+/** Workflow client facade implementation. */
+declare class WorkflowClient implements WorkflowClient$1 {
+  #private;
+  readonly runs: WorkflowClientRunsApi;
+  readonly admin: WorkflowClientAdminApi;
+  readonly schedules: WorkflowClientSchedulesApi;
+  readonly locks: WorkflowClientLocksApi;
+  readonly hooks: WorkflowClientHooksApi;
+  readonly streams: WorkflowClientStreamsApi;
+  readonly messages: WorkflowClientMessagesApi;
+  readonly workers: WorkflowClientWorkersApi;
+  constructor(options?: CreateWorkflowClientOptions);
+  close(): Promise<void>;
+  implementWorkflow<TInput, TOutput, TRawInput = TInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, handler: WorkflowHandler<TInput, TOutput>): WorkflowImplementation<TInput, TOutput, TRawInput>;
+  register<TInput, TOutput, TRawInput = TInput>(implementation: WorkflowImplementation<TInput, TOutput, TRawInput>): void;
+  workflow<TInput, TOutput, TRawInput = TInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, handler: WorkflowHandler<TInput, TOutput>): WorkflowRunnable<TInput, TOutput, TRawInput>;
+}
+//#endregion
+export { CreateWorkflowClientOptions, WorkflowClient, createWorkflowClient };

package/dist/client/create.mjs

@@ -0,0 +1,67 @@
+import { createWorkflowClientAdminApi, createWorkflowClientHooksApi, createWorkflowClientLocksApi, createWorkflowClientMessagesApi, createWorkflowClientRunsApi, createWorkflowClientSchedulesApi, createWorkflowClientStreamsApi, createWorkflowClientWorkersApi } from "./facades.mjs";
+import { createWorkflowEngine } from "../engine/create.mjs";
+import { Registry } from "../registry.mjs";
+//#region src/client/create.ts
+function createWorkflowClient(options = {}) {
+	return new WorkflowClient(options);
+}
+/** Workflow client facade implementation. */
+var WorkflowClient = class {
+	runs;
+	admin;
+	schedules;
+	locks;
+	hooks;
+	streams;
+	messages;
+	workers;
+	#engine;
+	#workerEngine;
+	#now;
+	#registry;
+	constructor(options = {}) {
+		const { engine, workerEngine, registry, now, ...engineOptions } = options;
+		this.#now = now ?? Temporal.Now.instant;
+		this.#engine = engine ?? createWorkflowEngine({
+			...engineOptions,
+			now: this.#now
+		});
+		this.#workerEngine = workerEngine ?? workflowWorkerEngineFromCandidate(this.#engine);
+		this.#registry = registry ?? new Registry();
+		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);
+	}
+	async close() {
+		await this.#engine.close?.();
+	}
+	implementWorkflow(definition, handler) {
+		return this.#registry.implementWorkflow(definition, handler);
+	}
+	register(implementation) {
+		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 };

package/dist/client/facades.d.mts

@@ -0,0 +1,21 @@
+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";
+//#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;
+//#endregion
+export { createWorkflowClientAdminApi, createWorkflowClientHooksApi, createWorkflowClientLocksApi, createWorkflowClientMessagesApi, createWorkflowClientRunsApi, createWorkflowClientSchedulesApi, createWorkflowClientStreamsApi, createWorkflowClientWorkersApi };

package/dist/client/facades.mjs

@@ -0,0 +1,142 @@
+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 { workerOptionsFromClientOptions, workerOptionsFromWakeOptions } from "./worker-options.mjs";
+import { resolveScheduleNextOptions } from "../engine/start-api.mjs";
+import { WorkflowWorker } from "../worker.mjs";
+//#region src/client/facades.ts
+function requireWorkflowWorkerEngine(engine) {
+	if (engine === void 0) WorkflowCapabilityError.unsupported("workflow worker engine");
+	return engine;
+}
+function createWorkflowClientRunsApi(getEngine, 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);
+		},
+		async startBatch(workflow, items) {
+			const definition = defineWorkflowFromTarget(workflow);
+			return (await getEngine().startWorkflows(definition, items)).map((handle) => createWorkflowRunHandle(getEngine(), definition, handle.runId, 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)
+	};
+}
+function createWorkflowClientAdminApi(getEngine, now) {
+	return {
+		cleanup: async (options) => await getEngine().cleanupRuns(options),
+		cleanupMarkers: async () => await getEngine().listCleanupMarkers(),
+		applyRetentionPolicy: async (options) => await getEngine().applyRetentionPolicy(options),
+		rerun: async (runId, options) => {
+			const handle = await getEngine().rerunWorkflow(runId, options);
+			return createWorkflowRunHandle(getEngine(), defineWorkflowFromName(handle.workflowName, handle.workflowVersion), handle.runId, 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)
+	};
+}
+function createWorkflowClientSchedulesApi(getEngine, now) {
+	return {
+		async next(workflow, input, scheduleOptions) {
+			const definition = defineWorkflowFromTarget(workflow);
+			const options = resolveScheduleNextOptions(scheduleOptions, now);
+			const handle = await getEngine().scheduleNextWorkflow(definition, input, options.schedule);
+			return createWorkflowRunHandle(getEngine(), definition, handle.runId, 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)
+	};
+}
+function createWorkflowClientLocksApi(getEngine) {
+	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)
+	};
+}
+function createWorkflowClientHooksApi(getEngine) {
+	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)
+	};
+}
+function createWorkflowClientStreamsApi(getEngine) {
+	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)
+	};
+}
+function createWorkflowClientMessagesApi(getEngine) {
+	return {
+		async send(runId, messageInput, channelOptions) {
+			const options = await resolveSendMessageInput(messageInput, channelOptions);
+			await getEngine().sendMessage(runId, options);
+		},
+		async broadcast(messageInput, channelOptions) {
+			const options = await resolveBroadcastMessageInput(messageInput, channelOptions);
+			return getEngine().broadcastMessage(options);
+		}
+	};
+}
+function createWorkflowClientWorkersApi(getEngine, getRegistry, now) {
+	return {
+		create: (options) => {
+			return new WorkflowWorker(workerOptionsFromClientOptions(requireWorkflowWorkerEngine(getEngine()), getRegistry(), now, options));
+		},
+		processRun: async (runId, options) => {
+			await new WorkflowWorker(workerOptionsFromClientOptions(requireWorkflowWorkerEngine(getEngine()), getRegistry(), now, workerOptionsFromWakeOptions(options))).processRun(runId);
+		},
+		wakeDueRuns: async (options) => {
+			const worker = new WorkflowWorker(workerOptionsFromClientOptions(requireWorkflowWorkerEngine(getEngine()), getRegistry(), now, workerOptionsFromWakeOptions(options)));
+			const filters = options === void 0 ? {} : options;
+			const maxRuns = resolvePositiveSafeIntegerOption(options?.maxRuns, "Workflow worker maxRuns") ?? 1;
+			let processedRuns = 0;
+			while (options?.signal?.aborted !== true && processedRuns < maxRuns) {
+				if (await worker.processNextRun(filters) === void 0) break;
+				processedRuns++;
+			}
+			return { processedRuns };
+		}
+	};
+}
+//#endregion
+export { createWorkflowClientAdminApi, createWorkflowClientHooksApi, createWorkflowClientLocksApi, createWorkflowClientMessagesApi, createWorkflowClientRunsApi, createWorkflowClientSchedulesApi, createWorkflowClientStreamsApi, createWorkflowClientWorkersApi };

package/dist/client/mod.d.mts

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

package/dist/client/mod.mjs

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

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

@@ -0,0 +1,66 @@
+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 { ResultOptions } from "../types/result.mjs";
+import { WorkflowAttributePatch, WorkflowRunRecord, WorkflowRunStatus } 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 "../mod.mjs";
+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> {
+  #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 */
+  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>>;
+}
+//#endregion
+export { WorkflowRunHandle, createWorkflowRunHandle };

package/dist/client/run-handle.mjs

@@ -0,0 +1,156 @@
+import { WorkflowResultTimeoutError, WorkflowRunCanceledError, WorkflowRunNotFoundError } from "../errors/run.mjs";
+import { durationTotal } from "../utility.mjs";
+import "../errors/mod.mjs";
+import { workflowErrorFromRecord } from "../errors/records.mjs";
+import { durationBetween } from "../temporal.mjs";
+import { nonNegativeTimerDelay, sleep } from "../timer.mjs";
+//#region src/client/run-handle.ts
+const DEFAULT_RESULT_POLL_INTERVAL = Temporal.Duration.from({ milliseconds: 100 });
+function createWorkflowRunHandle(engine, definition, runId, now) {
+	return new WorkflowRunHandle(engine, definition, runId, now);
+}
+var WorkflowRunHandle = class {
+	/** @inheritdoc */
+	runId;
+	/** @inheritdoc */
+	workflowName;
+	/** @inheritdoc */
+	workflowVersion;
+	#engine;
+	#now;
+	constructor(engine, definition, runId, now) {
+		this.#engine = engine;
+		this.#now = now;
+		this.runId = runId;
+		this.workflowName = definition.name;
+		if (definition.version !== void 0) this.workflowVersion = definition.version;
+	}
+	/** @inheritdoc */
+	async getRun() {
+		const run = await this.#engine.getRun(this.runId);
+		if (run === void 0) WorkflowRunNotFoundError.notFound(this.runId);
+		return run;
+	}
+	/** @inheritdoc */
+	async status() {
+		const run = await this.#engine.getRun(this.runId);
+		if (run === void 0) WorkflowRunNotFoundError.notFound(this.runId);
+		return run.status;
+	}
+	/** @inheritdoc */
+	async events() {
+		return await this.#engine.getEvents(this.runId);
+	}
+	/** @inheritdoc */
+	async timeline() {
+		return await this.#engine.getTimeline(this.runId);
+	}
+	/** @inheritdoc */
+	async result(options) {
+		const pollInterval = nonNegativeTimerDelay(options?.pollInterval ?? DEFAULT_RESULT_POLL_INTERVAL, "Workflow result pollInterval").clampedDelay;
+		const timeout = options?.timeout;
+		const deadlineAt = timeout === void 0 ? void 0 : this.#now().add(timeout);
+		while (true) {
+			const run = await this.#engine.getRun(this.runId);
+			if (run === void 0) WorkflowRunNotFoundError.notFound(this.runId);
+			if (run.status === "canceled") WorkflowRunCanceledError.canceled(this.runId);
+			const result = runToResult(run, this.runId, this.#now());
+			if (result.kind === "completed") return result.output;
+			if (result.kind === "failed") throw workflowErrorFromRecord(result.error);
+			let sleepDelay = pollInterval;
+			if (timeout !== void 0 && deadlineAt !== void 0) {
+				const remainingDelay = durationTotal(durationBetween(this.#now(), deadlineAt));
+				if (remainingDelay <= 0) WorkflowResultTimeoutError.timedOut(this.runId, timeout);
+				sleepDelay = Math.min(sleepDelay, remainingDelay);
+			}
+			await sleep(sleepDelay);
+		}
+	}
+	/** @inheritdoc */
+	async getStreamInfo(streamIdOrName) {
+		return await this.#engine.getStreamInfo(this.runId, streamIdOrName);
+	}
+	/** @inheritdoc */
+	followStream(streamIdOrName, followOptions) {
+		return this.#engine.followStream(this.runId, streamIdOrName, followOptions);
+	}
+	/** @inheritdoc */
+	async waitForStream(streamIdOrName, waitOptions) {
+		return await this.#engine.waitForStream(this.runId, streamIdOrName, waitOptions);
+	}
+	/** @inheritdoc */
+	async waitForStreamChunk(streamIdOrName, afterIndex, waitOptions) {
+		return await this.#engine.waitForStreamChunk(this.runId, streamIdOrName, afterIndex, waitOptions);
+	}
+	/** @inheritdoc */
+	async waitForStreamTerminal(streamIdOrName, waitOptions) {
+		return await this.#engine.waitForStreamTerminal(this.runId, streamIdOrName, waitOptions);
+	}
+	/** @inheritdoc */
+	async readStream(streamIdOrName, readOptions) {
+		return await this.#engine.readStream(this.runId, streamIdOrName, readOptions);
+	}
+	/** @inheritdoc */
+	async readStreamPage(streamIdOrName, readOptions) {
+		return await this.#engine.readStreamPage(this.runId, streamIdOrName, readOptions);
+	}
+	/** @inheritdoc */
+	async reschedule(options) {
+		return await this.#engine.rescheduleRun(this.runId, options);
+	}
+	/** @inheritdoc */
+	async releaseStaleLease(options) {
+		return await this.#engine.releaseStaleRunLease(this.runId, options);
+	}
+	/** @inheritdoc */
+	async retryFailed(options) {
+		return await this.#engine.retryFailedRun(this.runId, options);
+	}
+	/** @inheritdoc */
+	async markPermanentlyFailed(options) {
+		return await this.#engine.markRunPermanentlyFailed(this.runId, options);
+	}
+	/** @inheritdoc */
+	async setMetadata(metadata) {
+		return await this.#engine.updateRunMetadata(this.runId, metadata);
+	}
+	/** @inheritdoc */
+	async setAttributes(attributes) {
+		return await this.#engine.setRunAttributes(this.runId, attributes);
+	}
+	/** @inheritdoc */
+	async cancel() {
+		return await this.#engine.cancelRun(this.runId);
+	}
+};
+function runToResult(run, runId, fallbackAvailableAt) {
+	if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
+	if (run.status === "completed") return {
+		kind: "completed",
+		run,
+		output: run.output
+	};
+	if (run.status === "failed") return {
+		kind: "failed",
+		run,
+		error: run.error ?? {
+			name: "WorkflowError",
+			message: `Workflow run failed: ${run.id}`
+		}
+	};
+	if (run.status === "canceled") return {
+		kind: "failed",
+		run,
+		error: run.error ?? {
+			name: "WorkflowRunCanceledError",
+			message: `Workflow run was canceled: ${run.id}`
+		}
+	};
+	return {
+		kind: "waiting",
+		run,
+		availableAt: run.availableAt ?? fallbackAvailableAt
+	};
+}
+//#endregion
+export { WorkflowRunHandle, createWorkflowRunHandle };

package/dist/client/worker-options.d.mts

@@ -0,0 +1,17 @@
+import { WorkflowMissingImplementationRetryConfig } from "../types/retry.mjs";
+import { RegistryLike } from "../types/definition.mjs";
+import { WorkflowWorkerEngine } from "../types/engine.mjs";
+import { CreateWorkflowWorkerOptions } from "../types/worker.mjs";
+import { WorkflowClientWorkerOptions } from "../types/client.mjs";
+//#region src/client/worker-options.d.ts
+interface WorkflowWorkerFacetOptions {
+  readonly workerId?: string;
+  readonly leaseDuration?: Temporal.Duration;
+  readonly heartbeatInterval?: Temporal.Duration;
+  readonly stopDrainTimeout?: Temporal.Duration;
+  readonly missingImplementationRetry?: WorkflowMissingImplementationRetryConfig;
+}
+declare function workerOptionsFromClientOptions(engine: WorkflowWorkerEngine, registry: RegistryLike, now: () => Temporal.Instant, options: WorkflowClientWorkerOptions | undefined): CreateWorkflowWorkerOptions;
+declare function workerOptionsFromWakeOptions(options: WorkflowWorkerFacetOptions | undefined): WorkflowClientWorkerOptions;
+//#endregion
+export { workerOptionsFromClientOptions, workerOptionsFromWakeOptions };

package/dist/client/worker-options.mjs

@@ -0,0 +1,25 @@
+//#region src/client/worker-options.ts
+function workerOptionsFromClientOptions(engine, registry, now, options) {
+	return {
+		engine,
+		registry,
+		now,
+		...options?.workerId === void 0 ? {} : { workerId: options.workerId },
+		...options?.leaseDuration === void 0 ? {} : { leaseDuration: options.leaseDuration },
+		...options?.pollInterval === void 0 ? {} : { pollInterval: options.pollInterval },
+		...options?.heartbeatInterval === void 0 ? {} : { heartbeatInterval: options.heartbeatInterval },
+		...options?.stopDrainTimeout === void 0 ? {} : { stopDrainTimeout: options.stopDrainTimeout },
+		...options?.missingImplementationRetry === void 0 ? {} : { missingImplementationRetry: options.missingImplementationRetry }
+	};
+}
+function workerOptionsFromWakeOptions(options) {
+	return {
+		...options?.workerId === void 0 ? {} : { workerId: options.workerId },
+		...options?.leaseDuration === void 0 ? {} : { leaseDuration: options.leaseDuration },
+		...options?.heartbeatInterval === void 0 ? {} : { heartbeatInterval: options.heartbeatInterval },
+		...options?.stopDrainTimeout === void 0 ? {} : { stopDrainTimeout: options.stopDrainTimeout },
+		...options?.missingImplementationRetry === void 0 ? {} : { missingImplementationRetry: options.missingImplementationRetry }
+	};
+}
+//#endregion
+export { workerOptionsFromClientOptions, workerOptionsFromWakeOptions };