bosia 0.8.13 → 0.8.15

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.8.13",
+	"version": "0.8.15",
 	"type": "module",
 	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing No Node.js, no Vite, no adapters.",
 	"keywords": [

package/src/cli/start.ts

@@ -26,5 +26,7 @@ export async function runStart() {
 	// mid-drain. The terminal delivers SIGINT to the whole process group,
 	// so the child already gets the signal — no forwarding needed.
 	for (const sig of ["SIGINT", "SIGTERM"] as const) process.on(sig, () => {});
-	await proc.exited;
+	// Propagate the child's code — a refused boot must not report success to CI,
+	// Docker restart policies or orchestrators.
+	process.exit(await proc.exited);
 }

package/src/core/client/App.svelte

@@ -77,6 +77,8 @@
 	let showLoading = $state(false);
 	let currentLayoutPaths: string[] = [];
 	let lastSettledPath = "";
+	let lastNavKey = ""; // pathname + search of the last processed nav
+	let lastTick = 0; // invalidationTick value last processed
 	// Skip bar on the very first effect run (initial hydration — data already present)
 	let firstNav = true;
 	let navDoneTimer: ReturnType<typeof setTimeout> | null = null;
@@ -107,10 +109,12 @@
 
 		// Subscribe to `invalidationTick` so `invalidate()` can wake the effect
 		// without a URL change.
-		void appState.invalidationTick;
+		const currentTick = appState.invalidationTick; // still tracks reactively
 
 		const path = router.currentRoute;
-		const pathname = path.split("?")[0].split("#")[0];
+		const url = new URL(path, window.location.origin);
+		const pathname = url.pathname;
+		const navKey = pathname + url.search;
 		const match = findMatch(clientRoutes, pathname);
 		if (!match) return;
 
@@ -121,11 +125,22 @@
 		if (isFirst) {
 			currentLayoutPaths = (match.route as any).layoutPaths ?? [];
 			lastSettledPath = pathname;
+			lastNavKey = navKey;
+			lastTick = currentTick;
 			// Restore-after-reload: router.init() staged this entry's snapshot.
 			settleSnapshot();
 			return; // Initial hydration — data already in SSR props, no fetch needed
 		}
 
+		// Hash-only change (same pathname+search, no invalidation): scroll, don't
+		// refetch. A static host can't answer the parent-snapshot POST a refetch may
+		// issue, which would otherwise render the error page.
+		if (navKey === lastNavKey && currentTick === lastTick) {
+			settleScroll();
+			return;
+		}
+		lastTick = currentTick;
+
 		appState.form = null;
 		if (navDoneTimer) {
 			clearTimeout(navDoneTimer);
@@ -160,7 +175,6 @@
 		// For each layout depth + the page, compare the cached entry (if any)
 		// against the live URL/params and the dirty set. If everything is
 		// cacheable, skip the fetch entirely.
-		const url = new URL(path, window.location.origin);
 		const ctx = liveContext(pathname, match.params, url);
 		const layoutIds = (match.route as any).layoutIds as (string | null)[];
 		const pageId = (match.route as any).pageId as string | null;
@@ -243,6 +257,7 @@
 			LoadingComponent = null;
 			currentLayoutPaths = destLayoutPaths;
 			lastSettledPath = pathname;
+			lastNavKey = navKey;
 			navDoneTimer = setTimeout(() => {
 				navDone = false;
 			}, 400);

package/src/core/dev.ts

@@ -3,6 +3,7 @@ import { readdirSync, statSync, watch, type Dirent } from "fs";
 import { join } from "path";
 import { loadEnv, resetDeclaredKeys } from "./env.ts";
 import { BOSIA_NODE_PATH } from "./paths.ts";
+import { pidsOnPort } from "./port.ts";
 import { affectsRouteManifest, shouldIgnoreForRebuild } from "./devWatch.ts";
 
 // Dev always writes to .bosia/dev so a parallel `bun run build` (writing to ./dist)
@@ -159,26 +160,16 @@ const APP_PORT = DEV_PORT + 1; // internal, hidden from user
 // disk → "ENOENT reading +page-<hash>.js" 500s. Reap whatever is listening on
 // APP_PORT before we spawn, so a stale child can never shadow the fresh build.
 async function reapStaleAppServer(port: number) {
-	try {
-		const proc = spawn(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"], {
-			stdout: "pipe",
-			stderr: "ignore",
-		});
-		const out = await new Response(proc.stdout).text();
-		await proc.exited;
-		const pids = [...new Set(out.split("\n").map((s) => s.trim()))]
-			.map(Number)
-			.filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
-		for (const pid of pids) {
-			try {
-				process.kill(pid, "SIGKILL");
-				console.log(`🧹 Reaped stale app server holding port ${port} (pid ${pid})`);
-			} catch {}
-		}
-		if (pids.length) await Bun.sleep(200); // let the port free before we bind
-	} catch {
-		// lsof unavailable or errored — fail open; a real conflict surfaces on bind.
+	// pidsOnPort fails open when lsof is unavailable — a real conflict then
+	// surfaces on bind instead.
+	const pids = (await pidsOnPort(port)).filter((pid) => pid !== process.pid);
+	for (const pid of pids) {
+		try {
+			process.kill(pid, "SIGKILL");
+			console.log(`🧹 Reaped stale app server holding port ${port} (pid ${pid})`);
+		} catch {}
 	}
+	if (pids.length) await Bun.sleep(200); // let the port free before we bind
 }
 
 async function startAppServer() {

package/src/core/port.ts

@@ -0,0 +1,16 @@
+/** PIDs listening on `port`. Fails open to [] — lsof may be absent. */
+export async function pidsOnPort(port: number): Promise<number[]> {
+	try {
+		const proc = Bun.spawn(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"], {
+			stdout: "pipe",
+			stderr: "ignore",
+		});
+		const out = await new Response(proc.stdout).text();
+		await proc.exited;
+		return [...new Set(out.split("\n").map((s) => s.trim()))]
+			.map(Number)
+			.filter((pid) => Number.isInteger(pid) && pid > 0);
+	} catch {
+		return [];
+	}
+}

package/src/core/prerender.ts

@@ -27,6 +27,7 @@ export function getEphemeralPort(): Promise<number> {
 const CORE_DIR = import.meta.dir;
 
 const PRERENDER_TIMEOUT = Number(process.env.PRERENDER_TIMEOUT) || 5_000; // 5s default
+const PRERENDER_CONCURRENCY = Number(process.env.PRERENDER_CONCURRENCY) || 6;
 
 // ─── Prerendering ─────────────────────────────────────────
 
@@ -97,79 +98,62 @@ export function prerenderApiOutPath(routePath: string): string {
 	return `${OUT_DIR}/prerendered${routePath.replace(/\/$/, "")}.json`;
 }
 
+/** Dynamic route → import module, call entries(), expand to concrete targets. */
+async function expandDynamicRoute(
+	pattern: string,
+	filePath: string,
+	kind: "page" | "api",
+	ts: TrailingSlash,
+): Promise<PrerenderTarget[]> {
+	try {
+		const mod = await import(join(process.cwd(), filePath));
+		if (typeof mod.entries !== "function") {
+			console.warn(`   ⚠️  ${pattern} has prerender=true but no entries() export — skipped`);
+			return [];
+		}
+		const entryList: Record<string, string>[] = await mod.entries();
+		return entryList.map((entry) => ({
+			path: substituteParams(pattern, entry),
+			kind,
+			trailingSlash: ts,
+		}));
+	} catch (err) {
+		console.error(`   ❌ Failed to resolve entries() for ${pattern}:`, err);
+		return [];
+	}
+}
+
 async function detectPrerenderRoutes(manifest: RouteManifest): Promise<PrerenderTarget[]> {
-	const targets: PrerenderTarget[] = [];
-	for (const route of manifest.pages) {
-		if (!route.pageServer) continue;
+	const pageTasks = manifest.pages.map(async (route): Promise<PrerenderTarget[]> => {
+		if (!route.pageServer) return [];
 		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 (!/export\s+const\s+prerender\s*=\s*true/.test(content)) return [];
 		if (/export\s+const\s+ssr\s*=\s*false/.test(content)) {
 			console.warn(
 				`   ⚠️  ${route.pattern} has prerender=true && ssr=false — contradictory, skipped`,
 			);
-			continue;
+			return [];
 		}
-
 		const ts = route.trailingSlash;
+		if (route.pattern.includes("[")) return expandDynamicRoute(route.pattern, filePath, "page", ts);
+		return [{ path: route.pattern, kind: "page", trailingSlash: ts }];
+	});
 
-		if (route.pattern.includes("[")) {
-			// 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) {
-					targets.push({
-						path: substituteParams(route.pattern, entry),
-						kind: "page",
-						trailingSlash: ts,
-					});
-				}
-			} catch (err) {
-				console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
-			}
-		} else {
-			targets.push({ path: route.pattern, kind: "page", trailingSlash: ts });
-		}
-	}
-
-	for (const route of manifest.apis) {
+	const apiTasks = manifest.apis.map(async (route): Promise<PrerenderTarget[]> => {
 		const filePath = join("src", "routes", route.server);
 		const content = await Bun.file(filePath).text();
-		if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) continue;
-
-		if (route.pattern.includes("[")) {
-			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) {
-					targets.push({
-						path: substituteParams(route.pattern, entry),
-						kind: "api",
-						trailingSlash: "never",
-					});
-				}
-			} catch (err) {
-				console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
-			}
-		} else {
-			targets.push({ path: route.pattern, kind: "api", trailingSlash: "never" });
-		}
-	}
+		if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) return [];
+		if (route.pattern.includes("["))
+			return expandDynamicRoute(route.pattern, filePath, "api", "never");
+		return [{ path: route.pattern, kind: "api", trailingSlash: "never" }];
+	});
 
