@vite-hub/workflow 0.0.1 → 0.0.3

package/README.md

@@ -9,6 +9,8 @@
 
 `@vite-hub/workflow` defines long-running work once and starts it through one `runWorkflow()` API.
 
+Vercel definitions can register a native entry for durable execution. Definitions without one remain source-compatible, but execute inline and do not survive a function restart.
+
 ## Install
 
 ```sh
@@ -16,6 +18,7 @@ pnpm add @vite-hub/workflow
 ```
 
 Add the provider dependency for the workflow provider you configure.
+OpenWorkflow worker lifecycle helpers live at `@vite-hub/workflow/runtime/openworkflow-worker`, so importing the provider-agnostic package root does not require OpenWorkflow's types.
 
 ## Minimal API
 
@@ -32,6 +35,30 @@ export default defineWorkflow<{ email: string }>(async ({ id, payload, step }) =
 })
 ```
 
+For a durable Vercel run, keep the same context-shaped interface and register a native entry containing the Workflow DevKit directive:
+
+```ts
+import { defineWorkflow, type WorkflowExecutionContext } from "@vite-hub/workflow"
+
+interface WelcomePayload {
+  email: string
+}
+
+async function durableWelcome({ payload }: WorkflowExecutionContext<WelcomePayload>) {
+  "use workflow"
+
+  return { sentTo: payload.email }
+}
+
+async function inlineWelcome({ payload }: WorkflowExecutionContext<WelcomePayload>) {
+  return { sentTo: payload.email }
+}
+
+export default defineWorkflow(inlineWelcome, { native: durableWelcome })
+```
+
+ViteHub transforms the native entry with Workflow DevKit when it generates Vercel provider output.
+
 ```ts
 // server/api/welcome.post.ts
 import { getWorkflowRun, runWorkflow } from "@vite-hub/workflow"
@@ -43,19 +70,42 @@ export default defineEventHandler(async (event) => {
 })
 ```
 
+`getWorkflowRun()` normalizes provider run and step state, including timestamps, attempts, and failures. `cancelWorkflow()` cancels a durable run, and `resumeWorkflowSignal()` forwards an opaque signal token created inside the native workflow. Providers that cannot perform an operation fail explicitly instead of simulating it.
+
+Throw `ViteHubError` when app callers need a stable, inspectable Workflow failure instead of parsing log output or provider-specific messages. ViteHub-owned failures use the package's fixed `WorkflowErrorCode` vocabulary.
+
+```ts
+import { ViteHubError } from "@vite-hub/runtime"
+
+async function transcribe(recordingId: string) {
+  try {
+    return await transcribeRecording(recordingId)
+  }
+  catch (cause) {
+    throw new ViteHubError("TRANSCRIPTION_FAILED", "Transcription failed.", {
+      cause,
+      details: { recordingId },
+    })
+  }
+}
+```
+
+`code` and `message` remain available through `error.toJSON()`. Keep `details` JSON-safe and free of secrets; `toJSON()` omits `cause`, which remains available only on the in-memory error. ViteHub's built-in codes are typed as `WorkflowErrorCode` and use code-derived messages and code-specific details. Workflow Step retry behavior belongs in the Step's retry options rather than the error.
+
 ```ts
-// nitro.config.ts
-import { defineNitroConfig } from "nitro/config"
+// vite.config.ts
+import { hubWorkflow } from "@vite-hub/workflow/vite"
+import { defineConfig } from "vite"
 
