@vite-hub/workflow 0.0.3 → 0.1.0

package/dist/{provider-operation-CWIV4k42.js → provider-operation-CW2cYfVy.js}

@@ -27,7 +27,7 @@ function isWorkflowBoundaryError(error) {
 		return false;
 	}
 }
-function getProviderStatus(error) {
+function getWorkflowProviderStatus(error) {
 	if (typeof error !== "object" || error === null) return void 0;
 	try {
 		const value = error;
@@ -38,20 +38,23 @@ function getProviderStatus(error) {
 		return;
 	}
 }
-async function runWorkflowProviderOperation(provider, operation, run) {
+async function runWorkflowProviderOperation(provider, operation, run, options = {}) {
 	try {
 		return await run();
 	} catch (error) {
-		if (isWorkflowBoundaryError(error)) throw error;
-		const status = getProviderStatus(error);
+		if (options.boundaryError?.(error) || isWorkflowBoundaryError(error)) throw error;
+		const status = getWorkflowProviderStatus(error);
+		const acknowledgement = options.acknowledgementUnknown?.(error, status) === true ? "unknown" : void 0;
+		const details = {
+			operation,
+			provider
+		};
+		if (acknowledgement) details.acknowledgement = acknowledgement;
+		if (status !== void 0) details.status = status;
 		throw createWorkflowError({
 			cause: error,
 			code: "WORKFLOW_PROVIDER_OPERATION_FAILED",
-			details: {
-				operation,
-				provider,
-				...status === void 0 ? {} : { status }
-			}
+			details
 		});
 	}
 }
@@ -59,4 +62,4 @@ function safeWorkflowName(name) {
 	return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(name) ? name : void 0;
 }
 //#endregion
-export { createWorkflowError as i, runWorkflowProviderOperation as n, safeWorkflowName as r, isWorkflowBoundaryError as t };
+export { createWorkflowError as a, safeWorkflowName as i, isWorkflowBoundaryError as n, runWorkflowProviderOperation as r, getWorkflowProviderStatus as t };

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,27 +1,21 @@
-import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.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;
+  }) => Error;
   env: CloudflareWorkerEnv;
   event: CloudflareWorkflowEvent;
   name: string;
   registry: WorkflowDefinitionRegistry;
   step?: WorkflowProviderStep;
 }
