@finesoft/front 0.1.12 → 0.1.14

package/dist/index.js

@@ -1,3 +1,23 @@
+import {
+  History,
+  createPrefetchedIntentsFromDom,
+  deserializeServerData,
+  registerActionHandlers,
+  registerExternalUrlHandler,
+  registerFlowActionHandler,
+  startBrowserApp,
+  tryScroll
+} from "./chunk-T2AQHAYK.js";
+import {
+  createSSRApp
+} from "./chunk-Z4MHYAS3.js";
+import {
+  SSR_PLACEHOLDERS,
+  createSSRRender,
+  injectSSRContent,
+  serializeServerData,
+  ssrRender
+} from "./chunk-2VETWTN5.js";
 import {
   ACTION_KINDS,
   ActionDispatcher,
@@ -10,7 +30,6 @@ import {
   Container,
   DEP_KEYS,
   Framework,
-  History,
   HttpClient,
   HttpError,
   IntentDispatcher,
@@ -18,9 +37,7 @@ import {
   PrefetchedIntents,
   Router,
   buildUrl,
-  createPrefetchedIntentsFromDom,
   defineRoutes,
-  deserializeServerData,
   generateUuid,
   getBaseUrl,
   isCompoundAction,
@@ -34,206 +51,460 @@ import {
   mapEach,
   pipe,
   pipeAsync,
-  registerActionHandlers,
-  registerExternalUrlHandler,
-  registerFlowActionHandler,
   removeHost,
   removeQueryParams,
   removeScheme,
   resetFilterCache,
   shouldLog,
-  stableStringify,
-  startBrowserApp,
-  tryScroll
-} from "./chunk-OVGQ4NUA.js";
+  stableStringify
+} from "./chunk-RVKDILGM.js";
+import {
+  parseAcceptLanguage
+} from "./chunk-FYP2ZYYV.js";
 
-// ../ssr/src/render.ts
-async function ssrRender(options) {
-  const { url, frameworkConfig, bootstrap, getErrorPage, renderApp } = options;
-  const framework = Framework.create(frameworkConfig);
-  bootstrap(framework);
-  const parsed = new URL(url, "http://localhost");
-  const fullPath = parsed.pathname + parsed.search;
-  const match = framework.routeUrl(fullPath);
-  let page;
-  let serverData = [];
-  if (match) {
-    try {
-      page = await framework.dispatch(match.intent);
-      serverData = [{ intent: match.intent, data: page }];
-    } catch {
-      page = getErrorPage(500, "Internal error");
-    }
-  } else {
-    page = getErrorPage(404, "Page not found");
+// ../server/src/adapters/shared.ts
+var BUILD_TOOL_EXTERNALS = [
+  "vite",
+  "esbuild",
+  "rollup",
+  "fsevents",
+  "lightningcss"
+];
+function generateSSREntry(ctx, opts) {
+  const setupImport = ctx.setupPath ? `import _setupDefault from "./${ctx.setupPath}";` : ``;
+  const setupCall = ctx.setupPath ? `if (typeof _setupDefault === "function") await _setupDefault(app);` : ``;
+  const locales = JSON.stringify(ctx.locales);
+  const defaultLocale = JSON.stringify(ctx.defaultLocale);
+  return `
+import { Hono } from "hono";
+${opts.platformImport}
+import { render, serializeServerData } from "./${ctx.ssrEntry}";
+${setupImport}
+
+const TEMPLATE = ${JSON.stringify(ctx.templateHtml)};
+const LOCALES = ${locales};
+const DEFAULT_LOCALE = ${defaultLocale};
+
+function parseAcceptLanguage(header) {
+  if (!header) return DEFAULT_LOCALE;
+  const langs = header.split(",").map(p => {
+    const [l, q] = p.trim().split(";q=");
+    return { l: l.trim().toLowerCase(), q: q ? +q : 1 };
+  }).sort((a, b) => b.q - a.q);
+  for (const { l } of langs) {
+    const prefix = l.split("-")[0];
+    if (LOCALES.includes(prefix)) return prefix;
   }
-  const result = renderApp(page, framework);
-  framework.dispose();
-  return {
-    html: result.html,
-    head: result.head,
-    css: result.css,
-    serverData
-  };
+  return DEFAULT_LOCALE;
 }
 
-// ../ssr/src/create-render.ts
-function createSSRRender(config) {
-  const { bootstrap, getErrorPage, renderApp, frameworkConfig } = config;
-  return (url, locale) => ssrRender({
-    url,
-    frameworkConfig: frameworkConfig ?? {},
-    bootstrap,
-    getErrorPage,
-    renderApp: (page) => renderApp(page, locale)
-  });
+function injectSSR(t, locale, head, css, html, data) {
+  return t
+    .replace("<!--ssr-lang-->", locale)
+    .replace("<!--ssr-head-->", head + "\\n<style>" + css + "</style>")
+    .replace("<!--ssr-body-->", html)
+    .replace("<!--ssr-data-->", '<script id="serialized-server-data" type="application/json">' + data + "</script>");
 }
 
-// ../ssr/src/inject.ts
-var SSR_PLACEHOLDERS = {
-  LANG: "<!--ssr-lang-->",
-  HEAD: "<!--ssr-head-->",
-  BODY: "<!--ssr-body-->",
-  DATA: "<!--ssr-data-->"
-};
-function injectSSRContent(options) {
-  const { template, locale, head, css, html, serializedData } = options;
-  const cssTag = css ? `<style>${css}</style>` : "";
-  return template.replace(SSR_PLACEHOLDERS.LANG, locale).replace(SSR_PLACEHOLDERS.HEAD, `${head}
-${cssTag}`).replace(SSR_PLACEHOLDERS.BODY, html).replace(
-    SSR_PLACEHOLDERS.DATA,
-    `<script id="serialized-server-data" type="application/json">${serializedData}</script>`
-  );
+const app = new Hono();
+${setupCall}
+
+app.get("*", async (c) => {
+  const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
+  try {
+    const locale = parseAcceptLanguage(c.req.header("accept-language"));
+    const { html: appHtml, head, css, serverData } = await render(url, locale);
+    const serializedData = serializeServerData(serverData);
+    return c.html(injectSSR(TEMPLATE, locale, head, css, appHtml, serializedData));
+  } catch (e) {
+    console.error("[SSR Error]", e);
+    return c.text("Internal Server Error", 500);
+  }
+});
+
+${opts.platformExport}
+`;
+}
+async function buildBundle(ctx, opts) {
+  await ctx.vite.build({
+    root: ctx.root,
+    build: {
+      ssr: opts.entry,
+      outDir: opts.outDir,
+      emptyOutDir: true,
+      target: opts.target ?? "node18",
+      rollupOptions: {
+        output: { entryFileNames: opts.fileName ?? "index.mjs" }
+      }
+    },
+    ssr: {
+      noExternal: opts.noExternal !== false,
+      external: opts.external ?? BUILD_TOOL_EXTERNALS
+    },
+    resolve: ctx.resolvedResolve,
+    css: ctx.resolvedCss
+  });
+}
+function copyStaticAssets(ctx, destDir, opts) {
+  const { fs, path } = ctx;
+  fs.cpSync(path.resolve(ctx.root, "dist/client"), destDir, {
+    recursive: true
+  });
+  if (opts?.excludeHtml !== false) {
+    fs.rmSync(path.join(destDir, "index.html"), { force: true });
+  }
 }
 
-// ../ssr/src/server-data.ts
-var HTML_REPLACEMENTS = {
-  "<": "\\u003C",
-  ">": "\\u003E",
-  "/": "\\u002F",
-  "\u2028": "\\u2028",
-  "\u2029": "\\u2029"
-};
-var HTML_ESCAPE_PATTERN = /[<>/\u2028\u2029]/g;
-function serializeServerData(data) {
-  const json = JSON.stringify(data);
-  return json.replace(
-    HTML_ESCAPE_PATTERN,
-    (match) => HTML_REPLACEMENTS[match] ?? match
-  );
+// ../server/src/adapters/cloudflare.ts
+function cloudflareAdapter() {
+  return {
+    name: "cloudflare",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const outputDir = path.resolve(root, "dist/cloudflare");
+      fs.rmSync(outputDir, { recursive: true, force: true });
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: ``,
+        platformExport: `export default app;`
+      });
+      const tempEntry = path.resolve(root, ".cf-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        await buildBundle(ctx, {
+          entry: ".cf-entry.tmp.mjs",
+          outDir: outputDir,
+          target: "es2022",
+          fileName: "_worker.js",
+          external: []
+          // CF Workers 需全部打包
+        });
+        copyStaticAssets(ctx, path.resolve(outputDir, "assets"));
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
+      }
+      console.log("  Cloudflare output \u2192 dist/cloudflare/\n");
+    }
+  };
 }
 
