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

package/dist/cloudflare/registry.mjs

@@ -1,26 +1,8 @@
-import { WorkflowDefinitionError } from "../errors/definition.mjs";
-import "../errors/mod.mjs";
-import { getCompiledWorkflowDefinition } from "../compiled-function.mjs";
-import { Registry } from "../registry.mjs";
 //#region src/cloudflare/registry.ts
-/** Creates a registry shared by the Cloudflare entrypoint and runtime facade. */
-function createCloudflareWorkflowRegistry(entries = []) {
-	const registry = new Registry();
-	for (const entry of entries) {
-		if (typeof entry === "function") {
-			const implementation = getCompiledWorkflowDefinition(entry);
-			if (implementation === void 0) WorkflowDefinitionError.compiledMetadataMissing();
-			registry.register(implementation);
-			continue;
-		}
-		registry.register(entry);
-	}
-	return registry;
-}
 function resolveCloudflareWorkflowImplementation(registry, name, version) {
-	const implementation = version === void 0 ? registry.latest(name) : registry.getByName(name, version);
+	const implementation = registry.getByName(name, version);
 	if (implementation === void 0) throw new TypeError(`Cloudflare Workflow implementation is not registered: ${version === void 0 ? name : `${name}@${version}`}`);
 	return implementation;
 }
 //#endregion
-export { createCloudflareWorkflowRegistry, resolveCloudflareWorkflowImplementation };
+export { resolveCloudflareWorkflowImplementation };

package/dist/cloudflare/runtime.d.mts

@@ -1,30 +1,23 @@
-import { RunId } from "../types/run-id.mjs";
-import { RegistryLike, WorkflowStartTarget } from "../types/definition.mjs";
-import { MessageChannel, SendMessageChannelOptions, SendMessageInput } from "../types/message.mjs";
-import "../types/run.mjs";
-import { WorkflowRunHandle } from "../types/client.mjs";
-import { WorkflowRuntime, WorkflowRuntimeRunsApi } from "../types/runtime.mjs";
+import { RunId } from "../types/ids.mjs";
+import { RegistryLike, StartTarget } from "../types/definition.mjs";
+import { MessageSender } from "../types/message.mjs";
+import { RunHandle, RuntimeRunsApi, WorkflowRuntime } from "../types/runtime.mjs";
 import { CloudflareWorkflowBinding } from "./types.mjs";
 //#region src/cloudflare/runtime.d.ts
