@hazejs/vite 0.0.0-stage → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,1685 @@
+import { builtinModules, createRequire } from "node:module";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import process from "node:process";
+import { createBuilder, createServer, createServerModuleRunner, loadConfigFromFile, mergeConfig, normalizePath, preview } from "vite";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
+import { nodeUpgradeHandler, registerNodeServer, renderErrorPage, webSocketConfig, webSocketPlugin } from "@hazejs/core";
+import { toNodeHandler } from "srvx/node";
+import { consola } from "consola";
+import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { traceNodeModules } from "nf3";
+import { NodeNativePackages, NonBundleablePackages } from "nf3/db";
+import { execFileSync, spawn } from "node:child_process";
+import { connect, createServer as createServer$1 } from "node:net";
+import { pathToFileURL } from "node:url";
+import { parseEnv } from "node:util";
+import { serve } from "srvx";
+// src/constants.ts
+/** 产品更名时与 `@hazejs/core` 的 constants.ts 一起修改 */
+const PLUGIN_NAME = "hazejs";
+const CONFIG_BASENAME = "haze.config";
+const VIRTUAL_MODULES = {
+	/** 编译期发现的配置 / 路由 / 提供者 / 异常处理器 */
+	manifest: "virtual:haze/manifest",
+	/** `createApp(options)`：用 manifest 创建应用 */
+	app: "virtual:haze/app",
+	/** 生产环境入口：创建应用并监听端口 */
+	serverEntry: "virtual:haze/server-entry",
+	/** 打包进产物的迁移文件（database/ 下的 drizzle-kit 输出） */
+	migrations: "virtual:haze/migrations",
+	/** 生产迁移脚本入口（migrate.mjs） */
+	migrateEntry: "virtual:haze/migrate-entry",
+	/** 队列 worker 与定时任务入口（worker.mjs） */
+	workerEntry: "virtual:haze/worker-entry"
+};
+// src/config.ts
+function defineHazeConfig(config) {
+	return config;
+}
+const EXTENSIONS = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+/** 存在 vite.config.* 视为全栈项目：由用户的 Vite 配置（含 haze() 插件）驱动 */
+function findViteConfig(root) {
+	return EXTENSIONS.map((ext) => resolve(root, `vite.config.${ext}`)).find((file) => existsSync(file));
+}
+/** 读取项目根目录下的 `haze.config.ts`（可选） */
+async function loadHazeConfig(root, mode = "development") {
+	const configFile = EXTENSIONS.map((ext) => resolve(root, `${CONFIG_BASENAME}.${ext}`)).find((file) => existsSync(file));
+	let config = {};
+	if (configFile) config = (await loadConfigFromFile({
+		command: "serve",
+		mode
+	}, configFile, root, "silent"))?.config ?? {};
+	return {
+		root,
+		srcDir: resolve(root, config.srcDir ?? "."),
+		port: config.port ?? 3e3,
+		host: config.host,
+		outDir: resolve(root, config.outDir ?? "dist"),
+		typegen: config.typegen ?? true,
+		preset: config.preset,
+		cloudflare: config.cloudflare,
+		vercel: config.vercel,
+		externals: config.externals,
+		vite: config.vite ?? {},
+		configFile
+	};
+}
+// src/typegen.ts
+const SOURCE_RE$1 = /\.[cm]?[jt]s$/;
+/** 生成文件位置（需在 tsconfig 的 include 中加入 `.haze/types/**\/*.d.ts`） */
+function typesFile(root) {
+	return join(root, ".haze", "types", "haze.d.ts");
+}
+/** 生成配置键与命名路由的类型声明（模块扩充 @hazejs/core） */
+function generateTypes({ root, srcDir, routes }) {
+	const file = typesFile(root);
+	const typesDir = join(file, "..");
+	const configDir = join(srcDir, "config");
+	const configs = (existsSync(configDir) ? readdirSync(configDir).filter((name) => SOURCE_RE$1.test(name) && !name.endsWith(".d.ts")).sort() : []).map((name) => {
+		const key = name.replace(SOURCE_RE$1, "");
+		let path = normalizePath(relative(typesDir, join(configDir, key)));
+		if (!path.startsWith(".")) path = `./${path}`;
+		return {
+			key,
+			line: `    ${JSON.stringify(key)}: ConfigValue<typeof import(${JSON.stringify(path)}).default>`
+		};
+	});
+	const policyDir = join(srcDir, "app", "policy");
+	const policies = (existsSync(policyDir) ? readdirSync(policyDir).filter((name) => SOURCE_RE$1.test(name) && !name.endsWith(".d.ts")).sort() : []).map((name) => {
+		const key = name.replace(SOURCE_RE$1, "");
+		let path = normalizePath(relative(typesDir, join(policyDir, key)));
+		if (!path.startsWith(".")) path = `./${path}`;
+		return {
+			key,
+			line: `    ${JSON.stringify(key)}: typeof import(${JSON.stringify(path)}).default`
+		};
+	});
+	const named = routes.filter((route) => route.name).map((route) => {
+		const params = [...route.path.matchAll(/:(\w+)/g)].map((match) => match[1]);
+		const type = params.length ? `{ ${params.map((param) => `${param}: string | number`).join(", ")} }` : "Record<never, never>";
+		return {
+			name: route.name,
+			line: `    ${JSON.stringify(route.name)}: ${type}`
+		};
+	}).sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		file,
+		content: `// 由 ${PLUGIN_NAME} 自动生成（haze dev / haze typegen），请勿手动修改
+import type { ConfigValue } from '@hazejs/core'
+
+declare module '@hazejs/core' {
+  interface GeneratedConfig {
+${configs.map((item) => item.line).join("\n")}
+  }
+
+  interface RouteNames {
+${named.map((item) => item.line).join("\n")}
+  }
+
+  interface GeneratedPolicies {
+${policies.map((item) => item.line).join("\n")}
+  }
+}
+
+export {}
+`,
+		configs: configs.map((item) => item.key),
+		routes: named.map((item) => item.name),
+		policies: policies.map((item) => item.key)
+	};
+}
+/** 内容变化时才写入，避免触发编辑器与文件监听的无谓刷新 */
+async function writeTypes(options) {
+	const { content, ...result } = generateTypes(options);
+	if (await readFile(result.file, "utf8").catch(() => void 0) === content) return {
+		...result,
+		changed: false
+	};
+	await mkdir(join(result.file, ".."), { recursive: true });
+	await writeFile(result.file, content);
+	return {
+		...result,
+		changed: true
+	};
+}
+// src/host.ts
+function createAppHost({ vite, api, debounce = 30 }) {
+	const root = vite.config.root;
+	const runner = createServerModuleRunner(vite.environments.ssr, { hmr: false });
+	const listeners = /* @__PURE__ */ new Set();
+	let current;
+	let lastError;
+	let started;
+	let queue;
+	let timer;
+	let closed = false;
+	async function load(file) {
+		const start = performance.now();
+		try {
+			runner.clearCache();
+			const { createApp } = await runner.import(VIRTUAL_MODULES.app);
+			const app = await createApp({ mode: "development" });
+			const previous = current;
+			current = {
+				app,
+				active: 0
+			};
+			lastError = void 0;
+			if (previous) retire(previous);
+			await generateTypes(app);
+			return {
+				ok: true,
+				file,
+				duration: performance.now() - start
+			};
+		} catch (error) {
+			lastError = error;
+			return {
+				ok: false,
+				file,
+				duration: performance.now() - start,
+				error
+			};
+		}
+	}
+	async function generateTypes(app) {
+		const { srcDir, typegen } = api.settings();
+		if (!typegen) return;
+		try {
+			await writeTypes({
+				root,
+				srcDir,
+				routes: app.router.list()
+			});
+		} catch (error) {
+			consola.warn(`[${PLUGIN_NAME}] failed to generate types`, error);
+		}
+	}
+	async function retire(slot) {
+		if (slot.active > 0) await new Promise((resolve) => slot.onIdle = resolve);
+		try {
+			await slot.app.dispose({ reason: "hmr" });
+		} catch (error) {
+			consola.warn(`[${PLUGIN_NAME}] failed to dispose previous app`, error);
+		}
+	}
+	function reload(file) {
+		const run = async () => {
+			const result = await load(file);
+			report(result);
+			return result;
+		};
+		queue = (queue ?? Promise.resolve()).then(run, run);
+		return queue;
+	}
+	function start() {
+		started ??= reload();
+		return started;
+	}
+	function report(result) {
+		listeners.forEach((listener) => listener(result));
+		const ms = `${Math.round(result.duration)}ms`;
+		if (result.ok && result.file) consola.success(`[${PLUGIN_NAME}] reloaded in ${ms} (${result.file})`);
+		else if (!result.ok) consola.error(`[${PLUGIN_NAME}] ${result.file ? `reload failed (${result.file}), still serving the previous version` : "failed to start"}\n`, result.error);
+	}
+	const unsubscribe = api.onReload((event) => {
+		if (closed || !started) return;
+		const file = normalizePath(relative(root, event.file));
+		clearTimeout(timer);
+		timer = setTimeout(() => void reload(file), debounce);
+	});
+	async function fetch(request) {
+		if (!started) await start();
+		await started;
+		const slot = current;
+		if (!slot) return errorResponse(lastError, request, root);
+		slot.active++;
+		try {
+			return await slot.app.fetch(request);
+		} finally {
+			slot.active--;
+			if (slot.active === 0) slot.onIdle?.();
+		}
+	}
+	return {
+		get app() {
+			return current?.app;
+		},
+		start,
+		fetch,
+		reload,
+		import: (id) => runner.import(id),
+		onReload(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		async close() {
+			if (closed) return;
+			closed = true;
+			unsubscribe();
+			clearTimeout(timer);
+			await queue;
+			await current?.app.dispose({ reason: "shutdown" });
+			current = void 0;
+			await runner.close();
+		}
+	};
+}
+/** 应用启动失败时的响应：浏览器显示错误页，其余返回 JSON */
+function errorResponse(error, request, rootDir) {
+	const err = error instanceof Error ? error : new Error(String(error ?? "Application is starting"));
+	const message = `[${PLUGIN_NAME}] ${err.message}`;
+	if (request.headers.get("accept")?.includes("text/html")) return new Response(renderErrorPage({
+		error: err,
+		status: 500,
+		message,
+		request,
+		rootDir
+	}), {
+		status: 500,
+		headers: { "content-type": "text/html; charset=utf-8" }
+	});
+	return Response.json({
+		code: 500,
+		message,
+		stack: err.stack?.split("\n").map((line) => line.trim())
+	}, { status: 500 });
+}
+// src/presets/deps.ts
+/** 数据库驱动：含原生二进制 / WASM / 可选原生依赖，不打包，运行时从 node_modules 加载（或追踪进产物） */
+const DRIVER_PACKAGES = [
+	"@aws-sdk/client-s3",
+	"@aws-sdk/client-sesv2",
+	"@aws-sdk/lib-storage",
+	"@aws-sdk/s3-request-presigner",
+	"@libsql/client",
+	"@socket.io/bun-engine",
+	"@socket.io/redis-adapter",
+	"@upstash/redis",
+	"bullmq",
+	"ioredis",
+	"libsql",
+	"@electric-sql/pglite",
+	"mongodb",
+	"mysql2",
+	"nodemailer",
+	"postgres",
+	"socket.io"
+];
+/** Edge（Workers）上无法运行的驱动：构建时替换为调用即报错的空模块 */
+const EDGE_UNSUPPORTED_DRIVERS = [
+	"@electric-sql/pglite",
+	"@socket.io/bun-engine",
+	"@socket.io/redis-adapter",
+	"bullmq",
+	"socket.io",
+	"ioredis",
+	"mysql2",
+	"mongodb",
+	"libsql",
+	"nodemailer"
+];
+/** 匹配“除给定包外的全部依赖”，用作 ssr.noExternal */
+function bundleAllExcept(names) {
+	return new RegExp(`^(?!(?:${names.map((name) => name.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")).join("|")})(?:/|$))`);
+}
+/**
+* 匹配给定包（含子路径）的正则，用作 Rolldown 的 external：
+* 不经 Vite 解析直接保留导入，项目未安装的可选驱动（如 drizzle-orm 的 mysql2 / pglite）
+* 不会被替换为没有导出的空模块而导致构建失败
+*/
+function externalPattern(names) {
+	return new RegExp(`^(?:${names.map((name) => name.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")).join("|")})(?:/|$)`);
+}
+/** 不打包、运行时从 node_modules 加载的包：数据库驱动、原生模块、已知无法打包的包与 traceDeps */
+function externalPackages(options = {}) {
+	const inline = new Set(options.inline);
+	return [.../* @__PURE__ */ new Set([
+		...DRIVER_PACKAGES,
+		...NodeNativePackages,
+		...NonBundleablePackages,
+		...(options.traceDeps ?? []).map((name) => name.replace(/\*$/, ""))
+	])].filter((name) => !inline.has(name));
+}
+/** 按平台发布的原生二进制包，如 @libsql/darwin-arm64、@rollup/rollup-linux-x64-gnu */
+const PLATFORM_PACKAGE_RE = /(?:^|[-/])(?:darwin|win32|linux|freebsd)-(?:x64|arm64|ia32|arm)/;
+/**
+* 用 nf3（@vercel/nft）从产物入口追踪运行时实际加载的文件，复制为 `<serverDir>/node_modules`。
+* 同名多版本放在 `node_modules/.nf3/<name>@<version>` 并链接到依赖方。
+*/
+async function traceDependencies(serverDir, root, options) {
+	const inputs = walk(serverDir).filter((file) => /\.m?js$/.test(file) && !file.startsWith(join(serverDir, "client")));
+	const names = options.traceDeps ?? [];
+	const layout = await traceNodeModules(inputs, {
+		rootDir: root,
+		outDir: serverDir,
+		...options.conditions && { conditions: [
+			...options.conditions,
+			"import",
+			"default"
+		] },
+		traceInclude: names.filter((name) => !name.endsWith("*")),
+		fullTraceInclude: names.filter((name) => name.endsWith("*")).map((name) => name.slice(0, -1)),
+		chmod: true
+	});
+	const packages = Object.keys(layout.packages).sort();
+	return {
+		packages,
+		foreignNative: (options.platform ?? process.platform) === process.platform ? [] : packages.filter((name) => PLATFORM_PACKAGE_RE.test(name) || NodeNativePackages.includes(name))
+	};
+}
+const builtins = new Set(builtinModules);
+/** 产物中的 import / export ... from / import() 语句（Rolldown 输出的规范格式） */
+const IMPORT_RE = /(?:^|[;\n])\s*(?:import|export)\s[^;]*?\bfrom\s*["']([^"']+)["']|(?:^|[;\n])\s*import\s*["']([^"']+)["']|\bimport\(\s*["']([^"']+)["']\s*\)/g;
+const PACKAGE_RE = /^(?:@[\w.~-]+\/)?[\w.~-]+(?:\/.*)?$/;
+/** 扫描产物中的裸模块导入，得到运行时仍需要的包名 */
+function scanExternals(dir) {
+	const names = /* @__PURE__ */ new Set();
+	for (const file of walk(dir)) {
+		if (!/\.m?js$/.test(file)) continue;
+		for (const match of readFileSync(file, "utf8").matchAll(IMPORT_RE)) {
+			const specifier = match[1] ?? match[2] ?? match[3];
+			if (!specifier || !PACKAGE_RE.test(specifier) || specifier.startsWith(".") || builtins.has(specifier.split("/")[0])) continue;
+			names.add(packageName$2(specifier));
+		}
+	}
+	return [...names].sort();
+}
+/** 从 root 开始按 Node 解析规则查找已安装的包（跟随 pnpm 的符号链接） */
+function findInstalled(name, from) {
+	for (let dir = from;; dir = dirname(dir)) {
+		const candidate = join(dir, "node_modules", name, "package.json");
+		if (existsSync(candidate)) {
+			const real = realpathSync(dirname(candidate));
+			const { version } = JSON.parse(readFileSync(join(real, "package.json"), "utf8"));
+			return {
+				name,
+				version,
+				dir: real
+			};
+		}
+		if (dirname(dir) === dir) return void 0;
+	}
+}
+/** 生成只包含运行时依赖的 package.json（Docker 中 npm install 使用） */
+async function writeRuntimePackageJson(file, root, names) {
+	const manifest = join(root, "package.json");
+	const project = existsSync(manifest) ? JSON.parse(readFileSync(manifest, "utf8")) : {};
+	const dependencies = {};
+	for (const name of names) {
+		const found = findInstalled(name, root);
+		if (found) dependencies[name] = found.version;
+	}
+	await writeFile(file, `${JSON.stringify({
+		name: project.name ?? "app",
+		private: true,
+		type: "module",
+		dependencies
+	}, null, 2)}\n`);
+}
+function packageName$2(specifier) {
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function walk(dir) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) return entry.name === "node_modules" ? [] : walk(path);
+		return [path];
+	});
+}
+// src/presets/types.ts
+const PRESET_NAMES = [
+	"node",
+	"bun",
+	"deno",
+	"docker",
+	"cloudflare",
+	"vercel",
+	"netlify",
+	"aws-lambda"
+];
+// src/presets/index.ts
+const header = `import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+import { createApp } from '${VIRTUAL_MODULES.app}'
+`;
+function staticOption(context, layout) {
+	if (!context.fullstack || !layout.staticFromServer) return "";
+	return `static: { dir: fileURLToPath(new URL(${JSON.stringify(layout.staticFromServer)}, import.meta.url)), spaFallback: true, exclude: ${JSON.stringify(context.prefixes)} },`;
+}
+/** 常驻进程：监听端口 */
+function listenEntry(context) {
+	return `${header}
+const app = await createApp({ mode: 'production', ${staticOption(context, context.layout)} })
+app.serve({
+  port: Number(process.env.PORT) || ${context.port},
+  hostname: process.env.HOST || ${JSON.stringify(context.host ?? "0.0.0.0")},
+})
+`;
+}
+/** 按需创建应用（Serverless / Edge 冷启动时） */
+function lazyApp(context, extra = "") {
+	return `${header}
+let app
+function getApp() {
+  return (app ??= createApp({ mode: 'production', ${staticOption(context, context.layout)} ${extra} }))
+}
+void process
+void fileURLToPath
+`;
+}
+/**
+* 生产迁移脚本（migrate.mjs）：迁移文件已打包进产物，不需要源码与开发工具链。
+* `node migrate.mjs [--connection <name>] [--all]`
+*/
+function migrateEntryCode() {
+	return `import process from 'node:process'
+import { parseArgs } from 'node:util'
+import { runMigrations } from '@hazejs/orm'
+import { createApp } from '${VIRTUAL_MODULES.app}'
+import { files } from '${VIRTUAL_MODULES.migrations}'
+
+const { values } = parseArgs({
+  options: {
+    connection: { type: 'string', short: 'c' },
+    all: { type: 'boolean', default: false },
+  },
+})
+const app = await createApp({ mode: 'production' })
+try {
+  for (const result of await runMigrations({ files, connection: values.connection, all: values.all })) {
+    app.logger.info(result.skipped
+      ? \`[\${result.connection}] skipped (\${result.skipped})\`
+      : \`[\${result.connection}] \${result.applied} of \${result.total} migrations applied (\${result.folder})\`)
+  }
+}
+catch (error) {
+  app.logger.error('Migration failed', error)
+  process.exitCode = 1
+}
+finally {
+  await app.dispose()
+}
+`;
+}
+function serverLayout(context, dir = "server") {
+	return {
+		serverDir: join(context.outDir, dir),
+		clientDir: context.fullstack ? join(context.outDir, "client") : void 0,
+		staticFromServer: "../client"
+	};
+}
+function packageName$1(root) {
+	const file = join(root, "package.json");
+	return ((existsSync(file) ? JSON.parse(readFileSync(file, "utf8")).name : void 0) ?? "hazejs-app").replace(/^@[^/]+\//, "").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+}
+const rel = (context, path) => normalizePath(relative(context.root, path)) || ".";
+/**
+* 队列 worker 与定时任务（worker.mjs）：
+* `node worker.mjs queue [--queue a,b] [--concurrency 5] [--connection redis]`、
+* `node worker.mjs schedule`（常驻）、`node worker.mjs schedule:run`（执行一次到期任务）
+*/
+function workerEntryCode() {
+	return `import process from 'node:process'
+import { parseArgs } from 'node:util'
+import { QueueManager, Scheduler } from '@hazejs/core'
+import { createApp } from '${VIRTUAL_MODULES.app}'
+
+const { positionals, values } = parseArgs({
+  allowPositionals: true,
+  options: {
+    queue: { type: 'string', short: 'q' },
+    concurrency: { type: 'string', short: 'c' },
+    connection: { type: 'string' },
+  },
+})
+const command = positionals[0] ?? 'queue'
+const app = await createApp({ mode: 'production' })
+const controller = new AbortController()
+let stopQueue
+const shutdown = async () => {
+  controller.abort()
+  // 等待执行中的任务完成
+  await stopQueue?.()
+  await app.dispose()
+  process.exit(0)
+}
+process.once('SIGTERM', shutdown)
+process.once('SIGINT', shutdown)
+
+if (command === 'queue') {
+  const queues = values.queue?.split(',').map(name => name.trim()).filter(Boolean) ?? ['default']
+  const worker = await app.make(QueueManager).work({ connection: values.connection, queues, concurrency: Number(values.concurrency ?? 1) })
+  stopQueue = worker.stop
+  app.logger.info(\`Queue worker started: \${queues.join(', ')}\`)
+}
+else if (command === 'schedule') {
+  app.logger.info(\`Scheduler started: \${app.make(Scheduler).tasks().length} task(s)\`)
+  await app.make(Scheduler).work(controller.signal)
+}
+else if (command === 'schedule:run') {
+  const runs = await app.make(Scheduler).runDue()
+  await app.dispose()
+  process.exit(runs.some(run => run.status === 'failed') ? 1 : 0)
+}
+else {
+  app.logger.error(\`Unknown command "\${command}" (queue | schedule | schedule:run)\`)
+  await app.dispose()
+  process.exit(1)
+}
+`;
+}
+function workerHint(context, command) {
+	const worker = rel(context, join(context.layout.serverDir, "worker.mjs"));
+	return `\nQueue worker: ${command} ${worker} queue${context.schedules ? `\nScheduler: ${command} ${worker} schedule` : ""}`;
+}
+function migrateHint(context, command) {
+	return context.orm ? `\nMigrate: ${command} ${rel(context, join(context.layout.serverDir, "migrate.mjs"))}` : "";
+}
+const presets = {
+	"node": {
+		name: "node",
+		bundle: "drivers-external",
+		trace: "default",
+		layout: (context) => context.fullstack ? serverLayout(context) : {
+			serverDir: context.outDir,
+			clientDir: void 0,
+			staticFromServer: void 0
+		},
+		migrateScript: true,
+		entry: listenEntry,
+		hint: (context) => `Run: node ${rel(context, join(context.layout.serverDir, "index.mjs"))}  (or haze start)${migrateHint(context, "node")}${workerHint(context, "node")}`
+	},
+	"bun": {
+		name: "bun",
+		bundle: "drivers-external",
+		trace: "default",
+		conditions: [
+			"bun",
+			"module",
+			"node",
+			"production"
+		],
+		layout: (context) => context.fullstack ? serverLayout(context) : {
+			serverDir: context.outDir,
+			clientDir: void 0,
+			staticFromServer: void 0
+		},
+		migrateScript: true,
+		entry: listenEntry,
+		hint: (context) => `Run: bun ${rel(context, join(context.layout.serverDir, "index.mjs"))}${migrateHint(context, "bun")}${workerHint(context, "bun")}`
+	},
+	"deno": {
+		name: "deno",
+		bundle: "drivers-external",
+		trace: "default",
+		conditions: [
+			"deno",
+			"module",
+			"node",
+			"production"
+		],
+		layout: serverLayout,
+		migrateScript: true,
+		entry: listenEntry,
+		hint: (context) => `Run: deno run -A ${rel(context, join(context.layout.serverDir, "index.mjs"))}${migrateHint(context, "deno run -A")}${workerHint(context, "deno run -A")}`
+	},
+	"docker": {
+		name: "docker",
+		bundle: "drivers-external",
+		layout: serverLayout,
+		migrateScript: true,
+		entry: listenEntry,
+		async finalize(context) {
+			await writeRuntimePackageJson(join(context.outDir, "package.json"), context.root, context.externals);
+			await writeFile(join(context.outDir, "Dockerfile"), `# 由 haze build --preset docker 生成
+FROM node:22-slim
+WORKDIR /app
+ENV NODE_ENV=production
+ENV PORT=${context.port}
+COPY package.json ./
+RUN npm install --omit=dev --no-audit --no-fund
+COPY . .
+EXPOSE ${context.port}
+CMD ["node", "server/index.mjs"]
+`);
+			await writeFile(join(context.outDir, ".dockerignore"), "node_modules\nDockerfile\n.dockerignore\n");
+		},
+		hint: (context) => `Build image: docker build -t ${packageName$1(context.root)} ${rel(context, context.outDir)}\nRun: docker run -p ${context.port}:${context.port} -e APP_KEY=<key> ${packageName$1(context.root)}${context.orm ? `\nMigrate: docker run --rm ${packageName$1(context.root)} node server/migrate.mjs` : ""}\nQueue worker: docker run ${packageName$1(context.root)} node server/worker.mjs queue${context.schedules ? `\nScheduler: docker run ${packageName$1(context.root)} node server/worker.mjs schedule` : ""}`
+	},
+	"aws-lambda": {
+		name: "aws-lambda",
+		bundle: "drivers-external",
+		trace: "always",
+		runtimePlatform: "linux",
+		layout: (context) => ({
+			serverDir: join(context.outDir, "lambda"),
+			clientDir: context.fullstack ? join(context.outDir, "lambda", "client") : void 0,
+			staticFromServer: "./client"
+		}),
+		entry: (context) => `${lazyApp(context)}
+import { createLambdaHandler } from '@hazejs/core'
+
+/** API Gateway（HTTP API / REST API）、ALB、Function URL 事件 */
+export const handler = createLambdaHandler(async () => (await getApp()).fetch)
+
+import { Scheduler } from '@hazejs/core'
+
+/** 定时任务：handler 设为 index.schedule，由 EventBridge 每分钟触发（rate(1 minute)） */
+export async function schedule(event = {}) {
+  const runs = await (await getApp()).make(Scheduler).runDue(event.time ? new Date(event.time) : new Date())
+  return runs.map(({ name, status, reason }) => ({ name, status, reason }))
+}
+${context.orm ? `
+import { runMigrations } from '@hazejs/orm'
+import { files } from '${VIRTUAL_MODULES.migrations}'
+
+/** 生产迁移：handler 设为 index.migrate 的函数（或直接调用），事件 { connection?, all? } */
+export async function migrate(event = {}) {
+  await getApp()
+  return runMigrations({ files, connection: event.connection, all: event.all })
+}
+` : ""}`,
+		async finalize(context) {
+			const dir = context.layout.serverDir;
+			await writeFile(join(dir, "package.json"), "{ \"type\": \"module\" }\n");
+		},
+		hint: (context) => `Zip ${rel(context, context.layout.serverDir)} and set the Lambda handler to index.handler (runtime nodejs22.x), with APP_KEY in the environment${context.orm ? "\nMigrate: invoke the same bundle with handler index.migrate (event: { \"connection\"?: string, \"all\"?: boolean })" : ""}${context.schedules ? "\nScheduler: a function with handler index.schedule, triggered by an EventBridge rule rate(1 minute)" : ""}`
+	},
+	"vercel": {
+		name: "vercel",
+		bundle: "drivers-external",
+		trace: "always",
+		runtimePlatform: "linux",
+		layout: (context) => ({
+			serverDir: join(context.root, ".vercel", "output", "functions", "__server.func"),
+			clientDir: join(context.root, ".vercel", "output", "static"),
+			staticFromServer: void 0
+		}),
+		entry: (context) => `${lazyApp(context)}
+import { Scheduler, toNodeHandler } from '@hazejs/core'
+
+let handler
+export default async function vercelHandler(req, res) {
+  // Vercel Cron：调用 /__haze/schedule，并带上 Authorization: Bearer $CRON_SECRET
+  if (req.url?.split('?')[0] === '/__haze/schedule') {
+    if (!process.env.CRON_SECRET || req.headers.authorization !== \`Bearer \${process.env.CRON_SECRET}\`) {
+      res.statusCode = 401
+      return res.end('Unauthorized')
+    }
+    const runs = await (await getApp()).make(Scheduler).runDue()
+    res.setHeader('content-type', 'application/json')
+    return res.end(JSON.stringify(runs.map(({ name, status, reason }) => ({ name, status, reason }))))
+  }
+  handler ??= toNodeHandler((await getApp()).h3)
+  return handler(req, res)
+}
+`,
+		async finalize(context) {
+			const output = join(context.root, ".vercel", "output");
+			const dir = context.layout.serverDir;
+			await mkdir(join(output, "static"), { recursive: true });
+			await writeFile(join(dir, ".vc-config.json"), `${JSON.stringify({
+				runtime: "nodejs22.x",
+				handler: "index.mjs",
+				launcherType: "Nodejs",
+				shouldAddSourcemapSupport: true,
+				supportsResponseStreaming: true
+			}, null, 2)}\n`);
+			await writeFile(join(dir, "package.json"), "{ \"type\": \"module\" }\n");
+			const cron = context.schedules ? [{
+				src: "^/__haze/schedule$",
+				dest: "/__server"
+			}] : [];
+			const routes = context.fullstack ? [
+				{ handle: "filesystem" },
+				...cron,
+				...context.prefixes.map((prefix) => ({
+					src: `^${prefix}(?:/.*)?$`,
+					dest: "/__server"
+				})),
+				{
+					src: "/(.*)",
+					dest: "/index.html"
+				}
+			] : [{ handle: "filesystem" }, {
+				src: "/(.*)",
+				dest: "/__server"
+			}];
+			const crons = context.schedules ? [{
+				path: "/__haze/schedule",
+				schedule: context.vercel?.cron ?? "* * * * *"
+			}] : void 0;
+			await writeFile(join(output, "config.json"), `${JSON.stringify({
+				version: 3,
+				routes,
+				...crons && { crons }
+			}, null, 2)}\n`);
+		},
+		hint: (context) => `Deploy the prebuilt output: vercel deploy --prebuilt (set APP_KEY with: vercel env add APP_KEY)${context.schedules ? "\nScheduler: Vercel Cron calls /__haze/schedule; set CRON_SECRET (vercel env add CRON_SECRET). Hobby plans only allow daily crons (haze.config.ts: vercel.cron)" : ""}`
+	},
+	"netlify": {
+		name: "netlify",
+		bundle: "drivers-external",
+		layout: (context) => ({
+			...serverLayout(context),
+			staticFromServer: void 0
+		}),
+		entry: (context) => `${lazyApp(context)}
+/** Netlify Functions（v2）：Web Request → Response */
+export default async function netlifyHandler(request) {
+  return (await getApp()).fetch(request)
+}
+`,
+		async finalize(context) {
+			const functions = join(context.root, ".netlify", "v1", "functions");
+			await mkdir(functions, { recursive: true });
+			const entry = normalizePath(relative(functions, join(context.layout.serverDir, "index.mjs")));
+			const paths = context.fullstack ? context.prefixes.flatMap((prefix) => [prefix, `${prefix}/*`]) : ["/*"];
+			await writeFile(join(functions, "haze-server.mjs"), `// 由 haze build --preset netlify 生成
+export { default } from '${entry.startsWith(".") ? entry : `./${entry}`}'
+
+export const config = {
+  name: 'hazejs server',
+  generator: 'hazejs',
+  path: ${JSON.stringify(paths)},
+  preferStatic: true,
+}
+`);
+			const publish = context.layout.clientDir ?? join(context.outDir, "public");
+			await mkdir(publish, { recursive: true });
+			if (context.fullstack) await writeFile(join(publish, "_redirects"), "/*  /index.html  200\n");
+			const toml = join(context.root, "netlify.toml");
+			if (!existsSync(toml)) await writeFile(toml, `[build]\n  command = "npx haze build --preset netlify"\n  publish = "${rel(context, publish)}"\n`);
+		},
+		hint: (context) => `${existsSync(join(context.root, "netlify.toml")) ? "Deploy with: netlify deploy --build (publish directory is set in netlify.toml)" : "Deploy with: netlify deploy --build"}\nSet APP_KEY with: netlify env:set APP_KEY <key>`
+	},
+	"cloudflare": {
+		name: "cloudflare",
+		bundle: "all",
+		conditions: [
+			"workerd",
+			"worker",
+			"browser",
+			"module",
+			"production"
+		],
+		mainFields: [
+			"browser",
+			"module",
+			"jsnext:main",
+			"jsnext",
+			"main"
+		],
+		target: "es2022",
+		platform: "browser",
+		singleFile: true,
+		unsupported: EDGE_UNSUPPORTED_DRIVERS,
+		external: [/^cloudflare:/],
+		layout: (context) => ({
+			serverDir: context.outDir,
+			clientDir: context.fullstack ? join(context.outDir, "client") : void 0,
+			staticFromServer: void 0
+		}),
+		entry: (context) => `${lazyApp(context, `env: false,`)}
+import { QueueManager, Scheduler, setPlatformBindings } from '@hazejs/core'
+${context.websocket ? `import { createWebSocketDurableObject } from '@hazejs/core/cloudflare'
+
+// WebSocket：所有连接在同一个 Durable Object 中，订阅 / 广播全局生效；钩子在 DO 内经应用解析（含中间件）
+const websocket = createWebSocketDurableObject({ fetch: async request => (await getApp()).fetch(request), bind: env => bind(env) })
+export const HazeWebSocket = websocket.HazeWebSocket
+` : ""}
+function bind(env) {
+  setPlatformBindings(env)
+  if (!app) {
+    for (const [key, value] of Object.entries(env ?? {})) {
+      if (typeof value === 'string' && process.env[key] === undefined)
+        process.env[key] = value
+    }
+  }
+}
+
+/** Cloudflare Workers：静态资源由 Workers Assets 提供，环境变量与 D1 等来自绑定 */
+export default {
+  async fetch(request, env, ctx) {
+    bind(env)
+${context.websocket ? `    if (request.headers.get('upgrade')?.toLowerCase() === 'websocket')
+      return websocket.handleUpgrade(request, env, ctx)
+` : ""}    return (await getApp()).fetch(request)
+  },
+  /** Cloudflare Queues 消费：重试映射为 message.retry({ delaySeconds }) */
+  async queue(batch, env) {
+    bind(env)
+    await (await getApp()).make(QueueManager).handleBatch(batch)
+  },
+  /** Cron Triggers：执行该分钟到期的定时任务 */
+  async scheduled(controller, env, ctx) {
+    bind(env)
+    ctx.waitUntil((async () => (await getApp()).make(Scheduler).runDue(new Date(controller.scheduledTime)))())
+  },
+}
+`,
+		async finalize(context) {
+			const { compatibility_flags: flags, assets, d1_databases: d1, ...user } = context.cloudflare?.wrangler ?? {};
+			const config = {
+				name: packageName$1(context.root),
+				main: "index.mjs",
+				compatibility_date: "2026-01-01",
+				...user,
+				compatibility_flags: [.../* @__PURE__ */ new Set(["nodejs_compat", ...flags ?? []])]
+			};
+			if (context.fullstack || assets) config.assets = {
+				...context.fullstack && {
+					directory: "./client",
+					not_found_handling: "single-page-application",
+					run_worker_first: context.prefixes.map((prefix) => `${prefix}/*`)
+				},
+				...assets
+			};
+			if (d1?.length) {
+				config.d1_databases = d1.map((database) => ({
+					migrations_dir: "migrations",
+					...database
+				}));
+				const source = join(context.srcDir, "database", "migrations");
+				if (existsSync(source)) await cp(source, join(context.outDir, "migrations"), { recursive: true });
+			}
+			if (context.websocket) {
+				const durable = config.durable_objects ?? {};
+				config.durable_objects = {
+					...durable,
+					bindings: [...durable.bindings ?? [], {
+						name: "HAZE_WEBSOCKET",
+						class_name: "HazeWebSocket"
+					}]
+				};
+				config.migrations = [...config.migrations ?? [], {
+					tag: "haze-websocket-v1",
+					new_sqlite_classes: ["HazeWebSocket"]
+				}];
+			}
+			if (context.schedules && !config.triggers) config.triggers = { crons: ["* * * * *"] };
+			await writeFile(join(context.outDir, "wrangler.json"), `${JSON.stringify(config, null, 2)}\n`);
+		},
+		hint: (context) => {
+			const wrangler = rel(context, join(context.outDir, "wrangler.json"));
+			return `Deploy: npx wrangler deploy -c ${wrangler}\nSecrets: npx wrangler secret put APP_KEY -c ${wrangler}${(context.cloudflare?.wrangler?.d1_databases ?? []).map((database) => `\nApply D1 migrations: npx wrangler d1 migrations apply ${database.database_name ?? database.binding} --remote -c ${wrangler}`).join("")}`;
+		}
+	}
+};
+function resolvePreset(name) {
+	const preset = presets[name ?? "node"];
+	if (!preset) throw new Error(`Unknown preset "${name}". Available: ${PRESET_NAMES.join(", ")}`);
+	return preset;
+}
+// src/preview.ts
+function manifestFile(root) {
+	return join(root, ".haze", "build.json");
+}
+function writeBuildManifest(root, manifest) {
+	const file = manifestFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+function readBuildManifest(root) {
+	const file = manifestFile(root);
+	if (!existsSync(file)) throw new Error("No build found. Run `vite build` (or `haze build`) before previewing.");
+	return JSON.parse(readFileSync(file, "utf8"));
+}
+/** 前端静态文件由 Vite 托管的预设（产物中由平台 CDN 提供），其余预设的产物自己托管全部请求 */
+function staticDirOf(manifest) {
+	return manifest.fullstack && !manifest.layout.staticFromServer ? manifest.layout.clientDir : void 0;
+}
+/**
+* 按部署预设运行**构建产物**（而不是源码）：
+* - node / bun / deno / docker：在随机端口启动产物进程，请求全部转发给它
+* - aws-lambda / vercel / netlify：进程内加载函数 handler
+* - cloudflare：用 Miniflare（workerd）运行 Worker，绑定来自 wrangler.json
+*/
+async function startPreview(root, manifest, logger) {
+	const prefixes = manifest.prefixes;
+	const matches = staticDirOf(manifest) ? (url) => prefixes.some((prefix) => url === prefix || url.startsWith(`${prefix}/`) || url.startsWith(`${prefix}?`)) : () => true;
+	if ([
+		"aws-lambda",
+		"vercel",
+		"netlify"
+	].includes(manifest.preset)) {
+		const { loadEnv } = await import("@hazejs/core");
+		loadEnv({
+			cwd: root,
+			mode: "production"
+		});
+	}
+	switch (manifest.preset) {
+		case "node":
+		case "bun":
+		case "deno":
+		case "docker": return {
+			matches,
+			...await startProcess(root, manifest)
+		};
+		case "aws-lambda": {
+			const { lambdaResultToResponse, requestToLambdaEvent } = await import("@hazejs/core");
+			const { handler } = await importEntry(manifest.entry);
+			return fetchPreview(matches, async (request) => lambdaResultToResponse(await handler(await requestToLambdaEvent(request))));
+		}
+		case "vercel": {
+			const { default: handler } = await importEntry(manifest.entry);
+			return {
+				matches,
+				handle: handler,
+				close: async () => {}
+			};
+		}
+		case "netlify": {
+			const { default: handler } = await importEntry(join(root, ".netlify", "v1", "functions", "haze-server.mjs"));
+			return fetchPreview(matches, (request) => handler(request, {}));
+		}
+		case "cloudflare": return {
+			...await startWorker(root, manifest, logger),
+			matches
+		};
+	}
+}
+function fetchPreview(matches, fetch, close = async () => {}) {
+	return {
+		matches,
+		handle: toNodeHandler(fetch),
+		close
+	};
+}
+async function importEntry(file) {
+	return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+}
+/** 产物按预设的运行时构建（bun / deno 的导出条件），必须用对应运行时执行 */
+function runtimeCommand(root, preset, entry) {
+	if (preset === "bun") {
+		const bun = which("bun");
+		if (!bun) throw new Error("Previewing the bun build needs Bun (https://bun.sh)");
+		return [bun, entry];
+	}
+	if (preset === "deno") {
+		const deno = which("deno");
+		if (deno) return [
+			deno,
+			"run",
+			"-A",
+			entry
+		];
+		try {
+			return [
+				process.execPath,
+				createRequire(join(root, "package.json")).resolve("deno/bin.cjs"),
+				"run",
+				"-A",
+				entry
+			];
+		} catch {
+			throw new Error("Previewing the deno build needs Deno (https://deno.com) or the deno npm package");
+		}
+	}
+	return [process.execPath, entry];
+}
+async function startProcess(root, manifest) {
+	const port = await freePort();
+	const [command, ...args] = runtimeCommand(root, manifest.preset, manifest.entry);
+	const loaded = globalThis.__HAZEJS__envKeys;
+	const inherited = Object.fromEntries(Object.entries(process.env).filter(([key]) => !loaded?.has(key)));
+	const child = spawn(command, args, {
+		cwd: root,
+		env: {
+			...inherited,
+			NODE_ENV: "production",
+			PORT: String(port),
+			HOST: "127.0.0.1"
+		},
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	child.stdout?.pipe(process.stdout);
+	child.stderr?.pipe(process.stderr);
+	const origin = `http://127.0.0.1:${port}`;
+	await waitUntilReady(origin, child);
+	return {
+		handle: toNodeHandler((request) => forward(request, origin)),
+		upgrade: proxyUpgrade(port),
+		close: () => stopProcess(child)
+	};
+}
+/** 转发到产物进程（去掉逐跳头；fetch 已解压响应体，去掉对应的编码头） */
+async function forward(request, origin) {
+	const url = new URL(request.url);
+	const headers = new Headers(request.headers);
+	for (const name of [
+		"host",
+		"connection",
+		"keep-alive",
+		"transfer-encoding",
+		"upgrade"
+	]) headers.delete(name);
+	headers.set("x-forwarded-host", url.host);
+	headers.set("x-forwarded-proto", url.protocol.slice(0, -1));
+	const hasBody = request.method !== "GET" && request.method !== "HEAD";
+	const response = await fetch(new URL(url.pathname + url.search, origin), {
+		method: request.method,
+		headers,
+		body: hasBody ? request.body : void 0,
+		redirect: "manual",
+		duplex: "half"
+	});
+	const out = new Headers(response.headers);
+	out.delete("content-encoding");
+	out.delete("content-length");
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: out
+	});
+}
+/** 把升级请求原样写给产物进程，之后双向转发字节 */
+function proxyUpgrade(port) {
+	return (req, socket, head) => {
+		const upstream = connect(port, "127.0.0.1", () => {
+			const lines = [`${req.method} ${req.url} HTTP/${req.httpVersion}`];
+			for (let index = 0; index < req.rawHeaders.length; index += 2) lines.push(`${req.rawHeaders[index]}: ${req.rawHeaders[index + 1]}`);
+			upstream.write(`${lines.join("\r\n")}\r\n\r\n`);
+			if (head.length) upstream.write(head);
+			upstream.pipe(socket);
+			socket.pipe(upstream);
+		});
+		const destroy = () => {
+			upstream.destroy();
+			socket.destroy();
+		};
+		upstream.on("error", destroy);
+		socket.on("error", destroy);
+	};
+}
+async function startWorker(root, manifest, logger) {
+	const dir = manifest.layout.serverDir;
+	const wrangler = JSON.parse(readFileSync(join(dir, "wrangler.json"), "utf8"));
+	let Miniflare;
+	try {
+		const require = createRequire(join(root, "package.json"));
+		({Miniflare} = await import(pathToFileURL(require.resolve("miniflare")).href));
+	} catch {
+		throw new Error(`Previewing the cloudflare build needs miniflare (pnpm add -D miniflare), or run: npx wrangler dev -c ${join(dir, "wrangler.json")}`);
+	}
+	const persist = join(root, ".haze", "preview");
+	const d1 = wrangler.d1_databases ?? [];
+	const mf = new Miniflare({
+		modules: true,
+		scriptPath: manifest.entry,
+		compatibilityDate: wrangler.compatibility_date,
+		compatibilityFlags: wrangler.compatibility_flags,
+		bindings: {
+			...envFileValues(root),
+			...wrangler.vars
+		},
+		d1Databases: Object.fromEntries(d1.map((database) => [database.binding, database.database_id ?? database.binding])),
+		d1Persist: join(persist, "d1"),
+		kvNamespaces: Object.fromEntries((wrangler.kv_namespaces ?? []).map((namespace) => [namespace.binding, namespace.id ?? namespace.binding])),
+		durableObjects: Object.fromEntries((wrangler.durable_objects?.bindings ?? []).map((binding) => [binding.name, binding.class_name])),
+		kvPersist: join(persist, "kv")
+	});
+	for (const database of d1) {
+		const applied = await applyD1Migrations(await mf.getD1Database(database.binding), join(dir, database.migrations_dir ?? "migrations"));
+		if (applied.length) logger.info(`[hazejs] D1 ${database.database_name ?? database.binding}: applied ${applied.join(", ")}`);
+	}
+	return fetchPreview(() => true, (request) => mf.dispatchFetch(request.url, {
+		method: request.method,
+		headers: request.headers,
+		body: request.body,
+		redirect: "manual",
+		duplex: "half"
+	}), () => mf.dispose());
+}
+/** 读取项目根目录的 .env / .env.production（不写入 process.env） */
+function envFileValues(root) {
+	const values = {};
+	for (const file of [".env", ".env.production"]) {
+		const path = join(root, file);
+		if (existsSync(path)) Object.assign(values, parseEnv(readFileSync(path, "utf8")));
+	}
+	return values;
+}
+async function applyD1Migrations(db, dir) {
+	if (!existsSync(dir)) return [];
+	await db.exec("CREATE TABLE IF NOT EXISTS d1_migrations (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL)");
+	const done = new Set((await db.prepare("SELECT name FROM d1_migrations").all()).results.map((row) => row.name));
+	const applied = [];
+	for (const file of readdirSync(dir).filter((file) => file.endsWith(".sql")).sort()) {
+		if (done.has(file)) continue;
+		const statements = readFileSync(join(dir, file), "utf8").split("--> statement-breakpoint").filter((statement) => statement.trim());
+		await db.batch([...statements.map((statement) => db.prepare(statement)), db.prepare("INSERT INTO d1_migrations (name) VALUES (?)").bind(file)]);
+		applied.push(file);
+	}
+	return applied;
+}
+async function waitUntilReady(origin, child) {
+	const exited = () => child.exitCode !== null || child.signalCode !== null;
+	for (let attempt = 0; attempt < 150 && !exited(); attempt++) try {
+		await fetch(origin, { redirect: "manual" });
+		return;
+	} catch {
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	child.kill();
+	throw new Error(exited() ? "The built server exited before it started listening" : `The built server did not respond on ${origin}`);
+}
+function stopProcess(child) {
+	if (child.exitCode !== null) return Promise.resolve();
+	return new Promise((resolve) => {
+		child.once("exit", () => resolve());
+		child.kill("SIGTERM");
+	});
+}
+function freePort() {
+	return new Promise((resolve, reject) => {
+		const server = createServer$1().listen(0, "127.0.0.1", () => {
+			const { port } = server.address();
+			server.close(() => resolve(port));
+		}).on("error", reject);
+	});
+}
+function which(command) {
+	try {
+		return execFileSync(process.platform === "win32" ? "where" : "which", [command], { encoding: "utf8" }).split("\n")[0].trim() || void 0;
+	} catch {
+		return;
+	}
+}
+// src/plugin.ts
+const RESOLVED_PREFIX = "\0";
+const SOURCE_RE = /\.[cm]?[jt]s$/;
+const virtualIds = new Set(Object.values(VIRTUAL_MODULES));
+/**
+* hazejs 的 Vite 插件。
+*
+* - 纯后端项目：由 `hazejs` 命令行内部使用
+* - Vue 等前端项目：在 vite.config.ts 中加入 `haze()`，开发时把 `/api/**` 交给后端（同端口、热替换），
+*   `vite build` 一次产出 `dist/client` 与 `dist/server`
+*/
+function haze(options = {}) {
+	const listeners = /* @__PURE__ */ new Set();
+	const settings = {
+		root: process.cwd(),
+		srcDir: process.cwd(),
+		outDir: resolve("dist"),
+		typegen: true,
+		port: 3e3,
+		host: void 0,
+		prefixes: normalizePrefixes(options.prefix),
+		fullstack: !options.standalone,
+		preset: "node",
+		orm: false,
+		cloudflare: void 0,
+		vercel: void 0,
+		externals: {}
+	};
+	let lastBuild;
+	let unsupported = /* @__PURE__ */ new Set();
+	/** 全量打包时，未安装的驱动也替换为空模块（ORM 以字面量导入全部驱动） */
+	let stubMissing = false;
+	const api = {
+		onReload(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		settings: () => settings,
+		lastBuild: () => lastBuild
+	};
+	let isDev = true;
+	return {
+		name: PLUGIN_NAME,
+		api,
+		async config(userConfig, env) {
+			const base = normalizePath(resolve(userConfig.root ?? process.cwd()));
+			settings.root = base;
+			const fileConfig = options.srcDir === void 0 ? await loadHazeConfig(base) : void 0;
+			settings.srcDir = options.srcDir === void 0 ? normalizePath(fileConfig?.srcDir ?? base) : normalizePath(isAbsolute(options.srcDir) ? options.srcDir : resolve(base, options.srcDir));
+			settings.outDir = normalizePath(options.outDir ?? fileConfig?.outDir ?? resolve(base, "dist"));
+			settings.port = options.port ?? fileConfig?.port ?? 3e3;
+			settings.host = options.host ?? fileConfig?.host;
+			settings.typegen = options.typegen ?? fileConfig?.typegen ?? true;
+			settings.preset = options.preset ?? process.env.HAZE_PRESET ?? fileConfig?.preset ?? "node";
+			settings.cloudflare = options.cloudflare ?? fileConfig?.cloudflare;
+			settings.vercel = options.vercel ?? fileConfig?.vercel;
+			settings.externals = options.externals ?? fileConfig?.externals ?? {};
+			settings.orm = Boolean(findInstalled("@hazejs/orm", base));
+			const config = {};
+			if (options.alias !== false) config.resolve = { alias: [{
+				find: new RegExp(`^${escapeRegExp(options.alias ?? "~")}/`),
+				replacement: `${settings.srcDir}/`
+			}] };
+			if (env.isPreview) {
+				const manifest = existsSync(manifestFile(base)) ? readBuildManifest(base) : void 0;
+				if (manifest) config.environments = { client: { build: { outDir: staticDirOf(manifest) ?? manifest.layout.clientDir ?? manifest.layout.serverDir } } };
+			}
+			if (env.command === "build") {
+				const preset = resolvePreset(settings.preset);
+				const context = presetContext(settings);
+				const layout = preset.layout(context);
+				const migrateScript = Boolean(preset.migrateScript && settings.orm);
+				const trace = preset.trace === "always" || preset.trace === "default" && settings.externals.trace !== false;
+				const bundle = !trace && preset.trace === "default" && preset.name !== "deno" ? "external" : preset.bundle;
+				config.environments = {
+					ssr: {
+						resolve: {
+							...preset.conditions && { conditions: preset.conditions },
+							...preset.mainFields && { mainFields: preset.mainFields },
+							...bundle === "drivers-external" && { noExternal: bundleAllExcept(externalPackages(settings.externals)) },
+							...bundle === "all" && { noExternal: true }
+						},
+						build: {
+							outDir: layout.serverDir,
+							emptyOutDir: true,
+							target: preset.target ?? "node22",
+							sourcemap: true,
+							rolldownOptions: {
+								...preset.platform && { platform: preset.platform },
+								...preset.unsupported?.length && { shimMissingExports: true },
+								...(preset.external || bundle === "drivers-external") && { external: [...preset.external ?? [], ...bundle === "drivers-external" ? [externalPattern(externalPackages(settings.externals))] : []] },
+								input: {
+									index: VIRTUAL_MODULES.serverEntry,
+									...migrateScript && { migrate: VIRTUAL_MODULES.migrateEntry },
+									...preset.migrateScript && { worker: VIRTUAL_MODULES.workerEntry }
+								},
+								output: {
+									entryFileNames: "[name].mjs",
+									chunkFileNames: "chunks/[name]-[hash].mjs",
+									...preset.singleFile && { codeSplitting: false }
+								}
+							}
+						}
+					},
+					...settings.fullstack && layout.clientDir && { client: { build: { outDir: layout.clientDir } } }
+				};
+				unsupported = new Set(preset.unsupported);
+				stubMissing = bundle === "all";
+				config.builder = { async buildApp(builder) {
+					await builder.build(builder.environments.ssr);
+					if (settings.fullstack) await builder.build(builder.environments.client);
+					const externals = scanExternals(layout.serverDir).filter((name) => !DRIVER_PACKAGES.includes(name) || findInstalled(name, context.root));
+					const traced = trace ? await traceDependencies(layout.serverDir, context.root, {
+						conditions: preset.conditions,
+						traceDeps: settings.externals.traceDeps,
+						platform: preset.runtimePlatform
+					}) : void 0;
+					if (traced?.foreignNative.length) builder.config.logger.warn(`[hazejs] ${preset.name} runs on ${preset.runtimePlatform}, but these native packages were traced from this ${process.platform} machine: ${traced.foreignNative.join(", ")}. Build on ${preset.runtimePlatform} (CI or Docker) so the right binaries are copied.`);
+					const finalize = {
+						...context,
+						layout,
+						externals,
+						traced
+					};
+					await preset.finalize?.(finalize);
+					writeBuildManifest(settings.root, {
+						preset: preset.name,
+						layout,
+						entry: join(layout.serverDir, "index.mjs"),
+						fullstack: settings.fullstack,
+						prefixes: settings.prefixes
+					});
+					lastBuild = {
+						preset: preset.name,
+						layout,
+						externals,
+						traced,
+						entry: join(layout.serverDir, "index.mjs"),
+						...migrateScript && { migrate: join(layout.serverDir, "migrate.mjs") },
+						hint: preset.hint(finalize)
+					};
+				} };
+			}
+			return config;
+		},
+		configResolved(config) {
+			settings.root = normalizePath(config.root);
+			isDev = config.command === "serve";
+		},
+		configureServer(server) {
+			if (!settings.fullstack) return;
+			const host = createAppHost({
+				vite: server,
+				api
+			});
+			const handle = toNodeHandler(host.fetch);
+			const matches = (url) => settings.prefixes.some((prefix) => url === prefix || url.startsWith(`${prefix}/`) || url.startsWith(`${prefix}?`));
+			server.middlewares.use((req, res, next) => {
+				if (!req.url || !matches(req.url)) return next();
+				Promise.resolve(handle(req, res)).catch(next);
+			});
+			server.httpServer?.once("listening", () => void host.start());
+			if (server.httpServer) {
+				registerNodeServer(server.httpServer);
+				const upgrade = nodeUpgradeHandler(host.fetch);
+				server.httpServer.on("upgrade", (req, socket, head) => {
+					if (req.url && matches(req.url) && req.headers["sec-websocket-protocol"] !== "vite-hmr") upgrade(req, socket, head);
+				});
+			}
+			const close = server.close.bind(server);
+			server.close = async () => {
+				await host.close();
+				return close();
+			};
+		},
+		async configurePreviewServer(server) {
+			const manifest = readBuildManifest(settings.root);
+			const preview = await startPreview(settings.root, manifest, server.config.logger);
+			server.config.logger.info(`  [hazejs] previewing the ${manifest.preset} build`);
+			server.middlewares.use((req, res, next) => {
+				if (!req.url || !preview.matches(req.url)) return next();
+				Promise.resolve(preview.handle(req, res)).catch(next);
+			});
+			if (preview.upgrade) server.httpServer.on("upgrade", (req, socket, head) => {
+				if (req.url && preview.matches(req.url)) preview.upgrade(req, socket, head);
+			});
+			server.httpServer.once("close", () => void preview.close());
+		},
+		resolveId: {
+			order: "pre",
+			async handler(id, importer) {
+				if (virtualIds.has(id)) return RESOLVED_PREFIX + id;
+				if (this.environment?.name !== "ssr" || isDev) return;
+				const name = packageName(id);
+				if (unsupported.has(name)) return `${RESOLVED_PREFIX}haze-unsupported:${id}`;
+				if (stubMissing && DRIVER_PACKAGES.includes(name) && !await this.resolve(id, importer, { skipSelf: true })) return `${RESOLVED_PREFIX}haze-missing:${id}`;
+			}
+		},
+		load(id) {
+			if (!id.startsWith(RESOLVED_PREFIX)) return;
+			if (id.startsWith(`${RESOLVED_PREFIX}haze-unsupported:`)) {
+				const name = id.slice(`${RESOLVED_PREFIX}haze-unsupported:`.length);
+				return `throw new Error(${JSON.stringify(`"${name}" is not supported on the "${settings.preset}" deployment preset`)})\nexport default undefined\n`;
+			}
+			if (id.startsWith(`${RESOLVED_PREFIX}haze-missing:`)) {
+				const name = id.slice(`${RESOLVED_PREFIX}haze-missing:`.length);
+				return `throw new Error(${JSON.stringify(`"${name}" is not installed`)})\nexport default undefined\n`;
+			}
+			switch (id.slice(1)) {
+				case VIRTUAL_MODULES.manifest: return manifestCode(settings, isDev);
+				case VIRTUAL_MODULES.app: return appCode();
+				case VIRTUAL_MODULES.serverEntry: return serverEntryCode(settings);
+				case VIRTUAL_MODULES.migrations: return migrationsCode(settings);
+				case VIRTUAL_MODULES.migrateEntry: return migrateEntryCode();
+				case VIRTUAL_MODULES.workerEntry: return workerEntryCode();
+			}
+		},
+		hotUpdate({ type, file, modules }) {
+			if (this.environment.name !== "ssr") return;
+			if (file.startsWith(`${settings.root}/.haze/`) || file.endsWith(".d.ts")) return;
+			const isEnvFile = dirname(file) === settings.root && basename(file).startsWith(".env");
+			const isNewSource = type !== "update" && file.startsWith(`${settings.srcDir}/`) && SOURCE_RE.test(file);
+			if (!modules.length && !isEnvFile && !isNewSource) return;
+			if (type !== "update") {
+				const manifest = this.environment.moduleGraph.getModuleById(RESOLVED_PREFIX + VIRTUAL_MODULES.manifest);
+				if (manifest) this.environment.moduleGraph.invalidateModule(manifest);
+			}
+			listeners.forEach((listener) => listener({
+				type,
+				file
+			}));
+			return [];
+		}
+	};
+}
+function manifestCode(settings, dev) {
+	const rel = srcDirFromRoot(settings);
+	const base = rel ? `/${rel}` : "";
+	const glob = (pattern, extra = "") => `import.meta.glob(${JSON.stringify(`${base}/${pattern}`)}, { eager: true${extra} })`;
+	return [
+		`export const rootDir = ${dev ? JSON.stringify(settings.root) : "undefined"}`,
+		`export const config = ${glob("config/*.{ts,mts,js,mjs}")}`,
+		`export const routes = ${glob("route/*.{ts,mts,js,mjs}")}`,
+		`export const providers = ${glob("app/provider/*.{ts,mts,js,mjs}")}`,
+		`const handlers = ${glob("app/exception/Handler.{ts,mts,js,mjs}", ", import: 'default'")}`,
+		`export const exceptionHandler = Object.values(handlers)[0]`,
+		`const formatters = ${glob("app/response/Formatter.{ts,mts,js,mjs}", ", import: 'default'")}`,
+		`export const responseFormatter = Object.values(formatters)[0]`,
+		`export const interceptors = ${glob("app/interceptor/*.{ts,mts,js,mjs}")}`,
+		`export const policies = ${glob("app/policy/*.{ts,mts,js,mjs}")}`,
+		`export const jobs = ${glob("app/job/*.{ts,mts,js,mjs}")}`,
+		`export const schedules = ${glob("schedule/*.{ts,mts,js,mjs}")}`,
+		`export const events = ${glob("app/event/*.{ts,mts,js,mjs}")}`,
+		`export const listeners = ${glob("app/listener/*.{ts,mts,js,mjs}")}`,
+		`export const discovered = { sockets: ${glob("app/socket/*.{ts,mts,js,mjs}")} }`,
+		`export const apps = ${glob("app/*/{route,config,provider,exception,response}/*.{ts,mts,js,mjs}")}`
+	].join("\n");
+}
+/** database/ 下 drizzle-kit 生成的 SQL 与 journal，键为相对 srcDir 的路径（与 config/database.ts 的 migrations 一致） */
+function migrationsCode(settings) {
+	const rel = srcDirFromRoot(settings);
+	const base = rel ? `/${rel}/` : "/";
+	return `const raw = {
+  ...import.meta.glob(${JSON.stringify(`${base}database/**/*.sql`)}, { query: '?raw', import: 'default', eager: true }),
+  ...import.meta.glob(${JSON.stringify(`${base}database/**/meta/_journal.json`)}, { query: '?raw', import: 'default', eager: true }),
+}
+export const files = Object.fromEntries(Object.entries(raw).map(([path, content]) => [path.slice(${base.length}), content]))
+`;
+}
+function appCode() {
+	return `
+import { createApplication } from '@hazejs/core'
+import * as manifest from '${VIRTUAL_MODULES.manifest}'
+
+export { manifest }
+
+export function createApp(options = {}) {
+  return createApplication({
+    rootDir: manifest.rootDir,
+    config: manifest.config,
+    routes: manifest.routes,
+    providers: manifest.providers,
+    exceptionHandler: manifest.exceptionHandler,
+    responseFormatter: manifest.responseFormatter,
+    interceptors: manifest.interceptors,
+    policies: manifest.policies,
+    jobs: manifest.jobs,
+    schedules: manifest.schedules,
+    events: manifest.events,
+    listeners: manifest.listeners,
+    discovered: manifest.discovered,
+    apps: manifest.apps,
+    ...options,
+  })
+}
+`;
+}
+function presetContext(settings) {
+	return {
+		root: settings.root,
+		externalsOptions: settings.externals,
+		srcDir: settings.srcDir,
+		orm: settings.orm,
+		cloudflare: settings.cloudflare,
+		vercel: settings.vercel,
+		schedules: hasSources(join(settings.srcDir, "schedule")),
+		websocket: settings.cloudflare?.websocket ?? usesWebSocket(settings.srcDir),
+		outDir: settings.outDir,
+		fullstack: settings.fullstack,
+		prefixes: settings.prefixes,
+		port: settings.port,
+		host: settings.host
+	};
+}
+/** 生产入口由部署预设生成（监听端口 / Serverless handler / Worker） */
+function serverEntryCode(settings) {
+	const preset = resolvePreset(settings.preset);
+	const context = presetContext(settings);
+	return preset.entry({
+		...context,
+		layout: preset.layout(context)
+	});
+}
+function normalizePrefixes(prefix) {
+	return (Array.isArray(prefix) ? prefix : [prefix ?? "/api"]).map((item) => `/${item.replace(/^\/+|\/+$/g, "")}`);
+}
+/** 后端源码目录相对项目根的路径（相同时为空字符串；normalizePath('') 会得到 '.'） */
+function srcDirFromRoot(settings) {
+	const rel = normalizePath(relative(settings.root, settings.srcDir));
+	return rel === "." ? "" : rel;
+}
+/** 路由文件中是否定义了 WebSocket（r.ws(...)） */
+function usesWebSocket(srcDir) {
+	return [join(srcDir, "route"), ...existsSync(join(srcDir, "app")) ? readdirSync(join(srcDir, "app"), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(srcDir, "app", entry.name, "route")) : []].some((dir) => existsSync(dir) && readdirSync(dir).some((name) => SOURCE_RE.test(name) && /\.ws\s*\(/.test(readFileSync(join(dir, name), "utf8"))));
+}
+/** 目录下是否有源码文件（如 schedule/*.ts） */
+function hasSources(dir) {
+	return existsSync(dir) && readdirSync(dir).some((name) => SOURCE_RE.test(name) && !name.endsWith(".d.ts"));
+}
+function packageName(id) {
+	return id.split("/").slice(0, id.startsWith("@") ? 2 : 1).join("/");
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// src/build.ts
+/**
+* 构建纯后端项目的生产产物。产物布局、打包策略与入口由部署预设决定；
+* node 预设下依赖保持 external（运行时需要 node_modules），`.env` 从运行时工作目录加载。
+*/
+async function buildServer(options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const config = await loadHazeConfig(root, "production");
+	const outDir = options.outDir ? resolve(root, options.outDir) : config.outDir;
+	const plugin = haze({
+		srcDir: config.srcDir,
+		outDir,
+		port: config.port,
+		host: config.host,
+		preset: options.preset ?? config.preset,
+		cloudflare: config.cloudflare,
+		vercel: config.vercel,
+		externals: config.externals,
+		standalone: true
+	});
+	await (await createBuilder(mergeConfig(config.vite, {
+		root,
+		configFile: false,
+		mode: "production",
+		envDir: false,
+		logLevel: "warn",
+		plugins: [plugin],
+		build: {
+			minify: options.minify ?? false,
+			sourcemap: options.sourcemap ?? true
+		}
+	}))).buildApp();
+	const info = plugin.api.lastBuild();
+	if (!info) throw new Error("Build did not produce a server bundle");
+	return {
+		...info,
+		outDir
+	};
+}
+// src/dev.ts
+/**
+* 纯后端项目的开发服务器：HTTP 监听只创建一次，文件变化时通过 Vite ModuleRunner
+* 重新执行应用代码并原子替换 fetch 处理器——进程不重启、端口不断开。
+*/
+async function createDevServer(options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const config = await loadHazeConfig(root);
+	const plugin = haze({
+		srcDir: config.srcDir,
+		port: config.port,
+		host: config.host,
+		typegen: config.typegen,
+		standalone: true
+	});
+	const vite = await createServer(mergeConfig(config.vite, {
+		root,
+		configFile: false,
+		appType: "custom",
+		clearScreen: false,
+		logLevel: "warn",
+		envDir: false,
+		optimizeDeps: {
+			noDiscovery: true,
+			entries: []
+		},
+		server: {
+			middlewareMode: true,
+			ws: false,
+			watch: { ignored: [`${normalizePath(config.outDir)}/**`, `${normalizePath(root)}/.haze/**`] }
+		},
+		plugins: [plugin]
+	}));
+	const host = createAppHost({
+		vite,
+		api: plugin.api,
+		debounce: options.debounce
+	});
+	if (!(await host.start()).ok && options.listen === false) consola.warn(`[${PLUGIN_NAME}] the app failed to start; requests will return the error until it is fixed`);
+	const server = options.listen === false ? void 0 : serve({
+		fetch: host.fetch,
+		port: options.port ?? (Number(process.env.PORT) || config.port),
+		hostname: options.host ?? config.host,
+		silent: true,
+		gracefulShutdown: false,
+		plugins: [webSocketPlugin(host.fetch, host.app ? webSocketConfig(host.app.config) : void 0)]
+	});
+	await server?.ready();
+	return {
+		get url() {
+			return server?.url;
+		},
+		vite,
+		get app() {
+			return host.app;
+		},
+		fetch: host.fetch,
+		reload: host.reload,
+		onReload: host.onReload,
+		import: host.import,
+		async close() {
+			await server?.close(true);
+			await host.close();
+			await vite.close();
+		}
+	};
+}
+// src/preview-server.ts
+/**
+* 本地预览构建产物（`haze preview`）：按构建时的部署预设运行产物本身。
+* 全栈项目使用项目的 vite.config.ts（等同 `vite preview`），纯后端项目使用内置配置。
+*/
+async function previewServer(options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const server = { preview: {
+		...options.port !== void 0 && { port: options.port },
+		...options.host !== void 0 && { host: options.host },
+		...options.open !== void 0 && { open: options.open }
+	} };
+	const viteConfig = findViteConfig(root);
+	if (viteConfig) return preview({
+		root,
+		configFile: viteConfig,
+		...server
+	});
+	const config = await loadHazeConfig(root, "production");
+	return preview(mergeConfig(config.vite, {
+		root,
+		configFile: false,
+		appType: "custom",
+		envDir: false,
+		plugins: [haze({
+			srcDir: config.srcDir,
+			outDir: config.outDir,
+			standalone: true
+		})],
+		...server
+	}));
+}
+export { CONFIG_BASENAME, PRESET_NAMES, VIRTUAL_MODULES, buildServer, createAppHost, createDevServer, defineHazeConfig, findViteConfig, generateTypes, haze, loadHazeConfig, presets, previewServer, readBuildManifest, resolvePreset, typesFile, writeTypes };