bosia 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosia",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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": [

package/src/cli/add.ts

@@ -1,10 +1,15 @@
 import { join, dirname } from "path";
 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 (or local registry
-// with --local) and copies it into src/lib/components/ui/<name>/.
+// 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 REMOTE_BASE = "https://raw.githubusercontent.com/bosapi/bosia/main/registry";
 
@@ -38,29 +43,52 @@ export async function runAdd(name: string | undefined, flags: string[] = []) {
     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 readMeta(name);
+    const meta = await readMeta(fullPath);
 
     // Install component dependencies first (recursive)
     for (const dep of meta.dependencies) {
         await addComponent(dep, false);
     }
 
-    // Download/copy 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 readFile(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
@@ -78,7 +106,7 @@ 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 ─────────────────────────────

package/src/cli/index.ts

@@ -64,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

@@ -2,7 +2,7 @@
   import { router } from "./router.svelte.ts";
   import { findMatch } from "../matcher.ts";
   import { clientRoutes } from "bosia:routes";
-  import { consumePrefetch, prefetchCache } from "./prefetch.ts";
+  import { consumePrefetch, prefetchCache, dataUrl } from "./prefetch.ts";
 
   let {
     ssrMode = false,
@@ -45,12 +45,12 @@
 
     const isFirst = firstNav;
     firstNav = false;
-    if (!isFirst) {
-      formData = null;
-      if (navDoneTimer) { clearTimeout(navDoneTimer); navDoneTimer = null; }
-      navDone = false;
-      navigating = true;
-    }
+    if (isFirst) return; // Initial hydration — data already in SSR props, no fetch needed
+
+    formData = null;
+    if (navDoneTimer) { clearTimeout(navDoneTimer); navDoneTimer = null; }
+    navDone = false;
+    navigating = true;
 
     // Load components + data in parallel, then update state atomically
     // to avoid a flash of stale/empty data before the fetch completes.
@@ -59,7 +59,7 @@
     const dataFetch = cached
       ? Promise.resolve(cached)
       : match.route.hasServerData
-        ? fetch(`/__bosia/data?path=${encodeURIComponent(path)}`).then(r => r.json()).catch(() => null)
+        ? fetch(dataUrl(path)).then(r => r.json()).catch(() => null)
         : Promise.resolve(null);
 
     Promise.all([
@@ -75,7 +75,8 @@
         router.navigate(result.redirect);
         return;
       }
-      if (result?.error) {
+      if (result?.error || (result === null && match.route.hasServerData)) {
+        // Data fetch failed (e.g. static hosting with no server) — full page load
         window.location.href = path;
         return;
       }
@@ -84,6 +85,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/client/prefetch.ts

@@ -2,6 +2,13 @@
 // Supports `data-bosia-preload="hover"` and `data-bosia-preload="viewport"`
 // on <a> elements or their ancestors.
 
+/** Builds the `/__bosia/data/…` URL for a given client path. */
+export function dataUrl(path: string): string {
+    const url = new URL(path, window.location.origin);
+    let p = url.pathname.replace(/\/$/, "");
+    return `/__bosia/data${p || "/index"}.json${url.search}`;
+}
+
 export const prefetchCache = new Map<string, any>();
 
 // In-flight fetch deduplication
@@ -22,7 +29,7 @@ export async function prefetchPath(path: string): Promise<void> {
 
     pending.add(path);
     try {
-        const res = await fetch(`/__bosia/data?path=${encodeURIComponent(path)}`);
+        const res = await fetch(dataUrl(path));
         if (res.ok) {
             prefetchCache.set(path, await res.json());
         }

package/src/core/html.ts

@@ -96,8 +96,9 @@ 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">
+<body>
   <div id="app">${body}</div>${scripts}
 </body>
 </html>`;
@@ -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;
 }
@@ -149,7 +151,7 @@ export function buildMetadataChunk(metadata: Metadata | null): string {
     } else {
         out += `  <title>Bosia App</title>\n`;
     }
-    out += `</head>\n<body data-bosia-preload="hover">\n${SPINNER}`;
+    out += `</head>\n<body>\n${SPINNER}`;
     return out;
 }
 

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/plugin.ts

@@ -4,7 +4,19 @@ import { join, dirname } from "path";
 // Resolves:
 //   bosia:routes  → .bosia/routes.ts  (generated route map)
 //   $env           → .bosia/env.server.ts (bun) or .bosia/env.client.ts (browser)
-//   $lib/*        → src/lib/*         (user library alias)
+//   $*             → resolved dynamically via tsconfig.json compilerOptions.paths
+
+let cachedTsconfigPaths: Record<string, string[]> | null = null;
+async function getTsconfigPaths() {
+    if (cachedTsconfigPaths !== null) return cachedTsconfigPaths;
+    try {
+        const tsconfig = await Bun.file(join(process.cwd(), "tsconfig.json")).json();
+        cachedTsconfigPaths = tsconfig?.compilerOptions?.paths || {};
+    } catch {
+        cachedTsconfigPaths = {};
+    }
+    return cachedTsconfigPaths!;
+}
 
 export function makeBosiaPlugin(target: "browser" | "bun" = "bun") {
     return {
@@ -24,11 +36,37 @@ export function makeBosiaPlugin(target: "browser" | "bun" = "bun") {
                 ),
             }));
 
-            // $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) };
+            // Handle all $ aliases using tsconfig.json paths (e.g. $lib, $registry)
+            build.onResolve({ filter: /^\$/ }, async (args) => {
+                if (args.path === "$env") return undefined; // Handled above
+
+                const paths = await getTsconfigPaths();
+                let longestMatch = "";
+                let targetPattern = "";
+
+                for (const [pattern, targets] of Object.entries(paths)) {
+                    const prefix = pattern.replace(/\*$/, "");
+                    if (args.path.startsWith(prefix) && prefix.length > longestMatch.length) {
+                        longestMatch = prefix;
+                        targetPattern = (targets as string[])[0];
+                    }
+                }
+
+                if (longestMatch && targetPattern) {
+                    const suffix = args.path.slice(longestMatch.length);
+                    const targetDir = targetPattern.replace(/\*$/, "");
+                    const resolved = join(process.cwd(), targetDir, suffix);
+                    return { path: await resolveWithExts(resolved) };
+                }
+
+                // Fallback for $lib/* if not in tsconfig
+                if (args.path.startsWith("$lib/")) {
+                    const rel = args.path.slice(5);
+                    const base = join(process.cwd(), "src", "lib", rel);
+                    return { path: await resolveWithExts(base) };
+                }
+
+                return undefined;
             });
 
             // Force svelte imports to resolve from the app's node_modules.

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);
         }
     }
@@ -71,7 +91,19 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
                 : `./dist/prerendered${routePath}/index.html`;
             mkdirSync(outPath.substring(0, outPath.lastIndexOf("/")), { recursive: true });
             writeFileSync(outPath, html);
-            console.log(`   ✅ ${routePath} → ${outPath}`);
+
+            // Also prerender the data payload
+            const dataPath = routePath === "/" ? "/index.json" : `${routePath.replace(/\/$/, "")}.json`;
+            const dataRes = await fetch(`${base}/__bosia/data${dataPath}`, { signal: AbortSignal.timeout(PRERENDER_TIMEOUT) });
+            if (dataRes.ok) {
+                const dataJson = await dataRes.text();
+                const dataOutPath = `./dist/prerendered/__bosia/data${dataPath}`;
+                mkdirSync(dataOutPath.substring(0, dataOutPath.lastIndexOf("/")), { recursive: true });
+                writeFileSync(dataOutPath, dataJson);
+                console.log(`   ✅ ${routePath} → ${outPath} (+ data)`);
+            } else {
+                console.log(`   ✅ ${routePath} → ${outPath}`);
+            }
         } catch (err) {
             if (err instanceof DOMException && err.name === "TimeoutError") {
                 console.error(`   ❌ Prerender timed out for ${routePath} after ${PRERENDER_TIMEOUT / 1000}s — increase PRERENDER_TIMEOUT to raise the limit`);
@@ -84,3 +116,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 ──────────────────────────────────────────
@@ -113,18 +113,33 @@ async function resolve(event: RequestEvent): Promise<Response> {
     }
 
     // Data endpoint — returns server loader data as JSON for client-side navigation
-    if (path === "/__bosia/data") {
-        const routePath = url.searchParams.get("path") ?? "/";
-        if (!isValidRoutePath(routePath, url.origin)) {
+    if (path.startsWith("/__bosia/data/")) {
+        const routePathStr = path.slice("/__bosia/data".length).replace(/\.json$/, "").replace(/^\/index$/, "/") || "/";
+
+        if (!isValidRoutePath(routePathStr, url.origin)) {
             return Response.json({ error: "Invalid path", status: 400 }, { status: 400 });
         }
-        const routeUrl = new URL(routePath, url.origin);
+        const routeUrl = new URL(routePathStr, url.origin);
+        for (const [key, val] of url.searchParams.entries()) {
+            routeUrl.searchParams.append(key, val);
+        }
         // 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);