-export default defineNitroConfig({
-  modules: ["@vite-hub/workflow/nitro"],
+export default defineConfig({
+  plugins: [hubWorkflow()],
   workflow: { provider: "openworkflow" },
 })
 ```
 
-## Vite and Nitro
+## Vite Integration
 
-Nitro discovers `server/workflows/<name>.ts` and folder workflows such as `server/workflows/welcome/index.ts` with numbered step files. Vite also supports `src/<name>.workflow.ts` through `hubWorkflow()`.
+Use `hubWorkflow()` in Vite to discover `server/workflows/<name>.ts`, folder workflows such as `server/workflows/welcome/index.ts` with numbered step files, and `src/<name>.workflow.ts`.
 
 Providers map to [OpenWorkflow](https://openworkflow.dev/docs/overview), [Cloudflare Workflows](https://developers.cloudflare.com/workflows/), or [Vercel Workflow](https://vercel.com/docs/workflow).
 

package/dist/{cloudflare-env-BVUMOgFK.d.ts → cloudflare-env-CIjdFTv6.d.ts}

@@ -4,6 +4,7 @@ interface CloudflareWorkerExecutionContext {
   waitUntil?: (promise: Promise<unknown>) => void;
 }
 declare function setActiveCloudflareEnv(env: CloudflareWorkerEnv | undefined): void;
+declare function runWithActiveCloudflareEnv<T>(env: CloudflareWorkerEnv | undefined, callback: () => T): T;
 type WaitUntilFn = (promise: Promise<unknown>) => void;
 interface CloudflareRuntimeEvent {
   context: {
@@ -18,4 +19,4 @@ interface CloudflareRuntimeEvent {
 }
 declare function createCloudflareRuntimeEvent(env: CloudflareWorkerEnv, context: CloudflareWorkerExecutionContext | undefined): CloudflareRuntimeEvent;
 //#endregion
-export { setActiveCloudflareEnv as i, CloudflareWorkerExecutionContext as n, createCloudflareRuntimeEvent as r, CloudflareWorkerEnv as t };
+export { setActiveCloudflareEnv as a, runWithActiveCloudflareEnv as i, CloudflareWorkerExecutionContext as n, createCloudflareRuntimeEvent as r, CloudflareWorkerEnv as t };

package/dist/{cloudflare-env-g0Rf3ClH.js → cloudflare-env-mFp2Uj6Z.js}

@@ -6,11 +6,15 @@ function setActiveCloudflareEnv(env) {
 	activeEnv = env;
 	globalThis.__env__ = env;
 	try {
-		activeEnvStorage.enterWith(env);
+		activeEnvStorage.enterWith({ env });
 	} catch {}
 }
+function runWithActiveCloudflareEnv(env, callback) {
+	return activeEnvStorage.run({ env }, callback);
+}
 function getActiveCloudflareEnv() {
-	return activeEnvStorage.getStore() ?? activeEnv ?? globalThis.__env__;
+	const scoped = activeEnvStorage.getStore();
+	return scoped ? scoped.env : activeEnv ?? globalThis.__env__;
 }
 function getCloudflareEnv(event) {
 	const target = event;
@@ -46,4 +50,4 @@ function createCloudflareRuntimeEvent(env, context) {
 	};
 }
 //#endregion
-export { setActiveCloudflareEnv as i, getCloudflareEnv as n, resolveWaitUntil as r, createCloudflareRuntimeEvent as t };
+export { setActiveCloudflareEnv as a, runWithActiveCloudflareEnv as i, getCloudflareEnv as n, resolveWaitUntil as r, createCloudflareRuntimeEvent as t };

package/dist/{cloudflare-vite-DcM5YVTP.js → cloudflare-vite-B0zel2Do.js}

@@ -1,7 +1,7 @@
-import { t as normalizeWorkflowOptions } from "./config-DkgsQuXz.js";
-import { i as setActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "./cloudflare-env-g0Rf3ClH.js";
+import { t as normalizeWorkflowOptions } from "./config-BDqB6I4E.js";
+import { i as runWithActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "./cloudflare-env-mFp2Uj6Z.js";
 import { runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./runtime/state.js";
-import { t as resolveAppFetch } from "./app-BE3EYOWn.js";
+import { t as resolveAppFetch } from "./app-BZpq2cwC.js";
 import { H3, toWebHandler } from "h3/cloudflare";
 //#region ../internal/src/runtime/cloudflare-hosted.ts
 function createWebRequestHandler(appHandler) {
@@ -30,9 +30,8 @@ function createWorkflowCloudflareWorker(options = {}) {
 		async onRequest({ env, executionContext, handle }) {
 			setWorkflowRuntimeConfig(workflowConfig);
 			setWorkflowRuntimeRegistry(options.registry);
-			setActiveCloudflareEnv(env);
 			const runtimeEvent = createCloudflareRuntimeEvent(env, executionContext);
-			return await runWithWorkflowRuntimeEvent(runtimeEvent, () => handle(runtimeEvent.context));
+			return await runWithActiveCloudflareEnv(env, () => runWithWorkflowRuntimeEvent(runtimeEvent, () => handle(runtimeEvent.context)));
 		}
 	});
 }

package/dist/{config-DkgsQuXz.js → config-BDqB6I4E.js}

@@ -1,5 +1,5 @@
 import { defu } from "defu";
-//#region ../internal/src/feature-bridge/hosting.ts
+//#region ../internal/src/hosting.ts
 function normalizeHosting(hosting) {
 	const normalized = hosting?.trim().toLowerCase().replaceAll("_", "-") || "";
 	if (normalized === "cloudflare") return "cloudflare-module";
@@ -22,11 +22,26 @@ function readString(value, label) {
 	if (typeof value !== "string" || !value.trim()) throw new TypeError(`\`${label}\` must be a non-empty string when provided.`);
 	return value.trim();
 }
