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

package/dist/bundle.d.mts

@@ -0,0 +1,29 @@
+import { Registry, WorkflowDefinitionConfig, WorkflowImplementation } from "./types/definition.mjs";
+import { Schema } from "@temelj/standard-schema";
+//#region src/bundle.d.ts
+interface WorkflowImplementationLike {
+  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;
+}
+/** Workflow value accepted by an immutable workflow bundle. */
+type WorkflowBundleEntry = WorkflowImplementationLike | ((...args: never[]) => unknown);
+/** Immutable collection of workflow implementations shared by workflow hosts. */
+interface WorkflowBundle {
+  readonly kind: "workflow-bundle";
+  readonly workflows: readonly WorkflowImplementation<unknown, unknown>[];
+}
+/** Defines an immutable workflow collection for local and deployed workflow hosts. */
+declare function defineWorkflowBundle(entries: readonly WorkflowBundleEntry[]): WorkflowBundle;
+/** Creates an independent mutable registry populated from a workflow bundle. */
+declare function createWorkflowBundleRegistry(bundle: WorkflowBundle): Registry;
+//#endregion
+export { WorkflowBundle, WorkflowBundleEntry, createWorkflowBundleRegistry, defineWorkflowBundle };

package/dist/bundle.mjs

@@ -0,0 +1,28 @@
+import { WorkflowDefinitionError } from "./errors/definition.mjs";
+import "./errors/mod.mjs";
+import { getCompiledWorkflowDefinition } from "./compiled-function.mjs";
+import { Registry } from "./registry.mjs";
+//#region src/bundle.ts
+/** Defines an immutable workflow collection for local and deployed workflow hosts. */
+function defineWorkflowBundle(entries) {
+	const registry = new Registry();
+	for (const entry of entries) registry.register(workflowImplementationFromBundleEntry(entry));
+	return Object.freeze({
+		kind: "workflow-bundle",
+		workflows: Object.freeze([...registry.entries()])
+	});
+}
+/** Creates an independent mutable registry populated from a workflow bundle. */
+function createWorkflowBundleRegistry(bundle) {
+	const registry = new Registry();
+	for (const workflow of bundle.workflows) registry.register(workflow);
+	return registry;
+}
+function workflowImplementationFromBundleEntry(entry) {
+	if (typeof entry !== "function") return entry;
+	const implementation = getCompiledWorkflowDefinition(entry);
+	if (implementation === void 0) WorkflowDefinitionError.compiledMetadataMissing();
+	return implementation;
+}
+//#endregion
+export { createWorkflowBundleRegistry, defineWorkflowBundle };

package/dist/client/create.d.mts

@@ -1,14 +1,22 @@
 import { RegistryLike, WorkflowDefinition, WorkflowHandler, WorkflowImplementation } from "../types/definition.mjs";
+import { WorkflowBundle } from "../bundle.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 {
+interface CreateWorkflowClientBaseOptions extends WorkflowClientEngineOptions {
   readonly engine?: WorkflowClientEngine;
   readonly workerEngine?: WorkflowWorkerEngine;
-  readonly registry?: RegistryLike;
 }
+/** Options for creating a workflow client with either a registry or an immutable bundle. */
+type CreateWorkflowClientOptions = CreateWorkflowClientBaseOptions & ({
+  readonly registry?: RegistryLike;
+  readonly workflows?: never;
+} | {
+  readonly registry?: never;
+  readonly workflows?: WorkflowBundle;
+});
 declare function createWorkflowClient(options?: CreateWorkflowClientOptions): WorkflowClient$1;
 /** Workflow client facade implementation. */
 declare class WorkflowClient implements WorkflowClient$1 {

package/dist/client/create.mjs

@@ -1,6 +1,7 @@
+import { Registry } from "../registry.mjs";
+import { createWorkflowBundleRegistry } from "../bundle.mjs";
 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);
