bosia 0.6.8 → 0.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.6.8",
+	"version": "0.6.10",
 	"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/index.ts

@@ -26,6 +26,11 @@ async function main() {
 			await runBuild();
 			break;
 		}
+		case "sync": {
+			const { runSync } = await import("./sync.ts");
+			await runSync();
+			break;
+		}
 		case "start": {
 			const { runStart } = await import("./start.ts");
 			await runStart();
@@ -80,6 +85,7 @@ Commands:
   create <name> [--template <t>]  Scaffold a new Bosia project
   dev                 Start the development server
   build               Build for production
+  sync                Generate .bosia/ codegen (routes, $types, env) without building
   start               Run the production server
   test [args]         Run tests with bun test (auto-loads .env.test, sets BOSIA_ENV=test)
   add <component...> [-y]   Add one or more UI components from the registry

package/src/cli/sync.ts

@@ -0,0 +1,16 @@
+import { scanRoutes } from "../core/scanner.ts";
+import { generateRoutesFile } from "../core/routeFile.ts";
+import { generateRouteTypes, ensureRootDirs } from "../core/routeTypes.ts";
+import { loadEnv, classifyEnvVars } from "../core/env.ts";
+import { generateEnvModules } from "../core/envCodegen.ts";
+
+export async function runSync() {
+	const envMode = process.env.NODE_ENV === "production" ? "production" : "development";
+	const classifiedEnv = classifyEnvVars(loadEnv(envMode));
+	const manifest = scanRoutes();
+	generateRoutesFile(manifest);
+	generateRouteTypes(manifest);
+	ensureRootDirs();
+	generateEnvModules(classifiedEnv);
+	console.log("✅ Bosia codegen ready (.bosia/routes.ts, types, env modules)");
+}

package/src/core/client/App.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-	import { router } from "./router.svelte.ts";
+	import { tick } from "svelte";
+	import { router, scrollToHash } from "./router.svelte.ts";
 	import { findMatch } from "../matcher.ts";
 	import { clientRoutes } from "bosia:routes";
 	import { consumePrefetch, prefetchCache, dataUrl } from "./prefetch.ts";
@@ -198,7 +199,12 @@
 					appState.errorComponent = errMod.default;
 					appState.errorProps = { error: { status: errStatus, message: errMessage } };
 					appState.errorDepth = K;
-					if (router.isPush && !router.suppressScroll) window.scrollTo(0, 0);
+					if (router.isPush && !router.suppressScroll) {
+						const hash = window.location.hash;
+						tick().then(() => {
+							if (!scrollToHash(hash)) window.scrollTo(0, 0);
+						});
+					}
 					router.suppressScroll = false;
 					settle({ url, params: match.params });
 				} catch {
@@ -290,7 +296,13 @@
 
 			// Scroll to top on forward navigation (not on popstate/back-forward).
 			// goto({ noScroll: true }) flips `router.suppressScroll` for one nav.
-			if (router.isPush && !router.suppressScroll) window.scrollTo(0, 0);
+			// If the destination URL has a hash, scroll to that element instead.
+			if (router.isPush && !router.suppressScroll) {
+				const hash = window.location.hash;
+				tick().then(() => {
+					if (!scrollToHash(hash)) window.scrollTo(0, 0);
+				});
+			}
 			router.suppressScroll = false;
 
 			// Update document title and meta description from server metadata

package/src/core/client/router.svelte.ts

@@ -16,6 +16,22 @@ function buildTarget(path: string): { url: URL; params: Record<string, string> }
 	return { url, params: match?.params ?? {} };
 }
 
