@vite-hub/workflow 0.0.0 → 0.0.1

package/dist/runtime/vercel-vite.js

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

package/dist/types-ThDitg7Z.d.ts

@@ -0,0 +1,121 @@
+//#region src/types.d.ts
+type WorkflowProvider = "cloudflare" | "openworkflow" | "vercel";
+interface CloudflareWorkflowBinding<TPayload = unknown> {
+  create: (options?: {
+    id?: string;
+    params?: TPayload;
+  }) => Promise<CloudflareWorkflowInstance>;
+  get: (id: string) => Promise<CloudflareWorkflowInstance>;
+}
+interface CloudflareWorkflowInstance {
+  id: string;
+  status: () => Promise<unknown>;
+}
+interface WorkflowSharedOptions {
+  binding?: string;
+  name?: string;
+}
+interface CloudflareWorkflowProviderOptions extends WorkflowSharedOptions {
+  provider: "cloudflare";
+}
+interface VercelWorkflowProviderOptions extends WorkflowSharedOptions {
+  provider: "vercel";
+}
+interface OpenWorkflowPostgresOptions {
+  namespaceId?: string;
+  runMigrations?: boolean;
+  schema?: string;
+  url?: string;
+}
+interface OpenWorkflowWorkerOptions {
+  concurrency?: number;
+}
+interface OpenWorkflowProviderOptions extends WorkflowSharedOptions {
+  postgres?: OpenWorkflowPostgresOptions;
+  provider: "openworkflow";
+  worker?: OpenWorkflowWorkerOptions;
+}
+interface InferredWorkflowProviderOptions extends WorkflowSharedOptions {
+  postgres?: OpenWorkflowPostgresOptions;
+  provider?: undefined;
+  worker?: OpenWorkflowWorkerOptions;
+}
+type WorkflowProviderOptions = CloudflareWorkflowProviderOptions | OpenWorkflowProviderOptions | VercelWorkflowProviderOptions;
+type WorkflowModuleProviderOptions = InferredWorkflowProviderOptions | WorkflowProviderOptions;
+type WorkflowModuleOptions = false | WorkflowModuleProviderOptions;
+type ResolvedWorkflowOptions = WorkflowProviderOptions;
+interface WorkflowRun<TPayload = unknown, TResult = unknown> {
+  id: string;
+  provider: WorkflowProvider;
+  result?: TResult;
+  status: WorkflowRunStatus;
+  metadata?: unknown;
+  payload?: TPayload;
+}
+type WorkflowRunStatus = "queued" | "running" | "completed" | "failed" | "unknown";
+interface WorkflowStepOptions {
+  retries?: {
+    backoff?: string;
+    delay?: string;
+    limit?: number;
+  };
+}
+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>;
+}
+type WorkflowStepRunner<TSteps extends Record<string, WorkflowStepFunction> = Record<string, WorkflowStepFunction>> = { [TName in keyof TSteps]: TSteps[TName] };
+interface WorkflowExecutionContext<TPayload = unknown> {
+  id?: string;
+  name: string;
+  payload: TPayload;
+  provider: WorkflowProvider;
+  step?: WorkflowProviderStep;
+  steps?: WorkflowStepRunner;
+}
+type WorkflowHandler<TPayload = unknown, TResult = unknown> = (context: WorkflowExecutionContext<TPayload>) => TResult | Promise<TResult>;
+type WorkflowRunIdValue = boolean | null | number | string | undefined | {
+  readonly [key: string]: WorkflowRunIdValue;
+} | readonly WorkflowRunIdValue[];
+interface WorkflowCreateOptions<TPayload = unknown, TResult = unknown> {
+  handler?: WorkflowHandler<TPayload, TResult>;
+  id?: (context: {
+    name: string;
+    payload?: TPayload;
+  }) => Promise<WorkflowRunIdValue> | WorkflowRunIdValue;
+  name?: string;
+}
+interface WorkflowDefinitionOptions {
+  id?: string;
+  rootStep?: boolean;
+}
+interface WorkflowDefinition<TPayload = unknown, TResult = unknown> {
+  handler: WorkflowHandler<TPayload, TResult>;
+  options?: WorkflowDefinitionOptions;
+}
+interface WorkflowHandle<TPayload = unknown, TResult = unknown> {
+  defer: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload>>;
+  getRun: (id: string) => Promise<WorkflowRun<TPayload, TResult>>;
+  name: string;
+  run: (payload?: TPayload, options?: WorkflowStartOptions) => Promise<WorkflowRun<TPayload, TResult>>;
+}
+interface WorkflowStartOptions {
+  id?: string;
+}
+interface WorkflowDeferOptions extends WorkflowStartOptions {
+  deferred?: boolean;
+}
+interface WorkflowDefinitionRegistry {
+  [name: string]: () => Promise<{
+    default?: WorkflowDefinition;
+    [exportName: string]: unknown;
+  } | WorkflowDefinition>;
+}
+interface DiscoveredWorkflowDefinition {
+  handler: string;
+  name: string;
+  source?: "inline" | "nitro-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 };

package/dist/vite.d.ts

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

package/dist/vite.js

@@ -0,0 +1,503 @@
+import { t as normalizeWorkflowOptions } from "./config-DkgsQuXz.js";
+import { r as getCloudflareWorkflowClassName, t as createCloudflareWorkflowBindings } from "./cloudflare-CeHVSHoN.js";
+import { a as createImportPath, i as computePackageDir, n as discoverWorkflowDefinitions, o as ensureGeneratedDir, r as createRuntimeRegistryContents, s as resolveRuntimeModule$1, t as workflowNitroModule } from "./module-UYEnVfxy.js";
+import { cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { dirname, relative as relative$1, resolve as resolve$1 } from "pathe";
+import { build } from "esbuild";
+const VITEHUB_MODES = {
+	e2e: "e2e",
+	blob: "blob",
+	chat: "chat",
+	db: "db",
+	env: "env",
+	kv: "kv",
+	queue: "queue",
+	schedule: "schedule",
+	sandbox: "sandbox",
+	workspace: "workspace",
+	workflow: "workflow"
+};
+function isViteCli(argv) {
+	return argv.some((arg) => /(?:^|[/\\])vite(?:\.[cm]?js)?$/.test(arg) || arg === "vite");
+}
+function getViteCliMode(argv = process.argv) {
+	if (!isViteCli(argv)) return;
+	const modes = new Set(Object.values(VITEHUB_MODES));
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		const mode = arg === "--mode" || arg === "-m" ? argv[index + 1] : arg.startsWith("--mode=") ? arg.slice(7) : void 0;
+		if (mode && modes.has(mode)) return mode;
+	}
+}
+function getViteMode(env = process.env) {
+	return env["VITEHUB_VITE_MODE"] ?? getViteCliMode();
+}
+//#endregion
+//#region ../internal/src/build/client-output.ts
+function hasStaticIndex(clientDir) {
+	return existsSync(resolve$1(clientDir, "index.html"));
+}
+async function copyClientOutput(clientDir, targetDir) {
+	const resolvedClientDir = resolve$1(clientDir);
+	const resolvedTargetDir = resolve$1(targetDir);
+	if (resolvedClientDir === resolvedTargetDir) return;
+	await rm(resolvedTargetDir, {
+		force: true,
+		recursive: true
+	});
+	await mkdir(dirname(resolvedTargetDir), { recursive: true });
+	const targetRelativePath = relative$1(resolvedClientDir, resolvedTargetDir);
+	if (targetRelativePath && !targetRelativePath.startsWith("../")) {
+		const [targetRootEntry] = targetRelativePath.split("/", 1);
+		await mkdir(resolvedTargetDir, { recursive: true });
+		await Promise.all((await readdir(resolvedClientDir)).filter((entry) => entry !== targetRootEntry).map((entry) => cp(resolve$1(resolvedClientDir, entry), resolve$1(resolvedTargetDir, entry), { recursive: true })));
+		return;
+	}
+	await cp(resolvedClientDir, resolvedTargetDir, { recursive: true });
+}
+//#endregion
+//#region ../internal/src/build/esbuild.ts
+async function bundleEsmEntry(entryFile, outfile, options = {}) {
+	const format = options.format || "esm";
+	const platform = options.platform || "neutral";
+	await build({
+		alias: options.alias,
+		banner: format === "esm" && platform === "node" ? { js: "import { createRequire as __createRequire } from \"node:module\";\nvar require = __createRequire(import.meta.url);\n" } : void 0,
+		bundle: true,
+		conditions: options.conditions,
+		entryPoints: [entryFile],
+		external: options.external,
+		format,
+		logLevel: "silent",
+		outfile,
+		platform,
+		sourcemap: false,
+		target: "es2022",
+		write: true
+	});
+}
+//#endregion
+//#region ../internal/src/build/user-entry.ts
+function toSafeAppName(rootDir) {
+	return basename(rootDir).replace(/[^a-z0-9-]+/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+const DEFAULT_ENTRY_NAMES = [
+	"server.ts",
+	"server.mts",
+	"server.js",
+	"server.mjs",
+	"worker.ts",
+	"worker.mts",
+	"worker.js",
+	"worker.mjs"
+];
+function resolveUserAppEntry(rootDir, options = {}) {
+	const names = options.names ?? DEFAULT_ENTRY_NAMES;
+	const srcSubdir = options.srcSubdir ?? "src";
+	return names.map((name) => resolve(rootDir, srcSubdir, name)).find(existsSync);
+}
+//#endregion
+//#region ../internal/src/build/vercel-config.ts
+function createVercelConfigJson() {
+	return {
+		routes: [{ handle: "filesystem" }, {
+			src: "/(.*)",
+			dest: "/__server"
+		}],
+		version: 3
+	};
+}
+function createNodeFunctionConfig(extra = {}) {
+	return {
+		handler: "index.mjs",
+		launcherType: "Nodejs",
+		runtime: "nodejs22.x",
+		shouldAddHelpers: false,
+		supportsResponseStreaming: true,
+		...extra
+	};
+}
+//#endregion
+//#region ../internal/src/build/deployment-output.ts
+function resolveClientOutput(rootDir, clientOutDir) {
+	const clientDir = resolve(rootDir, clientOutDir);
+	return {
+		clientDir,
+		staticIndex: hasStaticIndex(clientDir)
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readJsonObject(file) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		return isJsonObject(parsed) ? parsed : {};
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw error;
+	}
+}
+function deleteJsonObjectKeys(value, keys) {
+	if (!keys?.length) return value;
+	const next = { ...value };
+	for (const key of keys) delete next[key];
+	return next;
+}
+async function writeMergedJsonObject(file, value, ownedKeys) {
+	const existing = await readJsonObject(file);
+	await writeFile(file, `${JSON.stringify({
+		...deleteJsonObjectKeys(existing, ownedKeys),
+		...value
+	}, null, 2)}\n`, "utf8");
+}
+async function deleteJsonObjectKeysFromFile(file, keys) {
+	if (!keys?.length) return;
+	let existing;
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		existing = isJsonObject(parsed) ? parsed : {};
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	const next = { ...existing };
+	let changed = false;
+	for (const key of keys) if (key in next) {
+		delete next[key];
+		changed = true;
+	}
+	if (!changed) return;
+	await writeFile(file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}
+function shouldSkipViteProviderBuild(command, mode) {
+	return command === "serve" || mode === "e2e";
+}
+function createDefaultCloudflareOutputRoot(rootDir) {
+	return resolve(rootDir, "dist", toSafeAppName(rootDir));
+}
+function createDefaultCloudflareStaticOutputDir(rootDir) {
+	return resolve(rootDir, "dist", "client");
+}
+function createDefaultVercelOutputRoot(rootDir) {
+	return resolve(rootDir, ".vercel", "output");
+}
+async function writeCloudflareDeploymentOutput(options) {
+	const { clientDir, staticIndex } = resolveClientOutput(options.rootDir, options.clientOutDir);
+	const outputRoot = options.outputRoot ?? createDefaultCloudflareOutputRoot(options.rootDir);
+	const workerOutfile = resolve(outputRoot, options.bundleOutfileName ?? "index.js");
+	await mkdir(outputRoot, { recursive: true });
+	await rm(workerOutfile, {
+		force: true,
+		recursive: true
+	});
+	await Promise.all([
+		bundleEsmEntry(options.bundleEntry, workerOutfile, options.bundleOptions),
+		writeMergedJsonObject(resolve(outputRoot, "wrangler.json"), options.wranglerConfig, options.wranglerConfigKeys),
+		staticIndex ? copyClientOutput(clientDir, options.staticOutputDir ?? createDefaultCloudflareStaticOutputDir(options.rootDir)) : Promise.resolve()
+	]);
+}
+async function writeVercelDeploymentOutput(options) {
+	const { clientDir, staticIndex } = resolveClientOutput(options.rootDir, options.clientOutDir);
+	const outputRoot = options.outputRoot ?? createDefaultVercelOutputRoot(options.rootDir);
+	const serverDir = resolve(outputRoot, "functions", options.serverFunctionName ?? "__server.func");
+	const serverEntry = resolve(serverDir, "index.mjs");
+	await rm(serverDir, {
+		force: true,
+		recursive: true
+	});
+	await mkdir(serverDir, { recursive: true });
+	await Promise.all([
+		bundleEsmEntry(options.bundleEntry, serverEntry, options.bundleOptions),
+		writeFile(resolve(serverDir, ".vc-config.json"), `${JSON.stringify(options.functionConfig ?? createNodeFunctionConfig(), null, 2)}\n`, "utf8"),
+		writeMergedJsonObject(resolve(outputRoot, "config.json"), options.config ?? createVercelConfigJson(), options.configKeys),
+		staticIndex ? copyClientOutput(clientDir, options.staticOutputDir ?? resolve(outputRoot, "static")) : Promise.resolve()
+	]);
+}
+async function cleanupCloudflareDeploymentOutput(rootDir, cleanup) {
+	const outputRoot = cleanup.outputRoot ?? createDefaultCloudflareOutputRoot(rootDir);
+	const writes = [];
+	if (cleanup.bundleOutfileName) writes.push(rm(resolve(outputRoot, cleanup.bundleOutfileName), {
+		force: true,
+		recursive: true
+	}));
+	writes.push(deleteJsonObjectKeysFromFile(resolve(outputRoot, "wrangler.json"), cleanup.wranglerConfigKeys));
+	await Promise.all(writes);
+}
+async function cleanupVercelDeploymentOutput(rootDir, cleanup) {
+	const outputRoot = cleanup.outputRoot ?? createDefaultVercelOutputRoot(rootDir);
+	const writes = [];
+	if (cleanup.serverFunctionName) writes.push(rm(resolve(outputRoot, "functions", cleanup.serverFunctionName), {
+		force: true,
+		recursive: true
+	}));
+	writes.push(deleteJsonObjectKeysFromFile(resolve(outputRoot, "config.json"), cleanup.configKeys));
+	await Promise.all(writes);
+}
+async function writeProviderDeploymentOutputs(options) {
+	const writes = [];
+	if (options.cloudflare) writes.push(writeCloudflareDeploymentOutput({
+		...options.cloudflare,
+		clientOutDir: options.clientOutDir,
+		rootDir: options.rootDir
+	}));
+	else if (options.cleanup?.cloudflare) writes.push(cleanupCloudflareDeploymentOutput(options.rootDir, options.cleanup.cloudflare));
+	if (options.vercel) writes.push(writeVercelDeploymentOutput({
+		...options.vercel,
+		clientOutDir: options.clientOutDir,
+		rootDir: options.rootDir
+	}));
+	else if (options.cleanup?.vercel) writes.push(cleanupVercelDeploymentOutput(options.rootDir, options.cleanup.vercel));
+	await Promise.all(writes);
+}
+//#endregion
+//#region ../internal/src/build/vite.ts
+function createNoExternalMerger(packageName) {
+	return (current) => {
+		if (current === true) return true;
+		if (!current) return [packageName];
+		const values = Array.isArray(current) ? current : [current];
+		return values.includes(packageName) ? values : [...values, packageName];
+	};
+}
+function isServerEnvironment(name, config) {
+	return name === "ssr" || config.consumer === "server";
+}
+//#endregion
+//#region ../internal/src/build/cloudflare.ts
+const defaultCloudflareCompatibilityDate = "2026-04-20";
+//#endregion
+//#region src/internal/vite-build.ts
+const workflowPackageName = "@vite-hub/workflow";
+const productName = "workflow";
+const generatedRegistryFileName = "registry.mjs";
+const packageDir = computePackageDir(import.meta.url);
+const resolveRuntimeModule = (modulePath) => resolveRuntimeModule$1(packageDir, modulePath);
+const WORKFLOW_ENTRY_BASE_NAMES = [
+	"server.ts",
+	"server.mts",
+	"server.js",
+	"server.mjs",
+	"worker.ts",
+	"worker.mts",
+	"worker.js",
+	"worker.mjs"
+];
+const WORKFLOW_PRIORITY_NAMES = [
+	"server-workflow.ts",
+	"server-workflow.mts",
+	"server-workflow.js",
+	"server-workflow.mjs"
+];
+function resolveWorkflowUserAppEntry(rootDir) {
+	return resolveUserAppEntry(rootDir, { names: getViteMode() === VITEHUB_MODES.workflow ? [...WORKFLOW_PRIORITY_NAMES, ...WORKFLOW_ENTRY_BASE_NAMES] : [...WORKFLOW_ENTRY_BASE_NAMES] });
+}
+const providerEntrySpecs = [{
+	name: "cloudflare",
+	entryFile: "cloudflare-worker.mjs",
+	runtimeModule: "runtime/cloudflare-vite",
+	factory: "createWorkflowCloudflareWorker",
+	hosting: "cloudflare"
+}, {
+	name: "vercel",
+	entryFile: "vercel-server.mjs",
+	runtimeModule: "runtime/vercel-vite",
+	factory: "createWorkflowVercelServer",
+	hosting: "vercel"
+}];
+function resolveWorkflowConfig(workflow, hosting) {
+	return normalizeWorkflowOptions(workflow, { hosting }) ?? false;
+}
+function renderCloudflareWorkerWrapper(definitions) {
+	return [
+		definitions.length ? `import { WorkflowEntrypoint, waitUntil as viteHubWaitUntil } from "cloudflare:workers"` : `import { waitUntil as viteHubWaitUntil } from "cloudflare:workers"`,
+		`import worker, { runViteHubWorkflowDefinition } from "./worker.mjs"`,
+		"",
+		...definitions.map((definition) => {
+			return [
+				`export class ${getCloudflareWorkflowClassName(definition.name)} extends WorkflowEntrypoint {`,
+				"  async run(event, step) {",
+				`    return await runViteHubWorkflowDefinition(${JSON.stringify(definition.name)}, this.env || {}, event, step)`,
+				"  }",
+				"}",
+				""
+			].join("\n");
+		}),
+		"const viteHubWorker = {",
+		"  async fetch(request, env, context) {",
+		"    const waitUntil = typeof viteHubWaitUntil === \"function\" ? viteHubWaitUntil : context?.waitUntil?.bind(context)",
+		"    return await worker.fetch(request, env, waitUntil ? { ...context, waitUntil } : context)",
+		"  }",
+		"}",
+		"",
+		"export default viteHubWorker",
+		""
+	].join("\n");
+}
+function renderProviderEntry(spec, entryFile, userAppEntry, serializedWorkflowConfig) {
+	const imports = [`import { ${spec.factory} } from ${JSON.stringify(createImportPath(entryFile, resolveRuntimeModule(spec.runtimeModule)))}`, `import workflowRegistry from ${JSON.stringify(`./${generatedRegistryFileName}`)}`];
+	if (spec.name === "cloudflare") imports.push(`import { runCloudflareWorkflow } from ${JSON.stringify(createImportPath(entryFile, resolveRuntimeModule("runtime/cloudflare-runner")))}`);
+	if (userAppEntry) imports.push(`import workflowApp from ${JSON.stringify(createImportPath(entryFile, userAppEntry))}`);
+	const cloudflareDispatcher = spec.name === "cloudflare" ? [
+		"",
+		"export async function runViteHubWorkflowDefinition(name, env, event, step) {",
+		"  return await runCloudflareWorkflow({ config: workflowConfig, env: env || {}, event, name, registry: workflowRegistry, step })",
+		"}"
+	] : [];
+	return [
+		...imports,
+		"",
+		`const workflowConfig = ${serializedWorkflowConfig}`,
+		...cloudflareDispatcher,
+		"",
+		`export default ${spec.factory}({`,
+		userAppEntry ? "  app: workflowApp," : "",
+		"  registry: workflowRegistry,",
+		"  workflow: workflowConfig,",
+		"})",
+		""
+	].filter(Boolean).join("\n");
+}
+async function writeProviderEntries(rootDir, workflow) {
+	const generatedDir = ensureGeneratedDir(rootDir, productName);
+	await mkdir(generatedDir, { recursive: true });
+	const registryFile = resolve(generatedDir, generatedRegistryFileName);
+	const definitions = discoverWorkflowDefinitions({ rootDir });
+	const providerDefinitions = definitions;
+	const userAppEntry = resolveWorkflowUserAppEntry(rootDir);
+	const cloudflareWorkflowConfig = resolveWorkflowConfig(workflow, "cloudflare");
+	await writeFile(registryFile, createRuntimeRegistryContents(registryFile, definitions), "utf8");
+	const entryFiles = {
+		cloudflare: "",
+		openworkflow: "",
+		vercel: ""
+	};
+	await Promise.all(providerEntrySpecs.map(async (spec) => {
+		const entryFile = resolve(generatedDir, spec.entryFile);
+		const workflowConfig = spec.name === "cloudflare" ? cloudflareWorkflowConfig : resolveWorkflowConfig(workflow, spec.hosting);
+		await writeFile(entryFile, renderProviderEntry(spec, entryFile, userAppEntry, JSON.stringify(workflowConfig, null, 2)), "utf8");
+		entryFiles[spec.name] = entryFile;
+	}));
+	return {
+		cloudflareWorkerFile: entryFiles.cloudflare,
+		cloudflareWorkflowConfig,
+		definitions,
+		generatedDir,
+		providerDefinitions,
+		registryFile,
+		vercelServerFile: entryFiles.vercel
+	};
+}
+function createCloudflareOutput(rootDir, artifacts) {
+	const workflowConfig = artifacts.cloudflareWorkflowConfig && artifacts.cloudflareWorkflowConfig.provider === "cloudflare" ? artifacts.cloudflareWorkflowConfig : false;
+	const workflows = createCloudflareWorkflowBindings(workflowConfig ? artifacts.providerDefinitions : [], workflowConfig);
+	const wranglerConfig = {
+		compatibility_date: defaultCloudflareCompatibilityDate,
+		compatibility_flags: ["nodejs_compat"],
+		main: "index.js",
+		observability: { enabled: true },
+		...workflows ? { workflows } : {}
+	};
+	return {
+		bundleEntry: artifacts.cloudflareWorkerFile,
+		bundleOptions: {
+			conditions: [
+				"workerd",
+				"worker",
+				"browser",
+				"default"
+			],
+			external: [
+				"@cloudflare/sandbox",
+				"@vercel/blob",
+				"@vercel/functions",
+				"@vercel/queue",
+				"@vercel/sandbox",
+				"cloudflare:workers",
+				"node:async_hooks",
+				"workflow",
+				"workflow/api",
+				"workflow/runtime"
+			],
+			format: "esm",
+			platform: "neutral"
+		},
+		bundleOutfileName: "worker.mjs",
+		outputRoot: createDefaultCloudflareOutputRoot(rootDir),
+		wranglerConfigKeys: ["workflows"],
+		wranglerConfig
+	};
+}
+async function writeCloudflareWorkflowWrapper(rootDir, artifacts) {
+	const outputRoot = createDefaultCloudflareOutputRoot(rootDir);
+	const workflowDefinitions = (artifacts.cloudflareWorkflowConfig && artifacts.cloudflareWorkflowConfig.provider === "cloudflare" ? artifacts.cloudflareWorkflowConfig : false) ? artifacts.providerDefinitions : [];
+	await writeFile(resolve(outputRoot, "index.js"), renderCloudflareWorkerWrapper(workflowDefinitions), "utf8");
+}
+function createVercelOutput(artifacts) {
+	return {
+		bundleEntry: artifacts.vercelServerFile,
+		bundleOptions: {
+			external: [
+				"@cloudflare/sandbox",
+				"cloudflare:workers",
+				"workflow",
+				"workflow/api",
+				"workflow/runtime"
+			],
+			format: "esm",
+			platform: "node"
+		}
+	};
+}
+async function generateProviderOutputs(options) {
+	const artifacts = await writeProviderEntries(options.rootDir, options.workflow);
+	const cloudflareWorkflowConfig = resolveWorkflowConfig(options.workflow, "cloudflare");
+	const vercelWorkflowConfig = resolveWorkflowConfig(options.workflow, "vercel");
+	await writeProviderDeploymentOutputs({
+		clientOutDir: options.clientOutDir,
+		...cloudflareWorkflowConfig && cloudflareWorkflowConfig.provider === "cloudflare" ? { cloudflare: createCloudflareOutput(options.rootDir, artifacts) } : {},
+		cleanup: { cloudflare: {
+			bundleOutfileName: "worker.mjs",
+			outputRoot: createDefaultCloudflareOutputRoot(options.rootDir),
+			wranglerConfigKeys: ["workflows"]
+		} },
+		rootDir: options.rootDir,
+		...vercelWorkflowConfig && vercelWorkflowConfig.provider === "vercel" ? { vercel: createVercelOutput(artifacts) } : {}
+	});
+	if (cloudflareWorkflowConfig && cloudflareWorkflowConfig.provider === "cloudflare") await writeCloudflareWorkflowWrapper(options.rootDir, artifacts);
+	return artifacts;
+}
+//#endregion
+//#region src/vite.ts
+const mergeNoExternal = createNoExternalMerger(workflowPackageName);
+function hubWorkflow(options) {
+	let resolved;
+	let workflow = options;
+	return {
+		name: "@vite-hub/workflow/vite",
+		nitro: workflowNitroModule,
+		config(config) {
+			workflow = config.workflow ?? workflow;
+		},
+		configResolved(config) {
+			resolved = config;
+			workflow = config.workflow ?? workflow;
+		},
+		configEnvironment(name, config) {
+			if (!isServerEnvironment(name, config)) return;
+			return { resolve: { noExternal: mergeNoExternal(config.resolve?.noExternal) } };
+		},
+		async closeBundle() {
+			if (!resolved || shouldSkipViteProviderBuild(resolved.command, getViteMode())) return;
+			await generateProviderOutputs({
+				clientOutDir: resolved.build.outDir,
+				rootDir: resolved.root,
+				workflow
+			});
+		}
+	};
+}
+//#endregion
+export { hubWorkflow };