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

package/dist/adapters/platforms.mjs

@@ -0,0 +1,284 @@
+// src/adapters/platforms.ts
+import { mkdir, writeFile, readFile as readFile2, cp, readdir } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2, relative } from "node:path";
+
+// src/adapter.ts
+import { readFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+
+// src/document.ts
+import { extractHeadMarker } from "@fluixi/head";
+
+// src/preload.ts
+import { matchRoutes } from "@fluixi/core/router";
+
+// src/adapter.ts
+async function readTemplate(clientDir, serverDir) {
+  const stashed = join(serverDir, "template.html");
+  return readFile(existsSync(stashed) ? stashed : join(clientDir, "index.html"), "utf-8");
+}
+
+// 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 = join2(ctx.serverDir, "route-assets.json");
+  const routeAssets = existsSync2(assetFile) ? JSON.parse(await readFile2(assetFile, "utf-8")) : {};
+  const middleware = join2(ctx.serverDir, "middleware.js");
+  const rel = (file) => {
+    const path = join2(ctx.serverDir, file).replace(/\\/g, "/");
+    return path.startsWith("/") ? path : `./${path}`;
+  };
+  return {
+    serverEntry: rel("entry-server.js"),
+    middleware: existsSync2(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 = join2(clientDir, "_redirects");
+  const existing = await readFile2(file, "utf-8").catch(() => "");
+  if (existing.includes(rule)) return;
+  const separator = existing && !existing.endsWith("\n") ? "\n" : "";
+  await 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 readdir(current, { withFileTypes: true })) {
+      const path = join2(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 = relative(dir, path).replace(/\\/g, "/").replace(/index\.html$/, "").replace(/\.html$/, "");
+        out.push("/" + rel.replace(/\/$/, ""));
+      }
+    }
+  };
+  await walk(dir);
+  const index = await readFile2(join2(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 = join2(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 writeFile(
+      join2(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 = join2(ctx.root, ".netlify", "functions-internal");
+    await mkdir(dir, { recursive: true });
+    const out = join2(dir, "fluixi-server.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(netlifyEntry(await entrySource(ctx, out, prerendered)), out);
+    await writeFile(
+      join2(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 = join2(ctx.root, ".vercel", "output");
+    await mkdir(output, { recursive: true });
+    await cp(ctx.clientDir, join2(output, "static"), { recursive: true });
+    if (skipWhenStatic(ctx, "vercel")) {
+      await writeFile(
+        join2(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 = join2(output, "functions", "index.func");
+    await mkdir(fn, { recursive: true });
+    const out = join2(fn, "index.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(vercelEntry(await entrySource(ctx, out, prerendered)), out);
+    await writeFile(
+      join2(fn, ".vc-config.json"),
+      JSON.stringify(
+        { runtime: "nodejs20.x", handler: "index.mjs", launcherType: "Nodejs", shouldAddHelpers: false },
+        null,
+        2
+      ) + "\n"
+    );
+    await writeFile(
+      join2(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"
+    );
+  }
+};
+export {
+  cloudflareAdapter,
+  netlifyAdapter,
+  vercelAdapter
+};

package/dist/api-HD7KU3BS.mjs

@@ -0,0 +1,114 @@
+// src/api.ts
+import { readdirSync, statSync } from "node:fs";
+import { resolve as resolvePath, relative as relativePath, join } from "node:path";
+var API_VMOD = "virtual:fluixi-api";
+var METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+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 = readdirSync(dir);
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const full = join(dir, name);
+    if (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 = resolvePath(root, opts.dir);
+      const files = scanFiles(dir);
+      const imports = [];
+      const entries = [];
+      files.forEach((file, i) => {
+        const rel = relativePath(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 API_VIRTUAL_MODULE = API_VMOD;
+export {
+  API_VIRTUAL_MODULE,
+  apiRoutesVitePlugin,
+  derivePattern,
+  handleApi,
+  isApiPath,
+  matchApiRoutes
+};

package/dist/api.cjs

@@ -0,0 +1,145 @@
+/*! @fluixi/start v0.1.0-alpha.75 | (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/api.ts
+var api_exports = {};
+__export(api_exports, {
+  API_VIRTUAL_MODULE: () => API_VIRTUAL_MODULE,
+  apiRoutesVitePlugin: () => apiRoutesVitePlugin,
+  derivePattern: () => derivePattern,
+  handleApi: () => handleApi,
+  isApiPath: () => isApiPath,
+  matchApiRoutes: () => matchApiRoutes
+});
+module.exports = __toCommonJS(api_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var API_VMOD = "virtual:fluixi-api";
+var METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+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_path.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_path.resolve)(root, opts.dir);
+      const files = scanFiles(dir);
+      const imports = [];
+      const entries = [];
+      files.forEach((file, i) => {
+        const rel = (0, import_node_path.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 API_VIRTUAL_MODULE = API_VMOD;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_VIRTUAL_MODULE,
+  apiRoutesVitePlugin,
+  derivePattern,
+  handleApi,
+  isApiPath,
+  matchApiRoutes
+});

package/dist/api.js

@@ -91,7 +91,7 @@ export function apiRoutesVitePlugin(opts) {
     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 —
+        // 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) {

package/dist/api.mjs

@@ -0,0 +1,116 @@
+/*! @fluixi/start v0.1.0-alpha.75 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/api.ts
+import { readdirSync, statSync } from "node:fs";
+import { resolve as resolvePath, relative as relativePath, join } from "node:path";
+var API_VMOD = "virtual:fluixi-api";
+var METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+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 = readdirSync(dir);
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const full = join(dir, name);
+    if (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 = resolvePath(root, opts.dir);
+      const files = scanFiles(dir);
+      const imports = [];
+      const entries = [];
+      files.forEach((file, i) => {
+        const rel = relativePath(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 API_VIRTUAL_MODULE = API_VMOD;
+export {
+  API_VIRTUAL_MODULE,
+  apiRoutesVitePlugin,
+  derivePattern,
+  handleApi,
+  isApiPath,
+  matchApiRoutes
+};