swift-rust 1.3.0 → 1.4.0

package/bin/build.mjs

@@ -13,6 +13,7 @@ import {
 } from "node:fs";
 import { join, resolve, dirname, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
 const cwd = process.cwd();
 const APP_DIR_CANDIDATES = [resolve(cwd, "src", "app"), resolve(cwd, "app")];
@@ -22,6 +23,260 @@ const OUT_DIR = resolve(cwd, ".vercel", "output");
 const STATIC_DIR = join(OUT_DIR, "static");
 const RUNTIME_DIR = resolve(fileURLToPath(import.meta.url), "..", "runtime");
 
+const ROUTING_EXTS = [".tsx", ".ts", ".jsx", ".js"];
+
+// Scan a file's leading directives for a runtime / guard opt-in.
+function scanFileDirectives(file) {
+  const out = { runtime: null, guard: false };
+  try {
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+      const t = line.trim();
+      if (!t || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
+      const m = t.match(/^["']use (bun|edge|node|worker|guard)["'];?$/);
+      if (m) {
+        if (m[1] === "guard") out.guard = true;
+        else if (!out.runtime) out.runtime = m[1];
+        continue;
+      }
+      if (/^["']use [a-z]+["'];?$/.test(t)) continue;
+      break;
+    }
+  } catch {}
+  return out;
+}
+
+// Source-level detection of a route's runtime/guard opt-in (page + layouts),
+// so dynamic routes are emitted even when a build-time GET redirects.
+function scanDirectives(pageFile) {
+  const { layouts } = collectChainFiles(pageFile);
+  let runtime = null;
+  let guard = false;
+  for (const f of [pageFile, ...layouts]) {
+    const d = scanFileDirectives(f);
+    if (d.runtime && !runtime) runtime = d.runtime;
+    if (d.guard) guard = true;
+  }
+  return { runtime, guardEnabled: guard };
+}
+
+function findRoutingFile(dir, base) {
+  for (const ext of ROUTING_EXTS) {
+    const f = join(dir, `${base}${ext}`);
+    if (existsSync(f)) return f;
+  }
+  return null;
+}
+
+// Collect the routing files along a page's dir chain (outer → inner) plus the
+// URL pattern segments (with [param] markers preserved). Mirrors the dev
+// server's pipeline so the emitted function has the same behavior.
+function collectChainFiles(pageFile) {
+  const layouts = []; // { file, slots: [{ name, file }] }
+  const proxies = [];
+  const schemas = [];
+  const guards = [];
+  const loaders = [];
+  let actionFile = null;
+  let queryFile = null;
+  let stateFile = null;
+  let seoFile = null;
+  let i18nFile = null;
+  let revalidateFile = null;
+  const pattern = [];
+  const rel = dirname(pageFile).slice(APP_DIR.length).replace(/^[/\\]/, "");
+  const segs = rel ? rel.split(sep) : [];
+  if (APP_DIR.endsWith(`${sep}app`) && dirname(APP_DIR).endsWith(`${sep}src`)) {
+    const rp = findRoutingFile(dirname(APP_DIR), "proxy");
+    if (rp) proxies.push(rp);
+  }
+  const slotsFor = (d) => {
+    const out = [];
+    try {
+      for (const e of readdirSync(d, { withFileTypes: true })) {
+        if (e.isDirectory() && e.name.startsWith("@")) {
+          const sd = join(d, e.name);
+          const file = findRoutingFile(sd, "page") || findRoutingFile(sd, "fragment") || findRoutingFile(sd, "default");
+          if (file) out.push({ name: e.name.slice(1), file });
+        }
+      }
+    } catch {}
+    return out;
+  };
+  let dir = APP_DIR;
+  const scan = (d, isLeaf) => {
+    const l = findRoutingFile(d, "layout");
+    if (l) layouts.push({ file: l, slots: slotsFor(d) });
+    const p = findRoutingFile(d, "proxy");
+    if (p) proxies.push(p);
+    const s = findRoutingFile(d, "schema");
+    if (s) schemas.push(s);
+    const g = findRoutingFile(d, "guard");
+    if (g) guards.push(g);
+    const ld = findRoutingFile(d, "loader");
+    if (ld) loaders.push(ld);
+    const q = findRoutingFile(d, "query");
+    if (q) queryFile = q;
+    const st = findRoutingFile(d, "state");
+    if (st) stateFile = st;
+    const se = findRoutingFile(d, "seo");
+    if (se) seoFile = se;
+    const i = findRoutingFile(d, "i18n");
+    if (i) i18nFile = i;
+    const rv = findRoutingFile(d, "revalidate");
+    if (rv) revalidateFile = rv;
+    if (isLeaf) {
+      const a = findRoutingFile(d, "action");
+      if (a) actionFile = a;
+    }
+  };
+  scan(dir, segs.length === 0);
+  for (let i = 0; i < segs.length; i++) {
+    dir = join(dir, segs[i]);
+    pattern.push(segs[i]);
+    scan(dir, i === segs.length - 1);
+  }
+  return { layouts, proxies, schemas, guards, loaders, actionFile, queryFile, stateFile, seoFile, i18nFile, revalidateFile, pattern };
+}
+
+function isClientPageFile(file) {
+  return scanFileDirectivesRaw(file).includes("client");
+}
+function scanFileDirectivesRaw(file) {
+  const found = [];
+  try {
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+      const t = line.trim();
+      if (!t || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
+      const m = t.match(/^["']use ([a-z]+)["'];?$/);
+      if (m) {
+        found.push(m[1]);
+        continue;
+      }
+      break;
+    }
+  } catch {}
+  return found;
+}
+
+// Build a client-island bundle for a "use client" page (served by the dev
+// server during build) and write it to the static output. Returns its URL.
+async function buildIslandAsset(pageFile) {
+  try {
+    const res = await fetch(`http://${HOST}:${PORT}/_swift-rust/island.js?p=${encodeURIComponent(pageFile)}`);
+    if (!res.ok) return null;
+    const code = await res.text();
+    const rel = `_swift-rust/island/${simpleHash(pageFile)}.js`;
+    writeRawFile(STATIC_DIR, rel, code);
+    return `/${rel}`;
+  } catch {
+    return null;
+  }
+}
+
+// Generate + bundle a Vercel function (.func) for one dynamic route.
+async function emitFunction({ route, funcRel, pageFile, runtime, head, guardEnabled, isClient, islandSrc }) {
+  if (typeof Bun === "undefined" || typeof Bun.build !== "function") return false;
+  const f = collectChainFiles(pageFile);
+  const fnCore = join(RUNTIME_DIR, "fn-core.mjs");
+  const imports = [`import { makeRouteHandler } from ${JSON.stringify(fnCore)};`];
+  let uid = 0;
+  const ns = (file) => {
+    const name = `__m${uid++}`;
+    imports.push(`import * as ${name} from ${JSON.stringify(file)};`);
+    return name;
+  };
+  const arr = (files) => `[${files.map((file) => ns(file)).join(", ")}]`;
+  const opt = (file) => (file ? ns(file) : "undefined");
+
+  // IMPORTANT: resolve every ns()/arr()/opt() (which append to `imports`)
+  // BEFORE joining `imports` — otherwise body-only modules go unimported.
+  const pageNs = ns(pageFile);
+  const layoutsArr = `[${f.layouts.map((l) => ns(l.file)).join(", ")}]`;
+  const slotsArr = `[${f.layouts.map((l) => `[${l.slots.map((s) => `{ name: ${JSON.stringify(s.name)}, mod: ${ns(s.file)} }`).join(", ")}]`).join(", ")}]`;
+  const proxiesArr = arr(f.proxies);
+  const schemasArr = arr(f.schemas);
+  const guardsArr = arr(f.guards);
+  const loadersArr = arr(f.loaders);
+  const actionNs = opt(f.actionFile);
+  const queryNs = opt(f.queryFile);
+  const stateNs = opt(f.stateFile);
+  const seoNs = opt(f.seoFile);
+  const i18nNs = opt(f.i18nFile);
+  const revNs = opt(f.revalidateFile);
+
+  const entry =
+    `${imports.join("\n")}\n` +
+    `const handler = makeRouteHandler({\n` +
+    `  page: ${pageNs}, layouts: ${layoutsArr}, layoutMetas: ${layoutsArr}, slots: ${slotsArr},\n` +
+    `  proxies: ${proxiesArr}, schemas: ${schemasArr}, guards: ${guardsArr}, guardEnabled: ${guardEnabled ? "true" : "false"},\n` +
+    `  action: ${actionNs}, loaders: ${loadersArr}, query: ${queryNs}, state: ${stateNs},\n` +
+    `  seo: ${seoNs}, i18n: ${i18nNs}, revalidate: ${revNs},\n` +
+    `  isClient: ${isClient ? "true" : "false"}, islandSrc: ${JSON.stringify(islandSrc || "")},\n` +
+    `  pattern: ${JSON.stringify(f.pattern)}, runtime: ${JSON.stringify(runtime)}, head: ${JSON.stringify(head)},\n` +
+    `});\n` +
+    (runtime === "bun" ? `export default { fetch: handler };\n` : `export default handler;\n`);
+
+  const rel = funcRel || (route === "/" ? "index.func" : `${route.replace(/^\//, "")}.func`);
+  const funcDir = join(OUT_DIR, "functions", rel);
+  mkdirSync(funcDir, { recursive: true });
+  const entryTmp = join(dirname(pageFile), `.__sr_fn_${process.pid}_${simpleHash(rel)}.js`);
+  writeFileSync(entryTmp, entry);
+  try {
+    const isEdge = runtime === "edge";
+    const result = await Bun.build({
+      entrypoints: [entryTmp],
+      target: isEdge ? "browser" : "node",
+      format: "esm",
+      minify: true,
+      external: isEdge ? ["react-dom/server"] : [],
+    });
+    if (!result.success) throw new AggregateError(result.logs, "function bundle failed");
+    const code = await result.outputs[0].text();
+    writeFileSync(join(funcDir, "index.js"), code);
+    const vcConfig = isEdge
+      ? { runtime: "edge", entrypoint: "index.js" }
+      : { runtime: "nodejs22.x", handler: "index.js", launcherType: "Nodejs", supportsResponseStreaming: true };
+    writeFileSync(join(funcDir, ".vc-config.json"), `${JSON.stringify(vcConfig, null, 2)}\n`);
+    return true;
+  } finally {
+    try {
+      unlinkSync(entryTmp);
+    } catch {}
+  }
+}
+
+// Vercel runs functions on Bun when vercel.json sets bunVersion. Ensure it's
+// present (preserving the rest of the file) so 'use bun' routes run on Bun.
+function ensureBunVersion() {
+  const file = resolve(cwd, "vercel.json");
+  let json = {};
+  if (existsSync(file)) {
+    try {
+      json = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      json = {};
+    }
+  }
+  if (json.bunVersion) return;
+  json.bunVersion = "1.x";
+  writeFileSync(file, `${JSON.stringify(json, null, 2)}\n`);
+  process.stdout.write(`  ${paint("cyan", "•")} set ${paint("bold", 'vercel.json "bunVersion": "1.x"')} for Bun functions\n`);
+}
+
+// Locate the bundled local fonts (installed @swift-rust/font, else monorepo).
+function resolveLocalFontDir() {
+  const candidates = [];
+  try {
+    const req = createRequire(import.meta.url);
+    const pkg = req.resolve("@swift-rust/font/package.json");
+    candidates.push(join(dirname(pkg), "src", "local"), join(dirname(pkg), "dist", "local"));
+  } catch {}
+  candidates.push(
+    resolve(fileURLToPath(import.meta.url), "..", "..", "..", "..", "packages", "font", "src", "local"),
+  );
+  return candidates.find((d) => existsSync(d)) ?? null;
+}
+
 const PORT_START = parseInt(process.env.SWIFT_RUST_BUILD_PORT || "47321", 10);
 const HOST = "127.0.0.1";
 let PORT = PORT_START;
@@ -57,6 +312,8 @@ function discoverPages(dir, base = "") {
   if (!existsSync(dir)) return pages;
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    // @slot dirs (parallel routes) are not URL segments — composed into layouts.
+    if (entry.name.startsWith("@")) continue;
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
       const catchAll = entry.name.match(CATCH_PARAM);
@@ -180,7 +437,13 @@ async function fetchRoute(pathname, timeoutMs = ROUTE_TIMEOUT_MS) {
       signal: controller.signal,
       redirect: "manual",
     });
-    return { status: res.status, body: await res.text() };
+    return {
+      status: res.status,
+      body: await res.text(),
+      runtime: res.headers.get("x-swift-rust-runtime") || "bun",
+      dynamic: res.headers.get("x-swift-rust-dynamic") === "1",
+      guardEnabled: res.headers.get("x-swift-rust-guard") === "1",
+    };
   } finally {
     clearTimeout(timer);
   }
@@ -258,7 +521,7 @@ async function localizeIslands(html) {
   return out;
 }
 
-function writeConfigJson(outDir, _hasPublic) {
+function writeConfigJson(outDir, _hasPublic, fnRoutes = []) {
   // Build Output API v3 config. Only schema-valid fields here — unknown
   // top-level fields or route properties are rejected at "Deploying outputs".
   const config = {
@@ -266,6 +529,8 @@ function writeConfigJson(outDir, _hasPublic) {
     routes: [
       { src: "/_swift-rust/static/(.*)", headers: { "Cache-Control": "public, max-age=31536000, immutable" } },
       { src: "/fonts/(.*)", headers: { "Cache-Control": "public, max-age=31536000, immutable" } },
+      // [param] / catch-all routes → their request-time function.
+      ...fnRoutes,
       { handle: "filesystem" },
       { src: "^(.*)$", status: 404, dest: "/404.html" },
     ],
@@ -313,10 +578,12 @@ async function main() {
     for (const r of routes) staticRoutes.push(r);
     process.stdout.write(`  ${paint("dim", "•")} catch-all ${paint("cyan", ca.base + "/[...]")}: ${paint("bold", String(routes.length))}\n`);
   }
+  const paramFns = []; // dynamic pages with no static params → request-time functions
   for (const dyn of dynamics) {
     const params = await enumerateParams(dyn);
     if (params.length === 0) {
-      process.stdout.write(`  ${paint("dim", "•")} dynamic ${paint("cyan", dyn.base + "/[" + dyn.paramName + "]")}: ${paint("yellow", "needs serverless function (skipped for v0.1.0)")}\n`);
+      paramFns.push(dyn);
+      process.stdout.write(`  ${paint("dim", "•")} dynamic ${paint("cyan", dyn.base + "/[" + dyn.paramName + "]")}: ${paint("cyan", "→ function")}\n`);
       continue;
     }
     const routes = routesFromParams(dyn.base, dyn.paramName, params);
@@ -324,6 +591,10 @@ async function main() {
     process.stdout.write(`  ${paint("dim", "•")} dynamic ${paint("cyan", dyn.base + "/[" + dyn.paramName + "]")}: ${paint("bold", String(routes.length))}\n`);
   }
 
+  // route → page file (for static-type routes that may opt into a runtime fn).
+  const routeToFile = new Map();
+  for (const p of pages) if (p.type === "static") routeToFile.set(p.route, p.file);
+
   const allRoutes = [...new Set(staticRoutes)].sort();
   process.stdout.write(`  ${paint("dim", "•")} total: ${paint("bold", String(allRoutes.length))}\n\n`);
 
@@ -336,18 +607,64 @@ async function main() {
   let okCount = 0;
   let skipCount = 0;
   let failCount = 0;
+  let fnCount = 0;
+  let usesBunFns = false;
+  let fallbackHead = null;
+  const fnConfigRoutes = [];
   try {
     await waitForServer();
     process.stdout.write(`  ${paint("green", "✓")} server ready\n\n`);
 
     for (const route of allRoutes) {
       try {
-        const { status, body } = await fetchRoute(route);
+        const { status, body, runtime, dynamic, guardEnabled } = await fetchRoute(route);
+        const pageFile = routeToFile.get(route);
+        const cleaned = status === 200 ? rewriteImageUrls(await localizeIslands(stripHmrScript(body))) : null;
+        if (cleaned && fallbackHead == null) {
+          fallbackHead = (cleaned.match(/<head>([\s\S]*?)<\/head>/i) || [, ""])[1];
+        }
+
+        // Decide if this route is a request-time function. Prefer the live
+        // headers (200 render); else fall back to a source directive scan so
+        // guarded routes that redirect a build-time GET still get a function.
+        let fnRuntime = null;
+        let fnGuard = false;
+        let fnHead = null;
+        if (dynamic && pageFile) {
+          fnRuntime = runtime;
+          fnGuard = guardEnabled;
+          fnHead = (cleaned?.match(/<head>([\s\S]*?)<\/head>/i) || [, ""])[1];
+        } else if (pageFile && status !== 404) {
+          const d = scanDirectives(pageFile);
+          if (d.runtime) {
+            fnRuntime = d.runtime;
+            fnGuard = d.guardEnabled;
+            fnHead = fallbackHead || "";
+          }
+        }
+
+        if (fnRuntime && pageFile) {
+          let emitted = false;
+          const isClient = isClientPageFile(pageFile);
+          const islandSrc = isClient ? await buildIslandAsset(pageFile) : null;
+          try {
+            emitted = await emitFunction({ route, pageFile, runtime: fnRuntime, head: fnHead, guardEnabled: fnGuard, isClient, islandSrc });
+          } catch (e) {
+            process.stdout.write(`      ${paint("dim", `fn emit failed: ${e?.message || e}`)}\n`);
+          }
+          if (emitted) {
+            fnCount++;
+            if (fnRuntime === "bun") usesBunFns = true;
+            process.stdout.write(`  ${paint("cyan", "ƒ")} ${route} ${paint("yellow", `[${fnRuntime}]`)}\n`);
+            continue;
+          }
+        }
+
         if (status === 200) {
-          const cleaned = rewriteImageUrls(await localizeIslands(stripHmrScript(body)));
           writeStaticFile(STATIC_DIR, route, cleaned);
           okCount++;
-          process.stdout.write(`  ${paint("green", "✓")} ${route}\n`);
+          const rt = runtime && runtime !== "bun" ? ` ${paint("yellow", `[${runtime}]`)}` : "";
+          process.stdout.write(`  ${paint("green", "✓")} ${route}${rt}\n`);
         } else if (status === 404) {
           skipCount++;
           process.stdout.write(`  ${paint("dim", "○")} ${route} ${paint("dim", "(404, skipped)")}\n`);
@@ -363,6 +680,32 @@ async function main() {
       }
     }
 
+    // [param] / catch-all routes with no static params → one request-time
+    // function each, matched via a config.json route.
+    for (const dyn of paramFns) {
+      const pageFile = dyn.file;
+      const relDir = dirname(pageFile).slice(APP_DIR.length).replace(/^[/\\]/, "").split(sep).join("/");
+      const funcRel = `${relDir}.func`;
+      const { runtime: dirRt, guardEnabled: dirGuard } = scanDirectives(pageFile);
+      const runtime = dirRt || "bun";
+      const isClient = isClientPageFile(pageFile);
+      const islandSrc = isClient ? await buildIslandAsset(pageFile) : null;
+      let emitted = false;
+      try {
+        emitted = await emitFunction({ funcRel, pageFile, runtime, head: fallbackHead || "", guardEnabled: dirGuard, isClient, islandSrc });
+      } catch (e) {
+        process.stdout.write(`      ${paint("dim", `fn emit failed: ${e?.message || e}`)}\n`);
+      }
+      if (emitted) {
+        fnCount++;
+        if (runtime === "bun") usesBunFns = true;
+        // src regex from the pattern segments; dest is the literal function path.
+        const src = `^/${relDir.split("/").map((s) => (s.startsWith("[...") ? "(.*)" : s.startsWith("[") ? "([^/]+)" : s)).join("/")}/?$`;
+        fnConfigRoutes.push({ src, dest: `/${relDir}` });
+        process.stdout.write(`  ${paint("cyan", "ƒ")} /${relDir} ${paint("yellow", `[${runtime}]`)}\n`);
+      }
+    }
+
     if (failCount > 0) {
       const tail = tailDevLog(30);
       if (tail.length) {
@@ -421,16 +764,29 @@ async function main() {
       process.stdout.write(`  ${paint("green", "✓")} _swift-rust/navigator.js\n`);
     }
 
-    writeConfigJson(OUT_DIR, hasPublic);
+    // Bundled local fonts — the dev server serves these from
+    // /_swift-rust/fonts/; emit them so deployed @font-face URLs resolve.
+    const fontDir = resolveLocalFontDir();
+    if (fontDir) {
+      cpSync(fontDir, join(STATIC_DIR, "_swift-rust", "fonts"), { recursive: true });
+      process.stdout.write(`  ${paint("green", "✓")} _swift-rust/fonts/\n`);
+    }
+
+    writeConfigJson(OUT_DIR, hasPublic, fnConfigRoutes);
 
     const total = Date.now() - start;
     const outRel = OUT_DIR.startsWith(cwd + sep) ? OUT_DIR.slice(cwd.length + 1) : OUT_DIR;
     const skippedPart = skipCount > 0 ? paint("dim", `${skipCount} skipped`) : "";
     const failedPart = failCount > 0 ? paint("yellow", `${failCount} failed`) : paint("dim", "0 failed");
-    const summary = `  ${paint("green", "✓")} ${okCount} ok  ${skippedPart}  ${failedPart}\n`;
+    const fnPart = fnCount > 0 ? `  ${paint("cyan", `${fnCount} function${fnCount === 1 ? "" : "s"}`)}` : "";
+    const summary = `  ${paint("green", "✓")} ${okCount} ok  ${skippedPart}  ${failedPart}${fnPart}\n`;
     process.stdout.write(`\n  ${paint("bold", "done")} ${paint("dim", "in " + fmtMs(total))}\n`);
     process.stdout.write(summary);
-    process.stdout.write(`  ${paint("dim", "output: " + outRel)}\n\n`);
+    process.stdout.write(`  ${paint("dim", "output: " + outRel)}\n`);
+    if (usesBunFns) {
+      ensureBunVersion();
+    }
+    process.stdout.write("\n");
 
     const treatFailuresAsWarning = okCount > 0;
     process.exit(treatFailuresAsWarning || failCount === 0 ? 0 : 1);

package/bin/dev-server.mjs

@@ -2,9 +2,27 @@
 import { existsSync, statSync, readFileSync, readdirSync, writeFileSync, unlinkSync, watch as fsWatch } from "node:fs";
 import { join, resolve, extname, relative, dirname, basename, sep } from "node:path";
 import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 import { performance } from "node:perf_hooks";
 import { errorOverlayHTML as renderErrorOverlay } from "./error-overlay.mjs";
 
+// Locate the bundled local fonts. Prefers the installed @swift-rust/font
+// package (so it works when swift-rust is installed from npm), falling back to
+// the monorepo source dir during local development.
+let _localFontDir;
+export function resolveLocalFontDir() {
+  if (_localFontDir) return _localFontDir;
+  const candidates = [];
+  try {
+    const req = createRequire(import.meta.url);
+    const pkg = req.resolve("@swift-rust/font/package.json");
+    candidates.push(join(dirname(pkg), "src", "local"), join(dirname(pkg), "dist", "local"));
+  } catch {}
+  candidates.push(join(import.meta.dirname, "..", "..", "..", "packages", "font", "src", "local"));
+  _localFontDir = candidates.find((d) => existsSync(d)) ?? candidates[candidates.length - 1];
+  return _localFontDir;
+}
+
 const cwd = process.cwd();
 const args = process.argv.slice(2);
 
@@ -590,8 +608,12 @@ async function scanFontsFromLayouts() {
 }
 
 function buildGoogleFontsLinkTag() {
-  if (GOOGLE_FONT_FAMILIES.size === 0) return "";
-  const families = Array.from(GOOGLE_FONT_FAMILIES)
+  // Layout-scanned families + families any factory registered during this
+  // render (globalThis.__SR_GOOGLE_FONTS__), so page-only fonts get a <link>.
+  const registered = globalThis.__SR_GOOGLE_FONTS__ instanceof Set ? globalThis.__SR_GOOGLE_FONTS__ : null;
+  const all = registered ? new Set([...GOOGLE_FONT_FAMILIES, ...registered]) : GOOGLE_FONT_FAMILIES;
+  if (all.size === 0) return "";
+  const families = Array.from(all)
     .map((f) => `family=${encodeURIComponent(f).replace(/%20/g, "+")}:wght@300..900`)
     .join("&");
   return `<link rel="preconnect" href="https://fonts.googleapis.com" />
@@ -740,7 +762,44 @@ export function isClientPage(file) {
     for (const raw of readFileSync(file, "utf8").split("\n")) {
       const t = raw.trim();
       if (!t || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
-      return /^["']use client["'];?$/.test(t);
+      if (/^["']use client["'];?$/.test(t)) return true;
+      // allow other leading directives (e.g. 'use bun') before 'use client'
+      if (/^["']use [a-z]+["'];?$/.test(t)) continue;
+      return false;
+    }
+  } catch {}
+  return false;
+}
+
+const VALID_RUNTIMES = new Set(["bun", "edge", "node", "worker"]);
+
+// Detect a `'use bun' | 'use edge' | 'use node'` directive among a file's
+// leading string-literal directives (alongside an optional 'use client').
+export function detectRuntimeDirective(file) {
+  try {
+    for (const raw of readFileSync(file, "utf8").split("\n")) {
+      const t = raw.trim();
+      if (!t || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
+      const m = t.match(/^["']use (bun|edge|node|worker)["'];?$/);
+      if (m) return m[1];
+      if (/^["']use [a-z]+["'];?$/.test(t)) continue; // other directive, keep scanning
+      return null; // first non-directive line ends the directive prologue
+    }
+  } catch {}
+  return null;
+}
+
+// True if a file declares a `'use <name>'` directive among its leading
+// string-literal directives (coexists with 'use client' / 'use bun' / etc.).
+export function hasUseDirective(file, name) {
+  try {
+    const re = new RegExp(`^["']use ${name}["'];?$`);
+    for (const raw of readFileSync(file, "utf8").split("\n")) {
+      const t = raw.trim();
+      if (!t || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
+      if (re.test(t)) return true;
+      if (/^["']use [a-z]+["'];?$/.test(t)) continue;
+      return false;
     }
   } catch {}
   return false;
@@ -883,7 +942,7 @@ function buildRouteCtx(req, url, params, searchParams) {
     cookies,
     params,
     searchParams,
-    runtime: "node",
+    runtime: "bun",
     locals: { get: (k) => localsMap.get(k), set: (k, v) => localsMap.set(k, v) },
     request: req,
     __setCookies: setCookies,
@@ -903,19 +962,85 @@ function applyControl(c) {
   throw e;
 }
 
-/** Merge config.ts along the chain (inner overrides outer). */
-async function readMergedConfig(chain) {
+// swift-rust.config.json (read once) — provides the project default runtime.
+let _globalConfig;
+function loadGlobalConfig() {
+  if (_globalConfig !== undefined) return _globalConfig;
+  try {
+    _globalConfig = existsSync(SWIFT_RUST_CONFIG) ? JSON.parse(readFileSync(SWIFT_RUST_CONFIG, "utf8")) : {};
+  } catch {
+    _globalConfig = {};
+  }
+  return _globalConfig;
+}
+
+// Resolve a `'use bun'|'use edge'|'use node'` directive for a route's tree:
+// the page wins, then layouts innermost → outermost.
+function resolveTreeRuntimeDirective(route, chain) {
+  if (route?.file) {
+    const d = detectRuntimeDirective(route.file);
+    if (d) return d;
+  }
+  const layouts = collectRouteFiles(chain, "layout"); // outer → inner
+  for (let i = layouts.length - 1; i >= 0; i--) {
+    const d = detectRuntimeDirective(layouts[i].file);
+    if (d) return d;
+  }
+  return null;
+}
+
+// guard.ts runs only when explicitly opted in: a `'use guard'` directive in the
+// route tree (page/layout/config), config.ts `{ guard: true }`, or the global
+// `autoApplyGuard: true`. Default is off (autoApplyGuard defaults to false).
+function shouldRunGuard(route, chain, config) {
+  if (route?.file && hasUseDirective(route.file, "guard")) return true;
+  for (const { file } of collectRouteFiles(chain, "layout")) {
+    if (hasUseDirective(file, "guard")) return true;
+  }
+  for (const { file } of collectRouteFiles(chain, "config")) {
+    if (hasUseDirective(file, "guard")) return true;
+  }
+  if (config?.guard === true) return true;
+  if (loadGlobalConfig().autoApplyGuard === true) return true;
+  return false;
+}
+
+/** Merge config.ts along the chain (inner overrides outer) + resolve runtime. */
+async function readMergedConfig(chain, route) {
   let config = {};
   for (const { file } of collectRouteFiles(chain, "config")) {
     const mod = await loadModuleFresh(file);
     const c = mod.config ?? mod.default;
     if (c && typeof c === "object") config = { ...config, ...c, headers: { ...config.headers, ...c.headers } };
   }
-  // edge.ts / worker.ts force a runtime.
+  // edge.ts / worker.ts force a runtime (file-based, like a directive).
   const edge = await collectFirst(chain, "edge");
   if (edge && (edge.edge || edge.default)) config.runtime = "edge";
   const worker = await collectFirst(chain, "worker");
   if (worker && (worker.default || worker.bindings)) config.runtime = "worker";
+
+  // Runtime resolution (highest priority first):
+  //   'use bun|edge|node' directive  →  config.ts / edge.ts / worker.ts
+  //   →  swift-rust.config.json "runtime"  →  default "bun".
+  const explicitRuntime = config.runtime != null; // set by config.ts / edge / worker
+  const directive = resolveTreeRuntimeDirective(route, chain);
+  const fromJson = loadGlobalConfig().runtime;
+  let runtime = directive ?? config.runtime ?? fromJson ?? "bun";
+  if (!VALID_RUNTIMES.has(runtime)) {
+    process.stderr.write(
+      `  ${paint("yellow", "⚠")} invalid runtime ${JSON.stringify(runtime)} — falling back to "bun"\n`,
+    );
+    runtime = "bun";
+  }
+  config.runtime = runtime;
+  // A route is "dynamic" (emitted as a request-time function) when it explicitly
+  // opts into a runtime via a directive, config.ts/edge/worker, or config.dynamic.
+  config.dynamic = Boolean(directive) || explicitRuntime || config.dynamic === true;
+  config.headers = {
+    "x-swift-rust-runtime": runtime,
+    ...(config.dynamic ? { "x-swift-rust-dynamic": "1" } : {}),
+    ...config.headers,
+  };
   return config;
 }
 
@@ -961,7 +1086,8 @@ async function runRoutePipeline(route, ctx) {
   }
 
   // config.ts — merged, applied to the response by the caller.
-  const config = await readMergedConfig(chain);
+  const config = await readMergedConfig(chain, route);
+  ctx.runtime = config.runtime;
 
   // i18n.ts — resolve the active locale into locals (cookie/header/default).
   const i18nMod = await collectFirst(chain, "i18n");
@@ -994,19 +1120,23 @@ async function runRoutePipeline(route, ctx) {
     }
   }
 
-  // guard.ts — outer → inner
-  for (const { file } of collectRouteFiles(chain, "guard")) {
-    const mod = await loadModuleFresh(file);
-    const fn = mod.default ?? mod.guard;
-    if (typeof fn === "function") {
-      try {
-        applyControl(await fn(ctx));
-      } catch (e) {
-        if (e?.digest || e?.__response) throw e;
-        throw new RoutingFileError("guard", file, e);
+  // guard.ts — outer → inner. Opt-in via 'use guard' / config.guard /
+  // global autoApplyGuard (see shouldRunGuard).
+  if (shouldRunGuard(route, chain, config)) {
+    config.headers = { ...config.headers, "x-swift-rust-guard": "1" };
+    for (const { file } of collectRouteFiles(chain, "guard")) {
+      const mod = await loadModuleFresh(file);
+      const fn = mod.default ?? mod.guard;
+      if (typeof fn === "function") {
+        try {
+          applyControl(await fn(ctx));
+        } catch (e) {
+          if (e?.digest || e?.__response) throw e;
+          throw new RoutingFileError("guard", file, e);
+        }
+      } else if (mod.default !== undefined || mod.guard !== undefined) {
+        warnRoutingFile(file, `guard.ts must export a function (default export). ${relative(cwd, file)}`);
       }
-    } else if (mod.default !== undefined || mod.guard !== undefined) {
-      warnRoutingFile(file, `guard.ts must export a function (default export). ${relative(cwd, file)}`);
     }
   }
 
@@ -1229,6 +1359,10 @@ async function renderRoute(urlPath, req) {
   const errorFile = findErrorBoundary(segments);
   const loadingFile = findLoading(segments);
 
+  // Reset per-render Google font registry so each page only requests the
+  // families it actually uses (factories re-register during render).
+  globalThis.__SR_GOOGLE_FONTS__ = new Set();
+
   try {
     const React = await import("react");
     const url = req ? new URL(req.url) : new URL(urlPath, "http://localhost");
@@ -1314,10 +1448,25 @@ async function renderRoute(urlPath, req) {
         }
       }
     }
+    // shell.tsx — root-only. Lets the app own the outer document
+    // (<html>/<body>/providers); the framework injects head assets + body
+    // scripts into what it renders (see the fullDocument branch in handleFetch).
+    let fullDocument = false;
+    const shellFile = findFile(APP_DIR, "shell");
+    if (shellFile) {
+      try {
+        const sm = await loadModuleFresh(shellFile);
+        const Shell = sm.default ?? sm.Shell ?? sm.shell;
+        if (Shell) {
+          tree = React.createElement(Shell, null, tree);
+          fullDocument = true;
+        }
+      } catch {}
+    }
     const html = await renderToStringCompat(tree);
     if (runtime?.__setRouteContext) runtime.__setRouteContext(null);
     const metadata = await resolveMetadata(layouts.map((l) => l.file), route.file, route.params, segments);
-    return { status: 200, html, metadata, error: null, clientPage, pageFile: route.file, layoutFiles: layouts.map((l) => l.file), notFoundFile, errorFile, loadingFile, segments, setCookies: pipeline.setCookies, actionData: pipeline.actionData, config: pipeline.config, revalidatePlan: pipeline.revalidatePlan, seoHead: pipeline.seoHead, serverState: pipeline.serverState };
+    return { status: 200, html, metadata, error: null, clientPage, pageFile: route.file, layoutFiles: layouts.map((l) => l.file), notFoundFile, errorFile, loadingFile, segments, setCookies: pipeline.setCookies, actionData: pipeline.actionData, config: pipeline.config, revalidatePlan: pipeline.revalidatePlan, seoHead: pipeline.seoHead, serverState: pipeline.serverState, fullDocument };
   } catch (err) {
     const rt = await routerRuntime();
     if (rt?.__setRouteContext) rt.__setRouteContext(null);
@@ -1733,15 +1882,8 @@ async function handleRequest(req, res) {
 
   if (pathname.startsWith("/_swift-rust/fonts/")) {
     const fontPath = join(
-      import.meta.dirname,
-      "..",
-      "..",
-      "..",
-      "packages",
-      "font",
-      "src",
-      "local",
-      decodeURIComponent(pathname.replace("/_swift-rust/fonts/", ""))
+      resolveLocalFontDir(),
+      decodeURIComponent(pathname.replace("/_swift-rust/fonts/", "")),
     );
     if (existsSync(fontPath) && statSync(fontPath).isFile()) {
       const ext = extname(fontPath).toLowerCase();
@@ -2190,7 +2332,19 @@ async function handleFetch(req) {
   await scanFontsFromLayouts();
   // seo.tsx head + metadata head
   const headExtra = [metadataToHead(renderResult.metadata), renderResult.seoHead || ""].filter(Boolean).join("\n");
-  let doc = await wrapInDocumentAsync({ head: headExtra, body: renderResult.html || "" });
+  let doc;
+  if (renderResult.fullDocument) {
+    // shell.tsx already rendered <html>/<head>/<body>. Inject framework head
+    // assets (metadata, fonts, globals CSS, navigator/HMR scripts) into its
+    // <head>; body scripts below still append before </body>.
+    const inject = `${await buildHead(headExtra)}\n<script src="/_swift-rust/navigator.js" defer></script>\n<script src="/_swift-rust/hmr-client.js" defer></script>`;
+    doc = renderResult.html || "";
+    if (!/^\s*<!doctype/i.test(doc)) doc = `<!DOCTYPE html>${doc}`;
+    if (doc.includes("</head>")) doc = doc.replace("</head>", `${inject}\n</head>`);
+    else doc = doc.replace(/<body([\s>])/i, `<head>${inject}</head><body$1`);
+  } else {
+    doc = await wrapInDocumentAsync({ head: headExtra, body: renderResult.html || "" });
+  }
   // state.ts → window.__SR_STATE__ for client stores
   if (renderResult.serverState !== undefined) {
     const json = JSON.stringify(renderResult.serverState).replace(/</g, "\\u003c");

package/bin/runtime/fn-core.mjs

@@ -0,0 +1,318 @@
+// Portable request-time SSR handler used by emitted Vercel functions
+// (edge / node / bun). No Bun-only APIs — renders with react-dom/server.
+// Mirrors the dev-server route pipeline so emitted functions behave the same.
+import { createElement } from "react";
+
+async function renderTree(tree) {
+  try {
+    const { renderToReadableStream } = await import("react-dom/server.edge");
+    const stream = await renderToReadableStream(tree);
+    if (stream.allReady) await stream.allReady;
+    return await new Response(stream).text();
+  } catch {
+    const { renderToString } = await import("react-dom/server");
+    return renderToString(tree);
+  }
+}
+
+function parseCookies(request) {
+  const header = request.headers.get("cookie") || "";
+  const map = new Map();
+  for (const part of header.split(";")) {
+    const i = part.indexOf("=");
+    if (i > 0) map.set(part.slice(0, i).trim(), decodeURIComponent(part.slice(i + 1).trim()));
+  }
+  return { get: (k) => map.get(k), has: (k) => map.has(k) };
+}
+
+function matchParams(pattern, pathname) {
+  const segs = pathname.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+  const params = {};
+  for (let i = 0; i < pattern.length; i++) {
+    const p = pattern[i];
+    if (p.startsWith("[...") && p.endsWith("]")) {
+      params[p.slice(4, -1)] = segs.slice(i);
+      return params;
+    }
+    if (p.startsWith("[") && p.endsWith("]")) params[p.slice(1, -1)] = segs[i];
+  }
+  return params;
+}
+
+const pick = (mod, ...keys) => {
+  for (const k of keys) if (mod && mod[k] != null) return mod[k];
+  return undefined;
+};
+const matchesMatcher = (pathname, matcher) => {
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  return list.some((m) => new RegExp(`^${String(m).replace(/\*\*/g, ".*").replace(/(?<!\.)\*/g, "[^/]*")}$`).test(pathname));
+};
+const esc = (s) =>
+  String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+
+// ── metadata (per-request) ──────────────────────────────────────────────────
+function mergeMetadata(...metas) {
+  const out = {};
+  for (const m of metas) {
+    if (!m) continue;
+    if (m.title) out.title = typeof m.title === "string" ? m.title : (m.title.default ?? out.title);
+    if (m.description) out.description = m.description;
+    if (m.keywords) out.keywords = m.keywords;
+    if (m.openGraph) out.openGraph = { ...(out.openGraph || {}), ...m.openGraph };
+    if (m.twitter) out.twitter = { ...(out.twitter || {}), ...m.twitter };
+  }
+  return out;
+}
+function metadataToHead(meta) {
+  if (!meta) return "";
+  const p = [];
+  if (typeof meta.title === "string") p.push(`<title>${esc(meta.title)}</title>`);
+  if (meta.description) p.push(`<meta name="description" content="${esc(meta.description)}" />`);
+  if (meta.keywords) p.push(`<meta name="keywords" content="${esc(Array.isArray(meta.keywords) ? meta.keywords.join(", ") : meta.keywords)}" />`);
+  const og = meta.openGraph;
+  if (og) {
+    if (og.title) p.push(`<meta property="og:title" content="${esc(og.title)}" />`);
+    if (og.description) p.push(`<meta property="og:description" content="${esc(og.description)}" />`);
+    if (og.type) p.push(`<meta property="og:type" content="${esc(og.type)}" />`);
+    if (og.url) p.push(`<meta property="og:url" content="${esc(og.url)}" />`);
+    for (const img of og.images || []) {
+      const url = typeof img === "string" ? img : img.url;
+      if (url) p.push(`<meta property="og:image" content="${esc(url)}" />`);
+      if (typeof img === "object" && img) {
+        if (img.width) p.push(`<meta property="og:image:width" content="${esc(img.width)}" />`);
+        if (img.height) p.push(`<meta property="og:image:height" content="${esc(img.height)}" />`);
+        if (img.alt) p.push(`<meta property="og:image:alt" content="${esc(img.alt)}" />`);
+      }
+    }
+  }
+  const tw = meta.twitter;
+  if (tw) {
+    if (tw.card) p.push(`<meta name="twitter:card" content="${esc(tw.card)}" />`);
+    if (tw.title) p.push(`<meta name="twitter:title" content="${esc(tw.title)}" />`);
+    if (tw.description) p.push(`<meta name="twitter:description" content="${esc(tw.description)}" />`);
+    for (const img of tw.images || []) p.push(`<meta name="twitter:image" content="${esc(typeof img === "string" ? img : img.url)}" />`);
+  }
+  return p.join("\n");
+}
+function buildSeoHead(r) {
+  if (!r || typeof r !== "object") return "";
+  const out = [];
+  if (r.title) out.push(`<title>${esc(r.title)}</title>`);
+  if (r.description) out.push(`<meta name="description" content="${esc(r.description)}" />`);
+  if (r.canonical) out.push(`<link rel="canonical" href="${esc(r.canonical)}" />`);
+  if (r.robots) out.push(`<meta name="robots" content="${esc(r.robots)}" />`);
+  for (const [k, v] of Object.entries(r.openGraph || {})) out.push(`<meta property="og:${esc(k)}" content="${esc(v)}" />`);
+  const jsonLd = r.jsonLd ? (Array.isArray(r.jsonLd) ? r.jsonLd : [r.jsonLd]) : [];
+  for (const ld of jsonLd) out.push(`<script type="application/ld+json">${JSON.stringify(ld).replace(/</g, "\\u003c")}</script>`);
+  return out.join("\n");
+}
+// Drop captured metadata tags so per-request metadata/seo can replace them.
+function stripMeta(head) {
+  return head
+    .replace(/<title>[\s\S]*?<\/title>/gi, "")
+    .replace(/<meta\s+name="description"[^>]*>/gi, "")
+    .replace(/<meta\s+name="keywords"[^>]*>/gi, "")
+    .replace(/<meta\s+property="og:[^"]*"[^>]*>/gi, "")
+    .replace(/<meta\s+name="twitter:[^"]*"[^>]*>/gi, "");
+}
+
+function cacheControl(plan) {
+  if (!plan) return null;
+  if (plan.ttl === 0 || plan.noStore) return "no-store";
+  const parts = [];
+  if (typeof plan.ttl === "number") parts.push(`s-maxage=${plan.ttl}`, "stale-while-revalidate");
+  return parts.length ? `public, ${parts.join(", ")}` : null;
+}
+
+function controlToResponse(c, url) {
+  if (!c || typeof c !== "object") return null;
+  if (c.kind === "redirect") return new Response(null, { status: c.status || 307, headers: { Location: new URL(c.to, url).toString() } });
+  if (c.kind === "notFound") return new Response("Not Found", { status: 404 });
+  if (c.kind === "response" && c.response) return c.response;
+  return null;
+}
+function thrownToResponse(err, url) {
+  if (err?.__response instanceof Response) return err.__response;
+  const d = err?.digest;
+  if (d && String(d).startsWith("REDIRECT")) {
+    const [, status, ...rest] = String(d).split(";");
+    return new Response(null, { status: Number(status) || 307, headers: { Location: new URL(rest.join(";"), url).toString() } });
+  }
+  if (d === "NOT_FOUND" || err?.name === "NotFoundError") return new Response("Not Found", { status: 404 });
+  if (d === "FORBIDDEN" || err?.name === "ForbiddenError") return new Response("Forbidden", { status: 403 });
+  if (d === "UNAUTHORIZED" || err?.name === "UnauthorizedError") return new Response("Unauthorized", { status: 401 });
+  return null;
+}
+
+export function makeRouteHandler(opts) {
+  return async function fetch(request) {
+    const url = new URL(request.url);
+    const params = matchParams(opts.pattern || [], url.pathname);
+    const setCookies = [];
+    const localsMap = new Map();
+    const ctx = {
+      url,
+      request,
+      method: request.method,
+      headers: request.headers,
+      params,
+      searchParams: Object.fromEntries(url.searchParams.entries()),
+      cookies: parseCookies(request),
+      locals: { get: (k) => localsMap.get(k), set: (k, v) => localsMap.set(k, v) },
+      runtime: opts.runtime,
+      __setCookies: setCookies,
+    };
+
+    try {
+      // proxy
+      for (const mod of opts.proxies || []) {
+        const fn = pick(mod, "default", "proxy");
+        if (typeof fn !== "function") continue;
+        if (mod.matcher && !matchesMatcher(url.pathname, mod.matcher)) continue;
+        const r = controlToResponse(await fn(ctx), url);
+        if (r) return r;
+      }
+
+      // i18n — resolve locale into locals
+      const i18nCfg = pick(opts.i18n || {}, "i18n", "default");
+      if (i18nCfg && Array.isArray(i18nCfg.locales)) {
+        let locale = i18nCfg.defaultLocale ?? i18nCfg.locales[0];
+        if (typeof i18nCfg.resolve === "function") locale = (await i18nCfg.resolve(ctx)) || locale;
+        else if (i18nCfg.strategy === "cookie") locale = ctx.cookies.get("locale") || locale;
+        else if (i18nCfg.strategy === "header") {
+          const al = request.headers.get("accept-language")?.split(",")[0]?.split("-")[0];
+          if (al && i18nCfg.locales.includes(al)) locale = al;
+        }
+        ctx.locals.set("locale", locale);
+        ctx.__locale = locale;
+      }
+
+      // schema / query
+      const querySpec = pick(opts.query || {}, "query");
+      for (const mod of opts.schemas || []) {
+        if (mod.params?.safeParse) {
+          const r = mod.params.safeParse(ctx.params);
+          if (!r.success) return Response.json({ error: "Invalid params", issues: r.error?.issues ?? r.error }, { status: 400 });
+          Object.assign(ctx.params, r.data);
+        }
+        const searchSchema = querySpec?.parse ?? mod.searchParams;
+        if (searchSchema?.safeParse) {
+          const r = searchSchema.safeParse(ctx.searchParams);
+          if (r.success) Object.assign(ctx.searchParams, r.data);
+        }
+      }
+
+      // guard (opt-in)
+      if (opts.guardEnabled) {
+        for (const mod of opts.guards || []) {
+          const fn = pick(mod, "default", "guard");
+          if (typeof fn !== "function") continue;
+          const r = controlToResponse(await fn(ctx), url);
+          if (r) return r;
+        }
+      }
+
+      // action (mutations)
+      let actionData;
+      if (ctx.method !== "GET" && ctx.method !== "HEAD" && opts.action) {
+        const fn = pick(opts.action, "default", "action");
+        if (typeof fn === "function") {
+          const actx = Object.assign({}, ctx, { formData: () => request.formData(), json: () => request.json() });
+          const result = await fn(actx);
+          const r = controlToResponse(result, url);
+          if (r) return r;
+          actionData = result;
+        }
+      }
+
+      // loaders (parallel)
+      const loaded = await Promise.all(
+        (opts.loaders || []).map(async (mod) => {
+          const fn = pick(mod, "default", "loader");
+          return typeof fn === "function" ? fn(ctx) : undefined;
+        }),
+      );
+      const loaderData = loaded.length ? loaded[loaded.length - 1] : undefined;
+
+      // state
+      let serverState;
+      const stateFn = pick(opts.state || {}, "default", "state");
+      if (typeof stateFn === "function") serverState = await stateFn(ctx);
+
+      // seo
+      let seoHead = "";
+      const seoFn = pick(opts.seo || {}, "default", "seo");
+      if (typeof seoFn === "function") seoHead = buildSeoHead(await seoFn(Object.assign({}, ctx, { data: loaderData })));
+
+      // per-request metadata (layout metadata + page metadata/generateMetadata)
+      const metas = [];
+      for (const m of opts.layoutMetas || []) if (m?.metadata) metas.push(m.metadata);
+      const pageMod = opts.page;
+      if (typeof pageMod.generateMetadata === "function") {
+        metas.push(await pageMod.generateMetadata({ params: ctx.params, searchParams: ctx.searchParams }));
+      } else if (pageMod.metadata) {
+        metas.push(pageMod.metadata);
+      }
+      const metaHead = metadataToHead(mergeMetadata(...metas));
+
+      // Expose loader/action data to useLoaderData()/useActionData() via the
+      // router's globalThis context box (same channel the dev server uses).
+      const g = globalThis;
+      g.__SR_ROUTE_CTX__ = g.__SR_ROUTE_CTX__ || { current: null };
+      g.__SR_ROUTE_CTX__.current = { request: ctx, loaderData, actionData, loaders: {} };
+
+      // render: page → (slots) → layouts
+      const Page = pick(opts.page, "default", "Page", "page");
+      let tree = createElement(Page, { params: ctx.params, loaderData });
+      if (opts.isClient) {
+        tree = createElement("div", { id: "__sr_island_root", "data-sr-params": JSON.stringify(ctx.params) }, tree);
+      }
+      const layouts = opts.layouts || [];
+      const slotsByLayout = opts.slots || [];
+      for (let i = layouts.length - 1; i >= 0; i--) {
+        const Layout = pick(layouts[i], "default", "Layout", "layout");
+        if (!Layout) continue;
+        const slotProps = {};
+        for (const slot of slotsByLayout[i] || []) {
+          const SlotComp = pick(slot.mod, "default", "Page", "Fragment", "page", "fragment");
+          if (SlotComp) slotProps[slot.name] = createElement(SlotComp, {});
+        }
+        tree = createElement(Layout, slotProps, tree);
+      }
+      const body = await renderTree(tree);
+      g.__SR_ROUTE_CTX__.current = null;
+
+      // head: captured assets (metadata stripped) + per-request metadata + seo
+      let head = stripMeta(opts.head || "");
+      head += metaHead;
+      if (/<title/i.test(seoHead)) head = head.replace(/<title>[\s\S]*?<\/title>/i, "");
+      head += seoHead;
+
+      const stateScript =
+        serverState !== undefined ? `<script>window.__SR_STATE__=${JSON.stringify(serverState).replace(/</g, "\\u003c")}</script>` : "";
+      const islandScript = opts.isClient && opts.islandSrc ? `<script type="module" src="${opts.islandSrc}"></script>` : "";
+      const html = `<!DOCTYPE html><html lang="${ctx.__locale || "en"}"><head>${head}</head><body>${body}${opts.bodyScripts || ""}${stateScript}${islandScript}</body></html>`;
+
+      // revalidate → Cache-Control + tags
+      let plan = opts.configRevalidate != null ? { ttl: opts.configRevalidate } : undefined;
+      const revFn = pick(opts.revalidate || {}, "default", "revalidate");
+      if (typeof revFn === "function") {
+        const p = await revFn(Object.assign({}, ctx, { data: loaderData, afterAction: ctx.method !== "GET" }));
+        if (p && typeof p === "object") plan = { ...plan, ...p };
+      }
+
+      const headers = new Headers({ "content-type": "text/html; charset=utf-8", "x-swift-rust-runtime": opts.runtime || "bun" });
+      for (const [k, v] of Object.entries(opts.config?.headers || {})) headers.set(k, String(v));
+      const cc = cacheControl(plan);
+      if (cc) headers.set("cache-control", cc);
+      const tags = plan?.tags || plan?.invalidate;
+      if (Array.isArray(tags) && tags.length) headers.set("x-vercel-cache-tags", tags.join(","));
+      for (const c of setCookies) headers.append("set-cookie", c);
+      return new Response(html, { headers });
+    } catch (err) {
+      const resp = thrownToResponse(err, url);
+      if (resp) return resp;
+      return new Response(`Internal Error: ${err?.message || err}`, { status: 500 });
+    }
+  };
+}

package/dist/head.d.ts

@@ -9,13 +9,13 @@ export interface HeadProps {
 export declare function Head({ children }: HeadProps): ReactNode;
 export declare function Title({ children }: {
     children: ReactNode;
-}): import("react").JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 export declare function Meta({ name, content, property, }: {
     name?: string;
     property?: string;
     content: string;
-}): import("react").JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 export declare function Style({ children }: {
     children: ReactNode;
-}): import("react").JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=head.d.ts.map

package/dist/head.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../src/head.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,SAAS,aAE3C;AAED,wBAAgB,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAE1D;AAED,wBAAgB,IAAI,CAAC,EACnB,IAAI,EACJ,OAAO,EACP,QAAQ,GACT,EAAE;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,+BAMA;AAED,wBAAgB,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAK1D"}
+{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../src/head.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,SAAS,aAE3C;AAED,wBAAgB,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAE1D;AAED,wBAAgB,IAAI,CAAC,EACnB,IAAI,EACJ,OAAO,EACP,QAAQ,GACT,EAAE;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,2CAMA;AAED,wBAAgB,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAK1D"}

package/dist/head.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function Head({ children }) {
+    return children;
+}
+export function Title({ children }) {
+    return _jsx("title", { children: children });
+}
+export function Meta({ name, content, property, }) {
+    return name ? (_jsx("meta", { name: name, content: content })) : (_jsx("meta", { property: property, content: content }));
+}
+export function Style({ children }) {
+    return (_jsx("style", { dangerouslySetInnerHTML: { __html: typeof children === "string" ? children : "" } }));
+}
+//# sourceMappingURL=head.js.map

package/dist/head.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.js","sourceRoot":"","sources":["../src/head.tsx"],"names":[],"mappings":";AAUA,MAAM,UAAU,IAAI,CAAC,EAAE,QAAQ,EAAa;IAC1C,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,EAAE,QAAQ,EAA2B;IACzD,OAAO,0BAAQ,QAAQ,GAAS,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,EACnB,IAAI,EACJ,OAAO,EACP,QAAQ,GAKT;IACC,OAAO,IAAI,CAAC,CAAC,CAAC,CACZ,eAAM,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAI,CACvC,CAAC,CAAC,CAAC,CACF,eAAM,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAI,CAC/C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,EAAE,QAAQ,EAA2B;IACzD,OAAO,CAEL,gBAAO,uBAAuB,EAAE,EAAE,MAAM,EAAE,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,GAAI,CAC7F,CAAC;AACJ,CAAC"}

package/dist/link.d.ts

@@ -6,5 +6,5 @@ export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>,
     replace?: boolean;
     scroll?: boolean;
 }
-export declare function Link({ href, prefetch, replace, scroll, children, ...rest }: LinkProps): import("react").JSX.Element;
+export declare function Link({ href, prefetch, replace, scroll, children, ...rest }: LinkProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=link.d.ts.map

package/dist/link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../src/link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAE7D,MAAM,WAAW,SAAU,SAAQ,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,EAAE,SAAS,+BAYrF"}
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../src/link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAE7D,MAAM,WAAW,SAAU,SAAQ,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,EAAE,SAAS,2CAYrF"}

package/dist/{link.jsx → link.js}

@@ -1,3 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 export function Link({ href, prefetch, replace, scroll, children, ...rest }) {
     // The client navigator (runtime/navigator.js) reads these data-* hints to
     // drive SPA navigation. Plain <a> semantics are preserved when JS is off.
@@ -8,8 +9,6 @@ export function Link({ href, prefetch, replace, scroll, children, ...rest }) {
         dataAttrs["data-sr-scroll"] = "false";
     if (prefetch === false)
         dataAttrs["data-sr-prefetch"] = "false";
-    return (<a href={href} {...dataAttrs} {...rest}>
-      {children}
-    </a>);
+    return (_jsx("a", { href: href, ...dataAttrs, ...rest, children: children }));
 }
-//# sourceMappingURL=link.jsx.map
+//# sourceMappingURL=link.js.map

package/dist/{link.jsx.map → link.js.map}

@@ -1 +1 @@
-{"version":3,"file":"link.jsx","sourceRoot":"","sources":["../src/link.tsx"],"names":[],"mappings":"AAUA,MAAM,UAAU,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAa;IACpF,0EAA0E;IAC1E,0EAA0E;IAC1E,MAAM,SAAS,GAA2B,EAAE,CAAC;IAC7C,IAAI,OAAO;QAAE,SAAS,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC;IACnD,IAAI,MAAM,KAAK,KAAK;QAAE,SAAS,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC;IAC5D,IAAI,QAAQ,KAAK,KAAK;QAAE,SAAS,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC;IAChE,OAAO,CACL,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC,CACrC;MAAA,CAAC,QAAQ,CACX;IAAA,EAAE,CAAC,CAAC,CACL,CAAC;AACJ,CAAC"}
+{"version":3,"file":"link.js","sourceRoot":"","sources":["../src/link.tsx"],"names":[],"mappings":";AAUA,MAAM,UAAU,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAa;IACpF,0EAA0E;IAC1E,0EAA0E;IAC1E,MAAM,SAAS,GAA2B,EAAE,CAAC;IAC7C,IAAI,OAAO;QAAE,SAAS,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC;IACnD,IAAI,MAAM,KAAK,KAAK;QAAE,SAAS,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC;IAC5D,IAAI,QAAQ,KAAK,KAAK;QAAE,SAAS,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC;IAChE,OAAO,CACL,YAAG,IAAI,EAAE,IAAI,KAAM,SAAS,KAAM,IAAI,YACnC,QAAQ,GACP,CACL,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swift-rust",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "The full-stack React framework powered with Rust + Bun. TSX-first, Rust rendering, 10x faster than Next.js, single binary deploy.",
   "license": "MIT",
   "homepage": "https://swift-rust.dev",

package/dist/head.jsx

@@ -1,15 +0,0 @@
-export function Head({ children }) {
-    return children;
-}
-export function Title({ children }) {
-    return <title>{children}</title>;
-}
-export function Meta({ name, content, property, }) {
-    return name ? (<meta name={name} content={content}/>) : (<meta property={property} content={content}/>);
-}
-export function Style({ children }) {
-    return (
-    // biome-ignore lint/security/noDangerouslySetInnerHtml: <style> contents are static CSS at build time
-    <style dangerouslySetInnerHTML={{ __html: typeof children === "string" ? children : "" }}/>);
-}
-//# sourceMappingURL=head.jsx.map

package/dist/head.jsx.map

@@ -1 +0,0 @@
-{"version":3,"file":"head.jsx","sourceRoot":"","sources":["../src/head.tsx"],"names":[],"mappings":"AAUA,MAAM,UAAU,IAAI,CAAC,EAAE,QAAQ,EAAa;IAC1C,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,EAAE,QAAQ,EAA2B;IACzD,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,EACnB,IAAI,EACJ,OAAO,EACP,QAAQ,GAKT;IACC,OAAO,IAAI,CAAC,CAAC,CAAC,CACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,EAAG,CACvC,CAAC,CAAC,CAAC,CACF,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,EAAG,CAC/C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,EAAE,QAAQ,EAA2B;IACzD,OAAO;IACL,sGAAsG;IACtG,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAG,CAC7F,CAAC;AACJ,CAAC"}