@fluixi/start 0.1.0-alpha.72 → 0.1.0-alpha.74

package/dist/commands/index.cjs

@@ -0,0 +1,1138 @@
+/*! @fluixi/start v0.1.0-alpha.74 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  API_VIRTUAL_MODULE: () => API_VIRTUAL_MODULE,
+  apiRoutesVitePlugin: () => apiRoutesVitePlugin,
+  derivePattern: () => derivePattern,
+  handleApi: () => handleApi,
+  isApiPath: () => isApiPath,
+  matchApiRoutes: () => matchApiRoutes
+});
+function derivePattern(rel, prefix = "/api") {
+  const segs = rel.split("/").filter(Boolean);
+  if (segs[segs.length - 1] === "index") segs.pop();
+  const keys = [];
+  let rank = 0;
+  const parts = segs.map((seg) => {
+    const catchAll = seg.match(/^\[\.\.\.(.+)\]$/);
+    if (catchAll) {
+      keys.push(catchAll[1]);
+      return "(.+)";
+    }
+    const param = seg.match(/^\[(.+)\]$/);
+    if (param) {
+      keys.push(param[1]);
+      rank += 1;
+      return "([^/]+)";
+    }
+    rank += 10;
+    return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  });
+  return { source: `^${prefix}${parts.length ? "/" + parts.join("/") : ""}/?$`, keys, rank };
+}
+function isApiPath(pathname, prefix = "/api") {
+  return pathname === prefix || pathname.startsWith(prefix + "/");
+}
+function matchApiRoutes(routes, pathname) {
+  for (const r of [...routes].sort((a, b) => b.rank - a.rank)) {
+    const m = new RegExp(r.source).exec(pathname);
+    if (!m) continue;
+    const params = {};
+    r.keys.forEach((k, i) => params[k] = decodeURIComponent(m[i + 1] ?? ""));
+    return { mod: r.mod, params };
+  }
+  return null;
+}
+async function handleApi(routes, request, prefix = "/api") {
+  const pathname = new URL(request.url).pathname;
+  const match = matchApiRoutes(routes, pathname);
+  if (!match) return new Response("Not Found", { status: 404 });
+  const fn = match.mod[request.method];
+  if (typeof fn !== "function") {
+    const allow = METHODS.filter((m) => typeof match.mod[m] === "function").join(", ");
+    return new Response("Method Not Allowed", { status: 405, headers: allow ? { allow } : void 0 });
+  }
+  const out = await fn(request, { params: match.params });
+  if (out instanceof Response) return out;
+  return new Response(JSON.stringify(out ?? null), { headers: { "content-type": "application/json; charset=utf-8" } });
+}
+function scanFiles(dir, base = dir) {
+  let out = [];
+  let entries = [];
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const full = (0, import_node_path2.join)(dir, name);
+    if ((0, import_node_fs.statSync)(full).isDirectory()) out = out.concat(scanFiles(full, base));
+    else if (/\.(ts|tsx|js|mjs)$/.test(name) && !/\.(spec|test)\./.test(name)) out.push(full);
+  }
+  return out;
+}
+function apiRoutesVitePlugin(opts) {
+  let root = process.cwd();
+  const prefix = opts.prefix ?? "/api";
+  const id = "\0" + API_VMOD;
+  return {
+    name: "fluixi-api",
+    // Must beat node resolution: '@fluixi/start/api-routes' is a real file in this package,
+    // so without `pre` Vite resolves the typed stub and the generated table never loads —
+    // the app builds and every API route 404s.
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(source) {
+      return source === API_VMOD || source === "@fluixi/start/api-routes" ? id : null;
+    },
+    load(source) {
+      if (source !== id) return null;
+      const dir = (0, import_node_path2.resolve)(root, opts.dir);
+      const files = scanFiles(dir);
+      const imports = [];
+      const entries = [];
+      files.forEach((file, i) => {
+        const rel = (0, import_node_path2.relative)(dir, file).replace(/\.(ts|tsx|js|mjs)$/, "").split(/[\\/]/).join("/");
+        const { source: src, keys, rank } = derivePattern(rel, prefix);
+        imports.push(`import * as _${i} from ${JSON.stringify(file)};`);
+        entries.push(`{ source: ${JSON.stringify(src)}, keys: ${JSON.stringify(keys)}, rank: ${rank}, mod: _${i} }`);
+      });
+      return `import { isApiPath, handleApi } from '@fluixi/start/api';
+${imports.join("\n")}
+const routes = [${entries.join(",")}];
+export const isApiRequest = (request) => isApiPath(new URL(request.url).pathname, ${JSON.stringify(prefix)});
+export const handleApiRequest = (request) => handleApi(routes, request, ${JSON.stringify(prefix)});
+`;
+    }
+  };
+}
+var import_node_fs, import_node_path2, API_VMOD, METHODS, API_VIRTUAL_MODULE;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_path2 = require("node:path");
+    API_VMOD = "virtual:fluixi-api";
+    METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+    API_VIRTUAL_MODULE = API_VMOD;
+  }
+});
+
+// src/commands/index.ts
+var index_exports = {};
+__export(index_exports, {
+  build: () => build,
+  dev: () => dev,
+  prerender: () => prerender,
+  start: () => start
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands/dev.ts
+var import_node_http2 = require("node:http");
+var import_node_fs4 = require("node:fs");
+var import_node_path5 = require("node:path");
+
+// src/config.ts
+var import_node_path = require("node:path");
+function resolveConfig(config = {}) {
+  const root = (0, import_node_path.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 ?? [],
+    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
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/document.ts
+var import_head = require("@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 } = (0, import_head.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 = (0, import_node_path3.resolve)(root, opts.dir);
+      let files = [];
+      try {
+        files = (0, import_node_fs2.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((0, import_node_path3.resolve)(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 = (0, import_node_path3.resolve)(root, i18n.dir);
+  let discovered = [];
+  try {
+    discovered = (0, import_node_fs2.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 = (0, import_node_path3.resolve)(root, "src");
+  const toSpec = (l) => {
+    const rel = (0, import_node_path3.relative)(srcDir, (0, import_node_path3.resolve)(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 = (0, import_node_path3.resolve)(root, "src/fluixi-start-env.d.ts");
+      try {
+        if (!(0, import_node_fs2.existsSync)(file) || (0, import_node_fs2.readFileSync)(file, "utf8") !== content) (0, import_node_fs2.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.
+    fluixi({ resolve: cfg.resolve })
+  ];
+  if (cfg.i18n) plugins.push(i18nVitePlugin(cfg.i18n));
+  const { apiRoutesVitePlugin: apiRoutesVitePlugin2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  plugins.push(apiRoutesVitePlugin2({ 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
+var import_node_http = require("node:http");
+var import_promises = require("node:fs/promises");
+var import_node_fs3 = require("node:fs");
+var import_node_stream = require("node:stream");
+var import_node_path4 = require("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 = (0, import_node_http.createServer)((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 !== "/" && (0, import_node_path4.extname)(pathname)) {
+      const file = (0, import_node_path4.join)(dir, decodeURIComponent(pathname));
+      try {
+        const s = await (0, import_promises.stat)(file);
+        if (s.isFile()) {
+          const body = import_node_stream.Readable.toWeb((0, import_node_fs3.createReadStream)(file));
+          return new Response(body, {
+            headers: {
+              "content-type": MIME[(0, import_node_path4.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/commands/dev.ts
+init_api();
+
+// src/ui.ts
+var import_node_os = require("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((0, import_node_os.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 = (0, import_node_fs4.readFileSync)((0, import_node_path5.resolve)(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 = (0, import_node_fs4.existsSync)((0, import_node_path5.resolve)(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 = (0, import_node_http2.createServer)((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
+var import_node_fs6 = require("node:fs");
+var import_promises4 = require("node:fs/promises");
+var import_node_path8 = require("node:path");
+
+// src/adapter.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_fs5 = require("node:fs");
+var import_node_path6 = require("node:path");
+var import_node_url = require("node:url");
+var import_node_module = require("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
+var import_router = require("@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 = (0, import_router.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 = (0, import_node_path6.resolve)(cfg.root, "dist/client");
+  const template = await readTemplate(clientDir, (0, import_node_path6.resolve)(cfg.root, "dist/server"));
+  const serverEntry = (0, import_node_path6.resolve)(cfg.root, "dist/server", "entry-server.js");
+  const mod = (0, import_node_fs5.existsSync)(serverEntry) ? await import(
+    /* @vite-ignore */
+    (0, import_node_url.pathToFileURL)(serverEntry).href
+  ) : {};
+  const mwFile = (0, import_node_path6.resolve)(cfg.root, "dist/server", "middleware.js");
+  const middleware = (0, import_node_fs5.existsSync)(mwFile) ? await import(
+    /* @vite-ignore */
+    (0, import_node_url.pathToFileURL)(mwFile).href
+  ) : void 0;
+  return createHandlerFrom({ template, mod, cfg, middleware, preload: await loadPreloader(cfg) });
+}
+async function readTemplate(clientDir, serverDir) {
+  const stashed = (0, import_node_path6.join)(serverDir, "template.html");
+  return (0, import_promises2.readFile)((0, import_node_fs5.existsSync)(stashed) ? stashed : (0, import_node_path6.join)(clientDir, "index.html"), "utf-8");
+}
+async function loadPreloader(cfg) {
+  const file = (0, import_node_path6.resolve)(cfg.root, "dist/server", "route-assets.json");
+  if (!(0, import_node_fs5.existsSync)(file)) return void 0;
+  try {
+    return createPreloader(JSON.parse(await (0, import_promises2.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 ${(0, import_node_path6.join)(cfg.root, "package.json")} — bundling everything.`
+    );
+  }
+  return { noExternal, external: external.length ? external : void 0 };
+}
+function frameworkDeps(root) {
+  const pkg = readPackage((0, import_node_path6.join)(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 exports2 = resolvePackage(root, name)?.exports;
+  if (!exports2 || typeof exports2 !== "object") return [name];
+  const ids = [name];
+  for (const key of Object.keys(exports2)) {
+    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((0, import_node_module.createRequire)((0, import_node_path6.join)(root, "index.js")).resolve(`${name}/package.json`));
+  } catch {
+  }
+  for (let dir = root; ; dir = (0, import_node_path6.dirname)(dir)) {
+    const pkg = readPackage((0, import_node_path6.join)(dir, "node_modules", name, "package.json"));
+    if (pkg) return pkg;
+    if ((0, import_node_path6.dirname)(dir) === dir) return void 0;
+  }
+}
+function readPackage(file) {
+  if (!(0, import_node_fs5.existsSync)(file)) return void 0;
+  try {
+    return JSON.parse((0, import_node_fs5.readFileSync)(file, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/prerender.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path7 = require("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 = (0, import_node_path7.resolve)(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 = (0, import_node_path7.join)(clientDir, htmlPath(url));
+    await (0, import_promises3.mkdir)((0, import_node_path7.dirname)(file), { recursive: true });
+    await (0, import_promises3.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 = (0, import_node_path8.resolve)(cfg.root, cfg.serverEntry);
+  if (cfg.ssr || (0, import_node_fs6.existsSync)(serverEntrySrc)) {
+    step(`server bundle${bundleNote(cfg)}`);
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      ssr,
+      build: {
+        outDir: "dist/server",
+        ssr: serverEntrySrc,
+        emptyOutDir: true
+      }
+    });
+  }
+  const middlewareSrc = (0, import_node_path8.resolve)(cfg.root, cfg.middleware);
+  if ((0, import_node_fs6.existsSync)(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 (0, import_promises4.copyFile)(
+      (0, import_node_path8.resolve)(cfg.root, "dist/client", "index.html"),
+      (0, import_node_path8.resolve)(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: (0, import_node_path8.resolve)(cfg.root, "dist/client"),
+      serverDir: (0, import_node_path8.resolve)(cfg.root, "dist/server"),
+      hasServer: (0, import_node_fs6.existsSync)((0, import_node_path8.resolve)(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 = (0, import_node_path8.resolve)(cfg.root, "dist/client");
+  const manifestFile = (0, import_node_path8.join)(clientDir, ".vite", "ssr-manifest.json");
+  if (!(0, import_node_fs6.existsSync)(manifestFile)) return;
+  const serverDir = (0, import_node_path8.resolve)(cfg.root, "dist/server");
+  const routesDir = (0, import_node_path8.resolve)(cfg.root, cfg.routesDir);
+  if ((0, import_node_fs6.existsSync)(serverDir) && (0, import_node_fs6.existsSync)(routesDir)) {
+    const manifest = JSON.parse(await (0, import_promises4.readFile)(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 (0, import_promises4.writeFile)((0, import_node_path8.join)(serverDir, "route-assets.json"), JSON.stringify(assets, null, 2) + "\n");
+  }
+  await (0, import_promises4.rm)((0, import_node_path8.join)(clientDir, ".vite"), { recursive: true, force: true });
+}
+async function bundleEntry(cfg, plugins, source, outFile) {
+  const { build: viteBuild } = await import("vite");
+  const dir = (0, import_node_path8.dirname)(outFile);
+  const temp = (0, import_node_path8.join)(dir, `.fluixi-entry-${Date.now()}.js`);
+  await (0, import_promises4.mkdir)(dir, { recursive: true });
+  await (0, import_promises4.writeFile)(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: (0, import_node_path8.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 (0, import_promises4.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
+var import_node_path9 = require("node:path");
+async function start(config = {}) {
+  const cfg = resolveConfig(config);
+  installCrashGuards();
+  await loadServerEnv(cfg.root, "production");
+  const clientDir = (0, import_node_path9.resolve)(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).`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  dev,
+  prerender,
+  start
+});