-	return targets;
+	// Unbounded Promise.all over all routes; each task holds only small text reads
+	// and route metadata, so RAM stays trivial. Chunk it if route counts ever hit
+	// tens of thousands (open file descriptors would be the first limit).
+	const results = await Promise.all([...pageTasks, ...apiTasks]);
+	return results.flat();
 }
 
 export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<void> {
@@ -198,11 +182,12 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 	for (const sig of signals) process.once(sig, onSignal);
 
 	try {
-		// Poll /_health until ready (max 10s)
+		// Poll /_health until ready (max 10s). Check first, sleep only on failure —
+		// avoids a guaranteed floor when the server is already up.
 		const base = `http://localhost:${port}`;
 		let ready = false;
-		for (let i = 0; i < 50; i++) {
-			await Bun.sleep(200);
+		const deadline = Date.now() + 10_000;
+		while (Date.now() < deadline) {
 			try {
 				const res = await fetch(`${base}/_health`);
 				if (res.ok) {
@@ -212,6 +197,7 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 			} catch {
 				/* not ready yet */
 			}
+			await Bun.sleep(50);
 		}
 
 		if (!ready) {
@@ -221,7 +207,11 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 
 		mkdirSync(`${OUT_DIR}/prerendered`, { recursive: true });
 
-		for (const { path: routePath, kind, trailingSlash: ts } of targets) {
+		const prerenderOne = async ({
+			path: routePath,
+			kind,
+			trailingSlash: ts,
+		}: PrerenderTarget): Promise<void> => {
 			try {
 				if (kind === "api") {
 					// APIs: fetch the bare route URL, write body to `<path>.json`.
@@ -233,7 +223,7 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 					mkdirSync(outPath.substring(0, outPath.lastIndexOf("/")), { recursive: true });
 					writeFileSync(outPath, body);
 					console.log(`   ✅ ${routePath} → ${outPath}`);
-					continue;
+					return;
 				}
 
 				// Hit the canonical URL so the server doesn't 308 us mid-prerender
@@ -278,7 +268,19 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 					console.error(`   ❌ Failed to prerender ${routePath}:`, err);
 				}
 			}
-		}
+		};
+
+		// Bounded worker pool: N workers pull from a shared index until targets drain.
+		let next = 0;
+		const worker = async () => {
+			while (next < targets.length) {
+				const target = targets[next++];
+				if (target) await prerenderOne(target);
+			}
+		};
+		await Promise.all(
+			Array.from({ length: Math.min(PRERENDER_CONCURRENCY, targets.length) }, worker),
+		);
 
 		console.log("✅ Prerendering complete");
 	} finally {

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 { pidsOnPort } from "./port.ts";
 import { buildPrerenderManifest, buildStaticManifest, lookupStatic } from "./staticManifest.ts";
 import { dedup } from "./dedup.ts";
 import {
@@ -1092,7 +1093,14 @@ const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : isDev ? 9001 :
 // Elysia's chained generics drift when plugins add routes — track the app as a
 // loose `Elysia` so plugin-extended types stay assignable.
 let app: Elysia = new Elysia({
-	serve: { maxRequestBodySize: BODY_SIZE_LIMIT, idleTimeout: IDLE_TIMEOUT },
+	serve: {
+		maxRequestBodySize: BODY_SIZE_LIMIT,
+		idleTimeout: IDLE_TIMEOUT,
+		// Elysia's Bun adapter defaults reusePort:true — SO_REUSEPORT lets a second
+		// server silently join the port and the kernel splits traffic between two
+		// different builds. Opt in only for deliberate N-worker clustering.
+		reusePort: process.env.BOSIA_REUSE_PORT === "1",
+	},
 }) as unknown as Elysia;
 
 // Plugins.backend.before — runs before framework middleware/routes.
@@ -1160,23 +1168,34 @@ for (const plugin of plugins) {
 	}
 }
 
-app.listen(PORT, () => {
-	// In dev mode the proxy owns the user-facing port — don't print the internal port
-	if (!isDev) console.log(`⬡ Bosia server running at http://localhost:${PORT}`);
-	// Last line of startup on purpose — the cache identity contract is the one
-	// config mistake that leaks one user's page to another, so it stays visible.
-	if (CACHE_ENABLED) {
-		console.log(
-			`\n🔑 Response cache tells users apart ONLY by these cookies/headers: [${CACHE_KEYS.join(", ")}]\n` +
-				`   Using a different session cookie or auth header? Add its name to CACHE_KEYS,\n` +
-				`   or one user's personalised page can be served to another. Routes personalised\n` +
-				`   by anything else should set \`export const cache = false\`.\n` +
-				`   Note: the runtime auto-warns only on uncovered *cookie* reads — it CANNOT\n` +
-				`   detect header-based personalisation, so custom auth headers (X-Api-Key,\n` +
-				`   X-Auth-Token, …) must be added to CACHE_KEYS by hand.\n`,
-		);
-	}
-});
+try {
+	app.listen(PORT, () => {
+		// In dev mode the proxy owns the user-facing port — don't print the internal port
+		if (!isDev) console.log(`⬡ Bosia server running at http://localhost:${PORT}`);
+		// Last line of startup on purpose — the cache identity contract is the one
+		// config mistake that leaks one user's page to another, so it stays visible.
+		if (CACHE_ENABLED) {
+			console.log(
+				`\n🔑 Response cache tells users apart ONLY by these cookies/headers: [${CACHE_KEYS.join(", ")}]\n` +
+					`   Using a different session cookie or auth header? Add its name to CACHE_KEYS,\n` +
+					`   or one user's personalised page can be served to another. Routes personalised\n` +
+					`   by anything else should set \`export const cache = false\`.\n` +
+					`   Note: the runtime auto-warns only on uncovered *cookie* reads — it CANNOT\n` +
+					`   detect header-based personalisation, so custom auth headers (X-Api-Key,\n` +
+					`   X-Auth-Token, …) must be added to CACHE_KEYS by hand.\n`,
+			);
+		}
+	});
+} catch (err) {
+	// Bun.serve runs inline inside .listen(), so a failed bind lands here.
+	if ((err as { code?: string })?.code !== "EADDRINUSE") throw err;
+	const [pid] = await pidsOnPort(PORT);
+	console.error(
+		`\n❌ Port ${PORT} is already serving${pid ? ` (pid ${pid})` : ""}.\n` +
+			`   Stop it or set PORT to a free port.\n`,
+	);
+	process.exit(1);
+}
 
 async function shutdown() {
 	if (shuttingDown) {