bosia 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "1.2.1",
+	"version": "1.2.2",
 	"type": "module",
 	"engines": {
 		"bun": ">=1.4"

package/src/core/build.ts

@@ -400,7 +400,7 @@ await bundleRuntimeUserFiles(process.cwd());
 const devBuild = process.env.BOSIA_DEV_BUILD === "1";
 
 // 9. Prerender static routes
-if (!devBuild) await prerenderStaticRoutes(manifest);
+if (!devBuild) await prerenderStaticRoutes(manifest, target);
 
 // 10. Generate static site output (HTML + client assets + public → dist/static/)
 if (!devBuild) generateStaticSite();

package/src/core/client/App.svelte

@@ -9,7 +9,7 @@
 	import { pickErrorPage } from "../errorMatch.ts";
 	import { fireAfterNavigate, type Navigation } from "./navListeners.ts";
 	import { drainNavResolvers } from "./navigation.ts";
-	import { collapseTitle } from "../headScan.ts";
+	import { collapseTitle, errorTitle } from "../headScan.ts";
 	import { chainTitles, takeTitleWrite, titleNav } from "./titleMemory.svelte.ts";
 	import TitleProbe from "./TitleProbe.svelte";
 
@@ -309,7 +309,10 @@
 			// can't clobber a newer nav's loader.
 			// The skeleton and the error page render in their own {#if} branch, so
 			// leaving either remounts the page. Read before both are cleared below.
-			const pageShown = !showLoading && !appState.errorComponent;
+			// The skeleton shows only once its chunk loaded (template's condition).
+			const skeletonShown = showLoading && !!LoadingComponent;
+			const pageShown = !skeletonShown && !appState.errorComponent;
+			const errorShown = skeletonShown ? null : appState.errorComponent;
 			showLoading = false;
 			LoadingComponent = null;
 			lastSettledPath = pathname;
@@ -350,9 +353,22 @@
 						...match.route.layouts.slice(0, K).map((l: any) => l()),
 					]);
 					if (cancelled) return;
+					// Error page to error page: the layouts both share stay mounted and
+					// never write their title again. Same error component under all of
+					// them too: nothing remounts, so a <title> it wrote stays — keep it.
+					const kept = errorShown
+						? sharedDepth(currentLayoutPaths, destLayoutPaths.slice(0, K))
+						: 0;
+					const prev = appState.errorProps?.error;
+					const keepTitle =
+						errorShown === errMod.default &&
+						kept === K &&
+						appState.errorDepth === K &&
+						!!prev &&
+						document.title !== collapseTitle(errorTitle(prev.status, prev.message));
 					layoutComponents = layoutModsForError.map((m: any) => m.default);
 					currentLayoutPaths = destLayoutPaths.slice(0, K);
-					titleNav.seq++; // the error branch remounts the layouts
+					titleNav.seq++; // the probes read again as this flushes
 					const newLayoutData: Record<string, any>[] = [];
 					for (let i = 0; i < K; i++) newLayoutData.push({});
 					appState.layoutData = newLayoutData;
@@ -361,6 +377,15 @@
 					appState.errorComponent = errMod.default;
 					appState.errorProps = { error: { status: errStatus, message: errMessage } };
 					appState.errorDepth = K;
