npm - @fluixi/start - Versions diffs - 0.1.0-alpha.73 → 0.1.0-alpha.75 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (123) hide show

package/dist/adapter.cjs +750 -0
package/dist/adapter.d.ts +9 -9
package/dist/adapter.d.ts.map +1 -1
package/dist/adapter.js +10 -10
package/dist/adapter.mjs +719 -0
package/dist/adapters/entry.cjs +122 -0
package/dist/adapters/entry.js +1 -1
package/dist/adapters/entry.mjs +95 -0
package/dist/adapters/platforms.cjs +311 -0
package/dist/adapters/platforms.d.ts +2 -2
package/dist/adapters/platforms.js +8 -8
package/dist/adapters/platforms.mjs +284 -0
package/dist/api-HD7KU3BS.mjs +114 -0
package/dist/api.cjs +145 -0
package/dist/api.js +1 -1
package/dist/api.mjs +116 -0
package/dist/commands/api-HD7KU3BS.mjs +114 -0
package/dist/commands/api-PBT4QZ34.mjs +16 -0
package/dist/commands/api-PJL37LV3.mjs +17 -0
package/dist/commands/build.cjs +877 -0
package/dist/commands/build.js +6 -6
package/dist/commands/build.mjs +717 -0
package/dist/commands/chunk-GFQ4MUIC.mjs +117 -0
package/dist/commands/chunk-MTM6M3TC.mjs +115 -0
package/dist/commands/dev.cjs +670 -0
package/dist/commands/dev.js +3 -3
package/dist/commands/dev.mjs +512 -0
package/dist/commands/index.cjs +1145 -0
package/dist/commands/index.d.ts +1 -1
package/dist/commands/index.js +1 -1
package/dist/commands/index.mjs +982 -0
package/dist/commands/prerender.cjs +404 -0
package/dist/commands/prerender.d.ts +1 -1
package/dist/commands/prerender.js +2 -2
package/dist/commands/prerender.mjs +377 -0
package/dist/commands/start.cjs +463 -0
package/dist/commands/start.d.ts +1 -1
package/dist/commands/start.js +2 -2
package/dist/commands/start.mjs +428 -0
package/dist/config.cjs +150 -0
package/dist/config.d.ts +24 -7
package/dist/config.d.ts.map +1 -1
package/dist/config.js +8 -6
package/dist/config.mjs +114 -0
package/dist/define-config.cjs +32 -0
package/dist/define-config.d.ts +12 -0
package/dist/define-config.d.ts.map +1 -0
package/dist/define-config.js +3 -0
package/dist/define-config.mjs +7 -0
package/dist/di.cjs +200 -0
package/dist/di.d.ts +4 -4
package/dist/di.d.ts.map +1 -1
package/dist/di.js +9 -9
package/dist/di.mjs +169 -0
package/dist/document.cjs +115 -0
package/dist/document.d.ts +1 -1
package/dist/document.js +1 -1
package/dist/document.mjs +86 -0
package/dist/generated-api.cjs +43 -0
package/dist/generated-api.js +1 -1
package/dist/generated-api.mjs +18 -0
package/dist/generated-server-fns.cjs +43 -0
package/dist/generated-server-fns.mjs +18 -0
package/dist/handler-core.cjs +211 -0
package/dist/handler-core.d.ts +2 -2
package/dist/handler-core.js +2 -2
package/dist/handler-core.mjs +185 -0
package/dist/handler.cjs +182 -0
package/dist/handler.d.ts +3 -3
package/dist/handler.js +3 -3
package/dist/handler.mjs +152 -0
package/dist/head.cjs +25 -0
package/dist/head.d.ts +1 -1
package/dist/head.js +1 -1
package/dist/head.mjs +4 -0
package/dist/image-loader.cjs +37 -0
package/dist/image-loader.d.ts +25 -0
package/dist/image-loader.d.ts.map +1 -0
package/dist/image-loader.js +18 -0
package/dist/image-loader.mjs +12 -0
package/dist/image.cjs +151 -0
package/dist/image.d.ts +2 -19
package/dist/image.d.ts.map +1 -1
package/dist/image.js +5 -21
package/dist/image.mjs +126 -0
package/dist/index.cjs +303 -0
package/dist/index.d.ts +28 -8
package/dist/index.d.ts.map +1 -1
package/dist/index.js +33 -17
package/dist/index.mjs +262 -0
package/dist/interceptors.cjs +72 -0
package/dist/interceptors.js +1 -1
package/dist/interceptors.mjs +44 -0
package/dist/internal.cjs +393 -0
package/dist/internal.d.ts +6 -6
package/dist/internal.d.ts.map +1 -1
package/dist/internal.js +23 -15
package/dist/internal.mjs +223 -0
package/dist/middleware.cjs +58 -0
package/dist/middleware.d.ts +3 -3
package/dist/middleware.d.ts.map +1 -1
package/dist/middleware.js +1 -1
package/dist/middleware.mjs +31 -0
package/dist/preload.cjs +42 -0
package/dist/preload.js +1 -1
package/dist/preload.mjs +18 -0
package/dist/router.cjs +25 -0
package/dist/router.d.ts +3 -3
package/dist/router.js +3 -3
package/dist/router.mjs +4 -0
package/dist/server-fn-setup.cjs +46 -0
package/dist/server-fn-setup.d.ts +1 -1
package/dist/server-fn-setup.js +2 -2
package/dist/server-fn-setup.mjs +22 -0
package/dist/server-fn.cjs +109 -0
package/dist/server-fn.d.ts +2 -2
package/dist/server-fn.js +2 -2
package/dist/server-fn.mjs +79 -0
package/dist/tsconfig.lib.tsbuildinfo +1 -1
package/dist/ui.cjs +123 -0
package/dist/ui.js +1 -1
package/dist/ui.mjs +93 -0
package/package.json +63 -25