+export function scrollToHash(hash: string): boolean {
+	if (typeof document === "undefined" || !hash) return false;
+	const raw = hash.startsWith("#") ? hash.slice(1) : hash;
+	if (!raw) return false;
+	let id = raw;
+	try {
+		id = decodeURIComponent(raw);
+	} catch {
+		// Fallback to raw if URI sequence is malformed.
+	}
+	const el = document.getElementById(id) ?? document.getElementById(raw);
+	if (!el) return false;
+	el.scrollIntoView();
+	return true;
+}
+
 export const router = new (class Router {
 	currentRoute = $state(
 		typeof window !== "undefined"
@@ -89,6 +105,22 @@ export const router = new (class Router {
 			if (anchor.rel.split(/\s+/).includes("external")) return;
 			if (anchor.protocol !== "https:" && anchor.protocol !== "http:") return;
 
+			// Same-page hash navigation: skip page reload, just update URL and scroll
+			// to the target element. Mirrors browser default for in-page anchors.
+			const samePage =
+				anchor.pathname === window.location.pathname &&
+				anchor.search === window.location.search;
+			if (samePage && anchor.hash) {
+				e.preventDefault();
+				const finalPath = anchor.pathname + anchor.search + anchor.hash;
+				if (this.currentRoute !== finalPath) {
+					history.pushState({}, "", finalPath);
+					this.currentRoute = finalPath;
+				}
+				scrollToHash(anchor.hash);
+				return;
+			}
+
 			e.preventDefault();
 			this.navigate(anchor.pathname + anchor.search + anchor.hash, { source: "link" });
 		});

package/src/core/routeTypes.ts

@@ -100,6 +100,7 @@ export function generateRouteTypes(manifest: RouteManifest): void {
 				`export type PageMetadataLoad = (event: _MetadataEvent) => Metadata | Promise<Metadata>;`,
 			);
 			lines.push(`export type Action = (event: _RequestEvent) => any;`);
+			lines.push(`export type Actions = Record<string, Action>;`);
 			lines.push(`export type PageData = Awaited<ReturnType<typeof _pageLoad>>;`);
 		} else {
 			lines.push(``);
@@ -107,6 +108,7 @@ export function generateRouteTypes(manifest: RouteManifest): void {
 				`export type PageMetadataLoad = (event: _MetadataEvent) => Metadata | Promise<Metadata>;`,
 			);
 			lines.push(`export type Action = (event: _RequestEvent) => any;`);
+			lines.push(`export type Actions = Record<string, Action>;`);
 			lines.push(`export type PageData = {};`);
 		}
 		lines.push(`export type PageProps = { data: PageData; params: Params };`);

package/src/core/server.ts

@@ -24,6 +24,7 @@ import { buildCspHeader, CSP_DIRECTIVES_TEMPLATE, CSP_ENABLED, generateNonce } f
 import { isDev, compress, isStaticPath } from "./html.ts";
 import { dev500WithPlugins } from "./dev-500.ts";
 import { OUT_DIR } from "./paths.ts";
+import { buildStaticManifest, lookupStatic } from "./staticManifest.ts";
 import { dedup, dedupKey } from "./dedup.ts";
 import {
 	CACHE_ENABLED,
@@ -170,6 +171,12 @@ function parseActionName(url: URL): string {
 	return "default";
 }
 
+// Prod: walk `dist/client`, `./public`, and `OUT_DIR` once at boot so static-asset
+// requests cost a single Map lookup instead of up to 4 `Bun.file().exists()` syscalls.
+// Dev keeps the per-request fallthrough so files dropped into `public/` mid-session
+// are served without a restart (dev's watcher doesn't fire on `public/`).
+const staticManifest = isDev ? null : buildStaticManifest(OUT_DIR);
+
 async function resolve(event: RequestEvent): Promise<Response> {
 	const { request, url, locals, cookies } = event;
 	const path = url.pathname;
@@ -327,7 +334,21 @@ async function resolve(event: RequestEvent): Promise<Response> {
 
 	// Static files
 	if (isStaticPath(path)) {
-		// dist/client: serve with cache headers based on whether filename is hashed
+		// Prod fast path: single Map lookup, no per-request stat calls.
+		if (staticManifest) {
+			const hit = lookupStatic(staticManifest, path);
+			if (hit) {
+				return new Response(
+					Bun.file(hit.absPath),
+					hit.cacheControl
+						? { headers: { "Cache-Control": hit.cacheControl } }
+						: undefined,
+				);
+			}
+			return new Response("Not Found", { status: 404 });
+		}
+		// Dev: keep the per-request fallthrough so files dropped into `public/`
+		// mid-session are served without a restart.
 		if (path.startsWith("/dist/client/")) {
 			const resolved = safePath(
 				`${OUT_DIR}/client`,
@@ -336,11 +357,7 @@ async function resolve(event: RequestEvent): Promise<Response> {
 			if (resolved) {
 				const file = Bun.file(resolved);
 				if (await file.exists()) {
-					const filename = path.split("/").pop() ?? "";
-					const isHashed = /\-[a-z0-9]{8,}\.[a-z]+$/.test(filename);
-					const cacheControl =
-						!isDev && isHashed ? "public, max-age=31536000, immutable" : "no-cache";
-					return new Response(file, { headers: { "Cache-Control": cacheControl } });
+					return new Response(file, { headers: { "Cache-Control": "no-cache" } });
 				}
 			}
 			return new Response("Not Found", { status: 404 });

package/src/core/staticManifest.ts

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join, resolve as resolvePath } from "path";
+
+export type StaticEntry = { absPath: string; cacheControl?: string };
+export type StaticManifest = Map<string, StaticEntry>;
+
+const HASHED_BASENAME = /\-[a-z0-9]{8,}\.[a-z]+$/;
+const IMMUTABLE_CACHE = "public, max-age=31536000, immutable";
+const DEFAULT_CACHE = "no-cache";
+
+// Files/dirs at OUT_DIR root that the manifest must not surface — they're either
+// build metadata or re-merges already covered by the per-root walks.
+const OUT_DIR_SKIP_DIRS = new Set(["client", "static", "prerendered", "server"]);
+const OUT_DIR_SKIP_FILES = new Set(["manifest.json", "route-manifest.json"]);
+
+const RESERVED_PREFIX = "/__bosia/";
+
+function* walk(dir: string, rel = ""): Generator<{ abs: string; rel: string }> {
+	let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" }) as unknown as Array<{
+			name: string;
+			isDirectory(): boolean;
+			isFile(): boolean;
+		}>;
+	} catch {
+		return;
+	}
+	for (const ent of entries) {
+		const childAbs = join(dir, ent.name);
+		const childRel = rel ? `${rel}/${ent.name}` : ent.name;
+		if (ent.isDirectory()) {
+			yield* walk(childAbs, childRel);
+		} else if (ent.isFile()) {
+			yield { abs: childAbs, rel: childRel };
+		}
+	}
+}
+
+function addOnce(manifest: StaticManifest, key: string, entry: StaticEntry) {
+	if (key.startsWith(RESERVED_PREFIX)) return;
+	if (manifest.has(key)) return;
+	manifest.set(key, entry);
+}
+
+export function buildStaticManifest(outDir: string): StaticManifest {
+	const manifest: StaticManifest = new Map();
+	const outAbs = resolvePath(outDir);
+
+	const clientRoot = join(outAbs, "client");
+	if (existsSync(clientRoot)) {
+		for (const { abs, rel } of walk(clientRoot)) {
+			const cacheControl = HASHED_BASENAME.test(basename(rel))
+				? IMMUTABLE_CACHE
+				: DEFAULT_CACHE;
+			addOnce(manifest, `/dist/client/${rel}`, { absPath: abs, cacheControl });
+		}
+	}
+
+	const publicRoot = resolvePath("./public");
+	if (existsSync(publicRoot)) {
+		for (const { abs, rel } of walk(publicRoot)) {
+			addOnce(manifest, `/${rel}`, { absPath: abs });
+		}
+	}
+
+	if (existsSync(outAbs)) {
+		let rootEntries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+		try {
+			rootEntries = readdirSync(outAbs, {
+				withFileTypes: true,
+				encoding: "utf8",
+			}) as unknown as Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+		} catch {
+			rootEntries = [];
+		}
+		for (const ent of rootEntries) {
+			if (ent.isDirectory()) {
+				if (OUT_DIR_SKIP_DIRS.has(ent.name)) continue;
+				const sub = join(outAbs, ent.name);
+				for (const { abs, rel } of walk(sub, ent.name)) {
+					addOnce(manifest, `/${rel}`, { absPath: abs });
+				}
+			} else if (ent.isFile()) {
+				if (OUT_DIR_SKIP_FILES.has(ent.name)) continue;
+				addOnce(manifest, `/${ent.name}`, { absPath: join(outAbs, ent.name) });
+			}
+		}
+	}
+
+	return manifest;
+}
+
+export function lookupStatic(manifest: StaticManifest, urlPath: string): StaticEntry | null {
+	const key = urlPath.split("?")[0];
+	return manifest.get(key) ?? null;
+}
+
+// Re-export for tests that want to confirm a file-on-disk exists at the entry.
+export function entryFileExists(entry: StaticEntry): boolean {
+	try {
+		return statSync(entry.absPath).isFile();
+	} catch {
+		return false;
+	}
+}

package/src/lib/index.ts

@@ -1,3 +1,5 @@
+/// <reference path="../ambient.d.ts" />
+
 // ─── Bosia Public API ─────────────────────────────────────
 // Usage in user apps:
 //   import { cn, sequence } from "bosia"

package/templates/default/package.json

@@ -6,7 +6,7 @@
 		"dev": "bosia dev",
 		"build": "bosia build",
 		"start": "bosia start",
-		"check": "tsc --noEmit && prettier --check .",
+		"check": "bosia sync && svelte-check --tsconfig ./tsconfig.json && tsc --noEmit",
 		"format": "prettier --write .",
 		"format:check": "prettier --check ."
 	},
@@ -19,6 +19,7 @@
 		"@types/bun": "latest",
 		"prettier": "^3.3.0",
 		"prettier-plugin-svelte": "^3.2.0",
+		"svelte-check": "^4.4.8",
 		"typescript": "^5"
 	}
 }

package/templates/default/tsconfig.json

@@ -17,6 +17,6 @@
 			"$lib/*": ["./src/lib/*"]
 		}
 	},
-	"include": ["src/**/*"],
+	"include": ["src/**/*", ".bosia/types/**/*.d.ts"],
 	"exclude": ["node_modules", "dist"]
 }