swift-rust 1.2.1 → 1.4.0

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/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/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: _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-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,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,2CAYrF"}

package/dist/link.js

@@ -0,0 +1,14 @@
+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.
+    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 (_jsx("a", { href: href, ...dataAttrs, ...rest, children: children }));
+}
+//# sourceMappingURL=link.js.map

package/dist/link.js.map

@@ -0,0 +1 @@
+{"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.2.1",
+  "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"}