package/dist/commands/build.mjs ADDED Viewed

@@ -0,0 +1,717 @@
+// src/commands/build.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir2, writeFile as writeFile2, rm, copyFile, readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve4, dirname as dirname3, join as join3, basename } from "node:path";
+// src/config.ts
+import { resolve, isAbsolute } from "node:path";
+function resolveConfig(config = {}) {
+  const root = resolve(config.root ?? process.cwd());
+  return {
+    root,
+    ssr: config.ssr ?? true,
+    port: config.port ?? 3e3,
+    serverEntry: config.serverEntry ?? "src/entry-server.ts",
+    clientEntry: config.clientEntry ?? "src/entry-client.ts",
+    template: config.template ?? "index.html",
+    mountId: config.mountId ?? "root",
+    routesDir: config.routesDir ?? "src/routes",
+    apiDir: config.apiDir ?? "src/api",
+    middleware: config.middleware ?? "src/middleware.ts",
+    ssrNoExternal: config.ssrNoExternal ?? [],
+    resolve: config.resolve ?? [],
+    vitePlugin: config.vitePlugin ?? {},
+    plugins: config.plugins ?? [],
+    adapter: config.adapter,
+    i18n: resolveI18n(config.i18n),
+    prerender: resolvePrerender(config.prerender)
+  };
+}
+function resolvePrerender(prerender2) {
+  if (!prerender2) return false;
+  const opts = typeof prerender2 === "object" ? prerender2 : {};
+  return {
+    routes: opts.routes?.length ? opts.routes : ["/"],
+    crawl: opts.crawl ?? true
+  };
+}
+function resolveI18n(i18n) {
+  if (i18n === false) return false;
+  const opts = typeof i18n === "object" ? i18n : {};
+  return {
+    dir: opts.dir ?? "src/i18n",
+    defaultLocale: opts.defaultLocale,
+    locales: opts.locales
+  };
+}
+// src/internal.ts
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve as resolvePath, relative as relativePath } from "node:path";
+// src/document.ts
+import { extractHeadMarker } from "@fluixi/head";
+function injectApp(template, appHtml, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  if (mount.test(template)) {
+    return template.replace(mount, `<div id="${mountId}">${appHtml}</div>`);
+  }
+  if (template.includes("<!--ssr-outlet-->")) {
+    return template.replace("<!--ssr-outlet-->", appHtml);
+  }
+  return template.replace("</body>", `<div id="${mountId}">${appHtml}</div></body>`);
+}
+function splitTemplate(template, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  const m = template.match(mount);
+  if (m && m.index !== void 0) {
+    return {
+      head: template.slice(0, m.index) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(m.index + m[0].length)
+    };
+  }
+  const outlet = template.indexOf("<!--ssr-outlet-->");
+  if (outlet !== -1) {
+    return {
+      head: template.slice(0, outlet),
+      tail: template.slice(outlet + "<!--ssr-outlet-->".length)
+    };
+  }
+  const body = template.indexOf("</body>");
+  if (body !== -1) {
+    return {
+      head: template.slice(0, body) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(body)
+    };
+  }
+  return { head: template, tail: "" };
+}
+function injectPreload(template, files) {
+  const tags = files.filter((file) => !template.includes(file)).map(
+    (file) => file.endsWith(".css") ? `<link rel="stylesheet" href="${file}">` : (
+      // `modulepreload` also fetches the chunk's own static imports.
+      `<link rel="modulepreload" href="${file}">`
+    )
+  );
+  if (tags.length === 0) return template;
+  const head = template.indexOf("</head>");
+  if (head === -1) return template;
+  return template.slice(0, head) + tags.join("") + template.slice(head);
+}
+function setHtmlAttr(html, name, value) {
+  const existing = new RegExp(`(<html\\b[^>]*?)\\s${name}="[^"]*"`, "i");
+  if (existing.test(html)) return html.replace(existing, `$1 ${name}="${value}"`);
+  return html.replace(/<html\b/i, `<html ${name}="${value}"`);
+}
+function injectAppAndHead(template, rendered, mountId = "root") {
+  const { head, body } = extractHeadMarker(rendered);
+  let html = injectApp(template, body, mountId);
+  if (head) {
+    if (head.headHtml) {
+      if (/<title[\s>]/i.test(head.headHtml)) html = html.replace(/<title>[\s\S]*?<\/title>/i, "");
+      html = html.replace("</head>", `${head.headHtml}</head>`);
+    }
+    for (const [k, v] of Object.entries(head.htmlAttrs)) html = setHtmlAttr(html, k, v);
+  }
+  return html;
+}
+function guardHandler(handler, onError) {
+  return async (request) => {
+    try {
+      return await handler(request);
+    } catch (e) {
+      onError?.(e);
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+// src/internal.ts
+var I18N_VMOD = "virtual:fluixi-i18n";
+function i18nVitePlugin(opts) {
+  let root = process.cwd();
+  const id = "\0" + I18N_VMOD;
+  return {
+    name: "fluixi-i18n",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(source) {
+      return source === I18N_VMOD ? id : null;
+    },
+    load(source) {
+      if (source !== id) return null;
+      const dir = resolvePath(root, opts.dir);
+      let files = [];
+      try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+      } catch {
+      }
+      const discovered = files.map((f) => f.replace(/\.json$/, "")).sort();
+      const locales = opts.locales?.length ? opts.locales : discovered;
+      const defaultLocale = opts.defaultLocale ?? locales[0] ?? "en";
+      const imports = locales.map((l, i) => `import _${i} from ${JSON.stringify(resolvePath(dir, l + ".json"))};`).join("\n");
+      const messages = `export const messages = {${locales.map((l, i) => `${JSON.stringify(l)}:_${i}`).join(",")}};`;
+      return `${imports}
+export const locales = ${JSON.stringify(locales)};
+export const defaultLocale = ${JSON.stringify(defaultLocale)};
+${messages}
+`;
+    }
+  };
+}
+async function loadServerEnv(root, mode) {
+  const { loadEnv } = await import("vite");
+  const env = loadEnv(mode, root, "");
+  for (const [k, v] of Object.entries(env)) {
+    if (process.env[k] === void 0) process.env[k] = v;
+  }
+}
+function i18nTypeBlock(root, i18n) {
+  const dir = resolvePath(root, i18n.dir);
+  let discovered = [];
+  try {
+    discovered = readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+  } catch {
+  }
+  const locales = i18n.locales?.length ? i18n.locales : discovered;
+  const defaultLocale = i18n.defaultLocale ?? locales[0] ?? "en";
+  const typed = locales.length > 0 && locales.every((l) => discovered.includes(l));
+  if (!typed) {
+    return [
+      `declare module 'virtual:fluixi-i18n' {`,
+      `  export const messages: Record<string, Record<string, unknown>>;`,
+      `  export const locales: string[];`,
+      `  export const defaultLocale: string;`,
+      `}`
+    ];
+  }
+  const srcDir = resolvePath(root, "src");
+  const toSpec = (l) => {
+    const rel = relativePath(srcDir, resolvePath(dir, l + ".json")).split(/[\\/]/).join("/");
+    return rel.startsWith(".") ? rel : "./" + rel;
+  };
+  const entries = locales.map((l) => `    ${JSON.stringify(l)}: (typeof import(${JSON.stringify(toSpec(l))}))['default'];`);
+  const tuple = locales.map((l) => JSON.stringify(l)).join(", ");
+  return [
+    `declare module 'virtual:fluixi-i18n' {`,
+    `  export const messages: {`,
+    ...entries,
+    `  };`,
+    `  export const locales: readonly [${tuple}];`,
+    `  export const defaultLocale: ${JSON.stringify(defaultLocale)};`,
+    `}`
+  ];
+}
+function startTypesPlugin(cfg) {
+  let root = process.cwd();
+  return {
+    name: "fluixi-start-types",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    buildStart() {
+      const blocks = [];
+      if (cfg.i18n) blocks.push(...i18nTypeBlock(root, cfg.i18n));
+      if (blocks.length === 0) return;
+      const content = `// Auto-generated by @fluixi/start, do not edit.
+${blocks.join("\n")}
+`;
+      const file = resolvePath(root, "src/fluixi-start-env.d.ts");
+      try {
+        if (!existsSync(file) || readFileSync(file, "utf8") !== content) writeFileSync(file, content);
+      } catch {
+      }
+    }
+  };
+}
+async function fluixiPlugins(cfg) {
+  const { fluixi, fluixiRoutesPlugin } = await import("@fluixi/core/plugins");
+  const { serverFunctionsVitePlugin } = await import("@fluixi/compiler/integrations");
+  const plugins = [
+    serverFunctionsVitePlugin(),
+    fluixiRoutesPlugin({ routesDir: cfg.routesDir, polyfills: false }),
+    // The app's component-resolution rules reach the compiler here; without this an SSR
+    // app has no way to say where an unimported tag comes from.
+    //
+    // `fluixi()` and not `createVitePlugin()`: the latter is the bare compiler integration,
+    // and the reactive graph: agent, source marks, /__fluixi/graph, is composed on top of
+    // it by the former. A start app got no graph at all until this changed.
+    // Everything the app declared for the compiler, with `resolve` still usable on its
+    // own because it is the one most apps set. A start app never writes
+    // `fluixi()` itself, so without this passthrough the plugin's other options
+    // (propsDestructure and the rest) had nowhere to be declared.
+    fluixi({ ...cfg.vitePlugin ?? {}, ...cfg.resolve ? { resolve: cfg.resolve } : {} })
+  ];
+  if (cfg.plugins?.length) plugins.push(...cfg.plugins);
+  if (cfg.i18n) plugins.push(i18nVitePlugin(cfg.i18n));
+  const { apiRoutesVitePlugin } = await import("./api-HD7KU3BS.mjs");
+  plugins.push(apiRoutesVitePlugin({ dir: cfg.apiDir }));
+  plugins.push(startTypesPlugin(cfg));
+  return plugins;
+}
+// src/adapter.ts
+import { readFile } from "node:fs/promises";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve2, join, dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+// 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: 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" }
+      });
+    }
+  };
+}
+// 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
+import { matchRoutes } from "@fluixi/core/router";
+function createPreloader(assets) {
+  const patterns = Object.keys(assets ?? {});
+  if (!patterns.length) return () => [];
+  const routes = patterns.map((path) => ({ path, meta: { path } }));
+  return (pathname) => {
+    const matched = matchRoutes(routes, pathname)?.matched;
+    const leaf = matched?.[matched.length - 1];
+    const pattern = leaf?.route.meta?.path;
+    return pattern ? assets[pattern] ?? [] : [];
+  };
+}
+// src/adapter.ts
+async function createProdHandler(config = {}) {
+  const cfg = resolveConfig(config);
+  const clientDir = resolve2(cfg.root, "dist/client");
+  const template = await readTemplate(clientDir, resolve2(cfg.root, "dist/server"));
+  const serverEntry = resolve2(cfg.root, "dist/server", "entry-server.js");
+  const mod = existsSync2(serverEntry) ? await import(
+    /* @vite-ignore */
+    pathToFileURL(serverEntry).href
+  ) : {};
+  const mwFile = resolve2(cfg.root, "dist/server", "middleware.js");
+  const middleware = existsSync2(mwFile) ? await import(
+    /* @vite-ignore */
+    pathToFileURL(mwFile).href
+  ) : void 0;
+  return createHandlerFrom({ template, mod, cfg, middleware, preload: await loadPreloader(cfg) });
+}
+async function readTemplate(clientDir, serverDir) {
+  const stashed = join(serverDir, "template.html");
+  return readFile(existsSync2(stashed) ? stashed : join(clientDir, "index.html"), "utf-8");
+}
+async function loadPreloader(cfg) {
+  const file = resolve2(cfg.root, "dist/server", "route-assets.json");
+  if (!existsSync2(file)) return void 0;
+  try {
+    return createPreloader(JSON.parse(await readFile(file, "utf-8")));
+  } catch {
+    return void 0;
+  }
+}
+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 ${join(cfg.root, "package.json")}, bundling everything.`
+    );
+  }
+  return { noExternal, external: external.length ? external : void 0 };
+}
+function frameworkDeps(root) {
+  const pkg = readPackage(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 exports = resolvePackage(root, name)?.exports;
+  if (!exports || typeof exports !== "object") return [name];
+  const ids = [name];
+  for (const key of Object.keys(exports)) {
+    if (!key.startsWith("./") || key.includes("*")) continue;
+    if (key === "./package.json" || GENERATED_SUBPATHS.has(key)) continue;
+    ids.push(`${name}/${key.slice(2)}`);
+  }
+  return ids;
+}
+function resolvePackage(root, name) {
+  try {
+    return readPackage(createRequire(join(root, "index.js")).resolve(`${name}/package.json`));
+  } catch {
+  }
+  for (let dir = root; ; dir = dirname(dir)) {
+    const pkg = readPackage(join(dir, "node_modules", name, "package.json"));
+    if (pkg) return pkg;
+    if (dirname(dir) === dir) return void 0;
+  }
+}
+function readPackage(file) {
+  if (!existsSync2(file)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(file, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+// src/commands/prerender.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve as resolve3, join as join2, dirname as dirname2 } from "node:path";
+// src/ui.ts
+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 step(text) {
+  process.stdout.write(`  ${c.cyan("•")} ${text}
+`);
+}
+function done(text) {
+  process.stdout.write(`  ${SYM.ok} ${text}
+`);
+}
+// src/commands/prerender.ts
+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 = resolve3(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 = join2(clientDir, htmlPath(url));
+    await mkdir(dirname2(file), { recursive: true });
+    await writeFile(file, html);
+    written.push(url);
+    if (crawl) {
+      for (const link of extractLinks(html)) if (!seen.has(link)) queue.push(link);
+    }
+  }
+  done(`${c.bold("prerendered")} ${c.bold(String(written.length))} page(s)  ${c.gray("→ dist/client")}
+`);
+  return written;
+}
+// src/commands/build.ts
+async function build(config = {}) {
+  const startedAt = Date.now();
+  const cfg = resolveConfig(config);
+  await loadServerEnv(cfg.root, "production");
+  const { build: viteBuild } = await import("vite");
+  const plugins = await fluixiPlugins(cfg);
+  const ssr = ssrBuildOptions(cfg);
+  process.stdout.write(`
+  ${wordmark()}  ${c.gray("building for production")}
+`);
+  step("client bundle");
+  await viteBuild({
+    root: cfg.root,
+    plugins,
+    logLevel: "warn",
+    build: { outDir: "dist/client", ssrManifest: true, emptyOutDir: true }
+  });
+  const serverEntrySrc = resolve4(cfg.root, cfg.serverEntry);
+  if (cfg.ssr || existsSync3(serverEntrySrc)) {
+    step(`server bundle${bundleNote(cfg)}`);
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      ssr,
+      build: {
+        outDir: "dist/server",
+        ssr: serverEntrySrc,
+        emptyOutDir: true
+      }
+    });
+  }
+  const middlewareSrc = resolve4(cfg.root, cfg.middleware);
+  if (existsSync3(middlewareSrc)) {
+    step("middleware");
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      logLevel: "warn",
+      ssr,
+      build: {
+        outDir: "dist/server",
+        ssr: middlewareSrc,
+        emptyOutDir: false
+      }
+    });
+  }
+  await collectRouteAssets(cfg);
+  if (cfg.prerender) {
+    await copyFile(
+      resolve4(cfg.root, "dist/client", "index.html"),
+      resolve4(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: resolve4(cfg.root, "dist/client"),
+      serverDir: resolve4(cfg.root, "dist/server"),
+      hasServer: existsSync3(resolve4(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 = resolve4(cfg.root, "dist/client");
+  const manifestFile = join3(clientDir, ".vite", "ssr-manifest.json");
+  if (!existsSync3(manifestFile)) return;
+  const serverDir = resolve4(cfg.root, "dist/server");
+  const routesDir = resolve4(cfg.root, cfg.routesDir);
+  if (existsSync3(serverDir) && existsSync3(routesDir)) {
+    const manifest = JSON.parse(await readFile2(manifestFile, "utf-8"));
+    const { scanRoutes } = await import("@fluixi/core/plugins");
+    const base = cfg.routesDir.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+    const assets = {};
+    const walk = (routes, inherited) => {
+      for (const route of routes) {
+        const files = [.../* @__PURE__ */ new Set([...inherited, ...manifest[`${base}/${route.filePath}`] ?? []])];
+        if (files.length) assets[route.urlPath] = [.../* @__PURE__ */ new Set([...assets[route.urlPath] ?? [], ...files])];
+        walk(route.children, files);
+      }
+    };
+    walk(scanRoutes(routesDir), []);
+    await writeFile2(join3(serverDir, "route-assets.json"), JSON.stringify(assets, null, 2) + "\n");
+  }
+  await rm(join3(clientDir, ".vite"), { recursive: true, force: true });
+}
+async function bundleEntry(cfg, plugins, source, outFile) {
+  const { build: viteBuild } = await import("vite");
+  const dir = dirname3(outFile);
+  const temp = join3(dir, `.fluixi-entry-${Date.now()}.js`);
+  await mkdir2(dir, { recursive: true });
+  await writeFile2(temp, source);
+  try {
+    await viteBuild({
+      root: cfg.root,
+      plugins,
+      logLevel: "warn",
+      // Nothing may be left to resolve: these run as an uploaded file, not an install.
+      ssr: { noExternal: true },
+      build: {
+        outDir: dir,
+        emptyOutDir: false,
+        ssr: temp,
+        rollupOptions: {
+          output: {
+            entryFileNames: basename(outFile),
+            // One file, no chunks. A lazy route would otherwise be split out beside
+            // the entry: and for Cloudflare that directory is the published one, so
+            // every server chunk would be a public download.
+            inlineDynamicImports: true
+          }
+        }
+      }
+    });
+  } finally {
+    await rm(temp, { force: true });
+  }
+}
+function bundleNote(cfg) {
+  const adapter = cfg.adapter;
+  if (!adapter?.bundle) return "";
+  return c.gray(` (${adapter.name} · ${adapter.bundle})`);
+}
+export {
+  build
+};