swift-rust 1.1.0 → 1.3.0

package/bin/build.mjs

@@ -15,7 +15,7 @@ import { join, resolve, dirname, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const cwd = process.cwd();
-const APP_DIR_CANDIDATES = [resolve(cwd, "app", "src"), resolve(cwd, "app")];
+const APP_DIR_CANDIDATES = [resolve(cwd, "src", "app"), resolve(cwd, "app")];
 const APP_DIR = APP_DIR_CANDIDATES.find((p) => existsSync(p)) ?? resolve(cwd, "app");
 const PUBLIC_DIR = resolve(cwd, "public");
 const OUT_DIR = resolve(cwd, ".vercel", "output");
@@ -200,6 +200,15 @@ function stripHmrScript(html) {
   return html.replace(/\s*<script src="\/_swift-rust\/hmr-client\.js"[^>]*>\s*<\/script>/g, "");
 }
 
+// The dev-time image endpoint (/_swift-rust/image) only exists while the dev
+// server runs. On Vercel the platform serves an optimizing endpoint at
+// /_vercel/image with the exact same query contract (url, w, q), so we swap the
+// path prefix at build time. The `images` config written into config.json
+// enables (and bounds) that optimizer. Handles `src`, `srcset`, and `&amp;`.
+function rewriteImageUrls(html) {
+  return html.split("/_swift-rust/image?").join("/_vercel/image?");
+}
+
 function writeStaticFile(outDir, pathname, html) {
   const rel = pathname === "/" ? "index.html" : `${pathname.replace(/^\//, "")}/index.html`;
   const outPath = join(outDir, rel);
@@ -263,6 +272,16 @@ function writeConfigJson(outDir, _hasPublic) {
     overrides: {
       "404.html": { path: "404", contentType: "text/html; charset=utf-8" },
     },
+    // Enables Vercel's image optimizer (/_vercel/image). `sizes` MUST match the
+    // widths <Image> requests (packages/image DEVICE_SIZES) or requests 400.
+    images: {
+      sizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+      formats: ["image/avif", "image/webp"],
+      minimumCacheTTL: 86400,
+      // Allow optimizing local SVG assets (e.g. blog covers); sandboxed by CSP.
+      dangerouslyAllowSVG: true,
+      contentSecurityPolicy: "default-src 'self'; script-src 'none'; sandbox;",
+    },
   };
   writeFileSync(join(outDir, "config.json"), `${JSON.stringify(config, null, 2)}\n`);
 }
@@ -325,7 +344,7 @@ async function main() {
       try {
         const { status, body } = await fetchRoute(route);
         if (status === 200) {
-          const cleaned = await localizeIslands(stripHmrScript(body));
+          const cleaned = rewriteImageUrls(await localizeIslands(stripHmrScript(body)));
           writeStaticFile(STATIC_DIR, route, cleaned);
           okCount++;
           process.stdout.write(`  ${paint("green", "✓")} ${route}\n`);
@@ -393,6 +412,15 @@ async function main() {
       }
     }
 
+    // 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`);
+    }
+
     writeConfigJson(OUT_DIR, hasPublic);
 
     const total = Date.now() - start;

package/bin/dev-server.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { existsSync, statSync, readFileSync, readdirSync, writeFileSync, unlinkSync, watch as fsWatch } from "node:fs";
-import { join, resolve, extname, relative, dirname, sep } from "node:path";
+import { join, resolve, extname, relative, dirname, basename, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { performance } from "node:perf_hooks";
 import { errorOverlayHTML as renderErrorOverlay } from "./error-overlay.mjs";
@@ -17,7 +17,7 @@ function getArg(name, fallback) {
   return fallback;
 }
 
-const port = parseInt(getArg("port", process.env.PORT || "3000"), 10);
+const port = parseInt(getArg("port", process.env.PORT || "3210"), 10);
 const hostname = getArg("hostname", "0.0.0.0");
 
 const c = {
@@ -36,7 +36,7 @@ const useColor = process.stdout.isTTY !== false && !process.env.NO_COLOR;
 const paint = (color, s) => (useColor ? `${c[color]}${s}${c.reset}` : s);
 
 const VERSION = "0.1.0";
-const APP_DIR_CANDIDATES = [resolve(cwd, "app", "src"), resolve(cwd, "app")];
+const APP_DIR_CANDIDATES = [resolve(cwd, "src", "app"), resolve(cwd, "app")];
 const APP_DIR = APP_DIR_CANDIDATES.find((p) => existsSync(p)) ?? resolve(cwd, "app");
 const PUBLIC_DIR = resolve(cwd, "public");
 const SWIFT_RUST_CONFIG = resolve(cwd, "swift-rust.config.json");
@@ -617,6 +617,7 @@ function mergeMetadata(...metas) {
     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;
 }
@@ -641,6 +642,24 @@ function metadataToHead(meta) {
       for (const img of meta.openGraph.images) {
         const url = typeof img === "string" ? img : img.url;
         if (url) parts.push(`<meta property="og:image" content="${escapeHtml(url)}" />`);
+        if (typeof img === "object" && img) {
+          if (img.width) parts.push(`<meta property="og:image:width" content="${escapeHtml(img.width)}" />`);
+          if (img.height) parts.push(`<meta property="og:image:height" content="${escapeHtml(img.height)}" />`);
+          if (img.alt) parts.push(`<meta property="og:image:alt" content="${escapeHtml(img.alt)}" />`);
+        }
+      }
+    }
+  }
+  if (meta.twitter) {
+    if (meta.twitter.card) parts.push(`<meta name="twitter:card" content="${escapeHtml(meta.twitter.card)}" />`);
+    if (meta.twitter.site) parts.push(`<meta name="twitter:site" content="${escapeHtml(meta.twitter.site)}" />`);
+    if (meta.twitter.creator) parts.push(`<meta name="twitter:creator" content="${escapeHtml(meta.twitter.creator)}" />`);
+    if (meta.twitter.title) parts.push(`<meta name="twitter:title" content="${escapeHtml(meta.twitter.title)}" />`);
+    if (meta.twitter.description) parts.push(`<meta name="twitter:description" content="${escapeHtml(meta.twitter.description)}" />`);
+    if (meta.twitter.images) {
+      for (const img of meta.twitter.images) {
+        const url = typeof img === "string" ? img : img.url;
+        if (url) parts.push(`<meta name="twitter:image" content="${escapeHtml(url)}" />`);
       }
     }
   }
@@ -796,10 +815,12 @@ function warnRoutingFile(file, msg) {
 function validateRoutingConventions() {
   const names = [...SPECIAL_FILES, "page"];
   const appRel = relative(cwd, APP_DIR) || "app";
-  const usesSrc = APP_DIR.endsWith(`${sep}src`);
-  const scan = (dir, label) => {
+  const srcRoot = dirname(APP_DIR);
+  const usesSrc = basename(APP_DIR) === "app" && basename(srcRoot) === "src";
+  const scan = (dir, label, allow = []) => {
     if (!existsSync(dir) || resolve(dir) === resolve(APP_DIR)) return;
     for (const name of names) {
+      if (allow.includes(name)) continue;
       const f = findFile(dir, name);
       if (f) {
         warnRoutingFile(
@@ -811,7 +832,8 @@ function validateRoutingConventions() {
     }
   };
   scan(cwd, "the project root");
-  if (usesSrc) scan(dirname(APP_DIR), `"app/" (outside "src/")`);
+  // proxy.ts is allowed to live at the src/ root (sibling of src/app).
+  if (usesSrc) scan(srcRoot, `"src/" (outside "app/")`, ["proxy"]);
 }
 
 // ── RFC 0001 route pipeline: config → schema → guard → loader/action ────────
@@ -902,7 +924,16 @@ async function runRoutePipeline(route, ctx) {
 
   // proxy.ts — phase 1, outer → inner. Cheap, data-free interception
   // (Next.js calls this "proxy"; "middleware" is accepted with a warning).
-  for (const { file } of collectRouteFiles(chain, "proxy")) {
+  // When using a src/ directory, a root proxy lives at src/proxy.ts (sibling
+  // of src/app), so it runs before any in-app proxy.
+  const proxyFiles = [];
+  const srcRoot = dirname(APP_DIR);
+  if (basename(APP_DIR) === "app" && basename(srcRoot) === "src") {
+    const rootProxy = findFile(srcRoot, "proxy");
+    if (rootProxy) proxyFiles.push({ file: rootProxy, dir: srcRoot });
+  }
+  proxyFiles.push(...collectRouteFiles(chain, "proxy"));
+  for (const { file } of proxyFiles) {
     const mod = await loadModuleFresh(file);
     const fn = mod.default ?? mod.proxy;
     if (typeof fn === "function") {
@@ -1095,6 +1126,98 @@ function cacheControlFromPlan(plan) {
   return null;
 }
 
+// ── Parallel routes (@slot dirs → fragment / fallback / default) ────────────
+function findDynamicChild(dir) {
+  try {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory() && /^\[.+\]$/.test(e.name)) return join(dir, e.name);
+    }
+  } catch {}
+  return null;
+}
+
+// Resolve one @slot dir against the URL segments below its layout. Returns a
+// React element (the slot's matched page/fragment, its default.tsx, wrapped in
+// any slot layouts + a fallback.tsx Suspense boundary) or null.
+async function resolveSlotElement(slotDir, segs) {
+  const React = await import("react");
+  let cur = slotDir;
+  const slotLayouts = [];
+  let matched = true;
+  for (let i = 0; i < segs.length; i++) {
+    const layoutFile = findFile(cur, "layout");
+    if (layoutFile) slotLayouts.push(layoutFile);
+    let next = join(cur, segs[i]);
+    if (!existsSync(next) || !statSync(next).isDirectory()) {
+      const dyn = findDynamicChild(cur);
+      if (dyn) next = dyn;
+      else {
+        matched = false;
+        break;
+      }
+    }
+    cur = next;
+  }
+  let leafFile = null;
+  if (matched) {
+    const layoutFile = findFile(cur, "layout");
+    if (layoutFile && !slotLayouts.includes(layoutFile)) slotLayouts.push(layoutFile);
+    leafFile = findFile(cur, "page") || findFile(cur, "fragment");
+  }
+  if (!leafFile) {
+    // Unmatched slot → default.tsx (Next.js semantics), else nothing.
+    const def = findFile(slotDir, "default");
+    if (!def) return null;
+    leafFile = def;
+    slotLayouts.length = 0;
+    const rootLayout = findFile(slotDir, "layout");
+    if (rootLayout) slotLayouts.push(rootLayout);
+  }
+  let mod;
+  try {
+    mod = await loadModuleFresh(leafFile);
+  } catch {
+    return null;
+  }
+  const Comp = mod.default ?? mod.Page ?? mod.Fragment ?? mod.page ?? mod.fragment;
+  if (!Comp) return null;
+  let el = React.createElement(Comp, {});
+  for (let i = slotLayouts.length - 1; i >= 0; i--) {
+    try {
+      const lm = await loadModuleFresh(slotLayouts[i]);
+      const L = lm.default ?? lm.Layout ?? lm.layout;
+      if (L) el = React.createElement(L, null, el);
+    } catch {}
+  }
+  const fallbackFile = findFile(slotDir, "fallback");
+  if (fallbackFile) {
+    try {
+      const fb = await loadModuleFresh(fallbackFile);
+      const Fallback = fb.default ?? fb.Fallback;
+      if (Fallback) el = React.createElement(React.Suspense, { fallback: React.createElement(Fallback, {}) }, el);
+    } catch {}
+  }
+  return el;
+}
+
+// Collect all @slot dirs of a layout dir into named props for the layout.
+async function resolveParallelSlots(dir, segs) {
+  const slots = {};
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return slots;
+  }
+  for (const e of entries) {
+    if (e.isDirectory() && e.name.startsWith("@")) {
+      const el = await resolveSlotElement(join(dir, e.name), segs);
+      if (el) slots[e.name.slice(1)] = el;
+    }
+  }
+  return slots;
+}
+
 async function renderRoute(urlPath, req) {
   const segments = urlToRouteSegments(urlPath);
   const route = resolvePageRoute(segments);
@@ -1168,10 +1291,28 @@ async function renderRoute(urlPath, req) {
         tree,
       );
     }
-    for (let i = layouts.length - 1; i >= 0; i--) {
-      const layoutMod = await loadModuleFresh(layouts[i].file);
-      const Layout = layoutMod.default ?? layoutMod.Layout ?? layoutMod.layout;
-      if (Layout) tree = React.createElement(Layout, null, tree);
+    // Wrap the page with each segment's template then layout, innermost dir
+    // first, so the nesting is layout > template > children (Next.js order).
+    // template.tsx re-mounts on navigation; on the server it just wraps.
+    const dirChain = route.dirChain && route.dirChain.length ? route.dirChain : [APP_DIR];
+    for (let i = dirChain.length - 1; i >= 0; i--) {
+      const dir = dirChain[i];
+      const templateFile = findFile(dir, "template");
+      if (templateFile) {
+        const tmod = await loadModuleFresh(templateFile);
+        const Template = tmod.default ?? tmod.Template ?? tmod.template;
+        if (Template) tree = React.createElement(Template, null, tree);
+      }
+      const layoutFile = findFile(dir, "layout");
+      if (layoutFile) {
+        const layoutMod = await loadModuleFresh(layoutFile);
+        const Layout = layoutMod.default ?? layoutMod.Layout ?? layoutMod.layout;
+        if (Layout) {
+          // Parallel routes: @slot subdirs of this layout become named props.
+          const slotProps = await resolveParallelSlots(dir, segments.slice(i));
+          tree = React.createElement(Layout, slotProps, tree);
+        }
+      }
     }
     const html = await renderToStringCompat(tree);
     if (runtime?.__setRouteContext) runtime.__setRouteContext(null);
@@ -1226,10 +1367,93 @@ async function renderRoute(urlPath, req) {
         }
       } catch {}
     }
+    // global-error.tsx — root-level boundary. It renders its own <html>/<body>,
+    // so it replaces the whole document. Only kicks in for uncaught errors when
+    // no closer error/error-recovery boundary handled them.
+    const globalErrorFile = findFile(APP_DIR, "global-error");
+    if (globalErrorFile) {
+      try {
+        const React = await import("react");
+        const mod = await loadModule(globalErrorFile, { bust: true });
+        const GlobalError = mod.default ?? mod.GlobalError;
+        if (GlobalError) {
+          const inner = await renderToStringCompat(
+            React.createElement(GlobalError, { error: err, reset: () => {} }),
+          );
+          // status:200 here only gates past the dev error overlay; the
+          // rawResponse carries the real 500 to the client.
+          return {
+            status: 200,
+            html: null,
+            error: null,
+            segments,
+            rawResponse: new Response(`<!DOCTYPE html>${inner}`, {
+              status: 500,
+              headers: { "Content-Type": "text/html; charset=utf-8" },
+            }),
+          };
+        }
+      } catch {}
+    }
     return { status: 500, html: null, error: err, segments, pageFile: route.file };
   }
 }
 
+async function resolveTransitionConfig(segments) {
+  const file = findRouteFileUp(segments || [], "transition");
+  if (!file) return null;
+  try {
+    const mod = await loadModuleFresh(file);
+    const cfg = mod.default && typeof mod.default === "object" ? mod.default : {};
+    const type = mod.type ?? cfg.type ?? "fade";
+    const out = { type };
+    const duration = mod.duration ?? cfg.duration;
+    if (duration) out.duration = Number(duration);
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+async function resolvePrefetchConfig(segments) {
+  const file = findRouteFileUp(segments || [], "prefetch");
+  if (!file) return null;
+  try {
+    const mod = await loadModuleFresh(file);
+    const cfg = mod.default && typeof mod.default === "object" ? mod.default : {};
+    const strategy = mod.strategy ?? cfg.strategy ?? "hover";
+    const out = { strategy };
+    const margin = mod.margin ?? cfg.margin;
+    if (margin) out.margin = String(margin);
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+const pendingOverlayCache = new Map();
+async function renderPendingOverlay(segments) {
+  const file = findRouteFileUp(segments || [], "pending");
+  if (!file) return "";
+  try {
+    let inner;
+    const cached = pendingOverlayCache.get(file);
+    if (cached && cached.gen === buildGeneration) {
+      inner = cached.html;
+    } else {
+      const React = await import("react");
+      const mod = await loadModuleFresh(file);
+      const Pending = mod.default ?? mod.Pending ?? mod.pending;
+      if (!Pending) return "";
+      inner = await renderToStringCompat(React.createElement(Pending, {}));
+      pendingOverlayCache.set(file, { gen: buildGeneration, html: inner });
+    }
+    return `<div id="__sr-pending" data-sr-pending hidden style="position:fixed;top:0;left:0;right:0;z-index:2147483646;pointer-events:none">${inner}</div>`;
+  } catch {
+    return "";
+  }
+}
+
 async function renderNotFound(segments) {
   const notFoundFile = findNotFound(segments);
   if (!notFoundFile) {
@@ -1318,6 +1542,7 @@ async function wrapInDocumentAsync({ head, body }) {
 <meta charset="utf-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1" />
 ${fullHead}
+<script src="/_swift-rust/navigator.js" defer></script>
 <script src="/_swift-rust/hmr-client.js" defer></script>
 </head>
 <body>${body}</body>
@@ -1333,6 +1558,15 @@ async function tryHmrClient() {
   }
 }
 
+function readNavigatorClient() {
+  try {
+    const file = join(dirname(new URL(import.meta.url).pathname), "runtime", "navigator.js");
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+
 function shouldIgnoreFile(filename) {
   if (!filename) return true;
   const base = filename.split(sep).pop();
@@ -1716,6 +1950,14 @@ async function handleFetch(req) {
     return new Response("Not found", { status: 404 });
   }
 
+  if (pathname === "/_swift-rust/navigator.js") {
+    const client = readNavigatorClient();
+    if (client) {
+      return new Response(client, { headers: { "Content-Type": "application/javascript; charset=utf-8" } });
+    }
+    return new Response("// navigator unavailable", { status: 404, headers: { "Content-Type": "application/javascript" } });
+  }
+
   if (pathname === "/_swift-rust/image") {
     const target = url.searchParams.get("url");
     const w = parseInt(url.searchParams.get("w") || "0", 10);
@@ -1958,6 +2200,22 @@ async function handleFetch(req) {
     const src = `/_swift-rust/island.js?p=${encodeURIComponent(renderResult.pageFile)}`;
     doc = doc.replace("</body>", `<script type="module" src="${src}"></script>\n</body>`);
   }
+  // pending.tsx → hidden overlay the client navigator reveals while a
+  // navigation is in flight (see runtime/navigator.js).
+  const pendingOverlay = await renderPendingOverlay(renderResult.segments);
+  if (pendingOverlay) doc = doc.replace("</body>", `${pendingOverlay}\n</body>`);
+  // prefetch.ts → client prefetch strategy for the navigator.
+  const prefetchCfg = await resolvePrefetchConfig(renderResult.segments);
+  if (prefetchCfg) {
+    const json = JSON.stringify(prefetchCfg).replace(/</g, "\\u003c");
+    doc = doc.replace("</body>", `<script>window.__SR_PREFETCH__=${json}</script>\n</body>`);
+  }
+  // transition.tsx → View Transitions config for the navigator's swap.
+  const transitionCfg = await resolveTransitionConfig(renderResult.segments);
+  if (transitionCfg) {
+    const json = JSON.stringify(transitionCfg).replace(/</g, "\\u003c");
+    doc = doc.replace("</body>", `<script>window.__SR_TRANSITION__=${json}</script>\n</body>`);
+  }
   const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
   for (const c of renderResult.setCookies || []) headers.append("Set-Cookie", c);
   // config.ts headers

package/bin/error-overlay.mjs

@@ -113,8 +113,8 @@ function classifyError(message) {
         "The dev server could not bind to the requested port, " +
         "or it ran out of system resources.",
       suggestions: [
-        "Close any other process using this port (usually 3000)",
-        "Run with --port 3001 to use a different port",
+        "Close any other process using this port (usually 3210)",
+        "Run with --port <number> to use a different port",
         "Check disk space with `df -h`",
       ],
     };

package/bin/runtime/navigator.js

@@ -0,0 +1,238 @@
+// Swift-Rust client navigator — turns full-page loads into SPA navigation for
+// <a>/<Link>. Intercepts same-origin clicks, fetches the destination HTML,
+// swaps <body>, re-runs body scripts (island bootstrap + serialized state),
+// syncs <title>/meta, and manages history. Ships in dev and in the build
+// output (NOT dev-only like the HMR client).
+(() => {
+  if (window.__SR_NAV__) return;
+  const nav = (window.__SR_NAV__ = { cache: new Map(), inflight: new Map() });
+  const ORIGIN = location.origin;
+  const MAX_CACHE = 32;
+
+  function internalAnchor(a) {
+    if (!a || a.target === "_blank" || a.hasAttribute("download")) return null;
+    if (a.dataset.srNoNav !== undefined) return null;
+    const raw = a.getAttribute("href");
+    if (!raw || raw.startsWith("#") || raw.startsWith("mailto:") || raw.startsWith("tel:")) return null;
+    let url;
+    try {
+      url = new URL(a.href, location.href);
+    } catch {
+      return null;
+    }
+    if (url.origin !== ORIGIN) return null;
+    return url;
+  }
+
+  function remember(key, html) {
+    if (nav.cache.size >= MAX_CACHE) nav.cache.delete(nav.cache.keys().next().value);
+    nav.cache.set(key, html);
+  }
+
+  // Fetch (and cache) a route's HTML. Deduped per URL so prefetch + click share.
+  function fetchDoc(url) {
+    const key = url;
+    if (nav.cache.has(key)) return Promise.resolve(nav.cache.get(key));
+    if (nav.inflight.has(key)) return nav.inflight.get(key);
+    const p = fetch(url, { headers: { "x-swift-rust-nav": "1" }, credentials: "same-origin" })
+      .then((res) => {
+        if (!res.ok && res.status !== 404) throw new Error("nav fetch " + res.status);
+        return res.text();
+      })
+      .then((html) => {
+        remember(key, html);
+        nav.inflight.delete(key);
+        return html;
+      })
+      .catch((err) => {
+        nav.inflight.delete(key);
+        throw err;
+      });
+    nav.inflight.set(key, p);
+    return p;
+  }
+  nav.prefetch = (url) => fetchDoc(new URL(url, location.href).href).catch(() => {});
+
+  // Scripts inserted via DOM cloning don't execute; clone them into fresh nodes.
+  function runScripts(root) {
+    for (const old of root.querySelectorAll("script")) {
+      const s = document.createElement("script");
+      for (const att of old.attributes) s.setAttribute(att.name, att.value);
+      s.textContent = old.textContent;
+      old.replaceWith(s);
+    }
+  }
+
+  // transition.tsx → wrap the DOM swap in the View Transitions API. Config is
+  // injected as window.__SR_TRANSITION__ = { type, duration }. Falls back to a
+  // plain swap when unsupported, type "none", or reduced-motion is requested.
+  function injectTransitionStyle() {
+    if (document.getElementById("__sr-transition-style")) return;
+    const s = document.createElement("style");
+    s.id = "__sr-transition-style";
+    s.textContent =
+      "::view-transition-old(root),::view-transition-new(root){animation-duration:var(--sr-transition-duration,250ms)}" +
+      'html[data-sr-transition="slide"]::view-transition-old(root){animation-name:sr-vt-slide-out}' +
+      'html[data-sr-transition="slide"]::view-transition-new(root){animation-name:sr-vt-slide-in}' +
+      "@keyframes sr-vt-slide-out{to{opacity:0;transform:translateX(-24px)}}" +
+      "@keyframes sr-vt-slide-in{from{opacity:0;transform:translateX(24px)}}";
+    (document.head || document.documentElement).appendChild(s);
+  }
+
+  async function withTransition(apply) {
+    const t = window.__SR_TRANSITION__;
+    const reduce = window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    if (!t || !t.type || t.type === "none" || reduce || typeof document.startViewTransition !== "function") {
+      apply();
+      return;
+    }
+    const root = document.documentElement;
+    root.dataset.srTransition = t.type;
+    if (t.duration) root.style.setProperty("--sr-transition-duration", t.duration + "ms");
+    try {
+      const vt = document.startViewTransition(() => apply());
+      await vt.finished;
+    } catch {
+      // DOM was already updated inside the callback; nothing to recover.
+    } finally {
+      delete root.dataset.srTransition;
+    }
+  }
+
+  function syncHead(doc) {
+    const title = doc.querySelector("title");
+    if (title) document.title = title.textContent || document.title;
+    const selectors = ['meta[name="description"]', 'meta[property^="og:"]', 'meta[name^="twitter:"]', 'link[rel="canonical"]'];
+    for (const sel of selectors) {
+      document.head.querySelectorAll(sel).forEach((m) => m.remove());
+      doc.head.querySelectorAll(sel).forEach((m) => document.head.appendChild(m.cloneNode(true)));
+    }
+  }
+
+  // pending.tsx overlay: revealed only if a navigation outlasts the threshold,
+  // so fast (cached) navigations don't flash it.
+  let pendingTimer = null;
+  function showPending() {
+    const el = document.getElementById("__sr-pending");
+    if (el) el.hidden = false;
+  }
+  function clearPending() {
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+      pendingTimer = null;
+    }
+    const el = document.getElementById("__sr-pending");
+    if (el) el.hidden = true;
+  }
+
+  async function navigate(href, { push = true, scroll = true, replace = false } = {}) {
+    let html;
+    nav.active = href;
+    if (pendingTimer) clearTimeout(pendingTimer);
+    const delay = typeof window.__SR_NAV_PENDING_DELAY === "number" ? window.__SR_NAV_PENDING_DELAY : 120;
+    pendingTimer = setTimeout(showPending, delay);
+    window.dispatchEvent(new CustomEvent("sr:navigate-start", { detail: { url: href } }));
+    try {
+      html = await fetchDoc(href);
+    } catch {
+      location.href = href; // hard fallback
+      return;
+    }
+    if (nav.active !== href) return; // superseded by a newer navigation
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    if (!doc.body) {
+      location.href = href;
+      return;
+    }
+    const apply = () => {
+      document.body.replaceWith(doc.body);
+      runScripts(document.body);
+      syncHead(doc);
+    };
+    await withTransition(apply);
+    if (push) {
+      if (replace) history.replaceState({ srNav: true }, "", href);
+      else history.pushState({ srNav: true }, "", href);
+    }
+    if (scroll) window.scrollTo(0, 0);
+    clearPending();
+    window.dispatchEvent(new CustomEvent("sr:navigate-end", { detail: { url: href } }));
+  }
+  nav.navigate = navigate;
+
+  document.addEventListener(
+    "click",
+    (e) => {
+      if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      const a = e.target.closest && e.target.closest("a");
+      const url = internalAnchor(a);
+      if (!url) return;
+      e.preventDefault();
+      if (url.href === location.href) return;
+      navigate(url.href, {
+        push: true,
+        scroll: a.dataset.srScroll !== "false",
+        replace: a.dataset.srReplace === "true",
+      });
+    },
+    false,
+  );
+
+  window.addEventListener("popstate", () => {
+    navigate(location.href, { push: false, scroll: false });
+  });
+
+  // ── Prefetch (prefetch.ts) ────────────────────────────────────────────────
+  // Strategy comes from the per-route prefetch.ts, injected as
+  // window.__SR_PREFETCH__ = { strategy, margin? }. Default: "hover".
+  // Per-link opt-out via data-sr-prefetch="false".
+  function strategy() {
+    const c = window.__SR_PREFETCH__;
+    return (c && c.strategy) || "hover";
+  }
+  function prefetchableURL(a) {
+    if (!a || a.dataset.srPrefetch === "false") return null;
+    return internalAnchor(a);
+  }
+  function intent(e) {
+    if (strategy() !== "hover") return;
+    const a = e.target.closest && e.target.closest("a");
+    const url = prefetchableURL(a);
+    if (url && url.href !== location.href) nav.prefetch(url.href);
+  }
+  document.addEventListener("mouseover", intent, { passive: true });
+  document.addEventListener("focusin", intent);
+  document.addEventListener("touchstart", intent, { passive: true });
+
+  let io = null;
+  function scanViewport() {
+    if (io) {
+      io.disconnect();
+      io = null;
+    }
+    if (strategy() !== "viewport" || !("IntersectionObserver" in window)) return;
+    const margin = (window.__SR_PREFETCH__ && window.__SR_PREFETCH__.margin) || "200px";
+    io = new IntersectionObserver(
+      (entries) => {
+        for (const en of entries) {
+          if (!en.isIntersecting) continue;
+          const url = prefetchableURL(en.target);
+          if (url && url.href !== location.href) nav.prefetch(url.href);
+          io.unobserve(en.target);
+        }
+      },
+      { rootMargin: margin },
+    );
+    document.querySelectorAll("a[href]").forEach((a) => {
+      if (prefetchableURL(a)) io.observe(a);
+    });
+  }
+  window.addEventListener("sr:navigate-end", scanViewport);
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", scanViewport, { once: true });
+  } else {
+    scanViewport();
+  }
+
+  injectTransitionStyle();
+})();

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: _prefetch, replace: _replace, scroll: _scroll, children, ...rest }: LinkProps): import("react").JSX.Element;
+export declare function Link({ href, prefetch, replace, scroll, children, ...rest }: LinkProps): import("react").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,EACnB,IAAI,EACJ,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,OAAO,EACf,QAAQ,EACR,GAAG,IAAI,EACR,EAAE,SAAS,+BAMX"}
+{"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"}

package/dist/link.jsx

@@ -1,5 +1,14 @@
-export function Link({ href, prefetch: _prefetch, replace: _replace, scroll: _scroll, children, ...rest }) {
-    return (<a href={href} {...rest}>
+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.
+    const dataAttrs = {};
+    if (replace)
+        dataAttrs["data-sr-replace"] = "true";
+    if (scroll === false)
+        dataAttrs["data-sr-scroll"] = "false";
+    if (prefetch === false)
+        dataAttrs["data-sr-prefetch"] = "false";
+    return (<a href={href} {...dataAttrs} {...rest}>
       {children}
     </a>);
 }

package/dist/link.jsx.map

@@ -1 +1 @@
-{"version":3,"file":"link.jsx","sourceRoot":"","sources":["../src/link.tsx"],"names":[],"mappings":"AAUA,MAAM,UAAU,IAAI,CAAC,EACnB,IAAI,EACJ,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,OAAO,EACf,QAAQ,EACR,GAAG,IAAI,EACG;IACV,OAAO,CACL,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CACtB;MAAA,CAAC,QAAQ,CACX;IAAA,EAAE,CAAC,CAAC,CACL,CAAC;AACJ,CAAC"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swift-rust",
-  "version": "1.1.0",
+  "version": "1.3.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",
@@ -22,6 +22,7 @@
   "types": "./dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
+    "./tsconfig.base.json": "./tsconfig.base.json",
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
@@ -74,7 +75,8 @@
     "dist",
     "bin",
     "scripts",
-    "native"
+    "native",
+    "tsconfig.base.json"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/tsconfig.base.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "swift-rust base",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true
+  }
+}