@fluixi/start 0.1.0-alpha.73 → 0.1.0-alpha.75

package/dist/commands/index.mjs

@@ -0,0 +1,982 @@
+/*! @fluixi/start v0.1.0-alpha.75 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  API_VIRTUAL_MODULE,
+  isApiPath
+} from "./chunk-GFQ4MUIC.mjs";
+
+// src/commands/dev.ts
+import { createServer as createHttp } from "node:http";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// src/config.ts
+import { resolve, isAbsolute } from "node:path";
+function resolveConfig(config = {}) {
+  const root = resolve(config.root ?? process.cwd());
+  return {
+    root,
+    ssr: config.ssr ?? true,
+    port: config.port ?? 3e3,
+    serverEntry: config.serverEntry ?? "src/entry-server.ts",
+    clientEntry: config.clientEntry ?? "src/entry-client.ts",
+    template: config.template ?? "index.html",
+    mountId: config.mountId ?? "root",
+    routesDir: config.routesDir ?? "src/routes",
+    apiDir: config.apiDir ?? "src/api",
+    middleware: config.middleware ?? "src/middleware.ts",
+    ssrNoExternal: config.ssrNoExternal ?? [],
+    resolve: config.resolve ?? [],
+    vitePlugin: config.vitePlugin ?? {},
+    plugins: config.plugins ?? [],
+    adapter: config.adapter,
+    i18n: resolveI18n(config.i18n),
+    prerender: resolvePrerender(config.prerender)
+  };
+}
+function resolvePrerender(prerender2) {
+  if (!prerender2) return false;
+  const opts = typeof prerender2 === "object" ? prerender2 : {};
+  return {
+    routes: opts.routes?.length ? opts.routes : ["/"],
+    crawl: opts.crawl ?? true
+  };
+}
+function resolveI18n(i18n) {
+  if (i18n === false) return false;
+  const opts = typeof i18n === "object" ? i18n : {};
+  return {
+    dir: opts.dir ?? "src/i18n",
+    defaultLocale: opts.defaultLocale,
+    locales: opts.locales
+  };
+}
+
+// src/internal.ts
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve as resolvePath, relative as relativePath } from "node:path";
+
+// src/document.ts
+import { extractHeadMarker } from "@fluixi/head";
+function injectApp(template, appHtml, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  if (mount.test(template)) {
+    return template.replace(mount, `<div id="${mountId}">${appHtml}</div>`);
+  }
+  if (template.includes("<!--ssr-outlet-->")) {
+    return template.replace("<!--ssr-outlet-->", appHtml);
+  }
+  return template.replace("</body>", `<div id="${mountId}">${appHtml}</div></body>`);
+}
+function splitTemplate(template, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  const m = template.match(mount);
+  if (m && m.index !== void 0) {
+    return {
+      head: template.slice(0, m.index) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(m.index + m[0].length)
+    };
+  }
+  const outlet = template.indexOf("<!--ssr-outlet-->");
+  if (outlet !== -1) {
+    return {
+      head: template.slice(0, outlet),
+      tail: template.slice(outlet + "<!--ssr-outlet-->".length)
+    };
+  }
+  const body = template.indexOf("</body>");
+  if (body !== -1) {
+    return {
+      head: template.slice(0, body) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(body)
+    };
+  }
+  return { head: template, tail: "" };
+}
+function injectPreload(template, files) {
+  const tags = files.filter((file) => !template.includes(file)).map(
+    (file) => file.endsWith(".css") ? `<link rel="stylesheet" href="${file}">` : (
+      // `modulepreload` also fetches the chunk's own static imports.
+      `<link rel="modulepreload" href="${file}">`
+    )
+  );
+  if (tags.length === 0) return template;
+  const head = template.indexOf("</head>");
+  if (head === -1) return template;
+  return template.slice(0, head) + tags.join("") + template.slice(head);
+}
+function setHtmlAttr(html, name, value) {
+  const existing = new RegExp(`(<html\\b[^>]*?)\\s${name}="[^"]*"`, "i");
+  if (existing.test(html)) return html.replace(existing, `$1 ${name}="${value}"`);
+  return html.replace(/<html\b/i, `<html ${name}="${value}"`);
+}
+function injectAppAndHead(template, rendered, mountId = "root") {
+  const { head, body } = extractHeadMarker(rendered);
+  let html = injectApp(template, body, mountId);
+  if (head) {
+    if (head.headHtml) {
+      if (/<title[\s>]/i.test(head.headHtml)) html = html.replace(/<title>[\s\S]*?<\/title>/i, "");
+      html = html.replace("</head>", `${head.headHtml}</head>`);
+    }
+    for (const [k, v] of Object.entries(head.htmlAttrs)) html = setHtmlAttr(html, k, v);
+  }
+  return html;
+}
+function guardHandler(handler, onError) {
+  return async (request) => {
+    try {
+      return await handler(request);
+    } catch (e) {
+      onError?.(e);
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+
+// src/internal.ts
+var SERVER_FNS_VMOD = "virtual:fluixi-server-fns";
+var I18N_VMOD = "virtual:fluixi-i18n";
+function i18nVitePlugin(opts) {
+  let root = process.cwd();
+  const id = "\0" + I18N_VMOD;
+  return {
+    name: "fluixi-i18n",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(source) {
+      return source === I18N_VMOD ? id : null;
+    },
+    load(source) {
+      if (source !== id) return null;
+      const dir = resolvePath(root, opts.dir);
+      let files = [];
+      try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+      } catch {
+      }
+      const discovered = files.map((f) => f.replace(/\.json$/, "")).sort();
+      const locales = opts.locales?.length ? opts.locales : discovered;
+      const defaultLocale = opts.defaultLocale ?? locales[0] ?? "en";
+      const imports = locales.map((l, i) => `import _${i} from ${JSON.stringify(resolvePath(dir, l + ".json"))};`).join("\n");
+      const messages = `export const messages = {${locales.map((l, i) => `${JSON.stringify(l)}:_${i}`).join(",")}};`;
+      return `${imports}
+export const locales = ${JSON.stringify(locales)};
+export const defaultLocale = ${JSON.stringify(defaultLocale)};
+${messages}
+`;
+    }
+  };
+}
+async function loadServerEnv(root, mode) {
+  const { loadEnv } = await import("vite");
+  const env = loadEnv(mode, root, "");
+  for (const [k, v] of Object.entries(env)) {
+    if (process.env[k] === void 0) process.env[k] = v;
+  }
+}
+function i18nTypeBlock(root, i18n) {
+  const dir = resolvePath(root, i18n.dir);
+  let discovered = [];
+  try {
+    discovered = readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+  } catch {
+  }
+  const locales = i18n.locales?.length ? i18n.locales : discovered;
+  const defaultLocale = i18n.defaultLocale ?? locales[0] ?? "en";
+  const typed = locales.length > 0 && locales.every((l) => discovered.includes(l));
+  if (!typed) {
+    return [
+      `declare module 'virtual:fluixi-i18n' {`,
+      `  export const messages: Record<string, Record<string, unknown>>;`,
+      `  export const locales: string[];`,
+      `  export const defaultLocale: string;`,
+      `}`
+    ];
+  }
+  const srcDir = resolvePath(root, "src");
+  const toSpec = (l) => {
+    const rel = relativePath(srcDir, resolvePath(dir, l + ".json")).split(/[\\/]/).join("/");
+    return rel.startsWith(".") ? rel : "./" + rel;
+  };
+  const entries = locales.map((l) => `    ${JSON.stringify(l)}: (typeof import(${JSON.stringify(toSpec(l))}))['default'];`);
+  const tuple = locales.map((l) => JSON.stringify(l)).join(", ");
+  return [
+    `declare module 'virtual:fluixi-i18n' {`,
+    `  export const messages: {`,
+    ...entries,
+    `  };`,
+    `  export const locales: readonly [${tuple}];`,
+    `  export const defaultLocale: ${JSON.stringify(defaultLocale)};`,
+    `}`
+  ];
+}
+function startTypesPlugin(cfg) {
+  let root = process.cwd();
+  return {
+    name: "fluixi-start-types",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    buildStart() {
+      const blocks = [];
+      if (cfg.i18n) blocks.push(...i18nTypeBlock(root, cfg.i18n));
+      if (blocks.length === 0) return;
+      const content = `// Auto-generated by @fluixi/start, do not edit.
+${blocks.join("\n")}
+`;
+      const file = resolvePath(root, "src/fluixi-start-env.d.ts");
+      try {
+        if (!existsSync(file) || readFileSync(file, "utf8") !== content) writeFileSync(file, content);
+      } catch {
+      }
+    }
+  };
+}
+async function fluixiPlugins(cfg) {
+  const { fluixi, fluixiRoutesPlugin } = await import("@fluixi/core/plugins");
+  const { serverFunctionsVitePlugin } = await import("@fluixi/compiler/integrations");
+  const plugins = [
+    serverFunctionsVitePlugin(),
+    fluixiRoutesPlugin({ routesDir: cfg.routesDir, polyfills: false }),
+    // The app's component-resolution rules reach the compiler here; without this an SSR
+    // app has no way to say where an unimported tag comes from.
+    //
+    // `fluixi()` and not `createVitePlugin()`: the latter is the bare compiler integration,
+    // and the reactive graph: agent, source marks, /__fluixi/graph, is composed on top of
+    // it by the former. A start app got no graph at all until this changed.
+    // Everything the app declared for the compiler, with `resolve` still usable on its
+    // own because it is the one most apps set. A start app never writes
+    // `fluixi()` itself, so without this passthrough the plugin's other options
+    // (propsDestructure and the rest) had nowhere to be declared.
+    fluixi({ ...cfg.vitePlugin ?? {}, ...cfg.resolve ? { resolve: cfg.resolve } : {} })
+  ];
+  if (cfg.plugins?.length) plugins.push(...cfg.plugins);
+  if (cfg.i18n) plugins.push(i18nVitePlugin(cfg.i18n));
+  const { apiRoutesVitePlugin } = await import("./api-PJL37LV3.mjs");
+  plugins.push(apiRoutesVitePlugin({ dir: cfg.apiDir }));
+  plugins.push(startTypesPlugin(cfg));
+  return plugins;
+}
+var _guardsInstalled = false;
+function installCrashGuards() {
+  if (_guardsInstalled) return;
+  _guardsInstalled = true;
+  process.on(
+    "unhandledRejection",
+    (reason) => console.warn("[fluixi] unhandled rejection (backend likely down) —", reason?.message || reason)
+  );
+  process.on(
+    "uncaughtException",
+    (err) => console.warn("[fluixi] uncaught exception —", err?.message || err)
+  );
+}
+
+// src/handler.ts
+import { createServer as createHttpServer } from "node:http";
+import { stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import { join, extname } from "node:path";
+function streamDocument(head, body, tail) {
+  const enc = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        controller.enqueue(enc.encode(head));
+        const reader = body.getReader();
+        for (; ; ) {
+          const { done: done2, value } = await reader.read();
+          if (done2) break;
+          controller.enqueue(value);
+        }
+        controller.enqueue(enc.encode(tail));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: { "content-type": "text/html; charset=utf-8" }
+  });
+}
+function createRequestHandler(render) {
+  return async (request) => {
+    const url = new URL(request.url);
+    try {
+      const html = await render(url.pathname + url.search, request);
+      return new Response(html, {
+        status: 200,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    } catch (e) {
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+function nodeToRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const url = `http://${host}${req.url ?? "/"}`;
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (Array.isArray(v)) v.forEach((x) => headers.append(k, x));
+    else if (v != null) headers.set(k, v);
+  }
+  const method = req.method ?? "GET";
+  const init = { method, headers };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = req;
+    init.duplex = "half";
+  }
+  return new Request(url, init);
+}
+async function sendResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => res.setHeader(key, value));
+  const body = response.body;
+  if (!body) {
+    res.end(await response.text().catch(() => ""));
+    return;
+  }
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done: done2, value } = await reader.read();
+      if (done2) break;
+      res.write(value);
+    }
+  } finally {
+    res.end();
+  }
+}
+function toNodeHandler(handler) {
+  return async (req, res) => {
+    const response = await handler(nodeToRequest(req));
+    await sendResponse(res, response);
+  };
+}
+function serveNode(handler, opts = {}) {
+  const port = opts.port ?? 3e3;
+  const node = toNodeHandler(handler);
+  const server = createHttpServer((req, res) => {
+    node(req, res).catch((e) => {
+      res.statusCode = 500;
+      res.end(String(e?.stack || e));
+    });
+  });
+  server.listen(
+    port,
+    () => opts.onListen ? opts.onListen(port) : console.log(`  fluixi → http://localhost:${port}`)
+  );
+  return server;
+}
+var MIME = {
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json"
+};
+function withStaticFiles(handler, dir) {
+  return async (request) => {
+    const { pathname } = new URL(request.url);
+    if (pathname !== "/" && extname(pathname)) {
+      const file = join(dir, decodeURIComponent(pathname));
+      try {
+        const s = await stat(file);
+        if (s.isFile()) {
+          const body = Readable.toWeb(createReadStream(file));
+          return new Response(body, {
+            headers: {
+              "content-type": MIME[extname(file).toLowerCase()] ?? "application/octet-stream",
+              "content-length": String(s.size)
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return handler(request);
+  };
+}
+
+// src/middleware.ts
+function normalizeMiddleware(mod) {
+  const def = mod?.default ?? mod;
+  if (def == null) return [];
+  if (Array.isArray(def)) return def.filter((m) => typeof m === "function");
+  return typeof def === "function" ? [def] : [];
+}
+function composeMiddleware(middlewares, core) {
+  if (middlewares.length === 0) return core;
+  return (request) => {
+    let lastCalled = -1;
+    const dispatch = (i) => {
+      if (i <= lastCalled) {
+        return Promise.reject(new Error("middleware called next() more than once"));
+      }
+      lastCalled = i;
+      const mw = middlewares[i];
+      if (!mw) return Promise.resolve(core(request));
+      return Promise.resolve(mw(request, () => dispatch(i + 1)));
+    };
+    return dispatch(0);
+  };
+}
+
+// src/ui.ts
+import { networkInterfaces } from "node:os";
+var COLOR = process.env.NO_COLOR || process.env.FORCE_COLOR === "0" ? false : (!!process.stdout.isTTY || !!process.env.FORCE_COLOR) && process.env.TERM !== "dumb";
+var sgr = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : `${s}`;
+var c = {
+  bold: sgr(1, 22),
+  dim: sgr(2, 22),
+  italic: sgr(3, 23),
+  underline: sgr(4, 24),
+  red: sgr(31, 39),
+  green: sgr(32, 39),
+  yellow: sgr(33, 39),
+  blue: sgr(34, 39),
+  magenta: sgr(35, 39),
+  cyan: sgr(36, 39),
+  gray: sgr(90, 39)
+};
+var rgb = (r, g, b) => (s) => COLOR ? `\x1B[38;2;${r};${g};${b}m${s}\x1B[39m` : s;
+var BRAND = [
+  [34, 211, 238],
+  // cyan-400
+  [56, 189, 248],
+  [129, 140, 248],
+  [167, 139, 250],
+  [192, 132, 252],
+  // violet-400
+  [217, 130, 245]
+];
+function gradient(text) {
+  if (!COLOR) return text;
+  const chars = [...text];
+  return chars.map((ch, i) => {
+    const [r, g, b] = BRAND[Math.min(BRAND.length - 1, Math.floor(i / Math.max(1, chars.length - 1) * (BRAND.length - 1)))];
+    return rgb(r, g, b)(ch);
+  }).join("");
+}
+function wordmark(version) {
+  const mark = `${gradient("◆")} ${c.bold(gradient("fluixi"))}`;
+  return version ? `${mark} ${c.dim(`v${version}`)}` : mark;
+}
+var SYM = {
+  arrow: c.gray("➜"),
+  ok: c.green("✓"),
+  err: c.red("✗")
+};
+function networkAddress() {
+  for (const list of Object.values(networkInterfaces())) {
+    for (const net of list ?? []) {
+      const family = typeof net.family === "string" ? net.family : `IPv${net.family}`;
+      if (family === "IPv4" && !net.internal) return net.address;
+    }
+  }
+  return null;
+}
+function devReady(opts) {
+  const ms = Date.now() - opts.startedAt;
+  const local = `http://localhost:${opts.port}/`;
+  const net = networkAddress();
+  const link = (u) => c.cyan(c.underline(u));
+  const label = (s) => c.gray(s.padEnd(8));
+  const lines = [
+    "",
+    `  ${wordmark(opts.version)}  ${c.gray(`dev ready in ${c.bold(String(ms))} ms`)}`,
+    "",
+    `  ${SYM.arrow} ${label("Local")} ${link(local)}`,
+    net ? `  ${SYM.arrow} ${label("Network")} ${link(`http://${net}:${opts.port}/`)}` : `  ${SYM.arrow} ${label("Network")} ${c.dim("not exposed")}`,
+    ""
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+}
+function step(text) {
+  process.stdout.write(`  ${c.cyan("•")} ${text}
+`);
+}
+function done(text) {
+  process.stdout.write(`  ${SYM.ok} ${text}
+`);
+}
+
+// src/commands/dev.ts
+var STYLE_FILE = /\.(css|scss|sass|less|styl|stylus|pcss|postcss)(\?|$)/;
+async function renderedStyles(vite, entry) {
+  const seen = /* @__PURE__ */ new Set();
+  const found = [];
+  const visit = (mod) => {
+    if (!mod || seen.has(mod.url)) return;
+    seen.add(mod.url);
+    if (STYLE_FILE.test(mod.url)) found.push(mod.url);
+    for (const dep of mod.importedModules ?? []) visit(dep);
+  };
+  try {
+    visit(await vite.moduleGraph.getModuleByUrl("/" + entry, true));
+  } catch {
+    return [];
+  }
+  return found;
+}
+function injectStyles(html, urls) {
+  if (urls.length === 0) return html;
+  const links = urls.map((url) => `<link rel="stylesheet" href="${url}${url.includes("?") ? "&" : "?"}direct">`).join("\n    ");
+  return html.includes("</head>") ? html.replace("</head>", `  ${links}
+  </head>`) : html;
+}
+async function dev(config = {}) {
+  const startedAt = Date.now();
+  const cfg = resolveConfig(config);
+  installCrashGuards();
+  await loadServerEnv(cfg.root, "development");
+  const { createServer } = await import("vite");
+  const template = readFileSync2(resolve2(cfg.root, cfg.template), "utf-8");
+  let vite;
+  const renderHandler = guardHandler(async (request) => {
+    const url = new URL(request.url);
+    const path = url.pathname + url.search;
+    if (url.pathname === "/_server") {
+      const sf = await vite.ssrLoadModule(SERVER_FNS_VMOD);
+      if (sf.isServerFnRequest(request)) return sf.handleServerFn(request);
+    }
+    if (isApiPath(url.pathname)) {
+      const api = await vite.ssrLoadModule(API_VIRTUAL_MODULE);
+      if (api.isApiRequest(request)) return api.handleApiRequest(request);
+    }
+    if (!cfg.ssr) {
+      const html2 = await vite.transformIndexHtml(path, template);
+      return new Response(html2, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+    }
+    const mod = await vite.ssrLoadModule("/" + cfg.serverEntry);
+    if (typeof mod.renderStream === "function") {
+      const shell = await vite.transformIndexHtml(
+        path,
+        injectStyles(template, await renderedStyles(vite, cfg.serverEntry))
+      );
+      const { head, tail } = splitTemplate(shell, cfg.mountId);
+      return streamDocument(head, await mod.renderStream(path, request), tail);
+    }
+    const render = mod.render ?? mod.default;
+    const appHtml = await render(path, request);
+    const styled = injectStyles(
+      injectAppAndHead(template, appHtml, cfg.mountId),
+      await renderedStyles(vite, cfg.serverEntry)
+    );
+    const html = await vite.transformIndexHtml(path, styled);
+    return new Response(html, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+  }, (e) => vite.ssrFixStacktrace?.(e));
+  const hasMiddleware = existsSync2(resolve2(cfg.root, cfg.middleware));
+  const handler = hasMiddleware ? guardHandler(async (request) => {
+    const mwMod = await vite.ssrLoadModule("/" + cfg.middleware);
+    return composeMiddleware(normalizeMiddleware(mwMod), renderHandler)(request);
+  }, (e) => vite.ssrFixStacktrace?.(e)) : renderHandler;
+  const nodeHandler = toNodeHandler(handler);
+  const http = createHttp((req, res) => {
+    vite.middlewares(req, res, () => nodeHandler(req, res));
+  });
+  vite = await createServer({
+    root: cfg.root,
+    plugins: await fluixiPlugins(cfg),
+    // file routing + JSX/SSR transform (fluixi)
+    server: { middlewareMode: true, hmr: { server: http } },
+    appType: "custom",
+    ssr: cfg.ssrNoExternal.length ? { noExternal: cfg.ssrNoExternal } : void 0
+  });
+  http.listen(cfg.port, () => devReady({ port: cfg.port, startedAt }));
+}
+
+// src/commands/build.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir2, writeFile as writeFile2, rm, copyFile, readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve5, dirname as dirname3, join as join4, basename } from "node:path";
+
+// src/adapter.ts
+import { readFile } from "node:fs/promises";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve3, join as join2, dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+
+// src/handler-core.ts
+function createHandlerFrom({ template, mod, cfg, middleware, preload }) {
+  const withPreload = (html, pathname) => preload ? injectPreload(html, preload(pathname)) : html;
+  let core;
+  if (!cfg.ssr) {
+    core = createRequestHandler(async (url) => withPreload(template, url.split("?")[0]));
+  } else if (typeof mod.renderStream === "function") {
+    core = async (request) => {
+      const url = new URL(request.url);
+      const { head, tail } = splitTemplate(withPreload(template, url.pathname), cfg.mountId);
+      const body = await mod.renderStream(url.pathname + url.search, request);
+      return streamDocument(head, body, tail);
+    };
+  } else {
+    const render = mod.render ?? mod.default;
+    core = createRequestHandler(
+      async (url, request) => (
+        // `url` here is `pathname + search`; matching only ever wants the path.
+        injectAppAndHead(withPreload(template, url.split("?")[0]), await render(url, request), cfg.mountId)
+      )
+    );
+  }
+  if (typeof mod.handleServerFn === "function" && typeof mod.isServerFnRequest === "function") {
+    const render = core;
+    core = async (request) => mod.isServerFnRequest(request) ? mod.handleServerFn(request) : render(request);
+  }
+  if (typeof mod.handleApiRequest === "function" && typeof mod.isApiRequest === "function") {
+    const next = core;
+    core = async (request) => mod.isApiRequest(request) ? mod.handleApiRequest(request) : next(request);
+  }
+  if (!middleware) return guardHandler(core);
+  return guardHandler(composeMiddleware(normalizeMiddleware(middleware), core));
+}
+
+// src/preload.ts
+import { matchRoutes } from "@fluixi/core/router";
+function createPreloader(assets) {
+  const patterns = Object.keys(assets ?? {});
+  if (!patterns.length) return () => [];
+  const routes = patterns.map((path) => ({ path, meta: { path } }));
+  return (pathname) => {
+    const matched = matchRoutes(routes, pathname)?.matched;
+    const leaf = matched?.[matched.length - 1];
+    const pattern = leaf?.route.meta?.path;
+    return pattern ? assets[pattern] ?? [] : [];
+  };
+}
+
+// src/adapter.ts
+async function createProdHandler(config = {}) {
+  const cfg = resolveConfig(config);
+  const clientDir = resolve3(cfg.root, "dist/client");
+  const template = await readTemplate(clientDir, resolve3(cfg.root, "dist/server"));
+  const serverEntry = resolve3(cfg.root, "dist/server", "entry-server.js");
+  const mod = existsSync3(serverEntry) ? await import(
+    /* @vite-ignore */
+    pathToFileURL(serverEntry).href
+  ) : {};
+  const mwFile = resolve3(cfg.root, "dist/server", "middleware.js");
+  const middleware = existsSync3(mwFile) ? await import(
+    /* @vite-ignore */
+    pathToFileURL(mwFile).href
+  ) : void 0;
+  return createHandlerFrom({ template, mod, cfg, middleware, preload: await loadPreloader(cfg) });
+}
+async function readTemplate(clientDir, serverDir) {
+  const stashed = join2(serverDir, "template.html");
+  return readFile(existsSync3(stashed) ? stashed : join2(clientDir, "index.html"), "utf-8");
+}
+async function loadPreloader(cfg) {
+  const file = resolve3(cfg.root, "dist/server", "route-assets.json");
+  if (!existsSync3(file)) return void 0;
+  try {
+    return createPreloader(JSON.parse(await readFile(file, "utf-8")));
+  } catch {
+    return void 0;
+  }
+}
+var nodeAdapter = {
+  name: "node",
+  // A Node server runs from the app directory, so node_modules is right there: keep the
+  // framework as imports instead of copying it into the bundle.
+  bundle: "external",
+  async serve({ handler, cfg, clientDir }) {
+    serveNode(withStaticFiles(handler, clientDir), {
+      port: cfg.port,
+      onListen: (p) => console.log(`  fluixi start (node) → http://localhost:${p}`)
+    });
+  }
+};
+var GENERATED_SUBPATHS = /* @__PURE__ */ new Set(["./routes", "./server-fns", "./api-routes"]);
+function ssrBuildOptions(cfg) {
+  const noExternal = cfg.ssrNoExternal.length ? cfg.ssrNoExternal : void 0;
+  const mode = cfg.adapter?.bundle;
+  if (mode === "inline") return { noExternal: true };
+  if (mode !== "external") return { noExternal };
+  const external = frameworkDeps(cfg.root).filter((name) => !cfg.ssrNoExternal.includes(name)).flatMap((name) => withSubpaths(cfg.root, name));
+  if (!external.length) {
+    console.warn(
+      `  fluixi: adapter "${cfg.adapter?.name}" builds an externalized server, but no fluixi or @fluixi/* dependency was found in ${join2(cfg.root, "package.json")}, bundling everything.`
+    );
+  }
+  return { noExternal, external: external.length ? external : void 0 };
+}
+function frameworkDeps(root) {
+  const pkg = readPackage(join2(root, "package.json"));
+  if (!pkg) return [];
+  const declared = { ...pkg.dependencies, ...pkg.peerDependencies, ...pkg.optionalDependencies };
+  return Object.keys(declared).filter((id) => id === "@fluixi/core" || id.startsWith("@fluixi/"));
+}
+function withSubpaths(root, name) {
+  const exports = resolvePackage(root, name)?.exports;
+  if (!exports || typeof exports !== "object") return [name];
+  const ids = [name];
+  for (const key of Object.keys(exports)) {
+    if (!key.startsWith("./") || key.includes("*")) continue;
+    if (key === "./package.json" || GENERATED_SUBPATHS.has(key)) continue;
+    ids.push(`${name}/${key.slice(2)}`);
+  }
+  return ids;
+}
+function resolvePackage(root, name) {
+  try {
+    return readPackage(createRequire(join2(root, "index.js")).resolve(`${name}/package.json`));
+  } catch {
+  }
+  for (let dir = root; ; dir = dirname(dir)) {
+    const pkg = readPackage(join2(dir, "node_modules", name, "package.json"));
+    if (pkg) return pkg;
+    if (dirname(dir) === dir) return void 0;
+  }
+}
+function readPackage(file) {
+  if (!existsSync3(file)) return void 0;
+  try {
+    return JSON.parse(readFileSync3(file, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/prerender.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve as resolve4, join as join3, dirname as dirname2 } from "node:path";
+function htmlPath(url) {
+  const clean = url.split(/[?#]/)[0].replace(/\/+$/, "");
+  return clean === "" ? "index.html" : `${clean.replace(/^\//, "")}/index.html`;
+}
+function extractLinks(html) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of html.matchAll(/href=["'](\/[^"'#?]*)["']/g)) {
+    const href = m[1];
+    if (/\.[a-z0-9]+$/i.test(href)) continue;
+    out.add(href.replace(/\/+$/, "") || "/");
+  }
+  return [...out];
+}
+var norm = (u) => {
+  const p = (u.startsWith("/") ? u : "/" + u).replace(/\/+$/, "");
+  return p || "/";
+};
+async function prerender(config = {}) {
+  const cfg = resolveConfig(config);
+  if (!cfg.prerender) return [];
+  if (!cfg.ssr) {
+    process.stdout.write(`  ${c.yellow("!")} prerender needs ssr:true — skipped
+`);
+    return [];
+  }
+  step("prerender");
+  const clientDir = resolve4(cfg.root, "dist/client");
+  const handler = await createProdHandler(config);
+  const { routes, crawl } = cfg.prerender;
+  const queue = routes.map(norm);
+  const seen = /* @__PURE__ */ new Set();
+  const written = [];
+  while (queue.length) {
+    const url = queue.shift();
+    if (seen.has(url)) continue;
+    seen.add(url);
+    let html;
+    try {
+      const res = await handler(new Request("http://prerender.local" + url));
+      if (!res.ok) {
+        process.stdout.write(`    ${c.yellow("skip")} ${url} ${c.gray("→ " + res.status)}
+`);
+        continue;
+      }
+      if (!(res.headers.get("content-type") || "").includes("html")) continue;
+      html = await res.text();
+    } catch (e) {
+      process.stdout.write(`    ${c.yellow("skip")} ${url} ${c.gray("→ " + e.message)}
+`);
+      continue;
+    }
+    const file = join3(clientDir, htmlPath(url));
+    await mkdir(dirname2(file), { recursive: true });
+    await writeFile(file, html);
+    written.push(url);
+    if (crawl) {
+      for (const link of extractLinks(html)) if (!seen.has(link)) queue.push(link);
+    }
+  }
+  done(`${c.bold("prerendered")} ${c.bold(String(written.length))} page(s)  ${c.gray("→ dist/client")}
+`);
+  return written;
+}
+
+// src/commands/build.ts
+async function build(config = {}) {
+  const startedAt = Date.now();
+  const cfg = resolveConfig(config);
+  await loadServerEnv(cfg.root, "production");
+  const { build: viteBuild } = await import("vite");
+  const plugins = await fluixiPlugins(cfg);
+  const ssr = ssrBuildOptions(cfg);
+  process.stdout.write(`
+  ${wordmark()}  ${c.gray("building for production")}
+
+`);
+  step("client bundle");
+  await viteBuild({
+    root: cfg.root,
+    plugins,
+    logLevel: "warn",
+    build: { outDir: "dist/client", ssrManifest: true, emptyOutDir: true }
+  });
+  const serverEntrySrc = resolve5(cfg.root, cfg.serverEntry);
+  if (cfg.ssr || existsSync4(serverEntrySrc)) {
+    step(`server bundle${bundleNote(cfg)}`);
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      ssr,
+      build: {
+        outDir: "dist/server",
+        ssr: serverEntrySrc,
+        emptyOutDir: true
+      }
+    });
+  }
+  const middlewareSrc = resolve5(cfg.root, cfg.middleware);
+  if (existsSync4(middlewareSrc)) {
+    step("middleware");
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      logLevel: "warn",
+      ssr,
+      build: {
+        outDir: "dist/server",
+        ssr: middlewareSrc,
+        emptyOutDir: false
+      }
+    });
+  }
+  await collectRouteAssets(cfg);
+  if (cfg.prerender) {
+    await copyFile(
+      resolve5(cfg.root, "dist/client", "index.html"),
+      resolve5(cfg.root, "dist/server", "template.html")
+    );
+    process.stdout.write("\n");
+    await prerender(config);
+  }
+  if (cfg.adapter?.build) {
+    step(`${cfg.adapter.name} output`);
+    await cfg.adapter.build({
+      cfg,
+      root: cfg.root,
+      clientDir: resolve5(cfg.root, "dist/client"),
+      serverDir: resolve5(cfg.root, "dist/server"),
+      hasServer: existsSync4(resolve5(cfg.root, "dist/server", "entry-server.js")),
+      bundleEntry: (source, outFile) => bundleEntry(cfg, plugins, source, outFile)
+    });
+  }
+  const ms = Date.now() - startedAt;
+  process.stdout.write("\n");
+  done(`${c.bold("built")} in ${c.bold(String(ms))} ms  ${c.gray("→ dist/client + dist/server")}
+`);
+}
+async function collectRouteAssets(cfg) {
+  const clientDir = resolve5(cfg.root, "dist/client");
+  const manifestFile = join4(clientDir, ".vite", "ssr-manifest.json");
+  if (!existsSync4(manifestFile)) return;
+  const serverDir = resolve5(cfg.root, "dist/server");
+  const routesDir = resolve5(cfg.root, cfg.routesDir);
+  if (existsSync4(serverDir) && existsSync4(routesDir)) {
+    const manifest = JSON.parse(await readFile2(manifestFile, "utf-8"));
+    const { scanRoutes } = await import("@fluixi/core/plugins");
+    const base = cfg.routesDir.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+    const assets = {};
+    const walk = (routes, inherited) => {
+      for (const route of routes) {
+        const files = [.../* @__PURE__ */ new Set([...inherited, ...manifest[`${base}/${route.filePath}`] ?? []])];
+        if (files.length) assets[route.urlPath] = [.../* @__PURE__ */ new Set([...assets[route.urlPath] ?? [], ...files])];
+        walk(route.children, files);
+      }
+    };
+    walk(scanRoutes(routesDir), []);
+    await writeFile2(join4(serverDir, "route-assets.json"), JSON.stringify(assets, null, 2) + "\n");
+  }
+  await rm(join4(clientDir, ".vite"), { recursive: true, force: true });
+}
+async function bundleEntry(cfg, plugins, source, outFile) {
+  const { build: viteBuild } = await import("vite");
+  const dir = dirname3(outFile);
+  const temp = join4(dir, `.fluixi-entry-${Date.now()}.js`);
+  await mkdir2(dir, { recursive: true });
+  await writeFile2(temp, source);
+  try {
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      logLevel: "warn",
+      // Nothing may be left to resolve: these run as an uploaded file, not an install.
+      ssr: { noExternal: true },
+      build: {
+        outDir: dir,
+        emptyOutDir: false,
+        ssr: temp,
+        rollupOptions: {
+          output: {
+            entryFileNames: basename(outFile),
+            // One file, no chunks. A lazy route would otherwise be split out beside
+            // the entry: and for Cloudflare that directory is the published one, so
+            // every server chunk would be a public download.
+            inlineDynamicImports: true
+          }
+        }
+      }
+    });
+  } finally {
+    await rm(temp, { force: true });
+  }
+}
+function bundleNote(cfg) {
+  const adapter = cfg.adapter;
+  if (!adapter?.bundle) return "";
+  return c.gray(` (${adapter.name} · ${adapter.bundle})`);
+}
+
+// src/commands/start.ts
+import { resolve as resolve6 } from "node:path";
+async function start(config = {}) {
+  const cfg = resolveConfig(config);
+  installCrashGuards();
+  await loadServerEnv(cfg.root, "production");
+  const clientDir = resolve6(cfg.root, "dist/client");
+  const handler = await createProdHandler(cfg);
+  const adapter = cfg.adapter ?? nodeAdapter;
+  const served = await adapter.serve({ handler, cfg, clientDir });
+  if (served && typeof served === "object" && "fetch" in served) {
+    console.log(
+      `  fluixi: the "${adapter.name}" adapter exports a fetch handler — there is no server to start. Deploy dist/ and let the platform invoke it, or run \`fluixi start\` with a filesystem adapter (nodeAdapter).`
+    );
+  }
+}
+export {
+  build,
+  dev,
+  prerender,
+  start
+};