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

package/dist/client/run-handle.mjs

@@ -1,61 +1,67 @@
+import { durationBetween, durationTotal } from "../temporal.mjs";
 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 "../errors/mod.mjs";
+import { getRunTimeline } from "../engine/inspection.mjs";
+import { readRunResult } from "../engine/run-utils.mjs";
+import { cancelWorkflowRun, setRunAttributes, updateWorkflowRunMetadata } from "../engine/run-service.mjs";
 import { nonNegativeTimerDelay, sleep } from "../timer.mjs";
+import { followStream, getStreamInfo, readStream, waitForStream, waitForStreamChunk, waitForStreamTerminal } from "../engine/stream-reader.mjs";
 import "temporal-polyfill/global";
 //#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);
+function createRunHandle(engine, ref, now) {
+	return new WorkflowRunHandle(engine, ref, now);
 }
 var WorkflowRunHandle = class {
-	/** @inheritdoc */
 	runId;
-	/** @inheritdoc */
 	workflowName;
-	/** @inheritdoc */
 	workflowVersion;
 	#engine;
+	#ref;
 	#now;
-	constructor(engine, definition, runId, now) {
+	streams;
+	constructor(engine, ref, now) {
 		this.#engine = engine;
+		this.#ref = ref;
 		this.#now = now;
-		this.runId = runId;
-		this.workflowName = definition.name;
-		if (definition.version !== void 0) this.workflowVersion = definition.version;
+		this.runId = ref.runId;
+		this.workflowName = ref.definition.name;
+		const context = engine.context;
+		const runId = ref.runId;
+		this.streams = {
+			getInfo: (name) => getStreamInfo(context, runId, name),
+			follow: (name, options) => followStream(context, runId, name, options),
+			wait: (name, options) => waitForStream(context, runId, name, options),
+			waitForChunk: (name, afterIndex, options) => waitForStreamChunk(context, runId, name, afterIndex, options),
+			waitForTerminal: (name, options) => waitForStreamTerminal(context, runId, name, options),
+			read: (name, options) => readStream(context, runId, name, options)
+		};
+		if (ref.definition.version !== void 0) this.workflowVersion = ref.definition.version;
 	}
-	/** @inheritdoc */
 	async getRun() {
-		const run = await this.#engine.getRun(this.runId);
+		const run = await this.#engine.store.getRun(this.runId);
 		if (run === void 0) WorkflowRunNotFoundError.notFound(this.runId);
 		return run;
 	}
-	/** @inheritdoc */
 	async status() {
-		const run = await this.#engine.getRun(this.runId);
+		const run = await this.#engine.store.getRun(this.runId);
 		if (run === void 0) WorkflowRunNotFoundError.notFound(this.runId);
 		return run.status;
 	}
-	/** @inheritdoc */
 	async events() {
-		return await this.#engine.getEvents(this.runId);
+		return await this.#engine.store.getEvents(this.runId);
 	}
-	/** @inheritdoc */
 	async timeline() {
-		return await this.#engine.getTimeline(this.runId);
+		return await getRunTimeline(this.#engine.context, 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());
+			const result = await readRunResult(this.#engine.store, this.#ref.definition, this.runId, this.#now());
+			if (result.run.status === "canceled") WorkflowRunCanceledError.canceled(this.runId);
 			if (result.kind === "completed") return result.output;
 			if (result.kind === "failed") throw workflowErrorFromRecord(result.error);
 			let sleepDelay = pollInterval;
@@ -68,91 +74,15 @@ var WorkflowRunHandle = class {
 			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);
+		return await updateWorkflowRunMetadata(this.#engine.context, this.#engine.lifecycle, this.runId, metadata);
 	}
-	/** @inheritdoc */
 	async setAttributes(attributes) {
-		return await this.#engine.setRunAttributes(this.runId, attributes);
+		return await setRunAttributes(this.#engine.context, this.runId, attributes);
 	}
-	/** @inheritdoc */
 	async cancel() {
-		return await this.#engine.cancelRun(this.runId);
+		return await cancelWorkflowRun(this.#engine.context, this.#engine.lifecycle, 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 };
+export { WorkflowRunHandle, createRunHandle };

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

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

package/dist/client/worker-options.mjs

@@ -4,21 +4,21 @@ function workerOptionsFromClientOptions(engine, registry, now, options) {
 		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 }
+		workerId: options?.workerId,
+		leaseDuration: options?.leaseDuration,
+		pollInterval: options?.pollInterval,
+		heartbeatInterval: options?.heartbeatInterval,
+		stopDrainTimeout: options?.stopDrainTimeout,
+		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 }
+		workerId: options?.workerId,
+		leaseDuration: options?.leaseDuration,
+		heartbeatInterval: options?.heartbeatInterval,
+		stopDrainTimeout: options?.stopDrainTimeout,
+		missingImplementationRetry: options?.missingImplementationRetry
 	};
 }
 //#endregion

package/dist/cloudflare/cloudflare.d.mts

@@ -1,12 +1,11 @@
 //#region src/cloudflare/cloudflare.d.ts
 declare module "cloudflare:workers" {
-  export abstract class WorkflowEntrypoint<TEnv = unknown, TPayload = unknown> {
-    protected readonly env: TEnv;
-    abstract run(event: unknown, step: unknown): Promise<unknown>;
-  }
+  export const WorkflowEntrypoint: typeof import("@cloudflare/workers-types").CloudflareWorkersModule.WorkflowEntrypoint;
 }
 declare module "cloudflare:workflows" {
   export class NonRetryableError extends Error {
     constructor(message: string, name?: string);
   }
-}
+}
+//#endregion
+export {};

package/dist/cloudflare/codec.d.mts

@@ -1,16 +1,31 @@
-import { z } from "zod";
+import { WorkflowDefinition } from "../types/definition.mjs";
+import { CloudflareWorkflowInstanceStatus } from "./types.mjs";
+import { SchemaOutput } from "@temelj/standard-schema";
+import { StorageValue } from "@temelj/storage";
 //#region src/cloudflare/codec.d.ts
-declare const cloudflareWorkflowEnvelopeSchema: z.ZodObject<{
-  kind: z.ZodLiteral<"temelj-workflow">;
-  version: z.ZodLiteral<1>;
-  workflowName: z.ZodString;
-  workflowVersion: z.ZodOptional<z.ZodString>;
-  input: z.ZodString;
-}, z.core.$strip>;
+declare const cloudflareEnvelopeSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  kind: import("@temelj/standard-schema").Schema<unknown, "temelj-workflow">;
+  version: import("@temelj/standard-schema").Schema<unknown, 1>;
+  workflowName: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowVersion: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  input: import("@temelj/standard-schema").Schema<unknown, string>;
+}>>;
 /** Serialized payload dispatched through the generic Cloudflare entrypoint. */
-type CloudflareWorkflowEnvelope = z.infer<typeof cloudflareWorkflowEnvelopeSchema>;
-declare function encodeCloudflareWorkflowValue(value: unknown): string;
-declare function decodeCloudflareWorkflowValue(value: unknown, label: string): unknown;
-declare function parseCloudflareWorkflowEnvelope(value: unknown): CloudflareWorkflowEnvelope;
+export type CloudflareEnvelope = SchemaOutput<typeof cloudflareEnvelopeSchema>;
+export declare function encodeCloudflareValue(value: unknown): string;
+export declare function decodeCloudflareValue(value: unknown, label: string): StorageValue | undefined;
+export declare function parseCloudflareEnvelope(value: unknown): CloudflareEnvelope;
+declare const cloudflareResultEnvelopeSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  kind: import("@temelj/standard-schema").Schema<unknown, "temelj-workflow-result">;
+  version: import("@temelj/standard-schema").Schema<unknown, 1>;
+  workflowName: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowVersion: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  output: import("@temelj/standard-schema").Schema<unknown, string>;
+}>>;
+/** Serialized result coupled to the workflow contract that produced it. */
+export type CloudflareResultEnvelope = SchemaOutput<typeof cloudflareResultEnvelopeSchema>;
+/** Validates the provider result and its workflow identity before decoding the output. */
+export declare function decodeCloudflareResult(state: CloudflareWorkflowInstanceStatus, definition: WorkflowDefinition): StorageValue | undefined;
+export declare function durationMilliseconds(duration: Temporal.Duration, label: string): number;
 //#endregion
-export { CloudflareWorkflowEnvelope, decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue, parseCloudflareWorkflowEnvelope };
+export {};

package/dist/cloudflare/codec.mjs

@@ -1,25 +1,48 @@
+import { durationTotal } from "../temporal.mjs";
+import { parse } from "../schema/common.mjs";
+import { persistedValueSchema } from "../schema/persisted-value.mjs";
+import { ss } from "@temelj/standard-schema";
 import { createSuperJsonStorageCodec } from "@temelj/storage";
-import { z } from "zod";
 //#region src/cloudflare/codec.ts
-const cloudflareWorkflowCodec = createSuperJsonStorageCodec({ format: "string" });
-const cloudflareWorkflowEnvelopeSchema = z.object({
-	kind: z.literal("temelj-workflow"),
-	version: z.literal(1),
-	workflowName: z.string().min(1),
-	workflowVersion: z.string().min(1).optional(),
-	input: z.string()
+const cloudflareCodec = createSuperJsonStorageCodec({ format: "string" });
+const nonEmptyStringSchema = ss.nonEmptyString();
+const cloudflareEnvelopeSchema = ss.object({
+	kind: ss.literal("temelj-workflow"),
+	version: ss.literal(1),
+	workflowName: nonEmptyStringSchema,
+	workflowVersion: ss.optional(nonEmptyStringSchema),
+	input: ss.string()
 });
-function encodeCloudflareWorkflowValue(value) {
-	return cloudflareWorkflowCodec.encode(value);
+function encodeCloudflareValue(value) {
+	return cloudflareCodec.encode(parse(ss.optional(persistedValueSchema), value));
 }
-function decodeCloudflareWorkflowValue(value, label) {
-	if (typeof value !== "string") throw new TypeError(`${label} must be an encoded string`);
-	return cloudflareWorkflowCodec.decode(value);
+function decodeCloudflareValue(value, label) {
+	const encoded = ss.safeParseSync(ss.string(), value);
+	if (!encoded.success) throw new TypeError(`${label} must be an encoded string`);
+	return parse(ss.optional(persistedValueSchema), cloudflareCodec.decode(encoded.value));
 }
-function parseCloudflareWorkflowEnvelope(value) {
-	const parsed = cloudflareWorkflowEnvelopeSchema.safeParse(value);
+function parseCloudflareEnvelope(value) {
+	const parsed = ss.safeParseSync(cloudflareEnvelopeSchema, value);
 	if (!parsed.success) throw new TypeError("Cloudflare Workflow payload is not a valid Temelj workflow envelope");
-	return parsed.data;
+	return parsed.value;
+}
+const cloudflareResultEnvelopeSchema = ss.object({
+	kind: ss.literal("temelj-workflow-result"),
+	version: ss.literal(1),
+	workflowName: nonEmptyStringSchema,
+	workflowVersion: ss.optional(nonEmptyStringSchema),
+	output: ss.string()
+});
+/** Validates the provider result and its workflow identity before decoding the output. */
+function decodeCloudflareResult(state, definition) {
+	const envelope = parse(cloudflareResultEnvelopeSchema, JSON.parse(parse(ss.string(), state.output)));
+	if (envelope.workflowName !== definition.name || envelope.workflowVersion !== definition.version) throw new TypeError("Cloudflare Workflow result does not match the requested workflow name and version");
+	return decodeCloudflareValue(envelope.output, "Cloudflare Workflow result output");
+}
+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;
 }
 //#endregion
-export { decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue, parseCloudflareWorkflowEnvelope };
+export { decodeCloudflareResult, decodeCloudflareValue, durationMilliseconds, encodeCloudflareValue, parseCloudflareEnvelope };

package/dist/cloudflare/entrypoint.d.mts

@@ -2,11 +2,10 @@ import { RegistryLike } from "../types/definition.mjs";
 import { Logger } from "@temelj/log";
 import { WorkflowEntrypoint } from "cloudflare:workers";
 //#region src/cloudflare/entrypoint.d.ts
-interface CreateCloudflareWorkflowEntrypointOptions {
+export interface CreateCloudflareWorkflowEntrypointOptions {
   readonly registry: RegistryLike;
   readonly logger?: Logger;
 }
 /** Creates a Cloudflare Workflow entrypoint class that dispatches through a Temelj registry. */
-declare function createCloudflareWorkflowEntrypoint<TEnv = unknown>(options: CreateCloudflareWorkflowEntrypointOptions): typeof WorkflowEntrypoint<TEnv, unknown>;
-//#endregion
-export { CreateCloudflareWorkflowEntrypointOptions, createCloudflareWorkflowEntrypoint };
+export declare function createCloudflareWorkflowEntrypoint<TEnv = unknown>(options: CreateCloudflareWorkflowEntrypointOptions): typeof WorkflowEntrypoint<TEnv, unknown>;
+//#endregion

package/dist/cloudflare/entrypoint.mjs

@@ -6,11 +6,12 @@ import { NonRetryableError } from "cloudflare:workflows";
 function createCloudflareWorkflowEntrypoint(options) {
 	return class TemeljCloudflareWorkflowEntrypoint extends WorkflowEntrypoint {
 		async run(event, step) {
-			return await runCloudflareWorkflow({
+			const runOptions = {
 				registry: options.registry,
-				...options.logger === void 0 ? {} : { logger: options.logger },
+				logger: options.logger,
 				nonRetryableError: NonRetryableError
-			}, event, step);
+			};
+			return await runCloudflareWorkflow(runOptions, event, step);
 		}
 	};
 }

package/dist/cloudflare/execution.d.mts

@@ -2,12 +2,11 @@ import { RegistryLike } from "../types/definition.mjs";
 import { CloudflareNonRetryableErrorConstructor, CloudflareWorkflowEvent, CloudflareWorkflowStep } from "./types.mjs";
 import { Logger } from "@temelj/log";
 //#region src/cloudflare/execution.d.ts
-interface RunCloudflareWorkflowOptions {
+export interface RunCloudflareWorkflowOptions {
   readonly registry: RegistryLike;
   readonly logger?: Logger;
   readonly nonRetryableError?: CloudflareNonRetryableErrorConstructor;
 }
 /** Dispatches one Cloudflare Workflow invocation to a registered Temelj implementation. */
-declare function runCloudflareWorkflow(options: RunCloudflareWorkflowOptions, event: CloudflareWorkflowEvent, step: CloudflareWorkflowStep): Promise<string>;
-//#endregion
-export { RunCloudflareWorkflowOptions, runCloudflareWorkflow };
+export declare function runCloudflareWorkflow(options: RunCloudflareWorkflowOptions, event: CloudflareWorkflowEvent, step: CloudflareWorkflowStep): Promise<string>;
+//#endregion

package/dist/cloudflare/execution.mjs

@@ -1,28 +1,35 @@
 import { WorkflowCapabilityError } from "../errors/capability.mjs";
 import "../errors/mod.mjs";
-import { parseWorkflowInput } from "../definition.mjs";
-import { decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue, parseCloudflareWorkflowEnvelope } from "./codec.mjs";
+import { parseInput } from "../engine/serialization.mjs";
+import { decodeCloudflareValue, encodeCloudflareValue, parseCloudflareEnvelope } from "./codec.mjs";
 import { resolveCloudflareWorkflowImplementation } from "./registry.mjs";
-import { createCloudflareWorkflowContext } from "./step.mjs";
+import { createCloudflareContext } from "./step.mjs";
 //#region src/cloudflare/execution.ts
 /** Dispatches one Cloudflare Workflow invocation to a registered Temelj implementation. */
 async function runCloudflareWorkflow(options, event, step) {
-	const envelope = parseCloudflareWorkflowEnvelope(event.payload);
+	const envelope = parseCloudflareEnvelope(event.payload);
 	const implementation = resolveCloudflareWorkflowImplementation(options.registry, envelope.workflowName, envelope.workflowVersion);
 	if (implementation.config.retry !== void 0) WorkflowCapabilityError.unsupported("Cloudflare workflow-level retry configuration");
-	const rawInput = decodeCloudflareWorkflowValue(envelope.input, "Cloudflare Workflow input");
-	const input = await parseWorkflowInput(implementation.definition, rawInput);
-	const context = createCloudflareWorkflowContext({
-		input,
+	const rawInput = decodeCloudflareValue(envelope.input, "Cloudflare Workflow input");
+	const contextOptions = {
+		input: await parseInput(implementation.definition, rawInput),
 		step,
 		runId: event.instanceId,
 		workflowName: implementation.name,
-		...implementation.version === void 0 ? {} : { workflowVersion: implementation.version },
+		workflowVersion: implementation.version,
 		createdAt: Temporal.Instant.fromEpochMilliseconds(event.timestamp.getTime()),
-		...options.logger === void 0 ? {} : { logger: options.logger },
-		...options.nonRetryableError === void 0 ? {} : { nonRetryableError: options.nonRetryableError }
-	});
-	return encodeCloudflareWorkflowValue(await implementation.handler(context));
+		logger: options.logger,
+		nonRetryableError: options.nonRetryableError
+	};
+	const context = createCloudflareContext(contextOptions);
+	const output = {
+		kind: "temelj-workflow-result",
+		version: 1,
+		workflowName: implementation.name,
+		output: encodeCloudflareValue(await implementation.handler(context)),
+		workflowVersion: implementation.version
+	};
+	return JSON.stringify(output);
 }
 //#endregion
 export { runCloudflareWorkflow };

package/dist/cloudflare/host.d.mts

@@ -1,19 +1,18 @@
 import { WorkflowBundle } from "../bundle.mjs";
-import { createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
 import { CloudflareWorkflowBinding } from "./types.mjs";
+import { createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
 import { CloudflareWorkflowRuntime, CreateCloudflareWorkflowRuntimeOptions } from "./runtime.mjs";
 import { Logger } from "@temelj/log";
 //#region src/cloudflare/host.d.ts
-interface CreateCloudflareWorkflowHostOptions {
+export interface CreateCloudflareWorkflowHostOptions {
   readonly workflows: WorkflowBundle;
   readonly logger?: Logger;
 }
-type CreateCloudflareWorkflowHostRuntimeOptions = Omit<CreateCloudflareWorkflowRuntimeOptions, "binding" | "registration" | "registry">;
-interface CloudflareWorkflowHost<TEnv> {
+export type CreateCloudflareWorkflowHostRuntimeOptions = Omit<CreateCloudflareWorkflowRuntimeOptions, "binding" | "registration" | "registry">;
+export interface CloudflareWorkflowHost<TEnv> {
   readonly Entrypoint: ReturnType<typeof createCloudflareWorkflowEntrypoint<TEnv>>;
   createRuntime(binding: CloudflareWorkflowBinding, options?: CreateCloudflareWorkflowHostRuntimeOptions): CloudflareWorkflowRuntime;
 }
 /** Creates a Cloudflare host backed by one immutable workflow bundle. */
-declare function createCloudflareWorkflowHost<TEnv = unknown>(options: CreateCloudflareWorkflowHostOptions): CloudflareWorkflowHost<TEnv>;
-//#endregion
-export { CloudflareWorkflowHost, CreateCloudflareWorkflowHostOptions, CreateCloudflareWorkflowHostRuntimeOptions, createCloudflareWorkflowHost };
+export declare function createCloudflareWorkflowHost<TEnv = unknown>(options: CreateCloudflareWorkflowHostOptions): CloudflareWorkflowHost<TEnv>;
+//#endregion

package/dist/cloudflare/host.mjs

@@ -1,15 +1,16 @@
-import { createWorkflowBundleRegistry } from "../bundle.mjs";
+import { Registry } from "../registry.mjs";
 import { createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
 import { createCloudflareWorkflowRuntime } from "./runtime.mjs";
 //#region src/cloudflare/host.ts
 /** Creates a Cloudflare host backed by one immutable workflow bundle. */
 function createCloudflareWorkflowHost(options) {
-	const registry = createWorkflowBundleRegistry(options.workflows);
+	const registry = new Registry(options.workflows.workflows);
+	const entrypointOptions = {
+		registry,
+		logger: options.logger
+	};
 	return {
-		Entrypoint: createCloudflareWorkflowEntrypoint({
-			registry,
-			...options.logger === void 0 ? {} : { logger: options.logger }
-		}),
+		Entrypoint: createCloudflareWorkflowEntrypoint(entrypointOptions),
 		createRuntime(binding, runtimeOptions = {}) {
 			return createCloudflareWorkflowRuntime({
 				...runtimeOptions,

package/dist/cloudflare/mod.d.mts

@@ -1,8 +1,8 @@
-import { CreateCloudflareWorkflowEntrypointOptions, createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
 import { CloudflareNonRetryableErrorConstructor, CloudflareWorkflowBinding, CloudflareWorkflowEvent, CloudflareWorkflowInstance, CloudflareWorkflowInstanceCreateOptions, CloudflareWorkflowInstanceStatus, CloudflareWorkflowStep, CloudflareWorkflowStepConfig, CloudflareWorkflowStepContext, CloudflareWorkflowStepEvent } from "./types.mjs";
+import { CreateCloudflareWorkflowEntrypointOptions, createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
 import { RunCloudflareWorkflowOptions, runCloudflareWorkflow } from "./execution.mjs";
-import { CloudflareWorkflowMessagesApi, CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, CreateCloudflareWorkflowRuntimeOptions, createCloudflareWorkflowRuntime } from "./runtime.mjs";
+import { CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, CreateCloudflareWorkflowRuntimeOptions, createCloudflareWorkflowRuntime } from "./runtime.mjs";
 import { CloudflareWorkflowHost, CreateCloudflareWorkflowHostOptions, CreateCloudflareWorkflowHostRuntimeOptions, createCloudflareWorkflowHost } from "./host.mjs";
-import { createCloudflareWorkflowRegistry, resolveCloudflareWorkflowImplementation } from "./registry.mjs";
+import { resolveCloudflareWorkflowImplementation } from "./registry.mjs";
 import "temporal-polyfill/global";
-export { type CloudflareNonRetryableErrorConstructor, type CloudflareWorkflowBinding, type CloudflareWorkflowEvent, CloudflareWorkflowHost, type CloudflareWorkflowInstance, type CloudflareWorkflowInstanceCreateOptions, type CloudflareWorkflowInstanceStatus, CloudflareWorkflowMessagesApi, CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, type CloudflareWorkflowStep, type CloudflareWorkflowStepConfig, type CloudflareWorkflowStepContext, type CloudflareWorkflowStepEvent, CreateCloudflareWorkflowEntrypointOptions, CreateCloudflareWorkflowHostOptions, CreateCloudflareWorkflowHostRuntimeOptions, CreateCloudflareWorkflowRuntimeOptions, RunCloudflareWorkflowOptions, createCloudflareWorkflowEntrypoint, createCloudflareWorkflowHost, createCloudflareWorkflowRegistry, createCloudflareWorkflowRuntime, resolveCloudflareWorkflowImplementation, runCloudflareWorkflow };
+export { type CloudflareNonRetryableErrorConstructor, type CloudflareWorkflowBinding, type CloudflareWorkflowEvent, CloudflareWorkflowHost, type CloudflareWorkflowInstance, type CloudflareWorkflowInstanceCreateOptions, type CloudflareWorkflowInstanceStatus, CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, type CloudflareWorkflowStep, type CloudflareWorkflowStepConfig, type CloudflareWorkflowStepContext, type CloudflareWorkflowStepEvent, CreateCloudflareWorkflowEntrypointOptions, CreateCloudflareWorkflowHostOptions, CreateCloudflareWorkflowHostRuntimeOptions, CreateCloudflareWorkflowRuntimeOptions, RunCloudflareWorkflowOptions, createCloudflareWorkflowEntrypoint, createCloudflareWorkflowHost, createCloudflareWorkflowRuntime, resolveCloudflareWorkflowImplementation, runCloudflareWorkflow };

package/dist/cloudflare/mod.mjs

@@ -1,7 +1,7 @@
-import { createCloudflareWorkflowRegistry, resolveCloudflareWorkflowImplementation } from "./registry.mjs";
+import { resolveCloudflareWorkflowImplementation } from "./registry.mjs";
 import { runCloudflareWorkflow } from "./execution.mjs";
 import { createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
 import { createCloudflareWorkflowRuntime } from "./runtime.mjs";
 import { createCloudflareWorkflowHost } from "./host.mjs";
 import "temporal-polyfill/global";
-export { createCloudflareWorkflowEntrypoint, createCloudflareWorkflowHost, createCloudflareWorkflowRegistry, createCloudflareWorkflowRuntime, resolveCloudflareWorkflowImplementation, runCloudflareWorkflow };
+export { createCloudflareWorkflowEntrypoint, createCloudflareWorkflowHost, createCloudflareWorkflowRuntime, resolveCloudflareWorkflowImplementation, runCloudflareWorkflow };

package/dist/cloudflare/name.d.mts

@@ -1,5 +1,4 @@
 //#region src/cloudflare/name.d.ts
-declare function makeCloudflareWorkflowStepName(value: string): string;
-declare function makeCloudflareWorkflowEventType(value: string): string;
-//#endregion
-export { makeCloudflareWorkflowEventType, makeCloudflareWorkflowStepName };
+export declare function makeCloudflareStepName(value: string): string;
+export declare function makeCloudflareEventType(value: string): string;
+//#endregion

package/dist/cloudflare/name.mjs

@@ -1,9 +1,9 @@
 //#region src/cloudflare/name.ts
 const CLOUDFLARE_NAME_CHARACTERS = /[^a-zA-Z0-9_-]+/g;
-function makeCloudflareWorkflowStepName(value) {
+function makeCloudflareStepName(value) {
 	return makeCloudflareName(value, 256, "step");
 }
-function makeCloudflareWorkflowEventType(value) {
+function makeCloudflareEventType(value) {
 	return makeCloudflareName(value, 100, "event");
 }
 function makeCloudflareName(value, maximumLength, fallback) {
@@ -19,4 +19,4 @@ function fnv1a(value) {
 	return hash.toString(36).padStart(13, "0");
 }
 //#endregion
-export { makeCloudflareWorkflowEventType, makeCloudflareWorkflowStepName };
+export { makeCloudflareEventType, makeCloudflareStepName };

package/dist/cloudflare/registry.d.mts

@@ -1,24 +1,4 @@
-import { RegistryLike, WorkflowDefinitionConfig, WorkflowImplementation } from "../types/definition.mjs";
-import { CompiledWorkflowFunction } from "../types/client.mjs";
-import { Registry } from "../registry.mjs";
-import { Schema } from "@temelj/standard-schema";
+import { RegistryLike, WorkflowImplementation } from "../types/definition.mjs";
 //#region src/cloudflare/registry.d.ts
-interface CloudflareWorkflowImplementationLike {
-  readonly kind: "implementation";
-  readonly definition: {
-    readonly kind: "definition";
-    readonly config: WorkflowDefinitionConfig<Schema | undefined>;
-    readonly name: string;
-    readonly version?: string;
-  };
-  readonly config: WorkflowDefinitionConfig<Schema | undefined>;
-  readonly name: string;
-  readonly version?: string;
-  readonly handler: (...args: never[]) => unknown;
-}
-type CloudflareWorkflowRegistryEntry = CloudflareWorkflowImplementationLike | CompiledWorkflowFunction<readonly unknown[], unknown>;
-/** Creates a registry shared by the Cloudflare entrypoint and runtime facade. */
-declare function createCloudflareWorkflowRegistry(entries?: readonly CloudflareWorkflowRegistryEntry[]): Registry;
-declare function resolveCloudflareWorkflowImplementation(registry: RegistryLike, name: string, version?: string): WorkflowImplementation<unknown, unknown>;
-//#endregion
-export { createCloudflareWorkflowRegistry, resolveCloudflareWorkflowImplementation };
+export declare function resolveCloudflareWorkflowImplementation(registry: RegistryLike, name: string, version?: string): WorkflowImplementation<unknown, unknown>;
+//#endregion