-declare function runCloudflareWorkflow({
-  config,
-  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,23 +1,86 @@
-import { i as runWithActiveCloudflareEnv } from "../cloudflare-env-mFp2Uj6Z.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
-async function runCloudflareWorkflow({ config, env, event, name, registry, step }) {
+function isNonRetryableError(error) {
+	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;
+}
+function wrapCloudflareWorkflowStep(step, createNonRetryableError, env, runtimeEvent) {
+	if (!step?.do) return step;
+	return {
+		async do(name, options, run) {
+			return await step.do(name, options, async () => await runWithActiveCloudflareEnv(env, async () => await runWithWorkflowRuntimeEvent(runtimeEvent(), async () => {
+				try {
+					return await run();
+				} catch (error) {
+					throw translateNonRetryableError(error, createNonRetryableError);
+				}
+			})));
+		},
+		...step.sleep ? { sleep: step.sleep.bind(step) } : {}
+	};
+}
+async function runCloudflareWorkflow({ config, createNonRetryableError, env, event, name, registry, step }) {
 	setWorkflowRuntimeConfig(config);
 	setWorkflowRuntimeRegistry(registry);
+	let runtimeEvent;
+	const providerStep = wrapCloudflareWorkflowStep(step, createNonRetryableError, env, () => runtimeEvent);
+	runtimeEvent = {
+		env,
+		step: providerStep
+	};
 	return await runWithActiveCloudflareEnv(env, async () => {
 		const definition = await loadWorkflowDefinition(name);
-		if (!definition) throw new Error(`Missing workflow definition: ${name}`);
-		return await runWithWorkflowRuntimeEvent({
-			env,
-			step
-		}, () => runWorkflowHandler({
-			id: event?.instanceId || event?.id,
-			name,
-			payload: event?.payload,
-			provider: "cloudflare",
-			step
-		}, definition));
+		if (!definition) throw workflowErrorDiagnostics.WORKFLOW_R0015({ message: `Missing workflow definition: ${name}` });
+		try {
+			return await runWithWorkflowRuntimeEvent(runtimeEvent, () => runSerializedWorkflowHandler({
+				id: event?.instanceId || event?.id,
+				name,
+				payload: event?.payload,
+				provider: "cloudflare",
+				step: providerStep
+			}, definition));
+		} catch (error) {
+			throw translateNonRetryableError(error, createNonRetryableError);
+		}
 	});
 }
 //#endregion

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-mFp2Uj6Z.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,17 +1,16 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.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 createWorkflowCloudflareWorker(options?: WorkflowCloudflareWorkerOptions): WorkflowCloudflareWorker;
-//#endregion
-export { CloudflareWorkerApp, WorkflowCloudflareWorker, WorkflowCloudflareWorkerOptions, createWorkflowCloudflareWorker };
+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 { t as createWorkflowCloudflareWorker } from "../cloudflare-vite-B0zel2Do.js";
-export { createWorkflowCloudflareWorker };
+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-BUlYBZwH.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-BUlYBZwH.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,6 @@
-import { i as createWorkflowError } from "../provider-operation-CWIV4k42.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";
 import "@vite-hub/runtime";
@@ -6,12 +8,15 @@ import "@vite-hub/runtime";
 function getProcess() {
 	return globalThis.process;
 }
+function isWorkflowDefinition(value) {
+	return isRuntimeRecord(value) && Object.hasOwn(value, "handler") && hasRuntimeType(value.handler, "function");
+}
 async function loadRegistryDefinitions(registry) {
 	const definitions = /* @__PURE__ */ new Map();
 	for (const name of Object.keys(registry).sort()) {
 		const loaded = await registry[name]?.();
-		const definition = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
-		if (definition && typeof definition === "object" && "handler" in definition && typeof definition.handler === "function") {
+		const definition = isRuntimeRecord(loaded) && "default" in loaded ? loaded.default : loaded;
+		if (isWorkflowDefinition(definition)) {
 			definitions.set(name, definition);
 			continue;
 		}
@@ -23,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);
@@ -41,7 +46,39 @@ async function createOpenWorkflowWorker(options = {}) {
 }
 async function startOpenWorkflowWorker(options = {}) {
 	const worker = await createOpenWorkflowWorker(options);
-	await worker.start();
+	await runWorkflowProviderOperation("openworkflow", "start", async () => {
+		let removeStartupAbortListener;
+		let startTask;
+		try {
+			if (options.signal?.aborted) throw options.signal.reason;
+			startTask = Promise.resolve(worker.start());
+			if (!options.signal) await startTask;
+			else {
+				const signal = options.signal;
+				const abortTask = new Promise((_resolve, reject) => {
+					const abort = () => reject(signal.reason);
+					removeStartupAbortListener = () => signal.removeEventListener("abort", abort);
+					signal.addEventListener("abort", abort, { once: true });
+					if (signal.aborted) abort();
+				});
+				await Promise.race([startTask, abortTask]);
+			}
+		} catch (startError) {
+			const stopTask = Promise.resolve().then(() => worker.stop());
+			if (startTask && options.signal?.aborted) startTask.then(async () => {
+				await stopTask.catch(() => {});
+				await worker.stop();
+			}).catch(() => {});
+			try {
+				await stopTask;
+			} catch (stopError) {
+				throw new AggregateError([startError, stopError], "OpenWorkflow worker startup and cleanup failed.");
+			}
+			throw startError;
+		} finally {
+			removeStartupAbortListener?.();
+		}
+	}, { boundaryError: (error) => options.signal?.aborted === true && error === options.signal.reason });
 	const originalStop = worker.stop.bind(worker);
 	const proc = getProcess();
 	let abortListenerActive = false;

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-BUlYBZwH.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 { i as createWorkflowError, n as runWorkflowProviderOperation } from "../provider-operation-CWIV4k42.js";
-import { runWorkflowHandler } from "./execute.js";
+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 { 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);
@@ -117,24 +122,28 @@ function toOpenWorkflowRetryPolicy(options) {
 	};
 }
 function createOpenWorkflowProviderStep(step) {
-	return { async do(name, options, run) {
-		return await step.run({
-			name,
-			...toOpenWorkflowRetryPolicy(options) ? { retryPolicy: toOpenWorkflowRetryPolicy(options) } : {}
-		}, run);
-	} };
+	return {
+		async do(name, options, run) {
+			return await step.run({
+				name,
+				...toOpenWorkflowRetryPolicy(options) ? { retryPolicy: toOpenWorkflowRetryPolicy(options) } : {}
+			}, run);
+		},
+		sleep: async (name, duration) => await step.sleep(name, duration)
+	};
 }
 async function registerOpenWorkflowDefinition(runtime, name, definition) {
 	const existing = runtime.workflows.get(name);
 	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,
 			provider: "openworkflow",
 			step: createOpenWorkflowProviderStep(step)
-		}, definition);
+		}, openWorkflowDefinition);
 	});
 	runtime.workflows.set(name, workflow);
 	return workflow;
@@ -143,7 +152,7 @@ function normalizeOpenWorkflowStatus(status) {
 	switch (String(status || "").toLowerCase()) {
 		case "completed":
 		case "succeeded": return "completed";
-		case "canceled":
+		case "canceled": return "cancelled";
 		case "failed": return "failed";
 		case "pending": return "queued";
 		case "running":
@@ -157,6 +166,7 @@ function serializeOpenWorkflowRun(run, name) {
 		provider: "openworkflow",
 		status: "unknown"
 	};
+	const result = isSerializedResponse(run.output) ? deserializeResponse(run.output) : run.output;
 	return {
 		id: run.id,
 		metadata: run.error || {
@@ -165,23 +175,31 @@ function serializeOpenWorkflowRun(run, name) {
 			workflowName: run.workflowName
 		},
 		provider: "openworkflow",
-		result: run.output ?? void 0,
+		result,
 		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);
+		return await start().catch((error) => {
+			if (!options.id) throw error;
+			firstAcknowledgementUnknown = getWorkflowProviderStatus(error) === void 0;
+			return start();
+		});
+	}, { acknowledgementUnknown: (_error, status) => firstAcknowledgementUnknown || status === void 0 });
 	return await runWorkflowProviderOperation("openworkflow", "run", async () => {
-		const handle = await workflow.run(payload, options.id ? { idempotencyKey: options.id } : void 0);
+		const serialized = serializeOpenWorkflowRun(handle.workflowRun, name);
 		return {
-			id: handle.workflowRun.id,
-			metadata: {
+			...serialized,
+			metadata: serialized.status === "failed" ? serialized.metadata : {
 				...options.id ? { idempotencyKey: options.id } : {},
 				workflow: name
 			},
-			payload,
-			provider: "openworkflow",
-			status: normalizeOpenWorkflowStatus(handle.workflowRun.status)
+			payload
 		};
 	});
 }