@ereo/server 0.1.6

package/dist/index.js

@@ -0,0 +1,1080 @@
+// @bun
+var __require = import.meta.require;
+
+// src/bun-server.ts
+import { createContext } from "@ereo/core";
+import { matchWithLayouts } from "@ereo/router";
+
+// src/middleware.ts
+class MiddlewareChain {
+  middlewares = [];
+  use(pathOrHandler, maybeHandler) {
+    if (typeof pathOrHandler === "function") {
+      this.middlewares.push({ handler: pathOrHandler });
+    } else {
+      this.middlewares.push({ path: pathOrHandler, handler: maybeHandler });
+    }
+    return this;
+  }
+  async execute(request, context, final) {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    const applicable = this.middlewares.filter((m) => {
+      if (!m.path)
+        return true;
+      const paths = Array.isArray(m.path) ? m.path : [m.path];
+      return paths.some((p) => this.matchPath(pathname, p));
+    });
+    let index = 0;
+    const next = async () => {
+      if (index < applicable.length) {
+        const middleware = applicable[index++];
+        return middleware.handler(request, context, next);
+      }
+      return final();
+    };
+    return next();
+  }
+  matchPath(pathname, pattern) {
+    if (pattern === "*")
+      return true;
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      return pathname.startsWith(prefix);
+    }
+    return pathname === pattern;
+  }
+}
+function createMiddlewareChain() {
+  return new MiddlewareChain;
+}
+function logger() {
+  return async (request, context, next) => {
+    const start = performance.now();
+    const url = new URL(request.url);
+    console.log(`\u2192 ${request.method} ${url.pathname}`);
+    const response = await next();
+    const duration = (performance.now() - start).toFixed(2);
+    console.log(`\u2190 ${request.method} ${url.pathname} ${response.status} ${duration}ms`);
+    return response;
+  };
+}
+function cors(options = {}) {
+  const {
+    origin = "*",
+    methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    allowedHeaders = ["Content-Type", "Authorization"],
+    exposedHeaders = [],
+    credentials = false,
+    maxAge = 86400
+  } = options;
+  return async (request, context, next) => {
+    const requestOrigin = request.headers.get("Origin");
+    let allowedOrigin = null;
+    if (typeof origin === "string") {
+      allowedOrigin = origin;
+    } else if (Array.isArray(origin)) {
+      allowedOrigin = requestOrigin && origin.includes(requestOrigin) ? requestOrigin : null;
+    } else if (typeof origin === "function") {
+      allowedOrigin = requestOrigin && origin(requestOrigin) ? requestOrigin : null;
+    }
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": allowedOrigin || "*",
+          "Access-Control-Allow-Methods": methods.join(", "),
+          "Access-Control-Allow-Headers": allowedHeaders.join(", "),
+          "Access-Control-Max-Age": maxAge.toString(),
+          ...credentials && { "Access-Control-Allow-Credentials": "true" }
+        }
+      });
+    }
+    const response = await next();
+    const headers = new Headers(response.headers);
+    if (allowedOrigin) {
+      headers.set("Access-Control-Allow-Origin", allowedOrigin);
+    }
+    if (exposedHeaders.length > 0) {
+      headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "));
+    }
+    if (credentials) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+function securityHeaders(options = {}) {
+  const {
+    contentSecurityPolicy = "default-src 'self'",
+    xFrameOptions = "SAMEORIGIN",
+    xContentTypeOptions = true,
+    referrerPolicy = "strict-origin-when-cross-origin",
+    permissionsPolicy = false
+  } = options;
+  return async (request, context, next) => {
+    const response = await next();
+    const headers = new Headers(response.headers);
+    if (contentSecurityPolicy) {
+      headers.set("Content-Security-Policy", contentSecurityPolicy);
+    }
+    if (xFrameOptions) {
+      headers.set("X-Frame-Options", xFrameOptions);
+    }
+    if (xContentTypeOptions) {
+      headers.set("X-Content-Type-Options", "nosniff");
+    }
+    if (referrerPolicy) {
+      headers.set("Referrer-Policy", referrerPolicy);
+    }
+    if (permissionsPolicy) {
+      headers.set("Permissions-Policy", permissionsPolicy);
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+function compress() {
+  return async (request, context, next) => {
+    const response = await next();
+    const acceptEncoding = request.headers.get("Accept-Encoding") || "";
+    const contentType = response.headers.get("Content-Type") || "";
+    const shouldCompress = (contentType.includes("text/") || contentType.includes("application/json") || contentType.includes("application/javascript")) && acceptEncoding.includes("gzip");
+    if (!shouldCompress) {
+      return response;
+    }
+    const headers = new Headers(response.headers);
+    headers.set("Content-Encoding", "gzip");
+    return new Response(Bun.gzipSync(await response.arrayBuffer()), {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+function rateLimit(options = {}) {
+  const { windowMs = 60000, max = 100, keyGenerator } = options;
+  const requests = new Map;
+  const getKey = keyGenerator || ((request) => {
+    const forwarded = request.headers.get("X-Forwarded-For");
+    return forwarded?.split(",")[0].trim() || "unknown";
+  });
+  return async (request, context, next) => {
+    const key = getKey(request);
+    const now = Date.now();
+    let record = requests.get(key);
+    if (!record || now > record.resetTime) {
+      record = { count: 0, resetTime: now + windowMs };
+      requests.set(key, record);
+    }
+    record.count++;
+    if (Math.random() < 0.01) {
+      for (const [k, v] of requests) {
+        if (now > v.resetTime) {
+          requests.delete(k);
+        }
+      }
+    }
+    if (record.count > max) {
+      return new Response(JSON.stringify({ error: "Too many requests" }), {
+        status: 429,
+        headers: {
+          "Content-Type": "application/json",
+          "Retry-After": Math.ceil((record.resetTime - now) / 1000).toString()
+        }
+      });
+    }
+    const response = await next();
+    const headers = new Headers(response.headers);
+    headers.set("X-RateLimit-Limit", max.toString());
+    headers.set("X-RateLimit-Remaining", Math.max(0, max - record.count).toString());
+    headers.set("X-RateLimit-Reset", Math.ceil(record.resetTime / 1000).toString());
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+
+// src/static.ts
+import { stat } from "fs/promises";
+import { join, extname } from "path";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".wasm": "application/wasm",
+  ".map": "application/json",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml"
+};
+function getMimeType(filepath) {
+  const ext = extname(filepath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+var NEGOTIABLE_IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png"];
+function supportsFormat(accept, format) {
+  if (!accept)
+    return false;
+  return accept.includes(`image/${format}`);
+}
+async function findOptimizedVariant(filepath, accept) {
+  const ext = extname(filepath).toLowerCase();
+  if (!NEGOTIABLE_IMAGE_EXTENSIONS.includes(ext)) {
+    return null;
+  }
+  const basePath = filepath.slice(0, -ext.length);
+  if (supportsFormat(accept, "avif")) {
+    const avifPath = `${basePath}.avif`;
+    try {
+      await stat(avifPath);
+      return { path: avifPath, mime: "image/avif" };
+    } catch {}
+  }
+  if (supportsFormat(accept, "webp")) {
+    const webpPath = `${basePath}.webp`;
+    try {
+      await stat(webpPath);
+      return { path: webpPath, mime: "image/webp" };
+    } catch {}
+  }
+  return null;
+}
+function serveStatic(options) {
+  const {
+    root,
+    prefix = "/",
+    maxAge = 0,
+    immutable = true,
+    index = "index.html",
+    listing = false,
+    fallback,
+    negotiateImageFormat = true
+  } = options;
+  return async (request) => {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      return null;
+    }
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+    if (prefix !== "/" && !pathname.startsWith(prefix)) {
+      return null;
+    }
+    if (prefix !== "/") {
+      pathname = pathname.slice(prefix.length) || "/";
+    }
+    if (pathname.includes("..")) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    let filepath = join(root, pathname);
+    try {
+      let stats = await stat(filepath);
+      if (negotiateImageFormat && stats.isFile()) {
+        const accept = request.headers.get("Accept");
+        const optimized = await findOptimizedVariant(filepath, accept);
+        if (optimized) {
+          filepath = optimized.path;
+          stats = await stat(filepath);
+        }
+      }
+      if (stats.isDirectory()) {
+        const indexPath = join(filepath, index);
+        try {
+          stats = await stat(indexPath);
+          filepath = indexPath;
+        } catch {
+          if (listing) {
+            return createDirectoryListing(filepath, pathname);
+          }
+          return null;
+        }
+      }
+      const file = Bun.file(filepath);
+      const headers = new Headers;
+      headers.set("Content-Type", getMimeType(filepath));
+      headers.set("Content-Length", stats.size.toString());
+      const etag = `"${stats.mtimeMs.toString(16)}-${stats.size.toString(16)}"`;
+      headers.set("ETag", etag);
+      headers.set("Last-Modified", new Date(stats.mtimeMs).toUTCString());
+      const isFingerprinted = /\.[a-f0-9]{8,}\./.test(filepath);
+      if (isFingerprinted && immutable) {
+        headers.set("Cache-Control", `public, max-age=${maxAge}, immutable`);
+      } else if (maxAge > 0) {
+        headers.set("Cache-Control", `public, max-age=${maxAge}`);
+      }
+      const ext = extname(filepath).toLowerCase();
+      if (negotiateImageFormat && NEGOTIABLE_IMAGE_EXTENSIONS.includes(ext)) {
+        headers.set("Vary", "Accept");
+      }
+      const ifNoneMatch = request.headers.get("If-None-Match");
+      if (ifNoneMatch === etag) {
+        return new Response(null, { status: 304, headers });
+      }
+      const ifModifiedSince = request.headers.get("If-Modified-Since");
+      if (ifModifiedSince) {
+        const ifModifiedDate = new Date(ifModifiedSince);
+        if (stats.mtimeMs <= ifModifiedDate.getTime()) {
+          return new Response(null, { status: 304, headers });
+        }
+      }
+      if (request.method === "HEAD") {
+        return new Response(null, { status: 200, headers });
+      }
+      return new Response(file, { status: 200, headers });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (fallback) {
+          const fallbackPath = join(root, fallback);
+          try {
+            const file = Bun.file(fallbackPath);
+            return new Response(file, {
+              status: 200,
+              headers: {
+                "Content-Type": "text/html; charset=utf-8"
+              }
+            });
+          } catch {}
+        }
+        return null;
+      }
+      throw error;
+    }
+  };
+}
+async function createDirectoryListing(dirpath, pathname) {
+  const { readdir } = await import("fs/promises");
+  const entries = await readdir(dirpath, { withFileTypes: true });
+  const items = entries.map((entry) => {
+    const name = entry.isDirectory() ? `${entry.name}/` : entry.name;
+    const href = join(pathname, entry.name);
+    return `<li><a href="${href}">${name}</a></li>`;
+  });
+  const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Index of ${pathname}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; padding: 2rem; }
+    ul { list-style: none; padding: 0; }
+    li { padding: 0.25rem 0; }
+    a { color: #0066cc; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+  </style>
+</head>
+<body>
+  <h1>Index of ${pathname}</h1>
+  <ul>
+    ${pathname !== "/" ? '<li><a href="..">..</a></li>' : ""}
+    ${items.join(`
+    `)}
+  </ul>
+</body>
+</html>
+  `.trim();
+  return new Response(html, {
+    status: 200,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+function staticMiddleware(options) {
+  const handler = serveStatic(options);
+  return async (request, context, next) => {
+    const response = await handler(request);
+    if (response)
+      return response;
+    return next();
+  };
+}
+
+// src/streaming.ts
+import { serializeLoaderData } from "@ereo/data";
+function createShell(options) {
+  const { shell = {}, scripts = [], styles = [], loaderData } = options;
+  const htmlAttrs = Object.entries(shell.htmlAttrs || {}).map(([k, v]) => `${k}="${v}"`).join(" ");
+  const bodyAttrs = Object.entries(shell.bodyAttrs || {}).map(([k, v]) => `${k}="${v}"`).join(" ");
+  const metaTags = (shell.meta || []).map((m) => {
+    const key = m.name ? `name="${m.name}"` : `property="${m.property}"`;
+    return `<meta ${key} content="${m.content}">`;
+  }).join(`
+    `);
+  const styleLinks = styles.map((href) => `<link rel="stylesheet" href="${href}">`).join(`
+    `);
+  const scriptTags = scripts.map((src) => `<script type="module" src="${src}"></script>`).join(`
+    `);
+  const loaderScript = loaderData ? `<script>window.__EREO_DATA__=${serializeLoaderData(loaderData)}</script>` : "";
+  const head = `<!DOCTYPE html>
+<html ${htmlAttrs}>
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    ${shell.title ? `<title>${shell.title}</title>` : ""}
+    ${metaTags}
+    ${styleLinks}
+    ${shell.head || ""}
+</head>
+<body ${bodyAttrs}>
+<div id="root">`;
+  const tail = `</div>
+    ${loaderScript}
+    ${scriptTags}
+</body>
+</html>`;
+  return { head, tail };
+}
+async function renderToStream(element, options) {
+  const { renderToPipeableStream } = await import("react-dom/server");
+  const { shell, scripts = [], styles = [] } = options;
+  let loaderData = null;
+  if (options.match.route.module?.loader) {
+    loaderData = await options.match.route.module.loader({
+      request: new Request("http://localhost"),
+      params: options.match.params,
+      context: options.context
+    });
+  }
+  const { head, tail } = createShell({ shell, scripts, styles, loaderData });
+  return new Promise((resolve, reject) => {
+    const { PassThrough } = __require("stream");
+    const { pipe, abort } = renderToPipeableStream(element, {
+      bootstrapScripts: scripts,
+      onShellReady() {
+        const passThrough = new PassThrough;
+        const chunks = [];
+        chunks.push(Buffer.from(head));
+        passThrough.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        passThrough.on("end", () => {
+          chunks.push(Buffer.from(tail));
+          const fullHtml = Buffer.concat(chunks).toString("utf-8");
+          resolve({
+            body: fullHtml,
+            headers: new Headers({
+              "Content-Type": "text/html; charset=utf-8",
+              "Content-Length": Buffer.byteLength(fullHtml).toString()
+            }),
+            status: 200
+          });
+        });
+        passThrough.on("error", (error) => {
+          console.error("Stream error:", error);
+          reject(error);
+        });
+        pipe(passThrough);
+      },
+      onShellError(error) {
+        console.error("Shell render error:", error);
+        reject(error);
+      },
+      onError(error) {
+        console.error("Render error:", error);
+      }
+    });
+    setTimeout(() => {
+      abort();
+    }, 1e4);
+  });
+}
+async function renderToString(element, options) {
+  const { renderToString: reactRenderToString } = await import("react-dom/server");
+  const { shell, scripts = [], styles = [] } = options;
+  let loaderData = null;
+  if (options.match.route.module?.loader) {
+    loaderData = await options.match.route.module.loader({
+      request: new Request("http://localhost"),
+      params: options.match.params,
+      context: options.context
+    });
+  }
+  const { head, tail } = createShell({ shell, scripts, styles, loaderData });
+  const content = reactRenderToString(element);
+  const html = head + content + tail;
+  return {
+    body: html,
+    headers: new Headers({
+      "Content-Type": "text/html; charset=utf-8",
+      "Content-Length": Buffer.byteLength(html).toString()
+    }),
+    status: 200
+  };
+}
+function createResponse(result) {
+  return new Response(result.body, {
+    status: result.status,
+    headers: result.headers
+  });
+}
+function createSuspenseStream() {
+  const encoder = new TextEncoder;
+  let controller;
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  return {
+    stream,
+    push: (chunk) => {
+      controller.enqueue(encoder.encode(chunk));
+    },
+    close: () => {
+      controller.close();
+    }
+  };
+}
+
+// src/bun-server.ts
+import { serializeLoaderData as serializeLoaderData2 } from "@ereo/data";
+import { createElement } from "react";
+async function getStreamingRenderer() {
+  try {
+    const browserServer = await import("react-dom/server.browser");
+    if (typeof browserServer.renderToReadableStream === "function") {
+      return {
+        renderToReadableStream: browserServer.renderToReadableStream,
+        renderToString: browserServer.renderToString
+      };
+    }
+  } catch {}
+  try {
+    const server = await import("react-dom/server");
+    return {
+      renderToReadableStream: server.renderToReadableStream,
+      renderToString: server.renderToString
+    };
+  } catch {
+    return {
+      renderToReadableStream: undefined,
+      renderToString: (await import("react-dom/server")).renderToString
+    };
+  }
+}
+
+class BunServer {
+  server = null;
+  app = null;
+  router = null;
+  middleware;
+  staticHandler = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      port: 3000,
+      hostname: "localhost",
+      development: true,
+      logging: true,
+      renderMode: "streaming",
+      assetsPath: "/_ereo",
+      clientEntry: "/_ereo/client.js",
+      ...options
+    };
+    this.middleware = createMiddlewareChain();
+    this.setupMiddleware();
+    if (options.static) {
+      this.staticHandler = serveStatic(options.static);
+    }
+  }
+  setupMiddleware() {
+    if (this.options.logging) {
+      this.middleware.use(logger());
+    }
+    if (this.options.cors) {
+      const corsOptions = typeof this.options.cors === "object" ? this.options.cors : {};
+      this.middleware.use(cors(corsOptions));
+    }
+    if (this.options.security !== false) {
+      const securityOptions = typeof this.options.security === "object" ? this.options.security : {};
+      this.middleware.use(securityHeaders(securityOptions));
+    }
+  }
+  setApp(app) {
+    this.app = app;
+  }
+  setRouter(router) {
+    this.router = router;
+    if (this.app) {
+      this.app.setRouteMatcher((pathname) => router.match(pathname));
+    }
+  }
+  use(pathOrHandler, maybeHandler) {
+    if (typeof pathOrHandler === "function") {
+      this.middleware.use(pathOrHandler);
+    } else if (maybeHandler) {
+      this.middleware.use(pathOrHandler, maybeHandler);
+    }
+  }
+  async handleRequest(request) {
+    const context = createContext(request);
+    try {
+      if (this.staticHandler) {
+        const staticResponse = await this.staticHandler(request);
+        if (staticResponse) {
+          return staticResponse;
+        }
+      }
+      const response = await this.middleware.execute(request, context, async () => {
+        if (this.options.handler) {
+          return this.options.handler(request);
+        }
+        if (this.router) {
+          const pathname = new URL(request.url).pathname;
+          if (typeof this.router.getRoutes === "function") {
+            const routes = this.router.getRoutes();
+            const matchResult = matchWithLayouts(pathname, routes);
+            if (!matchResult) {
+              return new Response("Not Found", { status: 404 });
+            }
+            await this.router.loadModule(matchResult.route);
+            for (const layout of matchResult.layouts) {
+              await this.router.loadModule(layout);
+            }
+            return this.handleRoute(request, matchResult, context);
+          } else {
+            const match = this.router.match(pathname);
+            if (!match) {
+              return new Response("Not Found", { status: 404 });
+            }
+            if (typeof this.router.loadModule === "function") {
+              await this.router.loadModule(match.route);
+            }
+            return this.handleRoute(request, { ...match, layouts: [] }, context);
+          }
+        }
+        if (this.app) {
+          return this.app.handle(request);
+        }
+        return new Response("Not Found", { status: 404 });
+      });
+      return context.applyToResponse(response);
+    } catch (error) {
+      return this.handleError(error, context);
+    }
+  }
+  async handleRoute(request, match, context) {
+    const module = match.route.module;
+    if (!module) {
+      return new Response("Route module not loaded", { status: 500 });
+    }
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      if (module.action) {
+        const result = await module.action({
+          request,
+          params: match.params,
+          context
+        });
+        if (result instanceof Response) {
+          return result;
+        }
+        return new Response(JSON.stringify(result), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    let loaderData = null;
+    if (module.loader) {
+      loaderData = await module.loader({
+        request,
+        params: match.params,
+        context
+      });
+      if (loaderData instanceof Response) {
+        return loaderData;
+      }
+    }
+    if (request.headers.get("Accept")?.includes("application/json")) {
+      return new Response(JSON.stringify({ data: loaderData, params: match.params }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return this.renderPage(request, match, context, loaderData);
+  }
+  async renderPage(request, match, context, loaderData) {
+    const module = match.route.module;
+    if (!module?.default) {
+      return this.renderMinimalPage(match, loaderData);
+    }
+    const url = new URL(request.url);
+    const metaDescriptors = this.buildMeta(module, loaderData, match.params, url);
+    const shell = {
+      ...this.options.shell,
+      title: this.extractTitle(metaDescriptors) || this.options.shell?.title,
+      meta: this.extractMetaTags(metaDescriptors)
+    };
+    const PageComponent = module.default;
+    let element = createElement(PageComponent, {
+      loaderData,
+      params: match.params
+    });
+    const layouts = match.layouts || [];
+    for (let i = layouts.length - 1;i >= 0; i--) {
+      const layout = layouts[i];
+      if (layout.module?.default) {
+        const LayoutComponent = layout.module.default;
+        element = createElement(LayoutComponent, {
+          loaderData: null,
+          params: match.params,
+          children: element
+        });
+      }
+    }
+    const hasRootLayout = layouts.length > 0 && layouts[0].module?.default;
+    if (hasRootLayout) {
+      if (this.options.renderMode === "streaming") {
+        return this.renderStreamingPageDirect(element, loaderData);
+      } else {
+        return this.renderStringPageDirect(element, loaderData);
+      }
+    }
+    if (this.options.renderMode === "streaming") {
+      return this.renderStreamingPage(element, shell, loaderData);
+    } else {
+      return this.renderStringPage(element, shell, loaderData);
+    }
+  }
+  async renderStreamingPage(element, shell, loaderData) {
+    try {
+      const { renderToReadableStream } = await getStreamingRenderer();
+      if (!renderToReadableStream) {
+        return this.renderStringPage(element, shell, loaderData);
+      }
+      const scripts = [this.options.clientEntry];
+      const { head, tail } = createShell({ shell, scripts, loaderData });
+      const encoder = new TextEncoder;
+      const headBytes = encoder.encode(head);
+      const tailBytes = encoder.encode(tail);
+      const reactStream = await renderToReadableStream(element, {
+        onError(error) {
+          console.error("Streaming render error:", error);
+        }
+      });
+      await reactStream.allReady;
+      const reader = reactStream.getReader();
+      const chunks = [headBytes];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+      }
+      chunks.push(tailBytes);
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const fullHtml = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        fullHtml.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return new Response(fullHtml, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Content-Length": totalLength.toString()
+        }
+      });
+    } catch (error) {
+      console.error("Streaming render failed:", error);
+      return this.renderStringPage(element, shell, loaderData);
+    }
+  }
+  async renderStringPage(element, shell, loaderData) {
+    try {
+      const { renderToString: reactRenderToString } = await import("react-dom/server");
+      const scripts = [this.options.clientEntry];
+      const { head, tail } = createShell({ shell, scripts, loaderData });
+      const content = reactRenderToString(element);
+      const html = head + content + tail;
+      const encoder = new TextEncoder;
+      const htmlBytes = encoder.encode(html);
+      return new Response(htmlBytes, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Content-Length": htmlBytes.length.toString()
+        }
+      });
+    } catch (error) {
+      console.error("String render failed:", error);
+      return this.renderErrorPage(error);
+    }
+  }
+  async renderStreamingPageDirect(element, loaderData) {
+    try {
+      const { renderToReadableStream } = await getStreamingRenderer();
+      if (!renderToReadableStream) {
+        return this.renderStringPageDirect(element, loaderData);
+      }
+      const reactStream = await renderToReadableStream(element, {
+        onError(error) {
+          console.error("Streaming render error:", error);
+        }
+      });
+      await reactStream.allReady;
+      const reader = reactStream.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+      }
+      const encoder = new TextEncoder;
+      const loaderScript = loaderData ? `<script>window.__EREO_DATA__=${serializeLoaderData2(loaderData)}</script>` : "";
+      const clientScript = `<script type="module" src="${this.options.clientEntry}"></script>`;
+      const injectedScripts = encoder.encode(loaderScript + clientScript);
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0) + injectedScripts.length;
+      const fullHtml = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        fullHtml.set(chunk, offset);
+        offset += chunk.length;
+      }
+      fullHtml.set(injectedScripts, offset);
+      return new Response(fullHtml, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Content-Length": totalLength.toString()
+        }
+      });
+    } catch (error) {
+      console.error("Streaming render failed:", error);
+      return this.renderStringPageDirect(element, loaderData);
+    }
+  }
+  async renderStringPageDirect(element, loaderData) {
+    try {
+      const { renderToString: reactRenderToString } = await import("react-dom/server");
+      let html = reactRenderToString(element);
+      const loaderScript = loaderData ? `<script>window.__EREO_DATA__=${serializeLoaderData2(loaderData)}</script>` : "";
+      const clientScript = `<script type="module" src="${this.options.clientEntry}"></script>`;
+      html = html.replace("</body>", `${loaderScript}${clientScript}</body>`);
+      const encoder = new TextEncoder;
+      const htmlBytes = encoder.encode(html);
+      return new Response(htmlBytes, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Content-Length": htmlBytes.length.toString()
+        }
+      });
+    } catch (error) {
+      console.error("String render failed:", error);
+      return this.renderErrorPage(error);
+    }
+  }
+  renderMinimalPage(match, loaderData) {
+    const serializedData = serializeLoaderData2({
+      loaderData,
+      params: match.params
+    });
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>EreoJS App</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script>window.__EREO_DATA__=${serializedData}</script>
+  <script type="module" src="${this.options.clientEntry}"></script>
+</body>
+</html>`;
+    const encoder = new TextEncoder;
+    const htmlBytes = encoder.encode(html);
+    return new Response(htmlBytes, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        "Content-Length": htmlBytes.length.toString()
+      }
+    });
+  }
+  renderErrorPage(error) {
+    const message = error instanceof Error ? error.message : "An error occurred";
+    const stack = this.options.development && error instanceof Error ? error.stack : undefined;
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Error - EreoJS</title>
+  <style>
+    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
+    h1 { color: #dc2626; }
+    pre { background: #1e1e1e; color: #d4d4d4; padding: 1rem; overflow-x: auto; border-radius: 4px; }
+  </style>
+</head>
+<body>
+  <h1>Render Error</h1>
+  <p>${this.escapeHtml(message)}</p>
+  ${stack ? `<pre>${this.escapeHtml(stack)}</pre>` : ""}
+</body>
+</html>`;
+    return new Response(html, {
+      status: 500,
+      headers: {
+        "Content-Type": "text/html; charset=utf-8"
+      }
+    });
+  }
+  buildMeta(module, loaderData, params, url) {
+    if (!module.meta) {
+      return [];
+    }
+    try {
+      return module.meta({
+        data: loaderData,
+        params,
+        location: {
+          pathname: url.pathname,
+          search: url.search,
+          hash: url.hash
+        }
+      });
+    } catch (error) {
+      console.error("Error building meta:", error);
+      return [];
+    }
+  }
+  extractTitle(meta) {
+    for (const descriptor of meta) {
+      if (descriptor.title) {
+        return descriptor.title;
+      }
+    }
+    return;
+  }
+  extractMetaTags(meta) {
+    const tags = [];
+    for (const descriptor of meta) {
+      if (descriptor.name && descriptor.content) {
+        tags.push({ name: descriptor.name, content: descriptor.content });
+      } else if (descriptor.property && descriptor.content) {
+        tags.push({ property: descriptor.property, content: descriptor.content });
+      }
+    }
+    return tags;
+  }
+  escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+  handleError(error, context) {
+    const message = error instanceof Error ? error.message : "Internal Server Error";
+    const stack = error instanceof Error ? error.stack : undefined;
+    console.error("Server error:", error);
+    if (this.options.development) {
+      return new Response(JSON.stringify({
+        error: message,
+        stack: stack?.split(`
+`)
+      }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Internal Server Error", { status: 500 });
+  }
+  async start() {
+    const { port, hostname, tls, websocket } = this.options;
+    const serverOptions = {
+      port,
+      hostname,
+      fetch: (request) => this.handleRequest(request),
+      error: (error) => this.handleError(error, {})
+    };
+    if (tls) {
+      serverOptions.tls = tls;
+    }
+    if (websocket) {
+      serverOptions.websocket = websocket;
+    }
+    this.server = Bun.serve(serverOptions);
+    const protocol = tls ? "https" : "http";
+    console.log(`Server running at ${protocol}://${hostname}:${port}`);
+    return this.server;
+  }
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+  }
+  async reload() {
+    if (this.server) {
+      this.server.reload({
+        fetch: (request) => this.handleRequest(request)
+      });
+    }
+  }
+  getServer() {
+    return this.server;
+  }
+  getInfo() {
+    return {
+      port: this.options.port,
+      hostname: this.options.hostname,
+      development: this.options.development
+    };
+  }
+}
+function createServer(options) {
+  return new BunServer(options);
+}
+async function serve(options) {
+  const server = createServer(options);
+  await server.start();
+  return server;
+}
+export {
+  staticMiddleware,
+  serveStatic,
+  serve,
+  securityHeaders,
+  renderToString,
+  renderToStream,
+  rateLimit,
+  logger,
+  getMimeType,
+  createSuspenseStream,
+  createShell,
+  createServer,
+  createResponse,
+  createMiddlewareChain,
+  cors,
+  compress,
+  MiddlewareChain,
+  BunServer
+};