@@ -20,14 +21,15 @@ var WorkflowClient = class {
 	#now;
 	#registry;
 	constructor(options = {}) {
-		const { engine, workerEngine, registry, now, ...engineOptions } = options;
+		const { engine, workerEngine, registry, workflows, now, ...engineOptions } = options;
+		if (registry !== void 0 && workflows !== void 0) throw new TypeError("Workflow client options cannot include both registry and workflows");
 		this.#now = now ?? Temporal.Now.instant;
 		this.#engine = engine ?? createWorkflowEngine({
 			...engineOptions,
 			now: this.#now
 		});
 		this.#workerEngine = workerEngine ?? workflowWorkerEngineFromCandidate(this.#engine);
-		this.#registry = registry ?? new Registry();
+		this.#registry = registry ?? (workflows === void 0 ? new Registry() : createWorkflowBundleRegistry(workflows));
 		this.runs = createWorkflowClientRunsApi(() => this.#engine, this.#now);
 		this.admin = createWorkflowClientAdminApi(() => this.#engine, this.#now);
 		this.schedules = createWorkflowClientSchedulesApi(() => this.#engine, this.#now);

package/dist/client/facades.mjs

@@ -120,13 +120,16 @@ function createWorkflowClientMessagesApi(getEngine) {
 function createWorkflowClientWorkersApi(getEngine, getRegistry, now) {
 	return {
 		create: (options) => {
-			return new WorkflowWorker(workerOptionsFromClientOptions(requireWorkflowWorkerEngine(getEngine()), getRegistry(), now, options));
+			const engine = requireWorkflowWorkerEngine(getEngine());
+			return new WorkflowWorker(workerOptionsFromClientOptions(engine, getRegistry(), now, options));
 		},
 		processRun: async (runId, options) => {
-			await new WorkflowWorker(workerOptionsFromClientOptions(requireWorkflowWorkerEngine(getEngine()), getRegistry(), now, workerOptionsFromWakeOptions(options))).processRun(runId);
+			const engine = requireWorkflowWorkerEngine(getEngine());
+			await new WorkflowWorker(workerOptionsFromClientOptions(engine, getRegistry(), now, workerOptionsFromWakeOptions(options))).processRun(runId);
 		},
 		wakeDueRuns: async (options) => {
-			const worker = new WorkflowWorker(workerOptionsFromClientOptions(requireWorkflowWorkerEngine(getEngine()), getRegistry(), now, workerOptionsFromWakeOptions(options)));
+			const engine = requireWorkflowWorkerEngine(getEngine());
+			const worker = new WorkflowWorker(workerOptionsFromClientOptions(engine, getRegistry(), now, workerOptionsFromWakeOptions(options)));
 			const filters = options === void 0 ? {} : options;
 			const maxRuns = resolvePositiveSafeIntegerOption(options?.maxRuns, "Workflow worker maxRuns") ?? 1;
 			let processedRuns = 0;

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

@@ -11,6 +11,7 @@ import { WorkflowRunHandleReader, WorkflowRunMaintenance, WorkflowStreamReader }
 import { WorkflowRunHandle as WorkflowRunHandle$1 } from "../types/client.mjs";
 import "../mod.mjs";
 import { StorageValue } from "@temelj/storage";
+import "temporal-polyfill/global";
 //#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>;

package/dist/client/run-handle.mjs

@@ -4,6 +4,7 @@ import "../errors/mod.mjs";
 import { workflowErrorFromRecord } from "../errors/records.mjs";
 import { durationBetween } from "../temporal.mjs";
 import { nonNegativeTimerDelay, sleep } from "../timer.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) {
@@ -59,7 +60,8 @@ var WorkflowRunHandle = class {
 			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));
+				const nowInstant = this.#now();
+				const remainingDelay = durationTotal(durationBetween(nowInstant, deadlineAt));
 				if (remainingDelay <= 0) WorkflowResultTimeoutError.timedOut(this.runId, timeout);
 				sleepDelay = Math.min(sleepDelay, remainingDelay);
 			}

package/dist/cloudflare/cloudflare.d.mts

@@ -0,0 +1,12 @@
+//#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>;
+  }
+}
+declare module "cloudflare:workflows" {
+  export class NonRetryableError extends Error {
+    constructor(message: string, name?: string);
+  }
+}

package/dist/cloudflare/codec.d.mts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+//#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>;
+/** 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;
+//#endregion
+export { CloudflareWorkflowEnvelope, decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue, parseCloudflareWorkflowEnvelope };

package/dist/cloudflare/codec.mjs

@@ -0,0 +1,25 @@
+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()
+});
+function encodeCloudflareWorkflowValue(value) {
+	return cloudflareWorkflowCodec.encode(value);
+}
+function decodeCloudflareWorkflowValue(value, label) {
+	if (typeof value !== "string") throw new TypeError(`${label} must be an encoded string`);
+	return cloudflareWorkflowCodec.decode(value);
+}
+function parseCloudflareWorkflowEnvelope(value) {
+	const parsed = cloudflareWorkflowEnvelopeSchema.safeParse(value);
+	if (!parsed.success) throw new TypeError("Cloudflare Workflow payload is not a valid Temelj workflow envelope");
+	return parsed.data;
+}
+//#endregion
+export { decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue, parseCloudflareWorkflowEnvelope };

package/dist/cloudflare/entrypoint.d.mts

@@ -0,0 +1,12 @@
+import { RegistryLike } from "../types/definition.mjs";
+import { Logger } from "@temelj/log";
+import { WorkflowEntrypoint } from "cloudflare:workers";
+//#region src/cloudflare/entrypoint.d.ts
+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 };

package/dist/cloudflare/entrypoint.mjs

@@ -0,0 +1,18 @@
+import { runCloudflareWorkflow } from "./execution.mjs";
+import { WorkflowEntrypoint } from "cloudflare:workers";
+import { NonRetryableError } from "cloudflare:workflows";
+//#region src/cloudflare/entrypoint.ts
+/** Creates a Cloudflare Workflow entrypoint class that dispatches through a Temelj registry. */
+function createCloudflareWorkflowEntrypoint(options) {
+	return class TemeljCloudflareWorkflowEntrypoint extends WorkflowEntrypoint {
+		async run(event, step) {
+			return await runCloudflareWorkflow({
+				registry: options.registry,
+				...options.logger === void 0 ? {} : { logger: options.logger },
+				nonRetryableError: NonRetryableError
+			}, event, step);
+		}
+	};
+}
+//#endregion
+export { createCloudflareWorkflowEntrypoint };

package/dist/cloudflare/execution.d.mts

@@ -0,0 +1,13 @@
+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 {
+  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 };

package/dist/cloudflare/execution.mjs

@@ -0,0 +1,28 @@
+import { WorkflowCapabilityError } from "../errors/capability.mjs";
+import "../errors/mod.mjs";
+import { parseWorkflowInput } from "../definition.mjs";
+import { decodeCloudflareWorkflowValue, encodeCloudflareWorkflowValue, parseCloudflareWorkflowEnvelope } from "./codec.mjs";
+import { resolveCloudflareWorkflowImplementation } from "./registry.mjs";
+import { createCloudflareWorkflowContext } 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 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,
+		step,
+		runId: event.instanceId,
+		workflowName: implementation.name,
+		...implementation.version === void 0 ? {} : { 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));
+}
+//#endregion
+export { runCloudflareWorkflow };

package/dist/cloudflare/host.d.mts

@@ -0,0 +1,19 @@
+import { WorkflowBundle } from "../bundle.mjs";
+import { createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
+import { CloudflareWorkflowBinding } from "./types.mjs";
+import { CloudflareWorkflowRuntime, CreateCloudflareWorkflowRuntimeOptions } from "./runtime.mjs";
+import { Logger } from "@temelj/log";
+//#region src/cloudflare/host.d.ts
+interface CreateCloudflareWorkflowHostOptions {
+  readonly workflows: WorkflowBundle;
+  readonly logger?: Logger;
+}
+type CreateCloudflareWorkflowHostRuntimeOptions = Omit<CreateCloudflareWorkflowRuntimeOptions, "binding" | "registration" | "registry">;
+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 };

package/dist/cloudflare/host.mjs

@@ -0,0 +1,24 @@
+import { createWorkflowBundleRegistry } from "../bundle.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);
+	return {
+		Entrypoint: createCloudflareWorkflowEntrypoint({
+			registry,
+			...options.logger === void 0 ? {} : { logger: options.logger }
+		}),
+		createRuntime(binding, runtimeOptions = {}) {
+			return createCloudflareWorkflowRuntime({
+				...runtimeOptions,
+				binding,
+				registry,
+				registration: "static"
+			});
+		}
+	};
+}
+//#endregion
+export { createCloudflareWorkflowHost };

