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

package/dist/adapter.cjs

@@ -0,0 +1,748 @@
+/*! @fluixi/start v0.1.0-alpha.74 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  cloudflareAdapter: () => cloudflareAdapter,
+  createProdHandler: () => createProdHandler,
+  netlifyAdapter: () => netlifyAdapter,
+  nodeAdapter: () => nodeAdapter,
+  readTemplate: () => readTemplate,
+  ssrBuildOptions: () => ssrBuildOptions,
+  vercelAdapter: () => vercelAdapter,
+  webAdapter: () => webAdapter
+});
+module.exports = __toCommonJS(adapter_exports);
+var import_promises3 = require("node:fs/promises");
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = require("node:path");
+var import_node_url = require("node:url");
+var import_node_module = require("node:module");
+
+// 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/handler.ts
+var import_node_http = require("node:http");
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_stream = require("node:stream");
+var import_node_path2 = 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, 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 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, 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);
+  };
+}
+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_path2.extname)(pathname)) {
+      const file = (0, import_node_path2.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_fs.createReadStream)(file));
+          return new Response(body, {
+            headers: {
+              "content-type": MIME[(0, import_node_path2.extname)(file).toLowerCase()] ?? "application/octet-stream",
+              "content-length": String(s.size)
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return handler(request);
+  };
+}
+
+// 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/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/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/adapters/platforms.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/adapters/entry.ts
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's — the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+
+// src/adapters/platforms.ts
+async function entrySource(ctx, from, prerendered) {
+  const template = await readTemplate(ctx.clientDir, ctx.serverDir);
+  const assetFile = (0, import_node_path3.join)(ctx.serverDir, "route-assets.json");
+  const routeAssets = (0, import_node_fs2.existsSync)(assetFile) ? JSON.parse(await (0, import_promises2.readFile)(assetFile, "utf-8")) : {};
+  const middleware = (0, import_node_path3.join)(ctx.serverDir, "middleware.js");
+  const rel = (file) => {
+    const path = (0, import_node_path3.join)(ctx.serverDir, file).replace(/\\/g, "/");
+    return path.startsWith("/") ? path : `./${path}`;
+  };
+  return {
+    serverEntry: rel("entry-server.js"),
+    middleware: (0, import_node_fs2.existsSync)(middleware) ? rel("middleware.js") : null,
+    template,
+    ssr: ctx.cfg.ssr,
+    mountId: ctx.cfg.mountId,
+    prerendered,
+    routeAssets
+  };
+}
+function indexIsPage(template, mountId) {
+  const mount = new RegExp(`<([a-z-]+)[^>]*\\sid=["']${mountId}["'][^>]*>`, "i").exec(template);
+  if (!mount) return false;
+  return !template.slice(mount.index + mount[0].length).trimStart().startsWith("</");
+}
+function skipWhenStatic(ctx, name) {
+  if (ctx.hasServer) return false;
+  console.log(`  fluixi: no server entry — ${name} gets the static output alone.`);
+  return true;
+}
+async function appendRedirect(clientDir, rule) {
+  const file = (0, import_node_path3.join)(clientDir, "_redirects");
+  const existing = await (0, import_promises2.readFile)(file, "utf-8").catch(() => "");
+  if (existing.includes(rule)) return;
+  const separator = existing && !existing.endsWith("\n") ? "\n" : "";
+  await (0, import_promises2.writeFile)(file, `${existing}${separator}${rule}
+`);
+}
+var SPA_FALLBACK = "/*  /index.html  200";
+var CF_MAX_RULES = 100;
+async function prerenderedRoutes(dir, mountId) {
+  const out = [];
+  const walk = async (current) => {
+    for (const entry of await (0, import_promises2.readdir)(current, { withFileTypes: true })) {
+      const path = (0, import_node_path3.join)(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "assets" || entry.name.startsWith(".")) continue;
+        await walk(path);
+      } else if (entry.name.endsWith(".html")) {
+        const rel = (0, import_node_path3.relative)(dir, path).replace(/\\/g, "/").replace(/index\.html$/, "").replace(/\.html$/, "");
+        out.push("/" + rel.replace(/\/$/, ""));
+      }
+    }
+  };
+  await walk(dir);
+  const index = await (0, import_promises2.readFile)((0, import_node_path3.join)(dir, "index.html"), "utf-8").catch(() => "");
+  const root = indexIsPage(index, mountId);
+  return out.filter((r) => r !== "/" || root).sort();
+}
+var cloudflareAdapter = {
+  name: "cloudflare",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    if (skipWhenStatic(ctx, "cloudflare")) return;
+    const out = (0, import_node_path3.join)(ctx.clientDir, "_worker.js");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(cloudflareEntry(await entrySource(ctx, out, prerendered)), out);
+    const base = ["/assets/*", "/_worker.js"];
+    const room = CF_MAX_RULES - base.length;
+    const exclude = [...base, ...prerendered.slice(0, room)];
+    if (prerendered.length > room) {
+      console.warn(
+        `  fluixi: ${prerendered.length} prerendered routes exceed Cloudflare's ${CF_MAX_RULES}-rule limit for _routes.json; ${prerendered.length - room} will invoke the worker to serve a static file.`
+      );
+    }
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path3.join)(ctx.clientDir, "_routes.json"),
+      JSON.stringify({ version: 1, include: ["/*"], exclude }, null, 2) + "\n"
+    );
+  }
+};
+var netlifyAdapter = {
+  name: "netlify",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    if (skipWhenStatic(ctx, "netlify")) return appendRedirect(ctx.clientDir, SPA_FALLBACK);
+    const dir = (0, import_node_path3.join)(ctx.root, ".netlify", "functions-internal");
+    await (0, import_promises2.mkdir)(dir, { recursive: true });
+    const out = (0, import_node_path3.join)(dir, "fluixi-server.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(netlifyEntry(await entrySource(ctx, out, prerendered)), out);
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path3.join)(dir, "fluixi-server.json"),
+      JSON.stringify({ config: { path: "/*", preferStatic: true }, version: 1 }, null, 2) + "\n"
+    );
+    if (!prerendered.includes("/")) {
+      await appendRedirect(ctx.clientDir, "/  /.netlify/functions/fluixi-server  200!");
+    }
+  }
+};
+var vercelAdapter = {
+  name: "vercel",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    const output = (0, import_node_path3.join)(ctx.root, ".vercel", "output");
+    await (0, import_promises2.mkdir)(output, { recursive: true });
+    await (0, import_promises2.cp)(ctx.clientDir, (0, import_node_path3.join)(output, "static"), { recursive: true });
+    if (skipWhenStatic(ctx, "vercel")) {
+      await (0, import_promises2.writeFile)(
+        (0, import_node_path3.join)(output, "config.json"),
+        JSON.stringify(
+          {
+            version: 3,
+            // The filesystem phase alone answers 404 for a client route, since nothing
+            // is on disk at that path; the catch-all is what makes it a SPA.
+            routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/index.html" }]
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      return;
+    }
+    const fn = (0, import_node_path3.join)(output, "functions", "index.func");
+    await (0, import_promises2.mkdir)(fn, { recursive: true });
+    const out = (0, import_node_path3.join)(fn, "index.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(vercelEntry(await entrySource(ctx, out, prerendered)), out);
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path3.join)(fn, ".vc-config.json"),
+      JSON.stringify(
+        { runtime: "nodejs20.x", handler: "index.mjs", launcherType: "Nodejs", shouldAddHelpers: false },
+        null,
+        2
+      ) + "\n"
+    );
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path3.join)(output, "config.json"),
+      JSON.stringify(
+        {
+          version: 3,
+          routes: [
+            // The filesystem holds a shell at `/index.html`, so `/` has to be claimed
+            // before that phase or it is served unrendered. Skipped when `/` really is
+            // a prerendered page, which the filesystem should answer.
+            ...prerendered.includes("/") ? [] : [{ src: "/", dest: "/index" }],
+            // A prerendered page or an asset wins; only a miss reaches the function.
+            { handle: "filesystem" },
+            { src: "/(.*)", dest: "/index" }
+          ]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+};
+
+// src/adapter.ts
+async function createProdHandler(config = {}) {
+  const cfg = resolveConfig(config);
+  const clientDir = (0, import_node_path4.resolve)(cfg.root, "dist/client");
+  const template = await readTemplate(clientDir, (0, import_node_path4.resolve)(cfg.root, "dist/server"));
+  const serverEntry = (0, import_node_path4.resolve)(cfg.root, "dist/server", "entry-server.js");
+  const mod = (0, import_node_fs3.existsSync)(serverEntry) ? await import(
+    /* @vite-ignore */
+    (0, import_node_url.pathToFileURL)(serverEntry).href
+  ) : {};
+  const mwFile = (0, import_node_path4.resolve)(cfg.root, "dist/server", "middleware.js");
+  const middleware = (0, import_node_fs3.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_path4.join)(serverDir, "template.html");
+  return (0, import_promises3.readFile)((0, import_node_fs3.existsSync)(stashed) ? stashed : (0, import_node_path4.join)(clientDir, "index.html"), "utf-8");
+}
+async function loadPreloader(cfg) {
+  const file = (0, import_node_path4.resolve)(cfg.root, "dist/server", "route-assets.json");
+  if (!(0, import_node_fs3.existsSync)(file)) return void 0;
+  try {
+    return createPreloader(JSON.parse(await (0, import_promises3.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 webAdapter = {
+  name: "web",
+  // An edge/serverless runtime uploads a file, not an install: nothing may be left to
+  // resolve at runtime, so everything goes in the bundle.
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  }
+};
+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_path4.join)(cfg.root, "package.json")} — bundling everything.`
+    );
+  }
+  return { noExternal, external: external.length ? external : void 0 };
+}
+function frameworkDeps(root) {
+  const pkg = readPackage((0, import_node_path4.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_path4.join)(root, "index.js")).resolve(`${name}/package.json`));
+  } catch {
+  }
+  for (let dir = root; ; dir = (0, import_node_path4.dirname)(dir)) {
+    const pkg = readPackage((0, import_node_path4.join)(dir, "node_modules", name, "package.json"));
+    if (pkg) return pkg;
+    if ((0, import_node_path4.dirname)(dir) === dir) return void 0;
+  }
+}
+function readPackage(file) {
+  if (!(0, import_node_fs3.existsSync)(file)) return void 0;
+  try {
+    return JSON.parse((0, import_node_fs3.readFileSync)(file, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudflareAdapter,
+  createProdHandler,
+  netlifyAdapter,
+  nodeAdapter,
+  readTemplate,
+  ssrBuildOptions,
+  vercelAdapter,
+  webAdapter
+});