@vite-hub/workflow 0.0.2 → 0.0.4

package/dist/{types-BUlYBZwH.d.ts → types-B9RdRkKh.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 {
@@ -98,6 +98,7 @@ 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> {
@@ -119,6 +120,7 @@ interface WorkflowCreateOptions<TPayload = unknown, TResult = unknown> {
     payload?: TPayload;
   }) => Promise<WorkflowRunIdValue> | WorkflowRunIdValue;
   name?: string;
+  rootStep?: boolean;
 }
 interface WorkflowDefinitionOptions<TPayload = unknown, TResult = unknown> {
   id?: string;
@@ -126,13 +128,15 @@ interface WorkflowDefinitionOptions<TPayload = unknown, TResult = unknown> {
   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>;
 }
 interface WorkflowHandle<TPayload = unknown, TResult = unknown> {
-  cancel: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
+  cancel: (id: string) => Promise<WorkflowRun<unknown, unknown>>;
   defer: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload>>;
-  getRun: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
+  getRun: (id: string) => Promise<WorkflowRun<unknown, unknown>>;
   name: string;
   run: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload, TResult>>;
 }
@@ -147,16 +151,18 @@ interface WorkflowSignalResult {
   provider: WorkflowProvider;
 }
 interface WorkflowDefinitionRegistry {
-  [name: string]: () => Promise<{
+  [name: string]: (() => Promise<{
     default?: WorkflowDefinition;
     [exportName: string]: unknown;
-  } | WorkflowDefinition>;
+  } | WorkflowDefinition>) & {
+    /** @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

package/dist/{vercel-D2_J5D_Y.js → vercel-B0MuIVgJ.js}

@@ -1,4 +1,5 @@
-import { i as createWorkflowError, n as runWorkflowProviderOperation, r as safeWorkflowName, t as isWorkflowBoundaryError } from "./provider-operation-CWIV4k42.js";
+import { t as hasRuntimeType } from "./runtime-type-DGUn8Ple.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)");
@@ -59,11 +60,11 @@ function invalidVercelResult(field) {
 	return /* @__PURE__ */ new TypeError(`Vercel Workflow provider returned an invalid ${field}.`);
 }
 function normalizeStatus(status) {
-	if (typeof status !== "string") throw invalidVercelResult("status");
+	if (!hasRuntimeType(status, "string")) throw invalidVercelResult("status");
 	return statusMap[status.toLowerCase()] || "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) {
@@ -74,17 +75,18 @@ function normalizeDate(value, field) {
 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 +94,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 +112,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 +169,7 @@ async function inspectVercelWorkflowRun(name, definition, id, payload) {
 		steps
 	};
 }
-async function startVercelWorkflow(name, definition, payload) {
+async function startVercelWorkflow(name, definition, payload, observeSettlement) {
 	const native = definition.options?.native;
 	if (!native) throw createWorkflowError({
 		code: "WORKFLOW_NATIVE_ENTRY_REQUIRED",
@@ -182,10 +184,16 @@ async function startVercelWorkflow(name, definition, payload) {
 		provider: "vercel"
 	};
 	const runtime = await getVercelWorkflowRuntime();
+	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",

package/dist/vite.d.ts

@@ -1,13 +1,58 @@
-import { y as WorkflowModuleOptions } from "./types-BUlYBZwH.js";
-import { Plugin } from "vite";
+import { i as DiscoveredWorkflowDefinition, y as WorkflowModuleOptions } from "./types-B9RdRkKh.js";
+import { Plugin } from "esbuild";
+import { Plugin as Plugin$1 } from "vite";
 
+//#region src/discovery.d.ts
+declare function discoverWorkflowDefinitions(options: {
+  mode?: "vite-suffix";
+  rootDir: string;
+  scanDirs?: string[];
+  serverDirs?: string[];
+} | {
+  mode: "server-workflows";
+  scanDirs: string[];
+}): DiscoveredWorkflowDefinition[];
+//#endregion
 //#region src/vite.d.ts
-type WorkflowVitePlugin = Plugin;
-declare function hubWorkflow(options?: WorkflowModuleOptions): WorkflowVitePlugin;
+interface WorkflowNitroConfigOptions {
+  nitro: Record<string, unknown>;
+  projectRoot: string;
+  serverDirs?: string[];
+  transformRegistry?: (code: string, id: string) => string | Promise<string>;
+}
+type WorkflowVitePlugin = Plugin$1 & {
+  vitehub?: {
+    workflow?: {
+      createNitroConfig?: (options: WorkflowNitroConfigOptions) => Promise<Record<string, unknown>>;
+      prepareScheduleRuntime?: (artifactDir?: string) => Promise<{
+        bundleAlias: Record<string, string>;
+        bundlePlugins?: Plugin[];
+        importBase: string;
+        native: boolean;
+        registryFile: string;
+      } | undefined>;
+    };
+  };
+};
+interface InternalWorkflowModuleOptions {
+  agentImportBase?: string;
+  hosting?: string;
+  implicitlyEnabled?: boolean;
+  importBase?: string;
+  providerImportAliases?: Record<string, string>;
+  includeUserAppEntry?: boolean;
+  workspaceDependencyRuntimeImports?: {
+    sandbox?: string;
+    sandboxRuntimeState?: string;
+    shellWorkspace?: string;
+  };
+  workspaceImportBase?: string;
+}
+declare function hubWorkflow(options?: WorkflowModuleOptions, internalOptions?: InternalWorkflowModuleOptions): WorkflowVitePlugin;
 declare module "vite" {
   interface UserConfig {
     workflow?: WorkflowModuleOptions;
   }
 }
 //#endregion
-export { WorkflowVitePlugin, hubWorkflow };
+export { WorkflowVitePlugin, discoverWorkflowDefinitions, hubWorkflow };