swift-rust 1.2.1 → 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) {
@@ -412,16 +755,38 @@ async function main() {
       }
     }
 
-    writeConfigJson(OUT_DIR, hasPublic);
+    // Client navigator runtime (SPA navigation). The rendered HTML references
+    // /_swift-rust/navigator.js; emit it as a static asset so deployed sites
+    // get client-side navigation too.
+    const navSrc = join(RUNTIME_DIR, "navigator.js");
+    if (existsSync(navSrc)) {
+      writeRawFile(STATIC_DIR, "_swift-rust/navigator.js", readFileSync(navSrc));
+      process.stdout.write(`  ${paint("green", "✓")} _swift-rust/navigator.js\n`);
+    }
+
+    // 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);