@vite-hub/workflow 0.0.3 → 0.1.0

package/dist/runtime/state.d.ts

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

package/dist/runtime/state.js

@@ -1,23 +1,34 @@
+import { t as workflowErrorDiagnostics } from "../error-diagnostics-pwNFvAHP.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/runtime/state.ts
 const RUNS_LIMIT = 1024;
-const RUNS_TTL_MS = 300 * 1e3;
+const RUNS_TTL_MS = 3e5;
 let runtimeConfig;
 let runtimeRegistry;
 const inlineRegistry = /* @__PURE__ */ new Map();
 const loadingRegistryEntries = /* @__PURE__ */ new Map();
 const loadedRegistryEntries = /* @__PURE__ */ new Map();
+let runtimeRegistryGeneration = 0;
 let fallbackEvent;
 const eventStorage = new AsyncLocalStorage();
 const loadingRegistryStorage = new AsyncLocalStorage();
 const loadingInlineRegistryStorage = new AsyncLocalStorage();
+const loadingGenerationStorage = new AsyncLocalStorage();
 const runs = /* @__PURE__ */ new Map();
+const inFlightRuns = /* @__PURE__ */ new Map();
+const fallbackRunKeys = /* @__PURE__ */ new Set();
+let collectedRuns;
+const completedRuns = /* @__PURE__ */ new Map();
+function isWeakReference(reference) {
+	return reference !== null && "deref" in reference;
+}
 function getRunKey(name, id) {
-	return `${name}\0${id}`;
+	return JSON.stringify([name, id]);
 }
 function pruneWorkflowRuns() {
 	const now = Date.now();
-	for (const [key, run] of runs) if (run.expiresAt && run.expiresAt <= now) runs.delete(key);
+	for (const [key, run] of completedRuns) if (run.expiresAt && run.expiresAt <= now) completedRuns.delete(key);
+	while (completedRuns.size > RUNS_LIMIT) completedRuns.delete(completedRuns.keys().next().value);
 }
 function setWorkflowRuntimeConfig(config) {
 	runtimeConfig = config;
@@ -26,6 +37,8 @@ function getWorkflowRuntimeConfig() {
 	return runtimeConfig;
 }
 function setWorkflowRuntimeRegistry(registry) {
+	if (runtimeRegistry !== registry) loadingRegistryEntries.clear();
+	runtimeRegistryGeneration++;
 	runtimeRegistry = registry;
 	loadedRegistryEntries.clear();
 }
@@ -42,7 +55,12 @@ function takeInlineWorkflowDefinition(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";
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (typeof candidate.name !== "string") return false;
+	if (typeof candidate.defer !== "function") return false;
+	if (typeof candidate.getRun !== "function") return false;
+	return typeof candidate.run === "function";
 }
 function findExportedInlineWorkflowDefinition(name, loaded, definitions) {
 	const namedDefinition = definitions.get(name);
@@ -83,13 +101,14 @@ function consumeInlineWorkflowDefinition(name, expected) {
 	return definition;
 }
 function registerInlineWorkflowDefinition(name, definition) {
-	if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
+	if (!name || typeof name !== "string") throw workflowErrorDiagnostics.WORKFLOW_R0023({ message: "`createWorkflow()` requires a workflow name." });
 	const loadingDefinitions = loadingInlineRegistryStorage.getStore();
+	const loadingGeneration = loadingGenerationStorage.getStore();
 	const existing = inlineRegistry.get(name);
 	if (existing && existing !== definition) {
-		if (!loadingDefinitions) throw new Error(`Duplicate workflow name "${name}" from inline definitions.`);
+		if (!loadingDefinitions) throw workflowErrorDiagnostics.WORKFLOW_R0024({ message: `Duplicate workflow name "${name}" from inline definitions.` });
 	}
-	inlineRegistry.set(name, definition);
+	if (loadingGeneration === void 0 || loadingGeneration === runtimeRegistryGeneration) inlineRegistry.set(name, definition);
 	loadingDefinitions?.set(name, definition);
 }
 function enterWorkflowRuntimeEvent(event) {
@@ -105,11 +124,12 @@ async function runWithWorkflowRuntimeEvent(event, run) {
 	return await eventStorage.run(event, run);
 }
 async function loadWorkflowDefinition(name) {
+	const generation = runtimeRegistryGeneration;
 	const inlineDefinition = inlineRegistry.get(name);
-	const entry = runtimeRegistry?.[name];
+	const entry = runtimeRegistry && Object.hasOwn(runtimeRegistry, name) ? runtimeRegistry[name] : void 0;
 	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.`);
+		if (entry) throw workflowErrorDiagnostics.WORKFLOW_R0025({ message: `Duplicate workflow name "${name}" from inline and discovered definitions.` });
 		return inlineDefinition;
 	}
 	if (!entry) return;
@@ -120,9 +140,15 @@ async function loadWorkflowDefinition(name) {
 	nextActiveLoads.add(name);
 	const loadingEntry = Promise.resolve().then(() => loadingRegistryStorage.run(nextActiveLoads, async () => {
 		const loadingInlineDefinitions = /* @__PURE__ */ new Map();
-		const loaded = await loadingInlineRegistryStorage.run(loadingInlineDefinitions, entry);
+		let loaded;
+		try {
+			loaded = await loadingGenerationStorage.run(generation, () => loadingInlineRegistryStorage.run(loadingInlineDefinitions, entry));
+		} catch (error) {
+			for (const [definitionName, definition] of loadingInlineDefinitions) if (inlineRegistry.get(definitionName) === definition) inlineRegistry.delete(definitionName);
+			throw error;
+		}
 		if (!loaded || typeof loaded !== "object") return;
-		const registeredInlineDefinition = loadingInlineDefinitions.get(name) ?? consumeInlineWorkflowDefinition(name);
+		const registeredInlineDefinition = loadingInlineDefinitions.get(name) ?? (generation === runtimeRegistryGeneration ? consumeInlineWorkflowDefinition(name) : void 0);
 		if (registeredInlineDefinition) {
 			consumeInlineWorkflowDefinition(name, registeredInlineDefinition);
 			return registeredInlineDefinition;
@@ -137,43 +163,87 @@ async function loadWorkflowDefinition(name) {
 	loadingRegistryEntries.set(name, loadingEntry);
 	try {
 		const loaded = await loadingEntry;
-		loadedRegistryEntries.set(name, loaded);
+		if (generation === runtimeRegistryGeneration && loadingRegistryEntries.get(name) === loadingEntry) loadedRegistryEntries.set(name, loaded);
 		return loaded;
 	} finally {
-		loadingRegistryEntries.delete(name);
+		if (loadingRegistryEntries.get(name) === loadingEntry) loadingRegistryEntries.delete(name);
 	}
 }
-function setWorkflowRun(name, id, promise) {
+function setWorkflowRun(name, id, promise, payload, retainInFlight = false) {
 	pruneWorkflowRuns();
-	if (runs.size >= RUNS_LIMIT) {
-		const oldest = runs.keys().next().value;
-		if (oldest !== void 0) runs.delete(oldest);
-	}
+	const key = getRunKey(name, id);
+	const canUseWeakReferences = globalThis.WeakRef !== void 0 && globalThis.FinalizationRegistry !== void 0;
+	if (canUseWeakReferences) collectedRuns ??= new FinalizationRegistry(({ key, reference }) => {
+		if (runs.get(key) === reference) runs.delete(key);
+	});
+	const previous = runs.get(key);
+	if (previous && canUseWeakReferences) collectedRuns?.unregister(previous);
+	fallbackRunKeys.delete(key);
+	completedRuns.delete(key);
 	const state = {
+		payload,
 		promise: promise.then((resolved) => {
 			state.status = resolved.status;
 			state.result = resolved.result;
 			state.error = resolved.error;
 			state.expiresAt = Date.now() + RUNS_TTL_MS;
+			if (inFlightRuns.get(key) === state) inFlightRuns.delete(key);
+			const active = runs.get(key);
+			if ((active && isWeakReference(active) ? active.deref() : active) === state) {
+				runs.delete(key);
+				fallbackRunKeys.delete(key);
+				if (isWeakReference(reference)) collectedRuns?.unregister(reference);
+				completedRuns.set(key, state);
+				pruneWorkflowRuns();
+			}
 			return resolved;
 		}),
 		status: "running"
 	};
-	runs.set(getRunKey(name, id), state);
+	const reference = canUseWeakReferences ? new WeakRef(state) : state;
+	runs.set(key, reference);
+	if (retainInFlight) inFlightRuns.set(key, state);
+	if (isWeakReference(reference)) collectedRuns?.register(state, {
+		key,
+		reference
+	}, reference);
+	else {
+		fallbackRunKeys.add(key);
+		while (fallbackRunKeys.size > RUNS_LIMIT) {
+			const oldest = fallbackRunKeys.values().next().value;
+			fallbackRunKeys.delete(oldest);
+			runs.delete(oldest);
+			inFlightRuns.delete(oldest);
+		}
+	}
 	return state;
 }
 function getWorkflowRunState(name, id) {
 	pruneWorkflowRuns();
-	return runs.get(getRunKey(name, id));
+	const key = getRunKey(name, id);
+	const inFlight = inFlightRuns.get(key);
+	if (inFlight) return inFlight;
+	const reference = runs.get(key);
+	const state = reference && isWeakReference(reference) ? reference.deref() : reference;
+	if (reference && !state) {
+		runs.delete(key);
+		if (isWeakReference(reference)) collectedRuns?.unregister(reference);
+	}
+	return state ?? completedRuns.get(key);
 }
 function resetWorkflowRuntime() {
+	runtimeRegistryGeneration++;
 	runtimeConfig = void 0;
 	runtimeRegistry = void 0;
 	inlineRegistry.clear();
 	loadingRegistryEntries.clear();
 	loadedRegistryEntries.clear();
 	fallbackEvent = void 0;
+	for (const reference of runs.values()) if (isWeakReference(reference)) collectedRuns?.unregister(reference);
 	runs.clear();
+	inFlightRuns.clear();
+	fallbackRunKeys.clear();
+	completedRuns.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

@@ -1,7 +1,6 @@
-import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-BUlYBZwH.js";
-import { t as WorkflowApp } from "../_app-DgwN4ulW.js";
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-D82WmfZa.js";
+import { t as VitehubApp } from "../app-BojnC_yf.js";
 import { IncomingMessage, ServerResponse } from "node:http";
-
 //#region src/runtime/vercel.d.ts
 interface VercelRun {
   cancel: () => Promise<void>;
@@ -40,7 +39,7 @@ interface VercelWorkflowRuntimeModule {
   getWorld: () => Promise<{
     steps: {
       list: (options: unknown) => Promise<{
-        cursor?: string;
+        cursor?: string | null;
         data: unknown[];
         hasMore: boolean;
       }>;
@@ -48,22 +47,22 @@ interface VercelWorkflowRuntimeModule {
   }> | {
     steps: {
       list: (options: unknown) => Promise<{
-        cursor?: string;
+        cursor?: string | null;
         data: unknown[];
         hasMore: boolean;
       }>;
     };
   };
 }
-declare function setVercelWorkflowRuntimeModules(api: VercelWorkflowApiModule, runtime: VercelWorkflowRuntimeModule): void;
+export declare function setVercelWorkflowRuntimeModules(api: VercelWorkflowApiModule, runtime: VercelWorkflowRuntimeModule): void;
 //#endregion
 //#region src/runtime/vercel-vite.d.ts
+export declare function runWithVercelWorkflowRuntimeEvent<T>(req: unknown, res: unknown, run: () => T | Promise<T>): Promise<T>;
 interface WorkflowVercelServerOptions {
-  app?: WorkflowApp;
+  app?: VitehubApp;
   registry?: WorkflowDefinitionRegistry;
   workflow?: false | ResolvedWorkflowOptions;
 }
-type WorkflowVercelServer = (req: IncomingMessage, res: ServerResponse) => unknown;
-declare function createWorkflowVercelServer(options?: WorkflowVercelServerOptions): WorkflowVercelServer;
-//#endregion
-export { WorkflowVercelServer, createWorkflowVercelServer, setVercelWorkflowRuntimeModules };
+export type WorkflowVercelServer = (req: IncomingMessage, res: ServerResponse) => unknown;
+export declare function createWorkflowVercelServer(options?: WorkflowVercelServerOptions): WorkflowVercelServer;
+//#endregion

package/dist/runtime/vercel-vite.js

@@ -1,6 +1,6 @@
 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 { i as setVercelWorkflowRuntimeModules } from "../vercel-D-ZNtB_u.js";
+import { t as resolveAppFetch } from "../app-CzPoP84f.js";
 import { waitUntil } from "@vercel/functions";
 import { H3 } from "h3";
 //#region ../internal/src/runtime/vercel-hosted.ts
@@ -30,6 +30,13 @@ function createVercelHostedServer(adapter) {
 }
 //#endregion
 //#region src/runtime/vercel-vite.ts
+async function runWithVercelWorkflowRuntimeEvent(req, res, run) {
+	return await runWithWorkflowRuntimeEvent({
+		req,
+		res,
+		waitUntil
+	}, run);
+}
 function createWorkflowVercelServer(options = {}) {
 	return createVercelHostedServer({
 		app: options.app,
@@ -37,13 +44,9 @@ function createWorkflowVercelServer(options = {}) {
 		onRequest({ handle, req, res }) {
 			setWorkflowRuntimeConfig(options.workflow);
 			setWorkflowRuntimeRegistry(options.registry);
-			return runWithWorkflowRuntimeEvent({
-				req,
-				res,
-				waitUntil
-			}, handle);
+			return runWithVercelWorkflowRuntimeEvent(req, res, handle);
 		}
 	});
 }
 //#endregion
-export { createWorkflowVercelServer, setVercelWorkflowRuntimeModules };
+export { createWorkflowVercelServer, runWithVercelWorkflowRuntimeEvent, setVercelWorkflowRuntimeModules };

package/dist/runtime-type-DBCvIh5x.js

@@ -0,0 +1,7 @@
+import { hasRuntimeType } from "@vite-hub/runtime/internal/runtime-type";
+//#region src/internal/runtime-type.ts
+function isRuntimeRecord(value) {
+	return value !== null && hasRuntimeType(value, "object") && !Array.isArray(value);
+}
+//#endregion
+export { isRuntimeRecord as n, hasRuntimeType as t };

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

@@ -1,10 +1,10 @@
 //#region src/types.d.ts
 type WorkflowProvider = "cloudflare" | "openworkflow" | "vercel";
 interface CloudflareWorkflowBinding<TPayload = unknown> {
-  create: (options?: {
-    id?: string;
+  createBatch: (batch: Array<{
+    id: string;
     params?: TPayload;
-  }) => Promise<CloudflareWorkflowInstance>;
+  }>) => Promise<CloudflareWorkflowInstance[]>;
   get: (id: string) => Promise<CloudflareWorkflowInstance>;
 }
 interface CloudflareWorkflowInstance {
@@ -46,14 +46,12 @@ 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;
@@ -98,15 +96,20 @@ interface WorkflowStepOptions {
 type WorkflowStepFunction<TInput = unknown, TResult = unknown> = (input: TInput) => TResult | Promise<TResult>;
 interface WorkflowProviderStep {
   do?: <TResult>(name: string, options: WorkflowStepOptions, run: () => TResult | Promise<TResult>) => Promise<TResult>;
+  sleep?: (name: string, duration: string) => Promise<void>;
 }
-type WorkflowStepRunner<TSteps extends Record<string, WorkflowStepFunction> = Record<string, WorkflowStepFunction>> = { [TName in keyof TSteps]: TSteps[TName] };
-interface WorkflowExecutionContext<TPayload = unknown> {
+type WorkflowStepRunner<TSteps extends Record<string, WorkflowStepFunction> = Record<string, WorkflowStepFunction>> = { [TName in keyof TSteps]: TSteps[TName]; };
+/** Run data that a provider gives to ViteHub before ViteHub adds the step runner. */
+interface WorkflowProviderContext<TPayload = unknown> {
   id?: string;
   name: string;
   payload: TPayload;
   provider: WorkflowProvider;
   step?: WorkflowProviderStep;
-  steps?: WorkflowStepRunner;
+}
+interface WorkflowExecutionContext<TPayload = unknown> extends WorkflowProviderContext<TPayload> {
+  /** Step functions from the numbered files in the Workflow folder. Empty when the Workflow has no step files. */
+  steps: WorkflowStepRunner;
 }
 type WorkflowHandler<TPayload = unknown, TResult = unknown> = (context: WorkflowExecutionContext<TPayload>) => TResult | Promise<TResult>;
 type WorkflowRunIdValue = boolean | null | number | string | undefined | {
@@ -119,22 +122,28 @@ interface WorkflowCreateOptions<TPayload = unknown, TResult = unknown> {
     payload?: TPayload;
   }) => Promise<WorkflowRunIdValue> | WorkflowRunIdValue;
   name?: string;
+  rootStep?: boolean;
 }
 interface WorkflowDefinitionOptions<TPayload = unknown, TResult = unknown> {
   id?: string;
-  native?: WorkflowHandler<TPayload, TResult>;
+  /** Vercel native entry. Vercel calls it with the provider context only, so it gets no step runner. */
+  native?: (context: WorkflowProviderContext<TPayload>) => TResult | Promise<TResult>;
   rootStep?: boolean;
 }
 interface WorkflowDefinition<TPayload = unknown, TResult = unknown> {
+  /** @internal Identifies provider-generated Agent invocation recovery definitions. */
+  internalAgentInvocationRecovery?: true;
   handler: WorkflowHandler<TPayload, TResult>;
   options?: WorkflowDefinitionOptions<TPayload, TResult>;
 }
+/** Omission is valid only when the handler accepts undefined. */
+type WorkflowStartArguments<TPayload> = undefined extends TPayload ? [payload?: TPayload, options?: WorkflowStartOptions] : [payload: TPayload, options?: WorkflowStartOptions];
 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>>;
+  cancel: (id: string) => Promise<WorkflowRun<unknown, unknown>>;
+  defer: (...args: WorkflowStartArguments<TPayload>) => Promise<WorkflowRun<TPayload>>;
+  getRun: (id: string) => Promise<WorkflowRun<unknown, unknown>>;
   name: string;
-  run: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload, TResult>>;
+  run: (...args: WorkflowStartArguments<TPayload>) => Promise<WorkflowRun<TPayload, TResult>>;
 }
 interface WorkflowStartOptions {
   id?: string;
@@ -146,18 +155,26 @@ interface WorkflowSignalResult {
   id: string;
   provider: WorkflowProvider;
 }
+/**
+ * Maps Workflow names to module loaders. The registry does not know each
+ * payload type, so it uses `never` as the payload. A definition with any
+ * payload type fits without a cast.
+ */
 interface WorkflowDefinitionRegistry {
-  [name: string]: () => Promise<{
-    default?: WorkflowDefinition;
+  [name: string]: (() => Promise<{
+    default?: WorkflowDefinition<never>;
     [exportName: string]: unknown;
-  } | WorkflowDefinition>;
+  } | WorkflowDefinition<never>>) & {
+    /** @internal Identifies provider-generated Agent invocation recovery definitions without evaluating their modules. */
+    internalAgentInvocationRecovery?: true;
+  };
 }
 interface DiscoveredWorkflowDefinition {
   agentIdentity?: string;
   handler: string;
   name: string;
-  source?: "agent-workflow" | "inline" | "server-workflows" | "vite-suffix";
+  source?: "agent-workflow" | "agent-workflow-recovery" | "inline" | "server-workflows" | "vite-suffix";
   steps?: string[];
 }
 //#endregion
-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 };
+export { WorkflowStartOptions as A, WorkflowProviderOptions as C, WorkflowRunStep as D, WorkflowRunStatus as E, WorkflowStepOptions as M, WorkflowStepRunner as N, WorkflowSharedOptions as O, WorkflowProviderContext as S, WorkflowRun 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, WorkflowStepFunction as j, WorkflowSignalResult 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, WorkflowProviderStep as w, WorkflowProvider as x, WorkflowModuleOptions as y };

package/dist/{vercel-D2_J5D_Y.js → vercel-D-ZNtB_u.js}

@@ -1,4 +1,6 @@
-import { i as createWorkflowError, n as runWorkflowProviderOperation, r as safeWorkflowName, t as isWorkflowBoundaryError } from "./provider-operation-CWIV4k42.js";
+import { t as workflowErrorDiagnostics } from "./error-diagnostics-pwNFvAHP.js";
+import { t as hasRuntimeType } from "./runtime-type-DBCvIh5x.js";
+import { a as createWorkflowError, i as safeWorkflowName, n as isWorkflowBoundaryError, r as runWorkflowProviderOperation } from "./provider-operation-CW2cYfVy.js";
 //#region src/runtime/vercel.ts
 async function loadVercelWorkflowRuntime() {
 	const importVercelWorkflow = new Function("specifier", "return import(specifier)");
@@ -12,9 +14,10 @@ function createVercelWorkflowRuntime(api, runtime) {
 		getRun,
 		async listSteps(id) {
 			const steps = [];
+			const cursors = /* @__PURE__ */ new Set();
 			let cursor;
 			do {
-				const page = await (await getWorld()).steps.list({
+				const page = normalizeStepPage(await (await getWorld()).steps.list({
 					pagination: {
 						cursor,
 						limit: 1e3,
@@ -22,9 +25,12 @@ function createVercelWorkflowRuntime(api, runtime) {
 					},
 					resolveData: "none",
 					runId: id
-				});
+				}));
 				steps.push(...page.data);
-				cursor = page.hasMore && page.cursor ? page.cursor : void 0;
+				if (!page.hasMore) break;
+				if (!hasRuntimeType(page.cursor, "string") || !page.cursor || cursors.has(page.cursor)) throw invalidVercelResult("step pagination cursor");
+				cursors.add(page.cursor);
+				cursor = page.cursor;
 			} while (cursor);
 			return steps;
 		},
@@ -56,35 +62,55 @@ const statusMap = {
 	running: "running"
 };
 function invalidVercelResult(field) {
-	return /* @__PURE__ */ new TypeError(`Vercel Workflow provider returned an invalid ${field}.`);
+	return workflowErrorDiagnostics.WORKFLOW_R0026({ message: `Vercel Workflow provider returned an invalid ${field}.` });
+}
+function normalizeStepPage(page) {
+	if (!hasRuntimeType(page, "object") || page === null || Array.isArray(page)) throw invalidVercelResult("step page");
+	const { cursor, data, hasMore } = page;
+	if (!Array.isArray(data)) throw invalidVercelResult("step page data");
+	if (!hasRuntimeType(hasMore, "boolean")) throw invalidVercelResult("step page hasMore flag");
+	if (cursor !== void 0 && cursor !== null && !hasRuntimeType(cursor, "string")) throw invalidVercelResult("step page cursor");
+	return {
+		...cursor === void 0 || cursor === null ? {} : { cursor },
+		data,
+		hasMore
+	};
 }
 function normalizeStatus(status) {
-	if (typeof status !== "string") throw invalidVercelResult("status");
-	return statusMap[status.toLowerCase()] || "unknown";
+	if (!hasRuntimeType(status, "string")) throw invalidVercelResult("status");
+	const normalized = status.toLowerCase();
+	return Object.hasOwn(statusMap, normalized) ? statusMap[normalized] : "unknown";
 }
 function normalizeRunId(id) {
-	if (typeof id !== "string" || !id) throw invalidVercelResult("run ID");
+	if (!hasRuntimeType(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;
+	let timestamp;
+	try {
+		timestamp = Date.prototype.getTime.call(value);
+	} catch {
+		throw invalidVercelResult(field);
+	}
+	if (!Number.isFinite(timestamp)) throw invalidVercelResult(field);
+	return new Date(timestamp);
 }
 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 {
+	if (hasRuntimeType(error, "string")) try {
 		return normalizeStepError(JSON.parse(error)) || { message: error };
 	} catch {
 		return { message: error };
 	}
-	if (typeof error === "object") {
+	if (hasRuntimeType(error, "object") && error) {
 		const value = error;
-		if (typeof value.message === "string") return {
-			...typeof value.code === "string" ? { code: value.code } : {},
-			message: value.message
-		};
+		if (hasRuntimeType(value.message, "string")) {
+			const normalized = { message: value.message };
+			if (hasRuntimeType(value.code, "string")) normalized.code = value.code;
+			return normalized;
+		}
 		if (value.error !== void 0) return normalizeStepError(value.error);
 	}
 	return { message: "Workflow step failed." };
@@ -92,11 +118,11 @@ function normalizeStepError(error) {
 function normalizeSteps(steps) {
 	if (!Array.isArray(steps)) throw invalidVercelResult("step list");
 	return steps.map((step) => {
-		if (typeof step !== "object" || step === null) throw invalidVercelResult("step");
+		if (!hasRuntimeType(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");
+		if (!hasRuntimeType(value.attempt, "number") || !Number.isFinite(value.attempt)) throw invalidVercelResult("step attempt");
+		if (!hasRuntimeType(value.stepId, "string") || !value.stepId) throw invalidVercelResult("step ID");
+		if (!hasRuntimeType(value.stepName, "string") || !value.stepName) throw invalidVercelResult("step name");
 		return {
 			attempt: value.attempt,
 			completedAt: normalizeDate(value.completedAt, "step completion date"),
@@ -110,10 +136,10 @@ function normalizeSteps(steps) {
 }
 async function readRunIdentity(run) {
 	const exists = await run.exists;
-	if (typeof exists !== "boolean") throw invalidVercelResult("existence state");
+	if (!hasRuntimeType(exists, "boolean")) throw invalidVercelResult("existence state");
 	if (!exists) return { exists };
 	const workflowName = await run.workflowName;
-	if (typeof workflowName !== "string") throw invalidVercelResult("workflow name");
+	if (!hasRuntimeType(workflowName, "string")) throw invalidVercelResult("workflow name");
 	return {
 		exists,
 		workflowName
@@ -167,7 +193,7 @@ async function inspectVercelWorkflowRun(name, definition, id, payload) {
 		steps
 	};
 }
-async function startVercelWorkflow(name, definition, payload) {
+async function startVercelWorkflow(name, definition, payload, observeSettlement, onDispatch) {
 	const native = definition.options?.native;
 	if (!native) throw createWorkflowError({
 		code: "WORKFLOW_NATIVE_ENTRY_REQUIRED",
@@ -182,10 +208,17 @@ async function startVercelWorkflow(name, definition, payload) {
 		provider: "vercel"
 	};
 	const runtime = await getVercelWorkflowRuntime();
+	onDispatch?.();
+	const { id, run } = await runWorkflowProviderOperation("vercel", "start", async () => {
+		const run = await runtime.start(native, [context]);
+		return {
+			id: normalizeRunId(run.runId),
+			run
+		};
+	});
+	observeSettlement?.(Promise.resolve(run.returnValue).then(() => void 0, () => void 0));
 	return {
-		id: await runWorkflowProviderOperation("vercel", "start", async () => {
-			return normalizeRunId((await runtime.start(native, [context])).runId);
-		}),
+		id,
 		metadata: { workflow: name },
 		payload,
 		provider: "vercel",