@vite-hub/workflow 0.0.0 → 0.0.2

package/dist/vite.js

@@ -0,0 +1,2037 @@
+import { t as normalizeWorkflowOptions } from "./config-BDqB6I4E.js";
+import { r as getCloudflareWorkflowClassName, t as createCloudflareWorkflowBindings } from "./cloudflare-Cds1VIWa.js";
+import { builtinModules, createRequire } from "node:module";
+import { cp, mkdir, readFile, readdir, rm, rmdir, stat, symlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename as basename$1, dirname as dirname$1, normalize, relative as relative$1, resolve as resolve$1 } from "pathe";
+import { fileURLToPath } from "node:url";
+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$1(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/provider-output-config.ts
+function isProviderJsonArray(value, ancestors) {
+	if (Object.getPrototypeOf(value) !== Array.prototype || ancestors.has(value)) return false;
+	if (Reflect.ownKeys(value).length !== value.length + 1) return false;
+	ancestors.add(value);
+	try {
+		for (let index = 0; index < value.length; index++) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+			if (!descriptor?.enumerable || !("value" in descriptor) || !isProviderJsonValue(descriptor.value, ancestors)) return false;
+		}
+		return true;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function isProviderJsonRecordValue(value, ancestors) {
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null || ancestors.has(value)) return false;
+	ancestors.add(value);
+	try {
+		return Reflect.ownKeys(value).every((key) => {
+			if (typeof key !== "string") return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			return descriptor?.enumerable === true && "value" in descriptor && isProviderJsonValue(descriptor.value, ancestors);
+		});
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function isProviderJsonValue(value, ancestors) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return isProviderJsonArray(value, ancestors);
+	return typeof value === "object" && isProviderJsonRecordValue(value, ancestors);
+}
+function isProviderJsonRecord(value) {
+	try {
+		return typeof value === "object" && value !== null && !Array.isArray(value) && isProviderJsonRecordValue(value, /* @__PURE__ */ new Set());
+	} catch {
+		return false;
+	}
+}
+function assertProviderJsonRecord(value) {
+	if (!isProviderJsonRecord(value)) throw new TypeError("[vitehub] Provider output config must be a JSON object.");
+}
+function isFileNotFoundError(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readProviderJsonRecord(file) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		assertProviderJsonRecord(parsed);
+		return parsed;
+	} catch (error) {
+		if (isFileNotFoundError(error)) return;
+		throw error;
+	}
+}
+function deleteOwnedFields(value, ownership) {
+	const next = { ...value };
+	for (const key of ownership.keys ?? []) delete next[key];
+	for (const field of Object.keys(ownership.arrays ?? {})) delete next[field];
+	return next;
+}
+function getKeyedArrayEntryValue(value, key) {
+	if (!isProviderJsonRecord(value)) return;
+	const entryValue = value[key];
+	return entryValue === null || typeof entryValue === "boolean" || typeof entryValue === "number" || typeof entryValue === "string" ? entryValue : void 0;
+}
+function preserveUnownedKeyedArrayEntries(value, ownership, replacements = []) {
+	const current = Array.isArray(value) ? value : [];
+	const replacementKeys = replacements.flatMap((entry) => {
+		const key = getKeyedArrayEntryValue(entry, ownership.key);
+		return key === void 0 ? [] : [key];
+	});
+	const ownedKeys = new Set([...ownership.values ?? [], ...replacementKeys]);
+	return current.filter((entry) => {
+		const key = getKeyedArrayEntryValue(entry, ownership.key);
+		return key === void 0 || !ownedKeys.has(key);
+	});
+}
+function mergeOwnedArrays(existing, value, arrays) {
+	const next = { ...value };
+	for (const [field, ownership] of Object.entries(arrays ?? {})) {
+		const incoming = Array.isArray(value[field]) ? value[field] : [];
+		const merged = [...preserveUnownedKeyedArrayEntries(existing[field], ownership, incoming), ...incoming];
+		if (merged.length) next[field] = merged;
+		else delete next[field];
+	}
+	return next;
+}
+async function persistProviderJsonRecord(file, value, removeIfEmpty) {
+	if (removeIfEmpty && !Object.keys(value).length) {
+		await rm(file, { force: true });
+		return;
+	}
+	await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+async function writeProviderOutputConfig(file, value, ownership = {}, options = {}) {
+	await persistProviderJsonRecord(file, mergeProviderOutputConfig(await readProviderJsonRecord(file) ?? {}, value, ownership), options.removeIfEmpty === true);
+}
+function mergeProviderOutputConfig(existing, value, ownership = {}) {
+	assertProviderJsonRecord(existing);
+	assertProviderJsonRecord(value);
+	return {
+		...deleteOwnedFields(existing, ownership),
+		...mergeOwnedArrays(existing, value, ownership.arrays)
+	};
+}
+function stringifyProviderOutputConfig(value) {
+	assertProviderJsonRecord(value);
+	return JSON.stringify(value, null, 2);
+}
+async function cleanProviderOutputConfig(file, ownership) {
+	if (!ownership.keys?.length && !Object.keys(ownership.arrays ?? {}).length) return;
+	const existing = await readProviderJsonRecord(file);
+	if (!existing) return;
+	const next = deleteOwnedFields(existing, ownership);
+	let changed = (ownership.keys ?? []).some((key) => key in existing);
+	for (const [field, arrayOwnership] of Object.entries(ownership.arrays ?? {})) {
+		if (!(field in existing)) continue;
+		const current = existing[field];
+		const preserved = preserveUnownedKeyedArrayEntries(current, arrayOwnership);
+		changed ||= !Array.isArray(current) || preserved.length !== current.length || preserved.length === 0;
+		if (preserved.length) next[field] = preserved;
+	}
+	if (!changed) return;
+	await persistProviderJsonRecord(file, next, 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/cloudflare.ts
+const defaultCloudflareCompatibilityDate = "2026-04-20";
+function createDefaultCloudflareOutputRoot(rootDir) {
+	return resolve(rootDir, "dist", toSafeAppName(rootDir));
+}
+async function writeCloudflareWranglerConfig(options) {
+	const outputRoot = options.outputRoot ?? createDefaultCloudflareOutputRoot(options.rootDir);
+	const configFile = resolve(outputRoot, "wrangler.json");
+	if (!options.wranglerConfig) {
+		await cleanProviderOutputConfig(configFile, options.wranglerConfigOwnership ?? {});
+		return;
+	}
+	await mkdir(outputRoot, { recursive: true });
+	await writeProviderOutputConfig(configFile, options.wranglerConfig, options.wranglerConfigOwnership, { removeIfEmpty: true });
+}
+//#endregion
+//#region ../internal/src/build/vite.ts
+const projectRootDirectoryMarkers = [
+	["server", "agents"],
+	["server", "schedules"],
+	["server", "templates"],
+	["server", "workspaces"]
+];
+const projectRootDefinitionFileMarkers = [
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+].flatMap((extension) => [["server", `email${extension}`], [`server.email${extension}`]]);
+const projectRootFileMarkers = [["package.json"]];
+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";
+}
+function includesNitroVitePlugin(value) {
+	if (Array.isArray(value)) return value.some(includesNitroVitePlugin);
+	if (!value || typeof value !== "object") return false;
+	return "name" in value && value.name === "nitro:main";
+}
+function hasNitroVitePlugin(config) {
+	return includesNitroVitePlugin(config.plugins);
+}
+function resolveNitroVercelFunctionName(config, product, env = process.env) {
+	const preset = config.nitro?.preset || env.NITRO_PRESET || env.SERVER_PRESET;
+	const nitro = Boolean(preset) || hasNitroVitePlugin(config);
+	const clientOutDir = config.environments?.client?.build?.outDir;
+	const vercel = preset ? preset.startsWith("vercel") : env.VITEHUB_HOSTING === "vercel" || Boolean(env.VERCEL) || Boolean(clientOutDir && /(^|[/\\])\.vercel[/\\]output([/\\]|$)/.test(clientOutDir));
+	return nitro && vercel ? `__${product}.func` : void 0;
+}
+function shouldSkipViteProviderBuild(command, mode) {
+	return command === "serve" || mode === "e2e";
+}
+function resolveViteHubProjectRoot(root, options = {}) {
+	const resolvedRoot = resolve(root);
+	if (options.projectRoot) return resolve(resolvedRoot, options.projectRoot);
+	if (basename(resolvedRoot) === "app") {
+		const parent = dirname(resolvedRoot);
+		if (hasProjectRootDirectoryMarker(parent) || hasProjectRootDefinitionFileMarker(parent)) return parent;
+	}
+	let current = resolvedRoot;
+	while (true) {
+		if (hasProjectRootMarker(current)) return current;
+		const parent = dirname(current);
+		if (parent === current) return resolvedRoot;
+		current = parent;
+	}
+}
+function hasProjectRootDirectoryMarker(root) {
+	for (const marker of projectRootDirectoryMarkers) try {
+		if (statSync(resolve(root, ...marker)).isDirectory()) return true;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return false;
+}
+function hasProjectRootMarker(root) {
+	if (hasProjectRootDirectoryMarker(root)) return true;
+	if (hasProjectRootDefinitionFileMarker(root)) return true;
+	for (const marker of projectRootFileMarkers) try {
+		if (statSync(resolve(root, ...marker)).isFile()) return true;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return false;
+}
+function hasProjectRootDefinitionFileMarker(root) {
+	for (const marker of projectRootDefinitionFileMarkers) try {
+		if (statSync(resolve(root, ...marker)).isFile()) return true;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return false;
+}
+//#endregion
+//#region ../internal/src/build/esbuild.ts
+const viteRawNamespace = "vitehub-vite-raw";
+const viteMarkdownTemplateNamespace = "vitehub-markdown-template";
+const markdownTemplateFileSuffix = ".template.md";
+const markdownTemplateModuleQuery = "markdown-template";
+const markdownTemplateRegistryId = "#vitehub/templates";
+const markdownTemplateRegistryPath = ".vitehub/markdown-template/templates.mjs";
+const skipMarkdownTemplateResolve = "vitehubSkipMarkdownTemplateResolve";
+const markdownTemplateRuntimeSpecifier = "@vite-hub/markdown-template";
+function resolveEsbuildAliases(aliases) {
+	if (!aliases) return;
+	return Object.fromEntries(Object.entries(aliases).filter(([specifier]) => !specifier.endsWith("/")));
+}
+function stripMarkdownCode(template) {
+	let fence;
+	let inList = false;
+	let previousLineBlank = true;
+	return template.split("\n").map((line) => {
+		const content = line.replace(/^(?: {0,3}> ?)+/, "");
+		if (!fence) {
+			const listIndented = inList && /^ {4}(?:`{3,}|~{3,})/.test(content);
+			const opening = (listIndented ? content.slice(4) : content).match(/^ {0,3}(`{3,}|~{3,})/);
+			if (!opening) {
+				if (/^ {0,3}(?:[-+*]|\d+[.)])\s+/.test(content)) inList = true;
+				else if (content.trim() && !/^ {2,}/.test(content)) inList = false;
+				const indentedCode = !inList && previousLineBlank && /^(?: {4}|\t)/.test(content) || inList && previousLineBlank && /^(?: {8}| {4}\t|\t{2})/.test(content);
+				previousLineBlank = content.trim() === "";
+				return indentedCode ? "" : line;
+			}
+			fence = {
+				marker: opening[1][0],
+				length: opening[1].length,
+				listIndented
+			};
+			previousLineBlank = false;
+			return "";
+		}
+		const closing = (fence.listIndented ? content.replace(/^ {4}/, "") : content).match(/^ {0,3}(`+|~+)\s*$/)?.[1];
+		if (closing?.[0] === fence.marker && closing.length >= fence.length) fence = void 0;
+		previousLineBlank = false;
+		return "";
+	}).join("\n");
+}
+function extractMarkdownTemplateImportSpecifiers(template) {
+	const visible = stripMarkdownCode(template).replace(/(`+)[\s\S]*?\1/g, "").replace(/(!?\[[^\]]*\])\([^)]*\)/g, "$1").replace(/^ {0,3}\[[^\]]+\]:\s*\S+/gm, "").replace(/<[^>]*>/g, "");
+	const specifiers = /* @__PURE__ */ new Set();
+	for (const match of visible.matchAll(/@(\.\.?\/[^\s<>{}[\]]+)/g)) {
+		const token = match[1];
+		const trailing = token.match(/[.,;:!?)]*$/)?.[0] || "";
+		specifiers.add(token.slice(0, token.length - trailing.length));
+	}
+	return [...specifiers];
+}
+function parseMarkdownTemplateRequest(id) {
+	const queryIndex = id.indexOf("?");
+	const path = id.split(/[?#]/, 1)[0];
+	if (queryIndex === -1) return path.endsWith(markdownTemplateFileSuffix) ? { path } : void 0;
+	const query = id.slice(queryIndex + 1).split("#", 1)[0];
+	if (!new URLSearchParams(query).has(markdownTemplateModuleQuery)) return;
+	return { path };
+}
+function renderMarkdownTemplateModule(template, sourceId, imports = {}) {
+	return [
+		`import { renderMarkdownTemplate as vitehubRenderMarkdownTemplate } from ${JSON.stringify(markdownTemplateRuntimeSpecifier)}`,
+		`const vitehubMarkdownTemplate = ${JSON.stringify(template)}`,
+		`const vitehubMarkdownTemplateSourceId = ${JSON.stringify(sourceId)}`,
+		`const vitehubMarkdownTemplateImports = ${JSON.stringify(imports)}`,
+		"export default function render(data = {}) {",
+		"  return vitehubRenderMarkdownTemplate(vitehubMarkdownTemplate, { data, sourceId: vitehubMarkdownTemplateSourceId, resolveImport: (specifier, importer) => vitehubMarkdownTemplateImports[`${importer}\\0${specifier}`] })",
+		"}",
+		""
+	].join("\n");
+}
+function hasViteRawQuery(path) {
+	const queryIndex = path.indexOf("?");
+	return queryIndex !== -1 && /(?:^|&)raw(?:&|$)/.test(path.slice(queryIndex + 1));
+}
+async function resolveViteRawSpecifier(path, rootDir) {
+	if (path.startsWith("/@fs/")) return path.slice(5);
+	if (!rootDir || !path.startsWith("/")) return path;
+	const rootRelativePath = path.slice(1);
+	const publicPath = resolve(rootDir, "public", rootRelativePath);
+	try {
+		await stat(publicPath);
+		return publicPath;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		return resolve(rootDir, rootRelativePath);
+	}
+}
+function createViteRawPlugin(rootDir, frameworkRuntime) {
+	return {
+		name: "vitehub-vite-raw",
+		setup(build) {
+			build.onResolve({
+				filter: /^@vite-hub\/markdown-template$/,
+				namespace: viteMarkdownTemplateNamespace
+			}, async (args) => {
+				if (!frameworkRuntime) return { path: fileURLToPath(import.meta.resolve(markdownTemplateRuntimeSpecifier)) };
+				return build.resolve("vite-hub/_internal/markdown-template", {
+					importer: args.importer,
+					kind: args.kind,
+					resolveDir: args.resolveDir
+				});
+			});
+			build.onResolve({ filter: /\?|\.template\.md$/ }, async (args) => {
+				if (args.pluginData?.[skipMarkdownTemplateResolve]) return;
+				const markdownTemplate = parseMarkdownTemplateRequest(args.path);
+				const raw = hasViteRawQuery(args.path);
+				if (!markdownTemplate && !raw) return;
+				const specifier = await resolveViteRawSpecifier(markdownTemplate?.path ?? args.path.slice(0, args.path.indexOf("?")), rootDir);
+				const resolved = await build.resolve(specifier, {
+					importer: args.importer,
+					kind: args.kind,
+					namespace: args.namespace,
+					pluginData: markdownTemplate ? {
+						...args.pluginData && typeof args.pluginData === "object" ? args.pluginData : {},
+						[skipMarkdownTemplateResolve]: true
+					} : args.pluginData,
+					resolveDir: args.resolveDir,
+					with: args.with
+				});
+				if (resolved.errors.length) return {
+					errors: resolved.errors,
+					warnings: resolved.warnings
+				};
+				if (resolved.external) return {
+					external: true,
+					namespace: resolved.namespace,
+					path: resolved.path,
+					pluginData: resolved.pluginData,
+					sideEffects: resolved.sideEffects,
+					suffix: resolved.suffix,
+					warnings: resolved.warnings
+				};
+				if (resolved.namespace !== "file") return {
+					errors: [{ text: markdownTemplate ? `[vitehub] Markdown template fallback cannot load ${JSON.stringify(args.path)} from the ${JSON.stringify(resolved.namespace)} namespace. Handle this template import in a caller plugin.` : `[vitehub] Vite raw fallback cannot load ${JSON.stringify(args.path)} from the ${JSON.stringify(resolved.namespace)} namespace. Handle this raw import in a caller plugin.` }],
+					warnings: resolved.warnings
+				};
+				return {
+					namespace: markdownTemplate ? viteMarkdownTemplateNamespace : viteRawNamespace,
+					path: resolved.path,
+					pluginData: resolved.pluginData,
+					sideEffects: resolved.sideEffects,
+					suffix: resolved.suffix,
+					warnings: resolved.warnings
+				};
+			});
+			build.onLoad({
+				filter: /.*/,
+				namespace: viteRawNamespace
+			}, async (args) => ({
+				contents: await readFile(args.path),
+				loader: "text"
+			}));
+			build.onLoad({
+				filter: /.*/,
+				namespace: viteMarkdownTemplateNamespace
+			}, async (args) => ({
+				contents: await (async () => {
+					const template = await readFile(args.path, "utf8");
+					const imports = {};
+					const visited = new Set([args.path]);
+					const visit = async (source, importer) => {
+						for (const specifier of extractMarkdownTemplateImportSpecifiers(source)) {
+							const key = `${importer}\0${specifier}`;
+							if (imports[key]) continue;
+							const resolved = await build.resolve(specifier, {
+								importer,
+								kind: "import-statement",
+								pluginData: {
+									...args.pluginData && typeof args.pluginData === "object" ? args.pluginData : {},
+									[skipMarkdownTemplateResolve]: true
+								},
+								resolveDir: dirname(importer)
+							});
+							if (resolved.errors.length) return Promise.reject(new Error(resolved.errors.map((error) => error.text).join("\n")));
+							if (resolved.external || resolved.namespace !== "file") throw new Error(`[vitehub] Could not resolve Markdown template import ${JSON.stringify(specifier)} from ${JSON.stringify(importer)} to a file.`);
+							const imported = {
+								id: resolved.path,
+								template: await readFile(resolved.path, "utf8")
+							};
+							imports[key] = imported;
+							if (!visited.has(imported.id)) {
+								visited.add(imported.id);
+								await visit(imported.template, imported.id);
+							}
+						}
+					};
+					await visit(template, args.path);
+					return renderMarkdownTemplateModule(template, args.path, imports);
+				})(),
+				loader: "js",
+				resolveDir: dirname(args.path)
+			}));
+		}
+	};
+}
+async function bundleEsmEntry(entryFile, outfile, options = {}) {
+	const format = options.format || "esm";
+	const platform = options.platform || "neutral";
+	const markdownTemplateRoot = options.rootDir && resolveViteHubProjectRoot(options.rootDir);
+	const aliases = resolveEsbuildAliases({
+		...markdownTemplateRoot ? { [markdownTemplateRegistryId]: resolve(markdownTemplateRoot, markdownTemplateRegistryPath) } : {},
+		...options.alias
+	});
+	const frameworkRuntime = Object.keys(aliases || {}).some((specifier) => specifier === "vite-hub" || specifier.startsWith("vite-hub/"));
+	await build({
+		alias: aliases,
+		banner: options.banner || format === "esm" && platform === "node" ? { js: [options.banner, ...format === "esm" && platform === "node" ? [
+			"import { createRequire as __createRequire } from \"node:module\";",
+			"import { dirname as __vitehubDirname } from \"node:path\";",
+			"import { fileURLToPath as __vitehubFileURLToPath } from \"node:url\";",
+			"globalThis.require = __createRequire(import.meta.url);",
+			"globalThis.__filename = __vitehubFileURLToPath(import.meta.url);",
+			"globalThis.__dirname = __vitehubDirname(globalThis.__filename);"
+		] : []].filter(Boolean).join("\n") } : void 0,
+		bundle: true,
+		conditions: options.conditions ?? (platform === "node" ? ["node"] : void 0),
+		entryPoints: [entryFile],
+		external: options.external,
+		format,
+		logLevel: "silent",
+		mainFields: options.mainFields ?? (platform === "neutral" ? ["module", "main"] : void 0),
+		minifyIdentifiers: options.minifyIdentifiers,
+		outfile,
+		platform,
+		plugins: [...options.plugins ?? [], createViteRawPlugin(options.rootDir, frameworkRuntime)],
+		sourcemap: false,
+		target: "es2022",
+		write: true
+	});
+}
+//#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
+const providerDeploymentOutputWrites = /* @__PURE__ */ new Map();
+function resolveClientOutput(rootDir, clientOutDir) {
+	const clientDir = resolve(rootDir, clientOutDir);
+	return {
+		clientDir,
+		staticIndex: hasStaticIndex(clientDir)
+	};
+}
+function createDefaultCloudflareStaticOutputDir(rootDir) {
+	return resolve(rootDir, "dist", "client");
+}
+function createDefaultVercelOutputRoot(rootDir) {
+	return resolve(rootDir, ".vercel", "output");
+}
+function createDefaultNetlifyOutputRoot(rootDir) {
+	return resolve(rootDir, ".netlify", "v1");
+}
+function assertNetlifyFunctionName(functionName) {
+	if (!functionName || functionName.includes("\\") || functionName.split("/").some((part) => !part || part === "." || part === "..")) throw new Error(`Invalid Netlify function name: ${functionName}`);
+}
+function resolveNetlifyFunctionFile(functionsRoot, functionName) {
+	assertNetlifyFunctionName(functionName);
+	return resolve(functionsRoot, `${functionName}.mjs`);
+}
+async function appendNetlifyFunctionConfig(outfile, config) {
+	if (!config) return;
+	await writeFile(outfile, `${(await readFile(outfile, "utf8")).trimEnd()}\n\nexport const config = ${stringifyProviderOutputConfig(config)}\n`, "utf8");
+}
+async function writeCloudflareDeploymentOutput(options) {
+	const { clientDir, staticIndex } = resolveClientOutput(options.rootDir, options.clientOutDir);
+	const outputRoot = options.outputRoot ?? createDefaultCloudflareOutputRoot(options.rootDir);
+	const files = Object.entries(options.files ?? {});
+	const workerOutfile = options.bundleEntry ? resolve(outputRoot, options.bundleOutfileName ?? "index.js") : void 0;
+	if (workerOutfile && files.some(([fileName]) => resolve(outputRoot, fileName) === workerOutfile)) throw new Error(`Cloudflare output file conflicts with bundle outfile: ${workerOutfile}`);
+	await mkdir(outputRoot, { recursive: true });
+	const writes = [
+		writeCloudflareWranglerConfig({
+			outputRoot,
+			rootDir: options.rootDir,
+			wranglerConfig: options.wranglerConfig,
+			wranglerConfigOwnership: options.wranglerConfigOwnership ?? { keys: options.wranglerConfigKeys }
+		}),
+		options.bundleEntry && staticIndex ? copyClientOutput(clientDir, options.staticOutputDir ?? createDefaultCloudflareStaticOutputDir(options.rootDir)) : Promise.resolve(),
+		...files.map(([fileName, contents]) => writeFile(resolve(outputRoot, fileName), contents, "utf8"))
+	];
+	if (options.bundleEntry && workerOutfile) {
+		await rm(workerOutfile, {
+			force: true,
+			recursive: true
+		});
+		writes.push(bundleEsmEntry(options.bundleEntry, workerOutfile, {
+			...options.bundleOptions,
+			rootDir: options.rootDir
+		}));
+	}
+	await Promise.all(writes);
+}
+async function writeVercelDeploymentOutput(options) {
+	const { clientDir, staticIndex } = resolveClientOutput(options.rootDir, options.clientOutDir);
+	const outputRoot = options.outputRoot ?? createDefaultVercelOutputRoot(options.rootDir);
+	const functionOutput = options.function ?? { kind: "root" };
+	const serverFunctionName = functionOutput.kind === "root" ? "__server.func" : functionOutput.name;
+	const config = options.config ?? (functionOutput.kind === "root" ? createVercelConfigJson() : {});
+	const serverDir = resolve(outputRoot, "functions", serverFunctionName);
+	const serverEntry = resolve(serverDir, "index.mjs");
+	await mkdir(serverDir, { recursive: true });
+	const staleFiles = (await readdir(serverDir)).filter((file) => file !== "node_modules");
+	await Promise.all(staleFiles.map((file) => rm(resolve(serverDir, file), {
+		force: true,
+		recursive: true
+	})));
+	await Promise.all([
+		bundleEsmEntry(options.bundleEntry, serverEntry, {
+			...options.bundleOptions,
+			rootDir: options.rootDir
+		}),
+		writeFile(resolve(serverDir, ".vc-config.json"), `${stringifyProviderOutputConfig(options.functionConfig ?? createNodeFunctionConfig())}\n`, "utf8"),
+		writeProviderOutputConfig(resolve(outputRoot, "config.json"), config, { keys: options.configKeys }),
+		staticIndex ? copyClientOutput(clientDir, options.staticOutputDir ?? resolve(outputRoot, "static")) : Promise.resolve()
+	]);
+}
+async function writeNetlifyDeploymentOutput(options) {
+	const outputRoot = options.outputRoot ?? createDefaultNetlifyOutputRoot(options.rootDir);
+	const functionsRoot = resolve(outputRoot, "functions");
+	const functionWrites = (options.functions ?? []).map(async (func) => {
+		const outfile = resolveNetlifyFunctionFile(functionsRoot, func.functionName);
+		await rm(outfile, {
+			force: true,
+			recursive: true
+		});
+		await mkdir(dirname(outfile), { recursive: true });
+		await bundleEsmEntry(func.bundleEntry, outfile, {
+			...func.bundleOptions,
+			minifyIdentifiers: func.config ? true : func.bundleOptions.minifyIdentifiers,
+			rootDir: options.rootDir
+		});
+		await appendNetlifyFunctionConfig(outfile, func.config);
+	});
+	await mkdir(outputRoot, { recursive: true });
+	await Promise.all([writeProviderOutputConfig(resolve(outputRoot, "config.json"), options.config ?? {}, { keys: options.configKeys }), ...functionWrites]);
+}
+async function cleanupCloudflareDeploymentOutput(rootDir, cleanupInput) {
+	const cleanup = typeof cleanupInput === "function" ? await cleanupInput() : cleanupInput;
+	const outputRoot = cleanup.outputRoot ?? createDefaultCloudflareOutputRoot(rootDir);
+	const writes = (cleanup.fileNames ?? []).map((fileName) => rm(resolve(outputRoot, fileName), {
+		force: true,
+		recursive: true
+	}));
+	writes.push(writeCloudflareWranglerConfig({
+		outputRoot,
+		rootDir,
+		wranglerConfigOwnership: cleanup.wranglerConfigOwnership
+	}));
+	await Promise.all(writes);
+	try {
+		await rmdir(outputRoot);
+	} catch (error) {
+		const code = error.code;
+		if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
+	}
+}
+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(cleanProviderOutputConfig(resolve(outputRoot, "config.json"), { keys: cleanup.configKeys }));
+	await Promise.all(writes);
+}
+async function cleanupVercelDeploymentOutputs(rootDir, cleanup) {
+	await Promise.all((Array.isArray(cleanup) ? cleanup : [cleanup]).map((item) => cleanupVercelDeploymentOutput(rootDir, item)));
+}
+async function cleanupNetlifyDeploymentOutput(rootDir, cleanup) {
+	const outputRoot = cleanup.outputRoot ?? createDefaultNetlifyOutputRoot(rootDir);
+	const functionsRoot = resolve(outputRoot, "functions");
+	const writes = (cleanup.functionNames ?? []).map((functionName) => rm(resolveNetlifyFunctionFile(functionsRoot, functionName), {
+		force: true,
+		recursive: true
+	}));
+	writes.push(cleanProviderOutputConfig(resolve(outputRoot, "config.json"), { keys: cleanup.configKeys }));
+	await Promise.all(writes);
+}
+async function writeProviderDeploymentOutputsNow(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.netlify) writes.push(writeNetlifyDeploymentOutput({
+		...options.netlify,
+		clientOutDir: options.clientOutDir,
+		rootDir: options.rootDir
+	}));
+	else if (options.cleanup?.netlify) writes.push(cleanupNetlifyDeploymentOutput(options.rootDir, options.cleanup.netlify));
+	if (options.vercel) writes.push(writeVercelDeploymentOutput({
+		...options.vercel,
+		clientOutDir: options.clientOutDir,
+		rootDir: options.rootDir
+	}));
+	else if (options.cleanup?.vercel) {
+		const cleanup = typeof options.cleanup.vercel === "function" ? await options.cleanup.vercel() : options.cleanup.vercel;
+		if (cleanup) writes.push(cleanupVercelDeploymentOutputs(options.rootDir, cleanup));
+	}
+	await Promise.all(writes);
+	await options.afterWrite?.();
+}
+async function writeProviderDeploymentOutputs(options) {
+	const key = resolve(options.rootDir);
+	const write = (providerDeploymentOutputWrites.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => writeProviderDeploymentOutputsNow(options));
+	providerDeploymentOutputWrites.set(key, write);
+	try {
+		await write;
+	} finally {
+		if (providerDeploymentOutputWrites.get(key) === write) providerDeploymentOutputWrites.delete(key);
+	}
+}
+//#endregion
+//#region ../internal/src/build/paths.ts
+function generatedDirSegments(productName) {
+	return [".vitehub", productName];
+}
+function ensureGeneratedDir(rootDir, productName) {
+	return resolve$1(rootDir, ...generatedDirSegments(productName));
+}
+function computePackageDir(importMetaUrl) {
+	const currentFileDir = dirname$1(fileURLToPath(importMetaUrl));
+	return resolve$1(currentFileDir, basename$1(currentFileDir) === "internal" ? "../.." : "..");
+}
+function resolveRuntimeModule$1(packageDir, modulePath) {
+	const distFile = resolve$1(packageDir, "dist", `${modulePath}.js`);
+	return existsSync(distFile) ? distFile : resolve$1(packageDir, "src", `${modulePath}.ts`);
+}
+function createImportPath(fromFile, targetFile) {
+	const importPath = relative$1(realpathIfExists(dirname$1(fromFile)), realpathIfExists(targetFile));
+	return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}
+function realpathIfExists(path) {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return resolve$1(path);
+	}
+}
+//#endregion
+//#region ../internal/src/definition-catalog.ts
+const sourceFilePattern$1 = /\.(?:c|m)?[jt]sx?$/i;
+const declarationFilePattern$1 = /\.d\.(?:c|m)?[jt]sx?$/i;
+const ignoredDirs = new Set([
+	"node_modules",
+	"dist",
+	".output",
+	".nuxt",
+	".vercel",
+	".git",
+	".vitehub"
+]);
+function resolveDefinitionScanRoots(rootDir, scanDirs = []) {
+	return [...new Set([rootDir, ...scanDirs].filter(Boolean))];
+}
+function createDirectoryDefinitionSource(source, scanDirs, subdir, options = {}) {
+	return {
+		...options,
+		kind: "directory",
+		scanDirs,
+		source,
+		subdir
+	};
+}
+function createSuffixDefinitionSource(source, roots, pattern, normalizeName, options = {}) {
+	return {
+		...options,
+		kind: "suffix",
+		normalizeName,
+		pattern,
+		roots,
+		source
+	};
+}
+function readDirEntries$1(root) {
+	try {
+		return readdirSync(root, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+function listMatchingFiles(root, predicate, options = {}) {
+	const files = [];
+	for (const entry of readDirEntries$1(root)) {
+		const absolute = resolve$1(root, entry.name);
+		if (entry.isDirectory() && !entry.isSymbolicLink()) {
+			if (entry.name.startsWith(".")) continue;
+			if (ignoredDirs.has(entry.name)) continue;
+			files.push(...listMatchingFiles(absolute, predicate, options));
+			continue;
+		}
+		if (entry.name.startsWith(".") && !options.includeHidden) continue;
+		if (entry.isFile() && predicate(entry.name)) files.push(absolute);
+	}
+	return files.sort();
+}
+function listSourceFiles(root, options = {}) {
+	return listMatchingFiles(root, (name) => sourceFilePattern$1.test(name) && !declarationFilePattern$1.test(name), options);
+}
+function normalizePathDefinitionName(rootDir, file) {
+	return relative$1(rootDir, file).replace(sourceFilePattern$1, "").replace(/\/index$/i, "");
+}
+function normalizeSuffixDefinitionName(rootDir, file, pattern, options = {}) {
+	const normalized = relative$1(rootDir, file).replace(pattern, "");
+	if (options.stripPrefix && normalized.startsWith(options.stripPrefix)) return normalized.slice(options.stripPrefix.length);
+	return normalized;
+}
+function sortDefinitions(definitions) {
+	return [...definitions.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function registerDefinition(definitions, definition, sourceLabel) {
+	const existing = definitions.get(definition.name);
+	if (existing) throw new Error(`Duplicate ${sourceLabel} name "${definition.name}":\n  - ${existing.handler}\n  - ${definition.handler}`);
+	definitions.set(definition.name, definition);
+}
+function mergeDefinitions(feature, ...sources) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		if (!source) continue;
+		for (const definition of source) {
+			const existing = definitions.get(definition.name);
+			if (existing && existing.handler !== definition.handler) throw new Error(`Duplicate ${feature} name "${definition.name}" from multiple discovery sources:\n  - ${existing.handler} (${existing.source ?? "unknown"})\n  - ${definition.handler} (${definition.source ?? "unknown"})`);
+			if (!existing) definitions.set(definition.name, definition);
+		}
+	}
+	return sortDefinitions(definitions);
+}
+function createDefinition(source, file, name) {
+	if (source.createDefinition) return source.createDefinition({
+		file,
+		name
+	});
+	return {
+		handler: file,
+		name,
+		source: source.source
+	};
+}
+function scanSuffixDefinitions(feature, source) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const root of source.roots) for (const file of listMatchingFiles(root, (name) => source.pattern.test(name), { includeHidden: source.includeHidden })) {
+		const name = source.normalizeName(root, file);
+		if (!name) continue;
+		registerDefinition(definitions, createDefinition(source, file, name), feature);
+	}
+	return sortDefinitions(definitions);
+}
+function scanDirectoryDefinitions(feature, source) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const scanDir of source.scanDirs) {
+		const directory = resolve$1(scanDir, source.subdir);
+		for (const file of listSourceFiles(directory, { includeHidden: source.includeHidden })) {
+			const name = source.normalizeName ? source.normalizeName(directory, file) : normalizePathDefinitionName(directory, file);
+			if (!name) continue;
+			registerDefinition(definitions, createDefinition(source, file, name), feature);
+		}
+	}
+	return sortDefinitions(definitions);
+}
+function discoverDefinitions(feature, sources) {
+	return mergeDefinitions(feature, ...sources.map((source) => source.kind === "suffix" ? scanSuffixDefinitions(feature, source) : scanDirectoryDefinitions(feature, source)));
+}
+//#endregion
+//#region ../internal/src/source-scanner.ts
+function isQuote(char) {
+	return char === "\"" || char === "'" || char === "`";
+}
+function skipQuoted(source, index, controlFlowRegexes = /* @__PURE__ */ new Map()) {
+	const quote = source[index];
+	if (quote === "`") return skipTemplateLiteral(source, index, controlFlowRegexes);
+	index += 1;
+	while (index < source.length) {
+		if (source[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (source[index] === quote) return index + 1;
+		index += 1;
+	}
+	return index;
+}
+function skipTemplateLiteral(source, index, controlFlowRegexes) {
+	index += 1;
+	let expressionDepth = 0;
+	let previousSignificant = "";
+	while (index < source.length) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (char === "\\") {
+			index += 2;
+			continue;
+		}
+		if (expressionDepth === 0) {
+			if (char === "`") return index + 1;
+			if (char === "$" && next === "{") {
+				expressionDepth = 1;
+				previousSignificant = "{";
+				index += 2;
+				continue;
+			}
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			index = skipQuoted(source, index, controlFlowRegexes);
+			previousSignificant = "literal";
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(source, index, controlFlowRegexes);
+			previousSignificant = "literal";
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			index = skipLineComment(source, index);
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(source, index);
+			continue;
+		}
+		if (char === "/" && (isRegexLiteralStart(previousSignificant) || isControlFlowRegexStart(source, index, controlFlowRegexes))) {
+			index = skipRegexLiteral(source, index);
+			previousSignificant = "/";
+			continue;
+		}
+		if (char === "{") expressionDepth += 1;
+		if (char === "}") expressionDepth -= 1;
+		previousSignificant = trackSignificant(previousSignificant, char);
+		index += 1;
+	}
+	return index;
+}
+function skipLineComment(source, index) {
+	const end = source.indexOf("\n", index + 2);
+	return end === -1 ? source.length : end + 1;
+}
+function skipBlockComment(source, index) {
+	const end = source.indexOf("*/", index + 2);
+	return end === -1 ? source.length : end + 2;
+}
+function isRegexLiteralStart(previousSignificant) {
+	const token = previousSignificant.trimEnd();
+	if (/^\.[\w$]+$/.test(token)) return false;
+	return !token || /[({[=,:!&|?;>+\-*%^~]/.test(token) || /\b(?:await|case|delete|do|else|in|instanceof|return|throw|typeof|void|yield)$/.test(token);
+}
+function findLineCommentStart(source, start, end, controlFlowRegexes) {
+	for (let index = start; index <= end;) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (isQuote(char)) {
+			index = skipQuoted(source, index, controlFlowRegexes);
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(source, index);
+			continue;
+		}
+		if (char === "/" && next === "/") return index;
+		index += 1;
+	}
+	return -1;
+}
+function previousCodeIndex(source, index, controlFlowRegexes) {
+	let current = index;
+	while (current >= 0) {
+		while (/\s/.test(source[current] ?? "")) current--;
+		if (source[current] === "/" && source[current - 1] === "*") {
+			const start = source.lastIndexOf("/*", current - 2);
+			if (start === -1) return current;
+			current = start - 1;
+			continue;
+		}
+		const lineStart = source.lastIndexOf("\n", current) + 1;
+		const lineComment = findLineCommentStart(source, lineStart, current, controlFlowRegexes);
+		if (lineComment !== -1 && lineComment <= current) {
+			current = lineStart - 1;
+			continue;
+		}
+		return current;
+	}
+	return current;
+}
+function isControlFlowRegexStart(source, index, controlFlowRegexes = /* @__PURE__ */ new Map()) {
+	const cached = controlFlowRegexes.get(index);
+	if (cached !== void 0) return cached;
+	if (controlFlowRegexes.has(index)) return true;
+	controlFlowRegexes.set(index, void 0);
+	try {
+		const closeParen = previousCodeIndex(source, index - 1, controlFlowRegexes);
+		if (source[closeParen] !== ")") {
+			controlFlowRegexes.set(index, false);
+			return false;
+		}
+		for (let current = closeParen; current >= 0; current--) {
+			if (source[current] !== "(") continue;
+			if (findMatching(source, current, "(", ")", controlFlowRegexes) !== closeParen) continue;
+			const head = source.slice(0, current).replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, " ");
+			const result = /(?:^|[^\w$])(?:catch|for|if|while|with)\s*$/.test(head);
+			controlFlowRegexes.set(index, result);
+			return result;
+		}
+		controlFlowRegexes.set(index, false);
+		return false;
+	} catch (error) {
+		controlFlowRegexes.delete(index);
+		throw error;
+	}
+}
+function skipRegexLiteral(source, index) {
+	index += 1;
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "\\") {
+			index += 2;
+			continue;
+		}
+		if (char === "[") {
+			index += 1;
+			while (index < source.length) {
+				if (source[index] === "\\") {
+					index += 2;
+					continue;
+				}
+				if (source[index] === "]") break;
+				index += 1;
+			}
+		}
+		if (char === "/") {
+			index += 1;
+			while (/[a-z]/i.test(source[index] ?? "")) index += 1;
+			return index;
+		}
+		index += 1;
+	}
+	return index;
+}
+function trackSignificant(previousSignificant, char) {
+	if (/[a-z$]/i.test(char ?? "")) return /[\w$]$/.test(previousSignificant) || previousSignificant === "." ? previousSignificant + char : char ?? "";
+	if (/\s/.test(char ?? "")) return /[\w$]$/.test(previousSignificant) ? `${previousSignificant} ` : previousSignificant;
+	if (!/\s/.test(char ?? "")) return char ?? "";
+	return previousSignificant;
+}
+function maskSourceLiterals(source) {
+	const output = source.split("");
+	let previousSignificant = "";
+	const mask = (start, end) => {
+		for (let index = start; index < end; index++) if (output[index] !== "\n" && output[index] !== "\r") output[index] = " ";
+	};
+	for (let index = 0; index < source.length;) {
+		const char = source[index];
+		const next = source[index + 1];
+		let end;
+		if (isQuote(char)) {
+			end = skipQuoted(source, index);
+			previousSignificant = "literal";
+		} else if (char === "/" && next === "/") end = skipLineComment(source, index);
+		else if (char === "/" && next === "*") end = skipBlockComment(source, index);
+		else if (char === "/" && (isRegexLiteralStart(previousSignificant) || isControlFlowRegexStart(source, index))) {
+			end = skipRegexLiteral(source, index);
+			previousSignificant = "/";
+		}
+		if (end !== void 0) {
+			mask(index, end);
+			index = end;
+			continue;
+		}
+		previousSignificant = trackSignificant(previousSignificant, char);
+		index += 1;
+	}
+	return output.join("");
+}
+function findMatching(source, index, open, close, controlFlowRegexes = /* @__PURE__ */ new Map()) {
+	let depth = 0;
+	let previousSignificant = "";
+	for (let current = index; current < source.length; current++) {
+		const char = source[current];
+		const next = source[current + 1];
+		if (isQuote(char)) {
+			current = skipQuoted(source, current, controlFlowRegexes) - 1;
+			previousSignificant = "literal";
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			current = skipLineComment(source, current) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			current = skipBlockComment(source, current) - 1;
+			continue;
+		}
+		if (char === "/" && (isRegexLiteralStart(previousSignificant) || isControlFlowRegexStart(source, current, controlFlowRegexes))) {
+			current = skipRegexLiteral(source, current) - 1;
+			previousSignificant = "/";
+			continue;
+		}
+		if (char === open) {
+			depth += 1;
+			previousSignificant = char;
+			continue;
+		}
+		if (char === close && !(open === "<" && close === ">" && source[current - 1] === "=")) {
+			depth -= 1;
+			if (depth === 0) return current;
+			previousSignificant = char;
+			continue;
+		}
+		previousSignificant = trackSignificant(previousSignificant, char);
+	}
+}
+//#endregion
+//#region src/discovery.ts
+const workflowSuffixPattern = /\.workflow\.(?:c|m)?[jt]s$/i;
+const agentSuffixPattern = /\.agent\.(?:c|m)?[jt]s$/i;
+const sourceFilePattern = /\.(?:c|m)?[jt]s$/i;
+const declarationFilePattern = /\.d\.(?:c|m)?[jt]s$/i;
+const stepFilePattern = /^\d+[.-].*\.(?:c|m)?[jt]s$/i;
+const folderAgentFilePattern = /^agent\.(?:c|m)?[jt]s$/i;
+const folderAgentIndexFilePattern = /^index\.(?:c|m)?[jt]s$/i;
+const legacyFolderAgentFilePattern = /^config\.(?:c|m)?[jt]s$/i;
+const agentEvalFilePattern = /\.eval\.(?:c|m)?[jt]s$/i;
+function normalizeSuffixWorkflowName(rootDir, file) {
+	return normalizeSuffixDefinitionName(rootDir, file, workflowSuffixPattern, { stripPrefix: "src/" });
+}
+function normalizeSuffixAgentName(rootDir, file) {
+	const name = normalizeSuffixDefinitionName(rootDir, file, agentSuffixPattern, { stripPrefix: "src/" });
+	return name.startsWith("server/") ? void 0 : name;
+}
+function readDirEntries(root) {
+	try {
+		return readdirSync(root, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+function isSourceFile(file) {
+	return sourceFilePattern.test(file) && !declarationFilePattern.test(file);
+}
+function findDefineAgentObjectStart(masked, start) {
+	let index = start;
+	while (/\s/.test(masked[index] || "")) index++;
+	if (masked[index] === "<") {
+		let depth = 0;
+		do {
+			if (masked[index] === "<") depth++;
+			else if (masked[index] === ">" && masked[index - 1] !== "=") depth--;
+			index++;
+		} while (index < masked.length && depth > 0);
+	}
+	while (/\s/.test(masked[index] || "")) index++;
+	if (masked[index++] !== "(") return void 0;
+	while (/\s/.test(masked[index] || "")) index++;
+	if (masked[index] === "{") return index;
+	const options = /^([A-Za-z_$][\w$]*)\b/.exec(masked.slice(index))?.[1];
+	if (options) {
+		const declaration = new RegExp(`\\b(?:const|let|var)\\s+${options}\\s*(?::(?:=>|[^=])*?)?=\\s*\\{`).exec(masked);
+		if (declaration) return declaration.index + declaration[0].lastIndexOf("{");
+	}
+}
+function agentFactoryNames(source) {
+	const names = new Set(["defineAgent"]);
+	for (const match of source.matchAll(/\bimport\s*\{([^}]+)\}\s*from\s*["']@vite-hub\/agent["']/g)) for (const specifier of match[1].split(",")) {
+		const alias = /^\s*defineAgent\s+as\s+([A-Za-z_$][\w$]*)\s*$/.exec(specifier)?.[1];
+		if (alias) names.add(alias);
+	}
+	return [...names];
+}
+function findAgentObjectStart(source, masked) {
+	for (const factory of agentFactoryNames(source)) {
+		const inline = new RegExp(`\\bexport\\s+default\\s+${factory}\\b`).exec(masked);
+		if (inline) return findDefineAgentObjectStart(masked, inline.index + inline[0].length);
+	}
+	const exported = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\b/.exec(masked);
+	if (!exported) return void 0;
+	for (const factory of agentFactoryNames(source)) {
+		const declaration = new RegExp(`\\b(?:const|let|var)\\s+${exported[1]}\\s*(?::(?:=>|[^=])*?)?=\\s*${factory}\\b`).exec(masked);
+		if (declaration) return findDefineAgentObjectStart(masked, declaration.index + declaration[0].length);
+	}
+}
+function hasExportedDefineAgent(source, masked) {
+	if (agentFactoryNames(source).some((factory) => new RegExp(`\\bexport\\s+default\\s+${factory}\\b`).test(masked))) return true;
+	const exported = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\b/.exec(masked);
+	return Boolean(exported && agentFactoryNames(source).some((factory) => new RegExp(`\\b(?:const|let|var)\\s+${exported[1]}\\s*(?::(?:=>|[^=])*?)?=\\s*${factory}\\b`).test(masked)));
+}
+function findUnmaskedSourceMatch(source, masked, pattern, prefix) {
+	return [...source.matchAll(pattern)].find((match) => prefix.test(masked.slice(match.index)));
+}
+function resolveAgentReExport(file, source, masked) {
+	const direct = findUnmaskedSourceMatch(source, masked, /\bexport\s+\{\s*default\s*\}\s+from\s*(["'])([^"']+)\1/g, /^export\s+\{\s*default\s*\}\s+from\b/);
+	const exported = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\b/.exec(masked);
+	const imported = exported && findUnmaskedSourceMatch(source, masked, new RegExp(`\\bimport\\s+${exported[1]}\\s+from\\s*(["'])([^"']+)\\1`, "g"), /^import\b/);
+	const specifier = direct?.[2] || imported?.[2];
+	if (!specifier?.startsWith(".")) return void 0;
+	const target = resolve$1(file, "..", specifier);
+	const extensions = [
+		".ts",
+		".mts",
+		".cts",
+		".js",
+		".mjs",
+		".cjs"
+	];
+	const sourceTarget = target.replace(/\.(?:c|m)?js$/i, "");
+	for (const candidate of [
+		target,
+		...extensions.map((extension) => `${target}${extension}`),
+		...extensions.map((extension) => `${sourceTarget}${extension}`),
+		...extensions.map((extension) => resolve$1(target, `index${extension}`))
+	]) if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+}
+function isFolderAgentImplementationTarget(file) {
+	const fileName = normalize(file).split("/").pop();
+	if (/^definition\.(?:c|m)?[jt]s$/i.test(fileName)) return true;
+	return /^index\.(?:c|m)?[jt]s$/i.test(fileName) && normalize(resolve$1(file, "../..")).split("/").pop() === "definition";
+}
+function extractAgentRuntime(file, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(file)) return void 0;
+	seen.add(file);
+	const source = readFileSync(file, "utf8");
+	const masked = maskSourceLiterals(source);
+	const start = findAgentObjectStart(source, masked);
+	if (start === void 0) {
+		const target = resolveAgentReExport(file, source, masked);
+		if (target) return extractAgentRuntime(target, seen);
+		if (hasExportedDefineAgent(source, masked)) return {};
+		return /\bexport\s+default\s+[A-Za-z_$][\w$]*Agent\b/.test(masked) ? {} : void 0;
+	}
+	let depth = 0;
+	for (let index = start; index < masked.length; index++) if (masked[index] === "{") depth++;
+	else if (masked[index] === "}" && --depth === 0) return {};
+	else if (depth === 1) {
+		const previous = masked.slice(0, index).trimEnd().at(-1);
+		if ((previous === "{" || previous === ",") && /^runtime\s*(?:,|})/.test(masked.slice(index))) return {
+			masked: "runtime",
+			raw: "runtime"
+		};
+		if (!(/^runtime\s*:/.test(masked.slice(index)) || (previous === "{" || previous === ",") && /^["']runtime["']\s*:/.test(source.slice(index)))) continue;
+		const colon = source.indexOf(":", index + 7);
+		let end = colon + 1;
+		let nested = 0;
+		for (; end < masked.length; end++) if ("([{".includes(masked[end] || "")) nested++;
+		else if (")]}".includes(masked[end] || "")) {
+			if (nested === 0) break;
+			nested--;
+		} else if (masked[end] === "," && nested === 0) break;
+		return {
+			masked: masked.slice(colon + 1, end).trim(),
+			raw: source.slice(colon + 1, end).trim()
+		};
+	}
+	return {};
+}
+function extractAgentWorkflowName(file, fallbackName) {
+	const runtime = extractAgentRuntime(file);
+	if (!runtime) return void 0;
+	const workflowPattern = /^(?:(?:\/\*[\s\S]*?\*\/|\/\/[^\n]*(?:\n|$))\s*)*workflow\s*\(\s*(?:(?:\/\*[\s\S]*?\*\/|\/\/[^\n]*(?:\n|$))\s*)*(["'`])([^"'`]+)\1\s*(?:(?:\/\*[\s\S]*?\*\/|\/\/[^\n]*(?:\n|$))\s*)*\)(?:\s*(?:\/\*[\s\S]*?\*\/|\/\/[^\n]*(?:\n|$)))*\s*$/;
+	const match = workflowPattern.exec(runtime.raw || "");
+	if (match) return match[2] || fallbackName;
+	if (/^false(?:\s+as\s+const)?$/.test(runtime.masked || "")) return void 0;
+	const shorthand = /^([A-Za-z_$][\w$]*)$/.exec(runtime.masked || "")?.[1];
+	if (shorthand) {
+		const source = readFileSync(file, "utf8");
+		const masked = maskSourceLiterals(source);
+		const declaration = new RegExp(`\\b(?:const|let|var)\\s+${shorthand}\\s*(?::(?:=>|[^=])*?)?=\\s*`).exec(masked);
+		if (declaration) {
+			const start = declaration.index + declaration[0].length;
+			let end = start;
+			let depth = 0;
+			for (; end < masked.length; end++) if ("([{".includes(masked[end] || "")) depth++;
+			else if (")]}".includes(masked[end] || "")) depth--;
+			else if (depth === 0 && (masked[end] === ";" || masked[end] === "\n")) break;
+			const initializer = source.slice(start, end).trim();
+			if (/^false(?:\s+as\s+const)?$/.test(masked.slice(start, end).trim())) return void 0;
+			const shorthandWorkflow = workflowPattern.exec(initializer);
+			if (shorthandWorkflow) return shorthandWorkflow[2] || fallbackName;
+		}
+	}
+	return fallbackName;
+}
+function toAgentWorkflowDefinition(file, fallbackName) {
+	const name = extractAgentWorkflowName(file, fallbackName);
+	return name ? {
+		agentIdentity: fallbackName,
+		handler: file,
+		name,
+		source: "agent-workflow"
+	} : void 0;
+}
+function isWorkflowFolder(directory) {
+	return readDirEntries(directory).some((entry) => entry.isFile() && (entry.name.toLowerCase().startsWith("index.") || stepFilePattern.test(entry.name)) && isSourceFile(entry.name));
+}
+function findWorkflowFolders(workflowsDir) {
+	const folders = [];
+	for (const entry of readDirEntries(workflowsDir)) {
+		if (!entry.isDirectory() || entry.isSymbolicLink() || entry.name.startsWith(".")) continue;
+		const directory = resolve$1(workflowsDir, entry.name);
+		if (isWorkflowFolder(directory)) {
+			folders.push(directory);
+			continue;
+		}
+		folders.push(...findWorkflowFolders(directory));
+	}
+	return folders.sort();
+}
+function hasFolderAgentDefinition(directory) {
+	return readDirEntries(directory).some((entry) => entry.isFile() && (folderAgentFilePattern.test(entry.name) || folderAgentIndexFilePattern.test(entry.name)) && isSourceFile(entry.name));
+}
+function findFolderAgentFiles(agentsDir) {
+	const files = [];
+	for (const entry of readDirEntries(agentsDir)) {
+		if (entry.name.startsWith(".")) continue;
+		const absolute = resolve$1(agentsDir, entry.name);
+		if (entry.isDirectory() && !entry.isSymbolicLink()) {
+			if ((entry.name === "workspace" || entry.name === "skills") && hasFolderAgentDefinition(agentsDir)) continue;
+			files.push(...findFolderAgentFiles(absolute));
+			continue;
+		}
+		if (entry.isFile() && (folderAgentFilePattern.test(entry.name) || folderAgentIndexFilePattern.test(entry.name)) && !(folderAgentIndexFilePattern.test(entry.name) && readDirEntries(agentsDir).some((sibling) => sibling.isFile() && folderAgentFilePattern.test(sibling.name))) && isSourceFile(entry.name)) files.push(absolute);
+	}
+	return files.sort();
+}
+function discoverSuffixAgentWorkflowDefinitions(roots) {
+	return discoverDefinitions("agent workflow", [createSuffixDefinitionSource("agent-workflow", roots, agentSuffixPattern, normalizeSuffixAgentName, { createDefinition: ({ file, name }) => ({
+		handler: file,
+		name,
+		source: "agent-workflow"
+	}) })]).flatMap((definition) => {
+		const workflowDefinition = toAgentWorkflowDefinition(definition.handler, definition.name);
+		return workflowDefinition ? [workflowDefinition] : [];
+	});
+}
+function discoverFlatServerAgentWorkflowDefinitions(scanDirs) {
+	const folderAgentFiles = scanDirs.flatMap((scanDir) => findFolderAgentFiles(resolve$1(scanDir, "agents")));
+	const folderAgentDirs = new Set(folderAgentFiles.map((file) => normalize(resolve$1(file, ".."))));
+	const folderAgentTargets = new Set(folderAgentFiles.flatMap((file) => {
+		const source = readFileSync(file, "utf8");
+		const target = resolveAgentReExport(file, source, maskSourceLiterals(source));
+		const relativeTarget = target && normalize(relative(resolve$1(file, ".."), target));
+		return target && relativeTarget && relativeTarget !== ".." && !relativeTarget.startsWith("../") && isFolderAgentImplementationTarget(target) ? [normalize(target)] : [];
+	}));
+	return discoverDefinitions("agent workflow", [createDirectoryDefinitionSource("agent-workflow", scanDirs, "agents", {
+		normalizeName(directory, file) {
+			const fileName = normalize(file).split("/").pop();
+			const parent = normalize(resolve$1(file, ".."));
+			const name = normalizePathDefinitionName(directory, file);
+			if (folderAgentTargets.has(normalize(file))) return void 0;
+			if ([...folderAgentDirs].some((agentDir) => {
+				const path = normalize(relative(agentDir, file));
+				return path === "workspace" || path.startsWith("workspace/") || path === "skills" || path.startsWith("skills/");
+			})) return void 0;
+			if (folderAgentFilePattern.test(fileName) && parent !== normalize(directory) || legacyFolderAgentFilePattern.test(fileName) || agentEvalFilePattern.test(fileName)) return;
+			if (parent !== normalize(directory) && hasFolderAgentDefinition(parent) && extractAgentWorkflowName(file, "__vitehub_agent_workflow__") === void 0) return;
+			if (/^index\.(?:c|m)?[jt]s$/i.test(fileName) && hasFolderAgentDefinition(resolve$1(file, ".."))) return;
+			return name;
+		},
+		createDefinition: ({ file, name }) => ({
+			handler: file,
+			name,
+			source: "agent-workflow"
+		})
+	})]).flatMap((definition) => {
+		const workflowDefinition = toAgentWorkflowDefinition(definition.handler, definition.name);
+		return workflowDefinition ? [workflowDefinition] : [];
+	});
+}
+function discoverConfiguredServerAgentWorkflowDefinitions(scanDirs) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const scanDir of scanDirs) {
+		const agentsDir = resolve$1(scanDir, "agents");
+		const files = findFolderAgentFiles(agentsDir);
+		const targets = new Set(files.flatMap((file) => {
+			const source = readFileSync(file, "utf8");
+			const target = resolveAgentReExport(file, source, maskSourceLiterals(source));
+			const relativeTarget = target && normalize(relative(resolve$1(file, ".."), target));
+			return target && relativeTarget && relativeTarget !== ".." && !relativeTarget.startsWith("../") ? [normalize(target)] : [];
+		}));
+		for (const file of files) {
+			if (targets.has(normalize(file))) continue;
+			const name = normalize(relative(agentsDir, resolve$1(file, "..")));
+			if (!name || name === ".") continue;
+			const definition = toAgentWorkflowDefinition(file, name);
+			if (definition) registerDefinition(definitions, definition, "agent workflow");
+		}
+	}
+	return sortDefinitions(definitions);
+}
+function discoverAgentWorkflowDefinitions(roots, serverScanDirs) {
+	return mergeDefinitions("agent workflow", discoverSuffixAgentWorkflowDefinitions(roots), discoverFlatServerAgentWorkflowDefinitions(serverScanDirs), discoverConfiguredServerAgentWorkflowDefinitions(serverScanDirs));
+}
+function discoverWorkflowFolders(scanDirs, source) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const scanDir of scanDirs) {
+		const workflowsDir = resolve$1(scanDir, "workflows");
+		for (const directory of findWorkflowFolders(workflowsDir)) {
+			const files = readDirEntries(directory).filter((entry) => entry.isFile() && isSourceFile(entry.name)).map((entry) => resolve$1(directory, entry.name)).sort();
+			const index = files.find((file) => /\/index\.(?:c|m)?[jt]s$/i.test(normalize(file)));
+			const steps = files.filter((file) => stepFilePattern.test(file.split("/").pop()));
+			if (!index && steps.length === 0) continue;
+			const relativeName = normalize(relative(workflowsDir, directory));
+			registerDefinition(definitions, {
+				handler: index || directory,
+				name: relativeName,
+				source,
+				steps
+			}, "workflow");
+		}
+	}
+	return sortDefinitions(definitions);
+}
+function discoverFlatServerWorkflowDefinitions(scanDirs, source) {
+	return discoverDefinitions("workflow", [createDirectoryDefinitionSource("server-workflows", scanDirs, "workflows", {
+		normalizeName(directory, file) {
+			const normalizedFile = normalize(file);
+			const parent = normalize(resolve$1(file, ".."));
+			if (parent !== normalize(directory) && statSync(parent).isDirectory() && isWorkflowFolder(parent)) return;
+			const fileName = normalizedFile.split("/").pop();
+			if (fileName.toLowerCase().startsWith("index.") || stepFilePattern.test(fileName)) return;
+			return normalizePathDefinitionName(directory, file);
+		},
+		createDefinition: ({ file, name }) => ({
+			handler: file,
+			name,
+			source
+		})
+	})]);
+}
+function discoverWorkflowDefinitions(options) {
+	if (options.mode === "server-workflows") return mergeDefinitions("workflow", discoverFlatServerWorkflowDefinitions(options.scanDirs, "server-workflows"), discoverWorkflowFolders(options.scanDirs, "server-workflows"));
+	const roots = resolveDefinitionScanRoots(options.rootDir, options.scanDirs);
+	const serverScanDirs = roots.map((root) => resolve$1(root, "server"));
+	const folderDefinitions = discoverWorkflowFolders(serverScanDirs, "server-workflows");
+	return mergeDefinitions("workflow", discoverDefinitions("workflow", [createSuffixDefinitionSource("vite-suffix", roots, workflowSuffixPattern, normalizeSuffixWorkflowName, { createDefinition: ({ file, name }) => ({
+		handler: file,
+		name,
+		source: "vite-suffix"
+	}) })]), discoverFlatServerWorkflowDefinitions(serverScanDirs, "server-workflows"), folderDefinitions, discoverAgentWorkflowDefinitions(roots, serverScanDirs));
+}
+//#endregion
+//#region src/internal/vite-build.ts
+const workflowPackageName = "@vite-hub/workflow";
+const productName = "workflow";
+const generatedRegistryFileName = "registry.mjs";
+const cloudflareWorkflowWranglerConfigKeys = [
+	"compatibility_date",
+	"compatibility_flags",
+	"main",
+	"observability",
+	"workflows"
+];
+const cloudflareWorkflowWrapperImport = `import worker, { runViteHubWorkflowDefinition } from "./worker.mjs"`;
+const packageDir = computePackageDir(import.meta.url);
+const resolveRuntimeModule = (modulePath) => resolveRuntimeModule$1(packageDir, modulePath);
+const nodeBuiltinExternals = [...new Set([
+	"node:*",
+	...builtinModules,
+	...builtinModules.map((module) => `node:${module}`)
+])];
+const optionalAgentRuntimeExternals = ["@vite-hub/workspace", "@vite-hub/workspace/*"];
+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"
+];
+const folderAgentEntryPattern = /^(?:agent|index)\.(?:c|m)?[jt]s$/i;
+async function loadVercelWorkflowBuilders() {
+	try {
+		const require = createRequire(import.meta.url);
+		require.resolve("workflow");
+		require.resolve("@workflow/builders");
+	} catch (error) {
+		if (error.code === "MODULE_NOT_FOUND") return void 0;
+		throw error;
+	}
+	return await import("@workflow/builders");
+}
+async function createVercelWorkflowTransformPlugin(rootDir) {
+	const builders = await loadVercelWorkflowBuilders();
+	if (!builders) return void 0;
+	return builders.createSwcPlugin({
+		mode: "workflow",
+		projectRoot: rootDir
+	});
+}
+async function withVercelWorkflowPackageLink(rootDir, run) {
+	const target = join(rootDir, "node_modules", "workflow");
+	if (existsSync(target)) return await run();
+	const source = dirname(dirname(dirname(createRequire(import.meta.url).resolve("workflow/internal/builtins"))));
+	await mkdir(dirname(target), { recursive: true });
+	let ownsLink = false;
+	try {
+		await symlink(source, target, process.platform === "win32" ? "junction" : "dir");
+		ownsLink = true;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+	try {
+		return await run();
+	} finally {
+		if (ownsLink) await rm(target, { force: true });
+	}
+}
+async function buildVercelNativeWorkflowOutput(rootDir, definitions, aliases = {}) {
+	const builders = await loadVercelWorkflowBuilders();
+	if (!definitions.length) return;
+	const definitionDirs = [...new Set(definitions.map((definition) => dirname(definition.handler)))];
+	let hasNativeEntry = false;
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (file) => {
+		if (visited.has(file)) return;
+		visited.add(file);
+		if (!existsSync(file)) return;
+		if (statSync(file).isDirectory()) {
+			for (const entry of readdirSync(file, { withFileTypes: true })) {
+				if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+				if (entry.isDirectory() || /\.(?:c|m)?[jt]sx?$/.test(entry.name)) visit(join(file, entry.name));
+			}
+			return;
+		}
+		const source = readFileSync(file, "utf8");
+		if (/^\s*["']use workflow["'];?/m.test(source)) {
+			if (!definitionDirs.some((definitionDir) => {
+				const path = relative(definitionDir, file);
+				return !path.startsWith("..") && !isAbsolute(path);
+			})) throw new Error(`Native Vercel workflow entry ${JSON.stringify(relative(rootDir, file))} must be colocated with its discovered workflow definition.`);
+			hasNativeEntry = true;
+		}
+		for (const match of source.matchAll(/(?:from\s*|import\s*(?:\(\s*)?)["']([^"']+)["']/g)) {
+			const specifier = match[1];
+			const alias = Object.entries(aliases).find(([find]) => specifier === find || specifier.startsWith(`${find}/`));
+			const imported = specifier.startsWith(".") ? resolve(dirname(file), specifier) : alias ? resolve(rootDir, specifier.replace(alias[0], alias[1])) : void 0;
+			if (!imported) continue;
+			const extensions = [
+				".ts",
+				".tsx",
+				".mts",
+				".cts",
+				".js",
+				".jsx",
+				".mjs",
+				".cjs"
+			];
+			const sourceBase = imported.replace(/\.(?:m|c)?js$/, "");
+			const candidate = [
+				imported,
+				...extensions.map((extension) => `${sourceBase}${extension}`),
+				...extensions.map((extension) => join(imported, `index${extension}`))
+			].find((path) => existsSync(path) && statSync(path).isFile());
+			if (candidate) visit(candidate);
+		}
+	};
+	for (const definition of definitions) visit(definition.handler);
+	if (!hasNativeEntry) return;
+	if (!builders) throw new Error("Native Vercel workflows require the optional workflow and @workflow/builders peer dependencies.");
+	const outputConfigFile = resolve(rootDir, ".vercel", "output", "config.json");
+	const viteHubConfig = JSON.parse(await readFile(outputConfigFile, "utf8"));
+	const builder = new builders.VercelBuildOutputAPIBuilder({
+		buildTarget: "vercel-build-output-api",
+		dirs: definitionDirs,
+		projectRoot: rootDir,
+		stepsBundlePath: "./.well-known/workflow/v1/step.js",
+		webhookBundlePath: "./.well-known/workflow/v1/webhook.js",
+		workflowsBundlePath: "./.well-known/workflow/v1/flow.js",
+		workingDir: rootDir
+	});
+	await withVercelWorkflowPackageLink(rootDir, async () => await builder.build());
+	const workflowConfig = JSON.parse(await readFile(outputConfigFile, "utf8"));
+	await writeFile(outputConfigFile, `${JSON.stringify({
+		...workflowConfig,
+		...viteHubConfig,
+		routes: [...workflowConfig.routes ?? [], ...viteHubConfig.routes ?? []]
+	}, null, 2)}\n`, "utf8");
+}
+function isFolderAgentEntry(file) {
+	if (!folderAgentEntryPattern.test(basename(file))) return false;
+	return !(basename(file).toLowerCase().startsWith("agent.") && basename(dirname(file)) === "agents" && basename(dirname(dirname(file))) === "server");
+}
+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 renderRegistryImport(registryFile, file) {
+	return `import(${JSON.stringify(createImportPath(registryFile, file))})`;
+}
+function resolveAgentWorkspaceSourceRoot(file) {
+	const workspaceDirectory = join(dirname(file), "workspace");
+	return existsSync(workspaceDirectory) && statSync(workspaceDirectory).isDirectory() ? workspaceDirectory : dirname(file);
+}
+function resolveInstructionFile(file, seen) {
+	if (seen.has(file)) throw new Error(`[vitehub] Circular instruction import: ${file}.`);
+	seen.add(file);
+	try {
+		const replaceImports = (content) => content.replace(/@(\.\.?\/\S+)/g, (_token, rawSpecifier) => {
+			const trailing = rawSpecifier.match(/[.,;:!?)]*$/)?.[0] || "";
+			const specifier = rawSpecifier.slice(0, rawSpecifier.length - trailing.length);
+			return `${resolveInstructionFile(resolve(dirname(file), specifier), seen)}${trailing}`;
+		});
+		let fence;
+		return readFileSync(file, "utf8").split(/(?<=\n)/).map((line) => {
+			const marker = line.match(/^\s*(```|~~~)/)?.[1];
+			if (marker) {
+				fence = fence === marker ? void 0 : fence || marker;
+				return line;
+			}
+			if (fence) return line;
+			if (/^(?: {4}|\t)/.test(line)) return line;
+			return line.split(/(`+[^`]*`+)/g).map((segment, index) => index % 2 ? segment : replaceImports(segment)).join("");
+		}).join("");
+	} finally {
+		seen.delete(file);
+	}
+}
+function readAgentInstructions(file) {
+	const instructions = join(dirname(file), "instructions.md");
+	return existsSync(instructions) && statSync(instructions).isFile() ? resolveInstructionFile(instructions, /* @__PURE__ */ new Set()) : void 0;
+}
+function readAgentSkills(file) {
+	if (!isFolderAgentEntry(file)) return void 0;
+	const root = dirname(file);
+	const skillsRoot = join(root, "skills");
+	if (!existsSync(skillsRoot) || !statSync(skillsRoot).isDirectory()) return void 0;
+	const sources = {};
+	const visit = (directory) => {
+		for (const entry of readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+			const target = join(directory, entry.name);
+			if (entry.isDirectory()) visit(target);
+			else if (entry.isFile()) {
+				const workspacePath = relative(root, target).replace(/\\/g, "/");
+				sources[`__vitehubAgentSkill:${workspacePath}`] = {
+					content: readFileSync(target).toString("base64"),
+					encoding: "base64",
+					materialize: "build",
+					mount: "",
+					workspacePath
+				};
+			}
+		}
+	};
+	visit(skillsRoot);
+	return Object.keys(sources).length ? sources : void 0;
+}
+function renderAgentWorkflowRegistryEntry(registryFile, definition) {
+	return [
+		`  ${JSON.stringify(definition.name)}: async () => {`,
+		`    const cached = registryEntryCache.get(${JSON.stringify(definition.name)})`,
+		"    if (cached) return cached",
+		`    const loaded = await ${renderRegistryImport(registryFile, definition.handler)}`,
+		`    const agent = agentWithColocatedSkills(workspaceAgentWithSourceRoot("default" in loaded ? loaded.default : loaded, ${JSON.stringify(resolveAgentWorkspaceSourceRoot(definition.handler))}, ${JSON.stringify(readAgentInstructions(definition.handler))}), ${JSON.stringify(readAgentSkills(definition.handler))})`,
+		`    const entry = { handler: async (context) => await runAgentWorkflowDefinition(agent, { ...context, payload: { ...context.payload, agentIdentity: context.payload?.agentIdentity || { name: ${JSON.stringify(definition.agentIdentity || definition.name)} } } }, runAgentInline) }`,
+		`    registryEntryCache.set(${JSON.stringify(definition.name)}, entry)`,
+		"    return entry",
+		"  },"
+	].join("\n");
+}
+function renderWorkflowRegistryEntry(registryFile, definition) {
+	if (definition.source === "agent-workflow") return renderAgentWorkflowRegistryEntry(registryFile, definition);
+	if (!definition.steps?.length) return `  ${JSON.stringify(definition.name)}: async () => ${renderRegistryImport(registryFile, definition.handler)},`;
+	const workflowDirectory = /\.(?:c|m)?[jt]s$/i.test(definition.handler) ? dirname(definition.handler) : definition.handler;
+	const stepImports = definition.steps.map((step) => {
+		const stepName = relative(workflowDirectory, step);
+		return `{ name: ${JSON.stringify(stepName)}, run: (await ${renderRegistryImport(registryFile, step)}).default }`;
+	});
+	const hasIndex = /\.(?:c|m)?[jt]s$/i.test(definition.handler);
+	const indexImport = hasIndex ? `const index = await ${renderRegistryImport(registryFile, definition.handler)}` : "";
+	const handler = hasIndex ? `index.default?.handler ? index.default : takeInlineWorkflowDefinitionForModule(${JSON.stringify(definition.name)}, index) || { handler: index.default }` : "{ handler: async (context) => { let value = context.payload; for (const step of Object.values(context.steps || {})) value = await step(value); return value } }";
+	return [
+		`  ${JSON.stringify(definition.name)}: async () => {`,
+		`    const cached = registryEntryCache.get(${JSON.stringify(definition.name)})`,
+		"    if (cached) return cached",
+		indexImport ? `    ${indexImport}` : "",
+		`    const steps = [${stepImports.join(", ")}]`,
+		`    const definition = ${handler}`,
+		"    const entry = {",
+		"      ...definition,",
+		"      options: { ...definition.options, rootStep: false },",
+		"      handler: async (context) => {",
+		"        const workflowSteps = createWorkflowSteps(context, steps)",
+		"        return await definition.handler({ ...context, steps: workflowSteps })",
+		"      },",
+		"    }",
+		`    registryEntryCache.set(${JSON.stringify(definition.name)}, entry)`,
+		"    return entry",
+		"  },"
+	].filter(Boolean).join("\n");
+}
+function createWorkflowRegistryContents(registryFile, definitions, importBases = {}) {
+	const agentImportBase = importBases.agent ?? "@vite-hub/agent";
+	const workflowImportBase = importBases.workflow ?? "@vite-hub/workflow";
+	const needsWorkflowRuntime = definitions.some((definition) => definition.steps?.length);
+	const needsAgentRuntime = definitions.some((definition) => definition.source === "agent-workflow");
+	const needsRegistryEntryCache = needsWorkflowRuntime || needsAgentRuntime;
+	const installAgentWorkflowRuntime = needsAgentRuntime && importBases.workflow;
+	const workspaceDependencyRuntimeImports = importBases.workspace ? importBases.workspaceDependencies : void 0;
+	const imports = [
+		...needsAgentRuntime ? [
+			`import { runAgentInline } from ${JSON.stringify(agentImportBase)}`,
+			`import { agentWithColocatedSkills, runAgentWorkflowDefinition, workspaceAgentWithSourceRoot } from ${JSON.stringify(`${agentImportBase}/runtime/workflow`)}`,
+			...installAgentWorkflowRuntime ? [`import { setAgentWorkflowRuntimeLoaders } from ${JSON.stringify(`${agentImportBase}/server/internal`)}`] : []
+		] : [],
+		...needsWorkflowRuntime ? [`import { createWorkflowSteps } from ${JSON.stringify(`${workflowImportBase}/runtime/execute`)}`, `import { takeInlineWorkflowDefinitionForModule } from ${JSON.stringify(`${workflowImportBase}/runtime/state`)}`] : [],
+		...workspaceDependencyRuntimeImports ? [`import { setWorkspaceDependencyRuntimeLoaders } from ${JSON.stringify(`${importBases.workspace}/runtime`)}`] : []
+	];
+	return [
+		...imports,
+		imports.length ? "" : "",
+		...installAgentWorkflowRuntime ? [
+			"setAgentWorkflowRuntimeLoaders({",
+			`  state: () => import(${JSON.stringify(`${importBases.workflow}/runtime/state`)}),`,
+			`  workflow: () => import(${JSON.stringify(importBases.workflow)}),`,
+			"})",
+			""
+		] : [],
+		...workspaceDependencyRuntimeImports ? [
+			"setWorkspaceDependencyRuntimeLoaders({",
+			...workspaceDependencyRuntimeImports.sandbox ? [`  sandbox: () => import(${JSON.stringify(workspaceDependencyRuntimeImports.sandbox)}),`] : [],
+			...workspaceDependencyRuntimeImports.sandboxRuntimeState ? [`  sandboxRuntimeState: () => import(${JSON.stringify(workspaceDependencyRuntimeImports.sandboxRuntimeState)}),`] : [],
+			...workspaceDependencyRuntimeImports.shellWorkspace ? [`  shellWorkspace: () => import(${JSON.stringify(workspaceDependencyRuntimeImports.shellWorkspace)}),`] : [],
+			"})",
+			""
+		] : [],
+		...needsRegistryEntryCache ? ["const registryEntryCache = new Map()", ""] : [],
+		"const registry = {",
+		...definitions.map((definition) => renderWorkflowRegistryEntry(registryFile, definition)),
+		"}",
+		"",
+		"export default registry",
+		""
+	].join("\n");
+}
+function renderCloudflareWorkerWrapper(definitions) {
+	return [
+		definitions.length ? `import { WorkflowEntrypoint, waitUntil as viteHubWaitUntil } from "cloudflare:workers"` : `import { waitUntil as viteHubWaitUntil } from "cloudflare:workers"`,
+		cloudflareWorkflowWrapperImport,
+		"",
+		...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, framework) {
+	const installVercelWorkflowRuntime = spec.name === "vercel" && framework;
+	const imports = [
+		`import { ${spec.factory}${installVercelWorkflowRuntime ? ", setVercelWorkflowRuntimeModules" : ""} } from ${JSON.stringify(createImportPath(entryFile, resolveRuntimeModule(spec.runtimeModule)))}`,
+		`import workflowRegistry from ${JSON.stringify(`./${generatedRegistryFileName}`)}`,
+		...installVercelWorkflowRuntime ? [`import * as workflowApi from "workflow/api"`, `import * as workflowRuntime from "workflow/runtime"`] : []
+	];
+	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,
+		"",
+		installVercelWorkflowRuntime ? "setVercelWorkflowRuntimeModules(workflowApi, workflowRuntime)" : "",
+		`const workflowConfig = ${serializedWorkflowConfig}`,
+		...cloudflareDispatcher,
+		"",
+		`export default ${spec.factory}({`,
+		userAppEntry ? "  app: workflowApp," : "",
+		"  registry: workflowRegistry,",
+		"  workflow: workflowConfig,",
+		"})",
+		""
+	].filter(Boolean).join("\n");
+}
+async function writeProviderEntries(rootDir, workflow, importBases = {}) {
+	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, createWorkflowRegistryContents(registryFile, definitions, importBases), "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), Boolean(importBases.workflow)), "utf8");
+		entryFiles[spec.name] = entryFile;
+	}));
+	return {
+		cloudflareWorkerFile: entryFiles.cloudflare,
+		cloudflareWorkflowConfig,
+		definitions,
+		generatedDir,
+		providerDefinitions,
+		registryFile,
+		vercelServerFile: entryFiles.vercel
+	};
+}
+function createCloudflareOutput(rootDir, artifacts, providerImportAliases) {
+	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: {
+			alias: providerImportAliases,
+			conditions: [
+				"workerd",
+				"worker",
+				"browser",
+				"default"
+			],
+			external: [
+				"@cloudflare/sandbox",
+				"@vercel/blob",
+				"@vercel/functions",
+				"@vercel/queue",
+				"@vercel/sandbox",
+				"cloudflare:workers",
+				...nodeBuiltinExternals,
+				"workflow",
+				"workflow/api",
+				"workflow/runtime"
+			],
+			format: "esm",
+			platform: "neutral"
+		},
+		bundleOutfileName: "worker.mjs",
+		files: { "index.js": createCloudflareWorkflowWrapper(artifacts) },
+		outputRoot: createDefaultCloudflareOutputRoot(rootDir),
+		wranglerConfigKeys: cloudflareWorkflowWranglerConfigKeys,
+		wranglerConfig
+	};
+}
+function createCloudflareWorkflowWrapper(artifacts) {
+	return renderCloudflareWorkerWrapper((artifacts.cloudflareWorkflowConfig && artifacts.cloudflareWorkflowConfig.provider === "cloudflare" ? artifacts.cloudflareWorkflowConfig : false) ? artifacts.providerDefinitions : []);
+}
+async function createCloudflareWorkflowCleanup(rootDir) {
+	const outputRoot = createDefaultCloudflareOutputRoot(rootDir);
+	let ownsWrapper = false;
+	try {
+		ownsWrapper = (await readFile(resolve(outputRoot, "index.js"), "utf8")).includes(cloudflareWorkflowWrapperImport);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return {
+		fileNames: ownsWrapper ? ["index.js", "worker.mjs"] : ["worker.mjs"],
+		outputRoot,
+		wranglerConfigOwnership: { keys: ownsWrapper ? cloudflareWorkflowWranglerConfigKeys : ["workflows"] }
+	};
+}
+function createVercelOutput(artifacts, workflowTransformPlugin, frameworkImportBase, providerImportAliases, serverFunctionName) {
+	return {
+		bundleEntry: artifacts.vercelServerFile,
+		bundleOptions: {
+			alias: providerImportAliases,
+			external: [
+				"@cloudflare/sandbox",
+				...frameworkImportBase ? [] : optionalAgentRuntimeExternals,
+				"cloudflare:workers",
+				...nodeBuiltinExternals,
+				...!frameworkImportBase ? [
+					"workflow",
+					"workflow/api",
+					"workflow/runtime"
+				] : []
+			],
+			format: "esm",
+			platform: "node",
+			plugins: workflowTransformPlugin ? [workflowTransformPlugin] : []
+		},
+		...serverFunctionName ? { function: {
+			kind: "isolated",
+			name: serverFunctionName
+		} } : {}
+	};
+}
+async function generateProviderOutputs(options) {
+	const artifacts = await writeProviderEntries(options.rootDir, options.workflow, {
+		agent: options.agentImportBase,
+		workflow: options.importBase,
+		workspace: options.workspaceImportBase,
+		workspaceDependencies: options.workspaceDependencyRuntimeImports
+	});
+	const cloudflareWorkflowConfig = resolveWorkflowConfig(options.workflow, "cloudflare");
+	const vercelWorkflowConfig = resolveWorkflowConfig(options.workflow, "vercel");
+	const cloudflareOutput = cloudflareWorkflowConfig && cloudflareWorkflowConfig.provider === "cloudflare" ? createCloudflareOutput(options.rootDir, artifacts, options.providerImportAliases) : void 0;
+	const workflowTransformPlugin = vercelWorkflowConfig && vercelWorkflowConfig.provider === "vercel" ? await createVercelWorkflowTransformPlugin(options.rootDir) : void 0;
+	const vercelOutput = vercelWorkflowConfig && vercelWorkflowConfig.provider === "vercel" ? createVercelOutput(artifacts, workflowTransformPlugin, options.importBase, options.providerImportAliases, options.serverFunctionName) : void 0;
+	const writeOutputs = async () => {
+		await writeProviderDeploymentOutputs({
+			clientOutDir: options.clientOutDir,
+			cloudflare: cloudflareOutput,
+			cleanup: { cloudflare: cloudflareOutput ? void 0 : () => createCloudflareWorkflowCleanup(options.rootDir) },
+			rootDir: options.rootDir,
+			...vercelOutput ? { vercel: vercelOutput } : {}
+		});
+		if (vercelOutput) await buildVercelNativeWorkflowOutput(options.rootDir, artifacts.providerDefinitions, options.providerImportAliases);
+	};
+	if (workflowTransformPlugin && options.importBase) await withVercelWorkflowPackageLink(options.rootDir, writeOutputs);
+	else await writeOutputs();
+	return artifacts;
+}
+//#endregion
+//#region src/vite.ts
+const mergeNoExternal = createNoExternalMerger(workflowPackageName);
+function resolveStringAliases(config) {
+	const aliases = {};
+	for (const alias of config.resolve.alias) if (typeof alias.find === "string" && typeof alias.replacement === "string") aliases[alias.find] = alias.replacement;
+	return aliases;
+}
+function hubWorkflow(options) {
+	const internalOptions = options;
+	let resolved;
+	let workflow = options;
+	return {
+		name: "@vite-hub/workflow/vite",
+		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({
+				agentImportBase: internalOptions?.agentImportBase,
+				clientOutDir: resolved.build.outDir,
+				importBase: internalOptions?.importBase,
+				providerImportAliases: {
+					...resolveStringAliases(resolved),
+					...internalOptions?.providerImportAliases
+				},
+				rootDir: resolved.root,
+				serverFunctionName: resolveNitroVercelFunctionName(resolved, "workflow"),
+				workflow,
+				workspaceDependencyRuntimeImports: internalOptions?.workspaceDependencyRuntimeImports,
+				workspaceImportBase: internalOptions?.workspaceImportBase
+			});
+		}
+	};
+}
+//#endregion
+export { hubWorkflow };