@vite-hub/workflow 0.0.0 → 0.0.2

package/dist/index.js

@@ -0,0 +1,357 @@
+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 { 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/integrations/vercel.ts
+function getVercelWorkflowName(name) {
+	return `workflow--${encodeNameHex(name)}`;
+}
+//#endregion
+//#region ../internal/src/runtime/random.ts
+function randomId(prefix) {
+	const body = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+	return prefix ? `${prefix}_${body}` : body;
+}
+//#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",
+	failed: "failed",
+	queued: "queued",
+	running: "running",
+	success: "completed",
+	terminated: "failed"
+};
+function normalizeCloudflareStatus(status) {
+	const value = typeof status === "object" && status ? status.status : status;
+	return cloudflareStatusMap[String(value || "").toLowerCase()] || "unknown";
+}
+function createCloudflareAdapter(config) {
+	return {
+		cancel: () => unsupportedOperation("cloudflare", "cancellation"),
+		async get({ event, id, name }) {
+			const binding = resolveCloudflareBinding(event, config.binding, name);
+			if (binding) {
+				const instance = await runWorkflowProviderOperation("cloudflare", "get", () => binding.get(id));
+				const metadata = await runWorkflowProviderOperation("cloudflare", "status", () => instance.status());
+				return {
+					id,
+					metadata,
+					provider: "cloudflare",
+					status: normalizeCloudflareStatus(metadata)
+				};
+			}
+			return await inlineAdapter(config).get({
+				event,
+				id,
+				name
+			});
+		},
+		async run({ definition, event, id, name, options, payload }) {
+			const binding = resolveCloudflareBinding(event, config.binding, name);
+			if (binding) {
+				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 runWorkflowProviderOperation("cloudflare", "status", () => instance.status()),
+					payload,
+					provider: "cloudflare",
+					status: "queued"
+				};
+			}
+			return await inlineAdapter(config).run({
+				definition,
+				event,
+				id,
+				name,
+				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) {
+				if (run.status === "running") return {
+					id,
+					provider: config.provider,
+					status: "running"
+				};
+				return {
+					id,
+					metadata: run.error,
+					provider: config.provider,
+					result: run.result,
+					status: run.status
+				};
+			}
+			return {
+				id,
+				provider: config.provider,
+				status: "unknown"
+			};
+		},
+		async run({ definition, event, id, name, payload }) {
+			const runState = setWorkflowRun(name, id, Promise.resolve().then(() => runWorkflowHandler({
+				id,
+				name,
+				payload,
+				provider: config.provider
+			}, definition)).then((result) => ({
+				result,
+				status: "completed"
+			})).catch((error) => ({
+				error,
+				status: "failed"
+			})));
+			const waitUntil = resolveWaitUntil(event);
+			if (waitUntil) waitUntil(runState.promise);
+			return {
+				id,
+				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 createVercelAdapter(config);
+}
+//#endregion
+//#region src/runtime/client.ts
+function getActiveWorkflowConfig() {
+	const config = getWorkflowRuntimeConfig();
+	if (config === false) return false;
+	return config || normalizeWorkflowOptions(void 0, { hosting: "vercel" });
+}
+async function loadRequiredWorkflowDefinition(name) {
+	const definition = await loadWorkflowDefinition(name);
+	if (!definition) throw createWorkflowError({
+		code: "WORKFLOW_DEFINITION_NOT_FOUND",
+		details: safeWorkflowName(name) ? { name } : void 0
+	});
+	return definition;
+}
+function normalizeWorkflowRunIdValue(value) {
+	if (value === void 0) return null;
+	if (value === null || typeof 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])]));
+}
+async function sha256Hex(value) {
+	const data = new TextEncoder().encode(value);
+	const digest = await crypto.subtle.digest("SHA-256", data);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function createStableWorkflowRunId(name, value) {
+	const hash = await sha256Hex(`${name}:${JSON.stringify(normalizeWorkflowRunIdValue(value))}`);
+	return `${name.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "workflow"}-${hash.slice(0, 32)}`;
+}
+async function resolveWorkflowStartOptions(name, payload, createOptions, startOptions) {
+	if (startOptions.id || !createOptions?.id) return startOptions;
+	return {
+		...startOptions,
+		id: await createStableWorkflowRunId(name, await createOptions.id({
+			name,
+			payload
+		}))
+	};
+}
+function createWorkflow(nameOrOptions, handlerOrOptions, options) {
+	if (typeof 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 });
+		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))
+		};
+	}
+	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 (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.");
+	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 function runWorkflow(name, payload, options = {}) {
+	const config = getActiveWorkflowConfig();
+	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
+	const id = options.id || randomId("wrun");
+	const definition = await loadRequiredWorkflowDefinition(name);
+	return await getWorkflowRuntimeAdapter(config).run({
+		definition,
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name,
+		options,
+		payload
+	});
+}
+async function getWorkflowRun(name, id) {
+	const config = getActiveWorkflowConfig();
+	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,
+		deferred: true
+	}));
+}
+//#endregion
+//#region src/runtime/payload.ts
+async function readRequestPayload(request) {
+	if ((request.headers.get("content-type") || "").includes("application/json")) return await request.json();
+	return await request.text();
+}
+async function validatePayload(payload, schema) {
+	if (typeof schema === "function") return await schema(payload);
+	if ("safeParse" in schema && typeof schema.safeParse === "function") {
+		const result = schema.safeParse(payload);
+		if (!result.success) throw result.error || /* @__PURE__ */ new TypeError("Invalid workflow payload.");
+		return result.data;
+	}
+	if ("parse" in schema && typeof schema.parse === "function") return schema.parse(payload);
+	throw new TypeError("Invalid workflow payload schema.");
+}
+async function readValidatedPayload(request, schema) {
+	return await validatePayload(await readRequestPayload(request), schema);
+}
+//#endregion
+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

