@ubean/build 0.5.2 → 0.6.0-beta.1

package/dist/vite-DvHEv7Op.js

@@ -0,0 +1,2656 @@
+import { a as ssrSingletonProdOptimizeExclude, m as createVirtualRegistry, o as ssrSingletonProdSsr, y as __exportAll } from "./ssr-singleton-DPTawJSx.js";
+import { a as createRoutingVirtualModule, i as createPagesVirtualModule, n as createLocalesVirtualModule, r as createMetaVirtualModule, s as transformMacros, t as createAppVirtualModule } from "./virtual-modules-CvGWlsXj.js";
+import { D as getDevScanCoordinator, a as createVueAppEntryVirtualModule, g as toWebRequest, h as sendWebResponse, i as createServerEntryVirtualModule, n as ubeanVite, o as createVuePagesVirtualModule, r as createClientEntryVirtualModule } from "./vue-BrbbaXTC.js";
+import { createStaticSsgRenderer } from "./static-render.js";
+import { prerender, resolvePrerenderStaticDir } from "./prerender.js";
+import { join, relative, resolve } from "pathe";
+import * as nodeFs from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { loadUbeanConfig, resolveModules, resolvePrerenderConfig, tryGetConfig } from "@ubean/config";
+import { isEphemeralCachePreset, registerBuiltinPresets, resolvePresetByName, resolveProductionCacheStore } from "@ubean/preset";
+import { createServerRouter } from "@ubean/routes";
+import { scanProject } from "@ubean/scan";
+import { getLogger } from "@ubean/shared/logger";
+import { getVueLocaleParam } from "@ubean/i18n";
+import * as nodeFsPromises from "node:fs/promises";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { getColorModeScript, resolveColorModeConfig } from "@ubean/client";
+import { DevEnvironment, createBuilder, normalizePath, perEnvironmentPlugin } from "vite";
+import { ubeanIslandsPlugin } from "@ubean/islands/vite";
+import { findUserViteConfig } from "@ubean/shared/node";
+import { dirname as dirname$1, extname, join as join$1, normalize as normalize$1, relative as relative$1, resolve as resolve$1, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/i18n-config.ts
+function serializeI18nConfig(config) {
+	return JSON.stringify(config);
+}
+function localeVueParamFromI18n(config) {
+	if (!config.enabled) return void 0;
+	return getVueLocaleParam({
+		defaultLocale: config.defaultLocale,
+		locales: config.locales.map((l) => l.code),
+		strategy: config.strategy
+	}) || void 0;
+}
+//#endregion
+//#region src/ssg-entry.ts
+/**
+* 生成 renderer setup 代码块（`_rendererRoutes` + `_pageRenderer`）。
+*
+* 依赖外层已定义：`_pages` / `_layouts` / `pageLoaders` / `layoutLoaders` /
+* （notFoundCatchAll 时）`_notFoundPage`，以及 `toVueRouterLocalePath` 导入。
+* ssrEnabled=false 时 `_pageRenderer = null`（与 fullstack 现状一致）。
+*/
+function buildRendererSetup(options) {
+	const { ssrEnabled, mode, localeVueParam, notFoundCatchAll } = options;
+	if (!ssrEnabled) return `
+// --- SSR disabled (mode=${mode}) ---
+// pageRenderer is null; page requests fall back to a client-only HTML shell.
+const _pageRenderer = null;`;
+	return `
+// --- SSR renderer setup ---
+const _defaultLayout = _layouts.find(l => l.isDefault)?.name || null;
+
+// Same i18n locale param as the client virtual:ubean-pages route table, so
+// language-prefixed URLs (e.g. /zh/playground) match the real page on SSR too.
+const _localeVueParam = ${JSON.stringify(localeVueParam)};
+
+// 页面 → Vue Router 路由记录。必须按 route 路径分组：并行路由（@slot/ 目录）在客户端是同一条
+// 路由记录上的命名视图（components: { default, <slot名> }）；SSR 侧若把每个页面各注册成一条路由，
+// 同路径的两条记录会互相覆盖 —— 实测首屏渲染的是插槽页，水合后客户端渲染默认视图（首屏与客户端
+// 不一致）。分组后 SlotView 组件在 SSR 也能解析到插槽组件。
+const _pageToRoute = p => {
+  // For reuse routes, load the target page's module (the .reuse.ts file
+  // only contains definePage metadata, not a Vue component).
+  const _targetPage = p.isReuse && p.reuseTarget ? _pages.find(tp => tp.name === p.reuseTarget) : undefined;
+  const _loaderKey = _targetPage?.relativePath || p.relativePath;
+  return {
+    path: _localeVueParam
+      ? toVueRouterLocalePath(p.route.replace(/\\*\\*:(\\w[\\w-]*)/g, ':$1(.*)*'), _localeVueParam)
+      : p.route.replace(/\\*\\*:(\\w[\\w-]*)/g, ':$1(.*)*'),
+    name: p.name,
+    component: async () => {
+      const loader = pageLoaders[_loaderKey];
+      if (!loader) throw new Error('Page loader not found: ' + _loaderKey);
+      const mod = await loader();
+      return mod.default || mod;
+    },
+    meta: {
+      layout: p.layout === false ? false : p.layout || _defaultLayout,
+      pageName: p.name,
+      cache: p.cache === true ? true : undefined
+    }
+  };
+};
+
+const _routeGroups = new Map();
+for (const _p of _pages) {
+  const _key = _p.route;
+  const _group = _routeGroups.get(_key) || { slots: [] };
+  if (_p.slot) _group.slots.push(_p);
+  else if (!_group.default) _group.default = _p;
+  _routeGroups.set(_key, _group);
+}
+
+const _rendererRoutes = [];
+for (const _group of _routeGroups.values()) {
+  const _primary = _group.default || _group.slots[0];
+  if (!_primary) continue;
+  const _record = _pageToRoute(_primary);
+  if (_group.slots.length > 0) {
+    // 并行路由：命名视图（component 与 components 不能同时出现）。
+    // 注意组件加载器在 _record 上（_primary 是扫描得到的页面条目，没有 component 字段 ——
+    // 写成 _primary.component 会得到 undefined，vue-router 报 Invalid route component）。
+    const _components = {};
+    if (_group.default) _components.default = _record.component;
+    for (const _slotPage of _group.slots) _components[_slotPage.slot] = _pageToRoute(_slotPage).component;
+    delete _record.component;
+    _record.components = _components;
+  }
+  _rendererRoutes.push(_record);
+}${notFoundCatchAll ? `
+
+// 404 渲染路由：注册为静态路径 /404（而非客户端的 /:pathMatch(.*)* catch-all）。
+// vue-router 中静态段确定性优先于 repeatable 参数 —— 即使应用存在根 catch-all
+// 页面（如 [...slug].vue），/404 也稳定命中本路由，保证 404.html 产物
+// 渲染的是 pages/404.vue 而非被 catch-all 抢占。
+if (_notFoundPage) {
+  const _nfLoaderKey = _notFoundPage.relativePath;
+  _rendererRoutes.push({
+    path: _localeVueParam
+      ? toVueRouterLocalePath('/404', _localeVueParam)
+      : '/404',
+    name: 'NotFound',
+    component: async () => {
+      const loader = pageLoaders[_nfLoaderKey];
+      if (!loader) throw new Error('Page loader not found: ' + _nfLoaderKey);
+      const mod = await loader();
+      return mod.default || mod;
+    },
+    meta: { pageName: 'NotFound' }
+  });
+}` : ""}
+
+const _layoutMap = new Map();
+for (const l of _layouts) {
+  _layoutMap.set(l.name, l.relativePath);
+}
+
+const _pageRenderer = createVueRenderer({
+  routes: _rendererRoutes,
+  async resolveLayoutComponent(name) {
+    if (name === false || name == null) return null;
+    const relPath = _layoutMap.get(name);
+    if (!relPath) return null;
+    const loader = layoutLoaders[relPath];
+    if (!loader) return null;
+    const mod = await loader();
+    return mod.default || mod;
+  },
+  defaultLayout: _defaultLayout,
+  resolveAppConfig: () => _resolveAppConfig('server')
+});
+`;
+}
+/**
+* 生成 client asset tags 代码块（读取 `.vite/manifest.json`）。
+*/
+function buildAssetTagsSetup(favicon) {
+	return `
+// --- Client asset tags（RM-V18：构建期注入，不再运行时读 dist/public/.vite/manifest.json）---
+// 由 \`ubean:asset-manifest\` 插件提供：值在服务端构建期间从 client manifest 算出并内联，
+// 因此服务端产物自包含 —— 不再依赖 client 产物的磁盘相对路径，也不再把「必须先 client
+// 后 server」藏在一句运行时 try/catch 里。
+import { assetTags as _injectedAssetTags } from 'virtual:ubean-asset-manifest';
+let _assetTags = { ..._injectedAssetTags, favicon: ${JSON.stringify(favicon)} };
+`;
+}
+/**
+* 生成静态 SSG entry 源码（写入 virtualDir/server-entry.mjs，由 SSR build
+* 产出 dist/server/entry.mjs）。
+*
+* 导出契约：
+* - `renderStaticPage({ pageName, params, url, locale }) → { html, statusCode }`
+* - `pageLoaders`（调试用）
+*/
+function buildStaticSsgEntry(input) {
+	const { pagesGlob, layoutsGlob, srcPrefix, pagesJson, layoutsJson, notFoundPageJson, localeVueParam, contentBootstrap, colorModeScript, favicon } = input;
+	return `// Auto-generated ubean static SSG entry (mode: ssg)
+import { renderPage } from '@ubean/pages';
+import { createVueRenderer } from 'ubean/ssr';
+import { toVueRouterLocalePath } from '@ubean/i18n';
+import { i18nConfig as _i18nConfig, loadLocales as _loadLocales } from 'ubean:locales';
+import { resolveAppConfig as _resolveAppConfig } from 'virtual:ubean-app';
+${contentBootstrap}
+const pageModules = import.meta.glob(${pagesGlob}, { eager: false });
+const layoutModules = import.meta.glob(${layoutsGlob}, { eager: false });
+
+const _srcPrefix = ${srcPrefix};
+function normalizeKey(p) {
+  const prefixes = ['/pages/', '/layouts/'];
+  for (const prefix of prefixes) {
+    const fullPrefix = _srcPrefix + prefix;
+    if (p.includes(fullPrefix)) {
+      const idx = p.indexOf(fullPrefix);
+      return p.slice(idx + fullPrefix.length);
+    }
+  }
+  return p;
+}
+
+export const pageLoaders = {};
+for (const [key, loader] of Object.entries(pageModules)) {
+  pageLoaders[normalizeKey(key)] = loader;
+}
+
+const layoutLoaders = {};
+for (const [key, loader] of Object.entries(layoutModules)) {
+  layoutLoaders[normalizeKey(key)] = loader;
+}
+
+const _pages = ${pagesJson};
+const _layouts = ${layoutsJson};
+const _notFoundPage = ${notFoundPageJson};
+const _hasDefaultLayout = _layouts.some(l => l.isDefault);
+${buildRendererSetup({
+		ssrEnabled: true,
+		mode: "ssg",
+		localeVueParam,
+		notFoundCatchAll: true
+	})}
+${buildAssetTagsSetup(favicon)}
+const _colorModeScript = ${JSON.stringify(colorModeScript)};
+
+// --- i18n ---
+const _i18nEnabled = _i18nConfig && _i18nConfig.enabled !== false;
+const _localeCodes = _i18nEnabled
+  ? (_i18nConfig.locales || []).map(l => (typeof l === 'string' ? l : l.code))
+  : [];
+const _defaultLocale = (_i18nEnabled && _i18nConfig.defaultLocale) || '';
+let _localesReady = false;
+
+async function _ensureLocales() {
+  if (_localesReady) return;
+  _localesReady = true;
+  if (!_i18nEnabled || _localeCodes.length === 0) return;
+  try {
+    await _loadLocales();
+  } catch (e) {
+    console.warn('[ubean-ssg] Failed to load locales:', (e && e.message) || e);
+  }
+}
+
+// 静态模式不执行 loader —— 检测到页面导出 loader 时警告一次（每页）
+const _loaderWarned = new Set();
+
+/**
+ * 渲染单个静态页面（由 createStaticSsgRenderer 调用）。
+ *
+ * @param input.pageName 目标页面名（ScannedPageRoute.name）或 'NotFound'
+ * @param input.params   路由参数（matchRoutePattern 提取）
+ * @param input.url      完整 URL path（含 locale 前缀与 query）
+ * @param input.locale   渲染语言（prefix 策略下已从 URL 提取）
+ */
+export async function renderStaticPage(input) {
+  const pageName = input && input.pageName;
+  const page = pageName === 'NotFound' ? _notFoundPage : _pages.find(p => p.name === pageName);
+  if (!page) return { html: '', statusCode: 404 };
+
+  await _ensureLocales();
+
+  // loader 检测 warn（模块加载有缓存，此处与渲染共用同一实例）
+  const _targetPage =
+    page.isReuse && page.reuseTarget ? _pages.find(tp => tp.name === page.reuseTarget) : undefined;
+  const _loaderKey = (_targetPage && _targetPage.relativePath) || page.relativePath;
+  const _modLoader = pageLoaders[_loaderKey];
+  if (_modLoader && !_loaderWarned.has(page.name)) {
+    try {
+      const mod = await _modLoader();
+      if (mod && typeof mod.loader === 'function') {
+        _loaderWarned.add(page.name);
+        console.warn(
+          '[ubean-ssg] page "' + page.name + '" exports \`loader\`, which is not executed in static SSG mode'
+        );
+      }
+    } catch {}
+  }
+
+  // renderContext 构造与 routes/router.ts 的页面渲染路径保持一致
+  const renderContext = {};
+  const locale = (input && input.locale) || _defaultLocale;
+  if (_i18nEnabled && locale) {
+    renderContext.locale = locale;
+    renderContext.localeDir = 'ltr';
+    renderContext.routing = {
+      defaultLocale: _i18nConfig.defaultLocale || 'en',
+      locales: _localeCodes,
+      strategy: _i18nConfig.strategy || 'prefix_except_default'
+    };
+    const cookieName =
+      _i18nConfig.detectBrowserLanguage && _i18nConfig.detectBrowserLanguage.cookieName;
+    if (cookieName) renderContext.cookieName = cookieName;
+    if (_i18nConfig.baseUrl) renderContext.baseUrl = _i18nConfig.baseUrl;
+    try {
+      const i18nMod = await import('ubean/i18n');
+      renderContext.localeDir = i18nMod.getLocaleDir(locale);
+      renderContext.messages = i18nMod.getLocaleMessages(locale);
+      const fallback = i18nMod.getFallbackLocale();
+      renderContext.fallbackLocale = fallback;
+      if (fallback !== locale) {
+        renderContext.fallbackMessages = i18nMod.getLocaleMessages(fallback);
+      }
+      renderContext.availableLocales = i18nMod.getRegisteredLocalesMeta();
+    } catch {}
+  }
+
+  // pageObj 构造与 routes/router.ts handlePageRequest 保持一致
+  const pageObj = {
+    component: page.reuseTarget || page.name,
+    props: {},
+    params: (input && input.params) || {},
+    url: (input && input.url) || '/',
+    layout: page.layout === false
+      ? false
+      : page.layout || (page.pageMeta && page.pageMeta.layout) || (_hasDefaultLayout ? 'default' : false),
+    errors: null,
+    head: page.pageMeta && page.pageMeta.head
+  };
+
+  let html = await renderPage(pageObj, _assetTags, _pageRenderer, 'app', renderContext);
+  if (_colorModeScript) {
+    html = html.replace('<head>', '<head>\\n    ' + _colorModeScript);
+  }
+  return { html, statusCode: 200 };
+}
+`;
+}
+//#endregion
+//#region src/vite/asset-manifest.ts
+/**
+* 客户端资产清单的**构建期注入**（RM-V18）。
+*
+* 整改前：生成的 SSR entry 在**运行时**读 `join(__dirname, '..', 'public', '.vite', 'manifest.json')`
+* —— 于是（a）服务端产物必须与 `dist/public` 的相对位置保持不变才能工作，（b）构建顺序被绑成
+* 「必须先 client 后 server」，且这个约束只体现在一句 `try/catch` 里（清单读不到就静默降级为
+* 无 asset tags 的 HTML）。
+*
+* 现在由核心插件提供 `virtual:ubean-asset-manifest`：值在**服务端构建期间**算出后内联进
+* bundle。效果：
+* - 服务端产物自包含，不再依赖 client 产物的磁盘路径（`dist/server` 可单独部署/打包）；
+* - 顺序依赖只剩「构建期要先拿到 manifest 对象」，不再有运行时的路径耦合；
+* - 清单缺失时给出**构建期告警**，而不是运行时静默产出无样式 HTML。
+*
+* **唯一提供者**（2026-09-16 修复）：RM-V21 把本虚拟模块从独立插件挪进核心插件时，两个提供者
+* 并存过一段时间 —— 核心插件那份的 ref 只在它自己的 `buildApp` 里被填，而它在 CLI 驱动的两条
+* 路径上都会**抢先解析**，于是标签被内联成空串，生产 HTML 既没有客户端入口 `<script>` 也没有
+* 样式表 `<link>`（页面不水合、无样式）。文件清单比对看不见内容差异，体积门禁也不比对 HTML，
+* 缺陷因此长期潜伏；由 RM-V24 的 `vite preview` 验收断言暴露。现在改为：
+* 核心插件是唯一提供者，取值顺序为「调用方传入的内存 manifest（RM-V18 的传递）→ 服务端
+* outDir 旁的磁盘 manifest（`<outputDir>/public/.vite/manifest.json`）→ 空 + 构建期告警」。
+*/
+const logger$5 = getLogger("build");
+/** 本插件提供的虚拟模块 id。 */
+const ASSET_MANIFEST_VIRTUAL_ID = "virtual:ubean-asset-manifest";
+const RESOLVED_ID = `\0${ASSET_MANIFEST_VIRTUAL_ID}`;
+/**
+* 从 client manifest 算出资产标签。
+*
+* 与旧运行时逻辑逐字等价（`<script type="module" src="/…">` + 每个 css 一个 `<link>`），
+* 只是执行时机从「服务端启动时」提前到「服务端构建时」。
+*/
+function computeAssetTags(manifest, favicon) {
+	const tags = {
+		css: "",
+		preloads: "",
+		body: "",
+		favicon: favicon ?? null
+	};
+	const entry = manifest ? Object.values(manifest).find((item) => item.isEntry) : void 0;
+	if (!entry) return tags;
+	tags.body = `<script type="module" src="/${entry.file}"><\/script>`;
+	if (Array.isArray(entry.css)) tags.css = entry.css.map((css) => `<link rel="stylesheet" href="/${css}">`).join("\n");
+	return tags;
+}
+/** 从磁盘读 client manifest（`<publicDir>/.vite/manifest.json`）。 */
+function readClientManifestFromDisk(publicDir) {
+	const manifestPath = join$1(publicDir, ".vite", "manifest.json");
+	if (!existsSync(manifestPath)) return null;
+	try {
+		return JSON.parse(readFileSync(manifestPath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/**
+* 服务端环境构建的 outDir → 客户端产物目录（`<outputDir>/server` → `<outputDir>/public`）。
+*
+* 用**本次构建的 outDir** 而不是配置里的 `build.outputDir`：`--outDir` 会覆盖后者，而插件实例
+* 可能来自用户 `vite.config.ts`（另一份模块实例、另一份配置对象），读配置会拿到过期的值。
+*/
+function clientPublicDirFor(serverOutDir) {
+	return join$1(dirname$1(serverOutDir), "public");
+}
+/**
+* 解析要注入的资产标签：内存 manifest 优先，其次读服务端 outDir 旁的磁盘清单。
+*
+* 磁盘兜底存在的原因：CLI 驱动的构建（默认路径与开关路径都算）拿不到核心插件实例的 ref ——
+* 那是用户 `vite.config.ts` 里 `ubeanPlugin()` 的内部状态。此时按 outDir 推断位置读盘，仍满足
+* 「服务端产物自包含」（值在构建期内联，运行时不读盘）。
+*/
+function resolveInjectedAssetTags(inMemory, serverOutDir) {
+	if (inMemory) return {
+		tags: computeAssetTags(inMemory),
+		source: "memory"
+	};
+	if (serverOutDir) {
+		const fromDisk = readClientManifestFromDisk(clientPublicDirFor(serverOutDir));
+		if (fromDisk) return {
+			tags: computeAssetTags(fromDisk),
+			source: "disk"
+		};
+	}
+	return {
+		tags: computeAssetTags(null),
+		source: "none"
+	};
+}
+/**
+* 提供 `virtual:ubean-asset-manifest` 的独立插件。
+*
+* **仅在没有核心插件时使用**（`!userViteConfig` 且未注册 `ubeanPlugin()` 的极端情形）。有核心
+* 插件时不要注册本插件 —— 两个提供者会各自持有 ref，谁先解析谁说了算，实测就是这条导致了
+* 「标签内联为空」的生产缺陷。
+*
+* `getManifest` 在**服务端环境加载该模块时**调用 —— 因此调用方可以先建 builder、按顺序构建
+* client，再把 manifest 填进闭包变量，服务端构建时自然读到最新值（无需重建插件实例）。
+*/
+function ubeanAssetManifestPlugin(getManifest, getServerOutDir) {
+	return {
+		name: "ubean:asset-manifest",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === "virtual:ubean-asset-manifest") return RESOLVED_ID;
+		},
+		load(id, options) {
+			if (id !== RESOLVED_ID) return void 0;
+			const { tags, source } = resolveInjectedAssetTags(getManifest(), getServerOutDir?.());
+			if (source === "none") logger$5.warn(`${ASSET_MANIFEST_VIRTUAL_ID} 注入时没有可用的 client manifest（环境：${options?.ssr ? "server" : "client"}）—— 产出的 HTML 将不含 asset tags。`);
+			return `export const assetTags = ${JSON.stringify({
+				...tags,
+				favicon: null
+			})};\n`;
+		}
+	};
+}
+//#endregion
+//#region src/vite/cloudflare-preview.ts
+/**
+* Cloudflare 产物的本地预览 runner（RM-V26）。
+*
+* 目的：`wrangler dev` 不可用时也能预览 worker 产物 —— 直接把构建出来的 `dist/server/worker.mjs`
+* 交给 **miniflare** 在进程内跑，而不是让用户去装 wrangler 或上传到 Cloudflare 才知道产物对不对。
+*
+* `miniflare` 是**可选 peer**（同 `satori`/`@resvg/resvg-js` 的约定）：本模块动态 import 它，缺失时
+* 返回 `{ ok: false, reason: 'miniflare-not-installed' }` 而不是抛错 —— 调用方据此给出可执行的提示，
+* 其余 preview 形态（node / static）完全不受影响。
+*
+* 实测过的 miniflare 面（4.20250214.0-rc.0）：
+* - 构造：`new Miniflare({ modules: [{ type: 'ESModule', path }], compatibilityDate })`
+* - 就绪：`await mf.ready`
+* - 派发：`mf.dispatchFetch(url, { method, headers, body })` —— **注意**这个版本的
+*   `dispatchFetch` 不接受 `Request` 实例（实测 `Failed to parse URL from [object Request]`），
+*   因此这里拆成 url + init，非 GET/HEAD 时用 `arrayBuffer()` 带体（POST 体实测可达 worker）。
+* - 释放：`mf.dispose()`
+*
+* 静态资源**不经 miniflare 的 `assets` 选项**：该选项在本版本上 `mf.ready` 直接失败
+* （`The Workers runtime failed to start`）。改为与 Cloudflare 平台同构的做法 —— 静态层在当前
+* 进程先服务 `dist/public`（预渲染 HTML / 资源），未命中再交给 worker。
+*/
+const DEFAULT_COMPATIBILITY_DATE = "2024-09-01";
+const MINIFLARE_INSTALL_HINT = "Install it with `pnpm add -D miniflare`, or preview with `wrangler dev` instead.";
+/**
+* 默认加载器：动态 import `miniflare`。
+*
+* 规格字符串放进变量是**故意的** —— 让打包器无法静态解析这个可选依赖（否则构建会尝试解析一个
+* 未安装的包）。
+*/
+async function defaultLoadMiniflare() {
+	const specifier = "miniflare";
+	try {
+		return (await import(
+			/* @vite-ignore */
+			specifier
+)).Miniflare ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 创建 Cloudflare 预览 runner。
+*
+* 失败不抛错：返回带 `reason` 的结果，让调用方决定是降级提示还是继续（与可选依赖的整体策略一致）。
+*/
+async function createCloudflarePreviewRunner(options) {
+	const { workerPath, compatibilityDate, compatibilityFlags, loadMiniflare = defaultLoadMiniflare } = options;
+	const wranglerToml = resolve$1(dirname$1(workerPath), "..", "wrangler.toml");
+	const resolvedDate = compatibilityDate ?? readCompatibilityDate(wranglerToml) ?? DEFAULT_COMPATIBILITY_DATE;
+	const resolvedFlags = compatibilityFlags ?? readCompatibilityFlags(wranglerToml) ?? ["nodejs_compat"];
+	if (!existsSync(workerPath)) return {
+		ok: false,
+		reason: "worker-missing",
+		message: `Build output not found: ${workerPath}. Run \`ubean build\` first to create a production build.`
+	};
+	const Miniflare = await loadMiniflare();
+	if (!Miniflare) return {
+		ok: false,
+		reason: "miniflare-not-installed",
+		message: `The cloudflare preset needs \`miniflare\` to preview locally. ${MINIFLARE_INSTALL_HINT}`
+	};
+	const instance = new Miniflare({
+		modulesRoot: commonAncestor(process.cwd(), dirname$1(workerPath)),
+		modules: workerModuleEntries(workerPath),
+		compatibilityDate: resolvedDate,
+		compatibilityFlags: resolvedFlags
+	});
+	try {
+		await instance.ready;
+	} catch (err) {
+		await instance.dispose().catch(() => void 0);
+		return {
+			ok: false,
+			reason: "worker-failed-to-start",
+			message: `The Cloudflare worker bundle failed to start in workerd: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	return {
+		ok: true,
+		runner: {
+			async fetch(request) {
+				const method = request.method || "GET";
+				const hasBody = method !== "GET" && method !== "HEAD";
+				return instance.dispatchFetch(request.url, {
+					method,
+					headers: request.headers,
+					body: hasBody ? await request.arrayBuffer() : void 0
+				});
+			},
+			dispose: () => instance.dispose()
+		}
+	};
+}
+/**
+* worker 目录下所有需要登记的模块。
+*
+* miniflare（同 wrangler）把 `modules` 当**权威模块表**：产物里 `worker.mjs` 会
+* `import './entry.mjs'`，若只登记 worker，运行时直接报 `No such module "entry.mjs"`（实测）。
+* 因此遍历同目录的 `.mjs`（含 chunk 划分的产物），路径用 **cwd 相对**形态（见调用处的路径语义说明）。
+*/
+function workerModuleEntries(workerPath) {
+	const dir = dirname$1(workerPath);
+	const toEntry = (file) => ({
+		type: "ESModule",
+		path: relative$1(process.cwd(), file)
+	});
+	const entries = [toEntry(workerPath)];
+	try {
+		for (const file of readdirSync(dir)) {
+			if (!file.endsWith(".mjs")) continue;
+			const full = join$1(dir, file);
+			if (full !== workerPath) entries.push(toEntry(full));
+		}
+	} catch {}
+	return entries;
+}
+/** 两个路径的公共祖先（用于 workerd 的模块名基准）。 */
+function commonAncestor(a, b) {
+	const partsA = resolve$1(a).split(sep);
+	const partsB = resolve$1(b).split(sep);
+	const common = [];
+	for (let i = 0; i < Math.min(partsA.length, partsB.length); i += 1) {
+		if (partsA[i] !== partsB[i]) break;
+		common.push(partsA[i]);
+	}
+	return common.join(sep) || sep;
+}
+/** 从 wrangler.toml 里取 `compatibility_flags`（预览必须与部署用同一组标志）。 */
+function readCompatibilityFlags(wranglerToml) {
+	if (!existsSync(wranglerToml)) return void 0;
+	try {
+		const match = /compatibility_flags\s*=\s*\[([^\]]*)\]/.exec(readFileSync(wranglerToml, "utf-8"));
+		if (!match) return void 0;
+		const flags = match[1].split(",").map((part) => part.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+		return flags.length > 0 ? flags : void 0;
+	} catch {
+		return;
+	}
+}
+/** 从 wrangler.toml 里取兼容性日期（preset 生成的文件就是它的产物契约）。 */
+function readCompatibilityDate(wranglerToml) {
+	if (!existsSync(wranglerToml)) return void 0;
+	try {
+		return /compatibility_date\s*=\s*"([^"]+)"/.exec(readFileSync(wranglerToml, "utf-8"))?.[1];
+	} catch {
+		return;
+	}
+}
+/**
+* workerd（Cloudflare Workers 运行时）不支持的 Node 内建 —— 即使开了 `nodejs_compat` 也不行。
+* 列在这里是为了让构建期的告警能直接点名，而不是等 worker 起不来时再去猜。
+*/
+const UNSUPPORTED_IN_WORKERD = [
+	"node:fs",
+	"node:fs/promises",
+	"node:net",
+	"node:os",
+	"node:child_process",
+	"node:worker_threads"
+];
+/**
+* 审计 worker 产物里的 Node 内建导入（返回命中的模块名，全部不重复）。
+*
+* 起因是一次实测：cloudflare preset 构建出的 `server/worker.mjs` 在图里带进了 `node:fs/promises`
+* （来自 `@ubean/app` / `@ubean/server/static` 的静态服务路径），miniflare 启动时直接报
+* `No such module "node:fs/promises"` —— **产物在 worker 运行时里根本起不来**。文件清单比对与体积
+* 门禁都看不见这类问题（不看产物内容，更不会去跑它）。
+*
+* 这里只报告、不阻断：把失败从「运行时谜团」变成「构建期清单」，同时保持既有构建行为不变。
+* 真正的修法是让 Node 专有路径在 worker 构建里消失（条件注册 / 动态 import），属于独立一笔。
+*/
+function findUnsupportedNodeImports(serverDir) {
+	const found = /* @__PURE__ */ new Set();
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join$1(dir, entry);
+			if (isDirectory(full)) {
+				walk(full);
+				continue;
+			}
+			if (!/\.(mjs|js)$/.test(entry)) continue;
+			let code;
+			try {
+				code = readFileSync(full, "utf-8");
+			} catch {
+				continue;
+			}
+			for (const specifier of UNSUPPORTED_IN_WORKERD) if (new RegExp(`(from\\s*|import\\s*\\(\\s*)["']${specifier}["']`).test(code)) found.add(specifier);
+		}
+	};
+	walk(serverDir);
+	return [...found].sort();
+}
+/** 目录判断（不可读时按非目录处理）。 */
+function isDirectory(path) {
+	try {
+		readdirSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/vite/build-steps.ts
+/**
+* 构建步骤的**可复用切片**（Phase 2 地基）。
+*
+* 收敛前的旧编排是一条约 300 行的直线流程：清理输出 → 落盘虚拟模块与 index.html →
+* 两次 `viteBuild`（client / server）→ preset 包装 → 写 manifest。RM-V16 起要把它交给
+* `createBuilder` 的 `buildApp` 编排（`prepare → client env → ubean env → prerender →
+* preset 包装 → manifest`），但目标是**产物逐字节可比**，所以先把与「用 viteBuild 还是
+* builder.build(env)」无关的几步切出来单独可测，再在 `build-app.ts` 里用环境驱动的方式
+* 重新编排。
+*
+* 这里只搬移、不改语义：所有行为与旧编排原先逐段一致。
+*/
+const logger$4 = getLogger("build");
+/** 产物目录布局（`dist/` 根、`dist/public`、`dist/server`，虚拟模块落 `.ubean/virtual`）。 */
+function getBuildOutDirs(cwd, outputDir) {
+	const outputRoot = resolve(cwd, outputDir);
+	return {
+		root: outputRoot,
+		public: join(outputRoot, "public"),
+		server: join(outputRoot, "server"),
+		assets: join(outputRoot, "public", "assets"),
+		virtual: join(cwd, ".ubean", "virtual")
+	};
+}
+/** 清空并重建产物目录（页面/服务端目录按 mode 决定是否创建）。 */
+async function cleanBuildOutput(options) {
+	const { outDirs, hasPages, hasServer, mode, ssrEnabled } = options;
+	logger$4.info(`Cleaning output directory... (mode=${mode}${mode === "fullstack" ? `, ssr=${ssrEnabled}` : ""})`);
+	if (existsSync(outDirs.root)) await rm(outDirs.root, {
+		recursive: true,
+		force: true
+	});
+	if (hasPages) await mkdir(outDirs.public, { recursive: true });
+	if (hasServer) await mkdir(outDirs.server, { recursive: true });
+}
+/** 客户端构建的 HTML 入口模板（`index.html` 写进 `.ubean/virtual`，作为 client env 的 input）。 */
+function renderClientIndexHtml() {
+	return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="icon" href="/favicon.svg" type="image/svg+xml" />
+  <title>Ubean App</title>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="virtual:ubean-client-entry"><\/script>
+</body>
+</html>`;
+}
+/** 把客户端 HTML 入口写到虚拟模块目录，返回其路径（client env 的 `build.rollupOptions.input`）。 */
+async function writeClientIndexHtml(virtualDir) {
+	const target = join(virtualDir, "index.html");
+	await writeFile(target, renderClientIndexHtml(), "utf-8");
+	return target;
+}
+/**
+* spa 模式的静态站点入口（`public/index.html`）。
+*
+* fullstack / ssg 的 HTML 由 SSR 渲染（或预渲染）产出，里面的资产标签来自 client manifest；
+* **spa 没有服务端**，客户端构建的 input 是虚拟 entry 而不是 HTML，因此 Vite 不会产出任何 HTML ——
+* 曾经的 spa 产物只有 `assets/`，部署出去没有入口文件（文档承诺的是「static `index.html` + assets」，
+* 实现与文档不符，直到 RM-V36 的矩阵按 mode 断言产物才发现）。
+*
+* 这里在客户端构建之后补出这个入口，资产标签复用与 SSR 相同的 `computeAssetTags()`：同一个
+* manifest、同一套标签规则，避免出现第二种「入口长什么样」的定义。
+*/
+async function writeSpaIndexHtml(options) {
+	const { outDirs, tags } = options;
+	const target = join(outDirs.public, "index.html");
+	const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="icon" href="${tags.favicon ?? "/favicon.svg"}" type="image/svg+xml" />
+  <title>Ubean App</title>
+${tags.css ? `  ${tags.css.split("\n").join("\n  ")}\n` : ""}</head>
+<body>
+  <div id="app"></div>
+  ${tags.body}
+</body>
+</html>`;
+	await writeFile(target, html, "utf-8");
+	return target;
+}
+/**
+* 写 preset 包装文件，返回服务端入口文件名。
+*
+* ssg 模式**不生成**包装：产物是纯静态站点，而包装文件 import 的 `createFetchHandler`
+* 在静态 entry 里不存在。
+*/
+async function writePresetWrapper(options) {
+	const { mode, presetBuildConfig, outDirs, entries } = options;
+	if (mode === "ssg") {
+		logger$4.info("SSG mode: skipping preset server wrapper (static output only)");
+		return "entry.mjs";
+	}
+	if (presetBuildConfig.entryType === "node") {
+		await writeFile(join(outDirs.server, "server.mjs"), entries.node(), "utf-8");
+		await writeFile(join(outDirs.server, "package.json"), JSON.stringify({
+			type: "module",
+			private: true,
+			main: "./server.mjs",
+			dependencies: { hono: "^4.0.0" }
+		}, null, 2), "utf-8");
+		return "server.mjs";
+	}
+	if (presetBuildConfig.entryType === "worker") {
+		await writeFile(join(outDirs.server, "worker.mjs"), entries.worker(), "utf-8");
+		const wranglerToml = `
+name = "ubean-app"
+main = "./server/worker.mjs"
+compatibility_date = "2024-09-23"
+compatibility_flags = ["nodejs_compat"]
+assets = { directory = "./public" }
+`.trim();
+		await writeFile(join(outDirs.root, "wrangler.toml"), wranglerToml, "utf-8");
+		const unsupported = findUnsupportedNodeImports(outDirs.server);
+		if (unsupported.length > 0) logger$4.warn(`worker 产物包含 workerd 不支持的 Node 内建导入（${unsupported.join("、")}）—— Worker 运行时会在启动时直接失败。来源通常是仅 Node 可用的静态服务/文件系统路径。`);
+		return "worker.mjs";
+	}
+	await writeFile(join(outDirs.server, "handler.mjs"), entries.standard(), "utf-8");
+	return "handler.mjs";
+}
+/** 汇总 client manifest 与 preset 信息，写 `dist/manifest.json`（构建产物契约的一部分）。 */
+async function writeBuildManifest(options) {
+	const { cwd, outDirs, clientManifest, serverEntry, preset, hasPages, hasServer } = options;
+	const assets = [];
+	for (const [key, entry] of Object.entries(clientManifest)) assets.push({
+		file: entry.file,
+		src: key,
+		isEntry: entry.isEntry,
+		css: entry.css
+	});
+	const manifest = {
+		assets,
+		entry: serverEntry,
+		clientDir: hasPages ? relative(cwd, outDirs.public) : "",
+		serverDir: hasServer ? relative(cwd, outDirs.server) : "",
+		preset: preset.name || "standard"
+	};
+	await writeFile(join(outDirs.root, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+	logger$4.info(`Build complete! Output: ${outDirs.root}`);
+	if (hasPages) logger$4.info(`  Client assets: ${outDirs.public}`);
+	if (hasServer) {
+		logger$4.info(`  Server bundle: ${outDirs.server}`);
+		logger$4.info(`  Entry: ${serverEntry}`);
+	}
+	return manifest;
+}
+//#endregion
+//#region src/vite/build-configs.ts
+var build_configs_exports = /* @__PURE__ */ __exportAll({
+	CLIENT_VIRTUAL_EXCLUDE: () => CLIENT_VIRTUAL_EXCLUDE,
+	clientOptimizeDepsExclude: () => clientOptimizeDepsExclude,
+	clientOutputNames: () => clientOutputNames,
+	createBuildEnvironments: () => createBuildEnvironments,
+	getBuildOutDirsForConfig: () => getBuildOutDirsForConfig,
+	serverExternal: () => serverExternal,
+	serverOutputNames: () => serverOutputNames
+});
+/** 客户端优化依赖里必须排除的虚拟模块（`ubean` 运行时链与 vue-router 的实例一致性） */
+const CLIENT_VIRTUAL_EXCLUDE = [
+	"virtual:ubean-pages",
+	"virtual:ubean-app",
+	"virtual:ubean-server",
+	"virtual:ubean-client-entry",
+	"#ubean-pages",
+	"#ubean-app",
+	"#ubean-server",
+	"#ubean-client-entry"
+];
+/** 客户端 `optimizeDeps.exclude`（含 `ssrSingletonProdOptimizeExclude` 的既有规则）。 */
+function clientOptimizeDepsExclude() {
+	return ssrSingletonProdOptimizeExclude(CLIENT_VIRTUAL_EXCLUDE);
+}
+/** 客户端产物命名（`assets/[name]-[hash].js` 等）。 */
+function clientOutputNames() {
+	return {
+		entryFileNames: "assets/[name]-[hash].js",
+		chunkFileNames: "assets/chunks/[name]-[hash].js",
+		assetFileNames: "assets/[name]-[hash].[ext]"
+	};
+}
+/**
+* 服务端 external 过滤（RM-V17 要求重审这条）。
+*
+* preset 的 external 里带有 `^ubean` 模式，它与 `resolve.noExternal: ['ubean']` **直接冲突**：
+* 保留会把 ubean 外置，Node 从 node_modules 加载时解析不到 `virtual:ubean-*`（构建期由插件
+* 提供，运行时不存在）。因此统一在派生处剔除，两条路径共用同一判断。
+*/
+function serverExternal(presetBuildConfig) {
+	if (presetBuildConfig.entryType === "worker") return [];
+	return presetBuildConfig.external.filter((entry) => !(entry instanceof RegExp && entry.source.startsWith("^ubean")));
+}
+/**
+* 服务端产物命名 + 打包形态。
+*
+* **非 node 目标必须内联动态 import**：默认路径用 `ssr.target: 'webworker'` 表达这一点
+* （Vite 对 webworker 目标的 SSR 构建会内联），env 驱动路径没有 env 级的 `ssr.target`
+* 等价字段，于是同一个 preset 下两条路径的 server bundle 形状分叉 —— 实测 `standard`
+* （`entryType: 'fetch'`、target 为 webworker）：默认路径 60 个文件（单文件 bundle），
+* builder 路径 175 个（带 `chunks/`）。`node` 与 `cloudflare` 两格原本就一致（前者 target=node，
+* 后者 entryType=worker），因此这里按 **target 是否为 node** 判定内联，与默认路径对齐。
+*/
+function serverOutputNames(presetBuildConfig) {
+	const isNodeTarget = presetBuildConfig.target === "node18" || presetBuildConfig.entryType === "node";
+	return {
+		format: presetBuildConfig.format,
+		entryFileNames: "entry.mjs",
+		chunkFileNames: "chunks/[name]-[hash].mjs",
+		codeSplitting: Boolean(isNodeTarget && presetBuildConfig.entryType !== "worker")
+	};
+}
+/** 由已解析配置取产物目录（插件 `config` 钩子用）。 */
+function getBuildOutDirsForConfig(config) {
+	return getBuildOutDirs(config.rootDir, config.build.outputDir);
+}
+/**
+* 两个 environment 的构建配置（RM-V17 / RM-V21）。
+*
+* **两条路径共用同一份**：CLI 自建 builder 时把它传给 `createBuilder({ environments })`；
+* 插件在 `config` 钩子里把它作为 `environments` 返回（`vite build` 路径由 Vite 建 builder）。
+* 各自写一份必然漂移 —— 之前只有 `outDir` 的极简版本会让客户端环境退回默认入口 `index.html`，
+* `vite build` 直接以 `Cannot resolve entry module index.html` 失败（实测）。
+*/
+function createBuildEnvironments(input) {
+	const { outDirs, clientInput, minify, sourcemap, presetBuildConfig, ssrNoExternal } = input;
+	return {
+		client: {
+			consumer: "client",
+			optimizeDeps: { exclude: clientOptimizeDepsExclude() },
+			build: {
+				outDir: outDirs.public,
+				assetsDir: "assets",
+				minify: minify ? "oxc" : false,
+				sourcemap,
+				manifest: true,
+				ssrManifest: true,
+				emptyOutDir: false,
+				rollupOptions: {
+					input: { app: clientInput },
+					output: clientOutputNames()
+				}
+			}
+		},
+		ubean: {
+			consumer: "server",
+			...presetBuildConfig.entryType === "worker" ? { define: {
+				"process.env.NODE_ENV": "\"production\"",
+				global: "globalThis"
+			} } : {},
+			resolve: {
+				noExternal: presetBuildConfig.entryType === "worker" ? [/./] : ssrNoExternal,
+				external: presetBuildConfig.entryType === "worker" ? [] : ["@ubean/i18n"]
+			},
+			build: {
+				outDir: outDirs.server,
+				ssr: true,
+				minify: presetBuildConfig.entryType === "worker" ? "oxc" : false,
+				sourcemap,
+				emptyOutDir: false,
+				rollupOptions: {
+					input: `${outDirs.virtual}/server-entry.mjs`,
+					external: serverExternal(presetBuildConfig),
+					output: serverOutputNames(presetBuildConfig)
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite/prerender-step.ts
+/**
+* 预渲染步骤（RM-V21 的最后一环）。
+*
+* 原先这段逻辑长在 `cli/src/build.ts` 里 —— 于是 `vite build`（插件驱动的编排）永远产不出
+* 静态 HTML：实测两条路径的产物清单逐项一致，唯一差异就是 9 个预渲染页面。把它搬进
+* `runEnvBuilds`（两条路径共用）之后，`vite build` 与 `ubean build` 才有可比性。
+*
+* 包含三件事：SSG 静态渲染器 / SSR fetcher 的选择、`prerender()` 调用、内容搜索索引
+* （`__search.json` + 可选 Pagefind）。
+*/
+var prerender_step_exports = /* @__PURE__ */ __exportAll({
+	createSsrFetcher: () => createSsrFetcher,
+	loadContentForBuild: () => loadContentForBuild,
+	runPrerenderStep: () => runPrerenderStep
+});
+const logger$3 = getLogger("build");
+/**
+* 用构建好的 SSR entry 驱动渲染：import `entry.mjs`，取其 `createFetchHandler()`，再用合成的
+* `http://localhost<path>` 请求驱动。
+*/
+async function createSsrFetcher(cwd, manifest) {
+	try {
+		const entryPath = resolve(cwd, manifest.serverDir, "entry.mjs");
+		const mod = await import(
+			/* @vite-ignore */
+			pathToFileURL(entryPath).href
+);
+		const createFetchHandler = mod.default ?? mod.createFetchHandler;
+		if (typeof createFetchHandler !== "function") {
+			logger$3.warn("SSR entry does not export createFetchHandler; falling back to placeholder prerender.");
+			return;
+		}
+		const fetch = await createFetchHandler();
+		if (typeof fetch !== "function") {
+			logger$3.warn("SSR entry did not return a fetch handler; falling back to placeholder prerender.");
+			return;
+		}
+		return {
+			fetch: async (url) => {
+				const req = new Request(`http://localhost${url || "/"}`, { headers: { "x-ubean-prerender": "1" } });
+				const res = await fetch(req);
+				return {
+					html: typeof res.text === "function" ? await res.text() : String(res.body ?? ""),
+					statusCode: res.status ?? 200
+				};
+			},
+			close: async () => {
+				try {
+					await mod.close?.();
+				} catch {}
+			}
+		};
+	} catch (err) {
+		logger$3.warn(`Failed to load SSR entry for prerender: ${err instanceof Error ? err.message : String(err)}. Falling back to placeholder prerender.`);
+		return;
+	}
+}
+/**
+* 构建期加载内容集合（内容路由 + 快照）。
+*
+* 与预渲染同因：`contentSnapshot` 决定内容集合页面（如 `/blog/hello`）是否进入预渲染队列，
+* 因此两条构建路径都必须加载它 —— 否则插件路径会少产出这些静态页（实测：`vite build` 比
+* `ubean build` 少 `blog/hello/index.html` 与一个服务端 chunk）。
+*/
+async function loadContentForBuild(cwd, content) {
+	if (!content) return { snapshot: void 0 };
+	try {
+		const mod = await import("@ubean/content");
+		const options = content === true ? {} : content;
+		return { snapshot: mod.scanContentSources(cwd, options) };
+	} catch (error) {
+		getLogger("build").warn(`Content snapshot unavailable — content routes will be skipped: ${String(error)}`);
+		return { snapshot: void 0 };
+	}
+}
+/**
+* 预渲染 + 内容搜索索引。未启用预渲染（`prerender.enabled` 为假且 routeRules 无
+* `prerender: true`）时整段跳过。
+*/
+async function runPrerenderStep(options) {
+	const { cwd, config, scanResult, manifest, contentSnapshot } = options;
+	const hasPrerenderRules = Object.values(config.routeRules || {}).some((rule) => rule?.prerender === true);
+	if (!config.prerender.enabled && !hasPrerenderRules) return;
+	logger$3.info("Prerendering static pages...");
+	let contentRoutes = [];
+	if (contentSnapshot) try {
+		contentRoutes = (await import("@ubean/content")).extractContentPageRoutes(Object.values(contentSnapshot).flat());
+	} catch {}
+	let ssrFetcher;
+	let notFoundRoute = false;
+	let expandRoutes;
+	if (config.mode === "ssg") {
+		const staticRenderer = await createStaticSsgRenderer(cwd, manifest, {
+			pages: scanResult.pages,
+			notFoundPage: scanResult.notFoundPage ?? null,
+			i18n: config.i18n
+		});
+		if (staticRenderer) {
+			ssrFetcher = {
+				fetch: staticRenderer.fetcher,
+				close: async () => {}
+			};
+			expandRoutes = staticRenderer.expandRoutes;
+			notFoundRoute = Boolean(scanResult.notFoundPage);
+			logger$3.info("Using static SSG renderer (direct render, no HTTP pipeline)");
+		}
+	} else ssrFetcher = await createSsrFetcher(cwd, manifest);
+	try {
+		await prerender({
+			cwd,
+			outputDir: config.build.outputDir,
+			pages: scanResult.pages,
+			prerender: config.prerender,
+			routeRules: config.routeRules,
+			contentRoutes,
+			fetcher: ssrFetcher?.fetch,
+			notFoundRoute,
+			expandRoutes
+		});
+	} finally {
+		await ssrFetcher?.close();
+	}
+	if (!contentSnapshot) return;
+	try {
+		const contentMod = await import("@ubean/content");
+		const searchConfig = contentMod.resolveContentSearchConfig(config.content, { ssg: config.mode === "ssg" });
+		const staticDir = resolvePrerenderStaticDir(cwd, config.build.outputDir, resolvePrerenderConfig(config.prerender));
+		if (searchConfig.sections) {
+			const payload = contentMod.generateSearchSectionsSnapshot(contentSnapshot);
+			await mkdir(staticDir, { recursive: true });
+			await writeFile(join(staticDir, "__search.json"), JSON.stringify(payload), "utf-8");
+			const sectionCount = Object.values(payload).reduce((sum, sections) => sum + sections.length, 0);
+			logger$3.info(`Search: wrote __search.json (${sectionCount} sections)`);
+		}
+		if (searchConfig.pagefind) {
+			const res = await contentMod.runPagefindIndex({
+				siteDir: staticDir,
+				createIndexOptions: searchConfig.pagefindOptions,
+				logger: {
+					info: (msg) => logger$3.info(msg),
+					warn: (msg) => logger$3.warn(msg)
+				}
+			});
+			if (res.indexed) logger$3.info("Search: pagefind index generated");
+			else if (res.reason === "pagefind-not-installed") logger$3.info("Search: pagefind is not installed — skipping index. Run `pnpm add -D pagefind` to enable.");
+			else logger$3.warn(`Search: pagefind indexing failed — ${res.error ?? res.reason}`);
+		}
+	} catch (err) {
+		logger$3.warn(`Search index generation skipped: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+//#endregion
+//#region src/vite/build-app.ts
+/**
+* environment 驱动的生产构建（RM-V16 / RM-V21，ADR-0012 §4）。
+*
+* 收敛前的旧编排是**两次独立的 `viteBuild`**（client 一次、
+* server 一次，各自带一份内联配置。新路径用一次 `createBuilder` 建两个环境（`client` /
+* `ubean`）并由 `buildApp` 编排：
+*
+* ```text
+* prepare（清理 + 虚拟模块落盘 + HTML 模板 + 插件组装）
+*   → client env 构建
+*   → ubean env 构建
+*   → 公共目录拷贝 → preset 包装 → manifest
+* ```
+*
+* 三个阶段刻意拆成三个出口（RM-V21），因为**谁来建 builder** 有两种情况：
+* - `buildWithEnvironments()`：调用方（CLI 的旧路径或未来的薄别名）自己建 builder，
+*   env 定义在这里；
+* - 插件（`ubeanPlugin` 的 `config` 钩子）在 `experimental.viteBuilder` 打开时提供
+*   `builder.buildApp`：此时 builder 由 Vite 自己创建、env 由同一钩子注册，插件只需
+*   `prepareBuild` + `runEnvBuilds` —— **不能**再调 `buildWithEnvironments`（那会递归建 builder）。
+*
+* **判据是产物可比**，不是写法漂亮：与 `viteBuild` 无关的步骤已抽到 `build-steps.ts` 两侧共用，
+* env 配置逐条对应旧路径的 `viteBuild` 入参 —— 旧路径写 `ssr.noExternal`/`external` 的地方，
+* 新路径是 server env 的 `resolve.noExternal`/`external`（Vite 6+ 的等价位置）；旧路径的
+* `optimizeDeps.exclude` 属于 client env；islands SSR 空壳插件只挂 ubean env。
+*/
+var build_app_exports = /* @__PURE__ */ __exportAll({
+	buildWithEnvironments: () => buildWithEnvironments,
+	createBuildContext: () => createBuildContext,
+	prepareBuild: () => prepareBuild,
+	runEnvBuilds: () => runEnvBuilds
+});
+const logger$2 = getLogger("build");
+/** 读客户端 manifest（供注入与 manifest 汇总共用）。 */
+function readClientManifest(publicDir) {
+	const manifestPath = join(publicDir, ".vite", "manifest.json");
+	if (!existsSync(manifestPath)) return null;
+	try {
+		return JSON.parse(readFileSync(manifestPath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** 由 options 派生上下文（不做任何 IO）。 */
+function createBuildContext(options) {
+	const { cwd, config, preset, scanResult, minify = true, sourcemap = false, contentSnapshot } = options;
+	const mode = config.mode;
+	return {
+		cwd,
+		config,
+		preset,
+		scanResult,
+		minify,
+		sourcemap,
+		contentSnapshot,
+		mode,
+		hasPages: mode !== "backend",
+		hasServer: mode !== "spa",
+		ssrEnabled: mode === "fullstack" && config.ssr.enabled || mode === "ssg",
+		outDirs: getBuildOutDirs(cwd, config.build.outputDir)
+	};
+}
+/**
+* 第一阶段：清理产物目录、虚拟模块落盘、HTML 模板、插件组装。
+*
+* 插件必须在这里（`createBuilder` 之前）备好；`manifestRef` 的**内容**稍后在 client 构建
+* 完成后填 —— 服务端构建期注入插件读的就是这个载体。
+*/
+async function prepareBuild(ctx, manifestRef = { current: null }) {
+	const { cwd, config, preset, scanResult, contentSnapshot, outDirs, hasPages, hasServer } = ctx;
+	await cleanBuildOutput({
+		outDirs,
+		hasPages,
+		hasServer,
+		mode: ctx.mode,
+		ssrEnabled: ctx.ssrEnabled
+	});
+	logger$2.info("Generating virtual modules...");
+	const virtualRegistry = createVirtualRegistry();
+	await generateVirtualModulesToDisk(cwd, config, scanResult, outDirs.virtual, preset, virtualRegistry, contentSnapshot);
+	if (hasPages) await writeClientIndexHtml(outDirs.virtual);
+	const userViteConfig = findUserViteConfig(cwd);
+	const builtinPlugins = [];
+	if (!userViteConfig) {
+		builtinPlugins.push(ubeanAssetManifestPlugin(() => manifestRef.current, () => outDirs.server));
+		builtinPlugins.push(ubeanPlugin({
+			config,
+			registry: virtualRegistry
+		}));
+		if (hasPages) builtinPlugins.push(...ubeanVite({
+			config,
+			registry: virtualRegistry
+		}), ubeanIslandsPlugin());
+		else if (hasServer) builtinPlugins.push(...ubeanVite({
+			config,
+			registry: virtualRegistry
+		}));
+	}
+	const { plugins } = await resolveModules({
+		cwd,
+		config,
+		builtinPlugins
+	});
+	if (hasServer) plugins.push(perEnvironmentPlugin("ubean", () => createIslandsSsrStubPlugin()));
+	return {
+		...ctx,
+		plugins,
+		presetBuildConfig: getPresetBuildConfig(preset),
+		manifestRef
+	};
+}
+/**
+* 第二、三阶段：按顺序构建两个环境，再做公共目录拷贝 / preset 包装 / manifest。
+*
+* `builder` 由调用方提供：CLI 路径是自建的，插件路径是 Vite 建好后传进 `buildApp` 的。
+*/
+async function runEnvBuilds(builder, prepared) {
+	const { cwd, preset, hasPages, hasServer, outDirs, mode, ssrEnabled, presetBuildConfig, manifestRef } = prepared;
+	if (hasPages) {
+		logger$2.info("Building client bundle...");
+		await builder.build(builder.environments.client);
+		manifestRef.current = readClientManifest(outDirs.public);
+	}
+	if (hasServer) {
+		logger$2.info(ssrEnabled ? "Building SSR bundle..." : "Building server bundle (SSR disabled)...");
+		await builder.build(builder.environments.ubean);
+	}
+	if (hasPages) {
+		const publicDir = join(cwd, "public");
+		if (existsSync(publicDir)) {
+			logger$2.info("Copying public assets...");
+			await cp(publicDir, outDirs.public, { recursive: true });
+		}
+	}
+	const clientManifest = hasPages ? readClientManifest(outDirs.public) ?? {} : {};
+	if (mode === "spa") {
+		const tags = computeAssetTags(clientManifest);
+		await writeSpaIndexHtml({
+			outDirs,
+			tags: {
+				css: tags.css,
+				body: tags.body,
+				favicon: prepared.config.favicon
+			}
+		});
+	}
+	const builtManifest = await writeBuildManifest({
+		cwd,
+		outDirs,
+		clientManifest,
+		serverEntry: hasServer ? await writePresetWrapper({
+			mode,
+			presetBuildConfig: { entryType: presetBuildConfig.entryType },
+			outDirs,
+			entries: {
+				node: generateNodeServerEntry,
+				worker: generateCloudflareWorkerEntry,
+				standard: generateStandardHandlerEntry
+			}
+		}) : "",
+		preset,
+		hasPages,
+		hasServer
+	});
+	await runPrerenderStep({
+		cwd,
+		config: prepared.config,
+		scanResult: prepared.scanResult,
+		manifest: builtManifest,
+		contentSnapshot: prepared.contentSnapshot
+	});
+	return builtManifest;
+}
+/**
+* 一次 `createBuilder` 完成整套生产构建（`ubean build` 与 `vite build` 共用的唯一编排）。
+*
+* **驱动权声明**：本函数自己就是编排者，因此先在环境里声明「构建由调用方驱动」，让插件侧的
+* `config` 钩子**不要**再注册它自己的 `builder.buildApp` —— 否则同一个 config 的 `builder` 字段
+* 会被插件返回值合并掉，本函数的内联编排不再执行、`manifest` 保持 undefined，表现为**静默返回
+* undefined**（RM-V36 把开关默认打开后由 `build-parity.test.ts` 实测撞到）。与 CLI 用的是同一个
+* 环境变量，结束后还原，避免影响同进程内的其它调用。
+*/
+async function buildWithEnvironments(options) {
+	const previous = process.env.UBEAN_BUILD_DRIVEN_BY_CLI;
+	process.env.UBEAN_BUILD_DRIVEN_BY_CLI = "1";
+	try {
+		return await runEnvOrchestration(options);
+	} finally {
+		if (previous === void 0) delete process.env.UBEAN_BUILD_DRIVEN_BY_CLI;
+		else process.env.UBEAN_BUILD_DRIVEN_BY_CLI = previous;
+	}
+}
+async function runEnvOrchestration(options) {
+	const prepared = await prepareBuild(createBuildContext(options));
+	const { cwd, sourcemap, minify, outDirs, presetBuildConfig } = prepared;
+	const userViteConfig = findUserViteConfig(cwd);
+	const clientEntryPath = join(resolve(cwd, options.config.srcDir), "entry.client.ts");
+	const clientInput = existsSync(clientEntryPath) ? clientEntryPath : join(outDirs.virtual, "client-entry.mjs");
+	const ssrOptions = ssrSingletonProdSsr();
+	let manifest;
+	await (await createBuilder({
+		root: cwd,
+		configFile: userViteConfig ?? false,
+		mode: "production",
+		plugins: prepared.plugins,
+		environments: createBuildEnvironments({
+			outDirs,
+			clientInput,
+			minify,
+			sourcemap,
+			presetBuildConfig,
+			ssrNoExternal: ssrOptions.noExternal
+		}),
+		builder: { async buildApp(b) {
+			manifest = await runEnvBuilds(b, prepared);
+		} }
+	})).buildApp();
+	return manifest;
+}
+//#endregion
+//#region src/production.ts
+function toVitePath(p) {
+	return p.replace(/\\/g, "/");
+}
+/**
+* 把扫描到的页面序列化进服务端入口（`const _pages = [...]`）。
+*
+* **白名单必须覆盖语义字段**：此前只序列化了 `relativePath/name/route/layout/reuseTarget/isReuse/
+* pageMeta`，于是 `matchers` / `slot` **在生产构建里丢失** ——
+* dev 用扫描得到的活对象（`enhanceDevApp` / `buildDevSsrRoutes` 直接拿 `scanResult.pages`），所以本地
+* 一切正常，只有构建产物坏掉：带着 `[id=numeric]` 的路由在 dev 返回 404、在生产返回 200（实测）。
+* 这类「dev 正常、产物丢失元数据」的缺陷对用户最不友好，因此单独抽成函数并配单测
+* （`packages/builder/test/page-metadata.test.ts`）。
+*
+* 不含 `fullPath`/`dirname`/`basename`（构建机上的文件系统细节，产物不需要）与 `frontmatter`
+* （Markdown 页正文用，服务端路由不消费）。拦截路由的两个字段（`interceptFrom` /
+* `interceptTarget`）曾在这份白名单里，随该约定一起移除（[docs/adr/0010] 刻意不做）。
+*/
+function serializePagesForEntry(pages) {
+	return JSON.stringify(pages.map((p) => ({
+		relativePath: p.relativePath,
+		name: p.name,
+		route: p.route,
+		path: p.path,
+		layout: p.layout,
+		cache: p.cache,
+		isReuse: p.isReuse,
+		isMarkdown: p.isMarkdown,
+		reuseTarget: p.reuseTarget,
+		pageMeta: p.pageMeta,
+		matchers: p.matchers,
+		slot: p.slot
+	})));
+}
+async function generateVirtualModulesToDisk(cwd, config, scanResult, virtualDir, preset, registry, contentSnapshot) {
+	const mode = config.mode;
+	const ssrEnabled = mode === "fullstack" && config.ssr.enabled || mode === "ssg";
+	const hasPages = mode !== "backend";
+	const hasServer = mode !== "spa";
+	await mkdir(virtualDir, { recursive: true });
+	const srcDirAbs = resolve(cwd, config.srcDir);
+	const viteSrcDir = toVitePath(relative(cwd, srcDirAbs));
+	const viteSrcPrefix = viteSrcDir ? `/${viteSrcDir}` : "";
+	registry.register(createRoutingVirtualModule(scanResult.apiRoutes.map((r) => ({
+		method: r.method?.toUpperCase() || "ALL",
+		path: r.route,
+		id: `${r.method}:${r.route}`,
+		filePath: r.fullPath
+	})), scanResult.middlewares.map((m) => ({
+		path: "/**",
+		filePath: m.fullPath,
+		order: m.order,
+		global: m.global
+	})), cwd));
+	if (hasPages) {
+		registry.register(createPagesVirtualModule(scanResult.pages.map((p) => ({
+			name: p.name,
+			path: p.route,
+			filePath: p.fullPath,
+			layout: p.layout,
+			reuseTarget: p.reuseTarget
+		})), scanResult.layouts.map((l) => ({
+			name: l.name,
+			filePath: l.fullPath,
+			isDefault: l.isDefault
+		})), cwd));
+		registry.register(createMetaVirtualModule());
+		registry.register(createVuePagesVirtualModule(scanResult.pages, scanResult.layouts, scanResult.notFoundPage, scanResult.loadingPage, scanResult.errorPage, localeVueParamFromI18n(config.i18n)));
+		registry.register(createVueAppEntryVirtualModule(scanResult.appEntry));
+		registry.register(createClientEntryVirtualModule());
+	}
+	registry.register(createAppVirtualModule(scanResult.apiRoutes, scanResult.middlewares, hasPages ? scanResult.pages : [], viteSrcPrefix || "/"));
+	registry.register(createLocalesVirtualModule(scanResult.locales, scanResult.defaultLocale, viteSrcPrefix || "/", serializeI18nConfig(config.i18n)));
+	if (hasServer) registry.register(createServerEntryVirtualModule(scanResult.serverEntry));
+	async function writeModule(id, filename, header = "// Auto-generated by ubean\n") {
+		const mod = registry.getModules().find((m) => m.id === id);
+		const content = mod ? await mod.load() : "";
+		await writeFile(join(virtualDir, filename), header + content, "utf-8");
+	}
+	await writeModule("ubean:routes", "routes.mjs");
+	await writeModule("ubean:app-config", "app-config.mjs");
+	await writeModule("ubean:locales", "locales.mjs");
+	if (hasPages) {
+		await writeModule("ubean:pages", "pages.ts");
+		await writeModule("ubean:meta", "meta.mjs");
+		await writeModule("virtual:ubean-pages", "vue-pages.ts", "");
+		await writeModule("virtual:ubean-app", "vue-app.ts", "");
+		await writeModule("virtual:ubean-client-entry", "client-entry.mjs", "");
+	}
+	if (hasServer) await writeModule("virtual:ubean-server", "server-entry.ts", "");
+	await writeFile(join(virtualDir, "islands-registry.ts"), "export const islands = {};\n", "utf-8");
+	const pagesGlob = JSON.stringify(`${viteSrcPrefix}/pages/**/*.{vue,ts,tsx,js,jsx,md,mdx}`);
+	const routesGlob = JSON.stringify(`${viteSrcPrefix}/routes/**/*.{ts,js,mjs}`);
+	const middlewareGlob = JSON.stringify(`${viteSrcPrefix}/middleware/**/*.{ts,js,mjs}`);
+	const layoutsGlob = JSON.stringify(`${viteSrcPrefix}/layouts/**/*.{vue,ts}`);
+	const cronsDirs = (Array.isArray(config.dir.crons) ? config.dir.crons : [config.dir.crons || "crons"]).map((d) => d.replace(/\\/g, "/"));
+	const cronsGlob = JSON.stringify(cronsDirs.length === 1 ? `${viteSrcPrefix}/${cronsDirs[0]}/**/*.{ts,js,mjs}` : `${viteSrcPrefix}/{${cronsDirs.join(",")}}/**/*.{ts,js,mjs}`);
+	const seoGlob = JSON.stringify(`${viteSrcPrefix}/{sitemap,robots,manifest,opengraph-image,icon,apple-icon}.{ts,js,mjs,mts,cjs}`);
+	const enableInProcessCron = !isEphemeralCachePreset(preset.name || "standard");
+	const enableIpx = Boolean(config.image);
+	const outputDir = config.build.outputDir || "dist";
+	const publicDir = toVitePath(resolve(cwd, outputDir, "public"));
+	const routesJson = JSON.stringify(scanResult.apiRoutes.map((r) => ({
+		relativePath: r.relativePath,
+		route: r.route,
+		method: r.method,
+		fileMeta: r.fileMeta
+	})));
+	const middlewareJson = JSON.stringify(scanResult.middlewares.map((m) => ({
+		relativePath: m.relativePath,
+		order: m.order,
+		global: m.global
+	})));
+	const pagesJson = serializePagesForEntry(scanResult.pages);
+	const layoutsJson = JSON.stringify(scanResult.layouts.map((l) => ({
+		name: l.name,
+		relativePath: l.relativePath,
+		isDefault: l.isDefault
+	})));
+	const notFoundPageJson = JSON.stringify(scanResult.notFoundPage ? {
+		relativePath: scanResult.notFoundPage.relativePath,
+		name: scanResult.notFoundPage.name,
+		route: scanResult.notFoundPage.route,
+		layout: scanResult.notFoundPage.layout,
+		pageMeta: scanResult.notFoundPage.pageMeta
+	} : null);
+	const colorModeScript = config.colorMode !== false ? getColorModeScript(resolveColorModeConfig(config.colorMode)) : "";
+	const rendererImport = ssrEnabled ? `import { createVueRenderer } from 'ubean/ssr';` : "";
+	const prodLocaleVueParam = localeVueParamFromI18n(config.i18n) || "";
+	const rendererSetup = buildRendererSetup({
+		ssrEnabled,
+		mode,
+		localeVueParam: prodLocaleVueParam
+	});
+	const assetTagsSetup = buildAssetTagsSetup(config.favicon);
+	const productionCache = resolveProductionCacheStore(preset.name || "standard", config.cache);
+	const contentEntries = Object.entries(contentSnapshot ?? {}).filter(([, docs]) => Array.isArray(docs));
+	const contentBootstrap = contentEntries.length > 0 ? `
+import { configureContentRuntime, registerContent } from '@ubean/content';
+configureContentRuntime();
+${contentEntries.map(([name, docs]) => `registerContent(${JSON.stringify(name)}, ${JSON.stringify(docs)});`).join("\n")}
+` : "";
+	const ipxImport = enableIpx ? `import { createIpxHonoHandler } from '@ubean/image';
+` : "";
+	const cronImport = enableInProcessCron ? `import { startCronScheduler } from '@ubean/server/cron';
+` : "";
+	if (hasServer) {
+		if (mode === "ssg") {
+			const staticEntry = buildStaticSsgEntry({
+				pagesGlob,
+				layoutsGlob,
+				srcPrefix: JSON.stringify(viteSrcPrefix),
+				pagesJson,
+				layoutsJson,
+				notFoundPageJson,
+				localeVueParam: prodLocaleVueParam,
+				contentBootstrap,
+				colorModeScript,
+				favicon: config.favicon
+			});
+			await writeFile(join(virtualDir, "server-entry.mjs"), staticEntry, "utf-8");
+			return virtualDir;
+		}
+		const serverEntry = `// Auto-generated server entry
+import { createUbeanApp, applyServerConfig } from 'ubean/server';
+import { toVueRouterLocalePath } from '@ubean/i18n';
+import 'ubean:locales';
+${rendererImport}
+import { resolveAppConfig as _resolveAppConfig } from 'virtual:ubean-app';
+import { resolveServerConfig as _resolveServerConfig } from 'virtual:ubean-server';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+${contentBootstrap}${ipxImport}${cronImport}
+export { createUbeanApp };
+
+const routeModules = import.meta.glob(${routesGlob}, { eager: false });
+const middlewareModules = import.meta.glob(${middlewareGlob}, { eager: false });
+const pageModules = import.meta.glob(${pagesGlob}, { eager: false });
+const layoutModules = import.meta.glob(${layoutsGlob}, { eager: false });
+const cronModules = import.meta.glob(${cronsGlob}, { eager: true });
+const seoConventionModules = import.meta.glob(${seoGlob}, { eager: true });
+
+const _srcPrefix = ${JSON.stringify(viteSrcPrefix)};
+function normalizeKey(p) {
+  const prefixes = ['/routes/', '/middleware/', '/pages/', '/layouts/'];
+  for (const prefix of prefixes) {
+    const fullPrefix = _srcPrefix + prefix;
+    if (p.includes(fullPrefix)) {
+      const idx = p.indexOf(fullPrefix);
+      return p.slice(idx + fullPrefix.length);
+    }
+  }
+  return p;
+}
+
+export const routeLoaders = {};
+for (const [key, loader] of Object.entries(routeModules)) {
+  routeLoaders[normalizeKey(key)] = loader;
+}
+
+export const middlewareLoaders = {};
+for (const [key, loader] of Object.entries(middlewareModules)) {
+  middlewareLoaders[normalizeKey(key)] = loader;
+}
+
+export const pageLoaders = {};
+for (const [key, loader] of Object.entries(pageModules)) {
+  pageLoaders[normalizeKey(key)] = loader;
+}
+
+const layoutLoaders = {};
+for (const [key, loader] of Object.entries(layoutModules)) {
+  layoutLoaders[normalizeKey(key)] = loader;
+}
+
+const _routes = ${routesJson};
+const _middleware = ${middlewareJson};
+const _pages = ${pagesJson};
+const _layouts = ${layoutsJson};
+const _notFoundPage = ${notFoundPageJson};
+${rendererSetup}
+${assetTagsSetup}
+
+// 进程内 cron 调度器句柄：必须声明在模块作用域 —— createApp() 赋值、导出的 close() 读取；
+// 若声明在 createApp 内部，close() 里读不到（且它整体包在 try/catch 里，会静默失败），
+// 于是 30s 的调度间隔留在进程里，预渲染后进程永不退出（实测：timer-probe 点出这一段栈）。
+let cronScheduler;
+
+export async function createApp(options = {}) {
+  const app = createUbeanApp({
+    rootDir: ${JSON.stringify(cwd)},
+    routes: _routes,
+    middleware: _middleware,
+    pages: _pages,
+    layouts: _layouts,
+    routeLoaders,
+    middlewareLoaders,
+    pageLoaders,
+    pageRenderer: _pageRenderer,
+    pageAssetTags: _assetTags,
+    publicDir: ${JSON.stringify(publicDir)},
+    i18nConfig: ${JSON.stringify(config.i18n)},
+    ssrExclude: ${JSON.stringify(config.ssr?.exclude ?? [])},
+    streaming: ${JSON.stringify(config.ssr?.streaming ?? false)},
+    notFoundPage: _notFoundPage || undefined,
+    colorModeScript: ${JSON.stringify(colorModeScript)},
+    routeRules: ${JSON.stringify(config.routeRules || {})},
+    csrf: ${JSON.stringify(config.security === false ? false : config.security?.csrf ?? true)},
+    securityHeaders: ${JSON.stringify(config.security === false ? false : config.security?.headers ?? true)},
+    dataCache: ${JSON.stringify(config.dataCache ?? true)},
+    cache: ${JSON.stringify(productionCache)},
+    seoConventions: { srcDir: ${JSON.stringify(srcDirAbs)} },
+    seoConventionModules,
+    ipxHandler: ${enableIpx ? `createIpxHonoHandler({ rootDir: ${JSON.stringify(publicDir)}, staticDir: '.' })` : "undefined"},
+    ...options
+  });
+
+  // Apply user's defineServer config (plugins, hooks, onAppCreate) before init
+  const _serverConfig = _resolveServerConfig('prod');
+  await applyServerConfig(app, _serverConfig);
+
+  await app.init();
+
+  ${enableInProcessCron ? `if (Object.keys(cronModules).length > 0) {
+    cronScheduler = startCronScheduler();
+  }` : ""}
+
+  // Call onServerReady after init completes
+  if (_serverConfig.onServerReady) {
+    await _serverConfig.onServerReady(app);
+  }
+
+  return app;
+}
+
+export default async function createFetchHandler() {
+  const app = await createApp();
+  return app.fetch;
+}
+
+// 释放本 entry 打开的运行时资源（RM-V21）：
+// 预渲染需要 import() 构建好的 entry 来渲染真实 HTML，而 entry 的 createApp() 会启动进程内
+// cron 调度器（以及可能被页面用到的队列 worker / 数据库连接）—— 进程因此不再退出：
+// ubean build 之后 CLI 显式退出看不出来，vite build 则会挂住（实测 13 分钟仍在）。
+// 保留调度器句柄并导出 close()，由预渲染步骤在渲染完成后调用。
+export async function close() {
+  try {
+    await cronScheduler?.stop?.();
+    cronScheduler = null;
+  } catch {}
+  // 经 ubean/server（项目必然依赖 ubean）而非子包路径 @ubean/server/* —— 后者从构建产物
+  // 解析不到，清理会静默失败（实测：定时器还在，进程不退）。
+  try {
+    const runtime = await import('ubean/server');
+    runtime.disposeMemoryRateLimitStores?.();
+    await runtime.stopQueueWorkers?.();
+    await runtime.closeDatabases?.();
+  } catch {}
+}
+
+export const handler = async (req, ctx) => {
+  const app = await createApp();
+  return app.fetch(req, ctx);
+};
+`;
+		await writeFile(join(virtualDir, "server-entry.mjs"), serverEntry, "utf-8");
+	}
+	return virtualDir;
+}
+function getPresetBuildConfig(preset) {
+	switch (preset.name) {
+		case "node":
+		case "bun":
+		case "deno": return {
+			format: "esm",
+			target: "node18",
+			entryType: "node",
+			external: [
+				"hono",
+				"vue",
+				"vue/server-renderer",
+				/^ubean(\/.*)?$/,
+				/^node:/
+			]
+		};
+		case "cloudflare": return {
+			format: "esm",
+			target: "es2022",
+			entryType: "worker",
+			external: [
+				"hono",
+				"vue",
+				"vue/server-renderer",
+				/^ubean(\/.*)?$/
+			]
+		};
+		default: return {
+			format: "esm",
+			target: "es2022",
+			entryType: "fetch",
+			external: [
+				"hono",
+				"vue",
+				"vue/server-renderer",
+				/^ubean(\/.*)?$/
+			]
+		};
+	}
+}
+/**
+* SSR 期的 islands 注册表空壳插件。
+*
+* 真正的注册表由 `ubeanIslandsPlugin` 在**客户端**构建期填充；SSR 期 islands 由服务端渲染
+* （不水合），空壳即可 —— 但不能让它以裸 `virtual:ubean-islands-registry` 泄漏给 Node。
+*/
+function createIslandsSsrStubPlugin() {
+	return {
+		name: "ubean:islands-ssr-stub",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === "virtual:ubean-islands-registry") return "\0virtual:ubean-islands-registry";
+		},
+		load(id) {
+			if (id === "\0virtual:ubean-islands-registry") return "export const islands = {};";
+		}
+	};
+}
+function generateNodeServerEntry() {
+	return `// Auto-generated ubean Node.js server entry
+import { createServer } from 'node:http';
+import createFetchHandler from './entry.mjs';
+
+const port = Number(process.env.PORT || 9527);
+const host = process.env.HOST || '0.0.0.0';
+
+async function main() {
+  const fetch = await createFetchHandler();
+
+  const server = createServer(async (req, res) => {
+    try {
+      const protocol = req.socket?.encrypted ? 'https' : 'http';
+      const url = \`\${protocol}://\${req.headers.host || host}\${req.url || '/'}\`;
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+          if (Array.isArray(value)) {
+            for (const v of value) headers.append(key, v);
+          } else {
+            headers.set(key, value);
+          }
+        }
+      }
+      const method = req.method || 'GET';
+      const body = method === 'GET' || method === 'HEAD' ? undefined : req;
+      const webReq = new Request(url, { method, headers, body, duplex: 'half' });
+      const webRes = await fetch(webReq);
+
+      res.statusCode = webRes.status;
+      res.statusMessage = webRes.statusText;
+      webRes.headers.forEach((value, key) => res.setHeader(key, value));
+
+      if (webRes.body) {
+        const reader = webRes.body.getReader();
+        try {
+          while (true) {
+            const { done, value: chunk } = await reader.read();
+            if (done) break;
+            res.write(chunk);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      res.end();
+    } catch (err) {
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader('Content-Type', 'text/plain');
+      }
+      res.end(err instanceof Error ? err.message : String(err));
+    }
+  });
+
+  server.listen(port, host, () => {
+    console.log(\`ubean server listening on http://\${host}:\${port}\`);
+  });
+
+  const shutdown = () => {
+    server.close(() => process.exit(0));
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main();
+`.trim();
+}
+function generateStandardHandlerEntry() {
+	return `// Auto-generated ubean standard fetch handler
+import createFetchHandler from './entry.mjs';
+
+const handlerPromise = createFetchHandler();
+export default async function fetch(req, ctx) {
+  const handler = await handlerPromise;
+  return handler(req, ctx);
+}
+`.trim();
+}
+function generateCloudflareWorkerEntry() {
+	return `// Auto-generated ubean Cloudflare Worker entry
+import createFetchHandler from './entry.mjs';
+
+const handlerPromise = createFetchHandler();
+export default {
+  async fetch(req, env, ctx) {
+    const handler = await handlerPromise;
+    return handler(req, { ...ctx, env });
+  }
+};
+`.trim();
+}
+//#endregion
+//#region src/vite/preview.ts
+/**
+* `vite preview` 接管（RM-V24，对齐 `nitro:src/build/vite/preview.ts`）。
+*
+* 与 dev 侧同构：请求处理属于**构建工具层**，因此落在插件里，CLI 只负责参数与 banner
+* （RM-V25）。两条形态：
+*
+* - `fullstack` / `backend`：**走生产 handler** —— 直接从 `dist/server/entry.mjs` 取
+*   `createFetchHandler()` 得到的 fetch handler，在进程内 dispatch。刻意不 spawn
+*   `dist/server/server.mjs`（旧 CLI 的做法）：那是「预览一个 Node 服务器」，而预览要验证的
+*   是**产物**。同样刻意不经 `server.mjs`/`handler.mjs` 包装层 —— 它们要么自监听端口
+*   （node/bun/deno），要么是平台适配壳（worker / standard），`entry.mjs` 才是所有 preset
+*   共同的真实产物。静态文件与预渲染 HTML 由产物内的 `serveStatic` 自己服务（与生产一致），
+*   因此这里不再叠一层静态中间件，避免「预览环境比生产环境多一层兜底」。
+* - `spa` / `ssg`：没有服务端 bundle（`hasServer = mode !== 'spa'`，ssg 构建后还会删掉
+*   `dist/server`），只能静态服务 `dist/public`。解析规则（目录 `index.html`、ssg 的
+*   `<path>/index.html` 与 `<path>.html`、spa 回退 `index.html`、路径穿越防护）与 CLI 的
+*   `startStaticServer` 是**同一份实现** —— 两套方言必然分叉，且此处正是历史上踩过
+*   `...` 文件名误判为穿越的地方。
+*/
+const logger$1 = getLogger("preview");
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".wasm": "application/wasm",
+	".txt": "text/plain; charset=utf-8",
+	".map": "application/json; charset=utf-8"
+};
+/** 静态文件的 MIME 推断（CLI 的静态服务器与本插件共用）。 */
+function previewMimeType(filePath) {
+	return MIME_TYPES[extname(filePath).toLowerCase()] || "application/octet-stream";
+}
+/**
+* 把请求路径解析为静态文件（spa / ssg 的规则，单一实现）。
+*
+* 不能用 `pathname.includes('..')` 判穿越：文件名里合法的 `...` 会被误伤（SSG 动态路由产物
+* `_...slug_-Bqlu_Muj.js` 实测踩过）。判据只能是**规范化后的路径是否仍在 root 内**。
+*/
+function resolvePreviewFile(root, pathname, mode) {
+	const rootPath = resolve$1(root);
+	const candidate = normalize$1(join$1(rootPath, pathname));
+	if (candidate !== rootPath && !candidate.startsWith(rootPath + sep)) return { kind: "forbidden" };
+	const isFile = (p) => isPath(p, "file");
+	const isDir = (p) => isPath(p, "dir");
+	if (!isFile(candidate) && isDir(candidate)) {
+		const indexPath = join$1(candidate, "index.html");
+		if (isFile(indexPath)) return {
+			kind: "file",
+			path: indexPath
+		};
+	}
+	if (isFile(candidate)) return {
+		kind: "file",
+		path: candidate
+	};
+	if (mode === "ssg") {
+		const indexPath = join$1(candidate, "index.html");
+		if (isFile(indexPath)) return {
+			kind: "file",
+			path: indexPath
+		};
+		const htmlPath = `${candidate}.html`;
+		if (isFile(htmlPath)) return {
+			kind: "file",
+			path: htmlPath
+		};
+	}
+	if (mode === "spa") {
+		const fallback = join$1(rootPath, "index.html");
+		if (isFile(fallback)) return {
+			kind: "file",
+			path: fallback
+		};
+	}
+	return { kind: "missing" };
+}
+/** 存在且类型匹配（`statSync` 抛错即视为不存在）。 */
+function isPath(p, kind) {
+	try {
+		const s = statSync(p);
+		return kind === "file" ? s.isFile() : s.isDirectory();
+	} catch {
+		return false;
+	}
+}
+/** 把解析结果写成响应；命中文件时流式返回内容。 */
+async function sendPreviewFile(res, path) {
+	const body = await readFile(path);
+	res.statusCode = 200;
+	res.setHeader("Content-Type", previewMimeType(path));
+	res.setHeader("Content-Length", body.length);
+	res.end(body);
+}
+function sendPreviewStatus(res, status, text) {
+	res.statusCode = status;
+	res.setHeader("Content-Type", "text/plain; charset=utf-8");
+	res.end(text);
+}
+/**
+* 预览中间件：按 mode 选择「生产 handler」或「静态文件」。
+*
+* 生产 handler 只加载一次（`entry.mjs` 的模块级单例因此保留，与生产行为一致），失败时把
+* 错误写进响应而不是让 `vite preview` 挂住 —— 预览最常见的失败就是「忘了先构建」。
+*/
+function createPreviewMiddleware(options) {
+	const { rootDir, outputDir, mode, presetName, host = "localhost", loadMiniflare } = options;
+	const outDirAbs = resolve$1(rootDir, outputDir);
+	const staticRoot = resolve$1(outDirAbs, "public");
+	const serverEntry = resolve$1(outDirAbs, "server", "entry.mjs");
+	const staticOnly = mode === "spa" || mode === "ssg";
+	const isCloudflare = presetName === "cloudflare";
+	let handlerPromise = null;
+	/** cloudflare：miniflare runner（worker 产物）；失败结果被缓存，避免每个请求重复尝试。 */
+	let cloudflarePromise = null;
+	const loadCloudflare = () => {
+		cloudflarePromise ??= createCloudflarePreviewRunner({
+			workerPath: resolve$1(outDirAbs, "server", "worker.mjs"),
+			compatibilityDate: readCompatibilityDate(resolve$1(outDirAbs, "wrangler.toml")),
+			compatibilityFlags: readCompatibilityFlags(resolve$1(outDirAbs, "wrangler.toml")),
+			loadMiniflare
+		});
+		return cloudflarePromise;
+	};
+	const loadHandler = () => {
+		handlerPromise ??= (async () => {
+			if (!existsSync(serverEntry)) throw new Error(`Build output not found: ${serverEntry}. Run \`ubean build\` first to create a production build.`);
+			const mod = await import(
+				/* @vite-ignore */
+				pathToFileURL(serverEntry).href
+);
+			const factory = mod.default ?? mod.createFetchHandler;
+			if (typeof factory !== "function") throw new Error(`${serverEntry} 未导出 createFetchHandler —— 产物与当前框架版本不匹配。`);
+			return factory();
+		})();
+		return handlerPromise;
+	};
+	if (!staticOnly) return (req, res, _next) => {
+		(async () => {
+			try {
+				const protocol = req.socket?.encrypted ? "https" : "http";
+				const webReq = await toWebRequest(req, host, protocol);
+				if (isCloudflare) {
+					const staticFile = resolvePreviewFile(staticRoot, new URL(webReq.url).pathname, "ssg");
+					if (staticFile.kind === "forbidden") return sendPreviewStatus(res, 400, "Bad Request");
+					if (staticFile.kind === "file") return sendPreviewFile(res, staticFile.path);
+					const runner = await loadCloudflare();
+					if (!runner.ok) return sendPreviewStatus(res, 501, runner.message);
+					return sendWebResponse(res, await runner.runner.fetch(webReq));
+				}
+				const handler = await loadHandler();
+				await sendWebResponse(res, await handler(webReq));
+			} catch (err) {
+				logger$1.error(`Preview request failed: ${err instanceof Error ? err.message : String(err)}`);
+				sendPreviewStatus(res, 500, err instanceof Error ? err.message : String(err));
+			}
+		})();
+	};
+	const staticMode = mode;
+	return (req, res, _next) => {
+		(async () => {
+			try {
+				const url = new URL(req.url || "/", `http://${req.headers.host || host}`);
+				const pathname = decodeURIComponent(url.pathname);
+				const resolvedFile = resolvePreviewFile(staticRoot, pathname, staticMode);
+				if (resolvedFile.kind === "forbidden") return sendPreviewStatus(res, 400, "Bad Request");
+				if (resolvedFile.kind === "missing") return sendPreviewStatus(res, 404, "Not Found");
+				await sendPreviewFile(res, resolvedFile.path);
+			} catch (err) {
+				sendPreviewStatus(res, 500, err instanceof Error ? err.message : String(err));
+			}
+		})();
+	};
+}
+/**
+* 把预览中间件挂到 server 上。
+*
+* 由**核心插件**调用（同 dev 的请求路由）：「哪条路径都必然注册的那一个插件」才拿得到两端
+* 共用的配置；独立插件从别的插件的 `config` 钩子里注入，在环境化构建下到不了每个环境
+* （RM-V21 踩过同一个坑）。
+*/
+function attachPreviewMiddleware(server, config, host) {
+	const middleware = createPreviewMiddleware({
+		rootDir: config.rootDir,
+		outputDir: config.build.outputDir,
+		mode: config.mode,
+		presetName: resolvePresetName(config.build.preset),
+		host
+	});
+	server.middlewares.use((req, res, next) => middleware(req, res, next));
+}
+/**
+* 解析 preset 名（未注册或未知时返回 `undefined`，此时按 node 形态处理 —— `entry.mjs` 对所有
+* 非 worker preset 都是正确的产物）。
+*/
+function resolvePresetName(name) {
+	if (!name) return void 0;
+	try {
+		registerBuiltinPresets();
+		return resolvePresetByName(name).name;
+	} catch {
+		return name;
+	}
+}
+/**
+* 独立的预览插件（`vite preview` 的显式形态）。
+*
+* 核心插件已内置同一份接线（`attachPreviewMiddleware`），这里保留独立导出便于测试与
+* 「不走 `ubeanPlugin()`」的场景。
+*/
+function ubeanPreviewPlugin(options) {
+	let config = options?.config ?? tryGetConfig() ?? void 0;
+	return {
+		name: "ubean:preview",
+		apply: "serve",
+		async configurePreviewServer(server) {
+			if (!config) config = tryGetConfig() ?? void 0;
+			if (!config) return;
+			attachPreviewMiddleware(server, config, options?.host);
+			logger$1.info(`Preview serving ${config.mode} build from ${join$1(config.rootDir, config.build.outputDir)}`);
+		}
+	};
+}
+//#endregion
+//#region src/vite/shims/index.ts
+/**
+* worker 目标下的 Node 内建桩（构建期重写为**虚拟模块**）。
+*
+* **为什么必须是构建期重写**：worker 运行时（Cloudflare 等）没有文件系统，而打包器会把静态
+* import 的 node 内建**留在产物里** —— workerd 在**模块实例化**阶段就失败
+* （`No such module "node:fs/promises"`），运行时的条件分支和动态 `import()` 都救不了
+* （后者会被 rolldown 内联，连同目标模块顶部的 node:fs）。
+*
+* **为什么用虚拟模块而不是指向一个 `.ts` 文件**：构建产物里 `import.meta.url` 指向 `dist/`，
+* 而源文件不在那里（实测报 `Could not load ../../packages/builder/dist/node-fs.ts`）。虚拟模块
+* 把桩源码内联，与包布局无关。也**不能用 `resolve.alias`**：Vite 解析器对 `node:` 前缀会短路，
+* alias 命不中（实测配了 alias 产物里照样有 `node:fs`）。
+*
+* 只覆盖运行时不支持、且实测会出现在服务端图里的两个：`node:fs` / `node:fs/promises`。
+* `node:crypto` / `node:async_hooks` / `node:path` 由 `nodejs_compat` 兼容标志支持，保持原样。
+*
+* 桩**抛错而不是静默返回空值**：静默降级会把「静态资源没被服务」「缓存没落盘」变成谜题。
+*/
+/**
+* 生成一个桩模块的源码：把 Node 真实模块里的**每个函数导出**都声明一遍（各自抛错）。
+*
+* 为什么要生成而不是手写：worker 构建会把依赖全部打包（`noExternal: true`），于是第三方
+* 依赖也会 `import { readdir, realpathSync, stat } from 'fs'` —— 手写清单必然漏名，而漏名的
+* 表现是**构建期 `MISSING_EXPORT` 失败**（比运行时谜团好，但仍然是无谓的中断）。从真实的
+* `node:fs` 导出面生成，既覆盖完整又跟得上 Node 版本。
+*
+* 非函数导出（`fs.constants` / `fs.promises`）不进桩：它们不是调用点，真被使用时会由打包器
+* 报缺名 —— 那种情况更适合在构建期看见。
+*/
+const RESERVED = /* @__PURE__ */ new Set([
+	"default",
+	"class",
+	"function",
+	"var",
+	"let",
+	"const",
+	"new",
+	"delete",
+	"in",
+	"of"
+]);
+/** 只接受合法且非保留字的标识符（CJS 互操作会给命名空间塞一个 `default`）。 */
+function isDeclarable(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !RESERVED.has(name);
+}
+function buildStubSource(moduleNamespace, runtime, apiPrefix) {
+	return `const MESSAGE = (api) =>
+  api + ' 需要 Node 系运行时（${runtime}）。当前运行时（Cloudflare Workers 等）没有文件系统：' +
+  '静态资源请交给平台层（wrangler.toml 的 assets.directory），缓存请用 store: "memory" 或 KV/对象存储驱动。';
+function unsupported(api) {
+  throw new Error(MESSAGE(api));
+}
+${Object.keys(moduleNamespace).filter((name) => isDeclarable(name) && typeof moduleNamespace[name] === "function").map((name) => `export function ${name}() { return unsupported('${name}'); }`).join("\n")}
+${Object.keys(moduleNamespace).filter((name) => isDeclarable(name) && typeof moduleNamespace[name] !== "function").map((name) => `export const ${name} = new Proxy({}, { get: (_t, prop) => unsupported('${apiPrefix}.${name}.' + String(prop)) });`).join("\n")}
+export default new Proxy({}, { get: (_t, prop) => () => unsupported('${apiPrefix}.' + String(prop)) });
+`;
+}
+const STUB_PREFIX = "\0ubean-node-stub:";
+/** 规格名 → 桩源码（`node:` 前缀与裸包名都收，两者都会被 import）。 */
+const FS_STUB_SOURCE = buildStubSource(nodeFs, "node:fs", "fs");
+const FS_PROMISES_STUB_SOURCE = buildStubSource(nodeFsPromises, "node:fs/promises", "fs/promises");
+const STUB_SOURCES = {
+	"node:fs": FS_STUB_SOURCE,
+	fs: FS_STUB_SOURCE,
+	"node:fs/promises": FS_PROMISES_STUB_SOURCE,
+	"fs/promises": FS_PROMISES_STUB_SOURCE
+};
+/** 该 id 在 worker 目标下是否要换成桩；命中时返回虚拟模块 id。 */
+function resolveWorkerNodeStub(id) {
+	return id in STUB_SOURCES ? `${STUB_PREFIX}${id}` : void 0;
+}
+/** 虚拟模块 id → 源码（`load` 用）；非桩 id 返回 `undefined`。 */
+function loadWorkerNodeStub(id) {
+	if (!id.startsWith(STUB_PREFIX)) return void 0;
+	return STUB_SOURCES[id.slice(17)];
+}
+Object.freeze(Object.keys(STUB_SOURCES));
+//#endregion
+//#region src/dev/dev-worker.ts
+/**
+* dev worker 入口（RM-V09，ADR-0012 §3）。
+*
+* dev 下服务端代码在 env-runner 的 worker 里跑：worker 内用 Vite 的 `ModuleRunner` 经 IPC
+* 向宿主取转换后的模块（对齐 `nitro:src/runtime/internal/vite/dev-worker.mjs`）。
+*
+* 这个入口由**框架生成到项目 `.ubean/` 下**，而不是随包发布：
+* - 避免打包器把 `.mjs` 资源漏掉（`vp pack` 只产出 JS 入口）；
+* - 生成的入口与当前运行的框架版本天然一致，不会出现 worker 用旧版本的情况。
+*/
+/** 生成到 `.ubean/` 下的文件名。 */
+const DEV_WORKER_FILE = "dev-worker.mjs";
+/**
+* worker 入口源码。刻意保持纯 ESM、无类型语法 —— worker 直接由 Node 加载，不经过转换。
+*/
+function getDevWorkerEntrySource(options) {
+	const envName = JSON.stringify(options.envName);
+	const entryId = JSON.stringify(options.entryId);
+	return `// 由 @ubean/build 生成，勿手工编辑（RM-V09）。
+import { createViteTransport } from ${JSON.stringify(options.envRunnerVite ?? "env-runner/vite")};
+import { ModuleRunner, ESModulesEvaluator } from ${JSON.stringify(options.moduleRunner ?? "vite/module-runner")};
+
+const ENV_NAME = ${envName};
+const ENTRY_ID = ${entryId};
+
+const listeners = [];
+let moduleRunner;
+let entryPromise;
+
+async function getEntry() {
+  entryPromise ??= moduleRunner.import(ENTRY_ID).then(mod => mod.default ?? mod);
+  return entryPromise;
+}
+
+export default {
+  async fetch(request) {
+    if (!moduleRunner) return new Response('ubean dev worker: module runner not ready', { status: 503 });
+    try {
+      const entry = await getEntry();
+      if (typeof entry?.fetch === 'function') return entry.fetch(request);
+      return new Response('ubean dev worker: entry has no fetch handler', { status: 500 });
+    } catch (error) {
+      // 把错误带回宿主：worker 直接抛会让连接重置，宿主只看到 ECONNRESET，无从诊断
+      return new Response(\`ubean dev worker error: \${error?.stack || error}\`, { status: 599 });
+    }
+  },
+  ipc: {
+    onOpen({ sendMessage }) {
+      moduleRunner = new ModuleRunner(
+        {
+          transport: createViteTransport(sendMessage, listener => listeners.push(listener), ENV_NAME)
+        },
+        new ESModulesEvaluator()
+      );
+    },
+    onMessage(message) {
+      // 作用域化失效：宿主已经失效了对应模块（连同其 importer 链），这里**只负责重新拿入口**。
+      // 具体的重新求值由 ModuleRunner 自己完成 —— \`fetchModule\` 会因宿主侧 transformResult 被清空
+      // 而返回 \`invalidate: true\`，runner 据此失效该节点，于是它连同受影响的 importer 一起重跑，
+      // 而未命中的模块仍命中 \`{ cache: true }\`，实例（单例）原样保留。
+      // 千万不要在这里按 url 自行失效：宿主若没失效同名模块，下一次 fetch 会因 \`cache: true\` +
+      // 本地 meta 已被清空而抛 “mistakenly invalidated during fetch phase”。
+      if (message?.type === 'ubean:invalidate') {
+        if (Array.isArray(message.urls) && message.urls.length > 0) entryPromise = undefined;
+        return;
+      }
+      // 其余消息按 env-runner 约定转给 transport 监听器
+      for (const listener of listeners) listener(message);
+    }
+  }
+};
+`;
+}
+/** 把 worker 入口写到 `<dir>/dev-worker.mjs`，返回其绝对路径（供 env-runner 的 `data.entry`）。 */
+async function writeDevWorkerEntry(dir, options) {
+	await mkdir(dir, { recursive: true });
+	const target = join$1(dir, DEV_WORKER_FILE);
+	await writeFile(target, getDevWorkerEntrySource(options), "utf8");
+	return target;
+}
+function invalidateDevWorkerModules(environment, runner, files) {
+	const keys = [];
+	const urls = /* @__PURE__ */ new Set();
+	for (const file of files) for (const key of candidateFileKeys(file)) {
+		const mods = environment.moduleGraph.getModulesByFile(key);
+		if (!mods) continue;
+		let hit = false;
+		for (const mod of mods) {
+			hit = true;
+			if (mod.url) urls.add(mod.url);
+			environment.moduleGraph.invalidateModule(mod);
+		}
+		if (hit) keys.push(key);
+	}
+	if (urls.size > 0) runner.sendMessage({
+		type: "ubean:invalidate",
+		urls: [...urls]
+	});
+	return {
+		keys,
+		urls: [...urls]
+	};
+}
+/** 模块图可能用原始路径或 realpath 建索引，两种都试（去重、保序）。 */
+function candidateFileKeys(file) {
+	const keys = [normalizePath(file)];
+	try {
+		keys.push(normalizePath(realpathSync.native(file)));
+	} catch {}
+	return [...new Set(keys)];
+}
+//#endregion
+//#region src/dev/dev-environment.ts
+/**
+* `UbeanDevEnvironment`（RM-V08，ADR-0012 §3）。
+*
+* 形态：宿主侧保留一个继承 Vite `DevEnvironment` 的环境，`dispatchFetch(request)` 把请求转发进
+* env-runner 的 worker（对齐 `nitro/src/build/vite/dev.ts:93-164` 的形态）。
+*
+* **当前状态（2026-09-16 核对）**：本类**没有接进实际 dev 路径** —— `createEnvironment` 全仓无
+* 接线点，RM-V14 收敛后的 `dev-vite.ts` 走的是「插件自举宿主 app + 请求路由中间件」（`getDevApp`
+* 在**主进程**里跑 SSR 模块图）。因此「dev 下服务端代码在 worker 里执行」目前**不成立**，本模块
+* 与它的测试（`dev-environment.test.ts` / `dev-worker.test.ts`）验证的是能力与 IPC 契约，不是线上
+* 行为。Phase 4 的 RM-V28（跨环境单例代理）与 RM-V29（services 环境机制）都服务于这套多环境
+* 拓扑，在拓扑被采用之前不落地 —— 结论与理由见 docs/vite-plugin-migration.md。
+*
+* 分工（依据 `docs/env-runner-spike.md` §7 的实测结论）：
+* - **Vite 自己**负责模块图语义与 `vite:invoke` 的分发 —— `DevEnvironment` 构造时会把传入的
+*   transport 规范化，并挂到 `environment.hot`（`NormalizedHotChannel`）上，其
+*   `handleInvoke()` 是公开方法，不需要我们复刻；
+* - **env-runner** 只负责「跑起 worker + 一条 IPC」。
+*
+* 因此本模块只做两件薄事：把宿主 → worker 的 payload 送出（transport），把 worker → 宿主的
+* `vite:invoke` 交给 Vite 计算后按约定回发（bridge）。
+*/
+/** 与 worker 侧 `createViteTransport(sendMessage, onMessage, envName)` 必须一致。 */
+const UBEAN_DEV_ENV_NAME = "ubean";
+/**
+* 宿主 → worker 的 transport 适配器。
+*
+* 只实现 Vite `HotChannel` 里能实现的部分：`send` 把 payload 送到 worker，`on`/`off` 维护
+* 本地监听表。`skipFsCheck` 置真 —— 同进程 IPC 不是网络通道，无需 fs 访问检查。
+* Vite 会在 `DevEnvironment` 构造时把它规范化（补 `setInvokeHandler` / `handleInvoke`）。
+*/
+function createEnvRunnerTransport(runner, envName = UBEAN_DEV_ENV_NAME) {
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		skipFsCheck: true,
+		send(payload) {
+			runner.sendMessage(tagForEnv(payload, envName));
+		},
+		on(event, listener) {
+			const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+			set.add(listener);
+			listeners.set(event, set);
+		},
+		off(event, listener) {
+			listeners.get(event)?.delete(listener);
+		},
+		api: {}
+	};
+}
+/**
+* 把 worker 发来的 `vite:invoke` 交给 Vite 计算并回发。
+*
+* 回发结构照抄 vite-plus 自己的实现（`dist/vite/node/chunks/node.js:32291-32313`）：
+* 应答 id 由 `send*` 改成 `response*`，`data` 为 `handleInvoke()` 的 `{ result }` / `{ error }`。
+* **必须在 `DevEnvironment` 构造之后调用** —— 那时 `environment.hot` 才存在。
+*/
+function bridgeEnvRunnerInvokes(environment, runner, envName = UBEAN_DEV_ENV_NAME) {
+	runner.onMessage(async (message) => {
+		const payload = message;
+		const inner = payload?.data;
+		if (payload?.type !== "custom" || payload.event !== "vite:invoke" || !inner?.id) return;
+		const outcome = await environment.hot.handleInvoke({
+			type: "custom",
+			event: "vite:invoke",
+			data: inner
+		});
+		runner.sendMessage(tagForEnv({
+			type: "custom",
+			event: "vite:invoke",
+			data: {
+				name: inner.name,
+				id: inner.id.replace("send", "response"),
+				data: outcome
+			}
+		}, envName));
+	});
+}
+/**
+* env-runner 按 `viteEnv` 给消息分命名空间（`env-runner/dist/vite.mjs`）：worker 侧
+* `createViteTransport` 只接受带本环境名的消息。宿主发出的任何 payload 都必须打上该标记，
+* 否则会被静默丢弃 —— 表现为 worker 侧 invoke 长时间无应答。
+*/
+function tagForEnv(payload, envName) {
+	return {
+		...payload,
+		viteEnv: envName
+	};
+}
+var UbeanDevEnvironment = class extends DevEnvironment {
+	#runner;
+	constructor(name, config, context, runner) {
+		super(name, config, {
+			...context,
+			transport: context.transport ?? createEnvRunnerTransport(runner, name)
+		});
+		this.#runner = runner;
+		bridgeEnvRunnerInvokes(this, runner, name);
+	}
+	/**
+	* ADR-0012 §3：框架请求入口把 Web `Request` 转发进 worker 内的 Hono app。
+	* 宿主进程不再执行服务端代码，因此服务端崩溃不会带走 dev server。
+	*/
+	async dispatchFetch(request) {
+		return this.#runner.fetch(request);
+	}
+};
+/**
+* 生成 `environments.<name>.dev.createEnvironment` 需要的工厂（RM-V09 的能力，**尚未接线** ——
+* 全仓没有 `createEnvironment` 的注册点，原因见文件头「当前状态」）。
+*/
+function createUbeanDevEnvironmentFactory(runner) {
+	return (name, config, context) => new UbeanDevEnvironment(name, config, context, runner);
+}
+//#endregion
+//#region src/vite.ts
+const logger = getLogger("build");
+const VIRTUAL_MODULES = [
+	"ubean:routes",
+	"ubean:pages",
+	"ubean:meta",
+	"ubean:app-config",
+	"ubean:locales"
+];
+const VIRTUAL_PREFIX = "\0ubean:";
+const RESOLVED_ASSET_MANIFEST_ID = `\0${ASSET_MANIFEST_VIRTUAL_ID}`;
+/**
+* ubean 核心 Vite 插件(框架无关部分)。
+*
+* 提供:
+* - 虚拟模块(`ubean:routes`、`ubean:pages`、`ubean:meta`、`ubean:app-config`、`ubean:locales`)
+* - 宏转换(`definePage` / `defineMeta` 在 `.ts` / `.vue` 中被剥离)
+* - 文件监听(dev 模式下扫描 `routes` / `middleware` / `pages` / `layouts` / `plugins` / `locales`)
+* - 实体路由文件生成(当 `routing.mode` 为 `'file'` 或 `'both'` 时触发 `@ubean/vue/generator`)
+*
+* Vue 专属的虚拟模块(`virtual:ubean-pages`、`virtual:ubean-app` 等)由 `@ubean/build/vue` 的
+* `ubeanVite` 提供,二者共用 `useVirtualRegistry()` 注册表。
+*
+* @example 在 vite.config.ts 中使用(自动加载 ubean.config)
+* ```typescript
+* import { defineConfig } from 'vite';
+* import { ubeanPlugin } from '@ubean/build/vite';
+*
+* export default defineConfig({
+*   plugins: [ubeanPlugin()]
+* });
+* ```
+*
+* @example 显式传入配置(ubean dev/build 内部使用)
+* ```typescript
+* ubeanPlugin({ config: resolvedConfig })
+* ```
+*/
+/**
+* 开关打开时插件侧的 environment 构建配置（RM-V21）。
+*
+* 与 CLI 自建 builder 共用 `createBuildEnvironments()` —— 只写 `outDir` 的极简版本会让客户端
+* 环境退回默认入口 `index.html`（实测报 `Cannot resolve entry module index.html`）。
+*/
+async function buildEnvironmentsForConfig(config) {
+	const [{ createBuildEnvironments, getBuildOutDirsForConfig }, { getPresetBuildConfig }, { resolvePresetByName, registerBuiltinPresets }, { ssrSingletonProdSsr }] = await Promise.all([
+		Promise.resolve().then(() => build_configs_exports),
+		import("./production.js"),
+		import("@ubean/preset"),
+		import("./ssr-singleton-DPTawJSx.js").then((n) => n.s)
+	]);
+	registerBuiltinPresets();
+	const outDirs = getBuildOutDirsForConfig(config);
+	const clientEntryPath = join(resolve(config.rootDir, config.srcDir), "entry.client.ts");
+	return createBuildEnvironments({
+		outDirs,
+		clientInput: existsSync(clientEntryPath) ? clientEntryPath : join(outDirs.virtual, "client-entry.mjs"),
+		minify: true,
+		sourcemap: false,
+		presetBuildConfig: getPresetBuildConfig(resolvePresetByName(config.build.preset)),
+		ssrNoExternal: ssrSingletonProdSsr().noExternal
+	});
+}
+function ubeanPlugin(options) {
+	const virtualRegistry = options?.registry ?? createVirtualRegistry();
+	let ubeanConfig = options?.config ?? tryGetConfig() ?? void 0;
+	/** client manifest 的内存载体（RM-V18）：`buildApp` 填、本插件的 load 读。 */
+	const assetManifestRef = { current: null };
+	let srcDirAbs = "";
+	let viteSrcDir = "";
+	let viteSrcPrefix = "";
+	/** 当前构建是否为 worker 目标（缓存：preset 在一次构建内不变）。 */
+	let workerTarget;
+	function isWorkerTarget() {
+		if (workerTarget !== void 0) return workerTarget;
+		workerTarget = false;
+		const presetName = process.env.UBEAN_BUILD_PRESET || ubeanConfig?.build.preset;
+		if (presetName) try {
+			registerBuiltinPresets();
+			workerTarget = getPresetBuildConfig(resolvePresetByName(presetName)).entryType === "worker";
+		} catch {
+			workerTarget = false;
+		}
+		return workerTarget;
+	}
+	function ensureDerived() {
+		if (!ubeanConfig) return;
+		srcDirAbs = resolve(ubeanConfig.rootDir, ubeanConfig.srcDir);
+		viteSrcDir = relative(ubeanConfig.rootDir, srcDirAbs).replace(/\\/g, "/");
+		viteSrcPrefix = viteSrcDir ? `/${viteSrcDir}` : "";
+	}
+	if (ubeanConfig) ensureDerived();
+	return {
+		name: "ubean:core",
+		enforce: "pre",
+		/**
+		* ADR-0012（RM-V36 收敛后为唯一路径）：以插件身份注册 `client` / `ubean` 两个环境，生命周期
+		* 交给 `vite dev|build|preview`。此前由 `experimental.viteBuilder` 开关隔离的旧编排已下线。
+		*
+		* 唯一例外是**构建已由调用方驱动**（`ubean build` 自建 builder 并传入同一套 env 配置）——
+		* 那时插件不能再注册自己的 `buildApp`/`environments`，否则同一份构建会被编排两次
+		* （插件返回值会覆盖内联的 `builder` 字段，表现为静默产出不完整）。
+		*/
+		async config() {
+			if (!ubeanConfig) {
+				ubeanConfig = await loadUbeanConfig();
+				ensureDerived();
+			}
+			if (process.env.UBEAN_BUILD_DRIVEN_BY_CLI === "1") return void 0;
+			return {
+				/**
+				* RM-V21：开关打开时构建编排也交给插件 —— `vite build`（无 CLI）因此能产出
+				* `dist/{public,server,manifest.json}`。builder 与 environments 由 Vite 按本钩子创建，
+				* 插件只跑拆分好的阶段（`prepareBuild` → `runEnvBuilds`），**不**自建 builder（会递归）。
+				*
+				* 已知缺口：**预渲染**尚未接入本路径（`prerender()` 目前由 CLI 调用），因此
+				* `vite build` 的产物缺静态 HTML，与 `ubean build` 仍不等价（RM-V23 的矩阵会据此判定）。
+				*/
+				builder: { async buildApp(builder) {
+					const [{ createBuildContext, prepareBuild, runEnvBuilds }, { resolvePresetByName, registerBuiltinPresets }, { loadContentForBuild }] = await Promise.all([
+						Promise.resolve().then(() => build_app_exports),
+						import("@ubean/preset"),
+						Promise.resolve().then(() => prerender_step_exports)
+					]);
+					registerBuiltinPresets();
+					const scanResult = await scanProject({
+						cwd: ubeanConfig.rootDir,
+						srcDir: ubeanConfig.srcDir,
+						dirs: ubeanConfig.dir,
+						ignore: ubeanConfig.scanOptions?.ignore
+					});
+					const { snapshot: contentSnapshot } = await loadContentForBuild(ubeanConfig.rootDir, ubeanConfig.content);
+					await runEnvBuilds(builder, await prepareBuild(createBuildContext({
+						cwd: ubeanConfig.rootDir,
+						config: ubeanConfig,
+						preset: resolvePresetByName(ubeanConfig.build.preset),
+						scanResult,
+						contentSnapshot
+					}), assetManifestRef));
+				} },
+				environments: await buildEnvironmentsForConfig(ubeanConfig)
+			};
+		},
+		async buildStart() {
+			if (!ubeanConfig) {
+				ubeanConfig = await loadUbeanConfig();
+				ensureDerived();
+			}
+			await scanAndRegister();
+		},
+		resolveId(id) {
+			if (this.environment?.name === "ubean" && isWorkerTarget()) {
+				const stub = resolveWorkerNodeStub(id);
+				if (stub) return stub;
+			}
+			if (id === "virtual:ubean-asset-manifest") return RESOLVED_ASSET_MANIFEST_ID;
+			if (VIRTUAL_MODULES.includes(id)) return VIRTUAL_PREFIX + id;
+		},
+		/**
+		* worker 目标：把产物里的 `import.meta.url` 换成合法的 `file://` 值。
+		*
+		* workerd 的 ESM 里它**是 undefined**（实测），而打包器为 CJS 依赖生成的互操作垫片正是
+		* `createRequire(import.meta.url)`，且**在模块实例化时执行** —— 于是 worker 报
+		* `The argument 'path' … Received 'undefined'` 起不来。`createRequire('file:///worker.mjs')`
+		* 在 workerd 上实测可用，垫片因此能构造（动态 `require()` 仍解析不到用户依赖，但那类调用只可能
+		* 出现在 Node-only 分支里）。
+		*
+		* 用 `renderChunk` 而不是 `define`：define 只作用于源码，**够不到打包器自己生成的垫片**
+		* （实测替换后第 46 行的 `__require` 仍是 `import.meta.url`）。
+		*/
+		renderChunk(code) {
+			if (this.environment?.name !== "ubean" || !isWorkerTarget() || !code.includes("import.meta.url")) return null;
+			return {
+				code: code.split("import.meta.url").join("\"file:///worker.mjs\""),
+				map: null
+			};
+		},
+		async load(id) {
+			const stubSource = loadWorkerNodeStub(id);
+			if (stubSource !== void 0) return stubSource;
+			if (id === RESOLVED_ASSET_MANIFEST_ID) {
+				const serverOutDir = this.environment?.config?.build?.outDir;
+				const { tags, source } = resolveInjectedAssetTags(assetManifestRef.current, serverOutDir);
+				if (source === "none") logger.warn(`${ASSET_MANIFEST_VIRTUAL_ID} 注入时没有可用的 client manifest（服务端 outDir=${serverOutDir ?? "unknown"}）—— 产出的 HTML 将不含 asset tags。`);
+				return `export const assetTags = ${JSON.stringify({
+					...tags,
+					favicon: null
+				})};\n`;
+			}
+			if (id.startsWith(VIRTUAL_PREFIX)) {
+				const moduleId = id.slice(7);
+				const mod = virtualRegistry.getModules().find((m) => m.id === moduleId);
+				if (mod) return await mod.load();
+			}
+		},
+		transform(code, id) {
+			const result = transformMacros(code, id);
+			if (result !== null && result !== code) return {
+				code: result,
+				map: null
+			};
+			return null;
+		},
+		configureServer(server) {
+			getDevScanCoordinator(server, (source) => ({
+				rootDir: ubeanConfig.rootDir,
+				srcDir: ubeanConfig.srcDir,
+				dirs: ubeanConfig.dir,
+				ignore: ubeanConfig.scanOptions?.ignore,
+				source,
+				scan: () => scanProjectOnce(),
+				reload: () => server.ws.send({ type: "full-reload" })
+			})).subscribe(async (result, changed) => {
+				await applyScan(result);
+				for (const mod of VIRTUAL_MODULES) {
+					const module = server.moduleGraph.getModuleById(VIRTUAL_PREFIX + mod);
+					if (module) server.moduleGraph.invalidateModule(module);
+				}
+				if (changed.some((file) => file.includes("/locales/"))) for (const file of changed.filter((f) => f.includes("/locales/"))) server.ws.send({
+					type: "custom",
+					event: "ubean:locale-update",
+					data: { file }
+				});
+			});
+		},
+		/**
+		* RM-V24：`vite preview` 接管。
+		*
+		* fullstack / backend 把产物里的 fetch handler（`dist/server/entry.mjs`）在进程内接上，
+		* spa / ssg 走静态服务 —— 两种形态的判据都在 `vite/preview.ts`，与 CLI 的 preview 共用
+		* 同一份解析规则（RM-V25 起 CLI 退化为参数与 banner）。
+		*/
+		configurePreviewServer(server) {
+			if (!ubeanConfig) return;
+			attachPreviewMiddleware(server, ubeanConfig);
+		}
+	};
+	function scanProjectOnce() {
+		return scanProject({
+			cwd: ubeanConfig.rootDir,
+			srcDir: ubeanConfig.srcDir,
+			dirs: ubeanConfig.dir,
+			ignore: ubeanConfig.scanOptions?.ignore
+		});
+	}
+	async function scanAndRegister() {
+		if (!ubeanConfig) return;
+		await applyScan(await scanProjectOnce());
+	}
+	/**
+	* 依据扫描结果重建路由/中间件注册与虚拟模块。与扫描分离（RM-V13）：dev 下由
+	* `dev-scan.ts` 的协调器统一扫一次，三个订阅者各取所需。
+	*/
+	async function applyScan(result) {
+		if (!ubeanConfig) return;
+		const router = createServerRouter();
+		for (const mw of result.middlewares) router.addMiddleware(mw);
+		for (const route of result.apiRoutes) router.addApiRoute(route);
+		for (const page of result.pages) router.addPage(page);
+		for (const layout of result.layouts) router.addLayout(layout);
+		virtualRegistry.register(createRoutingVirtualModule(result.apiRoutes.map((r) => ({
+			method: r.method?.toUpperCase() || "ALL",
+			path: r.route,
+			id: `${r.method}:${r.route}`,
+			filePath: r.fullPath
+		})), result.middlewares.map((m) => ({
+			path: "/**",
+			filePath: m.fullPath,
+			order: m.order,
+			global: m.global
+		})), ubeanConfig.rootDir));
+		virtualRegistry.register(createPagesVirtualModule(result.pages.map((p) => ({
+			name: p.name,
+			path: p.route,
+			filePath: p.fullPath,
+			layout: p.layout,
+			reuseTarget: p.reuseTarget
+		})), result.layouts.map((l) => ({
+			name: l.name,
+			filePath: l.fullPath,
+			isDefault: l.isDefault
+		})), ubeanConfig.rootDir));
+		virtualRegistry.register(createMetaVirtualModule());
+		virtualRegistry.register(createAppVirtualModule(result.apiRoutes, result.middlewares, result.pages, viteSrcPrefix || "/"));
+		virtualRegistry.register(createLocalesVirtualModule(result.locales, result.defaultLocale, viteSrcPrefix || "/", serializeI18nConfig(ubeanConfig.i18n)));
+		await maybeGenerateRouteFiles(ubeanConfig, result).catch((err) => {
+			console.warn("[ubean:core] Route file generation failed:", err?.message || err);
+		});
+	}
+}
+/**
+* 根据 `routing.mode` 决定是否触发实体文件生成。
+*
+* - `'virtual'`(默认):仅生成 `.ubean/typed-router.d.ts`(类型声明,所有模式都生成)
+* - `'file'`:额外生成 `routes.ts`/`imports.ts` 到 `outputDir`(实体文件,可编辑 `meta`)
+* - `'both'`:同 `'file'`,且虚拟模块也加载实体文件
+*
+* `typed-router.d.ts` 包含 `@ubean/scan` 和 `vue-router`/`vue-router/auto-routes`
+* 的模块增强(让 `useRoute<Name>(name)` 能推断 `route.params` 类型),所有模式
+* 都会生成到 `.ubean/typed-router.d.ts`,与 `auto-imports.d.ts`/`components.d.ts`
+* 等其他纯类型声明产物同目录,由 `.gitignore` 忽略。
+*
+* 由于 `@ubean/vue/generator` 通过动态 import 加载,前端-only 项目
+* (不依赖实体路由文件)即使没有安装 generator 相关依赖也能运行。
+*
+* 注意:`@ubean/config` 与 `@ubean/vue/generator` 的 `getRouteMeta` /
+* `onGenerated` 签名略有差异(配置层面向用户,生成器层面向内部)。本函数
+* 负责适配:把 `(filePath, frontmatter) => meta` 包装为 `(page) => meta`,
+* 把 `GeneratorResult` 转换为 `string[]` 文件路径列表。
+*/
+async function maybeGenerateRouteFiles(config, scanResult) {
+	const mode = config.routing?.mode;
+	const generateEntityFiles = mode === "file" || mode === "both";
+	const routing = config.routing;
+	const outDir = resolve(config.rootDir, routing.outputDir);
+	const dtsPath = resolve(config.rootDir, ".ubean", "typed-router.d.ts");
+	const configGetRouteMeta = routing.getRouteMeta;
+	const generatorGetRouteMeta = configGetRouteMeta ? (page) => configGetRouteMeta(page.relativePath, page.frontmatter ?? {}) : void 0;
+	const { generateRouteFiles } = await import("@ubean/vue/generator");
+	const result = await generateRouteFiles(scanResult, {
+		cwd: config.rootDir,
+		srcDir: config.srcDir,
+		outDir,
+		dtsPath,
+		generateRoutes: generateEntityFiles,
+		generateImports: generateEntityFiles,
+		generateDts: true,
+		routeLazy: routing.routeLazy,
+		layoutLazy: routing.layoutLazy,
+		getRouteMeta: generatorGetRouteMeta,
+		headerComment: void 0,
+		localeVueParam: localeVueParamFromI18n(config.i18n)
+	});
+	if (routing.onGenerated) {
+		const files = [
+			result.routesPath,
+			result.importsPath,
+			result.dtsPath
+		].filter((p) => Boolean(p));
+		routing.onGenerated(files);
+	}
+}
+//#endregion
+export { getPresetBuildConfig as C, createCloudflarePreviewRunner as D, MINIFLARE_INSTALL_HINT as E, defaultLoadMiniflare as O, generateVirtualModulesToDisk as S, buildWithEnvironments as T, ubeanPreviewPlugin as _, createEnvRunnerTransport as a, generateNodeServerEntry as b, getDevWorkerEntrySource as c, attachPreviewMiddleware as d, createPreviewMiddleware as f, sendPreviewStatus as g, sendPreviewFile as h, bridgeEnvRunnerInvokes as i, readCompatibilityDate as k, invalidateDevWorkerModules as l, resolvePreviewFile as m, UBEAN_DEV_ENV_NAME as n, createUbeanDevEnvironmentFactory as o, previewMimeType as p, UbeanDevEnvironment as r, DEV_WORKER_FILE as s, ubeanPlugin as t, writeDevWorkerEntry as u, createIslandsSsrStubPlugin as v, serializePagesForEntry as w, generateStandardHandlerEntry as x, generateCloudflareWorkerEntry as y };