package/dist/cloudflare/mod.d.mts

@@ -0,0 +1,8 @@
+import { CreateCloudflareWorkflowEntrypointOptions, createCloudflareWorkflowEntrypoint } from "./entrypoint.mjs";
+import { CloudflareNonRetryableErrorConstructor, CloudflareWorkflowBinding, CloudflareWorkflowEvent, CloudflareWorkflowInstance, CloudflareWorkflowInstanceCreateOptions, CloudflareWorkflowInstanceStatus, CloudflareWorkflowStep, CloudflareWorkflowStepConfig, CloudflareWorkflowStepContext, CloudflareWorkflowStepEvent } from "./types.mjs";
+import { RunCloudflareWorkflowOptions, runCloudflareWorkflow } from "./execution.mjs";
+import { CloudflareWorkflowMessagesApi, CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, CreateCloudflareWorkflowRuntimeOptions, createCloudflareWorkflowRuntime } from "./runtime.mjs";
+import { CloudflareWorkflowHost, CreateCloudflareWorkflowHostOptions, CreateCloudflareWorkflowHostRuntimeOptions, createCloudflareWorkflowHost } from "./host.mjs";
+import { createCloudflareWorkflowRegistry, 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 };

package/dist/cloudflare/mod.mjs

@@ -0,0 +1,7 @@
+import { createCloudflareWorkflowRegistry, 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 };

