@vite-hub/workflow 0.0.1 → 0.0.2

package/dist/runtime/openworkflow.js

@@ -1,49 +1,111 @@
+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 runtimes = /* @__PURE__ */ new Map();
+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 = postgres.url || readEnv("OPENWORKFLOW_POSTGRES_URL") || readEnv("DATABASE_URL");
-	if (!url) throw new Error("Missing OpenWorkflow Postgres URL. Set workflow.postgres.url, OPENWORKFLOW_POSTGRES_URL, or DATABASE_URL.");
-	return {
+	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) {
+async function createOpenWorkflowRuntime(config, importer) {
 	const options = getOpenWorkflowConfig(config);
-	const [{ OpenWorkflow }, { BackendPostgres }] = await Promise.all([openWorkflowImporter("openworkflow"), openWorkflowImporter("openworkflow/postgres")]);
-	const backend = await BackendPostgres.connect(options.url, {
-		namespaceId: options.namespaceId,
-		...typeof options.runMigrations === "boolean" ? { runMigrations: options.runMigrations } : {},
-		schema: options.schema
+	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: new OpenWorkflow({ backend }),
+		client,
 		workflows: /* @__PURE__ */ new Map()
 	};
 }
 async function getOpenWorkflowRuntime(config) {
+	const cache = runtimes;
 	const key = getRuntimeKey(config);
-	let runtime = runtimes.get(key);
+	let runtime = cache.get(key);
 	if (!runtime) {
-		runtime = createOpenWorkflowRuntime(config);
-		runtimes.set(key, runtime);
+		runtime = createOpenWorkflowRuntime(config, openWorkflowImporter);
+		cache.set(key, runtime);
+		runtime.catch(() => {
+			if (cache.get(key) === runtime) cache.delete(key);
+		});
 	}
-	return await runtime;
+	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;
@@ -108,33 +170,44 @@ function serializeOpenWorkflowRun(run, name) {
 	};
 }
 async function runOpenWorkflow(config, name, payload, definition, options) {
-	const handle = await (await registerOpenWorkflowDefinition(await getOpenWorkflowRuntime(config), name, definition)).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)
-	};
+	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 serialized = serializeOpenWorkflowRun(await (await getOpenWorkflowRuntime(config)).backend.getWorkflowRun({ workflowRunId: id }), name);
-	return serialized.id ? serialized : {
-		id,
-		provider: "openworkflow",
-		status: "unknown"
-	};
+	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 settled = await Promise.allSettled(runtimes.values());
-	runtimes.clear();
+	const closing = runtimes;
+	runtimes = /* @__PURE__ */ new Map();
 	openWorkflowImporter = defaultImporter;
-	await Promise.all(settled.map(async (entry) => {
-		if (entry.status === "fulfilled") await entry.value.backend.stop();
-	}));
+	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;

package/dist/runtime/state.d.ts

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

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

@@ -1,7 +1,62 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
-import { t as WorkflowApp } from "../_app-BVWpnNHo.js";
+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;
@@ -11,4 +66,4 @@ interface WorkflowVercelServerOptions {
 type WorkflowVercelServer = (req: IncomingMessage, res: ServerResponse) => unknown;
 declare function createWorkflowVercelServer(options?: WorkflowVercelServerOptions): WorkflowVercelServer;
 //#endregion
-export { WorkflowVercelServer, createWorkflowVercelServer };
+export { WorkflowVercelServer, createWorkflowVercelServer, setVercelWorkflowRuntimeModules };

package/dist/runtime/vercel-vite.js

@@ -1,5 +1,6 @@
 import { runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./state.js";
-import { t as resolveAppFetch } from "../app-BE3EYOWn.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
@@ -45,4 +46,4 @@ function createWorkflowVercelServer(options = {}) {
 	});
 }
 //#endregion
-export { createWorkflowVercelServer };
+export { createWorkflowVercelServer, setVercelWorkflowRuntimeModules };

package/dist/{types-ThDitg7Z.d.ts → types-BUlYBZwH.d.ts}

@@ -25,19 +25,38 @@ interface OpenWorkflowPostgresOptions {
   namespaceId?: string;
   runMigrations?: boolean;
   schema?: string;
-  url?: string;
+  url?: WorkflowRuntimeConfigValue;
+}
+interface WorkflowRuntimeEnvDeclarationLike {
+  default?: unknown;
+  kind: "env-variable";
+  source?: {
+    kind: "env";
+    name: string;
+    names?: string[];
+  };
+}
+type WorkflowRuntimeConfigValue = string | WorkflowRuntimeEnvDeclarationLike;
+interface OpenWorkflowSqliteOptions {
+  namespaceId?: string;
+  path?: WorkflowRuntimeConfigValue;
+  runMigrations?: boolean;
 }
 interface OpenWorkflowWorkerOptions {
   concurrency?: number;
 }
 interface OpenWorkflowProviderOptions extends WorkflowSharedOptions {
+  database?: string;
   postgres?: OpenWorkflowPostgresOptions;
   provider: "openworkflow";
+  sqlite?: OpenWorkflowSqliteOptions;
   worker?: OpenWorkflowWorkerOptions;
 }
 interface InferredWorkflowProviderOptions extends WorkflowSharedOptions {
+  database?: string;
   postgres?: OpenWorkflowPostgresOptions;
   provider?: undefined;
+  sqlite?: OpenWorkflowSqliteOptions;
   worker?: OpenWorkflowWorkerOptions;
 }
 type WorkflowProviderOptions = CloudflareWorkflowProviderOptions | OpenWorkflowProviderOptions | VercelWorkflowProviderOptions;
@@ -45,14 +64,30 @@ type WorkflowModuleProviderOptions = InferredWorkflowProviderOptions | WorkflowP
 type WorkflowModuleOptions = false | WorkflowModuleProviderOptions;
 type ResolvedWorkflowOptions = WorkflowProviderOptions;
 interface WorkflowRun<TPayload = unknown, TResult = unknown> {
+  completedAt?: Date;
+  createdAt?: Date;
   id: string;
   provider: WorkflowProvider;
   result?: TResult;
+  startedAt?: Date;
   status: WorkflowRunStatus;
+  steps?: WorkflowRunStep[];
   metadata?: unknown;
   payload?: TPayload;
 }
-type WorkflowRunStatus = "queued" | "running" | "completed" | "failed" | "unknown";
+type WorkflowRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "unknown";
+interface WorkflowRunStep {
+  attempt: number;
+  completedAt?: Date;
+  error?: {
+    code?: string;
+    message: string;
+  };
+  id: string;
+  name: string;
+  startedAt?: Date;
+  status: WorkflowRunStatus;
+}
 interface WorkflowStepOptions {
   retries?: {
     backoff?: string;
@@ -85,15 +120,17 @@ interface WorkflowCreateOptions<TPayload = unknown, TResult = unknown> {
   }) => Promise<WorkflowRunIdValue> | WorkflowRunIdValue;
   name?: string;
 }
-interface WorkflowDefinitionOptions {
+interface WorkflowDefinitionOptions<TPayload = unknown, TResult = unknown> {
   id?: string;
+  native?: WorkflowHandler<TPayload, TResult>;
   rootStep?: boolean;
 }
 interface WorkflowDefinition<TPayload = unknown, TResult = unknown> {
   handler: WorkflowHandler<TPayload, TResult>;
-  options?: WorkflowDefinitionOptions;
+  options?: WorkflowDefinitionOptions<TPayload, TResult>;
 }
 interface WorkflowHandle<TPayload = unknown, TResult = unknown> {
+  cancel: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
   defer: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload>>;
   getRun: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
   name: string;
@@ -105,6 +142,10 @@ interface WorkflowStartOptions {
 interface WorkflowDeferOptions extends WorkflowStartOptions {
   deferred?: boolean;
 }
+interface WorkflowSignalResult {
+  id: string;
+  provider: WorkflowProvider;
+}
 interface WorkflowDefinitionRegistry {
   [name: string]: () => Promise<{
     default?: WorkflowDefinition;
@@ -112,10 +153,11 @@ interface WorkflowDefinitionRegistry {
   } | WorkflowDefinition>;
 }
 interface DiscoveredWorkflowDefinition {
+  agentIdentity?: string;
   handler: string;
   name: string;
-  source?: "inline" | "nitro-server-workflows" | "vite-suffix";
+  source?: "agent-workflow" | "inline" | "server-workflows" | "vite-suffix";
   steps?: string[];
 }
 //#endregion
-export { WorkflowStepRunner as A, WorkflowProviderStep as C, WorkflowStartOptions as D, WorkflowSharedOptions as E, WorkflowStepFunction as O, WorkflowProviderOptions as S, WorkflowRunStatus as T, WorkflowHandle as _, InferredWorkflowProviderOptions as a, WorkflowModuleProviderOptions as b, OpenWorkflowWorkerOptions as c, WorkflowCreateOptions as d, WorkflowDeferOptions as f, WorkflowExecutionContext as g, WorkflowDefinitionRegistry as h, DiscoveredWorkflowDefinition as i, WorkflowStepOptions as k, ResolvedWorkflowOptions as l, WorkflowDefinitionOptions as m, CloudflareWorkflowInstance as n, OpenWorkflowPostgresOptions as o, WorkflowDefinition as p, CloudflareWorkflowProviderOptions as r, OpenWorkflowProviderOptions as s, CloudflareWorkflowBinding as t, VercelWorkflowProviderOptions as u, WorkflowHandler as v, WorkflowRun as w, WorkflowProvider as x, WorkflowModuleOptions as y };
+export { WorkflowStepFunction as A, WorkflowProviderStep as C, WorkflowSharedOptions as D, WorkflowRunStep as E, WorkflowStepRunner as M, WorkflowSignalResult as O, WorkflowProviderOptions as S, WorkflowRunStatus as T, WorkflowHandle as _, InferredWorkflowProviderOptions as a, WorkflowModuleProviderOptions as b, OpenWorkflowWorkerOptions as c, WorkflowCreateOptions as d, WorkflowDeferOptions as f, WorkflowExecutionContext as g, WorkflowDefinitionRegistry as h, DiscoveredWorkflowDefinition as i, WorkflowStepOptions as j, WorkflowStartOptions as k, ResolvedWorkflowOptions as l, WorkflowDefinitionOptions as m, CloudflareWorkflowInstance as n, OpenWorkflowPostgresOptions as o, WorkflowDefinition as p, CloudflareWorkflowProviderOptions as r, OpenWorkflowProviderOptions as s, CloudflareWorkflowBinding as t, VercelWorkflowProviderOptions as u, WorkflowHandler as v, WorkflowRun as w, WorkflowProvider as x, WorkflowModuleOptions as y };

package/dist/vercel-D2_J5D_Y.js

@@ -0,0 +1,217 @@
+import { i as createWorkflowError, n as runWorkflowProviderOperation, r as safeWorkflowName, t as isWorkflowBoundaryError } from "./provider-operation-CWIV4k42.js";
+//#region src/runtime/vercel.ts
+async function loadVercelWorkflowRuntime() {
+	const importVercelWorkflow = new Function("specifier", "return import(specifier)");
+	const [api, runtime] = await Promise.all([importVercelWorkflow("workflow/api"), importVercelWorkflow("workflow/runtime")]);
+	return createVercelWorkflowRuntime(api, runtime);
+}
+function createVercelWorkflowRuntime(api, runtime) {
+	const { getRun, resumeHook, start } = api;
+	const { getWorld } = runtime;
+	return {
+		getRun,
+		async listSteps(id) {
+			const steps = [];
+			let cursor;
+			do {
+				const page = await (await getWorld()).steps.list({
+					pagination: {
+						cursor,
+						limit: 1e3,
+						sortOrder: "asc"
+					},
+					resolveData: "none",
+					runId: id
+				});
+				steps.push(...page.data);
+				cursor = page.hasMore && page.cursor ? page.cursor : void 0;
+			} while (cursor);
+			return steps;
+		},
+		resumeHook,
+		start
+	};
+}
+let runtimeLoader = loadVercelWorkflowRuntime;
+function setVercelWorkflowRuntimeModules(api, runtime) {
+	runtimeLoader = async () => createVercelWorkflowRuntime(api, runtime);
+}
+async function getVercelWorkflowRuntime() {
+	try {
+		return await runtimeLoader();
+	} catch (error) {
+		if (isWorkflowBoundaryError(error)) throw error;
+		throw createWorkflowError({
+			cause: error,
+			code: "VERCEL_WORKFLOW_SDK_LOAD_FAILED",
+			details: { provider: "vercel" }
+		});
+	}
+}
+const statusMap = {
+	cancelled: "cancelled",
+	completed: "completed",
+	failed: "failed",
+	pending: "queued",
+	running: "running"
+};
+function invalidVercelResult(field) {
+	return /* @__PURE__ */ new TypeError(`Vercel Workflow provider returned an invalid ${field}.`);
+}
+function normalizeStatus(status) {
+	if (typeof status !== "string") throw invalidVercelResult("status");
+	return statusMap[status.toLowerCase()] || "unknown";
+}
+function normalizeRunId(id) {
+	if (typeof id !== "string" || !id) throw invalidVercelResult("run ID");
+	return id;
+}
+function normalizeDate(value, field) {
+	if (value === void 0) return void 0;
+	if (!(value instanceof Date) || !Number.isFinite(value.getTime())) throw invalidVercelResult(field);
+	return value;
+}
+function normalizeStepError(error) {
+	if (error === void 0 || error === null) return void 0;
+	if (error instanceof Error) return { message: error.message };
+	if (typeof error === "string") try {
+		return normalizeStepError(JSON.parse(error)) || { message: error };
+	} catch {
+		return { message: error };
+	}
+	if (typeof error === "object") {
+		const value = error;
+		if (typeof value.message === "string") return {
+			...typeof value.code === "string" ? { code: value.code } : {},
+			message: value.message
+		};
+		if (value.error !== void 0) return normalizeStepError(value.error);
+	}
+	return { message: "Workflow step failed." };
+}
+function normalizeSteps(steps) {
+	if (!Array.isArray(steps)) throw invalidVercelResult("step list");
+	return steps.map((step) => {
+		if (typeof step !== "object" || step === null) throw invalidVercelResult("step");
+		const value = step;
+		if (typeof value.attempt !== "number" || !Number.isFinite(value.attempt)) throw invalidVercelResult("step attempt");
+		if (typeof value.stepId !== "string" || !value.stepId) throw invalidVercelResult("step ID");
+		if (typeof value.stepName !== "string" || !value.stepName) throw invalidVercelResult("step name");
+		return {
+			attempt: value.attempt,
+			completedAt: normalizeDate(value.completedAt, "step completion date"),
+			error: normalizeStepError(value.error),
+			id: value.stepId,
+			name: value.stepName,
+			startedAt: normalizeDate(value.startedAt, "step start date"),
+			status: normalizeStatus(value.status)
+		};
+	});
+}
+async function readRunIdentity(run) {
+	const exists = await run.exists;
+	if (typeof exists !== "boolean") throw invalidVercelResult("existence state");
+	if (!exists) return { exists };
+	const workflowName = await run.workflowName;
+	if (typeof workflowName !== "string") throw invalidVercelResult("workflow name");
+	return {
+		exists,
+		workflowName
+	};
+}
+function getNativeWorkflowName(name, definition) {
+	const workflowName = (definition.options?.native)?.workflowId;
+	if (!workflowName) throw createWorkflowError({
+		code: "WORKFLOW_NATIVE_ENTRY_INVALID",
+		details: {
+			...safeWorkflowName(name) ? { name } : {},
+			provider: "vercel"
+		}
+	});
+	return workflowName;
+}
+async function inspectVercelWorkflowRun(name, definition, id, payload) {
+	const runtime = await getVercelWorkflowRuntime();
+	const run = await runWorkflowProviderOperation("vercel", "get-run", () => runtime.getRun(id));
+	const identity = await runWorkflowProviderOperation("vercel", "get-run", () => readRunIdentity(run));
+	if (!identity.exists || identity.workflowName !== getNativeWorkflowName(name, definition)) return {
+		id,
+		provider: "vercel",
+		status: "unknown"
+	};
+	const [snapshot, steps] = await Promise.all([runWorkflowProviderOperation("vercel", "get-run", async () => {
+		const [status, createdAt, startedAt, completedAt] = await Promise.all([
+			run.status,
+			run.createdAt,
+			run.startedAt,
+			run.completedAt
+		]);
+		return {
+			completedAt: normalizeDate(completedAt, "completion date"),
+			createdAt: normalizeDate(createdAt, "creation date"),
+			startedAt: normalizeDate(startedAt, "start date"),
+			status: normalizeStatus(status)
+		};
+	}), runWorkflowProviderOperation("vercel", "list-steps", async () => normalizeSteps(await runtime.listSteps(id)))]);
+	const result = snapshot.status === "completed" ? await runWorkflowProviderOperation("vercel", "get-run", () => run.returnValue) : void 0;
+	return {
+		completedAt: snapshot.completedAt,
+		createdAt: snapshot.createdAt,
+		id,
+		metadata: { workflow: name },
+		payload,
+		provider: "vercel",
+		result,
+		startedAt: snapshot.startedAt,
+		status: snapshot.status,
+		steps
+	};
+}
+async function startVercelWorkflow(name, definition, payload) {
+	const native = definition.options?.native;
+	if (!native) throw createWorkflowError({
+		code: "WORKFLOW_NATIVE_ENTRY_REQUIRED",
+		details: {
+			...safeWorkflowName(name) ? { name } : {},
+			provider: "vercel"
+		}
+	});
+	const context = {
+		name,
+		payload,
+		provider: "vercel"
+	};
+	const runtime = await getVercelWorkflowRuntime();
+	return {
+		id: await runWorkflowProviderOperation("vercel", "start", async () => {
+			return normalizeRunId((await runtime.start(native, [context])).runId);
+		}),
+		metadata: { workflow: name },
+		payload,
+		provider: "vercel",
+		status: "queued"
+	};
+}
+async function cancelVercelWorkflow(name, definition, id) {
+	const runtime = await getVercelWorkflowRuntime();
+	const run = await runWorkflowProviderOperation("vercel", "get-run", () => runtime.getRun(id));
+	const identity = await runWorkflowProviderOperation("vercel", "get-run", () => readRunIdentity(run));
+	if (!identity.exists || identity.workflowName !== getNativeWorkflowName(name, definition)) return {
+		id,
+		provider: "vercel",
+		status: "unknown"
+	};
+	await runWorkflowProviderOperation("vercel", "cancel", () => run.cancel());
+	return await inspectVercelWorkflowRun(name, definition, id);
+}
+async function resumeVercelWorkflowSignal(token, payload) {
+	const runtime = await getVercelWorkflowRuntime();
+	return {
+		id: await runWorkflowProviderOperation("vercel", "resume-signal", async () => {
+			return normalizeRunId((await runtime.resumeHook(token, payload)).runId);
+		}),
+		provider: "vercel"
+	};
+}
+//#endregion
+export { startVercelWorkflow as a, setVercelWorkflowRuntimeModules as i, inspectVercelWorkflowRun as n, resumeVercelWorkflowSignal as r, cancelVercelWorkflow as t };

package/dist/vite.d.ts

@@ -1,11 +1,8 @@
-import { y as WorkflowModuleOptions } from "./types-ThDitg7Z.js";
-import { NitroModule } from "nitro/types";
+import { y as WorkflowModuleOptions } from "./types-BUlYBZwH.js";
 import { Plugin } from "vite";
 
 //#region src/vite.d.ts
-type WorkflowVitePlugin = Plugin & {
-  nitro: NitroModule;
-};
+type WorkflowVitePlugin = Plugin;
 declare function hubWorkflow(options?: WorkflowModuleOptions): WorkflowVitePlugin;
 declare module "vite" {
   interface UserConfig {