@vite-hub/workflow 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,38 +1,23 @@
-import { t as normalizeWorkflowOptions } from "./config-DkgsQuXz.js";
-import { a as encodeNameHex, i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-CeHVSHoN.js";
-import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-g0Rf3ClH.js";
+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 { 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 { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-DcM5YVTP.js";
-import { createOpenWorkflowWorker, startOpenWorkflowWorker } from "./runtime/openworkflow-worker.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";
 //#region src/definition.ts
 function defineWorkflow(handler, options) {
 	if (typeof handler !== "function") throw new TypeError("`defineWorkflow()` requires a workflow handler.");
 	if (typeof options !== "undefined" && (!options || typeof options !== "object" || Array.isArray(options))) throw new TypeError("`defineWorkflow()` options must be a plain object.");
+	if (options?.native !== void 0 && typeof options.native !== "function") throw new TypeError("`defineWorkflow()` native entry must be a workflow handler.");
 	return {
 		handler,
 		options
 	};
 }
 //#endregion
-//#region src/errors.ts
-var WorkflowError = class extends Error {
-	code;
-	details;
-	httpStatus;
-	provider;
-	constructor(message, options = {}) {
-		super(message);
-		this.name = "WorkflowError";
-		this.cause = options.cause;
-		this.code = options.code;
-		this.details = options.details;
-		this.httpStatus = options.httpStatus;
-		this.provider = options.provider;
-	}
-};
-//#endregion
 //#region src/integrations/vercel.ts
 function getVercelWorkflowName(name) {
 	return `workflow--${encodeNameHex(name)}`;
@@ -44,68 +29,22 @@ function randomId(prefix) {
 	return prefix ? `${prefix}_${body}` : body;
 }
 //#endregion
-//#region src/runtime/vercel-state.ts
-const RUNS_TTL_SECONDS = 300;
-function readEnv(name) {
-	const value = globalThis.process?.env?.[name];
-	return value && value.trim() ? value : void 0;
-}
-function getUpstashConfig() {
-	const url = readEnv("KV_REST_API_URL") || readEnv("UPSTASH_REDIS_REST_URL");
-	const token = readEnv("KV_REST_API_TOKEN") || readEnv("UPSTASH_REDIS_REST_TOKEN");
-	return url && token ? {
-		token,
-		url
-	} : void 0;
-}
-function getRunKey(name, id) {
-	return `vitehub:workflow:runs:${encodeURIComponent(name)}:${encodeURIComponent(id)}`;
-}
-async function command(body) {
-	const config = getUpstashConfig();
-	if (!config || typeof fetch !== "function") return;
-	try {
-		const response = await fetch(config.url, {
-			body: JSON.stringify(body),
-			headers: {
-				authorization: `Bearer ${config.token}`,
-				"content-type": "application/json"
-			},
-			method: "POST"
-		});
-		if (!response.ok) return;
-		return (await response.json()).result;
-	} catch {
-		return;
-	}
-}
-async function setVercelWorkflowRunState(name, id, run) {
-	const value = JSON.stringify(run);
-	await command([
-		"SET",
-		getRunKey(name, id),
-		value,
-		"EX",
-		RUNS_TTL_SECONDS
-	]);
-}
-async function getVercelWorkflowRunState(name, id) {
-	const value = await command(["GET", getRunKey(name, id)]);
-	if (!value) return;
-	try {
-		const parsed = JSON.parse(value);
-		return parsed && typeof parsed.status === "string" ? parsed : void 0;
-	} catch {
-		return;
-	}
-}
-//#endregion
 //#region src/runtime/adapters.ts
+function unsupportedOperation(provider, operation) {
+	throw createWorkflowError({
+		code: "WORKFLOW_OPERATION_UNSUPPORTED",
+		details: {
+			operation,
+			provider
+		}
+	});
+}
 function resolveCloudflareBinding(event, binding, name) {
 	const bindingName = binding || getCloudflareWorkflowBindingName(name);
 	return getCloudflareEnv(event)?.[bindingName];
 }
 const cloudflareStatusMap = {
+	cancelled: "cancelled",
 	complete: "completed",
 	completed: "completed",
 	errored: "failed",
@@ -121,10 +60,12 @@ function normalizeCloudflareStatus(status) {
 }
 function createCloudflareAdapter(config) {
 	return {
+		cancel: () => unsupportedOperation("cloudflare", "cancellation"),
 		async get({ event, id, name }) {
 			const binding = resolveCloudflareBinding(event, config.binding, name);
 			if (binding) {
-				const metadata = await (await binding.get(id)).status();
+				const instance = await runWorkflowProviderOperation("cloudflare", "get", () => binding.get(id));
+				const metadata = await runWorkflowProviderOperation("cloudflare", "status", () => instance.status());
 				return {
 					id,
 					metadata,
@@ -141,16 +82,16 @@ function createCloudflareAdapter(config) {
 		async run({ definition, event, id, name, options, payload }) {
 			const binding = resolveCloudflareBinding(event, config.binding, name);
 			if (binding) {
-				const start = binding.create({
+				const start = runWorkflowProviderOperation("cloudflare", "create", () => binding.create({
 					id,
 					params: payload
-				});
+				}));
 				const waitUntil = options.deferred ? resolveWaitUntil(event) : void 0;
 				if (waitUntil) waitUntil(start);
 				const instance = await start;
 				return {
 					id: instance.id,
-					metadata: await instance.status(),
+					metadata: await runWorkflowProviderOperation("cloudflare", "status", () => instance.status()),
 					payload,
 					provider: "cloudflare",
 					status: "queued"
@@ -164,17 +105,21 @@ function createCloudflareAdapter(config) {
 				options,
 				payload
 			});
-		}
+		},
+		resume: () => unsupportedOperation("cloudflare", "signals")
 	};
 }
 function createOpenWorkflowAdapter(config) {
 	return {
+		cancel: () => unsupportedOperation("openworkflow", "cancellation"),
 		get: async ({ id, name }) => await getOpenWorkflowRun(config, name, id),
+		resume: () => unsupportedOperation("openworkflow", "signals"),
 		run: async ({ definition, name, options, payload }) => await runOpenWorkflow(config, name, payload, definition, options)
 	};
 }
 function inlineAdapter(config) {
 	return {
+		cancel: () => unsupportedOperation(config.provider, "cancellation"),
 		async get({ id, name }) {
 			const run = getWorkflowRunState(name, id);
 			if (run) {
@@ -191,16 +136,6 @@ function inlineAdapter(config) {
 					status: run.status
 				};
 			}
-			if (config.provider === "vercel") {
-				const persisted = await getVercelWorkflowRunState(name, id);
-				if (persisted) return {
-					id,
-					metadata: persisted.error,
-					provider: "vercel",
-					result: persisted.result,
-					status: persisted.status
-				};
-			}
 			return {
 				id,
 				provider: config.provider,
@@ -220,25 +155,67 @@ function inlineAdapter(config) {
 				error,
 				status: "failed"
 			})));
-			const persistStarted = config.provider === "vercel" ? setVercelWorkflowRunState(name, id, { status: "running" }).catch(() => {}) : Promise.resolve();
-			const persistFinished = config.provider === "vercel" ? runState.promise.then((result) => setVercelWorkflowRunState(name, id, result)).catch(() => {}) : Promise.resolve();
 			const waitUntil = resolveWaitUntil(event);
-			if (waitUntil) waitUntil(Promise.all([runState.promise, persistFinished]));
-			await persistStarted;
+			if (waitUntil) waitUntil(runState.promise);
 			return {
 				id,
-				metadata: config.provider === "vercel" ? { workflow: getVercelWorkflowName(name) } : void 0,
+				metadata: config.provider === "vercel" ? {
+					mode: "inline",
+					workflow: getVercelWorkflowName(name)
+				} : void 0,
 				payload,
 				provider: config.provider,
 				status: "queued"
 			};
+		},
+		resume: () => unsupportedOperation(config.provider, "signals")
+	};
+}
+function createVercelAdapter(config) {
+	const fallback = inlineAdapter(config);
+	return {
+		async cancel({ id, name }) {
+			const definition = await loadWorkflowDefinition(name);
+			if (!definition?.options?.native) return await fallback.cancel({
+				event: void 0,
+				id,
+				name
+			});
+			return await cancelVercelWorkflow(name, definition, id);
+		},
+		async get({ id, name }) {
+			const definition = await loadWorkflowDefinition(name);
+			return definition?.options?.native ? await inspectVercelWorkflowRun(name, definition, id) : await fallback.get({
+				event: void 0,
+				id,
+				name
+			});
+		},
+		resume: async (token, payload) => await resumeVercelWorkflowSignal(token, payload),
+		async run({ definition, event, id, name, options, payload }) {
+			if (!definition.options?.native) return await fallback.run({
+				definition,
+				event,
+				id,
+				name,
+				options,
+				payload
+			});
+			if (options.id) throw createWorkflowError({
+				code: "WORKFLOW_RUN_ID_UNSUPPORTED",
+				details: {
+					...safeWorkflowName(name) ? { name } : {},
+					provider: "vercel"
+				}
+			});
+			return await startVercelWorkflow(name, definition, payload);
 		}
 	};
 }
 function getWorkflowRuntimeAdapter(config) {
 	if (config.provider === "cloudflare") return createCloudflareAdapter(config);
 	if (config.provider === "openworkflow") return createOpenWorkflowAdapter(config);
-	return inlineAdapter(config);
+	return createVercelAdapter(config);
 }
 //#endregion
 //#region src/runtime/client.ts
@@ -249,10 +226,9 @@ function getActiveWorkflowConfig() {
 }
 async function loadRequiredWorkflowDefinition(name) {
 	const definition = await loadWorkflowDefinition(name);
-	if (!definition) throw new WorkflowError(`Unknown workflow definition: ${name}`, {
+	if (!definition) throw createWorkflowError({
 		code: "WORKFLOW_DEFINITION_NOT_FOUND",
-		details: { name },
-		httpStatus: 404
+		details: safeWorkflowName(name) ? { name } : void 0
 	});
 	return definition;
 }
@@ -290,6 +266,7 @@ function createWorkflow(nameOrOptions, handlerOrOptions, options) {
 		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
 		registerInlineWorkflowDefinition(name, { handler });
 		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),
@@ -305,6 +282,7 @@ function createWorkflow(nameOrOptions, handlerOrOptions, options) {
 		registerInlineWorkflowDefinition(name, { handler });
 	} else if (handlerOrOptions !== void 0 && (typeof 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),
@@ -313,10 +291,7 @@ function createWorkflow(nameOrOptions, handlerOrOptions, options) {
 }
 async function runWorkflow(name, payload, options = {}) {
 	const config = getActiveWorkflowConfig();
-	if (config === false) throw new WorkflowError("Workflow is disabled.", {
-		code: "WORKFLOW_DISABLED",
-		httpStatus: 400
-	});
+	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
 	const id = options.id || randomId("wrun");
 	const definition = await loadRequiredWorkflowDefinition(name);
 	return await getWorkflowRuntimeAdapter(config).run({
@@ -330,16 +305,29 @@ async function runWorkflow(name, payload, options = {}) {
 }
 async function getWorkflowRun(name, id) {
 	const config = getActiveWorkflowConfig();
-	if (config === false) throw new WorkflowError("Workflow is disabled.", {
-		code: "WORKFLOW_DISABLED",
-		httpStatus: 400
-	});
+	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
 	return await getWorkflowRuntimeAdapter(config).get({
 		event: getWorkflowRuntimeEvent(),
 		id,
 		name
 	});
 }
+async function cancelWorkflow(name, id) {
+	const config = getActiveWorkflowConfig();
+	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
+	await loadRequiredWorkflowDefinition(name);
+	return await getWorkflowRuntimeAdapter(config).cancel({
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name
+	});
+}
+async function resumeWorkflowSignal(token, payload) {
+	if (!token || typeof 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);
+}
 function deferWorkflow(name, payload, options = {}) {
 	return runWithWorkflowRuntimeEvent(getWorkflowRuntimeEvent(), () => runWorkflow(name, payload, {
 		...options,
@@ -366,4 +354,4 @@ async function readValidatedPayload(request, schema) {
 	return await validatePayload(await readRequestPayload(request), schema);
 }
 //#endregion
-export { WorkflowError, createOpenWorkflowWorker, createWorkflow, createWorkflowCloudflareWorker, deferWorkflow, defineWorkflow, getCloudflareWorkflowBindingName, getCloudflareWorkflowClassName, getCloudflareWorkflowName, getVercelWorkflowName, getWorkflowRun, normalizeWorkflowOptions, readRequestPayload, readValidatedPayload, runWorkflow, startOpenWorkflowWorker, validatePayload };
+export { cancelWorkflow, createWorkflow, createWorkflowCloudflareWorker, deferWorkflow, defineWorkflow, getCloudflareWorkflowBindingName, getCloudflareWorkflowClassName, getCloudflareWorkflowName, getVercelWorkflowName, getWorkflowRun, normalizeWorkflowOptions, readRequestPayload, readValidatedPayload, resumeWorkflowSignal, runWorkflow, validatePayload };

package/dist/provider-operation-CWIV4k42.js

@@ -0,0 +1,62 @@
+import { ViteHubError, getViteHubErrorShape } from "@vite-hub/runtime";
+//#region src/errors.ts
+const workflowErrorMessages = {
+	OPENWORKFLOW_BACKEND_CLOSE_FAILED: "OpenWorkflow backend cleanup failed.",
+	OPENWORKFLOW_RUNTIME_RESET: "OpenWorkflow runtime was reset while it was being acquired.",
+	OPENWORKFLOW_WORKER_STOP_FAILED: "OpenWorkflow worker stop failed.",
+	VERCEL_WORKFLOW_SDK_LOAD_FAILED: "Vercel Workflow DevKit load failed. Install the optional workflow peer dependency.",
+	WORKFLOW_DEFINITION_NOT_FOUND: "Workflow definition was not found.",
+	WORKFLOW_DISABLED: "Workflow is disabled.",
+	WORKFLOW_NATIVE_ENTRY_INVALID: "Workflow has no transformed native Vercel entry.",
+	WORKFLOW_NATIVE_ENTRY_REQUIRED: "Workflow has no native durable entry for Vercel.",
+	WORKFLOW_OPERATION_UNSUPPORTED: "Workflow provider operation is unsupported.",
+	WORKFLOW_PROVIDER_OPERATION_FAILED: "Workflow provider operation failed.",
+	WORKFLOW_RUN_ID_UNSUPPORTED: "Native Vercel workflows assign their own run IDs."
+};
+function createWorkflowError(options) {
+	return new ViteHubError(options.code, workflowErrorMessages[options.code], options);
+}
+//#endregion
+//#region src/runtime/provider-operation.ts
+function isWorkflowBoundaryError(error) {
+	if (getViteHubErrorShape(error)) return true;
+	if (typeof error !== "object" || error === null) return false;
+	try {
+		return "name" in error && error.name === "AbortError";
+	} catch {
+		return false;
+	}
+}
+function getProviderStatus(error) {
+	if (typeof error !== "object" || error === null) return void 0;
+	try {
+		const value = error;
+		const response = typeof value.response === "object" && value.response !== null ? value.response : void 0;
+		const status = value.status ?? value.statusCode ?? response?.status;
+		return typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599 ? status : void 0;
+	} catch {
+		return;
+	}
+}
+async function runWorkflowProviderOperation(provider, operation, run) {
+	try {
+		return await run();
+	} catch (error) {
+		if (isWorkflowBoundaryError(error)) throw error;
+		const status = getProviderStatus(error);
+		throw createWorkflowError({
+			cause: error,
+			code: "WORKFLOW_PROVIDER_OPERATION_FAILED",
+			details: {
+				operation,
+				provider,
+				...status === void 0 ? {} : { status }
+			}
+		});
+	}
+}
+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 };

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

@@ -1,5 +1,5 @@
-import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
-import { t as CloudflareWorkerEnv } from "../cloudflare-env-BVUMOgFK.js";
+import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
 
 //#region src/runtime/cloudflare-runner.d.ts
 interface CloudflareWorkflowEvent {

package/dist/runtime/cloudflare-runner.js

@@ -1,23 +1,24 @@
-import { i as setActiveCloudflareEnv } from "../cloudflare-env-g0Rf3ClH.js";
+import { i as runWithActiveCloudflareEnv } from "../cloudflare-env-mFp2Uj6Z.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 }) {
 	setWorkflowRuntimeConfig(config);
 	setWorkflowRuntimeRegistry(registry);
-	setActiveCloudflareEnv(env);
-	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));
+	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));
+	});
 }
 //#endregion
 export { runCloudflareWorkflow };

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

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

package/dist/runtime/cloudflare-shared.js

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

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

@@ -1,6 +1,6 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
-import { t as WorkflowApp } from "../_app-BVWpnNHo.js";
-import { n as CloudflareWorkerExecutionContext, t as CloudflareWorkerEnv } from "../cloudflare-env-BVUMOgFK.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { t as WorkflowApp } from "../_app-DgwN4ulW.js";
+import { n as CloudflareWorkerExecutionContext, t as CloudflareWorkerEnv } from "../cloudflare-env-CIjdFTv6.js";
 
 //#region src/runtime/cloudflare-vite.d.ts
 type CloudflareWorkerApp = WorkflowApp;

package/dist/runtime/cloudflare-vite.js

@@ -1,2 +1,2 @@
-import { t as createWorkflowCloudflareWorker } from "../cloudflare-vite-DcM5YVTP.js";
+import { t as createWorkflowCloudflareWorker } from "../cloudflare-vite-B0zel2Do.js";
 export { createWorkflowCloudflareWorker };

package/dist/runtime/execute.d.ts

@@ -1,4 +1,4 @@
-import { C as WorkflowProviderStep, O as WorkflowStepFunction, g as WorkflowExecutionContext, k as WorkflowStepOptions, p as WorkflowDefinition } from "../types-ThDitg7Z.js";
+import { A as WorkflowStepFunction, C as WorkflowProviderStep, g as WorkflowExecutionContext, j as WorkflowStepOptions, p as WorkflowDefinition } from "../types-BUlYBZwH.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,5 +1,6 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
-import { n as getOpenWorkflowRuntime } from "../openworkflow-amN7IkGO.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.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"]>;
@@ -9,6 +10,7 @@ interface CreateOpenWorkflowWorkerOptions {
   registry?: WorkflowDefinitionRegistry;
 }
 interface StartOpenWorkflowWorkerOptions extends CreateOpenWorkflowWorkerOptions {
+  onError?: (error: ViteHubError) => Promise<void> | void;
   signal?: AbortSignal;
   signals?: boolean;
 }

package/dist/runtime/openworkflow-worker.js

@@ -1,5 +1,7 @@
+import { i as createWorkflowError } from "../provider-operation-CWIV4k42.js";
 import { getOpenWorkflowRuntime, registerOpenWorkflowDefinition } from "./openworkflow.js";
 import { getInlineWorkflowDefinitions, getWorkflowRuntimeConfig, getWorkflowRuntimeRegistry, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinitionForModule } from "./state.js";
+import "@vite-hub/runtime";
 //#region src/runtime/openworkflow-worker.ts
 function getProcess() {
 	return globalThis.process;
@@ -40,15 +42,70 @@ async function createOpenWorkflowWorker(options = {}) {
 async function startOpenWorkflowWorker(options = {}) {
 	const worker = await createOpenWorkflowWorker(options);
 	await worker.start();
+	const originalStop = worker.stop.bind(worker);
+	const proc = getProcess();
+	let abortListenerActive = false;
+	let processListenersActive = false;
+	let stopTask;
+	const removeListeners = () => {
+		if (abortListenerActive) {
+			abortListenerActive = false;
+			options.signal?.removeEventListener("abort", requestStop);
+		}
+		if (processListenersActive) {
+			processListenersActive = false;
+			proc?.off?.("SIGINT", requestStop);
+			proc?.off?.("SIGTERM", requestStop);
+		}
+	};
 	const stop = () => {
-		worker.stop();
+		removeListeners();
+		stopTask ??= Promise.resolve().then(() => originalStop()).catch((cause) => {
+			throw createWorkflowError({
+				cause,
+				code: "OPENWORKFLOW_WORKER_STOP_FAILED",
+				details: { provider: "openworkflow" }
+			});
+		});
+		return stopTask;
 	};
-	options.signal?.addEventListener("abort", stop, { once: true });
-	const proc = getProcess();
-	if (options.signals !== false) {
-		proc?.on?.("SIGINT", stop);
-		proc?.on?.("SIGTERM", stop);
+	const reportUnhandledError = (error) => {
+		try {
+			if (proc?.emitWarning) proc.emitWarning(error);
+			else console.error(error);
+		} catch {}
+	};
+	const reportError = (error) => {
+		if (!options.onError) {
+			reportUnhandledError(error);
+			return;
+		}
+		try {
+			Promise.resolve(options.onError(error)).catch(() => {
+				reportUnhandledError(error);
+			});
+		} catch {
+			reportUnhandledError(error);
+		}
+	};
+	function requestStop() {
+		stop().catch(reportError);
+	}
+	Object.defineProperty(worker, "stop", {
+		configurable: true,
+		value: stop,
+		writable: true
+	});
+	if (options.signal) {
+		abortListenerActive = true;
+		options.signal.addEventListener("abort", requestStop, { once: true });
+	}
+	if (options.signals !== false && proc?.on && proc.off) {
+		processListenersActive = true;
+		proc.on("SIGINT", requestStop);
+		proc.on("SIGTERM", requestStop);
 	}
+	if (options.signal?.aborted) requestStop();
 	return worker;
 }
 //#endregion

package/dist/runtime/openworkflow.d.ts

@@ -1,2 +1,23 @@
-import { a as runOpenWorkflow, i as resetOpenWorkflowRuntime, n as getOpenWorkflowRuntime, o as setOpenWorkflowImporter, r as registerOpenWorkflowDefinition, t as getOpenWorkflowRun } from "../openworkflow-amN7IkGO.js";
+import { f as WorkflowDeferOptions, l as ResolvedWorkflowOptions, p as WorkflowDefinition, w as WorkflowRun } from "../types-BUlYBZwH.js";
+
+//#region src/runtime/openworkflow.d.ts
+type OpenWorkflowModule = typeof import("openworkflow");
+type OpenWorkflowPostgresModule = typeof import("openworkflow/postgres");
+type OpenWorkflowSqliteModule = typeof import("openworkflow/sqlite");
+type OpenWorkflowClient = InstanceType<OpenWorkflowModule["OpenWorkflow"]>;
+type OpenWorkflowBackend = Awaited<ReturnType<OpenWorkflowPostgresModule["BackendPostgres"]["connect"]>> | ReturnType<OpenWorkflowSqliteModule["BackendSqlite"]["connect"]>;
+type OpenWorkflowRunnable = ReturnType<OpenWorkflowClient["defineWorkflow"]>;
+type OpenWorkflowImporter = <T>(specifier: string) => Promise<T>;
+interface OpenWorkflowRuntime {
+  backend: OpenWorkflowBackend;
+  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 };