-// ../server/src/app.ts
-import { Hono } from "hono";
+// ../server/src/adapters/netlify.ts
+function netlifyAdapter() {
+  return {
+    name: "netlify",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const funcDir = path.resolve(
+        root,
+        ".netlify/functions-internal/ssr"
+      );
+      fs.rmSync(path.resolve(root, ".netlify"), {
+        recursive: true,
+        force: true
+      });
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: `import { handle } from "hono/netlify";`,
+        platformExport: `export default handle(app);`
+      });
+      const tempEntry = path.resolve(root, ".netlify-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        await buildBundle(ctx, {
+          entry: ".netlify-entry.tmp.mjs",
+          outDir: funcDir,
+          target: "node18"
+        });
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
+      }
+      const redirects = `/* /.netlify/functions/ssr 200
+`;
+      fs.writeFileSync(
+        path.resolve(root, "dist/client/_redirects"),
+        redirects
+      );
+      console.log(
+        "  Netlify output \u2192 .netlify/functions-internal/ssr/\n  Publish dir: dist/client/\n"
+      );
+    }
+  };
+}
 
-// ../server/src/locale.ts
-function parseAcceptLanguage(header, supported, fallback) {
-  const effectiveSupported = supported ?? ["zh", "en"];
-  const effectiveFallback = fallback ?? effectiveSupported[0] ?? "en";
-  if (!header) return effectiveFallback;
-  const langs = header.split(",").map((part) => {
-    const [lang, q] = part.trim().split(";q=");
-    return {
-      lang: lang.trim().toLowerCase(),
-      q: q ? parseFloat(q) : 1
-    };
-  }).sort((a, b) => b.q - a.q);
-  for (const { lang } of langs) {
-    const prefix = lang.split("-")[0];
-    if (effectiveSupported.includes(prefix)) {
-      return prefix;
+// ../server/src/adapters/node.ts
+function nodeAdapter() {
+  return {
+    name: "node",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: `import { serve } from "@hono/node-server";`,
+        platformExport: `
+const port = +(process.env.PORT || 3000);
+serve({ fetch: app.fetch, port }, (info) => {
+  console.log(\`Server running at http://localhost:\${info.port}\`);
+});
+`
+      });
+      const tempEntry = path.resolve(root, ".node-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        await buildBundle(ctx, {
+          entry: ".node-entry.tmp.mjs",
+          outDir: path.resolve(root, "dist/server"),
+          target: "node18"
+        });
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
+      }
+      console.log(
+        "  Node output \u2192 dist/server/index.mjs\n  Run: node dist/server/index.mjs\n"
+      );
     }
