@vite-hub/workflow 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,12 +1,13 @@
-import { t as normalizeWorkflowOptions } from "./config-BDqB6I4E.js";
-import { a as encodeNameHex, i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-Cds1VIWa.js";
-import { i as createWorkflowError, n as runWorkflowProviderOperation, r as safeWorkflowName } from "./provider-operation-CWIV4k42.js";
-import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-mFp2Uj6Z.js";
+import { t as normalizeWorkflowOptions } from "./config-BHknO_rT.js";
+import { a as encodeNameHex, i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-D0Di-QYL.js";
+import { t as hasRuntimeType } from "./runtime-type-DGUn8Ple.js";
+import { a as createWorkflowError, i as safeWorkflowName, r as runWorkflowProviderOperation } from "./provider-operation-CW2cYfVy.js";
+import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-DjxQNbrx.js";
 import { runWorkflowHandler } from "./runtime/execute.js";
 import { getOpenWorkflowRun, runOpenWorkflow } from "./runtime/openworkflow.js";
-import { getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, loadWorkflowDefinition, registerInlineWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRun } from "./runtime/state.js";
-import { a as startVercelWorkflow, n as inspectVercelWorkflowRun, r as resumeVercelWorkflowSignal, t as cancelVercelWorkflow } from "./vercel-D2_J5D_Y.js";
-import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-B0zel2Do.js";
+import { getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRun } from "./runtime/state.js";
+import { a as startVercelWorkflow, n as inspectVercelWorkflowRun, r as resumeVercelWorkflowSignal, t as cancelVercelWorkflow } from "./vercel-B0MuIVgJ.js";
+import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-BkDgB6Sr.js";
 //#region src/definition.ts
 function defineWorkflow(handler, options) {
 	if (typeof handler !== "function") throw new TypeError("`defineWorkflow()` requires a workflow handler.");
@@ -30,6 +31,15 @@ function randomId(prefix) {
 }
 //#endregion
 //#region src/runtime/adapters.ts
+function resolveSettlementObserver(event) {
+	if (!event || !hasRuntimeType(event, "object")) return void 0;
+	const candidate = "settled" in event ? event.settled : void 0;
+	if (hasRuntimeType(candidate, "function")) return candidate;
+	const context = "context" in event ? event.context : void 0;
+	if (!context || !hasRuntimeType(context, "object")) return void 0;
+	const nested = "settled" in context ? context.settled : void 0;
+	return hasRuntimeType(nested, "function") ? nested : void 0;
+}
 function unsupportedOperation(provider, operation) {
 	throw createWorkflowError({
 		code: "WORKFLOW_OPERATION_UNSUPPORTED",
@@ -39,9 +49,13 @@ function unsupportedOperation(provider, operation) {
 		}
 	});
 }
-function resolveCloudflareBinding(event, binding, name) {
-	const bindingName = binding || getCloudflareWorkflowBindingName(name);
-	return getCloudflareEnv(event)?.[bindingName];
+function resolveCloudflareBinding(event, binding, name, definition) {
+	const env = getCloudflareEnv(event);
+	const bindingName = definition?.internalAgentInvocationRecovery ? getCloudflareWorkflowBindingName(name) : binding || getCloudflareWorkflowBindingName(name);
+	return env?.[bindingName];
+}
+function resolveCloudflareInspectionBinding(event, binding, name) {
+	return resolveCloudflareBinding(event, binding, name, getWorkflowRuntimeRegistry()?.[name]);
 }
 const cloudflareStatusMap = {
 	cancelled: "cancelled",
@@ -55,14 +69,19 @@ const cloudflareStatusMap = {
 	terminated: "failed"
 };
 function normalizeCloudflareStatus(status) {
-	const value = typeof status === "object" && status ? status.status : status;
+	const value = hasRuntimeType(status, "object") && status ? status.status : status;
 	return cloudflareStatusMap[String(value || "").toLowerCase()] || "unknown";
 }
+function hasUnknownWorkflowAcknowledgement(error) {
+	if (!error || !hasRuntimeType(error, "object")) return false;
+	const details = error.details;
+	return Boolean(details && hasRuntimeType(details, "object") && details.acknowledgement === "unknown");
+}
 function createCloudflareAdapter(config) {
 	return {
 		cancel: () => unsupportedOperation("cloudflare", "cancellation"),
 		async get({ event, id, name }) {
-			const binding = resolveCloudflareBinding(event, config.binding, name);
+			const binding = resolveCloudflareInspectionBinding(event, config.binding, name);
 			if (binding) {
 				const instance = await runWorkflowProviderOperation("cloudflare", "get", () => binding.get(id));
 				const metadata = await runWorkflowProviderOperation("cloudflare", "status", () => instance.status());
@@ -80,18 +99,24 @@ function createCloudflareAdapter(config) {
 			});
 		},
 		async run({ definition, event, id, name, options, payload }) {
-			const binding = resolveCloudflareBinding(event, config.binding, name);
+			const binding = resolveCloudflareBinding(event, config.binding, name, definition);
 			if (binding) {
-				const start = runWorkflowProviderOperation("cloudflare", "create", () => binding.create({
+				const start = () => runWorkflowProviderOperation("cloudflare", "create", async () => (await binding.createBatch([{
 					id,
 					params: payload
-				}));
+				}]))[0] || await binding.get(id), { acknowledgementUnknown: (_error, status) => status === void 0 });
+				const creation = start().catch(async (firstError) => {
+					try {
+						return await start();
+					} catch (retryError) {
+						if (hasUnknownWorkflowAcknowledgement(firstError)) throw firstError;
+						throw retryError;
+					}
+				});
 				const waitUntil = options.deferred ? resolveWaitUntil(event) : void 0;
-				if (waitUntil) waitUntil(start);
-				const instance = await start;
+				if (waitUntil) waitUntil(creation);
 				return {
-					id: instance.id,
-					metadata: await runWorkflowProviderOperation("cloudflare", "status", () => instance.status()),
+					id: (await creation).id,
 					payload,
 					provider: "cloudflare",
 					status: "queued"
@@ -208,7 +233,7 @@ function createVercelAdapter(config) {
 					provider: "vercel"
 				}
 			});
-			return await startVercelWorkflow(name, definition, payload);
+			return await startVercelWorkflow(name, definition, payload, resolveSettlementObserver(event));
 		}
 	};
 }
@@ -234,7 +259,7 @@ async function loadRequiredWorkflowDefinition(name) {
 }
 function normalizeWorkflowRunIdValue(value) {
 	if (value === void 0) return null;
-	if (value === null || typeof value !== "object") return value;
+	if (value === null || !hasRuntimeType(value, "object")) return value;
 	if (Array.isArray(value)) return value.map((item) => normalizeWorkflowRunIdValue(item));
 	const record = value;
 	return Object.fromEntries(Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => [key, normalizeWorkflowRunIdValue(record[key])]));
@@ -259,34 +284,44 @@ async function resolveWorkflowStartOptions(name, payload, createOptions, startOp
 	};
 }
 function createWorkflow(nameOrOptions, handlerOrOptions, options) {
-	if (typeof nameOrOptions === "object" && nameOrOptions !== null) {
+	if (hasRuntimeType(nameOrOptions, "object") && nameOrOptions !== null) {
 		const createOptions = nameOrOptions;
 		const { handler, name } = createOptions;
-		if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
-		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
-		registerInlineWorkflowDefinition(name, { handler });
+		if (!name || !hasRuntimeType(name, "string")) throw new TypeError("`createWorkflow()` requires a workflow name.");
+		if (!hasRuntimeType(handler, "function")) throw new TypeError("`createWorkflow()` requires a workflow handler.");
+		registerInlineWorkflowDefinition(name, {
+			handler,
+			...createOptions.rootStep === void 0 ? {} : { options: { rootStep: createOptions.rootStep } }
+		});
 		return {
 			cancel: (id) => cancelWorkflow(name, id),
 			name,
 			defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
 			getRun: (id) => getWorkflowRun(name, id),
-			run: async (payload, options = {}) => runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options))
+			async run(payload, options = {}) {
+				return await runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options));
+			}
 		};
 	}
 	const name = nameOrOptions;
-	if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
-	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : typeof handlerOrOptions === "object" && handlerOrOptions !== null ? handlerOrOptions.handler : void 0;
-	const createOptions = typeof handlerOrOptions === "function" ? options : handlerOrOptions;
+	if (!name || !hasRuntimeType(name, "string")) throw new TypeError("`createWorkflow()` requires a workflow name.");
+	const handler = hasRuntimeType(handlerOrOptions, "function") ? handlerOrOptions : hasRuntimeType(handlerOrOptions, "object") && handlerOrOptions !== null ? handlerOrOptions.handler : void 0;
+	const createOptions = hasRuntimeType(handlerOrOptions, "function") ? options : handlerOrOptions;
 	if (handler !== void 0) {
-		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
-		registerInlineWorkflowDefinition(name, { handler });
-	} else if (handlerOrOptions !== void 0 && (typeof handlerOrOptions !== "object" || handlerOrOptions === null)) throw new TypeError("`createWorkflow()` options must be an object.");
+		if (!hasRuntimeType(handler, "function")) throw new TypeError("`createWorkflow()` requires a workflow handler.");
+		registerInlineWorkflowDefinition(name, {
+			handler,
+			...createOptions?.rootStep === void 0 ? {} : { options: { rootStep: createOptions.rootStep } }
+		});
+	} else if (handlerOrOptions !== void 0 && (!hasRuntimeType(handlerOrOptions, "object") || handlerOrOptions === null)) throw new TypeError("`createWorkflow()` options must be an object.");
 	return {
 		cancel: (id) => cancelWorkflow(name, id),
 		name,
 		defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
 		getRun: (id) => getWorkflowRun(name, id),
-		run: async (payload, options = {}) => runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options))
+		async run(payload, options = {}) {
+			return await runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options));
+		}
 	};
 }
 async function runWorkflow(name, payload, options = {}) {
@@ -323,7 +358,7 @@ async function cancelWorkflow(name, id) {
 	});
 }
 async function resumeWorkflowSignal(token, payload) {
-	if (!token || typeof token !== "string") throw new TypeError("`resumeWorkflowSignal()` requires an opaque signal token.");
+	if (!token || !hasRuntimeType(token, "string")) throw new TypeError("`resumeWorkflowSignal()` requires an opaque signal token.");
 	const config = getActiveWorkflowConfig();
 	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
 	return await getWorkflowRuntimeAdapter(config).resume(token, payload);

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/runtime/cloudflare-runner.d.ts

@@ -1,4 +1,4 @@
-import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
 import { t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
 
 //#region src/runtime/cloudflare-runner.d.ts
@@ -9,6 +9,9 @@ interface CloudflareWorkflowEvent {
 }
 interface RunCloudflareWorkflowOptions {
   config: false | ResolvedWorkflowOptions | undefined;
+  createNonRetryableError?: (error: Error & {
+    isRetryable: false;
+  }) => Error;
   env: CloudflareWorkerEnv;
   event: CloudflareWorkflowEvent;
   name: string;
@@ -17,6 +20,7 @@ interface RunCloudflareWorkflowOptions {
 }
 declare function runCloudflareWorkflow({
   config,
+  createNonRetryableError,
   env,
   event,
   name,

package/dist/runtime/cloudflare-runner.js

@@ -1,23 +1,51 @@
-import { i as runWithActiveCloudflareEnv } from "../cloudflare-env-mFp2Uj6Z.js";
+import { i as runWithActiveCloudflareEnv } from "../cloudflare-env-DjxQNbrx.js";
 import { runWorkflowHandler } 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) {
+	return error instanceof Error && error.isRetryable === 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));
+		try {
+			return await runWithWorkflowRuntimeEvent(runtimeEvent, () => runWorkflowHandler({
+				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.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-DjxQNbrx.js";
 export { createCloudflareRuntimeEvent, runWithActiveCloudflareEnv, setActiveCloudflareEnv };

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

@@ -1,4 +1,4 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
 import { t as WorkflowApp } from "../_app-DgwN4ulW.js";
 import { n as CloudflareWorkerExecutionContext, t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
 
@@ -12,6 +12,7 @@ interface WorkflowCloudflareWorkerOptions {
 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 };
+export { CloudflareWorkerApp, WorkflowCloudflareWorker, WorkflowCloudflareWorkerOptions, createWorkflowCloudflareWorker, installWorkflowCloudflareRuntime };

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-BkDgB6Sr.js";
+export { createWorkflowCloudflareWorker, installWorkflowCloudflareRuntime };

package/dist/runtime/execute.d.ts

@@ -1,4 +1,4 @@
-import { A as WorkflowStepFunction, C as WorkflowProviderStep, g as WorkflowExecutionContext, j as WorkflowStepOptions, p as WorkflowDefinition } from "../types-BUlYBZwH.js";
+import { A as WorkflowStepFunction, C as WorkflowProviderStep, g as WorkflowExecutionContext, j as WorkflowStepOptions, p as WorkflowDefinition } from "../types-B9RdRkKh.js";
 
 //#region src/runtime/execute.d.ts
 declare function runProviderStep<TResult>(step: WorkflowProviderStep | undefined, name: string, run: () => TResult | Promise<TResult>, options?: WorkflowStepOptions): Promise<TResult>;

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

@@ -1,4 +1,4 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
 import { getOpenWorkflowRuntime } from "./openworkflow.js";
 import { ViteHubError } from "@vite-hub/runtime";
 

package/dist/runtime/openworkflow-worker.js

@@ -1,4 +1,5 @@
-import { i as createWorkflowError } from "../provider-operation-CWIV4k42.js";
+import { n as isRuntimeRecord, t as hasRuntimeType } from "../runtime-type-DGUn8Ple.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 +7,15 @@ import "@vite-hub/runtime";
 function getProcess() {
 	return globalThis.process;
 }
+function isWorkflowDefinition(value) {
+	return isRuntimeRecord(value) && 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;
 		}
@@ -41,7 +45,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,4 +1,4 @@
-import { f as WorkflowDeferOptions, l as ResolvedWorkflowOptions, p as WorkflowDefinition, w as WorkflowRun } from "../types-BUlYBZwH.js";
+import { f as WorkflowDeferOptions, l as ResolvedWorkflowOptions, p as WorkflowDefinition, w as WorkflowRun } from "../types-B9RdRkKh.js";
 
 //#region src/runtime/openworkflow.d.ts
 type OpenWorkflowModule = typeof import("openworkflow");

package/dist/runtime/openworkflow.js

@@ -1,4 +1,4 @@
-import { i as createWorkflowError, n as runWorkflowProviderOperation } from "../provider-operation-CWIV4k42.js";
+import { a as createWorkflowError, r as runWorkflowProviderOperation, t as getWorkflowProviderStatus } from "../provider-operation-CW2cYfVy.js";
 import { runWorkflowHandler } from "./execute.js";
 //#region src/runtime/openworkflow.ts
 const defaultImporter = new Function("specifier", "return import(specifier)");
@@ -117,16 +117,20 @@ 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({
 			id: run.id,
@@ -134,7 +138,7 @@ async function registerOpenWorkflowDefinition(runtime, name, definition) {
 			payload: input,
 			provider: "openworkflow",
 			step: createOpenWorkflowProviderStep(step)
-		}, definition);
+		}, openWorkflowDefinition);
 	});
 	runtime.workflows.set(name, workflow);
 	return workflow;
@@ -143,7 +147,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 +161,7 @@ function serializeOpenWorkflowRun(run, name) {
 		provider: "openworkflow",
 		status: "unknown"
 	};
+	const result = run.output;
 	return {
 		id: run.id,
 		metadata: run.error || {
@@ -165,23 +170,30 @@ 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) {
 	const workflow = await registerOpenWorkflowDefinition(await getOpenWorkflowRuntime(config), name, definition);
+	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
 		};
 	});
 }

package/dist/runtime/state.d.ts

@@ -1,4 +1,4 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-BUlYBZwH.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-B9RdRkKh.js";
 
 //#region src/runtime/state.d.ts
 interface WorkflowRunState<TResult = unknown> {

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

@@ -1,4 +1,4 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-B9RdRkKh.js";
 import { t as WorkflowApp } from "../_app-DgwN4ulW.js";
 import { IncomingMessage, ServerResponse } from "node:http";
 
@@ -58,6 +58,7 @@ interface VercelWorkflowRuntimeModule {
 declare function setVercelWorkflowRuntimeModules(api: VercelWorkflowApiModule, runtime: VercelWorkflowRuntimeModule): void;
 //#endregion
 //#region src/runtime/vercel-vite.d.ts
+declare function runWithVercelWorkflowRuntimeEvent<T>(req: unknown, res: unknown, run: () => T | Promise<T>): Promise<T>;
 interface WorkflowVercelServerOptions {
   app?: WorkflowApp;
   registry?: WorkflowDefinitionRegistry;
@@ -66,4 +67,4 @@ interface WorkflowVercelServerOptions {
 type WorkflowVercelServer = (req: IncomingMessage, res: ServerResponse) => unknown;
 declare function createWorkflowVercelServer(options?: WorkflowVercelServerOptions): WorkflowVercelServer;
 //#endregion
-export { WorkflowVercelServer, createWorkflowVercelServer, setVercelWorkflowRuntimeModules };
+export { WorkflowVercelServer, createWorkflowVercelServer, runWithVercelWorkflowRuntimeEvent, setVercelWorkflowRuntimeModules };

package/dist/runtime/vercel-vite.js

@@ -1,5 +1,5 @@
 import { runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./state.js";
-import { i as setVercelWorkflowRuntimeModules } from "../vercel-D2_J5D_Y.js";
+import { i as setVercelWorkflowRuntimeModules } from "../vercel-B0MuIVgJ.js";
 import { t as resolveAppFetch } from "../app-BZpq2cwC.js";
 import { waitUntil } from "@vercel/functions";
 import { H3 } from "h3";
@@ -30,6 +30,13 @@ function createVercelHostedServer(adapter) {
 }
 //#endregion
 //#region src/runtime/vercel-vite.ts
+async function runWithVercelWorkflowRuntimeEvent(req, res, run) {
+	return await runWithWorkflowRuntimeEvent({
+		req,
+		res,
+		waitUntil
+	}, run);
+}
 function createWorkflowVercelServer(options = {}) {
 	return createVercelHostedServer({
 		app: options.app,
@@ -37,13 +44,9 @@ function createWorkflowVercelServer(options = {}) {
 		onRequest({ handle, req, res }) {
 			setWorkflowRuntimeConfig(options.workflow);
 			setWorkflowRuntimeRegistry(options.registry);
-			return runWithWorkflowRuntimeEvent({
-				req,
-				res,
-				waitUntil
-			}, handle);
+			return runWithVercelWorkflowRuntimeEvent(req, res, handle);
 		}
 	});
 }
 //#endregion
-export { createWorkflowVercelServer, setVercelWorkflowRuntimeModules };
+export { createWorkflowVercelServer, runWithVercelWorkflowRuntimeEvent, setVercelWorkflowRuntimeModules };

package/dist/runtime-type-DGUn8Ple.js

@@ -0,0 +1,37 @@
+//#region src/internal/runtime-type.ts
+function isCallableRepresentation(value) {
+	if (value === null || value === void 0 || Object(value) !== value) return false;
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Parses JavaScript runtime representation categories at Workflow boundaries. */
+function hasRuntimeType(value, expected) {
+	if (expected === "undefined") return value === void 0;
+	if (expected === "object" && value === null) return true;
+	if (value === null || value === void 0) return false;
+	const isPrimitive = Object(value) !== value;
+	if (!isPrimitive) {
+		if (expected === "function") return isCallableRepresentation(value);
+		return expected === "object" && !isCallableRepresentation(value);
+	}
+	const tag = Object.prototype.toString.call(value);
+	switch (expected) {
+		case "bigint": return isPrimitive && tag === "[object BigInt]";
+		case "boolean": return isPrimitive && tag === "[object Boolean]";
+		case "function": return false;
+		case "number": return isPrimitive && tag === "[object Number]";
+		case "object": return false;
+		case "string": return isPrimitive && tag === "[object String]";
+		case "symbol": return isPrimitive && tag === "[object Symbol]";
+	}
+	throw new TypeError(`Unsupported runtime type: ${expected}`);
+}
+function isRuntimeRecord(value) {
+	return value !== null && hasRuntimeType(value, "object") && !Array.isArray(value);
+}
+//#endregion
+export { isRuntimeRecord as n, hasRuntimeType as t };