@vite-hub/workflow 0.0.4 → 0.1.0

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-B9RdRkKh.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,23 +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
-declare function runWithVercelWorkflowRuntimeEvent<T>(req: unknown, res: unknown, run: () => T | Promise<T>): Promise<T>;
+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, runWithVercelWorkflowRuntimeEvent, 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-B0MuIVgJ.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

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-B9RdRkKh.d.ts → types-D82WmfZa.d.ts}

@@ -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;
@@ -100,14 +98,18 @@ 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 | {
@@ -124,7 +126,8 @@ interface WorkflowCreateOptions<TPayload = unknown, TResult = unknown> {
 }
 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> {
@@ -133,12 +136,14 @@ interface WorkflowDefinition<TPayload = unknown, TResult = unknown> {
   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<unknown, unknown>>;
-  defer: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload>>;
+  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;
@@ -150,12 +155,18 @@ 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;
+    default?: WorkflowDefinition<never>;
     [exportName: string]: unknown;
-  } | WorkflowDefinition>) & {
-    /** @internal Identifies provider-generated Agent invocation recovery definitions without evaluating their modules. */internalAgentInvocationRecovery?: true;
+  } | WorkflowDefinition<never>>) & {
+    /** @internal Identifies provider-generated Agent invocation recovery definitions without evaluating their modules. */
+    internalAgentInvocationRecovery?: true;
   };
 }
 interface DiscoveredWorkflowDefinition {
@@ -166,4 +177,4 @@ interface DiscoveredWorkflowDefinition {
   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-B0MuIVgJ.js → vercel-D-ZNtB_u.js}

@@ -1,4 +1,5 @@
-import { t as hasRuntimeType } from "./runtime-type-DGUn8Ple.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() {
@@ -13,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,
@@ -23,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;
 		},
@@ -57,11 +62,24 @@ 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 (!hasRuntimeType(status, "string")) throw invalidVercelResult("status");
-	return statusMap[status.toLowerCase()] || "unknown";
+	const normalized = status.toLowerCase();
+	return Object.hasOwn(statusMap, normalized) ? statusMap[normalized] : "unknown";
 }
 function normalizeRunId(id) {
 	if (!hasRuntimeType(id, "string") || !id) throw invalidVercelResult("run ID");
@@ -69,8 +87,14 @@ function normalizeRunId(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;
@@ -169,7 +193,7 @@ async function inspectVercelWorkflowRun(name, definition, id, payload) {
 		steps
 	};
 }
-async function startVercelWorkflow(name, definition, payload, observeSettlement) {
+async function startVercelWorkflow(name, definition, payload, observeSettlement, onDispatch) {
 	const native = definition.options?.native;
 	if (!native) throw createWorkflowError({
 		code: "WORKFLOW_NATIVE_ENTRY_REQUIRED",
@@ -184,6 +208,7 @@ async function startVercelWorkflow(name, definition, payload, observeSettlement)
 		provider: "vercel"
 	};
 	const runtime = await getVercelWorkflowRuntime();
+	onDispatch?.();
 	const { id, run } = await runWorkflowProviderOperation("vercel", "start", async () => {
 		const run = await runtime.start(native, [context]);
 		return {