+function readRuntimeConfigValue(value, label) {
+	if (typeof value === "undefined") return;
+	if (typeof value === "string") return readString(value, label);
+	if (!isRuntimeEnvDeclaration(value)) throw new TypeError(`\`${label}\` must be a string or runtime env declaration.`);
+	return value;
+}
 function readBoolean(value, label) {
 	if (typeof value === "undefined") return;
 	if (typeof value !== "boolean") throw new TypeError(`\`${label}\` must be a boolean when provided.`);
 	return value;
 }
+function isRuntimeEnvDeclaration(value) {
+	return isPlainObject(value) && value.kind === "env-variable" && (!("source" in value) || isRuntimeEnvSource(value.source));
+}
+function isRuntimeEnvSource(value) {
+	return isPlainObject(value) && value.kind === "env" && typeof value.name === "string" && (!("names" in value) || Array.isArray(value.names) && value.names.every((name) => typeof name === "string"));
+}
+function readDatabaseName(value) {
+	return readString(value, "workflow.database");
+}
 function readPositiveInteger(value, label) {
 	if (typeof value === "undefined") return;
 	if (!Number.isInteger(value) || value <= 0) throw new TypeError(`\`${label}\` must be a positive integer when provided.`);
@@ -38,7 +53,7 @@ function normalizeOpenWorkflowPostgresOptions(value) {
 	const namespaceId = readString(value.namespaceId, "workflow.postgres.namespaceId");
 	const runMigrations = readBoolean(value.runMigrations, "workflow.postgres.runMigrations");
 	const schema = readString(value.schema, "workflow.postgres.schema");
-	const url = readString(value.url, "workflow.postgres.url");
+	const url = readRuntimeConfigValue(value.url, "workflow.postgres.url");
 	return {
 		...namespaceId ? { namespaceId } : {},
 		...typeof runMigrations === "boolean" ? { runMigrations } : {},
@@ -46,22 +61,38 @@ function normalizeOpenWorkflowPostgresOptions(value) {
 		...url ? { url } : {}
 	};
 }
+function normalizeOpenWorkflowSqliteOptions(value) {
+	if (typeof value === "undefined") return;
+	if (!isPlainObject(value)) throw new TypeError("`workflow.sqlite` must be a plain object.");
+	const namespaceId = readString(value.namespaceId, "workflow.sqlite.namespaceId");
+	const path = readRuntimeConfigValue(value.path, "workflow.sqlite.path");
+	const runMigrations = readBoolean(value.runMigrations, "workflow.sqlite.runMigrations");
+	return {
+		...namespaceId ? { namespaceId } : {},
+		...path ? { path } : {},
+		...typeof runMigrations === "boolean" ? { runMigrations } : {}
+	};
+}
 function normalizeOpenWorkflowWorkerOptions(value) {
 	if (typeof value === "undefined") return;
 	if (!isPlainObject(value)) throw new TypeError("`workflow.worker` must be a plain object.");
 	const concurrency = readPositiveInteger(value.concurrency, "workflow.worker.concurrency");
 	return typeof concurrency === "number" ? { concurrency } : {};
 }
-function hasOpenWorkflowPostgresConfig(options) {
-	return isPlainObject(options.postgres) && typeof options.postgres.url === "string" && !!options.postgres.url.trim();
+function hasOpenWorkflowStorageConfig(options) {
+	return typeof options.database === "string" && !!options.database.trim() || isPlainObject(options.postgres) && isDefinedRuntimeConfigValue(options.postgres.url) || isPlainObject(options.sqlite) && isDefinedRuntimeConfigValue(options.sqlite.path);
+}
+function isDefinedRuntimeConfigValue(value) {
+	return typeof value === "string" && !!value.trim() || isRuntimeEnvDeclaration(value);
 }
 function inferProvider(provider, hosting) {
 	if (provider === "cloudflare" || provider === "openworkflow" || provider === "vercel") return provider;
+	if (hosting.includes("netlify")) throw new TypeError("`workflow.provider` cannot be inferred for Netlify hosting. Set `workflow.provider` explicitly or disable `workflow`.");
 	if (hosting.includes("cloudflare")) return "cloudflare";
 	return "vercel";
 }
 function inferProviderFromOptions(options, hosting) {
-	if (typeof options.provider === "undefined" && (hosting.includes("node") || hosting.includes("docker")) && hasOpenWorkflowPostgresConfig(options)) return "openworkflow";
+	if (typeof options.provider === "undefined" && (hosting.includes("node") || hosting.includes("docker")) && hasOpenWorkflowStorageConfig(options)) return "openworkflow";
 	return inferProvider(options.provider, hosting);
 }
 function resolveProvider(options, hosting) {
@@ -74,10 +105,17 @@ function resolveProvider(options, hosting) {
 	const resolved = inferProviderFromOptions(options, hosting);
 	if (resolved === "cloudflare") return defu(shared, { provider: "cloudflare" });
 	if (resolved === "openworkflow") {
+		const database = readDatabaseName(options.database);
 		const postgres = normalizeOpenWorkflowPostgresOptions(options.postgres);
+		const sqlite = normalizeOpenWorkflowSqliteOptions(options.sqlite);
 		const worker = normalizeOpenWorkflowWorkerOptions(options.worker);
+		if (database && postgres?.url) throw new TypeError("`workflow.database` and `workflow.postgres.url` cannot both configure OpenWorkflow storage.");
+		if (database && sqlite?.path) throw new TypeError("`workflow.database` and `workflow.sqlite.path` cannot both configure OpenWorkflow storage.");
+		if (postgres?.url && sqlite?.path) throw new TypeError("`workflow.postgres.url` and `workflow.sqlite.path` cannot both configure OpenWorkflow storage.");
 		return defu({
+			...database ? { database } : {},
 			...postgres ? { postgres } : {},
+			...sqlite ? { sqlite } : {},
 			...worker ? { worker } : {}
 		}, shared, { provider: "openworkflow" });
 	}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { A as WorkflowStepRunner, C as WorkflowProviderStep, D as WorkflowStartOptions, E as WorkflowSharedOptions, O as WorkflowStepFunction, S as WorkflowProviderOptions, T as WorkflowRunStatus, _ as WorkflowHandle, a as InferredWorkflowProviderOptions, b as WorkflowModuleProviderOptions, c as OpenWorkflowWorkerOptions, d as WorkflowCreateOptions, f as WorkflowDeferOptions, g as WorkflowExecutionContext, h as WorkflowDefinitionRegistry, i as DiscoveredWorkflowDefinition, k as WorkflowStepOptions, l as ResolvedWorkflowOptions, m as WorkflowDefinitionOptions, n as CloudflareWorkflowInstance, o as OpenWorkflowPostgresOptions, p as WorkflowDefinition, r as CloudflareWorkflowProviderOptions, s as OpenWorkflowProviderOptions, t as CloudflareWorkflowBinding, u as VercelWorkflowProviderOptions, v as WorkflowHandler, w as WorkflowRun, x as WorkflowProvider, y as WorkflowModuleOptions } from "./types-ThDitg7Z.js";
+import { A as WorkflowStepFunction, C as WorkflowProviderStep, D as WorkflowSharedOptions, E as WorkflowRunStep, M as WorkflowStepRunner, O as WorkflowSignalResult, S as WorkflowProviderOptions, T as WorkflowRunStatus, _ as WorkflowHandle, a as InferredWorkflowProviderOptions, b as WorkflowModuleProviderOptions, c as OpenWorkflowWorkerOptions, d as WorkflowCreateOptions, f as WorkflowDeferOptions, g as WorkflowExecutionContext, h as WorkflowDefinitionRegistry, i as DiscoveredWorkflowDefinition, j as WorkflowStepOptions, k as WorkflowStartOptions, l as ResolvedWorkflowOptions, m as WorkflowDefinitionOptions, n as CloudflareWorkflowInstance, o as OpenWorkflowPostgresOptions, p as WorkflowDefinition, r as CloudflareWorkflowProviderOptions, s as OpenWorkflowProviderOptions, t as CloudflareWorkflowBinding, u as VercelWorkflowProviderOptions, v as WorkflowHandler, w as WorkflowRun, x as WorkflowProvider, y as WorkflowModuleOptions } from "./types-BUlYBZwH.js";
 import { createWorkflowCloudflareWorker } from "./runtime/cloudflare-vite.js";
-import { createOpenWorkflowWorker, startOpenWorkflowWorker } from "./runtime/openworkflow-worker.js";
+import { ViteHubError } from "@vite-hub/runtime";
 
 //#region src/config.d.ts
 interface WorkflowResolutionInput {
@@ -9,23 +9,46 @@ interface WorkflowResolutionInput {
 declare function normalizeWorkflowOptions(options: WorkflowModuleOptions | undefined, input?: WorkflowResolutionInput): ResolvedWorkflowOptions | undefined;
 //#endregion
 //#region src/definition.d.ts
-declare function defineWorkflow<TPayload = unknown, TResult = unknown>(handler: WorkflowHandler<TPayload, TResult>, options?: WorkflowDefinitionOptions): WorkflowDefinition<TPayload, TResult>;
+declare function defineWorkflow<TPayload = unknown, TResult = unknown>(handler: WorkflowHandler<TPayload, TResult>, options?: WorkflowDefinitionOptions<TPayload, TResult>): WorkflowDefinition<TPayload, TResult>;
 //#endregion
 //#region src/errors.d.ts
-interface WorkflowErrorOptions {
-  cause?: unknown;
-  code?: string;
-  details?: Record<string, unknown>;
-  httpStatus?: number;
-  provider?: string;
-}
-declare class WorkflowError extends Error {
-  readonly code?: string;
-  readonly details?: Record<string, unknown>;
-  readonly httpStatus?: number;
-  readonly provider?: string;
-  constructor(message: string, options?: WorkflowErrorOptions);
-}
+declare const workflowErrorMessages: {
+  readonly OPENWORKFLOW_BACKEND_CLOSE_FAILED: "OpenWorkflow backend cleanup failed.";
+  readonly OPENWORKFLOW_RUNTIME_RESET: "OpenWorkflow runtime was reset while it was being acquired.";
+  readonly OPENWORKFLOW_WORKER_STOP_FAILED: "OpenWorkflow worker stop failed.";
+  readonly VERCEL_WORKFLOW_SDK_LOAD_FAILED: "Vercel Workflow DevKit load failed. Install the optional workflow peer dependency.";
+  readonly WORKFLOW_DEFINITION_NOT_FOUND: "Workflow definition was not found.";
+  readonly WORKFLOW_DISABLED: "Workflow is disabled.";
+  readonly WORKFLOW_NATIVE_ENTRY_INVALID: "Workflow has no transformed native Vercel entry.";
+  readonly WORKFLOW_NATIVE_ENTRY_REQUIRED: "Workflow has no native durable entry for Vercel.";
+  readonly WORKFLOW_OPERATION_UNSUPPORTED: "Workflow provider operation is unsupported.";
+  readonly WORKFLOW_PROVIDER_OPERATION_FAILED: "Workflow provider operation failed.";
+  readonly WORKFLOW_RUN_ID_UNSUPPORTED: "Native Vercel workflows assign their own run IDs.";
+};
+declare const workflowProviderNames: readonly ["cloudflare", "openworkflow", "vercel"];
+declare const workflowOperationNames: readonly ["cancel", "cancellation", "connect", "create", "get", "get-run", "import", "list-steps", "resume-signal", "run", "signals", "start", "status"];
+type WorkflowErrorCode = keyof typeof workflowErrorMessages;
+type WorkflowOperationName = typeof workflowOperationNames[number];
+type WorkflowProviderName = typeof workflowProviderNames[number];
+type WorkflowNameDetails = {
+  name?: string;
+};
+type VercelWorkflowDetails = {
+  name?: string;
+  provider: "vercel";
+};
+type WorkflowOperationDetails = {
+  operation: WorkflowOperationName;
+  provider: WorkflowProviderName;
+};
+type WorkflowProviderOperationDetails = WorkflowOperationDetails & {
+  status?: number;
+};
+type WorkflowErrorDetails<TCode extends WorkflowErrorCode = WorkflowErrorCode> = TCode extends "OPENWORKFLOW_BACKEND_CLOSE_FAILED" | "OPENWORKFLOW_RUNTIME_RESET" | "OPENWORKFLOW_WORKER_STOP_FAILED" ? {
+  provider: "openworkflow";
+} : TCode extends "VERCEL_WORKFLOW_SDK_LOAD_FAILED" ? {
+  provider: "vercel";
+} : TCode extends "WORKFLOW_DEFINITION_NOT_FOUND" ? WorkflowNameDetails : TCode extends "WORKFLOW_DISABLED" ? Record<string, never> : TCode extends "WORKFLOW_NATIVE_ENTRY_INVALID" | "WORKFLOW_NATIVE_ENTRY_REQUIRED" | "WORKFLOW_RUN_ID_UNSUPPORTED" ? VercelWorkflowDetails : TCode extends "WORKFLOW_OPERATION_UNSUPPORTED" ? WorkflowOperationDetails : TCode extends "WORKFLOW_PROVIDER_OPERATION_FAILED" ? WorkflowProviderOperationDetails : never;
 //#endregion
 //#region src/integrations/cloudflare.d.ts
 declare function getCloudflareWorkflowBindingName(name: string): string;
@@ -44,6 +67,8 @@ declare function createWorkflow<TPayload = unknown, TResult = unknown>(name: str
 declare function createWorkflow<TPayload = unknown, TResult = unknown>(name: string, handler: WorkflowHandler<TPayload, TResult>, options?: WorkflowCreateOptions<TPayload, TResult>): WorkflowHandle<TPayload, TResult>;
 declare function runWorkflow<TPayload = unknown, TResult = unknown>(name: string, payload?: TPayload, options?: WorkflowDeferOptions): Promise<WorkflowRun<TPayload, TResult>>;
 declare function getWorkflowRun<TPayload = unknown, TResult = unknown>(name: string, id: string): Promise<WorkflowRun<TPayload, TResult>>;
+declare function cancelWorkflow<TPayload = unknown, TResult = unknown>(name: string, id: string): Promise<WorkflowRun<TPayload, TResult>>;
+declare function resumeWorkflowSignal<TPayload = unknown>(token: string, payload: TPayload): Promise<WorkflowSignalResult>;
 declare function deferWorkflow<TPayload = unknown>(name: string, payload?: TPayload, options?: WorkflowStartOptions): Promise<WorkflowRun<TPayload>>;
 //#endregion
 //#region src/runtime/payload.d.ts
@@ -62,4 +87,4 @@ declare function readRequestPayload<T = unknown>(request: Request): Promise<T>;
 declare function validatePayload<T>(payload: unknown, schema: PayloadValidator<T>): Promise<T>;
 declare function readValidatedPayload<T>(request: Request, schema: PayloadValidator<T>): Promise<T>;
 //#endregion
-export { type CloudflareWorkflowBinding, type CloudflareWorkflowInstance, type CloudflareWorkflowProviderOptions, type DiscoveredWorkflowDefinition, type InferredWorkflowProviderOptions, type OpenWorkflowPostgresOptions, type OpenWorkflowProviderOptions, type OpenWorkflowWorkerOptions, type ResolvedWorkflowOptions, type VercelWorkflowProviderOptions, type WorkflowCreateOptions, type WorkflowDeferOptions, type WorkflowDefinition, type WorkflowDefinitionOptions, type WorkflowDefinitionRegistry, WorkflowError, type WorkflowExecutionContext, type WorkflowHandle, type WorkflowHandler, type WorkflowModuleOptions, type WorkflowModuleProviderOptions, type WorkflowProvider, type WorkflowProviderOptions, type WorkflowProviderStep, type WorkflowRun, type WorkflowRunStatus, type WorkflowSharedOptions, type WorkflowStartOptions, type WorkflowStepFunction, type WorkflowStepOptions, type WorkflowStepRunner, createOpenWorkflowWorker, createWorkflow, createWorkflowCloudflareWorker, deferWorkflow, defineWorkflow, getCloudflareWorkflowBindingName, getCloudflareWorkflowClassName, getCloudflareWorkflowName, getVercelWorkflowName, getWorkflowRun, normalizeWorkflowOptions, readRequestPayload, readValidatedPayload, runWorkflow, startOpenWorkflowWorker, validatePayload };
+export { type CloudflareWorkflowBinding, type CloudflareWorkflowInstance, type CloudflareWorkflowProviderOptions, type DiscoveredWorkflowDefinition, type InferredWorkflowProviderOptions, type OpenWorkflowPostgresOptions, type OpenWorkflowProviderOptions, type OpenWorkflowWorkerOptions, type ResolvedWorkflowOptions, type VercelWorkflowProviderOptions, type WorkflowCreateOptions, type WorkflowDeferOptions, type WorkflowDefinition, type WorkflowDefinitionOptions, type WorkflowDefinitionRegistry, type WorkflowErrorCode, type WorkflowErrorDetails, type WorkflowExecutionContext, type WorkflowHandle, type WorkflowHandler, type WorkflowModuleOptions, type WorkflowModuleProviderOptions, type WorkflowOperationName, type WorkflowProvider, type WorkflowProviderName, type WorkflowProviderOptions, type WorkflowProviderStep, type WorkflowRun, type WorkflowRunStatus, type WorkflowRunStep, type WorkflowSharedOptions, type WorkflowSignalResult, type WorkflowStartOptions, type WorkflowStepFunction, type WorkflowStepOptions, type WorkflowStepRunner, cancelWorkflow, createWorkflow, createWorkflowCloudflareWorker, deferWorkflow, defineWorkflow, getCloudflareWorkflowBindingName, getCloudflareWorkflowClassName, getCloudflareWorkflowName, getVercelWorkflowName, getWorkflowRun, normalizeWorkflowOptions, readRequestPayload, readValidatedPayload, resumeWorkflowSignal, runWorkflow, validatePayload };