+					// What a hard load shows (renderer.ts): a layout's title, else the
+					// status title. Set before Svelte flushes, so a freshly mounted
+					// <title> in +error.svelte or a layout still wins.
+					document.querySelectorAll("[data-bosia-meta]").forEach((el) => el.remove());
+					if (!keepTitle) {
+						document.title =
+							(kept > 0 ? chainTitles[kept - 1] : null) ?? errorTitle(errStatus, errMessage);
+						navTitle = document.title;
+					}
 					settleScroll();
 					settle({ url, params: match.params });
 				} catch {

package/src/core/headScan.ts

@@ -5,6 +5,12 @@
 /** The title a page gets when nothing else sets one. */
 export const DEFAULT_TITLE = "Bosia App";
 
+/** The title an error page gets when its components set none: `404 — Not Found`.
+ *  SSR and client navigation both use it, so the two never drift apart. */
+export function errorTitle(status: number, message: string): string {
+	return `${status} — ${message}`;
+}
+
 /** Whether a chunk of head markup already sets the document title. Matches a
  *  <title> with attributes too. Ignores one in a comment, an attribute value, a
  *  script or JSON-LD string, <style>, <noscript>, <template>, or an inline <svg>

package/src/core/prerender.ts

@@ -1,7 +1,8 @@
-import { writeFileSync, mkdirSync, cpSync, existsSync } from "fs";
+import { writeFileSync, mkdirSync, cpSync, existsSync, readFileSync } from "fs";
 import { createServer } from "net";
 import { join } from "path";
 import type { RouteManifest, TrailingSlash } from "./types.ts";
+import type { RuntimeTarget } from "./types/plugin.ts";
 
 import { BOSIA_NODE_PATH, OUT_DIR } from "./paths.ts";
 import { currentBase } from "./appBase.ts";
@@ -28,6 +29,26 @@ export function getEphemeralPort(): Promise<number> {
 
 const CORE_DIR = import.meta.dir;
 
+/**
+ * True when the app's wrangler config serves `404.html` for unknown paths
+ * (`not_found_handling: "404-page"`) and `public/404.html` doesn't provide one,
+ * so a failed 404 probe must fail the build. Reads the text, skipping whole-line
+ * `//` and `#` comments; a block comment around the key still counts.
+ */
+export function needsStatic404(cwd = process.cwd()): boolean {
+	if (existsSync(join(cwd, "public", "404.html"))) return false;
+	for (const name of ["wrangler.jsonc", "wrangler.json", "wrangler.toml"]) {
+		const file = join(cwd, name);
+		if (!existsSync(file)) continue;
+		const text = readFileSync(file, "utf-8")
+			.split("\n")
+			.filter((line) => !/^\s*(\/\/|#)/.test(line))
+			.join("\n");
+		return /not_found_handling"?\s*[:=]\s*"404-page"/.test(text);
+	}
+	return false;
+}
+
 const PRERENDER_TIMEOUT = Number(process.env.PRERENDER_TIMEOUT) || 5_000; // 5s default
 const PRERENDER_CONCURRENCY = Number(process.env.PRERENDER_CONCURRENCY) || 6;
 
@@ -157,23 +178,44 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 	return results.flat();
 }
 
-export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<void> {
+export async function prerenderStaticRoutes(
+	manifest: RouteManifest,
+	target: RuntimeTarget = "bun",
+): Promise<void> {
 	const targets = await detectPrerenderRoutes(manifest);
-	if (targets.length === 0) return;
+	// On Workers the worker answers unknown paths, so 404.html is never required.
+	const require404 = target !== "workers" && needsStatic404();
+	// No routes to prerender: start the server only for the required 404.html.
+	if (targets.length === 0 && !require404) return;
 
-	console.log(`\n🖨️  Prerendering ${targets.length} route(s)...`);
+	console.log(
+		targets.length
+			? `\n🖨️  Prerendering ${targets.length} route(s)...`
+			: "\n🖨️  Building 404.html (wrangler sets 404-page)...",
+	);
 
 	const port = await getEphemeralPort();
+	// No BOSIA_REUSE_PORT: the child must fail to bind rather than share a port
+	// with another server, whose pages we'd then save as ours. The ready loop
+	// stops once the child exits, but a server that grabbed the port first can
+	// still answer /_health before the child dies. Have /_health echo a nonce
+	// from the child's env if that race ever shows up.
+	const { BOSIA_REUSE_PORT: _, ...env } = process.env;
 	const child = Bun.spawn(["bun", "run", `${OUT_DIR}/server/index.js`], {
 		env: {
-			...process.env,
+			...env,
 			NODE_ENV: "production",
 			PORT: String(port),
 			NODE_PATH: BOSIA_NODE_PATH,
 		},
 		stdout: "ignore",
-		stderr: "ignore",
+		// Show render errors (a throwing +error.svelte, a crashing loader).
+		stderr: "inherit",
 	});
+	// exitCode stays null when a signal kills the child (OOM, segfault), so
+	// watch `exited` instead.
+	let exited = false;
+	child.exited.then(() => (exited = true));
 
 	const signals: NodeJS.Signals[] = ["SIGINT", "SIGTERM"];
 	let receivedSignal: NodeJS.Signals | null = null;
@@ -191,7 +233,7 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 		const base = `http://localhost:${port}${currentBase()}`;
 		let ready = false;
 		const deadline = Date.now() + 10_000;
-		while (Date.now() < deadline) {
+		while (Date.now() < deadline && !exited) {
 			try {
 				const res = await fetch(`${base}/_health`);
 				if (res.ok) {
@@ -204,8 +246,14 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 			await Bun.sleep(50);
 		}
 
-		if (!ready) {
-			console.error("❌ Prerender server failed to start");
+		if (!ready || exited) {
+			const why = child.signalCode ?? `exit code ${child.exitCode ?? "none"}`;
+			if (require404)
+				throw new Error(
+					`Prerender server failed to start (${why}), so 404.html could not be built, but ` +
+						`wrangler sets not_found_handling "404-page". Fix the server, or add public/404.html.`,
+				);
+			console.error(`❌ Prerender server failed to start (${why})`);
 			return;
 		}
 
@@ -286,7 +334,38 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 			Array.from({ length: Math.min(PRERENDER_CONCURRENCY, targets.length) }, worker),
 		);
 
-		console.log("✅ Prerendering complete");
+		// Static hosts (Cloudflare assets) serve index.html with a 200 for unknown
+		// paths unless a 404.html exists. Save the server's own 404 page while it's up.
+		// Goes to dist/static, not prerendered/, so the Bun server doesn't route /404
+		// to it, though it (and static hosts) still serve /404.html with a 200.
+		// Skipped on Workers: the worker answers unknown paths, and an uploaded file
+		// would only add that soft 404. A public/404.html overwrites it.
+		// One probe, one locale: add per-locale probe paths (e.g. /id/404.html) when asked.
+		if (target !== "workers")
+			try {
+				const res = await fetch(`${base}/__bosia-404-probe`, {
+					signal: AbortSignal.timeout(PRERENDER_TIMEOUT),
+				});
+				if (res.status !== 404) throw new Error(`expected a 404 page, got ${res.status}`);
+				// No +error.svelte (or it crashed) → plain-text "Not Found", not a page.
+				if (!res.headers.get("content-type")?.includes("text/html"))
+					throw new Error(`expected an HTML 404 page, got ${res.headers.get("content-type")}`);
+				mkdirSync(`${OUT_DIR}/static`, { recursive: true });
+				writeFileSync(`${OUT_DIR}/static/404.html`, await res.text());
+				console.log(`   ✅ 404 page → ${OUT_DIR}/static/404.html`);
+			} catch (err) {
+				// Only a deploy that serves 404.html needs it; elsewhere (an app whose
+				// hooks redirect every request) a missing one is fine, so just warn.
+				const reason = (err as Error).message;
+				if (require404)
+					throw new Error(
+						`404.html could not be built (${reason}), but wrangler sets ` +
+							`not_found_handling "404-page". Make unknown paths answer 404, or add public/404.html.`,
+					);
+				console.warn(`   ⚠️  404.html skipped: ${reason}`);
+			}
+
+		if (targets.length) console.log("✅ Prerendering complete");
 	} finally {
 		for (const sig of signals) process.off(sig, onSignal);
 		child.kill();

package/src/core/renderer.ts

@@ -45,7 +45,7 @@ import { reportDevErrorFromCatch } from "./devErrorReport.ts";
 import { dev500Response } from "./dev-500.ts";
 import type { BosiaPlugin, RenderContext } from "./types/plugin.ts";
 import { getAppHtmlSegments } from "./appHtml.ts";
-import { hasTitle } from "./headScan.ts";
+import { errorTitle, hasTitle } from "./headScan.ts";
 import type { AppHtmlSegments } from "./appHtml.ts";
 
 // Shared, stateless — one instance instead of a fresh allocation per stream.
@@ -1217,7 +1217,7 @@ export async function renderErrorPage(
 	// head, so a real title hasTitle misses still comes first), except when
 	// app.html has its own <title>: that would come first, so the status title
 	// takes the metadata slot ahead of it instead.
-	const statusTitle = `${status} — ${message}`;
+	const statusTitle = errorTitle(status, message);
 	const errMeta = (head: string): Metadata | null =>
 		appHtmlHasTitle(appHtmlSegments) && !hasTitle(head) ? { title: statusTitle } : null;