npm - bosbun - Versions diffs - 0.0.1 - Mend

bosbun 0.0.1

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 (46) hide show

package/README.md +163 -0
package/package.json +56 -0
package/src/cli/add.ts +83 -0
package/src/cli/build.ts +16 -0
package/src/cli/create.ts +54 -0
package/src/cli/dev.ts +14 -0
package/src/cli/feat.ts +80 -0
package/src/cli/index.ts +75 -0
package/src/cli/start.ts +28 -0
package/src/core/build.ts +157 -0
package/src/core/client/App.svelte +147 -0
package/src/core/client/hydrate.ts +78 -0
package/src/core/client/router.svelte.ts +46 -0
package/src/core/cookies.ts +52 -0
package/src/core/cors.ts +60 -0
package/src/core/csrf.ts +65 -0
package/src/core/dev.ts +193 -0
package/src/core/env.ts +135 -0
package/src/core/envCodegen.ts +94 -0
package/src/core/errors.ts +23 -0
package/src/core/hooks.ts +74 -0
package/src/core/html.ts +170 -0
package/src/core/matcher.ts +85 -0
package/src/core/plugin.ts +59 -0
package/src/core/prerender.ts +79 -0
package/src/core/renderer.ts +222 -0
package/src/core/routeFile.ts +88 -0
package/src/core/routeTypes.ts +95 -0
package/src/core/scanner.ts +99 -0
package/src/core/server.ts +320 -0
package/src/core/types.ts +37 -0
package/src/lib/index.ts +19 -0
package/src/lib/utils.ts +24 -0
package/templates/default/.env.example +34 -0
package/templates/default/README.md +102 -0
package/templates/default/package.json +21 -0
package/templates/default/public/.gitkeep +0 -0
package/templates/default/src/app.css +132 -0
package/templates/default/src/app.d.ts +7 -0
package/templates/default/src/lib/.gitkeep +0 -0
package/templates/default/src/routes/+error.svelte +18 -0
package/templates/default/src/routes/+layout.svelte +6 -0
package/templates/default/src/routes/+page.svelte +36 -0
package/templates/default/src/routes/about/+page.server.ts +1 -0
package/templates/default/src/routes/about/+page.svelte +8 -0
package/templates/default/tsconfig.json +22 -0

package/src/core/html.ts ADDED Viewed