package/dist/cloudflare/name.d.mts

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

package/dist/cloudflare/name.mjs

@@ -0,0 +1,22 @@
+//#region src/cloudflare/name.ts
+const CLOUDFLARE_NAME_CHARACTERS = /[^a-zA-Z0-9_-]+/g;
+function makeCloudflareWorkflowStepName(value) {
+	return makeCloudflareName(value, 256, "step");
+}
+function makeCloudflareWorkflowEventType(value) {
+	return makeCloudflareName(value, 100, "event");
+}
+function makeCloudflareName(value, maximumLength, fallback) {
+	const normalized = value.replace(CLOUDFLARE_NAME_CHARACTERS, "-").replace(/^-+/, "");
+	return `${(normalized === "" ? fallback : normalized).slice(0, maximumLength - 16)}-${fnv1a(value)}`.slice(0, maximumLength);
+}
+function fnv1a(value) {
+	let hash = 14695981039346656037n;
+	for (let index = 0; index < value.length; index++) {
+		hash ^= BigInt(value.charCodeAt(index));
+		hash = BigInt.asUintN(64, hash * 1099511628211n);
+	}
+	return hash.toString(36).padStart(13, "0");
+}
+//#endregion
+export { makeCloudflareWorkflowEventType, makeCloudflareWorkflowStepName };

package/dist/cloudflare/registry.d.mts

@@ -0,0 +1,24 @@
+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";
+//#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 };

package/dist/cloudflare/registry.mjs

@@ -0,0 +1,26 @@
+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);
+	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 };

package/dist/cloudflare/runtime.d.mts

@@ -0,0 +1,30 @@
+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 { CloudflareWorkflowBinding } from "./types.mjs";
+//#region src/cloudflare/runtime.d.ts
+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>>;
+}
+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 {
+  readonly runs: CloudflareWorkflowRuntimeRunsApi;
+  readonly messages: CloudflareWorkflowMessagesApi;
+}
+/** Creates a runtime facade over a generic Cloudflare Workflow binding. */
+declare function createCloudflareWorkflowRuntime(options: CreateCloudflareWorkflowRuntimeOptions): CloudflareWorkflowRuntime;
+//#endregion
+export { CloudflareWorkflowMessagesApi, CloudflareWorkflowRuntime, CloudflareWorkflowRuntimeRunsApi, CreateCloudflareWorkflowRuntimeOptions, createCloudflareWorkflowRuntime };