bosia 0.1.0 → 0.1.2-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosia",
-  "version": "0.1.0",
+  "version": "0.1.2-rc.1",
   "type": "module",
   "description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing inspired by SvelteKit. No Node.js, no Vite, no adapters.",
   "keywords": [
@@ -44,6 +44,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "@clack/prompts": "^1.1.0",
     "@tailwindcss/cli": "^4.2.1",
     "bun-plugin-svelte": "^0.0.6",
     "clsx": "^2.1.1",

package/src/cli/add.ts

@@ -1,12 +1,17 @@
 import { join, dirname } from "path";
-import { mkdirSync, writeFileSync } from "fs";
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from "fs";
 import { spawn } from "bun";
+import * as p from "@clack/prompts";
 
 // ─── bosia add <component> ────────────────────────────────
-// Fetches a component from the GitHub registry and copies it
-// into the user's src/lib/components/ui/<name>/ directory.
+// Fetches a component from the GitHub registry (or local registry
+// with --local) and copies it into src/lib/components/<path>/.
+//
+// Path-based names:
+//   bosia add button       → src/lib/components/ui/button/
+//   bosia add shop/cart    → src/lib/components/shop/cart/
 
-const REGISTRY_BASE = "https://raw.githubusercontent.com/bosapi/bosia/main/registry";
+const REMOTE_BASE = "https://raw.githubusercontent.com/bosapi/bosia/main/registry";
 
 interface ComponentMeta {
     name: string;
@@ -19,37 +24,71 @@ interface ComponentMeta {
 // Track already-installed components within a session to avoid re-running deps
 const installed = new Set<string>();
 
-export async function runAdd(name: string | undefined) {
+// Resolved once in runAdd, used by addComponent
+let registryRoot: string | null = null;
+
+export async function runAdd(name: string | undefined, flags: string[] = []) {
     if (!name) {
-        console.error("❌ Please provide a component name.\n   Usage: bosia add <component>");
+        console.error("❌ Please provide a component name.\n   Usage: bosia add <component> [--local]");
         process.exit(1);
     }
+
+    if (flags.includes("--local")) {
+        // Walk up from this file to find the repo's registry/ directory
+        registryRoot = resolveLocalRegistry();
+        console.log(`⬡ Using local registry: ${registryRoot}\n`);
+    }
+
+    ensureUtils();
     await addComponent(name, true);
 }
 
+/**
+ * Resolve the destination path for a component.
+ * - "button"     → "ui/button"     (default ui/ prefix)
+ * - "shop/cart"  → "shop/cart"     (explicit path used as-is)
+ */
+function resolveDestPath(name: string): string {
+    return name.includes("/") ? name : `ui/${name}`;
+}
+
 export async function addComponent(name: string, root = false) {
-    if (installed.has(name)) return;
-    installed.add(name);
+    // Resolve the full path (e.g. "button" → "ui/button", "shop/cart" stays "shop/cart")
+    const fullPath = resolveDestPath(name);
+
+    if (installed.has(fullPath)) return;
+    installed.add(fullPath);
 
     console.log(root ? `⬡ Installing component: ${name}\n` : `   📦 Dependency: ${name}`);
 
-    const meta = await fetchJSON<ComponentMeta>(`${REGISTRY_BASE}/components/${name}/meta.json`);
+    const meta = await readMeta(fullPath);
 
     // Install component dependencies first (recursive)
     for (const dep of meta.dependencies) {
         await addComponent(dep, false);
     }
 
-    // Download component files into src/lib/components/ui/<name>/
-    const destDir = join(process.cwd(), "src", "lib", "components", "ui", name);
+    // Check if component already exists
+    const destDir = join(process.cwd(), "src", "lib", "components", fullPath);
+    if (existsSync(destDir)) {
+        const replace = await p.confirm({
+            message: `Component "${name}" already exists at src/lib/components/${fullPath}/. Replace it?`,
+        });
+        if (p.isCancel(replace) || !replace) {
+            console.log(`   ⏭️  Skipped ${name}`);
+            return;
+        }
+    }
+
+    // Download/copy component files into src/lib/components/<fullPath>/
     mkdirSync(destDir, { recursive: true });
 
     for (const file of meta.files) {
-        const content = await fetchText(`${REGISTRY_BASE}/components/${name}/${file}`);
+        const content = await readFile(fullPath, file);
         const dest = join(destDir, file);
         mkdirSync(dirname(dest), { recursive: true });
         writeFileSync(dest, content, "utf-8");
-        console.log(`   ✍️  src/lib/components/ui/${name}/${file}`);
+        console.log(`   ✍️  src/lib/components/${fullPath}/${file}`);
     }
 
     // Install npm dependencies
@@ -67,7 +106,64 @@ export async function addComponent(name: string, root = false) {
         }
     }
 
-    if (root) console.log(`\n✅ ${name} installed at src/lib/components/ui/${name}/`);
+    if (root) console.log(`\n✅ ${name} installed at src/lib/components/${fullPath}/`);
+}
+
+// ─── Ensure $lib/utils.ts exists ─────────────────────────────
+
+const UTILS_CONTENT = `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs));
+}
+`;
+
+function ensureUtils() {
+    const utilsPath = join(process.cwd(), "src", "lib", "utils.ts");
+    if (!existsSync(utilsPath)) {
+        mkdirSync(dirname(utilsPath), { recursive: true });
+        writeFileSync(utilsPath, UTILS_CONTENT, "utf-8");
+        console.log("   ✍️  src/lib/utils.ts (cn utility)\n");
+    }
+}
+
+// ─── Registry resolvers ──────────────────────────────────────
+
+function resolveLocalRegistry(): string {
+    // Walk up from this file's directory to find registry/
+    let dir = dirname(new URL(import.meta.url).pathname);
+    for (let i = 0; i < 10; i++) {
+        const candidate = join(dir, "registry");
+        if (existsSync(join(candidate, "index.json"))) return candidate;
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    console.error("❌ Could not find local registry/ directory.");
+    process.exit(1);
+}
+
+async function readMeta(name: string): Promise<ComponentMeta> {
+    if (registryRoot) {
+        const path = join(registryRoot, "components", name, "meta.json");
+        if (!existsSync(path)) {
+            throw new Error(`Component "${name}" not found in local registry`);
+        }
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    return fetchJSON<ComponentMeta>(`${REMOTE_BASE}/components/${name}/meta.json`);
+}
+
+async function readFile(name: string, file: string): Promise<string> {
+    if (registryRoot) {
+        const path = join(registryRoot, "components", name, file);
+        if (!existsSync(path)) {
+            throw new Error(`File "${file}" not found for component "${name}" in local registry`);
+        }
+        return readFileSync(path, "utf-8");
+    }
+    return fetchText(`${REMOTE_BASE}/components/${name}/${file}`);
 }
 
 async function fetchJSON<T>(url: string): Promise<T> {

package/src/cli/create.ts

@@ -1,7 +1,7 @@
 import { resolve, join, basename } from "path";
-import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { spawn } from "bun";
-import * as readline from "readline";
+import * as p from "@clack/prompts";
 
 // ─── bosia create <name> [--template <name>] ──────────────
 
@@ -79,26 +79,21 @@ async function promptTemplate(): Promise<string> {
 
     if (templates.length === 1) return templates[0];
 
-    console.log("\n? Which template?\n");
-    templates.forEach((t, i) => {
-        const desc = TEMPLATE_DESCRIPTIONS[t] ?? "";
-        const marker = i === 0 ? "❯" : " ";
-        console.log(`  ${marker} ${t}${desc ? `  — ${desc}` : ""}`);
+    const selected = await p.select({
+        message: "Which template?",
+        options: templates.map((t) => ({
+            value: t,
+            label: t,
+            hint: TEMPLATE_DESCRIPTIONS[t],
+        })),
     });
-    console.log();
 
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
+    if (p.isCancel(selected)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+    }
 
-    return new Promise<string>((resolvePromise) => {
-        rl.question(`  Template name (default): `, (answer) => {
-            rl.close();
-            const trimmed = answer.trim();
-            resolvePromise(trimmed || "default");
-        });
-    });
+    return selected as string;
 }
 
 function copyDir(src: string, dest: string, projectName: string) {

package/src/cli/index.ts

@@ -33,7 +33,9 @@ async function main() {
         }
         case "add": {
             const { runAdd } = await import("./add.ts");
-            await runAdd(args[0]);
+            const addName = args.find((a) => !a.startsWith("--"));
+            const addFlags = args.filter((a) => a.startsWith("--"));
+            await runAdd(addName, addFlags);
             break;
         }
         case "feat": {
@@ -62,7 +64,8 @@ Examples:
   bosia dev
   bosia build
   bosia start
-  bosia add button
+  bosia add button              → src/lib/components/ui/button/
+  bosia add shop/cart           → src/lib/components/shop/cart/
   bosia feat login
 `);
             break;

package/src/core/build.ts

@@ -7,7 +7,7 @@ import { scanRoutes } from "./scanner.ts";
 import { generateRoutesFile } from "./routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "./routeTypes.ts";
 import { makeBosiaPlugin } from "./plugin.ts";
-import { prerenderStaticRoutes } from "./prerender.ts";
+import { prerenderStaticRoutes, generateStaticSite } from "./prerender.ts";
 import { loadEnv, classifyEnvVars } from "./env.ts";
 import { generateEnvModules } from "./envCodegen.ts";
 import { BOSIA_NODE_PATH, resolveBosiaBin } from "./paths.ts";
@@ -144,7 +144,7 @@ mkdirSync("./dist", { recursive: true });
 const distManifest = {
     js: jsFiles,
     css: cssFiles,
-    entry: jsFiles.find(f => f.startsWith("hydrate")) ?? jsFiles[0] ?? "hydrate.js",
+    entry: jsFiles.find(f => f === "hydrate.js") ?? jsFiles.find(f => f.startsWith("hydrate")) ?? "hydrate.js",
     serverEntry,
 };
 writeFileSync("./dist/manifest.json", JSON.stringify(distManifest, null, 2));
@@ -154,4 +154,7 @@ console.log(`✅ Server entry:  dist/server/${serverEntry}`);
 // 9. Prerender static routes
 await prerenderStaticRoutes(manifest);
 
+// 10. Generate static site output (HTML + client assets + public → dist/static/)
+generateStaticSite();
+
 console.log("\n🎉 Build complete!");

package/src/core/client/App.svelte

@@ -84,6 +84,20 @@
       pageData = result?.pageData ?? {};
       layoutData = result?.layoutData ?? [];
       routeParams = result?.pageData?.params ?? match.params;
+
+      // Update document title and meta description from server metadata
+      if (result?.metadata) {
+        if (result.metadata.title) document.title = result.metadata.title;
+        if (result.metadata.description) {
+          let meta = document.querySelector('meta[name="description"]') as HTMLMetaElement | null;
+          if (!meta) {
+            meta = document.createElement("meta");
+            meta.name = "description";
+            document.head.appendChild(meta);
+          }
+          meta.content = result.metadata.description;
+        }
+      }
     });
 
     return () => { cancelled = true; };

package/src/core/html.ts

@@ -96,6 +96,7 @@ export function buildHtml(
   ${head}
   ${cssLinks}
   <link rel="stylesheet" href="/bosia-tw.css${cacheBust}">
+  <script>try{var t=localStorage.getItem('theme');if(t==='dark'||(!t&&window.matchMedia('(prefers-color-scheme: dark)').matches))document.documentElement.classList.add('dark');else document.documentElement.classList.remove('dark')}catch(_){}</script>
 </head>
 <body data-bosia-preload="hover">
   <div id="app">${body}</div>${scripts}
@@ -121,6 +122,7 @@ export function buildHtmlShellOpen(): string {
         `  <link rel="icon" type="image/svg+xml" href="/favicon.svg">\n` +
         `  ${cssLinks}\n` +
         `  <link rel="stylesheet" href="/bosia-tw.css${cacheBust}">\n` +
+        `  <script>try{var t=localStorage.getItem('theme');if(t==='dark'||(!t&&window.matchMedia('(prefers-color-scheme: dark)').matches))document.documentElement.classList.add('dark');else document.documentElement.classList.remove('dark')}catch(_){}</script>\n` +
         `  <link rel="modulepreload" href="/dist/client/${distManifest.entry}${cacheBust}">`;
     return _shellOpen;
 }

package/src/core/matcher.ts

@@ -32,6 +32,9 @@ function matchPattern(
         const paramName = catchallMatch[2]!;
         if (prefix === "" || pathname.startsWith(prefix + "/") || pathname === prefix) {
             const rest = prefix ? pathname.slice(prefix.length + 1) : pathname.slice(1);
+            // Don't let a root catch-all match "/" with an empty slug.
+            // If you want the catch-all to also serve "/", add an explicit +page.svelte at the root.
+            if (!prefix && rest === "") return null;
             return { [paramName]: rest };
         }
         return null;

package/src/core/prerender.ts

@@ -1,4 +1,4 @@
-import { writeFileSync, mkdirSync } from "fs";
+import { writeFileSync, mkdirSync, cpSync, existsSync } from "fs";
 import { join } from "path";
 import type { RouteManifest } from "./types.ts";
 
@@ -14,13 +14,33 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<string[]>
     const paths: string[] = [];
     for (const route of manifest.pages) {
         if (!route.pageServer) continue;
+        const filePath = join("src", "routes", route.pageServer);
+        const content = await Bun.file(filePath).text();
+        if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) 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)) {
+            // Dynamic route — import module and call entries() to get param values
+            try {
+                const mod = await import(join(process.cwd(), filePath));
+                if (typeof mod.entries !== "function") {
+                    console.warn(`   ⚠️  ${route.pattern} has prerender=true but no entries() export — skipped`);
+                    continue;
+                }
+                const entryList: Record<string, string>[] = await mod.entries();
+                for (const entry of entryList) {
+                    let resolved = route.pattern;
+                    for (const [key, value] of Object.entries(entry)) {
+                        // [...slug] → value (rest param)
+                        resolved = resolved.replace(`[...${key}]`, value);
+                        // [param] → value
+                        resolved = resolved.replace(`[${key}]`, value);
+                    }
+                    paths.push(resolved);
+                }
+            } catch (err) {
+                console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
+            }
+        } else {
             paths.push(route.pattern);
         }
     }
@@ -84,3 +104,28 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
     child.kill();
     console.log("✅ Prerendering complete");
 }
+
+// ─── Static Site Output ──────────────────────────────────
+
+export function generateStaticSite(): void {
+    if (!existsSync("./dist/prerendered")) {
+        console.log("\n⏭️  No prerendered pages — skipping static site output");
+        return;
+    }
+
+    console.log("\n📦 Generating static site...");
+    mkdirSync("./dist/static", { recursive: true });
+
+    // 1. HTML files from prerendering
+    cpSync("./dist/prerendered", "./dist/static", { recursive: true });
+
+    // 2. Client JS/CSS — preserves /dist/client/... absolute paths used in HTML
+    cpSync("./dist/client", "./dist/static/dist/client", { recursive: true });
+
+    // 3. Public assets (bosia-tw.css, favicon, etc.) — preserves /bosia-tw.css path
+    if (existsSync("./public")) {
+        cpSync("./public", "./dist/static", { recursive: true });
+    }
+
+    console.log("✅ Static site generated: dist/static/");
+}

package/src/core/renderer.ts

@@ -5,7 +5,7 @@ import { serverRoutes, errorPage } from "bosia:routes";
 import type { Cookies } from "./hooks.ts";
 import { HttpError, Redirect } from "./errors.ts";
 import App from "./client/App.svelte";
-import { buildHtml, buildHtmlShellOpen, buildMetadataChunk, buildHtmlTail, compress, safeJsonStringify, isDev } from "./html.ts";
+import { buildHtml, buildHtmlShellOpen, buildMetadataChunk, buildHtmlTail, compress, isDev } from "./html.ts";
 import type { Metadata } from "./hooks.ts";
 
 // ─── Timeout Helpers ─────────────────────────────────────
@@ -92,6 +92,7 @@ export async function loadRouteData(
             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);
+            throw new HttpError(500, "Internal Server Error");
         }
     }
 
@@ -114,6 +115,7 @@ export async function loadRouteData(
             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);
+            throw new HttpError(500, "Internal Server Error");
         }
     }
 
@@ -122,7 +124,7 @@ export async function loadRouteData(
 
 // ─── Metadata Loader ─────────────────────────────────────
 
-async function loadMetadata(
+export async function loadMetadata(
     route: any,
     params: Record<string, string>,
     url: URL,
@@ -174,9 +176,28 @@ export async function renderSSRStream(
         // Continue with null metadata — don't break the page for a metadata failure
     }
 
-    // Kick off imports immediately (parallel with data loading)
-    const pageModPromise = route.pageModule();
-    const layoutModsPromise = Promise.all(route.layoutModules.map((l: () => Promise<any>) => l()));
+    // ── Pre-stream phase: run load() + module imports in parallel before committing to a 200 ──
+    // This ensures HttpError/Redirect from load() can return a proper response before any bytes are sent.
+    const metadataData = metadata?.data ?? null;
+    let data: Awaited<ReturnType<typeof loadRouteData>>;
+    let pageMod: any;
+    let layoutMods: any[];
+
+    try {
+        [data, pageMod, layoutMods] = await Promise.all([
+            loadRouteData(url, locals, req, cookies, metadataData),
+            route.pageModule(),
+            Promise.all(route.layoutModules.map((l: () => Promise<any>) => l())),
+        ]);
+    } catch (err) {
+        if (err instanceof Redirect) return Response.redirect(err.location, err.status);
+        if (err instanceof HttpError) return renderErrorPage(err.status, err.message, url, req);
+        if (isDev) console.error("SSR load error:", err);
+        else console.error("SSR load error:", (err as Error).message ?? err);
+        return renderErrorPage(500, "Internal Server Error", url, req);
+    }
+
+    if (!data) return renderErrorPage(404, "Not Found", url, req);
 
     const enc = new TextEncoder();
 
@@ -189,53 +210,23 @@ export async function renderSSRStream(
             controller.enqueue(enc.encode(buildMetadataChunk(metadata)));
 
             try {
-                // Pass metadata.data to load() so it can reuse fetched data
-                const metadataData = metadata?.data ?? null;
-
-                // Wait for data + component imports
-                const [data, pageMod, layoutMods] = await Promise.all([
-                    loadRouteData(url, locals, req, cookies, metadataData),
-                    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,
+                        ssrPageData: data!.pageData,
+                        ssrLayoutData: data!.layoutData,
                     },
                 });
 
                 // Chunk 3: rendered content
-                controller.enqueue(enc.encode(buildHtmlTail(body, head, data.pageData, data.layoutData, data.csr)));
+                controller.enqueue(enc.encode(buildHtmlTail(body, head, data!.pageData, data!.layoutData, data!.csr)));
                 controller.close();
             } catch (err) {
-                // Head is closed and body is open at this point — HTML structure is valid
-                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("/__bosia/error?status=${err.status}&message="+encodeURIComponent(${safeJsonStringify(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);
+                // Only render() can throw here — data is already loaded successfully
+                if (isDev) console.error("SSR render error:", err);
+                else console.error("SSR render error:", (err as Error).message ?? err);
                 controller.enqueue(enc.encode(`<p>Internal Server Error</p></body></html>`));
                 controller.close();
             }
@@ -294,14 +285,11 @@ export async function renderErrorPage(status: number, message: string, url: URL,
     if (errorPage) {
         try {
             const mod = await errorPage();
-            const { body, head } = render(App, {
-                props: {
-                    ssrMode: true,
-                    ssrPageComponent: mod.default,
-                    ssrLayoutComponents: [],
-                    ssrPageData: { status, message },
-                    ssrLayoutData: [],
-                },
+            // Render the error component directly — NOT through App.svelte.
+            // App.svelte always remaps ssrPageData to a `data` prop, but +error.svelte
+            // expects `error` as a direct prop: `let { error } = $props()`.
+            const { body, head } = render(mod.default, {
+                props: { error: { status, message } },
             });
             const html = buildHtml(body, head, { status, message }, [], false);
             return compress(html, "text/html; charset=utf-8", req, status);

package/src/core/routeFile.ts

@@ -101,7 +101,9 @@ export function generateRoutesFile(manifest: RouteManifest): void {
 
     mkdirSync(".bosia", { recursive: true });
     writeFileSync(".bosia/routes.ts", lines.join("\n"));
-    console.log("✅ Routes generated: .bosia/routes.ts");
+    const pagePatterns = pages.map(p => p.pattern).join(", ") || "(none)";
+    console.log(`✅ Routes generated: .bosia/routes.ts`);
+    console.log(`   Found ${pages.length} page route(s): ${pagePatterns}`);
 }
 
 // Import path from .bosia/routes.ts to src/routes/<routePath>

package/src/core/scanner.ts

@@ -88,6 +88,24 @@ export function scanRoutes(): RouteManifest {
 
     walk("", [], [], []);
 
+    // Warn when a catch-all exists but no exact route covers its prefix.
+    // e.g. "/[...slug]" matches everything EXCEPT "/" (which needs its own +page.svelte).
+    const exactPatterns = new Set(
+        pages.filter(p => !p.pattern.includes("[")).map(p => p.pattern),
+    );
+    for (const p of pages) {
+        const m = p.pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
+        if (m) {
+            const exactEquivalent = m[1] || "/";
+            if (!exactPatterns.has(exactEquivalent)) {
+                console.warn(
+                    `⚠️  No exact route for "${exactEquivalent}" — the catch-all "${p.pattern}" will NOT match it.\n` +
+                    `   Add a +page.svelte at the "${exactEquivalent}" level to serve that URL.`,
+                );
+            }
+        }
+    }
+
     const errorPage = existsSync(join(ROUTES_DIR, "+error.svelte")) ? "+error.svelte" : null;
 
     return { pages, apis, errorPage };

package/src/core/server.ts

@@ -13,7 +13,7 @@ import type { CsrfConfig } from "./csrf.ts";
 import { getCorsHeaders, handlePreflight } from "./cors.ts";
 import type { CorsConfig } from "./cors.ts";
 import { isDev, compress, isStaticPath } from "./html.ts";
-import { loadRouteData, renderSSRStream, renderErrorPage, renderPageWithFormData } from "./renderer.ts";
+import { loadRouteData, loadMetadata, renderSSRStream, renderErrorPage, renderPageWithFormData } from "./renderer.ts";
 import { getServerTime } from "../lib/utils.ts";
 
 // ─── User Hooks ──────────────────────────────────────────
@@ -122,9 +122,20 @@ async function resolve(event: RequestEvent): Promise<Response> {
         // Rewrite event.url so logging middleware sees the real page path, not /__bosia/data
         event.url = routeUrl;
         try {
+            const pageMatch = findMatch(serverRoutes, routeUrl.pathname);
             const data = await loadRouteData(routeUrl, locals, request, cookies);
             if (!data) return compress(JSON.stringify({ pageData: {}, layoutData: [] }), "application/json", request);
-            return compress(JSON.stringify(data), "application/json", request);
+
+            // Include metadata for client-side title/description updates
+            let metadata = null;
+            if (pageMatch) {
+                try {
+                    const meta = await loadMetadata(pageMatch.route, pageMatch.params, routeUrl, locals, cookies, request);
+                    if (meta) metadata = { title: meta.title, description: meta.description };
+                } catch { /* non-fatal */ }
+            }
+
+            return compress(JSON.stringify({ ...data, metadata }), "application/json", request);
         } catch (err) {
             if (err instanceof Redirect) {
                 return compress(JSON.stringify({ redirect: err.location, status: err.status }), "application/json", request);