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

package/dist/index.mjs

@@ -1,106 +1,9 @@
-/*! @fluixi/start v0.1.0-alpha.74 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/start v0.1.0-alpha.75 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
-// src/config.ts
-import { pathToFileURL } from "node:url";
-import { existsSync } from "node:fs";
-import { writeFile, unlink } from "node:fs/promises";
-import { resolve, isAbsolute } from "node:path";
+// src/define-config.ts
 function defineConfig(config) {
   return config;
 }
-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 ?? [],
-    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
-  };
-}
-var CONFIG_NAMES = [
-  "fluixi.config.ts",
-  "fluixi.config.mts",
-  "fluixi.config.mjs",
-  "fluixi.config.js"
-];
-async function loadConfig(root = process.cwd()) {
-  for (const name of CONFIG_NAMES) {
-    const file = resolve(root, name);
-    if (existsSync(file)) return loadConfigFile(file);
-  }
-  return {};
-}
-async function loadConfigFile(file) {
-  if (!/\.[mc]?ts$/.test(file)) {
-    const mod = await import(
-      /* @vite-ignore */
-      pathToFileURL(file).href
-    );
-    return mod.default ?? mod;
-  }
-  const esbuild = await import("esbuild");
-  const { outputFiles } = await esbuild.build({
-    entryPoints: [file],
-    bundle: true,
-    write: false,
-    format: "esm",
-    platform: "node",
-    target: `node${process.versions.node.split(".")[0]}`,
-    sourcemap: "inline",
-    plugins: [
-      {
-        name: "fluixi:externalize-bare",
-        setup(b) {
-          b.onResolve({ filter: /.*/ }, (args) => {
-            if (args.kind === "entry-point") return null;
-            if (args.path.startsWith(".") || isAbsolute(args.path)) return null;
-            return { path: args.path, external: true };
-          });
-        }
-      }
-    ]
-  });
-  const tempFile = `${file}.timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}.mjs`;
-  await writeFile(tempFile, outputFiles[0].text);
-  try {
-    const mod = await import(
-      /* @vite-ignore */
-      pathToFileURL(tempFile).href
-    );
-    return mod.default ?? mod;
-  } finally {
-    await unlink(tempFile).catch(() => {
-    });
-  }
-}
 
 // src/index.ts
 import { html, svg } from "@fluixi/core";
@@ -186,11 +89,6 @@ function guardHandler(handler, onError) {
 }
 
 // src/handler.ts