@@ -0,0 +1,27 @@
+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 {
+  id?: string;
+  instanceId?: string;
+  payload?: unknown;
+}
+interface RunCloudflareWorkflowOptions {
+  config: false | ResolvedWorkflowOptions | undefined;
+  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 };

package/dist/runtime/cloudflare-runner.js

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,17 @@
+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;
+interface WorkflowCloudflareWorkerOptions {
+  app?: CloudflareWorkerApp;
+  registry?: WorkflowDefinitionRegistry;
+  workflow?: false | ResolvedWorkflowOptions;
+}
+interface WorkflowCloudflareWorker {
+  fetch: (request: Request, env: CloudflareWorkerEnv, context: CloudflareWorkerExecutionContext) => Promise<Response>;
+}
+declare function createWorkflowCloudflareWorker(options?: WorkflowCloudflareWorkerOptions): WorkflowCloudflareWorker;
+//#endregion
+export { CloudflareWorkerApp, WorkflowCloudflareWorker, WorkflowCloudflareWorkerOptions, createWorkflowCloudflareWorker };

package/dist/runtime/cloudflare-vite.js

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

package/dist/runtime/execute.d.ts

@@ -0,0 +1,11 @@
+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>;
+declare function createWorkflowSteps(context: WorkflowExecutionContext, 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 };

package/dist/runtime/execute.js

@@ -0,0 +1,25 @@
+//#region src/runtime/execute.ts
+const defaultStepOptions = { retries: {
+	backoff: "exponential",
+	delay: "10 seconds",
+	limit: 3
+} };
+async function runProviderStep(step, name, run, options = defaultStepOptions) {
+	if (typeof step?.do === "function") return await step.do(name, options, run);
+	return await run();
+}
+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) {
+	return Object.fromEntries(stepModules.map((module) => {
+		return [toStepPropertyName(module.name), async (input) => await runProviderStep(context.step, `${context.name}/${module.name}`, () => module.run(input))];
+	}));
+}
+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);
+}
+//#endregion
+export { createWorkflowSteps, runProviderStep, runWorkflowHandler };

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

@@ -0,0 +1,20 @@
+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"]>;
+interface CreateOpenWorkflowWorkerOptions {
+  concurrency?: number;
+  config?: false | ResolvedWorkflowOptions;
+  registry?: WorkflowDefinitionRegistry;
+}
+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 };

package/dist/runtime/openworkflow-worker.js

@@ -0,0 +1,112 @@
+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;
+}
+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") {
+			definitions.set(name, definition);
+			continue;
+		}
+		const inlineDefinition = takeInlineWorkflowDefinitionForModule(name, loaded);
+		if (inlineDefinition) definitions.set(name, inlineDefinition);
+	}
+	return definitions;
+}
+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.`);
+		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\".");
+	const registry = options.registry ?? getWorkflowRuntimeRegistry() ?? {};
+	setWorkflowRuntimeConfig(config);
+	setWorkflowRuntimeRegistry(registry);
+	const runtime = await getOpenWorkflowRuntime(config);
+	const definitions = await loadRegistryDefinitions(registry);
+	mergeInlineDefinitions(definitions);
+	for (const [name, definition] of definitions) await registerOpenWorkflowDefinition(runtime, name, definition);
+	return runtime.client.newWorker({ concurrency: options.concurrency ?? config.worker?.concurrency });
+}
+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 = () => {
+		removeListeners();
+		stopTask ??= Promise.resolve().then(() => originalStop()).catch((cause) => {
+			throw createWorkflowError({
+				cause,
+				code: "OPENWORKFLOW_WORKER_STOP_FAILED",
+				details: { provider: "openworkflow" }
+			});
+		});
+		return stopTask;
+	};
+	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
+export { createOpenWorkflowWorker, startOpenWorkflowWorker };