@vite-hub/workflow 0.0.4 → 0.1.0

package/dist/rolldown-runtime-CMFfr-1z.js

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };

package/dist/runtime/cloudflare-runner.d.ts

@@ -1,13 +1,12 @@
-import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, w as WorkflowProviderStep } from "../types-D82WmfZa.js";
 import { t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
-
 //#region src/runtime/cloudflare-runner.d.ts
-interface CloudflareWorkflowEvent {
+export interface CloudflareWorkflowEvent {
   id?: string;
   instanceId?: string;
   payload?: unknown;
 }
-interface RunCloudflareWorkflowOptions {
+export interface RunCloudflareWorkflowOptions {
   config: false | ResolvedWorkflowOptions | undefined;
   createNonRetryableError?: (error: Error & {
     isRetryable: false;
@@ -18,14 +17,5 @@ interface RunCloudflareWorkflowOptions {
   registry: WorkflowDefinitionRegistry;
   step?: WorkflowProviderStep;
 }
-declare function runCloudflareWorkflow({
-  config,
-  createNonRetryableError,
-  env,
-  event,
-  name,
-  registry,
-  step
-}: RunCloudflareWorkflowOptions): Promise<unknown>;
-//#endregion
-export { CloudflareWorkflowEvent, RunCloudflareWorkflowOptions, runCloudflareWorkflow };
+export declare function runCloudflareWorkflow({ config, createNonRetryableError, env, event, name, registry, step }: RunCloudflareWorkflowOptions): Promise<unknown>;
+//#endregion

package/dist/runtime/cloudflare-runner.js

@@ -1,9 +1,44 @@
-import { i as runWithActiveCloudflareEnv } from "../cloudflare-env-DjxQNbrx.js";
-import { runWorkflowHandler } from "./execute.js";
+import { t as workflowErrorDiagnostics } from "../error-diagnostics-pwNFvAHP.js";
+import { t as hasRuntimeType } from "../runtime-type-DBCvIh5x.js";
+import { i as runWithActiveCloudflareEnv } from "../cloudflare-env-BNrYo29x.js";
+import { runSerializedWorkflowHandler } from "./execute.js";
 import { loadWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./state.js";
 //#region src/runtime/cloudflare-runner.ts
 function isNonRetryableError(error) {
-	return error instanceof Error && error.isRetryable === false;
+	if (!hasRuntimeType(error, "object") || error === null) return false;
+	try {
+		const candidate = error;
+		if (Reflect.get(candidate, "isRetryable") !== false) return false;
+		const nativeIsError = Reflect.get(Error, "isError");
+		if (hasRuntimeType(nativeIsError, "function")) return nativeIsError(candidate) === true;
+		const clone = Reflect.get(globalThis, "structuredClone");
+		if (!hasRuntimeType(clone, "function")) return false;
+		try {
+			return clone(candidate) instanceof Error;
+		} catch {
+			const descriptors = /* @__PURE__ */ new Map();
+			try {
+				for (const key of Reflect.ownKeys(candidate)) {
+					const descriptor = Reflect.getOwnPropertyDescriptor(candidate, key);
+					if (!descriptor?.configurable || !("value" in descriptor)) continue;
+					descriptors.set(key, descriptor);
+					Reflect.defineProperty(candidate, key, {
+						...descriptor,
+						value: void 0
+					});
+				}
+				try {
+					return clone(candidate) instanceof Error;
+				} catch {
+					return false;
+				}
+			} finally {
+				for (const [key, descriptor] of descriptors) Reflect.defineProperty(candidate, key, descriptor);
+			}
+		}
+	} catch {
+		return false;
+	}
 }
 function translateNonRetryableError(error, createNonRetryableError) {
 	return createNonRetryableError && isNonRetryableError(error) ? createNonRetryableError(error) : error;
@@ -34,9 +69,9 @@ async function runCloudflareWorkflow({ config, createNonRetryableError, env, eve
 	};
 	return await runWithActiveCloudflareEnv(env, async () => {
 		const definition = await loadWorkflowDefinition(name);
-		if (!definition) throw new Error(`Missing workflow definition: ${name}`);
+		if (!definition) throw workflowErrorDiagnostics.WORKFLOW_R0015({ message: `Missing workflow definition: ${name}` });
 		try {
-			return await runWithWorkflowRuntimeEvent(runtimeEvent, () => runWorkflowHandler({
+			return await runWithWorkflowRuntimeEvent(runtimeEvent, () => runSerializedWorkflowHandler({
 				id: event?.instanceId || event?.id,
 				name,
 				payload: event?.payload,

package/dist/runtime/cloudflare-shared.d.ts

@@ -1,2 +1,3 @@
 import { a as setActiveCloudflareEnv, i as runWithActiveCloudflareEnv, n as CloudflareWorkerExecutionContext, r as createCloudflareRuntimeEvent, t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
+import "../cloudflare-shared-CaxrMD1A.js";
 export { type CloudflareWorkerEnv, type CloudflareWorkerExecutionContext, createCloudflareRuntimeEvent, runWithActiveCloudflareEnv, setActiveCloudflareEnv };

package/dist/runtime/cloudflare-shared.js

@@ -1,2 +1,2 @@
-import { a as setActiveCloudflareEnv, i as runWithActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "../cloudflare-env-DjxQNbrx.js";
+import { a as setActiveCloudflareEnv, i as runWithActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "../cloudflare-env-BNrYo29x.js";
 export { createCloudflareRuntimeEvent, runWithActiveCloudflareEnv, setActiveCloudflareEnv };

package/dist/runtime/cloudflare-vite.d.ts

@@ -1,18 +1,16 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
-import { t as WorkflowApp } from "../_app-DgwN4ulW.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-D82WmfZa.js";
+import { t as VitehubApp } from "../app-BojnC_yf.js";
 import { n as CloudflareWorkerExecutionContext, t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
-
 //#region src/runtime/cloudflare-vite.d.ts
-type CloudflareWorkerApp = WorkflowApp;
-interface WorkflowCloudflareWorkerOptions {
+export type CloudflareWorkerApp = VitehubApp;
+export interface WorkflowCloudflareWorkerOptions {
   app?: CloudflareWorkerApp;
   registry?: WorkflowDefinitionRegistry;
   workflow?: false | ResolvedWorkflowOptions;
 }
-interface WorkflowCloudflareWorker {
+export interface WorkflowCloudflareWorker {
   fetch: (request: Request, env: CloudflareWorkerEnv, context: CloudflareWorkerExecutionContext) => Promise<Response>;
 }
-declare function installWorkflowCloudflareRuntime(options?: WorkflowCloudflareWorkerOptions): void;
-declare function createWorkflowCloudflareWorker(options?: WorkflowCloudflareWorkerOptions): WorkflowCloudflareWorker;
-//#endregion
-export { CloudflareWorkerApp, WorkflowCloudflareWorker, WorkflowCloudflareWorkerOptions, createWorkflowCloudflareWorker, installWorkflowCloudflareRuntime };
+export declare function installWorkflowCloudflareRuntime(options?: WorkflowCloudflareWorkerOptions): void;
+export declare function createWorkflowCloudflareWorker(options?: WorkflowCloudflareWorkerOptions): WorkflowCloudflareWorker;
+//#endregion

package/dist/runtime/cloudflare-vite.js

@@ -1,2 +1,2 @@
-import { n as installWorkflowCloudflareRuntime, t as createWorkflowCloudflareWorker } from "../cloudflare-vite-BkDgB6Sr.js";
+import { n as installWorkflowCloudflareRuntime, t as createWorkflowCloudflareWorker } from "../cloudflare-vite-B3IabBsv.js";
 export { createWorkflowCloudflareWorker, installWorkflowCloudflareRuntime };

package/dist/runtime/execute.d.ts

@@ -1,11 +1,12 @@
-import { A as WorkflowStepFunction, C as WorkflowProviderStep, g as WorkflowExecutionContext, j as WorkflowStepOptions, p as WorkflowDefinition } from "../types-B9RdRkKh.js";
-
+import { M as WorkflowStepOptions, S as WorkflowProviderContext, j as WorkflowStepFunction, p as WorkflowDefinition, w as WorkflowProviderStep } from "../types-D82WmfZa.js";
+import { SerializedResponse } from "@vite-hub/runtime";
 //#region src/runtime/execute.d.ts
-declare function runProviderStep<TResult>(step: WorkflowProviderStep | undefined, name: string, run: () => TResult | Promise<TResult>, options?: WorkflowStepOptions): Promise<TResult>;
-declare function createWorkflowSteps(context: WorkflowExecutionContext, stepModules: Array<{
+export declare function runProviderStep<TResult>(step: WorkflowProviderStep | undefined, name: string, run: () => TResult | Promise<TResult>, options?: WorkflowStepOptions): Promise<TResult>;
+export declare function createWorkflowSteps(context: WorkflowProviderContext, stepModules: Array<{
   name: string;
   run: WorkflowStepFunction;
 }>): Record<string, WorkflowStepFunction>;
-declare function runWorkflowHandler<TPayload, TResult>(context: WorkflowExecutionContext<TPayload>, definition: WorkflowDefinition<TPayload, TResult>): Promise<TResult>;
-//#endregion
-export { createWorkflowSteps, runProviderStep, runWorkflowHandler };
+export declare function runWorkflowHandler<TPayload, TResult>(context: WorkflowProviderContext<TPayload>, definition: WorkflowDefinition<TPayload, TResult>): Promise<Response>;
+/** Encode inside the root step so both checkpoints and final outputs survive replay. */
+export declare function runSerializedWorkflowHandler<TPayload, TResult>(context: WorkflowProviderContext<TPayload>, definition: WorkflowDefinition<TPayload, TResult>): Promise<SerializedResponse>;
+//#endregion

package/dist/runtime/execute.js

@@ -1,3 +1,5 @@
+import { t as workflowErrorDiagnostics } from "../error-diagnostics-pwNFvAHP.js";
+import { serializeResponse, toResponse } from "@vite-hub/runtime";
 //#region src/runtime/execute.ts
 const defaultStepOptions = { retries: {
 	backoff: "exponential",
@@ -12,14 +14,35 @@ function toStepPropertyName(file) {
 	return file.split("/").pop().replace(/\.(?:c|m)?[jt]s$/i, "").replace(/^\d+[.-]?/, "").replace(/[-_.]+([a-z0-9])/gi, (_, char) => char.toUpperCase());
 }
 function createWorkflowSteps(context, stepModules) {
+	const names = /* @__PURE__ */ new Map();
 	return Object.fromEntries(stepModules.map((module) => {
-		return [toStepPropertyName(module.name), async (input) => await runProviderStep(context.step, `${context.name}/${module.name}`, () => module.run(input))];
+		const propertyName = toStepPropertyName(module.name);
+		if (!propertyName) throw workflowErrorDiagnostics.WORKFLOW_C0011({ message: `[vitehub] Workflow step file ${JSON.stringify(module.name)} normalizes to an empty step property. Rename the file so the step property is non-empty.` });
+		const previousName = names.get(propertyName);
+		if (previousName) throw workflowErrorDiagnostics.WORKFLOW_C0010({ message: `[vitehub] Workflow step files ${JSON.stringify(previousName)} and ${JSON.stringify(module.name)} both normalize to the \`${propertyName}\` step property. Rename one file so each step property is unique.` });
+		names.set(propertyName, module.name);
+		return [propertyName, async (input) => await runProviderStep(context.step, `${context.name}/${module.name}`, () => module.run(input))];
 	}));
 }
+/**
+* Gives every handler a step runner. Generated folder Workflows replace this
+* empty runner with their step files.
+*/
+function toExecutionContext(context) {
+	return {
+		...context,
+		steps: {}
+	};
+}
 async function runWorkflowHandler(context, definition) {
-	const run = () => definition.handler(context);
-	if (definition.options?.rootStep === false) return await run();
-	return await runProviderStep(context.step, context.name, run);
+	const run = () => definition.handler(toExecutionContext(context));
+	const value = definition.options?.rootStep === false ? await run() : await runProviderStep(context.step, context.name, run);
+	return toResponse(value);
+}
+/** Encode inside the root step so both checkpoints and final outputs survive replay. */
+async function runSerializedWorkflowHandler(context, definition) {
+	const run = async () => serializeResponse(toResponse(await definition.handler(toExecutionContext(context))));
+	return definition.options?.rootStep === false ? await run() : await runProviderStep(context.step, context.name, run);
 }
 //#endregion
-export { createWorkflowSteps, runProviderStep, runWorkflowHandler };
+export { createWorkflowSteps, runProviderStep, runSerializedWorkflowHandler, runWorkflowHandler };

package/dist/runtime/openworkflow-worker.d.ts

@@ -1,20 +1,18 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-D82WmfZa.js";
 import { getOpenWorkflowRuntime } from "./openworkflow.js";
 import { ViteHubError } from "@vite-hub/runtime";
-
 //#region src/runtime/openworkflow-worker.d.ts
 type OpenWorkflowWorker = ReturnType<Awaited<ReturnType<typeof getOpenWorkflowRuntime>>["client"]["newWorker"]>;
-interface CreateOpenWorkflowWorkerOptions {
+export interface CreateOpenWorkflowWorkerOptions {
   concurrency?: number;
   config?: false | ResolvedWorkflowOptions;
   registry?: WorkflowDefinitionRegistry;
 }
-interface StartOpenWorkflowWorkerOptions extends CreateOpenWorkflowWorkerOptions {
+export interface StartOpenWorkflowWorkerOptions extends CreateOpenWorkflowWorkerOptions {
   onError?: (error: ViteHubError) => Promise<void> | void;
   signal?: AbortSignal;
   signals?: boolean;
 }
-declare function createOpenWorkflowWorker(options?: CreateOpenWorkflowWorkerOptions): Promise<OpenWorkflowWorker>;
-declare function startOpenWorkflowWorker(options?: StartOpenWorkflowWorkerOptions): Promise<OpenWorkflowWorker>;
-//#endregion
-export { CreateOpenWorkflowWorkerOptions, StartOpenWorkflowWorkerOptions, createOpenWorkflowWorker, startOpenWorkflowWorker };
+export declare function createOpenWorkflowWorker(options?: CreateOpenWorkflowWorkerOptions): Promise<OpenWorkflowWorker>;
+export declare function startOpenWorkflowWorker(options?: StartOpenWorkflowWorkerOptions): Promise<OpenWorkflowWorker>;
+//#endregion

package/dist/runtime/openworkflow-worker.js

@@ -1,4 +1,5 @@
-import { n as isRuntimeRecord, t as hasRuntimeType } from "../runtime-type-DGUn8Ple.js";
+import { t as workflowErrorDiagnostics } from "../error-diagnostics-pwNFvAHP.js";
+import { n as isRuntimeRecord, t as hasRuntimeType } from "../runtime-type-DBCvIh5x.js";
 import { a as createWorkflowError, r as runWorkflowProviderOperation } from "../provider-operation-CW2cYfVy.js";
 import { getOpenWorkflowRuntime, registerOpenWorkflowDefinition } from "./openworkflow.js";
 import { getInlineWorkflowDefinitions, getWorkflowRuntimeConfig, getWorkflowRuntimeRegistry, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinitionForModule } from "./state.js";
@@ -8,7 +9,7 @@ function getProcess() {
 	return globalThis.process;
 }
 function isWorkflowDefinition(value) {
-	return isRuntimeRecord(value) && hasRuntimeType(value.handler, "function");
+	return isRuntimeRecord(value) && Object.hasOwn(value, "handler") && hasRuntimeType(value.handler, "function");
 }
 async function loadRegistryDefinitions(registry) {
 	const definitions = /* @__PURE__ */ new Map();
@@ -27,13 +28,13 @@ async function loadRegistryDefinitions(registry) {
 function mergeInlineDefinitions(definitions) {
 	for (const [name, definition] of getInlineWorkflowDefinitions()) {
 		const existing = definitions.get(name);
-		if (existing && existing !== definition) throw new Error(`Duplicate workflow name "${name}" from inline and discovered definitions.`);
+		if (existing && existing !== definition) throw workflowErrorDiagnostics.WORKFLOW_R0016({ message: `Duplicate workflow name "${name}" from inline and discovered definitions.` });
 		definitions.set(name, definition);
 	}
 }
 async function createOpenWorkflowWorker(options = {}) {
 	const config = options.config ?? getWorkflowRuntimeConfig();
-	if (!config || config.provider !== "openworkflow") throw new Error("OpenWorkflow worker requires workflow.provider \"openworkflow\".");
+	if (!config || config.provider !== "openworkflow") throw workflowErrorDiagnostics.WORKFLOW_R0017({ message: "OpenWorkflow worker requires workflow.provider \"openworkflow\"." });
 	const registry = options.registry ?? getWorkflowRuntimeRegistry() ?? {};
 	setWorkflowRuntimeConfig(config);
 	setWorkflowRuntimeRegistry(registry);

package/dist/runtime/openworkflow.d.ts

@@ -1,5 +1,4 @@
-import { f as WorkflowDeferOptions, l as ResolvedWorkflowOptions, p as WorkflowDefinition, w as WorkflowRun } from "../types-B9RdRkKh.js";
-
+import { T as WorkflowRun, f as WorkflowDeferOptions, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-D82WmfZa.js";
 //#region src/runtime/openworkflow.d.ts
 type OpenWorkflowModule = typeof import("openworkflow");
 type OpenWorkflowPostgresModule = typeof import("openworkflow/postgres");
@@ -13,11 +12,10 @@ interface OpenWorkflowRuntime {
   client: OpenWorkflowClient;
   workflows: Map<string, OpenWorkflowRunnable>;
 }
-declare function getOpenWorkflowRuntime(config: ResolvedWorkflowOptions): Promise<OpenWorkflowRuntime>;
-declare function registerOpenWorkflowDefinition(runtime: OpenWorkflowRuntime, name: string, definition: WorkflowDefinition): Promise<OpenWorkflowRunnable>;
-declare function runOpenWorkflow<TPayload = unknown, TResult = unknown>(config: ResolvedWorkflowOptions, name: string, payload: TPayload | undefined, definition: WorkflowDefinition<TPayload, TResult>, options: WorkflowDeferOptions): Promise<WorkflowRun<TPayload, TResult>>;
-declare function getOpenWorkflowRun<TPayload = unknown, TResult = unknown>(config: ResolvedWorkflowOptions, name: string, id: string): Promise<WorkflowRun<TPayload, TResult>>;
-declare function resetOpenWorkflowRuntime(): Promise<void>;
-declare function setOpenWorkflowImporter(importer: OpenWorkflowImporter): void;
-//#endregion
-export { getOpenWorkflowRun, getOpenWorkflowRuntime, registerOpenWorkflowDefinition, resetOpenWorkflowRuntime, runOpenWorkflow, setOpenWorkflowImporter };
+export declare function getOpenWorkflowRuntime(config: ResolvedWorkflowOptions): Promise<OpenWorkflowRuntime>;
+export declare function registerOpenWorkflowDefinition(runtime: OpenWorkflowRuntime, name: string, definition: WorkflowDefinition): Promise<OpenWorkflowRunnable>;
+export declare function runOpenWorkflow<TPayload = unknown, TResult = unknown>(config: ResolvedWorkflowOptions, name: string, payload: TPayload | undefined, definition: WorkflowDefinition<TPayload, TResult>, options: WorkflowDeferOptions, onDispatch?: () => void): Promise<WorkflowRun<TPayload, TResult>>;
+export declare function getOpenWorkflowRun<TPayload = unknown, TResult = unknown>(config: ResolvedWorkflowOptions, name: string, id: string): Promise<WorkflowRun<TPayload, TResult>>;
+export declare function resetOpenWorkflowRuntime(): Promise<void>;
+export declare function setOpenWorkflowImporter(importer: OpenWorkflowImporter): void;
+//#endregion

package/dist/runtime/openworkflow.js

@@ -1,5 +1,7 @@
+import { t as workflowErrorDiagnostics } from "../error-diagnostics-pwNFvAHP.js";
 import { a as createWorkflowError, r as runWorkflowProviderOperation, t as getWorkflowProviderStatus } from "../provider-operation-CW2cYfVy.js";
-import { runWorkflowHandler } from "./execute.js";
+import { runSerializedWorkflowHandler } from "./execute.js";
+import { deserializeResponse, isSerializedResponse } from "@vite-hub/runtime";
 //#region src/runtime/openworkflow.ts
 const defaultImporter = new Function("specifier", "return import(specifier)");
 let openWorkflowImporter = defaultImporter;
@@ -24,8 +26,8 @@ function getRuntimeEnvNames(value) {
 	return value.source?.names ?? (value.source?.name ? [value.source.name] : []);
 }
 function normalizeSqlitePath(path) {
-	if (/^(?:libsql:|https?:\/\/)/i.test(path)) throw new Error(`OpenWorkflow SQLite storage requires a local SQLite file path, received ${JSON.stringify(path)}.`);
-	if (/^[a-z][a-z0-9+.-]*:/i.test(path) && !path.startsWith("file:")) throw new Error(`OpenWorkflow SQLite storage received unsupported storage URL ${JSON.stringify(path)}.`);
+	if (/^(?:libsql:|https?:\/\/)/i.test(path)) throw workflowErrorDiagnostics.WORKFLOW_R0018({ message: `OpenWorkflow SQLite storage requires a local SQLite file path, received ${JSON.stringify(path)}.` });
+	if (/^[a-z][a-z0-9+.-]*:/i.test(path) && !path.startsWith("file:")) throw workflowErrorDiagnostics.WORKFLOW_R0019({ message: `OpenWorkflow SQLite storage received unsupported storage URL ${JSON.stringify(path)}.` });
 	return path.startsWith("file:") ? path.slice(5) : path;
 }
 async function prepareSqlitePath(path, importer) {
@@ -36,17 +38,23 @@ async function prepareSqlitePath(path, importer) {
 	return path;
 }
 function getOpenWorkflowConfig(config) {
-	if (config.provider !== "openworkflow") throw new Error(`OpenWorkflow runtime requires workflow.provider "openworkflow", received "${config.provider}".`);
+	if (config.provider !== "openworkflow") throw workflowErrorDiagnostics.WORKFLOW_R0020({ message: `OpenWorkflow runtime requires workflow.provider "openworkflow", received "${config.provider}".` });
+	if ("database" in config && config.database !== void 0) throw workflowErrorDiagnostics.WORKFLOW_R0027({ message: "`workflow.database` is not supported. Set `workflow.sqlite.path` or `workflow.postgres.url` explicitly." });
 	const sqlite = config.sqlite || {};
-	const sqlitePath = resolveRuntimeConfigValue(sqlite.path) || readEnv("OPENWORKFLOW_SQLITE_PATH");
+	const postgres = config.postgres || {};
+	if (postgres.url !== void 0 && sqlite.path !== void 0) throw workflowErrorDiagnostics.WORKFLOW_R0030({ message: "`workflow.postgres.url` and `workflow.sqlite.path` cannot both configure OpenWorkflow storage." });
+	const explicitSqlitePath = resolveRuntimeConfigValue(sqlite.path);
+	const explicitPostgresUrl = resolveRuntimeConfigValue(postgres.url)?.trim();
+	if (sqlite.path !== void 0 && !explicitSqlitePath?.trim()) throw workflowErrorDiagnostics.WORKFLOW_R0028({ message: "`workflow.sqlite.path` must resolve to a non-empty local SQLite path. Check its runtime environment declaration." });
+	if (postgres.url !== void 0 && !explicitPostgresUrl) throw workflowErrorDiagnostics.WORKFLOW_R0029({ message: "`workflow.postgres.url` must resolve to a non-empty Postgres URL. Check its runtime environment declaration." });
+	const sqlitePath = explicitSqlitePath || (!explicitPostgresUrl ? readEnv("OPENWORKFLOW_SQLITE_PATH") : void 0);
 	if (sqlitePath) return {
 		backend: "sqlite",
 		namespaceId: sqlite.namespaceId || readEnv("OPENWORKFLOW_NAMESPACE_ID") || "production",
 		path: normalizeSqlitePath(sqlitePath),
 		runMigrations: sqlite.runMigrations
 	};
-	const postgres = config.postgres || {};
-	const url = resolveRuntimeConfigValue(postgres.url) || readEnv("OPENWORKFLOW_POSTGRES_URL") || readEnv("DATABASE_URL");
+	const url = explicitPostgresUrl || readEnv("OPENWORKFLOW_POSTGRES_URL") || readEnv("DATABASE_URL");
 	if (url) return {
 		backend: "postgres",
 		namespaceId: postgres.namespaceId || readEnv("OPENWORKFLOW_NAMESPACE_ID") || "production",
@@ -61,11 +69,7 @@ function getOpenWorkflowConfig(config) {
 		runMigrations: sqlite.runMigrations
 	};
 }
-function getRuntimeKey(config) {
-	return JSON.stringify(getOpenWorkflowConfig(config));
-}
-async function createOpenWorkflowRuntime(config, importer) {
-	const options = getOpenWorkflowConfig(config);
+async function createOpenWorkflowRuntime(options, importer) {
 	const [{ OpenWorkflow }, backendModule] = await Promise.all([importOpenWorkflowModule("openworkflow", importer), options.backend === "sqlite" ? importOpenWorkflowModule("openworkflow/sqlite", importer) : importOpenWorkflowModule("openworkflow/postgres", importer)]);
 	const { backend, client } = await runWorkflowProviderOperation("openworkflow", "connect", async () => {
 		let backend;
@@ -91,10 +95,11 @@ async function createOpenWorkflowRuntime(config, importer) {
 }
 async function getOpenWorkflowRuntime(config) {
 	const cache = runtimes;
-	const key = getRuntimeKey(config);
+	const options = getOpenWorkflowConfig(config);
+	const key = JSON.stringify(options);
 	let runtime = cache.get(key);
 	if (!runtime) {
-		runtime = createOpenWorkflowRuntime(config, openWorkflowImporter);
+		runtime = createOpenWorkflowRuntime(options, openWorkflowImporter);
 		cache.set(key, runtime);
 		runtime.catch(() => {
 			if (cache.get(key) === runtime) cache.delete(key);
@@ -132,7 +137,7 @@ async function registerOpenWorkflowDefinition(runtime, name, definition) {
 	if (existing) return existing;
 	const openWorkflowDefinition = definition;
 	const workflow = runtime.client.defineWorkflow({ name }, async ({ input, run, step }) => {
-		return await runWorkflowHandler({
+		return await runSerializedWorkflowHandler({
 			id: run.id,
 			name,
 			payload: input,
@@ -161,7 +166,7 @@ function serializeOpenWorkflowRun(run, name) {
 		provider: "openworkflow",
 		status: "unknown"
 	};
-	const result = run.output;
+	const result = isSerializedResponse(run.output) ? deserializeResponse(run.output) : run.output;
 	return {
 		id: run.id,
 		metadata: run.error || {
@@ -174,8 +179,9 @@ function serializeOpenWorkflowRun(run, name) {
 		status: normalizeOpenWorkflowStatus(run.status)
 	};
 }
-async function runOpenWorkflow(config, name, payload, definition, options) {
+async function runOpenWorkflow(config, name, payload, definition, options, onDispatch) {
 	const workflow = await registerOpenWorkflowDefinition(await getOpenWorkflowRuntime(config), name, definition);
+	onDispatch?.();
 	let firstAcknowledgementUnknown = false;
 	const handle = await runWorkflowProviderOperation("openworkflow", "run", async () => {
 		const start = () => workflow.run(payload, options.id ? { idempotencyKey: options.id } : void 0);

package/dist/runtime/state.d.ts

@@ -1,9 +1,9 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-B9RdRkKh.js";
-
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-D82WmfZa.js";
 //#region src/runtime/state.d.ts
-interface WorkflowRunState<TResult = unknown> {
+export interface WorkflowRunState<TResult = unknown> {
   error?: unknown;
   expiresAt?: number;
+  payload?: unknown;
   promise: Promise<{
     result?: TResult;
     status: "completed" | "failed";
@@ -12,24 +12,23 @@ interface WorkflowRunState<TResult = unknown> {
   result?: TResult;
   status: "running" | "completed" | "failed";
 }
-declare function setWorkflowRuntimeConfig(config: false | ResolvedWorkflowOptions | undefined): void;
-declare function getWorkflowRuntimeConfig(): false | ResolvedWorkflowOptions | undefined;
-declare function setWorkflowRuntimeRegistry(registry: WorkflowDefinitionRegistry | undefined): void;
-declare function getWorkflowRuntimeRegistry(): WorkflowDefinitionRegistry | undefined;
-declare function getInlineWorkflowDefinitions(): ReadonlyMap<string, WorkflowDefinition>;
-declare function takeInlineWorkflowDefinition(name: string): WorkflowDefinition | undefined;
-declare function takeInlineWorkflowDefinitionForModule(name: string, loaded: unknown): WorkflowDefinition | undefined;
-declare function registerInlineWorkflowDefinition(name: string, definition: WorkflowDefinition): void;
-declare function enterWorkflowRuntimeEvent(event: unknown): void;
-declare function getWorkflowRuntimeEvent(): unknown;
-declare function runWithWorkflowRuntimeEvent<T>(event: unknown, run: () => T | Promise<T>): Promise<T>;
-declare function loadWorkflowDefinition(name: string): Promise<WorkflowDefinition | undefined>;
-declare function setWorkflowRun<TResult = unknown>(name: string, id: string, promise: Promise<{
+export declare function setWorkflowRuntimeConfig(config: false | ResolvedWorkflowOptions | undefined): void;
+export declare function getWorkflowRuntimeConfig(): false | ResolvedWorkflowOptions | undefined;
+export declare function setWorkflowRuntimeRegistry(registry: WorkflowDefinitionRegistry | undefined): void;
+export declare function getWorkflowRuntimeRegistry(): WorkflowDefinitionRegistry | undefined;
+export declare function getInlineWorkflowDefinitions(): ReadonlyMap<string, WorkflowDefinition>;
+export declare function takeInlineWorkflowDefinition(name: string): WorkflowDefinition | undefined;
+export declare function takeInlineWorkflowDefinitionForModule(name: string, loaded: unknown): WorkflowDefinition | undefined;
+export declare function registerInlineWorkflowDefinition(name: string, definition: WorkflowDefinition): void;
+export declare function enterWorkflowRuntimeEvent(event: unknown): void;
+export declare function getWorkflowRuntimeEvent(): unknown;
+export declare function runWithWorkflowRuntimeEvent<T>(event: unknown, run: () => T | Promise<T>): Promise<T>;
+export declare function loadWorkflowDefinition(name: string): Promise<WorkflowDefinition | undefined>;
+export declare function setWorkflowRun<TResult = unknown>(name: string, id: string, promise: Promise<{
   result?: TResult;
   status: "completed" | "failed";
   error?: unknown;
-}>): WorkflowRunState<TResult>;
-declare function getWorkflowRunState(name: string, id: string): WorkflowRunState | undefined;
-declare function resetWorkflowRuntime(): void;
-//#endregion
-export { WorkflowRunState, enterWorkflowRuntimeEvent, getInlineWorkflowDefinitions, getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, resetWorkflowRuntime, runWithWorkflowRuntimeEvent, setWorkflowRun, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinition, takeInlineWorkflowDefinitionForModule };
+}>, payload?: unknown, retainInFlight?: boolean): WorkflowRunState<TResult>;
+export declare function getWorkflowRunState(name: string, id: string): WorkflowRunState | undefined;
+export declare function resetWorkflowRuntime(): void;
+//#endregion