@vite-hub/workflow 0.0.0 → 0.0.2

package/dist/runtime/openworkflow.d.ts

@@ -0,0 +1,23 @@
+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 };

package/dist/runtime/openworkflow.js

@@ -0,0 +1,216 @@
+import { i as createWorkflowError, n as runWorkflowProviderOperation } from "../provider-operation-CWIV4k42.js";
+import { runWorkflowHandler } from "./execute.js";
+//#region src/runtime/openworkflow.ts
+const defaultImporter = new Function("specifier", "return import(specifier)");
+let openWorkflowImporter = defaultImporter;
+const defaultOpenWorkflowSqlitePath = ".vitehub/data/openworkflow.sqlite.db";
+let runtimes = /* @__PURE__ */ new Map();
+async function importOpenWorkflowModule(specifier, importer) {
+	return await runWorkflowProviderOperation("openworkflow", "import", () => importer(specifier));
+}
+function readEnv(name) {
+	const value = (globalThis.process?.env)?.[name];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveRuntimeConfigValue(value) {
+	if (typeof value === "string" || typeof value === "undefined") return value;
+	for (const name of getRuntimeEnvNames(value)) {
+		const resolved = readEnv(name);
+		if (resolved) return resolved;
+	}
+	return typeof value.default === "string" && value.default.trim() ? value.default.trim() : void 0;
+}
+function getRuntimeEnvNames(value) {
+	return value.source?.names ?? (value.source?.name ? [value.source.name] : []);
+}
+function normalizeSqlitePath(path) {
+	if (/^(?:libsql:|https?:\/\/)/i.test(path)) throw new Error(`OpenWorkflow SQLite storage requires a local SQLite file path, received ${JSON.stringify(path)}.`);
+	if (/^[a-z][a-z0-9+.-]*:/i.test(path) && !path.startsWith("file:")) throw new Error(`OpenWorkflow SQLite storage received unsupported storage URL ${JSON.stringify(path)}.`);
+	return path.startsWith("file:") ? path.slice(5) : path;
+}
+async function prepareSqlitePath(path, importer) {
+	if (path !== ":memory:") {
+		const [{ mkdirSync }, { dirname }] = await Promise.all([importOpenWorkflowModule("node:fs", importer), importOpenWorkflowModule("node:path", importer)]);
+		mkdirSync(dirname(path), { recursive: true });
+	}
+	return path;
+}
+function getOpenWorkflowConfig(config) {
+	if (config.provider !== "openworkflow") throw new Error(`OpenWorkflow runtime requires workflow.provider "openworkflow", received "${config.provider}".`);
+	const sqlite = config.sqlite || {};
+	const sqlitePath = resolveRuntimeConfigValue(sqlite.path) || readEnv("OPENWORKFLOW_SQLITE_PATH");
+	if (sqlitePath) return {
+		backend: "sqlite",
+		namespaceId: sqlite.namespaceId || readEnv("OPENWORKFLOW_NAMESPACE_ID") || "production",
+		path: normalizeSqlitePath(sqlitePath),
+		runMigrations: sqlite.runMigrations
+	};
+	const postgres = config.postgres || {};
+	const url = resolveRuntimeConfigValue(postgres.url) || readEnv("OPENWORKFLOW_POSTGRES_URL") || readEnv("DATABASE_URL");
+	if (url) return {
+		backend: "postgres",
+		namespaceId: postgres.namespaceId || readEnv("OPENWORKFLOW_NAMESPACE_ID") || "production",
+		runMigrations: postgres.runMigrations,
+		schema: postgres.schema || readEnv("OPENWORKFLOW_SCHEMA") || "openworkflow",
+		url
+	};
+	return {
+		backend: "sqlite",
+		namespaceId: sqlite.namespaceId || readEnv("OPENWORKFLOW_NAMESPACE_ID") || "production",
+		path: defaultOpenWorkflowSqlitePath,
+		runMigrations: sqlite.runMigrations
+	};
+}
+function getRuntimeKey(config) {
+	return JSON.stringify(getOpenWorkflowConfig(config));
+}
+async function createOpenWorkflowRuntime(config, importer) {
+	const options = getOpenWorkflowConfig(config);
+	const [{ OpenWorkflow }, backendModule] = await Promise.all([importOpenWorkflowModule("openworkflow", importer), options.backend === "sqlite" ? importOpenWorkflowModule("openworkflow/sqlite", importer) : importOpenWorkflowModule("openworkflow/postgres", importer)]);
+	const { backend, client } = await runWorkflowProviderOperation("openworkflow", "connect", async () => {
+		let backend;
+		if (options.backend === "sqlite") backend = await backendModule.BackendSqlite.connect(await prepareSqlitePath(options.path, importer), {
+			namespaceId: options.namespaceId,
+			...typeof options.runMigrations === "boolean" ? { runMigrations: options.runMigrations } : {}
+		});
+		else backend = await backendModule.BackendPostgres.connect(options.url, {
+			namespaceId: options.namespaceId,
+			...typeof options.runMigrations === "boolean" ? { runMigrations: options.runMigrations } : {},
+			schema: options.schema
+		});
+		return {
+			backend,
+			client: new OpenWorkflow({ backend })
+		};
+	});
+	return {
+		backend,
+		client,
+		workflows: /* @__PURE__ */ new Map()
+	};
+}
+async function getOpenWorkflowRuntime(config) {
+	const cache = runtimes;
+	const key = getRuntimeKey(config);
+	let runtime = cache.get(key);
+	if (!runtime) {
+		runtime = createOpenWorkflowRuntime(config, openWorkflowImporter);
+		cache.set(key, runtime);
+		runtime.catch(() => {
+			if (cache.get(key) === runtime) cache.delete(key);
+		});
+	}
+	const resolved = await runtime;
+	if (cache !== runtimes) throw createWorkflowError({
+		code: "OPENWORKFLOW_RUNTIME_RESET",
+		details: { provider: "openworkflow" }
+	});
+	return resolved;
+}
+function toOpenWorkflowRetryPolicy(options) {
+	const retries = options.retries;
+	if (!retries) return;
+	return {
+		...retries.backoff ? { backoffCoefficient: retries.backoff === "exponential" ? 2 : 1 } : {},
+		...retries.delay ? { initialInterval: retries.delay } : {},
+		...typeof retries.limit === "number" ? { maximumAttempts: retries.limit } : {}
+	};
+}
+function createOpenWorkflowProviderStep(step) {
+	return { async do(name, options, run) {
+		return await step.run({
+			name,
+			...toOpenWorkflowRetryPolicy(options) ? { retryPolicy: toOpenWorkflowRetryPolicy(options) } : {}
+		}, run);
+	} };
+}
+async function registerOpenWorkflowDefinition(runtime, name, definition) {
+	const existing = runtime.workflows.get(name);
+	if (existing) return existing;
+	const workflow = runtime.client.defineWorkflow({ name }, async ({ input, run, step }) => {
+		return await runWorkflowHandler({
+			id: run.id,
+			name,
+			payload: input,
+			provider: "openworkflow",
+			step: createOpenWorkflowProviderStep(step)
+		}, definition);
+	});
+	runtime.workflows.set(name, workflow);
+	return workflow;
+}
+function normalizeOpenWorkflowStatus(status) {
+	switch (String(status || "").toLowerCase()) {
+		case "completed":
+		case "succeeded": return "completed";
+		case "canceled":
+		case "failed": return "failed";
+		case "pending": return "queued";
+		case "running":
+		case "sleeping": return "running";
+		default: return "unknown";
+	}
+}
+function serializeOpenWorkflowRun(run, name) {
+	if (!run || run.workflowName !== name) return {
+		id: run?.id || "",
+		provider: "openworkflow",
+		status: "unknown"
+	};
+	return {
+		id: run.id,
+		metadata: run.error || {
+			namespaceId: run.namespaceId,
+			version: run.version,
+			workflowName: run.workflowName
+		},
+		provider: "openworkflow",
+		result: run.output ?? void 0,
+		status: normalizeOpenWorkflowStatus(run.status)
+	};
+}
+async function runOpenWorkflow(config, name, payload, definition, options) {
+	const workflow = await registerOpenWorkflowDefinition(await getOpenWorkflowRuntime(config), name, definition);
+	return await runWorkflowProviderOperation("openworkflow", "run", async () => {
+		const handle = await workflow.run(payload, options.id ? { idempotencyKey: options.id } : void 0);
+		return {
+			id: handle.workflowRun.id,
+			metadata: {
+				...options.id ? { idempotencyKey: options.id } : {},
+				workflow: name
+			},
+			payload,
+			provider: "openworkflow",
+			status: normalizeOpenWorkflowStatus(handle.workflowRun.status)
+		};
+	});
+}
+async function getOpenWorkflowRun(config, name, id) {
+	const runtime = await getOpenWorkflowRuntime(config);
+	return await runWorkflowProviderOperation("openworkflow", "get", async () => {
+		const serialized = serializeOpenWorkflowRun(await runtime.backend.getWorkflowRun({ workflowRunId: id }), name);
+		return serialized.id ? serialized : {
+			id,
+			provider: "openworkflow",
+			status: "unknown"
+		};
+	});
+}
+async function resetOpenWorkflowRuntime() {
+	const closing = runtimes;
+	runtimes = /* @__PURE__ */ new Map();
+	openWorkflowImporter = defaultImporter;
+	const fulfilled = (await Promise.allSettled(closing.values())).flatMap((entry) => entry.status === "fulfilled" ? [entry.value] : []);
+	const failures = (await Promise.allSettled(fulfilled.map((runtime) => Promise.resolve().then(() => runtime.backend.stop())))).flatMap((entry) => entry.status === "rejected" ? [createWorkflowError({
+		cause: entry.reason,
+		code: "OPENWORKFLOW_BACKEND_CLOSE_FAILED",
+		details: { provider: "openworkflow" }
+	})] : []);
+	if (failures.length === 1) throw failures[0];
+	if (failures.length > 1) throw new AggregateError(failures, "OpenWorkflow backend cleanup failed for multiple runtimes.");
+}
+function setOpenWorkflowImporter(importer) {
+	openWorkflowImporter = importer;
+}
+//#endregion
+export { getOpenWorkflowRun, getOpenWorkflowRuntime, registerOpenWorkflowDefinition, resetOpenWorkflowRuntime, runOpenWorkflow, setOpenWorkflowImporter };

package/dist/runtime/state.d.ts

@@ -0,0 +1,35 @@
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-BUlYBZwH.js";
+
+//#region src/runtime/state.d.ts
+interface WorkflowRunState<TResult = unknown> {
+  error?: unknown;
+  expiresAt?: number;
+  promise: Promise<{
+    result?: TResult;
+    status: "completed" | "failed";
+    error?: unknown;
+  }>;
+  result?: TResult;
+  status: "running" | "completed" | "failed";
+}
+declare function setWorkflowRuntimeConfig(config: false | ResolvedWorkflowOptions | undefined): void;
+declare function getWorkflowRuntimeConfig(): false | ResolvedWorkflowOptions | undefined;
+declare function setWorkflowRuntimeRegistry(registry: WorkflowDefinitionRegistry | undefined): void;
+declare function getWorkflowRuntimeRegistry(): WorkflowDefinitionRegistry | undefined;
+declare function getInlineWorkflowDefinitions(): ReadonlyMap<string, WorkflowDefinition>;
+declare function takeInlineWorkflowDefinition(name: string): WorkflowDefinition | undefined;
+declare function takeInlineWorkflowDefinitionForModule(name: string, loaded: unknown): WorkflowDefinition | undefined;
+declare function registerInlineWorkflowDefinition(name: string, definition: WorkflowDefinition): void;
+declare function enterWorkflowRuntimeEvent(event: unknown): void;
+declare function getWorkflowRuntimeEvent(): unknown;
+declare function runWithWorkflowRuntimeEvent<T>(event: unknown, run: () => T | Promise<T>): Promise<T>;
+declare function loadWorkflowDefinition(name: string): Promise<WorkflowDefinition | undefined>;
+declare function setWorkflowRun<TResult = unknown>(name: string, id: string, promise: Promise<{
+  result?: TResult;
+  status: "completed" | "failed";
+  error?: unknown;
+}>): WorkflowRunState<TResult>;
+declare function getWorkflowRunState(name: string, id: string): WorkflowRunState | undefined;
+declare function resetWorkflowRuntime(): void;
+//#endregion
+export { WorkflowRunState, enterWorkflowRuntimeEvent, getInlineWorkflowDefinitions, getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, resetWorkflowRuntime, runWithWorkflowRuntimeEvent, setWorkflowRun, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinition, takeInlineWorkflowDefinitionForModule };

package/dist/runtime/state.js

@@ -0,0 +1,179 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/runtime/state.ts
+const RUNS_LIMIT = 1024;
+const RUNS_TTL_MS = 300 * 1e3;
+let runtimeConfig;
+let runtimeRegistry;
+const inlineRegistry = /* @__PURE__ */ new Map();
+const loadingRegistryEntries = /* @__PURE__ */ new Map();
+const loadedRegistryEntries = /* @__PURE__ */ new Map();
+let fallbackEvent;
+const eventStorage = new AsyncLocalStorage();
+const loadingRegistryStorage = new AsyncLocalStorage();
+const loadingInlineRegistryStorage = new AsyncLocalStorage();
+const runs = /* @__PURE__ */ new Map();
+function getRunKey(name, id) {
+	return `${name}\0${id}`;
+}
+function pruneWorkflowRuns() {
+	const now = Date.now();
+	for (const [key, run] of runs) if (run.expiresAt && run.expiresAt <= now) runs.delete(key);
+}
+function setWorkflowRuntimeConfig(config) {
+	runtimeConfig = config;
+}
+function getWorkflowRuntimeConfig() {
+	return runtimeConfig;
+}
+function setWorkflowRuntimeRegistry(registry) {
+	runtimeRegistry = registry;
+	loadedRegistryEntries.clear();
+}
+function getWorkflowRuntimeRegistry() {
+	return runtimeRegistry;
+}
+function getInlineWorkflowDefinitions() {
+	return inlineRegistry;
+}
+function takeInlineWorkflowDefinition(name) {
+	const definition = inlineRegistry.get(name);
+	inlineRegistry.delete(name);
+	loadingInlineRegistryStorage.getStore()?.delete(name);
+	return definition;
+}
+function isWorkflowHandle(value) {
+	return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.defer === "function" && typeof value.getRun === "function" && typeof value.run === "function";
+}
+function findExportedInlineWorkflowDefinition(name, loaded, definitions) {
+	const namedDefinition = definitions.get(name);
+	if (namedDefinition) return {
+		definition: namedDefinition,
+		name
+	};
+	if (!loaded || typeof loaded !== "object") return void 0;
+	if ("default" in loaded && isWorkflowHandle(loaded.default)) {
+		const definition = definitions.get(loaded.default.name);
+		if (definition) return {
+			definition,
+			name: loaded.default.name
+		};
+	}
+	const matches = /* @__PURE__ */ new Map();
+	for (const value of Object.values(loaded)) {
+		if (!isWorkflowHandle(value)) continue;
+		const definition = definitions.get(value.name);
+		if (definition) matches.set(value.name, definition);
+	}
+	if (matches.size !== 1) return void 0;
+	const [matchedName, definition] = matches.entries().next().value;
+	return {
+		definition,
+		name: matchedName
+	};
+}
+function takeInlineWorkflowDefinitionForModule(name, loaded) {
+	const match = findExportedInlineWorkflowDefinition(name, loaded, inlineRegistry);
+	if (!match) return void 0;
+	inlineRegistry.delete(match.name);
+	return match.definition;
+}
+function consumeInlineWorkflowDefinition(name, expected) {
+	const definition = inlineRegistry.get(name);
+	if (!expected || definition === expected) inlineRegistry.delete(name);
+	return definition;
+}
+function registerInlineWorkflowDefinition(name, definition) {
+	if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
+	const loadingDefinitions = loadingInlineRegistryStorage.getStore();
+	const existing = inlineRegistry.get(name);
+	if (existing && existing !== definition) {
+		if (!loadingDefinitions) throw new Error(`Duplicate workflow name "${name}" from inline definitions.`);
+	}
+	inlineRegistry.set(name, definition);
+	loadingDefinitions?.set(name, definition);
+}
+function enterWorkflowRuntimeEvent(event) {
+	fallbackEvent = event;
+	try {
+		eventStorage.enterWith(event);
+	} catch {}
+}
+function getWorkflowRuntimeEvent() {
+	return eventStorage.getStore() ?? fallbackEvent;
+}
+async function runWithWorkflowRuntimeEvent(event, run) {
+	return await eventStorage.run(event, run);
+}
+async function loadWorkflowDefinition(name) {
+	const inlineDefinition = inlineRegistry.get(name);
+	const entry = runtimeRegistry?.[name];
+	if (entry && loadedRegistryEntries.has(name)) return loadedRegistryEntries.get(name);
+	if (inlineDefinition) {
+		if (entry) throw new Error(`Duplicate workflow name "${name}" from inline and discovered definitions.`);
+		return inlineDefinition;
+	}
+	if (!entry) return;
+	const activeLoads = loadingRegistryStorage.getStore();
+	const inFlightEntry = loadingRegistryEntries.get(name);
+	if (inFlightEntry) return activeLoads?.has(name) ? void 0 : await inFlightEntry;
+	const nextActiveLoads = new Set(activeLoads);
+	nextActiveLoads.add(name);
+	const loadingEntry = Promise.resolve().then(() => loadingRegistryStorage.run(nextActiveLoads, async () => {
+		const loadingInlineDefinitions = /* @__PURE__ */ new Map();
+		const loaded = await loadingInlineRegistryStorage.run(loadingInlineDefinitions, entry);
+		if (!loaded || typeof loaded !== "object") return;
+		const registeredInlineDefinition = loadingInlineDefinitions.get(name) ?? consumeInlineWorkflowDefinition(name);
+		if (registeredInlineDefinition) {
+			consumeInlineWorkflowDefinition(name, registeredInlineDefinition);
+			return registeredInlineDefinition;
+		}
+		const definition = "default" in loaded ? loaded.default : loaded;
+		if (definition && typeof definition.handler === "function") return definition;
+		const exportedInlineDefinition = findExportedInlineWorkflowDefinition(name, loaded, loadingInlineDefinitions);
+		if (!exportedInlineDefinition) return void 0;
+		consumeInlineWorkflowDefinition(exportedInlineDefinition.name, exportedInlineDefinition.definition);
+		return exportedInlineDefinition.definition;
+	}));
+	loadingRegistryEntries.set(name, loadingEntry);
+	try {
+		const loaded = await loadingEntry;
+		loadedRegistryEntries.set(name, loaded);
+		return loaded;
+	} finally {
+		loadingRegistryEntries.delete(name);
+	}
+}
+function setWorkflowRun(name, id, promise) {
+	pruneWorkflowRuns();
+	if (runs.size >= RUNS_LIMIT) {
+		const oldest = runs.keys().next().value;
+		if (oldest !== void 0) runs.delete(oldest);
+	}
+	const state = {
+		promise: promise.then((resolved) => {
+			state.status = resolved.status;
+			state.result = resolved.result;
+			state.error = resolved.error;
+			state.expiresAt = Date.now() + RUNS_TTL_MS;
+			return resolved;
+		}),
+		status: "running"
+	};
+	runs.set(getRunKey(name, id), state);
+	return state;
+}
+function getWorkflowRunState(name, id) {
+	pruneWorkflowRuns();
+	return runs.get(getRunKey(name, id));
+}
+function resetWorkflowRuntime() {
+	runtimeConfig = void 0;
+	runtimeRegistry = void 0;
+	inlineRegistry.clear();
+	loadingRegistryEntries.clear();
+	loadedRegistryEntries.clear();
+	fallbackEvent = void 0;
+	runs.clear();
+}
+//#endregion
+export { enterWorkflowRuntimeEvent, getInlineWorkflowDefinitions, getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, resetWorkflowRuntime, runWithWorkflowRuntimeEvent, setWorkflowRun, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinition, takeInlineWorkflowDefinitionForModule };

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

@@ -0,0 +1,69 @@
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
+import { t as WorkflowApp } from "../_app-DgwN4ulW.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/runtime/vercel.d.ts
+interface VercelRun {
+  cancel: () => Promise<void>;
+  completedAt: Promise<Date | undefined>;
+  createdAt: Promise<Date>;
+  exists: Promise<boolean>;
+  returnValue: Promise<unknown>;
+  runId: string;
+  startedAt: Promise<Date | undefined>;
+  status: Promise<string>;
+  workflowName: Promise<string>;
+}
+interface VercelStep {
+  attempt: number;
+  completedAt?: Date;
+  error?: unknown;
+  startedAt?: Date;
+  status: string;
+  stepId: string;
+  stepName: string;
+}
+interface VercelWorkflowRuntime {
+  getRun: (id: string) => VercelRun;
+  listSteps: (id: string) => Promise<VercelStep[]>;
+  resumeHook: (token: string, payload: unknown) => Promise<{
+    runId: string;
+  }>;
+  start: (handler: (...args: never[]) => unknown, args: unknown[]) => Promise<VercelRun>;
+}
+interface VercelWorkflowApiModule {
+  getRun: (id: string) => VercelRun;
+  resumeHook: VercelWorkflowRuntime["resumeHook"];
+  start: VercelWorkflowRuntime["start"];
+}
+interface VercelWorkflowRuntimeModule {
+  getWorld: () => Promise<{
+    steps: {
+      list: (options: unknown) => Promise<{
+        cursor?: string;
+        data: unknown[];
+        hasMore: boolean;
+      }>;
+    };
+  }> | {
+    steps: {
+      list: (options: unknown) => Promise<{
+        cursor?: string;
+        data: unknown[];
+        hasMore: boolean;
+      }>;
+    };
+  };
+}
+declare function setVercelWorkflowRuntimeModules(api: VercelWorkflowApiModule, runtime: VercelWorkflowRuntimeModule): void;
+//#endregion
+//#region src/runtime/vercel-vite.d.ts
+interface WorkflowVercelServerOptions {
+  app?: WorkflowApp;
+  registry?: WorkflowDefinitionRegistry;
+  workflow?: false | ResolvedWorkflowOptions;
+}
+type WorkflowVercelServer = (req: IncomingMessage, res: ServerResponse) => unknown;
+declare function createWorkflowVercelServer(options?: WorkflowVercelServerOptions): WorkflowVercelServer;
+//#endregion
+export { WorkflowVercelServer, createWorkflowVercelServer, setVercelWorkflowRuntimeModules };

package/dist/runtime/vercel-vite.js

@@ -0,0 +1,49 @@
+import { runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./state.js";
+import { i as setVercelWorkflowRuntimeModules } from "../vercel-D2_J5D_Y.js";
+import { t as resolveAppFetch } from "../app-BZpq2cwC.js";
+import { waitUntil } from "@vercel/functions";
+import { H3 } from "h3";
+//#region ../internal/src/runtime/vercel-hosted.ts
+function createVercelHostedServer(adapter) {
+	const app = new H3();
+	const appHandler = resolveAppFetch(adapter.label, adapter.app);
+	let nodeHandlerPromise;
+	return function hostedVercelServer(req, res) {
+		const handle = async () => {
+			nodeHandlerPromise ||= (async () => {
+				if (appHandler) {
+					const { fromWebHandler } = await import("h3");
+					app.use(fromWebHandler(async (request, context) => await appHandler(request, context)));
+				}
+				const { toNodeHandler } = await import("h3/node");
+				return toNodeHandler(app);
+			})();
+			return (await nodeHandlerPromise)(req, res);
+		};
+		if (adapter.onRequest) return adapter.onRequest({
+			handle,
+			req,
+			res
+		});
+		return handle();
+	};
+}
+//#endregion
+//#region src/runtime/vercel-vite.ts
+function createWorkflowVercelServer(options = {}) {
+	return createVercelHostedServer({
+		app: options.app,
+		label: "workflow",
+		onRequest({ handle, req, res }) {
+			setWorkflowRuntimeConfig(options.workflow);
+			setWorkflowRuntimeRegistry(options.registry);
+			return runWithWorkflowRuntimeEvent({
+				req,
+				res,
+				waitUntil
+			}, handle);
+		}
+	});
+}
+//#endregion
+export { createWorkflowVercelServer, setVercelWorkflowRuntimeModules };