-import { createServer as createHttpServer } from "node:http";
-import { stat } from "node:fs/promises";
-import { createReadStream } from "node:fs";
-import { Readable } from "node:stream";
-import { join, extname } from "node:path";
 function streamDocument(head, body, tail) {
   const enc = new TextEncoder();
   const stream = new ReadableStream({
@@ -232,107 +130,6 @@ function createRequestHandler(render) {
     }
   };
 }
-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 = createHttpServer((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 !== "/" && extname(pathname)) {
-      const file = join(dir, decodeURIComponent(pathname));
-      try {
-        const s = await stat(file);
-        if (s.isFile()) {
-          const body = Readable.toWeb(createReadStream(file));
-          return new Response(body, {
-            headers: {
-              "content-type": MIME[extname(file).toLowerCase()] ?? "application/octet-stream",
-              "content-length": String(s.size)
-            }
-          });
-        }
-      } catch {
-      }
-    }
-    return handler(request);
-  };
-}
-
-// src/adapter.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { existsSync as existsSync3, readFileSync } from "node:fs";
-import { resolve as resolve2, join as join3, dirname } from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { createRequire } from "node:module";
 
 // src/middleware.ts
 function defineMiddleware(mw) {
@@ -395,385 +192,6 @@ function createHandlerFrom({ template, mod, cfg, middleware, preload }) {
   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/adapters/platforms.ts
-import { mkdir, writeFile as writeFile2, readFile, cp, readdir } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join2, relative } from "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 = join2(ctx.serverDir, "route-assets.json");
-  const routeAssets = existsSync2(assetFile) ? JSON.parse(await readFile(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 readFile(file, "utf-8").catch(() => "");
-  if (existing.includes(rule)) return;
-  const separator = existing && !existing.endsWith("\n") ? "\n" : "";
-  await writeFile2(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 readFile(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 writeFile2(
-      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 writeFile2(
-      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 writeFile2(
-        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 writeFile2(
-      join2(fn, ".vc-config.json"),
-      JSON.stringify(
-        { runtime: "nodejs20.x", handler: "index.mjs", launcherType: "Nodejs", shouldAddHelpers: false },
-        null,
-        2
-      ) + "\n"
-    );
-    await writeFile2(
-      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"
-    );
-  }
-};
-
-// 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 = existsSync3(serverEntry) ? await import(
-    /* @vite-ignore */
-    pathToFileURL2(serverEntry).href
-  ) : {};
-  const mwFile = resolve2(cfg.root, "dist/server", "middleware.js");
-  const middleware = existsSync3(mwFile) ? await import(
-    /* @vite-ignore */
-    pathToFileURL2(mwFile).href
-  ) : void 0;
-  return createHandlerFrom({ template, mod, cfg, middleware, preload: await loadPreloader(cfg) });
-}
-async function readTemplate(clientDir, serverDir) {
-  const stashed = join3(serverDir, "template.html");
-  return readFile2(existsSync3(stashed) ? stashed : join3(clientDir, "index.html"), "utf-8");
-}
-async function loadPreloader(cfg) {
-  const file = resolve2(cfg.root, "dist/server", "route-assets.json");
-  if (!existsSync3(file)) return void 0;
-  try {
-    return createPreloader(JSON.parse(await readFile2(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 ${join3(cfg.root, "package.json")} — bundling everything.`
-    );
-  }
-  return { noExternal, external: external.length ? external : void 0 };
-}
-function frameworkDeps(root) {
-  const pkg = readPackage(join3(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(join3(root, "index.js")).resolve(`${name}/package.json`));
-  } catch {
-  }
-  for (let dir = root; ; dir = dirname(dir)) {
-    const pkg = readPackage(join3(dir, "node_modules", name, "package.json"));
-    if (pkg) return pkg;
-    if (dirname(dir) === dir) return void 0;
-  }
-}
-function readPackage(file) {
-  if (!existsSync3(file)) return void 0;
-  try {
-    return JSON.parse(readFileSync(file, "utf-8"));
-  } catch {
-    return void 0;
-  }
-}
-
 // src/server-fn.ts
 var _fetch = (...a) => fetch(...a);
 function setServerFnFetch(f) {
@@ -812,114 +230,7 @@ async function fetchWithInterceptors(input, init) {
   return response;
 }
 
-// src/image.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { resolve as resolvePath, join as join4, extname as extname2, sep } from "node:path";
-var DEFAULT_SIZES = [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840];
-var MIME2 = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml"
-};
-var sharpModule;
-async function loadSharp() {
-  if (sharpModule !== void 0) return sharpModule;
-  try {
-    const name = "sharp";
-    sharpModule = (await import(
-      /* @vite-ignore */
-      name
-    )).default;
-  } catch {
-    sharpModule = null;
-  }
-  return sharpModule;
-}
-var defaultTransform = async (input, { width, quality, format }) => {
-  const sharp = await loadSharp();
-  if (!sharp) return null;
-  const pipe = sharp(input).rotate().resize({ width, withoutEnlargement: true });
-  if (format === "avif") return { data: new Uint8Array(await pipe.avif({ quality }).toBuffer()), contentType: "image/avif" };
-  if (format === "webp") return { data: new Uint8Array(await pipe.webp({ quality }).toBuffer()), contentType: "image/webp" };
-  if (format === "png") return { data: new Uint8Array(await pipe.png().toBuffer()), contentType: "image/png" };
-  return { data: new Uint8Array(await pipe.jpeg({ quality, mozjpeg: true }).toBuffer()), contentType: "image/jpeg" };
-};
-function imageResponse(body, contentType, maxAge) {
-  return new Response(body, {
-    headers: {
-      "content-type": contentType,
-      "cache-control": `public, max-age=${maxAge}, immutable`,
-      vary: "Accept"
-    }
-  });
-}
-function createImageHandler(options = {}) {
-  const root = resolvePath(options.root ?? join4(process.cwd(), "public"));
-  const domains = new Set((options.domains ?? []).map((d) => d.toLowerCase()));
-  const sizes = options.sizes ?? DEFAULT_SIZES;
-  const maxQuality = options.quality ?? 80;
-  const maxAge = options.cacheMaxAge ?? 60 * 60 * 24 * 365;
-  const transform = options.transform ?? defaultTransform;
-  const cacheMax = options.cache === false ? 0 : typeof options.cache === "number" ? options.cache : 100;
-  const cache = /* @__PURE__ */ new Map();
-  return async (request) => {
-    const url = new URL(request.url);
-    const src = url.searchParams.get("url") ?? url.searchParams.get("src");
-    const width = Number(url.searchParams.get("w"));
-    const quality = Math.min(Math.max(Number(url.searchParams.get("q")) || maxQuality, 1), 100);
-    if (!src) return new Response('missing "url"', { status: 400 });
-    if (!Number.isInteger(width) || !sizes.includes(width)) return new Response('invalid "w"', { status: 400 });
-    const accept = request.headers.get("accept") ?? "";
-    const format = accept.includes("image/avif") ? "avif" : accept.includes("image/webp") ? "webp" : "original";
-    const key = `${src}|${width}|${quality}|${format}`;
-    const hit = cache.get(key);
-    if (hit) return imageResponse(hit.body, hit.contentType, maxAge);
-    let input;
-    let sourceType;
-    if (/^https?:\/\//i.test(src)) {
-      let host;
-      try {
-        host = new URL(src).hostname.toLowerCase();
-      } catch {
-        return new Response("bad url", { status: 400 });
-      }
-      if (!domains.has(host)) return new Response("domain not allowed", { status: 403 });
-      const res = await fetch(src);
-      if (!res.ok) return new Response("upstream error", { status: 502 });
-      input = new Uint8Array(await res.arrayBuffer());
-      sourceType = res.headers.get("content-type") ?? "application/octet-stream";
-    } else {
-      const filePath = resolvePath(root, src.startsWith("/") ? src.slice(1) : src);
-      if (filePath !== root && !filePath.startsWith(root + sep)) return new Response("forbidden", { status: 403 });
-      try {
-        input = new Uint8Array(await readFile3(filePath));
-      } catch {
-        return new Response("not found", { status: 404 });
-      }
-      sourceType = MIME2[extname2(filePath).toLowerCase()] ?? "application/octet-stream";
-    }
-    if (sourceType === "image/svg+xml" || sourceType === "image/gif") {
-      return imageResponse(input, sourceType, maxAge);
-    }
-    let out = null;
-    try {
-      out = await transform(input, { width, quality, format, contentType: sourceType });
-    } catch {
-      out = null;
-    }
-    const body = out?.data ?? input;
-    const contentType = out?.contentType ?? sourceType;
-    if (cacheMax > 0) {
-      if (cache.size >= cacheMax) cache.delete(cache.keys().next().value);
-      cache.set(key, { body, contentType });
-    }
-    return imageResponse(body, contentType, maxAge);
-  };
-}
+// src/image-loader.ts
 function imageLoader(options = {}) {
   const path = options.path ?? "/api/image";
   return ({ src, width, quality }) => {
@@ -934,12 +245,8 @@ import { getRequestLocals, getLocals } from "@fluixi/server";
 export {
   addInterceptor,
   clearInterceptors,
-  cloudflareAdapter,
   composeMiddleware,
   createHandlerFrom,
-  createImageHandler,
-  createProdHandler,
-  createRequestHandler,
   defineConfig,
   defineMiddleware,
   fetchWithInterceptors,
@@ -949,20 +256,7 @@ export {
   imageLoader,
   injectApp,
   injectAppAndHead,
-  loadConfig,
-  netlifyAdapter,
-  nodeAdapter,
-  nodeToRequest,
   normalizeMiddleware,
-  resolveConfig,
-  sendResponse,
-  serveNode,
   splitTemplate,
-  ssrBuildOptions,
-  streamDocument,
-  svg,
-  toNodeHandler,
-  vercelAdapter,
-  webAdapter,
-  withStaticFiles
+  svg
 };