-interface CreateCloudflareWorkflowRuntimeOptions {
+export interface CreateCloudflareWorkflowRuntimeOptions {
   readonly binding: CloudflareWorkflowBinding;
   readonly registry?: RegistryLike;
   readonly resultPollInterval?: Temporal.Duration;
   /** Controls whether workflows absent from the initial registry may be registered at runtime. */
   readonly registration?: "dynamic" | "static";
 }
-interface CloudflareWorkflowRuntimeRunsApi extends WorkflowRuntimeRunsApi {
-  get<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, runId: RunId): Promise<WorkflowRunHandle<TOutput>>;
+export interface CloudflareWorkflowRuntimeRunsApi extends RuntimeRunsApi {
+  get<TInput, TOutput, TRawInput = TInput>(workflow: StartTarget<TInput, TOutput, TRawInput>, runId: RunId): Promise<RunHandle<TOutput>>;
 }
-interface CloudflareWorkflowMessagesApi {
-  send(runId: RunId, options: SendMessageInput): Promise<void>;
-  send<TPayload, TKey = void>(runId: RunId, channel: MessageChannel<TPayload, TKey>, options?: SendMessageChannelOptions<TPayload, TKey>): Promise<void>;
-}
-interface CloudflareWorkflowRuntime extends WorkflowRuntime {
+export interface CloudflareWorkflowRuntime extends WorkflowRuntime {
   readonly runs: CloudflareWorkflowRuntimeRunsApi;
-  readonly messages: CloudflareWorkflowMessagesApi;
+  readonly messages: MessageSender;
 }
 /** Creates a runtime facade over a generic Cloudflare Workflow binding. */
-declare function createCloudflareWorkflowRuntime(options: CreateCloudflareWorkflowRuntimeOptions): CloudflareWorkflowRuntime;
-//#endregion
-export { CloudflareWorkflowMessagesApi, CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, CreateCloudflareWorkflowRuntimeOptions, createCloudflareWorkflowRuntime };
+export declare function createCloudflareWorkflowRuntime(options: CreateCloudflareWorkflowRuntimeOptions): CloudflareWorkflowRuntime;
+//#endregion

package/dist/cloudflare/runtime.mjs

@@ -1,28 +1,25 @@
-import { WorkflowResultTimeoutError, WorkflowRunCanceledError } from "../errors/run.mjs";
-import { durationTotal } from "../utility.mjs";
 import { WorkflowCapabilityError } from "../errors/capability.mjs";
 import { WorkflowDefinitionError } from "../errors/definition.mjs";
+import { WorkflowResultTimeoutError, WorkflowRunCanceledError } from "../errors/run.mjs";
 import "../errors/mod.mjs";
-import { getCompiledWorkflowDefinition } from "../compiled-function.mjs";
+import { getCompiledDefinition } from "../compiled-function.mjs";
 import { Registry } from "../registry.mjs";
-import { parseWorkflowInput } from "../definition.mjs";
+import { defineFromTarget } from "../definition.mjs";
 import { resolveSendMessageInput } from "../message-options.mjs";
-import { decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue } from "./codec.mjs";
-import { resolveCloudflareWorkflowImplementation } from "./registry.mjs";
-import { makeCloudflareWorkflowEventType } from "./name.mjs";
+import { parseInput } from "../engine/serialization.mjs";
+import { decodeCloudflareResult, durationMilliseconds, encodeCloudflareValue } from "./codec.mjs";
+import { makeCloudflareEventType } from "./name.mjs";
+import { isFunction } from "@temelj/value";
 //#region src/cloudflare/runtime.ts
 const DEFAULT_RESULT_POLL_INTERVAL = 100;
 const CLOUDFLARE_INSTANCE_ID_PATTERN = /^[a-zA-Z0-9_][a-zA-Z0-9-_]*$/;
 /** Creates a runtime facade over a generic Cloudflare Workflow binding. */
 function createCloudflareWorkflowRuntime(options) {
-	return new CloudflareWorkflowRuntimeImpl(options);
+	return new CloudflareRuntimeImpl(options);
 }
-var CloudflareWorkflowRuntimeImpl = class {
+var CloudflareRuntimeImpl = class {
 	runs;
 	messages;
-	schedules = unsupportedApi("Cloudflare workflow schedules");
-	locks = unsupportedApi("Cloudflare workflow locks");
-	workers = unsupportedApi("Cloudflare workflow workers");
 	#binding;
 	#registry;
 	#registration;
@@ -32,16 +29,27 @@ var CloudflareWorkflowRuntimeImpl = class {
 		this.#registry = options.registry ?? new Registry();
 		this.#registration = options.registration ?? "dynamic";
 		this.#resultPollInterval = options.resultPollInterval === void 0 ? DEFAULT_RESULT_POLL_INTERVAL : durationMilliseconds(options.resultPollInterval, "Cloudflare result poll interval");
+		const runtime = this;
+		async function start(workflow, ...args) {
+			if (isFunction(workflow)) {
+				const implementation = getCompiledDefinition(workflow);
+				if (implementation === void 0) WorkflowDefinitionError.compiledMetadataMissing();
+				runtime.register(implementation);
+				return await runtime.#startTarget(implementation, args, void 0);
+			}
+			const [input, options] = args;
+			if (workflow.kind === "implementation") runtime.register(workflow);
+			return await runtime.#startTarget(workflow, input, options);
+		}
 		this.runs = {
-			getHandle: async () => WorkflowCapabilityError.unsupported("Cloudflare run lookup without a workflow target; use runtime.runs.get(workflow, runId)"),
-			list: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow run listing"),
+			start,
 			get: async (workflow, runId) => this.#createHandle(workflow, runId)
 		};
 		this.messages = { send: async (runId, input, channelOptions) => {
 			const message = await resolveSendMessageInput(input, channelOptions);
 			await (await this.#binding.get(runId)).sendEvent({
-				type: makeCloudflareWorkflowEventType(message.messageId),
-				payload: encodeCloudflareWorkflowValue(message.payload)
+				type: makeCloudflareEventType(message.messageId),
+				payload: encodeCloudflareValue(message.payload)
 			});
 		} };
 	}
@@ -60,38 +68,29 @@ var CloudflareWorkflowRuntimeImpl = class {
 			this.#registry.register(implementation);
 		}
 	}
-	async start(workflow, ...args) {
-		if (typeof workflow === "function") {
-			const implementation = getCompiledWorkflowDefinition(workflow);
-			if (implementation === void 0) WorkflowDefinitionError.compiledMetadataMissing();
-			this.register(implementation);
-			return await this.#startTarget(implementation, args, void 0);
-		}
-		const target = workflow;
-		if (target.kind === "implementation") this.register(target);
-		return await this.#startTarget(target, args[0], args[1]);
-	}
 	async #startTarget(target, rawInput, startOptions) {
 		rejectUnsupportedStartOptions(startOptions);
-		const requestedVersion = startOptions?.workflowVersion ?? target.version;
-		const implementation = resolveCloudflareWorkflowImplementation(this.#registry, target.name, requestedVersion);
+		if (startOptions?.workflowVersion !== void 0 && startOptions.workflowVersion !== target.version) throw new WorkflowDefinitionError("Cloudflare start target version mismatch");
+		const implementation = this.#registeredImplementation(target);
 		if (implementation.config.retry !== void 0) WorkflowCapabilityError.unsupported("Cloudflare workflow-level retry configuration");
-		const input = await parseWorkflowInput(implementation.definition, rawInput);
+		await parseInput(implementation.definition, rawInput);
 		const envelope = {
 			kind: "temelj-workflow",
 			version: 1,
 			workflowName: implementation.name,
-			...implementation.version === void 0 ? {} : { workflowVersion: implementation.version },
-			input: encodeCloudflareWorkflowValue(input)
+			workflowVersion: implementation.version,
+			input: encodeCloudflareValue(rawInput)
 		};
 		const id = await resolveInstanceId(implementation.name, implementation.version, startOptions);
 		const createdAt = Temporal.Now.instant();
 		let instance;
-		if (startOptions?.idempotencyKey === void 0) instance = await this.#binding.create({
-			...id === void 0 ? {} : { id },
-			params: envelope
-		});
-		else {
+		if (startOptions?.idempotencyKey === void 0) {
+			const createOptions = {
+				id,
+				params: envelope
+			};
+			instance = await this.#binding.create(createOptions);
+		} else {
 			if (id === void 0) throw new TypeError("Cloudflare idempotent workflow start requires a resolved instance id");
 			instance = (await this.#binding.createBatch([{
 				id,
@@ -101,35 +100,25 @@ var CloudflareWorkflowRuntimeImpl = class {
 		return this.#handle(implementation.definition, instance, createdAt);
 	}
 	async #createHandle(workflow, runId) {
-		const implementation = resolveCloudflareWorkflowImplementation(this.#registry, workflow.name, workflow.version);
+		const implementation = this.#registeredImplementation(workflow);
 		const instance = await this.#binding.get(runId);
 		return this.#handle(implementation.definition, instance, Temporal.Now.instant());
 	}
+	#registeredImplementation(target) {
+		const implementation = this.#registry.get(defineFromTarget(target));
+		if (implementation === void 0) throw new TypeError("Cloudflare Workflow target must use its registered definition: " + target.name);
+		return implementation;
+	}
 	#handle(definition, instance, createdAt) {
-		const status = async () => await instance.status();
+		const status = () => instance.status();
 		const record = async () => workflowRunRecord(definition, instance.id, createdAt, await status());
 		return {
 			runId: instance.id,
 			workflowName: definition.name,
-			...definition.version === void 0 ? {} : { workflowVersion: definition.version },
+			workflowVersion: definition.version,
 			getRun: record,
 			status: async () => cloudflareRunStatus((await status()).status),
-			events: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow event history"),
-			timeline: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow timeline"),
-			result: async (options) => await cloudflareWorkflowResult(instance, options, this.#resultPollInterval),
-			getStreamInfo: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			followStream: () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			waitForStream: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			waitForStreamChunk: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			waitForStreamTerminal: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			readStream: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			readStreamPage: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow streams"),
-			reschedule: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow rescheduling"),
-			releaseStaleLease: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow worker leases"),
-			retryFailed: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow manual retries"),
-			markPermanentlyFailed: async () => WorkflowCapabilityError.unsupported("Cloudflare permanent workflow failure"),
-			setMetadata: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow metadata"),
-			setAttributes: async () => WorkflowCapabilityError.unsupported("Cloudflare workflow attributes"),
+			result: (options) => cloudflareResult(definition, instance, options, this.#resultPollInterval),
 			async cancel() {
 				if (!isTerminalCloudflareStatus((await instance.status()).status)) await instance.terminate();
 				return await record();
@@ -143,13 +132,13 @@ function workflowImplementationKey(name, version) {
 function isTerminalCloudflareStatus(status) {
 	return status === "complete" || status === "errored" || status === "terminated";
 }
-async function cloudflareWorkflowResult(instance, options, defaultPollInterval) {
+async function cloudflareResult(definition, instance, options, defaultPollInterval) {
 	const pollInterval = options?.pollInterval === void 0 ? defaultPollInterval : durationMilliseconds(options.pollInterval, "Cloudflare result poll interval");
 	const timeout = options?.timeout === void 0 ? void 0 : durationMilliseconds(options.timeout, "Cloudflare result timeout");
 	const startedAt = Date.now();
 	while (true) {
 		const state = await instance.status();
-		if (state.status === "complete") return decodeCloudflareWorkflowValue(state.output, `Cloudflare Workflow ${instance.id} output`);
+		if (state.status === "complete") return decodeCloudflareResult(state, definition);
 		if (state.status === "errored") {
 			const error = new Error(state.error?.message ?? "Cloudflare Workflow failed");
 			error.name = state.error?.name ?? "Error";
@@ -168,18 +157,18 @@ function workflowRunRecord(definition, runId, createdAt, state) {
 		id: runId,
 		namespace: "cloudflare",
 		workflowName: definition.name,
-		...definition.version === void 0 ? {} : { workflowVersion: definition.version },
+		workflowVersion: definition.version,
 		status,
-		...state.status === "complete" ? { output: decodeCloudflareWorkflowValue(state.output, `Cloudflare Workflow ${runId} output`) } : {},
-		...state.error === void 0 ? {} : { error: {
+		output: state.status === "complete" ? decodeCloudflareResult(state, definition) : void 0,
+		error: state.error !== void 0 ? {
 			name: state.error.name,
 			message: state.error.message
-		} },
+		} : void 0,
 		createdAt,
 		updatedAt: now,
 		lastTransitionAt: now,
 		lastTransitionReason: status === "completed" ? "completed" : status === "failed" ? "failed" : status === "canceled" ? "canceled" : status === "waiting" ? "waiting" : status === "running" ? "started" : "created",
-		...status === "completed" || status === "failed" || status === "canceled" ? { finishedAt: now } : {}
+		finishedAt: status === "completed" || status === "failed" || status === "canceled" ? now : void 0
 	};
 }
 function cloudflareRunStatus(status) {
@@ -212,15 +201,5 @@ function validateInstanceId(id) {
 function rejectUnsupportedStartOptions(options) {
 	if (options?.availableAt !== void 0 || options?.deadlineAt !== void 0 || options?.context !== void 0 || options?.parent !== void 0 || options?.workflowVersionResolver !== void 0) WorkflowCapabilityError.unsupported("Cloudflare start context, parent, delayed availability, deadline, or version resolver");
 }
-function durationMilliseconds(duration, label) {
-	const milliseconds = durationTotal(duration);
-	if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) throw new RangeError(`${label} must resolve to non-negative whole milliseconds`);
-	return milliseconds;
-}
-function unsupportedApi(capability) {
-	return new Proxy({}, { get() {
-		return () => WorkflowCapabilityError.unsupported(capability);
-	} });
-}
 //#endregion
 export { createCloudflareWorkflowRuntime };

package/dist/cloudflare/step.d.mts

@@ -1,22 +1,22 @@
 import { WorkflowContext } from "../types/definition.mjs";
-import { WorkflowStepApi } from "../types/step.mjs";
+import { StepApi } from "../types/step.mjs";
 import { CloudflareNonRetryableErrorConstructor, CloudflareWorkflowStep } from "./types.mjs";
 import { Logger } from "@temelj/log";
 //#region src/cloudflare/step.d.ts
-interface CreateCloudflareWorkflowStepApiOptions {
+interface CreateCloudflareStepApiOptions {
   readonly step: CloudflareWorkflowStep;
   readonly logger?: Logger;
   readonly nonRetryableError?: CloudflareNonRetryableErrorConstructor;
 }
 /** Creates the Temelj durable command API backed by one Cloudflare Workflow step object. */
-declare function createCloudflareWorkflowStepApi(options: CreateCloudflareWorkflowStepApiOptions): WorkflowStepApi;
-interface CreateCloudflareWorkflowContextOptions<TInput> extends CreateCloudflareWorkflowStepApiOptions {
+export declare function createCloudflareStepApi(options: CreateCloudflareStepApiOptions): StepApi;
+export interface CreateCloudflareContextOptions<TInput> extends CreateCloudflareStepApiOptions {
   readonly input: TInput;
   readonly runId: string;
   readonly workflowName: string;
   readonly workflowVersion?: string;
   readonly createdAt: Temporal.Instant;
 }
-declare function createCloudflareWorkflowContext<TInput>(options: CreateCloudflareWorkflowContextOptions<TInput>): WorkflowContext<TInput>;
+export declare function createCloudflareContext<TInput>(options: CreateCloudflareContextOptions<TInput>): WorkflowContext<TInput>;
 //#endregion
-export { CreateCloudflareWorkflowContextOptions, CreateCloudflareWorkflowStepApiOptions, createCloudflareWorkflowContext, createCloudflareWorkflowStepApi };
+export {};

package/dist/cloudflare/step.mjs

@@ -1,11 +1,10 @@
-import { WorkflowNonRetryableError } from "../errors/failures.mjs";
-import { durationTotal } from "../utility.mjs";
 import { WorkflowCapabilityError } from "../errors/capability.mjs";
+import { WorkflowNonRetryableError } from "../errors/failures.mjs";
 import "../errors/mod.mjs";
-import { resolveWaitForMessageInput } from "../message-options.mjs";
-import { resolveWorkflowRetryConfig } from "../engine/retry.mjs";
-import { decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue } from "./codec.mjs";
-import { makeCloudflareWorkflowEventType, makeCloudflareWorkflowStepName } from "./name.mjs";
+import { createMessageWait } from "../message-options.mjs";
+import { resolveRetryConfig } from "../engine/retry.mjs";
+import { decodeCloudflareValue, durationMilliseconds, encodeCloudflareValue } from "./codec.mjs";
+import { makeCloudflareEventType, makeCloudflareStepName } from "./name.mjs";
 import { validateStandardSchema } from "@temelj/standard-schema";
 import { createNoopLogger } from "@temelj/log";
 //#region src/cloudflare/step.ts
@@ -18,23 +17,23 @@ const MAXIMUM_CLOUDFLARE_DELAY_MILLISECONDS = 31536e6;
 const MAXIMUM_CLOUDFLARE_STEP_TIMEOUT_MILLISECONDS = 18e5;
 const MAXIMUM_EVENT_WAIT_MILLISECONDS = 31536e6;
 /** Creates the Temelj durable command API backed by one Cloudflare Workflow step object. */
-function createCloudflareWorkflowStepApi(options) {
+function createCloudflareStepApi(options) {
 	const logger = options.logger ?? createNoopLogger();
 	const runTask = async (config, callback) => {
 		const commandName = config.commandId ?? config.name;
 		if (commandName === void 0) throw new TypeError("Cloudflare durable task requires a name or commandId");
-		const retry = resolveWorkflowRetryConfig(config.retry, DEFAULT_STEP_RETRY, "Cloudflare Workflow step retry");
-		const stepName = makeCloudflareWorkflowStepName(commandName);
+		const retry = resolveRetryConfig(config.retry, DEFAULT_STEP_RETRY, "Cloudflare Workflow step retry");
+		const stepName = makeCloudflareStepName(commandName);
 		const encoded = await options.step.do(stepName, cloudflareStepConfig(config, retry), async (cloudflareContext) => {
 			const context = workflowStepContext(commandName, retry, cloudflareContext, logger);
 			try {
-				return encodeCloudflareWorkflowValue(await callback(context));
+				return encodeCloudflareValue(await callback(context));
 			} catch (error) {
 				if (error instanceof WorkflowNonRetryableError && options.nonRetryableError !== void 0) throw new options.nonRetryableError(error.message, error.name);
 				throw error;
 			}
 		});
-		return decodeCloudflareWorkflowValue(encoded, `Cloudflare step ${commandName} result`);
+		return decodeCloudflareValue(encoded, `Cloudflare step ${commandName} result`);
 	};
 	const deterministic = {
 		now: async (commandId = "now") => await runTask({ commandId: `deterministic:${commandId}` }, () => Temporal.Now.instant()),
@@ -48,65 +47,73 @@ function createCloudflareWorkflowStepApi(options) {
 			return bytes;
 		})
 	};
-	const waitMessage = (async (messageInput, channelOptions) => {
-		const wait = resolveWaitForMessageInput(messageInput, channelOptions);
+	const waitMessage = createMessageWait(async (wait) => {
 		const timeout = wait.timeout === void 0 ? MAXIMUM_EVENT_WAIT_MILLISECONDS : durationMilliseconds(wait.timeout, "Cloudflare Workflow message timeout");
 		if (timeout < 1e3 || timeout > MAXIMUM_EVENT_WAIT_MILLISECONDS) throw new RangeError("Cloudflare Workflow message timeout must be between 1 second and 365 days");
-		const event = await options.step.waitForEvent(makeCloudflareWorkflowStepName(wait.commandId ?? wait.name ?? wait.messageId), {
-			type: makeCloudflareWorkflowEventType(wait.messageId),
+		const event = await options.step.waitForEvent(makeCloudflareStepName(wait.commandId ?? wait.name ?? wait.messageId), {
+			type: makeCloudflareEventType(wait.messageId),
 			timeout
 		});
-		const decoded = decodeCloudflareWorkflowValue(event.payload, `Cloudflare message ${wait.messageId} payload`);
+		const decoded = decodeCloudflareValue(event.payload, `Cloudflare message ${wait.messageId} payload`);
 		if (wait.schema === void 0) return decoded;
 		return await validateStandardSchema(wait.schema, decoded, "Workflow message validation failed");
 	});
 	return {
 		log: logger,
-		task: {
-			run: runTask,
-			async call(definition, ...args) {
-				return await runTask(definition.config, async (context) => {
-					return await definition.handler(...args, context);
-				});
-			},
-			async sleep(commandId, duration) {
-				await options.step.sleep(makeCloudflareWorkflowStepName(commandId), durationMilliseconds(duration, "Cloudflare Workflow sleep"));
-			},
-			async sleepUntil(commandId, timestamp) {
-				await options.step.sleepUntil(makeCloudflareWorkflowStepName(commandId), timestamp.epochMilliseconds);
-			}
+		run: runTask,
+		async call(definition, ...args) {
+			return await runTask(definition.config, async (context) => {
+				return await definition.handler(context, ...args);
+			});
+		},
+		async sleep(commandId, duration) {
+			await options.step.sleep(makeCloudflareStepName(commandId), durationMilliseconds(duration, "Cloudflare Workflow sleep"));
+		},
+		async sleepUntil(commandId, timestamp) {
+			await options.step.sleepUntil(makeCloudflareStepName(commandId), timestamp.epochMilliseconds);
+		},
+		workflow: {
+			run: unsupportedWorkflow,
+			start: unsupportedWorkflow
 		},
-		workflow: unsupportedFacet("child workflows"),
 		message: {
 			send: async () => WorkflowCapabilityError.unsupported("Cloudflare in-workflow message send"),
 			wait: waitMessage
 		},
-		lock: unsupportedFacet("Cloudflare workflow locks"),
-		runData: unsupportedFacet("Cloudflare workflow run data"),
+		lock: {
+			acquire: unsupportedLock,
+			release: unsupportedLock,
+			with: unsupportedLock
+		},
+		runData: {
+			setMetadata: unsupportedRunData,
+			setAttributes: unsupportedRunData
+		},
 		deterministic,
-		stream: unsupportedFacet("Cloudflare workflow streams"),
-		hook: unsupportedFacet("Cloudflare workflow hooks")
+		stream: { create: unsupportedStream },
+		hook: {
+			create: unsupportedHook,
+			createWebhook: unsupportedHook
+		}
 	};
 }
-function createCloudflareWorkflowContext(options) {
+function createCloudflareContext(options) {
 	const logger = options.logger ?? createNoopLogger();
-	const step = createCloudflareWorkflowStepApi({
+	const step = createCloudflareStepApi({
 		...options,
 		logger
 	});
+	const run = {
+		id: options.runId,
+		workflowName: options.workflowName,
+		workflowVersion: options.workflowVersion,
+		createdAt: options.createdAt
+	};
 	return {
 		input: options.input,
 		step,
-		deterministic: step.deterministic,
-		log: logger,
-		run: {
-			id: options.runId,
-			workflowName: options.workflowName,
-			...options.workflowVersion === void 0 ? {} : { workflowVersion: options.workflowVersion },
-			createdAt: options.createdAt
-		},
-		signal: new AbortController().signal,
-		version: options.workflowVersion
+		run,
+		signal: new AbortController().signal
 	};
 }
 function cloudflareStepConfig(config, retry) {
@@ -122,7 +129,7 @@ function cloudflareStepConfig(config, retry) {
 			limit: retry.maximumAttempts,
 			delay: ({ ctx }) => retryDelay(initialDelay, retry, ctx.attempt, maximumDelay)
 		},
-		...timeout === void 0 ? {} : { timeout }
+		timeout
 	};
 }
 function retryDelay(initialDelay, retry, attempt, maximumDelay) {
@@ -143,18 +150,23 @@ function workflowStepContext(commandName, retry, context, logger) {
 		log: logger
 	};
 }
-function durationMilliseconds(duration, label) {
-	const milliseconds = durationTotal(duration);
-	if (!Number.isSafeInteger(milliseconds) || milliseconds < 0) throw new RangeError(`${label} must resolve to non-negative whole milliseconds`);
-	return milliseconds;
-}
 function assertMaximumDuration(value, maximum, label) {
 	if (value > maximum) throw new RangeError(`${label} must not exceed ${maximum} milliseconds`);
 }
-function unsupportedFacet(capability) {
-	return new Proxy({}, { get() {
-		return () => WorkflowCapabilityError.unsupported(capability);
-	} });
+function unsupportedWorkflow() {
+	return WorkflowCapabilityError.unsupported("child workflows");
+}
+function unsupportedLock() {
+	return WorkflowCapabilityError.unsupported("Cloudflare workflow locks");
+}
+function unsupportedRunData() {
+	return WorkflowCapabilityError.unsupported("Cloudflare workflow run data");
+}
+function unsupportedStream() {
+	return WorkflowCapabilityError.unsupported("Cloudflare workflow streams");
+}
+function unsupportedHook() {
+	return WorkflowCapabilityError.unsupported("Cloudflare workflow hooks");
 }
 //#endregion
-export { createCloudflareWorkflowContext, createCloudflareWorkflowStepApi };
+export { createCloudflareContext, createCloudflareStepApi };

package/dist/cloudflare/types.d.mts

@@ -1,17 +1,18 @@
+import { CloudflareWorkersModule } from "@cloudflare/workers-types";
 //#region src/cloudflare/types.d.ts
 /** Minimal Cloudflare Workflow binding used by the Temelj adapter. */
-interface CloudflareWorkflowBinding {
+export interface CloudflareWorkflowBinding {
   create(options?: CloudflareWorkflowInstanceCreateOptions): Promise<CloudflareWorkflowInstance>;
   createBatch(items: readonly CloudflareWorkflowInstanceCreateOptions[]): Promise<readonly CloudflareWorkflowInstance[]>;
   get(id: string): Promise<CloudflareWorkflowInstance>;
 }
 /** Parameters accepted when creating a Cloudflare Workflow instance. */
-interface CloudflareWorkflowInstanceCreateOptions {
+export interface CloudflareWorkflowInstanceCreateOptions {
   readonly id?: string;
   readonly params?: unknown;
 }
 /** Minimal Cloudflare Workflow instance used by the Temelj adapter. */
-interface CloudflareWorkflowInstance {
+export interface CloudflareWorkflowInstance {
   readonly id: string;
   status(): Promise<CloudflareWorkflowInstanceStatus>;
   terminate(options?: {
@@ -22,8 +23,7 @@ interface CloudflareWorkflowInstance {
     readonly payload?: unknown;
   }): Promise<void>;
 }
-/** Status returned by a Cloudflare Workflow instance binding. */
-interface CloudflareWorkflowInstanceStatus {
+export interface CloudflareWorkflowInstanceStatus {
   readonly status: "queued" | "running" | "paused" | "errored" | "terminated" | "complete" | "waiting" | "waitingForPause" | "unknown";
   readonly error?: {
     readonly name: string;
@@ -31,45 +31,28 @@ interface CloudflareWorkflowInstanceStatus {
   };
   readonly output?: unknown;
 }
-/** Minimal Cloudflare durable step context. */
-interface CloudflareWorkflowStepContext {
-  readonly step: {
-    readonly name: string;
-    readonly count: number;
-  };
-  readonly attempt: number;
-  readonly config: CloudflareWorkflowStepConfig;
-}
+/** Cloudflare's context for static and dynamic retry configurations. */
+export type CloudflareWorkflowStepContext = CloudflareWorkersModule.WorkflowStepContext<CloudflareWorkersModule.WorkflowDelayDuration | CloudflareWorkersModule.WorkflowDelayFunction>;
 /** Cloudflare retry and timeout configuration used by a durable step. */
-interface CloudflareWorkflowStepConfig {
-  readonly retries?: {
-    readonly limit: number;
-    readonly delay: number | ((input: {
-      readonly ctx: CloudflareWorkflowStepContext;
-      readonly error: Error;
-    }) => number | Promise<number>);
-    readonly backoff?: "constant" | "linear" | "exponential";
-  };
-  readonly timeout?: number;
-}
+export type CloudflareWorkflowStepConfig = CloudflareWorkersModule.WorkflowStepConfig;
 /** Event returned by Cloudflare after a matching `waitForEvent` call. */
-interface CloudflareWorkflowStepEvent<TPayload = unknown> {
+export interface CloudflareWorkflowStepEvent<TPayload = unknown> {
   readonly payload: TPayload;
   readonly timestamp: Date;
   readonly type: string;
 }
 /** Minimal Cloudflare durable step API used by the Temelj adapter. */
-interface CloudflareWorkflowStep {
-  do<T>(name: string, config: CloudflareWorkflowStepConfig, callback: (context: CloudflareWorkflowStepContext) => T | Promise<T>): Promise<T>;
+export interface CloudflareWorkflowStep {
+  do(name: string, config: CloudflareWorkflowStepConfig, callback: (context: CloudflareWorkflowStepContext) => Promise<string>): Promise<string>;
   sleep(name: string, duration: number): Promise<void>;
   sleepUntil(name: string, timestamp: number): Promise<void>;
-  waitForEvent<T>(name: string, options: {
+  waitForEvent(name: string, options: {
     readonly type: string;
-    readonly timeout: string | number;
-  }): Promise<CloudflareWorkflowStepEvent<T>>;
+    readonly timeout: number;
+  }): Promise<CloudflareWorkflowStepEvent>;
 }
 /** Event delivered to the generic Temelj Cloudflare entrypoint. */
-interface CloudflareWorkflowEvent<TPayload = unknown> {
+export interface CloudflareWorkflowEvent<TPayload = unknown> {
   readonly payload: TPayload;
   readonly timestamp: Date;
   readonly instanceId: string;
@@ -79,9 +62,7 @@ interface CloudflareWorkflowEvent<TPayload = unknown> {
     readonly scheduledTime: number;
   };
 }
-/** Constructor used to convert Temelj non-retryable errors for Cloudflare. */
-interface CloudflareNonRetryableErrorConstructor {
+export interface CloudflareNonRetryableErrorConstructor {
   new (message: string, name?: string): Error;
 }
-//#endregion
-export { CloudflareNonRetryableErrorConstructor, CloudflareWorkflowBinding, CloudflareWorkflowEvent, CloudflareWorkflowInstance, CloudflareWorkflowInstanceCreateOptions, CloudflareWorkflowInstanceStatus, CloudflareWorkflowStep, CloudflareWorkflowStepConfig, CloudflareWorkflowStepContext, CloudflareWorkflowStepEvent };
+//#endregion

package/dist/collection.d.mts

@@ -1,15 +1,12 @@
 //#region src/collection.d.ts
 /** Returns whether a value matches one expected value or any value in an expected list. */
-declare function matchesOptionalValue<T>(value: T, expected: T | readonly T[]): boolean;
+export declare function matchesOptionalValue<T>(value: T, expected: T | readonly T[]): boolean;
 /** Returns the first item for each key while preserving input order. */
-declare function uniqueBy<T>(items: readonly T[], key: (item: T) => string): readonly T[];
-/** Returns a copy of an object without properties whose value is undefined. */
-declare function omitUndefined(value: object): Record<string, unknown>;
-/** Returns an object containing one property only when the value is defined. */
-declare function optionalProperty<TKey extends string, TValue>(key: TKey, value: TValue | undefined): Partial<Record<TKey, TValue>>;
-/** Returns sorted string values from a set. */
-declare function sortedStringSet(values: ReadonlySet<string>): readonly string[];
-/** Returns an object containing a sorted string set only when the set is not empty. */
-declare function optionalSortedStringSetProperty<TKey extends string>(key: TKey, values: ReadonlySet<string>): Partial<Record<TKey, readonly string[]>>;
+export declare function uniqueBy<T>(items: readonly T[], key: (item: T) => string): readonly T[];
+/** Own record fields after removing undefined values. */
+type DefinedProperties<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? K : never]?: Exclude<T[K], undefined>; };
+/** Copies the defined own enumerable fields of a plain record. */
+export declare function omitUndefined<T extends object>(value: T): DefinedProperties<T>;
+export declare function limitItems<T>(items: readonly T[], limit: number | undefined): readonly T[];
 //#endregion
-export { matchesOptionalValue, omitUndefined, optionalProperty, optionalSortedStringSetProperty, sortedStringSet, uniqueBy };
+export {};