-  }
-  return effectiveFallback;
+  };
 }
 
-// ../server/src/app.ts
-function createSSRApp(options) {
-  const {
-    root,
-    vite,
-    isProduction,
-    ssrEntryPath = "/src/ssr.ts",
-    ssrProductionModule,
-    supportedLocales,
-    defaultLocale
-  } = options;
-  const app = new Hono();
-  async function readTemplate(url) {
-    if (!isProduction && vite) {
-      const { readFileSync: readFileSync2 } = await import(
+// ../server/src/adapters/static.ts
+function staticAdapter(opts = {}) {
+  return {
+    name: "static",
+    async build(ctx) {
+      const { fs, path, root, vite } = ctx;
+      const outputDir = path.resolve(root, "dist/static");
+      fs.rmSync(outputDir, { recursive: true, force: true });
+      fs.mkdirSync(outputDir, { recursive: true });
+      const { pathToFileURL } = await import(
         /* @vite-ignore */
-        "fs"
+        "url"
       );
-      const { resolve: resolve2 } = await import(
+      const ssrPath = pathToFileURL(
+        path.resolve(root, "dist/server/ssr.js")
+      ).href;
+      const ssrModule = await import(
         /* @vite-ignore */
-        "path"
+        ssrPath
       );
-      const raw = readFileSync2(resolve2(root, "index.html"), "utf-8");
-      return vite.transformIndexHtml(url, raw);
-    }
-    const isDeno = typeof globalThis.Deno !== "undefined";
-    if (isDeno) {
-      return globalThis.Deno.readTextFileSync(
-        new URL("../dist/client/index.html", import.meta.url)
+      const routePaths = await extractRoutes(ctx, opts);
+      const allUrls = [];
+      for (const routePath of routePaths) {
+        for (const locale of ctx.locales) {
+          const url = locale === ctx.defaultLocale ? routePath : `/${locale}${routePath === "/" ? "" : routePath}`;
+          allUrls.push(url);
+        }
+      }
+      console.log(
+        `  Pre-rendering ${allUrls.length} pages (${routePaths.length} routes \xD7 ${ctx.locales.length} locales)...
+`
       );
+      for (const url of allUrls) {
+        try {
+          const locale = inferLocale(
+            url,
+            ctx.locales,
+            ctx.defaultLocale
+          );
+          const {
+            html: appHtml,
+            head,
+            css,
+            serverData
+          } = await ssrModule.render(url, locale);
+          const serializedData = ssrModule.serializeServerData(serverData);
+          const finalHtml = injectSSRForStatic(
+            ctx.templateHtml,
+            locale,
+            head,
+            css,
+            appHtml,
+            serializedData
+          );
+          const filePath = url === "/" ? path.join(outputDir, "index.html") : path.join(outputDir, url, "index.html");
+          fs.mkdirSync(path.resolve(filePath, ".."), {
+            recursive: true
+          });
+          fs.writeFileSync(filePath, finalHtml);
+        } catch (e) {
+          console.warn(`  [static] Failed to render ${url}:`, e);
+        }
+      }
+      ctx.copyStaticAssets(outputDir, { excludeHtml: true });
+      console.log(`  Static output \u2192 dist/static/
+`);
     }
-    const { readFileSync } = await import(
+  };
+}
+async function extractRoutes(ctx, opts) {
+  const routesFile = opts.routesExport ?? "src/lib/bootstrap.ts";
+  const paths = [];
+  try {
+    const { pathToFileURL } = await import(
       /* @vite-ignore */
-      "fs"
+      "url"
     );
-    const { resolve } = await import(
+    await ctx.vite.build({
+      root: ctx.root,
+      build: {
+        ssr: routesFile,
+        outDir: ctx.path.resolve(ctx.root, "dist/server"),
+        emptyOutDir: false,
+        rollupOptions: {
+          output: { entryFileNames: "_routes.mjs" }
+        }
+      },
+      resolve: ctx.resolvedResolve
+    });
+    const routesPath = pathToFileURL(
+      ctx.path.resolve(ctx.root, "dist/server/_routes.mjs")
+    ).href;
+    const routesMod = await import(
       /* @vite-ignore */
-      "path"
+      routesPath
     );
-    return readFileSync(resolve(root, "dist/client/index.html"), "utf-8");
+    const routes = routesMod.routes ?? routesMod.default;
+    if (Array.isArray(routes)) {
+      for (const r of routes) {
+        if (r.path && !r.path.includes(":")) {
+          paths.push(r.path);
+        }
+      }
+    }
+    ctx.fs.rmSync(ctx.path.resolve(ctx.root, "dist/server/_routes.mjs"), {
+      force: true
+    });
+  } catch (e) {
+    console.warn(
+      `  [static] Could not load routes from "${routesFile}". Using "/" only.`,
+      e
+    );
+    if (paths.length === 0) paths.push("/");
   }
-  async function loadSSRModule() {
-    if (!isProduction && vite) {
-      return await vite.ssrLoadModule(ssrEntryPath);
+  if (opts.dynamicRoutes) {
+    for (const r of opts.dynamicRoutes) {
+      if (!paths.includes(r)) paths.push(r);
     }
-    const modulePath = ssrProductionModule ?? "../dist/server/ssr.js";
-    return import(modulePath);
   }
-  app.get("*", async (c) => {
-    const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
-    try {
-      const template = await readTemplate(url);
-      const { render, serializeServerData: serializeServerData2 } = await loadSSRModule();
-      const locale = parseAcceptLanguage(
-        c.req.header("accept-language"),
-        supportedLocales,
-        defaultLocale
-      );
-      const {
-        html: appHtml,
-        head,
-        css,
-        serverData
-      } = await render(url, locale);
-      const serializedData = serializeServerData2(serverData);
-      const finalHtml = injectSSRContent({
-        template,
-        locale,
-        head,
-        css,
-        html: appHtml,
-        serializedData
+  if (paths.length === 0) paths.push("/");
+  return paths;
+}
+function inferLocale(url, locales, defaultLocale) {
+  const segments = url.split("/").filter(Boolean);
+  if (segments.length > 0 && locales.includes(segments[0])) {
+    return segments[0];
+  }
+  return defaultLocale;
+}
+function injectSSRForStatic(template, locale, head, css, html, serializedData) {
+  return template.replace("<!--ssr-lang-->", locale).replace("<!--ssr-head-->", head + "\n<style>" + css + "</style>").replace("<!--ssr-body-->", html).replace(
+    "<!--ssr-data-->",
+    '<script id="serialized-server-data" type="application/json">' + serializedData + "</script>"
+  );
+}
+
+// ../server/src/adapters/vercel.ts
+function vercelAdapter() {
+  return {
+    name: "vercel",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const outputDir = path.resolve(root, ".vercel/output");
+      fs.rmSync(outputDir, { recursive: true, force: true });
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: `import { handle } from "hono/vercel";`,
+        platformExport: `export default handle(app);`
       });
-      return c.html(finalHtml);
-    } catch (e) {
-      if (!isProduction && vite) {
-        vite.ssrFixStacktrace(e);
+      const tempEntry = path.resolve(root, ".vercel-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        const funcDir = path.resolve(
+          root,
+          ".vercel/output/functions/ssr.func"
+        );
+        await buildBundle(ctx, {
+          entry: ".vercel-entry.tmp.mjs",
+          outDir: funcDir,
+          target: "node18"
+        });
+        fs.writeFileSync(
+          path.resolve(funcDir, ".vc-config.json"),
+          JSON.stringify(
+            {
+              runtime: "nodejs20.x",
+              handler: "index.mjs",
+              launcherType: "Nodejs"
+            },
+            null,
+            2
+          )
+        );
+        copyStaticAssets(
+          ctx,
+          path.resolve(root, ".vercel/output/static")
+        );
+        fs.writeFileSync(
+          path.resolve(root, ".vercel/output/config.json"),
+          JSON.stringify(
+            {
+              version: 3,
+              routes: [
+                { handle: "filesystem" },
+                { src: "/(.*)", dest: "/ssr" }
+              ]
+            },
+            null,
+            2
+          )
+        );
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
       }
-      console.error("[SSR Error]", e);
-      return c.text("Internal Server Error", 500);
+      console.log("  Vercel output \u2192 .vercel/output/\n");
     }
-  });
-  return app;
+  };
+}
+
+// ../server/src/adapters/resolve.ts
+function resolveAdapter(value) {
+  if (typeof value !== "string") return value;
+  switch (value) {
+    case "vercel":
+      return vercelAdapter();
+    case "cloudflare":
+      return cloudflareAdapter();
+    case "netlify":
+      return netlifyAdapter();
+    case "node":
+      return nodeAdapter();
+    case "static":
+      return staticAdapter();
+    case "auto":
+      return autoAdapter();
+    default:
+      throw new Error(
+        `[finesoft] Unknown adapter: "${value}". Available: vercel, cloudflare, netlify, node, static, auto`
+      );
+  }
+}
+
+// ../server/src/adapters/auto.ts
+function autoAdapter() {
+  return {
+    name: "auto",
+    async build(ctx) {
+      const detected = detectPlatform();
+      console.log(`  [auto] Detected platform: ${detected}
+`);
+      const adapter = resolveAdapter(detected);
+      return adapter.build(ctx);
+    }
+  };
+}
+function detectPlatform() {
+  if (process.env.VERCEL) return "vercel";
+  if (process.env.CF_PAGES) return "cloudflare";
+  if (process.env.NETLIFY) return "netlify";
+  return "node";
 }
 
 // ../server/src/create-server.ts
-import { Hono as Hono3 } from "hono";
+import { Hono as Hono2 } from "hono";
 
 // ../server/src/runtime.ts
 function detectRuntime() {
@@ -269,7 +540,7 @@ async function resolveRoot(importMetaUrl, levelsUp = 0) {
 }
 
 // ../server/src/start.ts
-import { Hono as Hono2 } from "hono";
+import { Hono } from "hono";
 async function startServer(options) {
   const {
     app,
@@ -351,8 +622,16 @@ async function startServer(options) {
       /* @vite-ignore */
       "path"
     );
-    const prodApp = new Hono2();
-    prodApp.use("/*", serveStatic({ root: resolve(root, "dist/client") }));
+    const prodApp = new Hono();
+    const clientDir = resolve(root, "dist/client");
+    prodApp.use(
+      "/*",
+      serveStatic({
+        root: clientDir,
+        // 禁止目录路径自动提供 index.html，让其 fall through 到 SSR
+        rewriteRequestPath: (path) => path.endsWith("/") ? "/__nosuchfile__" : path
+      })
+    );
     prodApp.route("/", app);
     const { serve } = await import(
       /* @vite-ignore */
@@ -408,7 +687,7 @@ async function createServer(config = {}) {
       appType: "custom"
     });
   }
-  const app = new Hono3();
+  const app = new Hono2();
   if (setup) {
     await setup(app);
   }
@@ -433,6 +712,251 @@ async function createServer(config = {}) {
   });
   return { app, vite, runtime };
 }
+
+// ../server/src/vite-plugin.ts
+function resolveSetupFn(mod) {
+  if (typeof mod.default === "function") return mod.default;
+  if (typeof mod.setup === "function") return mod.setup;
+  const first = Object.values(mod).find((v) => typeof v === "function");
+  return first ?? null;
+}
+function finesoftFrontViteConfig(options = {}) {
+  const ssrEntry = options.ssr?.entry ?? "src/ssr.ts";
+  let root = process.cwd();
+  let resolvedCommand;
+  let resolvedResolve;
+  let resolvedCss;
+  return {
+    name: "finesoft-front",
+    config(userConfig, env) {
+      const overrides = {
+        appType: "custom"
+      };
+      if (env.command === "build" && !process.env.__FINESOFT_SUB_BUILD__) {
+        overrides.build = {
+          outDir: userConfig.build?.outDir ?? "dist/client"
+        };
+      }
+      return overrides;
+    },
+    configResolved(config) {
+      resolvedCommand = config.command;
+      resolvedResolve = config.resolve;
+      resolvedCss = config.css;
+      root = config.root;
+    },
+    // ─── Dev ───────────────────────────────────────────────
+    configureServer(server) {
+      return async () => {
+        const { Hono: HonoClass } = await import(
+          /* @vite-ignore */
+          "hono"
+        );
+        const { createSSRApp: createSSRApp2 } = await import("./app-MYBG3TGV.js");
+        const { getRequestListener } = await import(
+          /* @vite-ignore */
+          "@hono/node-server"
+        );
+        const app = new HonoClass();
+        if (typeof options.setup === "function") {
+          await options.setup(app);
+        } else if (typeof options.setup === "string") {
+          const mod = await server.ssrLoadModule("/" + options.setup);
+          const fn = resolveSetupFn(mod);
+          if (fn) await fn(app);
+        }
+        const ssrApp = createSSRApp2({
+          root,
+          vite: server,
+          isProduction: false,
+          ssrEntryPath: "/" + ssrEntry,
+          supportedLocales: options.locales,
+          defaultLocale: options.defaultLocale
+        });
+        app.route("/", ssrApp);
+        const listener = getRequestListener(app.fetch);
+        server.middlewares.use((req, res) => {
+          listener(req, res);
+        });
+      };
+    },
+    // ─── Preview ───────────────────────────────────────────
+    configurePreviewServer(server) {
+      return async () => {
+        const { readFileSync } = await import(
+          /* @vite-ignore */
+          "fs"
+        );
+        const { resolve } = await import(
+          /* @vite-ignore */
+          "path"
+        );
+        const { pathToFileURL } = await import(
+          /* @vite-ignore */
+          "url"
+        );
+        const { Hono: HonoClass } = await import(
+          /* @vite-ignore */
+          "hono"
+        );
+        const { injectSSRContent: injectSSRContent2 } = await import(
+          /* @vite-ignore */
+          "./src-7D236CLJ.js"
+        );
+        const { parseAcceptLanguage: parseAcceptLanguage2 } = await import("./locale-YK3THSI6.js");
+        const { getRequestListener } = await import(
+          /* @vite-ignore */
+          "@hono/node-server"
+        );
+        const app = new HonoClass();
+        if (typeof options.setup === "function") {
+          await options.setup(app);
+        } else if (typeof options.setup === "string") {
+          try {
+            const setupPath = pathToFileURL(
+              resolve(root, "dist/server/setup.mjs")
+            ).href;
+            const mod = await import(
+              /* @vite-ignore */
+              setupPath
+            );
+            const fn = resolveSetupFn(
+              mod
+            );
+            if (fn) await fn(app);
+          } catch {
+            console.warn(
+              "[finesoft] Could not load setup module for preview. API routes disabled."
+            );
+          }
+        }
+        const templatePath = resolve(root, "dist/client/index.html");
+        const template = readFileSync(templatePath, "utf-8");
+        const ssrPath = pathToFileURL(
+          resolve(root, "dist/server/ssr.js")
+        ).href;
+        const ssrModule = await import(
+          /* @vite-ignore */
+          ssrPath
+        );
+        app.get("*", async (c) => {
+          const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
+          try {
+            const locale = parseAcceptLanguage2(
+              c.req.header("accept-language"),
+              options.locales,
+              options.defaultLocale
+            );
+            const {
+              html: appHtml,
+              head,
+              css,
+              serverData
+            } = await ssrModule.render(url, locale);
+            const serializedData = ssrModule.serializeServerData(serverData);
+            const finalHtml = injectSSRContent2({
+              template,
+              locale,
+              head,
+              css,
+              html: appHtml,
+              serializedData
+            });
+            return c.html(finalHtml);
+          } catch (e) {
+            console.error("[SSR Preview Error]", e);
+            return c.text("Internal Server Error", 500);
+          }
+        });
+        const listener = getRequestListener(app.fetch);
+        server.middlewares.use((req, res) => {
+          listener(req, res);
+        });
+      };
+    },
+    // ─── Build ─────────────────────────────────────────────
+    async closeBundle() {
+      if (process.env.__FINESOFT_SUB_BUILD__) return;
+      if (resolvedCommand !== "build") return;
+      process.env.__FINESOFT_SUB_BUILD__ = "1";
+      try {
+        const vite = await import(
+          /* @vite-ignore */
+          "vite"
+        );
+        const fs = await import(
+          /* @vite-ignore */
+          "fs"
+        );
+        const path = await import(
+          /* @vite-ignore */
+          "path"
+        );
+        console.log("\n  Building SSR bundle...\n");
+        await vite.build({
+          root,
+          build: {
+            ssr: ssrEntry,
+            outDir: "dist/server"
+          },
+          resolve: resolvedResolve,
+          css: resolvedCss
+        });
+        if (typeof options.setup === "string") {
+          console.log("  Building setup module...\n");
+          await vite.build({
+            root,
+            build: {
+              ssr: options.setup,
+              outDir: "dist/server",
+              emptyOutDir: false,
+              rollupOptions: {
+                output: { entryFileNames: "setup.mjs" }
+              }
+            },
+            resolve: resolvedResolve
+          });
+        }
+        if (options.adapter) {
+          const adapter = resolveAdapter(options.adapter);
+          const locales = options.locales ?? ["zh", "en"];
+          const defaultLocale = options.defaultLocale ?? locales[0] ?? "en";
+          const templateHtml = fs.readFileSync(
+            path.resolve(root, "dist/client/index.html"),
+            "utf-8"
+          );
+          const ctx = {
+            root,
+            ssrEntry,
+            setupPath: typeof options.setup === "string" ? options.setup : void 0,
+            locales,
+            defaultLocale,
+            templateHtml,
+            resolvedResolve,
+            resolvedCss,
+            vite,
+            fs,
+            path,
+            generateSSREntry(opts) {
+              return generateSSREntry(ctx, opts);
+            },
+            buildBundle(opts) {
+              return buildBundle(ctx, opts);
+            },
+            copyStaticAssets(destDir, opts) {
+              return copyStaticAssets(ctx, destDir, opts);
+            }
+          };
+          console.log(`  Running adapter: ${adapter.name}...
+`);
+          await adapter.build(ctx);
+        }
+      } finally {
+        delete process.env.__FINESOFT_SUB_BUILD__;
+      }
+    }
+  };
+}
 export {
   ACTION_KINDS,
   ActionDispatcher,
@@ -453,7 +977,9 @@ export {
   PrefetchedIntents,
   Router,
   SSR_PLACEHOLDERS,
+  autoAdapter,
   buildUrl,
+  cloudflareAdapter,
   createPrefetchedIntentsFromDom,
   createSSRApp,
   createSSRRender,
@@ -461,6 +987,7 @@ export {
   defineRoutes,
   deserializeServerData,
   detectRuntime,
+  finesoftFrontViteConfig,
   generateUuid,
   getBaseUrl,
   injectSSRContent,
@@ -473,6 +1000,8 @@ export {
   makeExternalUrlAction,
   makeFlowAction,
   mapEach,
+  netlifyAdapter,
+  nodeAdapter,
   parseAcceptLanguage,
   pipe,
   pipeAsync,
@@ -483,6 +1012,7 @@ export {
   removeQueryParams,
   removeScheme,
   resetFilterCache,
+  resolveAdapter,
   resolveRoot,
   serializeServerData,
   shouldLog,
@@ -490,6 +1020,8 @@ export {
   stableStringify,
   startBrowserApp,
   startServer,
-  tryScroll
+  staticAdapter,
+  tryScroll,
+  vercelAdapter
 };
 //# sourceMappingURL=index.js.map