@@ -0,0 +1,170 @@
+import { existsSync, readFileSync } from "fs";
+// ─── Dist Manifest ───────────────────────────────────────
+// Maps hashed filenames → script/link tags.
+// Cached at startup; server restarts on rebuild in dev anyway.
+export const distManifest: { js: string[]; css: string[]; entry: string } = (() => {
+    const p = "./dist/manifest.json";
+    return existsSync(p)
+        ? JSON.parse(readFileSync(p, "utf-8"))
+        : { js: [], css: [], entry: "hydrate.js" };
+})();
+export const isDev = process.env.NODE_ENV !== "production";
+// ─── Safe JSON Serialization ──────────────────────────────
+/** Escapes JSON for safe embedding inside <script> tags. Prevents XSS via </script> injection. */
+export function safeJsonStringify(data: unknown): string {
+    const map: Record<string, string> = {
+        "<": "\\u003c",
+        ">": "\\u003e",
+        "&": "\\u0026",
+        "\u2028": "\\u2028",
+        "\u2029": "\\u2029",
+    };
+    return JSON.stringify(data).replace(/[<>&\u2028\u2029]/g, c => map[c]);
+}
+// ─── Public Env Injection ─────────────────────────────────
+/**
+ * Collect PUBLIC_* (non-static) vars from process.env that were declared in .bunia/env.server.ts.
+ * We read the generated server env module to know which keys to expose.
+ * Falls back to an empty object if the module hasn't been generated yet (e.g., dev before first build).
+ */
+function getPublicDynamicEnv(): Record<string, string> {
+    // Read keys from .bunia/env.server.ts declarations of PUBLIC_* (non-static) vars
+    // by inspecting process.env keys that start with PUBLIC_ but not PUBLIC_STATIC_.
+    // We only expose keys that came from .env files — tracked in process.env via loadEnv.
+    // At runtime the server module exports are inlined; we collect from process.env here.
+    const result: Record<string, string> = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (key.startsWith("PUBLIC_") && !key.startsWith("PUBLIC_STATIC_") && value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+// ─── HTML Builder ─────────────────────────────────────────
+export function buildHtml(
+    body: string,
+    head: string,
+    pageData: any,
+    layoutData: any[],
+    csr = true,
+): string {
+    const cacheBust = isDev ? `?v=${Date.now()}` : "";
+    const cssLinks = (distManifest.css ?? [])
+        .map((f: string) => `<link rel="stylesheet" href="/dist/client/${f}">`)
+        .join("\n  ");
+    const fallbackTitle = head.includes("<title>") ? "" : "<title>Bunia App</title>";
+    const publicEnv = getPublicDynamicEnv();
+    const envScript = Object.keys(publicEnv).length > 0
+        ? `\n  <script>window.__BUNIA_ENV__=${safeJsonStringify(publicEnv)};</script>`
+        : "";
+    const scripts = csr
+        ? `${envScript}\n  <script>window.__BUNIA_PAGE_DATA__=${safeJsonStringify(pageData)};window.__BUNIA_LAYOUT_DATA__=${safeJsonStringify(layoutData)};</script>\n  <script type="module" src="/dist/client/${distManifest.entry}${cacheBust}"></script>`
+        : isDev
+            ? `\n  <script>!function r(){var e=new EventSource("/__bunia/sse");e.addEventListener("reload",()=>location.reload());e.onopen=()=>r._ok||(r._ok=1);e.onerror=()=>{e.close();setTimeout(r,2000)}}()</script>`
+            : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  ${fallbackTitle}
+  <link rel="icon" href="data:,">
+  ${head}
+  ${cssLinks}
+  <link rel="stylesheet" href="/bunia-tw.css${cacheBust}">
+</head>
+<body>
+  <div id="app">${body}</div>${scripts}
+</body>
+</html>`;
+}
+// ─── Streaming HTML Helpers ──────────────────────────────
+let _shell: string | null = null;
+export function buildHtmlShell(): string {
+    if (_shell) return _shell;
+    const cacheBust = isDev ? `?v=${Date.now()}` : "";
+    const cssLinks = (distManifest.css ?? [])
+        .map((f: string) => `<link rel="stylesheet" href="/dist/client/${f}">`)
+        .join("\n  ");
+    _shell = `<!DOCTYPE html>\n<html lang="en">\n<head>\n` +
+        `  <meta charset="UTF-8">\n` +
+        `  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n` +
+        `  <link rel="icon" href="data:,">\n` +
+        `  ${cssLinks}\n` +
+        `  <link rel="stylesheet" href="/bunia-tw.css${cacheBust}">\n` +
+        `  <link rel="modulepreload" href="/dist/client/${distManifest.entry}${cacheBust}">\n` +
+        `</head>\n<body>\n` +
+        `<div id="__bs__"><style>` +
+        `:root{--bunia-loading-color:#f73b27}` +
+        `#__bs__{position:fixed;inset:0;display:flex;align-items:center;justify-content:center}` +
+        `#__bs__ i{width:32px;height:32px;border:3px solid #e5e7eb;border-top-color:var(--bunia-loading-color);` +
+        `border-radius:50%;animation:__bs__ .8s linear infinite}` +
+        `@keyframes __bs__{to{transform:rotate(360deg)}}</style><i></i></div>`;
+    return _shell;
+}
+export function buildHtmlTail(
+    body: string,
+    head: string,
+    pageData: any,
+    layoutData: any[],
+    csr: boolean,
+): string {
+    const cacheBust = isDev ? `?v=${Date.now()}` : "";
+    let out = `<script>document.getElementById('__bs__').remove()</script>`;
+    out += `\n<div id="app">${body}</div>`;
+    if (head) out += `\n<script>document.head.innerHTML+=${safeJsonStringify(head)}</script>`;
+    if (csr) {
+        const publicEnv = getPublicDynamicEnv();
+        if (Object.keys(publicEnv).length > 0) {
+            out += `\n<script>window.__BUNIA_ENV__=${safeJsonStringify(publicEnv)};</script>`;
+        }
+        out += `\n<script>window.__BUNIA_PAGE_DATA__=${safeJsonStringify(pageData)};` +
+               `window.__BUNIA_LAYOUT_DATA__=${safeJsonStringify(layoutData)};</script>`;
+        out += `\n<script type="module" src="/dist/client/${distManifest.entry}${cacheBust}"></script>`;
+    } else if (isDev) {
+        out += `\n<script>!function r(){var e=new EventSource("/__bunia/sse");e.addEventListener("reload",()=>location.reload());e.onopen=()=>r._ok||(r._ok=1);e.onerror=()=>{e.close();setTimeout(r,2000)}}()</script>`;
+    }
+    out += `\n</body>\n</html>`;
+    return out;
+}
+// ─── Gzip Compression ────────────────────────────────────
+export function compress(body: string, contentType: string, req: Request, status = 200): Response {
+    const headers: Record<string, string> = { "Content-Type": contentType, "Vary": "Accept-Encoding" };
+    const accept = req.headers.get("accept-encoding") ?? "";
+    // Skip compression in dev — the dev proxy's fetch() auto-decompresses gzip
+    // responses but keeps the Content-Encoding header, causing ERR_CONTENT_DECODING_FAILED.
+    if (!isDev && body.length > 1024 && accept.includes("gzip")) {
+        return new Response(Bun.gzipSync(body), { status, headers: { ...headers, "Content-Encoding": "gzip" } });
+    }
+    return new Response(body, { status, headers });
+}
+// ─── Static File Detection ────────────────────────────────
+export const STATIC_EXTS = new Set([".ico", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".css", ".js", ".woff", ".woff2", ".ttf"]);
+export function isStaticPath(path: string): boolean {
+    if (path.startsWith("/dist/") || path.startsWith("/__bunia/")) return true;
+    const dot = path.lastIndexOf(".");
+    return dot !== -1 && STATIC_EXTS.has(path.slice(dot));
+}

package/src/core/matcher.ts ADDED Viewed

@@ -0,0 +1,85 @@
+import type { RouteMatch } from "./types.ts";
+// ─── Route Matcher ───────────────────────────────────────
+// Single shared matcher used by both client and server at runtime.
+// Replaces the old code-generated match functions.
+//
+// Matching priority (same as old / SvelteKit):
+//   1. Exact match        — "/about" === "/about"
+//   2. Dynamic match      — "/blog/[slug]" matches "/blog/hello"
+//   3. Catch-all match    — "/[...rest]" matches anything
+/**
+ * Match a URL pathname against a single route pattern.
+ * Returns extracted params if matched, null otherwise.
+ */
+export function matchPattern(
+    pattern: string,
+    pathname: string,
+): Record<string, string> | null {
+    // Exact match
+    if (pattern === pathname) return {};
+    // Catch-all pattern: /[...name] or /prefix/[...name]
+    const catchallMatch = pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
+    if (catchallMatch) {
+        const prefix = catchallMatch[1] || "";
+        const paramName = catchallMatch[2]!;
+        if (prefix === "" || pathname.startsWith(prefix + "/") || pathname === prefix) {
+            const rest = prefix ? pathname.slice(prefix.length + 1) : pathname.slice(1);
+            return { [paramName]: rest };
+        }
+        return null;
+    }
+    // Dynamic segments: must have same segment count
+    if (!pattern.includes("[")) return null;
+    const patParts = pattern.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+    if (patParts.length !== pathParts.length) return null;
+    const params: Record<string, string> = {};
+    for (let i = 0; i < patParts.length; i++) {
+        const pp = patParts[i]!;
+        const val = pathParts[i]!;
+        if (pp.startsWith("[") && pp.endsWith("]")) {
+            params[pp.slice(1, -1)] = val;
+        } else if (pp !== val) {
+            return null;
+        }
+    }
+    return params;
+}
+/**
+ * Find the first matching route from a list.
+ * Uses 3-pass priority: exact → dynamic → catch-all.
+ */
+export function findMatch<T extends { pattern: string }>(
+    routes: T[],
+    pathname: string,
+): RouteMatch<T> | null {
+    // Pass 1 — exact
+    for (const route of routes) {
+        if (route.pattern === pathname) {
+            return { route, params: {} };
+        }
+    }
+    // Pass 2 — dynamic segments (no catch-all)
+    for (const route of routes) {
+        if (!route.pattern.includes("[") || route.pattern.includes("[...")) continue;
+        const params = matchPattern(route.pattern, pathname);
+        if (params !== null) return { route, params };
+    }
+    // Pass 3 — catch-all
+    for (const route of routes) {
+        if (!route.pattern.includes("[...")) continue;
+        const params = matchPattern(route.pattern, pathname);
+        if (params !== null) return { route, params };
+    }
+    return null;
+}

package/src/core/plugin.ts ADDED Viewed

@@ -0,0 +1,59 @@
+import { join } from "path";
+// ─── Bun Build Plugin ─────────────────────────────────────
+// Resolves:
+//   bunia:routes  → .bunia/routes.ts  (generated route map)
+//   bunia:env     → .bunia/env.server.ts (bun) or .bunia/env.client.ts (browser)
+//   $lib/*        → src/lib/*         (user library alias)
+export function makeBuniaPlugin(target: "browser" | "bun" = "bun") {
+    return {
+        name: "bunia-resolver",
+        setup(build: import("bun").PluginBuilder) {
+            // bunia:routes → .bunia/routes.ts
+            build.onResolve({ filter: /^bunia:routes$/ }, () => ({
+                path: join(process.cwd(), ".bunia", "routes.ts"),
+            }));
+            // bunia:env → .bunia/env.client.ts (browser) or .bunia/env.server.ts (bun)
+            build.onResolve({ filter: /^bunia:env$/ }, () => ({
+                path: join(
+                    process.cwd(),
+                    ".bunia",
+                    target === "browser" ? "env.client.ts" : "env.server.ts",
+                ),
+            }));
+            // $lib/* → src/lib/* with extension probing
+            build.onResolve({ filter: /^\$lib\// }, async (args) => {
+                const rel = args.path.slice(5); // remove "$lib/"
+                const base = join(process.cwd(), "src", "lib", rel);
+                return { path: await resolveWithExts(base) };
+            });
+            // "tailwindcss" inside app.css is a Tailwind CLI directive —
+            // it's already compiled to public/bunia-tw.css by the CLI step.
+            // Return an empty CSS module so Bun's CSS bundler doesn't choke on it.
+            build.onResolve({ filter: /^tailwindcss$/ }, () => ({
+                path: "tailwindcss",
+                namespace: "bunia-empty-css",
+            }));
+            build.onLoad({ filter: /.*/, namespace: "bunia-empty-css" }, () => ({
+                contents: "",
+                loader: "css",
+            }));
+        },
+    };
+}
+async function resolveWithExts(base: string): Promise<string> {
+    if (await Bun.file(base).exists()) return base;
+    for (const ext of [".ts", ".svelte", ".js"]) {
+        if (await Bun.file(base + ext).exists()) return base + ext;
+    }
+    for (const idx of ["index.ts", "index.svelte", "index.js"]) {
+        const p = join(base, idx);
+        if (await Bun.file(p).exists()) return p;
+    }
+    return base;
+}

package/src/core/prerender.ts ADDED Viewed

@@ -0,0 +1,79 @@
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import type { RouteManifest } from "./types.ts";
+const CORE_DIR = import.meta.dir;
+const BUNIA_NODE_MODULES = join(CORE_DIR, "..", "..", "node_modules");
+// ─── Prerendering ─────────────────────────────────────────
+async function detectPrerenderRoutes(manifest: RouteManifest): Promise<string[]> {
+    const paths: string[] = [];
+    for (const route of manifest.pages) {
+        if (!route.pageServer) continue;
+        if (route.pattern.includes("[")) {
+            // TODO: Support dynamic routes by reading export const entries() and calling it to get param values
+            // Then prerender each route variant: /blog/slug1, /blog/slug2, etc.
+            continue;
+        }
+        const content = await Bun.file(join("src", "routes", route.pageServer)).text();
+        if (/export\s+const\s+prerender\s*=\s*true/.test(content)) {
+            paths.push(route.pattern);
+        }
+    }
+    return paths;
+}
+export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<void> {
+    const paths = await detectPrerenderRoutes(manifest);
+    if (paths.length === 0) return;
+    console.log(`\n🖨️  Prerendering ${paths.length} route(s)...`);
+    const port = 13572;
+    const child = Bun.spawn(
+        ["bun", "run", "./dist/server/index.js"],
+        {
+            env: { ...process.env, NODE_ENV: "production", PORT: String(port), NODE_PATH: BUNIA_NODE_MODULES },
+            stdout: "ignore",
+            stderr: "ignore",
+        },
+    );
+    // Poll /_health until ready (max 10s)
+    const base = `http://localhost:${port}`;
+    let ready = false;
+    for (let i = 0; i < 50; i++) {
+        await Bun.sleep(200);
+        try {
+            const res = await fetch(`${base}/_health`);
+            if (res.ok) { ready = true; break; }
+        } catch { /* not ready yet */ }
+    }
+    if (!ready) {
+        child.kill();
+        console.error("❌ Prerender server failed to start");
+        return;
+    }
+    mkdirSync("./dist/prerendered", { recursive: true });
+    for (const routePath of paths) {
+        try {
+            const res = await fetch(`${base}${routePath}`);
+            const html = await res.text();
+            const outPath = routePath === "/"
+                ? "./dist/prerendered/index.html"
+                : `./dist/prerendered${routePath}/index.html`;
+            mkdirSync(outPath.substring(0, outPath.lastIndexOf("/")), { recursive: true });
+            writeFileSync(outPath, html);
+            console.log(`   ✅ ${routePath} → ${outPath}`);
+        } catch (err) {
+            console.error(`   ❌ Failed to prerender ${routePath}:`, err);
+        }
+    }
+    child.kill();
+    console.log("✅ Prerendering complete");
+}

package/src/core/renderer.ts ADDED Viewed

@@ -0,0 +1,222 @@
+import { render } from "svelte/server";
+import { findMatch } from "./matcher.ts";
+import { serverRoutes, errorPage } from "bunia:routes";
+import type { Cookies } from "./hooks.ts";
+import { HttpError, Redirect } from "./errors.ts";
+import App from "./client/App.svelte";
+import { buildHtml, buildHtmlShell, buildHtmlTail, compress, safeJsonStringify, isDev } from "./html.ts";
+// ─── Session-Aware Fetch ─────────────────────────────────
+// Passed to load() functions so they can call internal APIs
+// with the current user's cookies automatically forwarded.
+function makeFetch(req: Request, url: URL) {
+    const cookie = req.headers.get("cookie") ?? "";
+    const origin = url.origin;
+    return (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+        const resolved =
+            typeof input === "string" && input.startsWith("/")
+                ? `${origin}${input}`
+                : input;
+        const headers = new Headers(init?.headers);
+        if (cookie && !headers.has("cookie")) headers.set("cookie", cookie);
+        return globalThis.fetch(resolved, { ...init, headers });
+    };
+}
+// ─── Route Data Loader ───────────────────────────────────
+// Runs layout + page server loaders for a given URL.
+// Used by both SSR and the /__bunia/data JSON endpoint.
+export async function loadRouteData(
+    url: URL,
+    locals: Record<string, any>,
+    req: Request,
+    cookies: Cookies,
+) {
+    const match = findMatch(serverRoutes, url.pathname);
+    if (!match) return null;
+    const { route, params } = match;
+    const fetch = makeFetch(req, url);
+    const layoutData: Record<string, any>[] = [];
+    // Run layout server loaders root → leaf, each gets parent() data
+    for (const ls of route.layoutServers) {
+        try {
+            const mod = await ls.loader();
+            if (typeof mod.load === "function") {
+                const parent = async () => {
+                    const merged: Record<string, any> = {};
+                    for (let d = 0; d < ls.depth; d++) Object.assign(merged, layoutData[d] ?? {});
+                    return merged;
+                };
+                layoutData[ls.depth] = (await mod.load({ params, url, locals, cookies, parent, fetch })) ?? {};
+            }
+        } catch (err) {
+            if (err instanceof HttpError || err instanceof Redirect) throw err;
+            if (isDev) console.error("Layout server load error:", err);
+            else console.error("Layout server load error:", (err as Error).message ?? err);
+        }
+    }
+    // Run page server loader
+    let pageData: Record<string, any> = {};
+    let csr = true;
+    if (route.pageServer) {
+        try {
+            const mod = await route.pageServer();
+            if (mod.csr === false) csr = false;
+            if (typeof mod.load === "function") {
+                const parent = async () => {
+                    const merged: Record<string, any> = {};
+                    for (const d of layoutData) if (d) Object.assign(merged, d);
+                    return merged;
+                };
+                pageData = (await mod.load({ params, url, locals, cookies, parent, fetch })) ?? {};
+            }
+        } catch (err) {
+            if (err instanceof HttpError || err instanceof Redirect) throw err;
+            if (isDev) console.error("Page server load error:", err);
+            else console.error("Page server load error:", (err as Error).message ?? err);
+        }
+    }
+    return { pageData: { ...pageData, params }, layoutData, csr };
+}
+// ─── SSR Renderer ────────────────────────────────────────
+export async function renderSSR(url: URL, locals: Record<string, any>, req: Request, cookies: Cookies) {
+    const match = findMatch(serverRoutes, url.pathname);
+    if (!match) return null;
+    const { route } = match;
+    // Kick off component imports in parallel with data loading
+    const pageModPromise = route.pageModule();
+    const layoutModsPromise = Promise.all(route.layoutModules.map((l: () => Promise<any>) => l()));
+    const data = await loadRouteData(url, locals, req, cookies);
+    if (!data) return null;
+    const [pageMod, layoutMods] = await Promise.all([pageModPromise, layoutModsPromise]);
+    const { body, head } = render(App, {
+        props: {
+            ssrMode: true,
+            ssrPageComponent: pageMod.default,
+            ssrLayoutComponents: layoutMods.map((m: any) => m.default),
+            ssrPageData: data.pageData,
+            ssrLayoutData: data.layoutData,
+        },
+    });
+    return { body, head, pageData: data.pageData, layoutData: data.layoutData, csr: data.csr };
+}
+// ─── Streaming SSR Renderer ──────────────────────────────
+export function renderSSRStream(
+    url: URL,
+    locals: Record<string, any>,
+    req: Request,
+    cookies: Cookies,
+): Response | null {
+    const match = findMatch(serverRoutes, url.pathname);
+    if (!match) return null;
+    const { route } = match;
+    const enc = new TextEncoder();
+    // Kick off imports immediately (parallel with data loading)
+    const pageModPromise = route.pageModule();
+    const layoutModsPromise = Promise.all(route.layoutModules.map((l: () => Promise<any>) => l()));
+    const stream = new ReadableStream<Uint8Array>({
+        async start(controller) {
+            // Chunk 1: shell (cached at startup)
+            controller.enqueue(enc.encode(buildHtmlShell()));
+            try {
+                const [data, pageMod, layoutMods] = await Promise.all([
+                    loadRouteData(url, locals, req, cookies),
+                    pageModPromise,
+                    layoutModsPromise,
+                ]);
+                if (!data) {
+                    controller.enqueue(enc.encode(`</body></html>`));
+                    controller.close();
+                    return;
+                }
+                const { body, head } = render(App, {
+                    props: {
+                        ssrMode: true,
+                        ssrPageComponent: pageMod.default,
+                        ssrLayoutComponents: layoutMods.map((m: any) => m.default),
+                        ssrPageData: data.pageData,
+                        ssrLayoutData: data.layoutData,
+                    },
+                });
+                // Chunk 2: content
+                controller.enqueue(enc.encode(buildHtmlTail(body, head, data.pageData, data.layoutData, data.csr)));
+                controller.close();
+            } catch (err) {
+                if (err instanceof Redirect) {
+                    controller.enqueue(enc.encode(
+                        `<script>location.replace(${safeJsonStringify(err.location)})</script></body></html>`
+                    ));
+                    controller.close();
+                    return;
+                }
+                if (err instanceof HttpError) {
+                    controller.enqueue(enc.encode(
+                        `<script>location.replace("/__bunia/error?status=${err.status}&message=${encodeURIComponent(err.message)}")</script></body></html>`
+                    ));
+                    controller.close();
+                    return;
+                }
+                if (isDev) console.error("SSR stream error:", err);
+                else console.error("SSR stream error:", (err as Error).message ?? err);
+                controller.enqueue(enc.encode(`<p>Internal Server Error</p></body></html>`));
+                controller.close();
+            }
+        },
+    });
+    return new Response(stream, {
+        headers: { "Content-Type": "text/html; charset=utf-8" },
+    });
+}
+// ─── Error Page Renderer ──────────────────────────────────
+export async function renderErrorPage(status: number, message: string, url: URL, req: Request): Promise<Response> {
+    if (errorPage) {
+        try {
+            const mod = await errorPage();
+            const { body, head } = render(App, {
+                props: {
+                    ssrMode: true,
+                    ssrPageComponent: mod.default,
+                    ssrLayoutComponents: [],
+                    ssrPageData: { status, message },
+                    ssrLayoutData: [],
+                },
+            });
+            const html = buildHtml(body, head, { status, message }, [], false);
+            return compress(html, "text/html; charset=utf-8", req, status);
+        } catch (err) {
+            if (isDev) console.error("Error page render failed:", err);
+            else console.error("Error page render failed:", (err as Error).message ?? err);
+        }
+    }
+    return new Response(message, { status, headers: { "Content-Type": "text/plain; charset=utf-8" } });
+}