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

package/dist/commands/dev.cjs

@@ -0,0 +1,663 @@
+"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/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev
+});
+module.exports = __toCommonJS(dev_exports);
+var import_node_http = require("node:http");
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = 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(prerender) {
+  if (!prerender) return false;
+  const opts = typeof prerender === "object" ? prerender : {};
+  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 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
+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, value } = await reader.read();
+          if (done) 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 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, value } = await reader.read();
+      if (done) break;
+      res.write(value);
+    }
+  } finally {
+    res.end();
+  }
+}
+function toNodeHandler(handler) {
+  return async (req, res) => {
+    const response = await handler(nodeToRequest(req));
+    await sendResponse(res, response);
+  };
+}
+
+// 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");
+}
+
+// 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_fs3.readFileSync)((0, import_node_path4.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_fs3.existsSync)((0, import_node_path4.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_http.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 }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dev
+});