swift-rust 1.2.1 → 1.3.0

package/bin/build.mjs

@@ -412,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

@@ -1126,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);
@@ -1199,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);
@@ -1257,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) {
@@ -1349,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>
@@ -1364,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();
@@ -1747,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);
@@ -1989,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/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.2.1",
+  "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",