bosia 1.1.1 → 1.1.3

package/package.json

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

package/src/core/build.ts

@@ -17,7 +17,9 @@ import { generateRouteTypes, ensureRootDirs } from "./routeTypes.ts";
 import { makeBosiaPlugin } from "./plugin.ts";
 import { makeBosiaSvelteCompiler, svelteMapCache } from "./svelteCompiler.ts";
 import { finalizeComponentCss } from "./componentCss.ts";
+import { buildPreloadMap } from "./preloadMap.ts";
 import { prerenderStaticRoutes, generateStaticSite } from "./prerender.ts";
+import { precompressDir } from "./precompress.ts";
 import { loadEnv, classifyEnvVars } from "./env.ts";
 import { generateEnvModules } from "./envCodegen.ts";
 import { BOSIA_NODE_PATH, OUT_DIR, resolveBosiaBin, toPosix } from "./paths.ts";
@@ -252,6 +254,8 @@ const clientPromise = Bun.build({
 	// Chunks are named after their source, which for routes is `+page` — and
 	// Cloudflare's asset server answers a `+` in the path with a redirect.
 	naming: { entry: "[name]-[hash].[ext]", chunk: "chunk-[hash].[ext]" },
+	// Read below to map each route to the chunks it needs (see preloadMap.ts).
+	metafile: true,
 	minify: isProduction,
 	sourcemap: isProduction ? "none" : "linked",
 	define: {
@@ -346,14 +350,20 @@ const serverEntry = serverEntryOutput ? basename(serverEntryOutput.path) : "inde
 
 // 8. Write dist/manifest.json
 mkdirSync(OUT_DIR, { recursive: true });
+const entryFile =
+	clientEntry ??
+	jsFiles.find((f) => f === "hydrate.js") ??
+	jsFiles.find((f) => f.startsWith("hydrate")) ??
+	"hydrate.js";
 const distManifest = {
 	js: jsFiles,
 	css: cssFiles,
-	entry:
-		clientEntry ??
-		jsFiles.find((f) => f === "hydrate.js") ??
-		jsFiles.find((f) => f.startsWith("hydrate")) ??
-		"hydrate.js",
+	entry: entryFile,
+	// Per-route modulepreload list, so a page's code downloads with the entry
+	// instead of after it.
+	preload: clientResult.metafile
+		? buildPreloadMap(clientResult.metafile, manifest.pages, entryFile)
+		: {},
 	serverEntry,
 	target,
 	tw: twFile,
@@ -389,6 +399,25 @@ await prerenderStaticRoutes(manifest);
 // 10. Generate static site output (HTML + client assets + public → dist/static/)
 generateStaticSite();
 
+// 10b. Precompress client assets + prerendered HTML (.br/.gz siblings) for the
+// Bun server. Runs after the static mirror so dist/static — the Workers upload
+// and static-host output — stays free of them; Workers' edge compresses itself.
+// public/ is left raw: mostly already-compressed images, and it is the app's
+// source dir. Precompress into dist/static and serve from there if that bites.
+if (isProduction && target !== "workers") {
+	const t0 = performance.now();
+	const results = await Promise.all([
+		precompressDir(join(OUT_DIR, "client")),
+		precompressDir(join(OUT_DIR, "prerendered")),
+	]);
+	const files = results.reduce((n, r) => n + r.files, 0);
+	const raw = results.reduce((n, r) => n + r.rawBytes, 0);
+	const br = results.reduce((n, r) => n + r.brBytes, 0);
+	console.log(
+		`✅ Precompressed ${files} files: ${Math.round(raw / 1024)}KB → ${Math.round(br / 1024)}KB br (${Math.round(performance.now() - t0)}ms)`,
+	);
+}
+
 // 11. Workers target: a second server bundle for Cloudflare. The Bun one above
 // still exists — prerender just booted it to crawl static routes.
 if (target === "workers") await buildWorker();

package/src/core/cache.ts

@@ -8,11 +8,10 @@
 // node:crypto / node:zlib rather than Bun.* — the same code runs on Bun and on
 // Cloudflare Workers (nodejs_compat), and both stay sync there.
 import { createHash } from "node:crypto";
-import { brotliCompressSync, gzipSync, constants as zlibConstants } from "node:zlib";
 import type { Cookies, LoaderDeps } from "./hooks.ts";
 import type { CookieJar } from "./cookies.ts";
 import { dedupKey } from "./dedup.ts";
-import { compressionOn, PRECOMPRESSED } from "./html.ts";
+import { compressionOn, encodeBytes, PRECOMPRESSED } from "./html.ts";
 
 // ─── Config ──────────────────────────────────────────────
 
@@ -280,7 +279,7 @@ function cacheDeleteIndexOnly(key: string, entry: CacheEntry): void {
 
 // ─── Compression helpers ─────────────────────────────────
 
-/** Build gzip + brotli copies of body. Sync, runs in microtask. */
+/** Build gzip + brotli copies of body. Sync — call it from `deferCacheWrite`. */
 export function buildCompressedVariants(body: Bytes): {
 	gzip: Bytes | null;
 	brotli: Bytes | null;
@@ -290,24 +289,35 @@ export function buildCompressedVariants(body: Bytes): {
 	let gzip: Bytes | null = null;
 	let brotli: Bytes | null = null;
 	try {
-		gzip = new Uint8Array(gzipSync(body)) as Bytes;
+		gzip = encodeBytes(body, "gzip");
 	} catch {
 		gzip = null;
 	}
 	try {
-		// Quality 5: ~20x faster than the default 11, still beats gzip on size.
-		// This runs sync in a microtask — 11 would block the event loop ~17ms/500KB.
-		brotli = new Uint8Array(
-			brotliCompressSync(body, {
-				params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 5 },
-			}),
-		) as Bytes;
+		// Quality 5 (set in encodeBytes): ~20x faster than the default 11, still
+		// beats gzip on size. 11 would block the event loop ~17ms/500KB.
+		brotli = encodeBytes(body, "br");
 	} catch {
 		brotli = null;
 	}
 	return { gzip, brotli };
 }
 
+/**
+ * Run a cache write after the current response has gone out. A microtask
+ * would not: it fires before the awaiting caller resumes, so gzip + brotli of
+ * the body ran ahead of the first byte. `setImmediate` yields to I/O first.
+ * Workers keeps the microtask — it compresses nothing (the edge does), and a
+ * timer after the response returns is not guaranteed to run there.
+ *
+ * On a miss the variant sent to the client is compressed twice (response +
+ * cache). Off the critical path; pass the built variant in if it ever shows up.
+ */
+export function deferCacheWrite(fn: () => void | Promise<void>): void {
+	if (compressionOn) setImmediate(fn);
+	else queueMicrotask(fn);
+}
+
 /** Concatenate multiple Uint8Array chunks into one buffer. */
 export function concatChunks(chunks: Uint8Array[]): Bytes {
 	let total = 0;

package/src/core/html.ts

@@ -1,4 +1,4 @@
-import { gzipSync } from "node:zlib";
+import { brotliCompressSync, gzipSync, constants as zlibConstants } from "node:zlib";
 
 import { readArtifact } from "./artifacts.ts";
 import { nonceAttr } from "./csp.ts";
@@ -24,6 +24,8 @@ export const distManifest: {
 	basePath?: string;
 	/** PUBLIC_* (non-static) names declared in .env files, stamped by the build. */
 	publicEnv?: string[];
+	/** Client chunks per route pattern, stamped by the build (see preloadMap.ts). */
+	preload?: Record<string, string[]>;
 } = readArtifact("manifest.json") ?? { js: [], css: [], entry: "hydrate.js" };
 
 export const isDev = process.env.NODE_ENV !== "production";
@@ -55,6 +57,17 @@ export function baseScript(nonce?: string): string {
 		: "";
 }
 
+/** modulepreload links for the chunks `pattern` needs to hydrate, so they
+ *  download alongside the entry instead of after it has run. Hashed names, so
+ *  no buster (same reason as ENTRY). Unknown pattern or an older dist/ without
+ *  the `preload` field → nothing, and the page loads as it did before. */
+export function routePreloadLinks(pattern?: string): string {
+	if (!pattern) return "";
+	return (distManifest.preload?.[pattern] ?? [])
+		.map((f) => `\n  <link rel="modulepreload" href="${DIST}/${f}">`)
+		.join("");
+}
+
 /** Tailwind stylesheet link. Content-hashed name needs no cache buster — the
  *  hash IS the buster. Fallback keeps older dist/ artifacts (no `tw` field) styled. */
 function twCssLink(): string {
@@ -161,6 +174,7 @@ export function buildHtml(
 	bodyEndExtras?: string[],
 	segments?: AppHtmlSegments,
 	metadata?: Metadata | null,
+	pattern?: string,
 ): string {
 	// An app writes <a href="/masuk">; under a base the browser has to be handed
 	// /sso/masuk or it walks off this app entirely. Only the rendered markup is
@@ -208,6 +222,11 @@ export function buildHtml(
 
 	const bodyEnd = bodyEndExtras?.length ? "\n  " + bodyEndExtras.join("\n  ") : "";
 
+	// Same hints the streaming shell sends; skipped when no JS runs at all.
+	const preloads = csr
+		? `  <link rel="modulepreload" href="${ENTRY}">${routePreloadLinks(pattern)}\n`
+		: "";
+
 	if (segments) {
 		const safeKey = safeLang(lang);
 		const headOpenInterpolated = interpolateSegment(segments.headOpen, {
@@ -225,6 +244,7 @@ export function buildHtml(
 			`\n  ${faviconLine}${twCssLink()}\n` +
 			componentCssLinks() +
 			`  <script${n}>${THEME_INIT_JS}</script>\n` +
+			preloads +
 			`  ${fallbackTitle}${metaTags}${head}` +
 			headCloseInterpolated +
 			(body ? "" : `\n${SPINNER}`) +
@@ -243,7 +263,7 @@ export function buildHtml(
 ${metaTags}  ${head}
   ${twCssLink()}
 ${componentCssLinks()}  <script${n}>${THEME_INIT_JS}</script>
-</head>
+${preloads}</head>
 <body>
   <div id="app">${body}</div>${scripts}${bodyEnd}
 </body>
@@ -257,6 +277,7 @@ export function buildHtmlShellOpen(
 	lang?: string,
 	nonce?: string,
 	segments?: AppHtmlSegments,
+	pattern?: string,
 ): string {
 	const key = safeLang(lang);
 	const n = nonceAttr(nonce);
@@ -270,7 +291,8 @@ export function buildHtmlShellOpen(
 			`\n  ${faviconLine}${twCssLink()}\n` +
 			componentCssLinks() +
 			`  <script${n}>${THEME_INIT_JS}</script>\n` +
-			`  <link rel="modulepreload" href="${ENTRY}">`
+			`  <link rel="modulepreload" href="${ENTRY}">` +
+			routePreloadLinks(pattern)
 		);
 	}
 
@@ -282,7 +304,8 @@ export function buildHtmlShellOpen(
 		`  ${twCssLink()}\n` +
 		componentCssLinks() +
 		`  <script${n}>${THEME_INIT_JS}</script>\n` +
-		`  <link rel="modulepreload" href="${ENTRY}">`
+		`  <link rel="modulepreload" href="${ENTRY}">` +
+		routePreloadLinks(pattern)
 	);
 }
 
@@ -441,12 +464,43 @@ export function disableCompression(): void {
 // Shared, stateless — one instance instead of a fresh allocation per response.
 const textEncoder = new TextEncoder();
 
+export type Encoding = "br" | "gzip";
+
+/** Best encoding the client accepts — brotli over gzip, null for identity.
+ *  A substring check, not q-value parsing: no browser sends `br;q=0`. */
+export function pickEncoding(accept: string | null): Encoding | null {
+	if (!accept) return null;
+	if (accept.includes("br")) return "br";
+	if (accept.includes("gzip")) return "gzip";
+	return null;
+}
+
+// Quality 5: close to gzip's speed with a better ratio — runs per request.
+const BROTLI_RUNTIME = { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 5 } };
+
+/** Compress bytes on the request path. The one place runtime quality is set —
+ *  cache.ts builds its stored variants through here too. */
+export function encodeBytes(bytes: Uint8Array, enc: Encoding): Uint8Array<ArrayBuffer> {
+	const out = enc === "br" ? brotliCompressSync(bytes, BROTLI_RUNTIME) : gzipSync(bytes);
+	return new Uint8Array(out) as Uint8Array<ArrayBuffer>;
+}
+
 export function compress(
 	body: string,
 	contentType: string,
 	req: Request,
 	status = 200,
 	extraHeaders?: Record<string, string>,
+): Response {
+	return compressBytes(textEncoder.encode(body), contentType, req, status, extraHeaders);
+}
+
+export function compressBytes(
+	bytes: Uint8Array<ArrayBuffer>,
+	contentType: string,
+	req: Request,
+	status = 200,
+	extraHeaders?: Record<string, string>,
 ): Response {
 	// Base keys lowercased so lowercased extraHeaders (e.g. loader setHeaders)
 	// override them instead of getting comma-joined by Headers.
@@ -455,15 +509,14 @@ export function compress(
 		vary: "Accept-Encoding",
 		...extraHeaders,
 	};
-	const accept = req.headers.get("accept-encoding") ?? "";
-	const bytes = textEncoder.encode(body);
+	const enc = pickEncoding(req.headers.get("accept-encoding"));
 	// Skip compression in dev — the dev proxy's fetch() auto-decompresses gzip
 	// responses but keeps the Content-Encoding header, causing ERR_CONTENT_DECODING_FAILED.
-	if (compressionOn && !isDev && bytes.length > GZIP_MIN_BYTES && accept.includes("gzip")) {
-		return new Response(gzipSync(bytes), {
+	if (compressionOn && !isDev && enc && bytes.length > GZIP_MIN_BYTES) {
+		return new Response(encodeBytes(bytes, enc), {
 			...PRECOMPRESSED,
 			status,
-			headers: { ...headers, "content-encoding": "gzip" },
+			headers: { ...headers, "content-encoding": enc },
 		});
 	}
 	return new Response(bytes, { status, headers });

package/src/core/plugins/server-timing.ts

@@ -10,9 +10,9 @@ export interface ServerTimingOptions {
 /**
  * Adds a `Server-Timing` response header that reports how long each request
  * spent inside the framework's handler. Measured from `onRequest` to
- * `onAfterHandle` — so for streaming SSR routes this is "time to start
- * streaming," not full end-to-end. Headers must flush before the body, so a
- * true end-to-end value cannot be reported in a response header.
+ * `onAfterHandle` — the time to build the response, not to deliver it. A
+ * streaming `+server.ts` route reports "time to start streaming". Headers must
+ * flush before the body, so a true end-to-end value cannot be reported here.
  */
 export function serverTiming(options: ServerTimingOptions = {}): BosiaPlugin {
 	const headerName = options.header ?? "Server-Timing";

package/src/core/precompress.ts

@@ -0,0 +1,82 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { extname, join } from "path";
+import { promisify } from "util";
+import { brotliCompress, gzip, constants as zlibConstants } from "node:zlib";
+
+// ─── Build-time Precompression ───────────────────────────
+// Writes `file.br` + `file.gz` next to each compressible build output so the
+// server hands out ready-made bytes (staticManifest.ts `serveStatic`) instead of
+// raw ones. Build time is paid once, so both run at max quality.
+
+const brotliAsync = promisify(brotliCompress);
+const gzipAsync = promisify(gzip);
+
+const COMPRESSIBLE = new Set([
+	".js",
+	".css",
+	".html",
+	".json",
+	".svg",
+	".txt",
+	".xml",
+	".webmanifest",
+	".map",
+]);
+
+// Same floor as the runtime compress(): below it the overhead beats the saving.
+const MIN_BYTES = 2048;
+
+function* files(dir: string): Generator<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 abs = join(dir, ent.name);
+		if (ent.isDirectory()) yield* files(abs);
+		else if (ent.isFile()) yield abs;
+	}
+}
+
+export type PrecompressStats = { files: number; rawBytes: number; brBytes: number };
+
+/**
+ * Precompress every compressible file under `dir`. A variant is only written
+ * when it is smaller than the original, so the server can trust any sibling it
+ * finds. Missing `dir` is a no-op.
+ */
+export async function precompressDir(dir: string): Promise<PrecompressStats> {
+	const stats: PrecompressStats = { files: 0, rawBytes: 0, brBytes: 0 };
+	const jobs: Promise<void>[] = [];
+	for (const abs of files(dir)) {
+		if (!COMPRESSIBLE.has(extname(abs))) continue;
+		if (statSync(abs).size < MIN_BYTES) continue;
+		jobs.push(
+			(async () => {
+				const raw = readFileSync(abs);
+				const [br, gz] = await Promise.all([
+					brotliAsync(raw, {
+						params: {
+							[zlibConstants.BROTLI_PARAM_QUALITY]: zlibConstants.BROTLI_MAX_QUALITY,
+							[zlibConstants.BROTLI_PARAM_SIZE_HINT]: raw.length,
+						},
+					}),
+					gzipAsync(raw, { level: 9 }),
+				]);
+				if (br.length < raw.length) writeFileSync(`${abs}.br`, br);
+				if (gz.length < raw.length) writeFileSync(`${abs}.gz`, gz);
+				stats.files++;
+				stats.rawBytes += raw.length;
+				stats.brBytes += Math.min(br.length, raw.length);
+			})(),
+		);
+	}
+	await Promise.all(jobs);
+	return stats;
+}

package/src/core/preloadMap.ts

@@ -0,0 +1,58 @@
+import { toPosix } from "./paths.ts";
+import type { PageRoute } from "./types.ts";
+
+/** The slice of Bun's `BuildMetafile` this module reads. */
+export interface PreloadMetafile {
+	outputs: Record<string, { entryPoint?: string; imports?: { path: string; kind: string }[] }>;
+}
+
+/**
+ * Client chunks each page route needs before it can hydrate, keyed by route
+ * pattern, as paths relative to `dist/client` (same shape as `manifest.js`).
+ *
+ * Without this the browser only learns about a route's code after the entry has
+ * run and `import()`ed it, and only learns about that chunk's own imports after
+ * it arrives — a serial waterfall during which clicks hit dead buttons. Emitting
+ * these as modulepreload links lets them download alongside the entry.
+ *
+ * Route chunks are found by their metafile `entryPoint` (Bun makes every
+ * dynamically imported route file its own entry chunk, named relative to the
+ * app root), then followed through static imports only — a `dynamic-import`
+ * edge is code the page may never ask for. The client entry is left out: the
+ * shell already preloads it.
+ */
+export function buildPreloadMap(
+	metafile: PreloadMetafile,
+	pages: Pick<PageRoute, "pattern" | "page" | "layouts">[],
+	entry: string,
+): Record<string, string[]> {
+	const clean = (p: string) => toPosix(p).replace(/^\.\//, "");
+	const outputs = new Map<string, { path: string; kind: string }[]>();
+	const chunkBySource = new Map<string, string>();
+	for (const [out, info] of Object.entries(metafile.outputs)) {
+		if (!out.endsWith(".js")) continue;
+		outputs.set(clean(out), info.imports ?? []);
+		if (info.entryPoint) chunkBySource.set(clean(info.entryPoint), clean(out));
+	}
+
+	const map: Record<string, string[]> = {};
+	for (const route of pages) {
+		const seen = new Set<string>([entry]);
+		const files: string[] = [];
+		const visit = (chunk: string) => {
+			if (seen.has(chunk)) return;
+			seen.add(chunk);
+			files.push(chunk);
+			for (const imp of outputs.get(chunk) ?? []) {
+				if (imp.kind === "import-statement") visit(clean(imp.path));
+			}
+		};
+		// Layouts first: they wrap the page, so hydration needs them just as much.
+		for (const src of [...route.layouts, route.page]) {
+			const chunk = chunkBySource.get(`src/routes/${toPosix(src)}`);
+			if (chunk) visit(chunk);
+		}
+		if (files.length) map[route.pattern] = files;
+	}
+	return map;
+}

package/src/core/renderer.ts

@@ -16,6 +16,7 @@ import {
 	collectTags,
 	computeCacheKey,
 	concatChunks,
+	deferCacheWrite,
 	serveCached,
 } from "./cache.ts";
 import type { CookieJar } from "./cookies.ts";
@@ -31,6 +32,7 @@ import {
 	buildMetadataChunk,
 	buildHtmlTail,
 	compress,
+	compressBytes,
 	isDev,
 } from "./html.ts";
 import type { Metadata } from "./hooks.ts";
@@ -640,7 +642,7 @@ export async function renderSSRStream(
 	// INVARIANT: releaseMiss must fire exactly once — a missed release() hangs
 	// coalesced waiters for the process lifetime. Every early return and throw
 	// below must stay inside this try; the cache-write path hands the release
-	// off to its cacheSet microtask by nulling releaseMiss first.
+	// off to its deferred cacheSet by nulling releaseMiss first.
 	try {
 		// ── Pre-stream phase: resolve metadata before committing to a 200 ──
 		// Errors here return a proper error response with correct status code.
@@ -761,7 +763,7 @@ export async function renderSSRStream(
 				);
 			}
 			const html =
-				buildHtmlShellOpen(metadata?.lang, nonce, appHtmlSegments) +
+				buildHtmlShellOpen(metadata?.lang, nonce, appHtmlSegments, route.pattern) +
 				buildMetadataChunk(metadata, headExtras, appHtmlSegments) +
 				buildHtmlTail(
 					"",
@@ -777,9 +779,7 @@ export async function renderSSRStream(
 					data.layoutDeps,
 					appHtmlSegments,
 				);
-			return new Response(html, {
-				headers: { "content-type": "text/html; charset=utf-8", ...data.loaderHeaders },
-			});
+			return compress(html, "text/html; charset=utf-8", req, 200, data.loaderHeaders);
 		}
 
 		// Render-first: run render() before committing to a 200. Failure → proper error page
@@ -817,9 +817,19 @@ export async function renderSSRStream(
 			);
 		}
 
-		// Pre-compute all chunks; pull-based stream gives Bun native backpressure.
+		// Every chunk is built before the first byte, so the body goes out whole and
+		// compressed — a stream here never streamed, it only skipped compression.
+		// Truly progressive SSR (ROADMAP) would pipe a stream through
+		// CompressionStream instead.
 		const chunks: Uint8Array[] = [
-			enc.encode(buildHtmlShellOpen(metadata?.lang, nonce, appHtmlSegments)),
+			enc.encode(
+				buildHtmlShellOpen(
+					metadata?.lang,
+					nonce,
+					appHtmlSegments,
+					data.csr ? route.pattern : undefined,
+				),
+			),
 			enc.encode(buildMetadataChunk(metadata, headExtras, appHtmlSegments)),
 			enc.encode(
 				buildHtmlTail(
@@ -839,22 +849,23 @@ export async function renderSSRStream(
 			),
 		];
 
-		// ── Response cache: write after chunks built, before stream creation ──
+		const fullBody = concatChunks(chunks);
+
+		// ── Response cache: write after the response has gone out ──
 		// Skip if the handler set cookies — cached response can't reproduce
-		// per-request Set-Cookie headers. Compression runs in a microtask so
-		// the response goes out first.
+		// per-request Set-Cookie headers. deferCacheWrite runs the variant
+		// compression after this response is flushed, not ahead of it.
 		if (cacheable && cacheKey && (cookies as any).outgoing?.length === 0) {
-			const fullBody = concatChunks(chunks);
 			// Oversized bodies skip early so they never pay compression; cacheSet
 			// re-checks as the authoritative guard.
 			if (CACHE_MAX_BODY_BYTES === 0 || fullBody.length <= CACHE_MAX_BODY_BYTES) {
 				const tags = collectTags(data.layoutDeps ?? null, data.pageDeps ?? null);
 				const keyForWrite = cacheKey;
-				// Hand the gate release to the write microtask: waiters resume only
+				// Hand the gate release to the deferred write: waiters resume only
 				// after cacheSet ran, so their re-check hits.
 				const rel = releaseMiss;
 				releaseMiss = null;
-				queueMicrotask(() => {
+				deferCacheWrite(() => {
 					try {
 						const { gzip, brotli } = buildCompressedVariants(fullBody);
 						cacheSet(
@@ -877,35 +888,7 @@ export async function renderSSRStream(
 			}
 		}
 
-		let i = 0;
-		let cancelled = false;
-		const onAbort = () => {
-			cancelled = true;
-		};
-		req.signal.addEventListener("abort", onAbort, { once: true });
-
-		const stream = new ReadableStream<Uint8Array>({
-			pull(controller) {
-				if (cancelled || i >= chunks.length) {
-					controller.close();
-					req.signal.removeEventListener("abort", onAbort);
-					return;
-				}
-				controller.enqueue(chunks[i++]);
-				if (i >= chunks.length) {
-					controller.close();
-					req.signal.removeEventListener("abort", onAbort);
-				}
-			},
-			cancel() {
-				cancelled = true;
-				req.signal.removeEventListener("abort", onAbort);
-			},
-		});
-
-		return new Response(stream, {
-			headers: { "content-type": "text/html; charset=utf-8", ...data.loaderHeaders },
-		});
+		return compressBytes(fullBody, "text/html; charset=utf-8", req, 200, data.loaderHeaders);
 	} finally {
 		releaseMiss?.();
 	}
@@ -1031,6 +1014,7 @@ export async function renderPageWithFormData(
 			bodyEndExtras,
 			appHtmlSegments,
 			metadata,
+			route.pattern,
 		);
 		return compress(html, "text/html; charset=utf-8", req, status, data.loaderHeaders);
 	}
@@ -1065,6 +1049,7 @@ export async function renderPageWithFormData(
 		bodyEndExtras,
 		appHtmlSegments,
 		metadata,
+		route.pattern,
 	);
 	return compress(html, "text/html; charset=utf-8", req, status, data.loaderHeaders);
 }

package/src/core/server.ts

@@ -25,7 +25,12 @@ import { dev500WithPlugins } from "./dev-500.ts";
 import { OUT_DIR } from "./paths.ts";
 import { stripBase, withBase } from "./basePath.ts";
 import { currentBase } from "./appBase.ts";
-import { buildPrerenderManifest, buildStaticManifest, lookupStatic } from "./staticManifest.ts";
+import {
+	buildPrerenderManifest,
+	buildStaticManifest,
+	lookupStatic,
+	serveStatic,
+} from "./staticManifest.ts";
 import { dedup } from "./dedup.ts";
 import {
 	CACHE_ENABLED,
@@ -35,6 +40,7 @@ import {
 	cacheSet,
 	coalesceMiss,
 	computeCacheKey,
+	deferCacheWrite,
 	serveCached,
 	warnUncoveredCookies,
 } from "./cache.ts";
@@ -410,12 +416,7 @@ async function resolve(event: RequestEvent): Promise<Response> {
 	// api-before-static ordering intact for every user-facing path.
 	if (staticManifest && (path.startsWith("/dist/") || path.startsWith("/__bosia/"))) {
 		const hit = lookupStatic(staticManifest, path);
-		if (hit) {
-			return new Response(
-				Bun.file(hit.absPath),
-				hit.cacheControl ? { headers: { "Cache-Control": hit.cacheControl } } : undefined,
-			);
-		}
+		if (hit) return serveStatic(hit, request);
 	}
 
 	// API routes (+server.ts) — resolve with `.json` alias preference.
@@ -428,7 +429,7 @@ async function resolve(event: RequestEvent): Promise<Response> {
 		if (warmingUp) return new Response(null, { status: 404 });
 		// INVARIANT: once set, releaseApiMiss must fire exactly once — a missed
 		// release() hangs coalesced waiters for the process lifetime. The cache
-		// write path hands it off to its microtask by nulling it first.
+		// write path hands it off to its deferred write by nulling it first.
 		let releaseApiMiss: (() => void) | null = null;
 		try {
 			const mod = await apiMatch.route.module();
@@ -518,11 +519,11 @@ async function resolve(event: RequestEvent): Promise<Response> {
 				const extraHeaders = captureCacheableHeaders(response.headers);
 				const contentType = responseContentType || "application/octet-stream";
 				const keyForWrite = apiCacheKey;
-				// Hand the gate release to the write microtask: waiters resume only
+				// Hand the gate release to the deferred write: waiters resume only
 				// after the cacheSet attempt, so their re-check hits.
 				const rel = releaseApiMiss;
 				releaseApiMiss = null;
-				queueMicrotask(async () => {
+				deferCacheWrite(async () => {
 					try {
 						const buf = new Uint8Array(await cloned.arrayBuffer());
 						// Oversized bodies skip early so they never pay compression;
@@ -588,12 +589,7 @@ async function resolve(event: RequestEvent): Promise<Response> {
 		// 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,
-				);
-			}
+			if (hit) return serveStatic(hit, request);
 			return new Response("Not Found", { status: 404 });
 		}
 		// Dev: keep the per-request fallthrough so files dropped into `public/`
@@ -646,13 +642,11 @@ async function resolve(event: RequestEvent): Promise<Response> {
 		// Keys come from a boot-time walk of `dist/prerendered/`, not from the
 		// URL, so no safePath needed — a non-matching path is just a miss.
 		const key = path === "/" ? "/" : path.replace(/\/$/, "");
-		const abs = prerenderManifest.get(key);
-		if (abs) {
-			return new Response(Bun.file(abs), {
-				headers: {
-					"Content-Type": "text/html; charset=utf-8",
-					"Cache-Control": "public, max-age=3600",
-				},
+		const hit = prerenderManifest.get(key);
+		if (hit) {
+			return serveStatic(hit, request, {
+				"Content-Type": "text/html; charset=utf-8",
+				"Cache-Control": "public, max-age=3600",
 			});
 		}
 	}

package/src/core/staticManifest.ts

@@ -1,7 +1,9 @@
 import { existsSync, readdirSync, statSync } from "fs";
 import { basename, join, resolve as resolvePath } from "path";
+import { PRECOMPRESSED, pickEncoding } from "./html.ts";
 
-export type StaticEntry = { absPath: string; cacheControl?: string };
+/** `br`/`gz`: absolute paths of build-time precompressed siblings (precompress.ts). */
+export type StaticEntry = { absPath: string; cacheControl?: string; br?: string; gz?: string };
 export type StaticManifest = Map<string, StaticEntry>;
 
 const HASHED_BASENAME = /\-[a-z0-9]{8,}\.[a-z]+$/;
@@ -49,9 +51,16 @@ export function buildStaticManifest(outDir: string): StaticManifest {
 
 	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 });
+		for (const entry of withSiblings(walk(clientRoot))) {
+			const cacheControl = HASHED_BASENAME.test(basename(entry.rel))
+				? IMMUTABLE_CACHE
+				: DEFAULT_CACHE;
+			addOnce(manifest, `/dist/client/${entry.rel}`, {
+				absPath: entry.abs,
+				cacheControl,
+				br: entry.br,
+				gz: entry.gz,
+			});
 		}
 	}
 
@@ -99,6 +108,54 @@ export function buildStaticManifest(outDir: string): StaticManifest {
 	return manifest;
 }
 
+/**
+ * Fold `x.br` / `x.gz` into the entry for `x`. The variants are not URLs of
+ * their own — a request for `/chunk.js.br` is a miss, like any file the build
+ * never meant to publish. A `.br` with no original is kept as a plain file.
+ */
+function withSiblings(
+	all: Iterable<{ abs: string; rel: string }>,
+): Array<{ abs: string; rel: string; br?: string; gz?: string }> {
+	const list = [...all];
+	const byRel = new Map(list.map((f) => [f.rel, f]));
+	const out: Array<{ abs: string; rel: string; br?: string; gz?: string }> = [];
+	for (const f of list) {
+		const ext = f.rel.endsWith(".br") ? ".br" : f.rel.endsWith(".gz") ? ".gz" : null;
+		if (ext && byRel.has(f.rel.slice(0, -ext.length))) continue;
+		out.push({
+			...f,
+			br: byRel.get(`${f.rel}.br`)?.abs,
+			gz: byRel.get(`${f.rel}.gz`)?.abs,
+		});
+	}
+	return out;
+}
+
+/**
+ * Response for a manifest hit, precompressed when the build left a variant the
+ * client accepts. Content-Type comes from the original — `Bun.file("x.js.br")`
+ * would infer the wrong one. `Vary` only when variants exist: a raw-only file
+ * answers every client the same way.
+ */
+export function serveStatic(
+	entry: StaticEntry,
+	req: Request,
+	headers: Record<string, string> = {},
+): Response {
+	const out: Record<string, string> = { ...headers };
+	if (entry.cacheControl) out["Cache-Control"] = entry.cacheControl;
+	if (!entry.br && !entry.gz) return new Response(Bun.file(entry.absPath), { headers: out });
+
+	out["Vary"] = "Accept-Encoding";
+	const enc = pickEncoding(req.headers.get("accept-encoding"));
+	const variant = enc === "br" ? (entry.br ?? entry.gz) : enc === "gzip" ? entry.gz : undefined;
+	if (!variant) return new Response(Bun.file(entry.absPath), { headers: out });
+
+	out["Content-Type"] ??= Bun.file(entry.absPath).type;
+	out["Content-Encoding"] = variant === entry.br ? "br" : "gzip";
+	return new Response(Bun.file(variant), { ...PRECOMPRESSED, headers: out });
+}
+
 export function lookupStatic(manifest: StaticManifest, urlPath: string): StaticEntry | null {
 	const raw = urlPath.split("?")[0];
 	// Manifest keys are raw filenames; URLs arrive percent-encoded.
@@ -117,10 +174,10 @@ export function lookupStatic(manifest: StaticManifest, urlPath: string): StaticE
  * On collision the `…/index.html` variant wins (mirrors the old runtime
  * candidate order). Replaces per-request `Bun.file().exists()` probes.
  */
-export function buildPrerenderManifest(outDir: string): Map<string, string> {
-	const manifest = new Map<string, string>();
+export function buildPrerenderManifest(outDir: string): Map<string, StaticEntry> {
+	const manifest = new Map<string, StaticEntry>();
 	const root = join(resolvePath(outDir), "prerendered");
-	for (const { abs, rel } of walk(root)) {
+	for (const { abs, rel, br, gz } of withSiblings(walk(root))) {
 		if (!rel.endsWith(".html")) continue;
 		let key: string;
 		let isIndex = false;
@@ -133,7 +190,7 @@ export function buildPrerenderManifest(outDir: string): Map<string, string> {
 		} else {
 			key = `/${rel.slice(0, -".html".length)}`;
 		}
-		if (isIndex || !manifest.has(key)) manifest.set(key, abs);
+		if (isIndex || !manifest.has(key)) manifest.set(key, { absPath: abs, br, gz });
 	}
 	return manifest;
 }