swift-rust 1.8.0 → 1.10.2

package/bin/dev-server.mjs

@@ -414,22 +414,22 @@ function detectIslandExports(src) {
   return { hasDefault, named: [...named] };
 }
 
-// Temp sibling files holding verbatim copies of client components, so the
+// Build the source of an island wrapper module for a given client component
+// file. Temp sibling files hold verbatim copies of client components, so the
 // wrapper can import the *real* module under a distinct on-disk path (Bun
 // dedupes modules by resolved path, so a query-string alias would collapse the
-// real module into the wrapper). Cleaned up after each SSR build.
-const islandRawTemps = [];
-
-// Build the source of an island wrapper module for a given client component file.
-function islandWrapperSource(abs) {
+// real module into the wrapper). `temps` is per-build: a shared global list
+// let concurrent builds delete each other's temp files mid-build, which
+// surfaced as transient module-not-found errors on save.
+function islandWrapperSource(abs, temps) {
   const src = readFileSync(abs, "utf8");
   const { hasDefault, named } = detectIslandExports(src);
   // Write the real component to a unique sibling so imports resolve identically.
   const rawName = `.__sr_raw_${process.pid}_${Math.random().toString(36).slice(2)}__${basename(abs)}`;
   const rawPath = join(dirname(abs), rawName);
   writeFileSync(rawPath, src);
-  islandRawTemps.push(rawPath);
-  const rawSpec = JSON.stringify("./" + rawName);
+  temps.push(rawPath);
+  const rawSpec = JSON.stringify(rawPath);
   let out = `import { createElement as __h } from "react";
 import * as __real from ${rawSpec};
 const __src = ${JSON.stringify(abs)};
@@ -467,43 +467,152 @@ function __wrap(Comp, name){
   return out;
 }
 
+// Which exported names of a 'use cache' module are *async functions* (the only
+// ones safe to wrap with cache(), since cache() always returns a Promise). We
+// pass everything else through untouched.
+function detectAsyncExports(src) {
+  const code = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1");
+  const asyncNamed = new Set();
+  const allNamed = new Set();
+  let defaultAsync = false;
+  let hasDefault = false;
+  if (/\bexport\s+default\b/.test(code)) {
+    hasDefault = true;
+    if (/\bexport\s+default\s+async\b/.test(code)) defaultAsync = true;
+  }
+  for (const m of code.matchAll(/\bexport\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)/g)) {
+    allNamed.add(m[2]);
+    if (m[1]) asyncNamed.add(m[2]);
+  }
+  for (const m of code.matchAll(/\bexport\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(async\b)?/g)) {
+    allNamed.add(m[1]);
+    if (m[2]) asyncNamed.add(m[1]);
+  }
+  for (const m of code.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
+    for (const part of m[1].split(",")) {
+      const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+      if (name && name !== "default") allNamed.add(name);
+    }
+  }
+  return { asyncNamed: [...asyncNamed], allNamed: [...allNamed], defaultAsync, hasDefault };
+}
+
+// Source of a wrapper module that memoizes a 'use cache' module's async exports.
+function cacheWrapperSource(abs, temps) {
+  const src = readFileSync(abs, "utf8");
+  const { asyncNamed, allNamed, defaultAsync, hasDefault } = detectAsyncExports(src);
+  const rawName = `.__sr_raw_${process.pid}_${Math.random().toString(36).slice(2)}__${basename(abs)}`;
+  const rawPath = join(dirname(abs), rawName);
+  writeFileSync(rawPath, src);
+  temps.push(rawPath);
+  const tag = relative(cwd, abs);
+  let out = `import { cache as __cache } from "swift-rust/cache";
+import * as __real from ${JSON.stringify(rawPath)};
+const __opts = { tags: ${JSON.stringify([tag])} };
+`;
+  if (hasDefault) {
+    out += defaultAsync
+      ? `export default __cache(__real.default, __opts);\n`
+      : `export default __real.default;\n`;
+  }
+  for (const n of allNamed) {
+    out += asyncNamed.includes(n)
+      ? `export const ${n} = __cache(__real[${JSON.stringify(n)}], __opts);\n`
+      : `export const ${n} = __real[${JSON.stringify(n)}];\n`;
+  }
+  return out;
+}
+
+// Bun plugin: auto-memoize modules that declare a leading 'use cache' directive.
+// Built per-build so each build owns its temp-file list (see islandWrapperSource).
+function makeUseCachePlugin(temps) {
+  return {
+    name: "sr-use-cache",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const p = args.path;
+        if (!(p.startsWith(".") || p.startsWith("/") || p.startsWith("@/"))) return undefined;
+        // Our own raw temp copy: resolve it explicitly into the file namespace.
+        // (Deferring to Bun's default resolver fails from a virtual namespace.)
+        if (/\.__sr_raw_/.test(p)) return { path: p, namespace: "file" };
+        if (args.importer && hasUseDirective(args.importer, "cache")) return undefined;
+        const abs = resolveIslandSpecifier(p, args.importer);
+        if (!abs || !hasUseDirective(abs, "cache")) return undefined;
+        return { path: abs, namespace: "sr-cache" };
+      });
+      build.onLoad({ filter: /.*/, namespace: "sr-cache" }, (args) => ({
+        contents: cacheWrapperSource(args.path, temps),
+        loader: "js",
+        resolveDir: dirname(args.path),
+      }));
+    },
+  };
+}
+
 // Bun plugin: wrap client components imported by *server* modules as islands.
-const clientIslandPlugin = {
-  name: "sr-client-islands",
-  setup(build) {
-    build.onResolve({ filter: /.*/ }, (args) => {
-      const p = args.path;
-      if (!(p.startsWith(".") || p.startsWith("/") || p.startsWith("@/"))) return undefined;
-      // Never wrap our own temp raw copies, and don't wrap when the importer is
-      // itself a client module — nested client components belong to that
-      // island's bundle, not a new boundary.
-      if (/\.__sr_raw_/.test(p)) return undefined;
-      if (args.importer && hasUseDirective(args.importer, "client")) return undefined;
-      const abs = resolveIslandSpecifier(p, args.importer);
-      if (!abs || !hasUseDirective(abs, "client")) return undefined;
-      return { path: abs, namespace: "sr-island" };
-    });
-    build.onLoad({ filter: /.*/, namespace: "sr-island" }, (args) => ({
-      contents: islandWrapperSource(args.path),
-      loader: "js",
-      resolveDir: dirname(args.path),
-    }));
-  },
-};
+function makeClientIslandPlugin(temps) {
+  return {
+    name: "sr-client-islands",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const p = args.path;
+        if (!(p.startsWith(".") || p.startsWith("/") || p.startsWith("@/"))) return undefined;
+        // Never wrap our own temp raw copies, and don't wrap when the importer is
+        // itself a client module — nested client components belong to that
+        // island's bundle, not a new boundary.
+        if (/\.__sr_raw_/.test(p)) return { path: p, namespace: "file" };
+        if (args.importer && hasUseDirective(args.importer, "client")) return undefined;
+        const abs = resolveIslandSpecifier(p, args.importer);
+        if (!abs || !hasUseDirective(abs, "client")) return undefined;
+        return { path: abs, namespace: "sr-island" };
+      });
+      build.onLoad({ filter: /.*/, namespace: "sr-island" }, (args) => ({
+        contents: islandWrapperSource(args.path, temps),
+        loader: "js",
+        resolveDir: dirname(args.path),
+      }));
+    },
+  };
+}
+
+// In-flight build dedup: concurrent requests for the same entry (every open tab
+// reloads at once on an HMR broadcast) await one build instead of racing.
+function withInflight(map, key, gen, factory) {
+  const cur = map.get(key);
+  if (cur && cur.gen === gen) return cur.promise;
+  const entry = { gen, promise: null };
+  entry.promise = (async () => {
+    try {
+      return await factory();
+    } finally {
+      if (map.get(key) === entry) map.delete(key);
+    }
+  })();
+  map.set(key, entry);
+  return entry.promise;
+}
 
 // Cache for per-component browser island bundles (src -> { gen, code }).
 // Each bundle is self-mounting: it imports the client component, finds every
 // marker on the page for this source, and hydrates it. React is bundled in, so a
 // single <script type="module"> per source needs no import map or shared runtime.
 const componentIslandCache = new Map();
+const componentIslandInflight = new Map();
 async function buildComponentIslandBundle(srcFile) {
   if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
     throw new Error("client islands require the Bun runtime");
   }
   const cached = componentIslandCache.get(srcFile);
   if (cached && cached.gen === buildGeneration) return cached.code;
-
-  const entryPath = join(dirname(srcFile), `.__sr_cisland_${process.pid}_${Date.now()}.js`);
+  return withInflight(componentIslandInflight, srcFile, buildGeneration, () =>
+    buildComponentIslandBundleNow(srcFile),
+  );
+}
+async function buildComponentIslandBundleNow(srcFile) {
+  const entryPath = join(
+    dirname(srcFile),
+    `.__sr_cisland_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2)}.js`,
+  );
   const entry = `import { hydrateRoot, createRoot } from "react-dom/client";
 import { createElement } from "react";
 import * as __mod from ${JSON.stringify(srcFile)};
@@ -551,6 +660,7 @@ function collectIslandSources(html) {
 }
 
 const ssrBundleCache = new Map(); // file -> { gen, mod }
+const ssrInflight = new Map(); // file -> { gen, promise }
 
 async function loadModuleFresh(filePath) {
   if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
@@ -558,28 +668,32 @@ async function loadModuleFresh(filePath) {
   }
   const cached = ssrBundleCache.get(filePath);
   if (cached && cached.gen === buildGeneration) return cached.mod;
+  return withInflight(ssrInflight, filePath, buildGeneration, () =>
+    buildSsrModule(filePath, buildGeneration),
+  );
+}
 
-  islandRawTemps.length = 0;
+async function buildSsrModule(filePath, gen) {
+  const temps = [];
   let result;
   try {
     result = await Bun.build({
       entrypoints: [filePath],
       target: "bun",
-      plugins: [clientIslandPlugin, externalizeDepsPlugin],
+      plugins: [makeUseCachePlugin(temps), makeClientIslandPlugin(temps), externalizeDepsPlugin],
     });
   } finally {
-    for (const t of islandRawTemps) { try { unlinkSync(t); } catch {} }
-    islandRawTemps.length = 0;
+    for (const t of temps) { try { unlinkSync(t); } catch {} }
   }
   if (!result.success) {
     throw new Error(result.logs.map((l) => l.message).join("\n"));
   }
   const code = await result.outputs[0].text();
-  const tmp = join(dirname(filePath), `.__sr_ssr_${buildGeneration}_${Math.random().toString(36).slice(2)}.mjs`);
+  const tmp = join(dirname(filePath), `.__sr_ssr_${gen}_${Math.random().toString(36).slice(2)}.mjs`);
   writeFileSync(tmp, code);
   try {
     const mod = await import(pathToFileURL(tmp).href);
-    ssrBundleCache.set(filePath, { gen: buildGeneration, mod });
+    ssrBundleCache.set(filePath, { gen, mod });
     return mod;
   } finally {
     try { unlinkSync(tmp); } catch {}
@@ -617,11 +731,15 @@ async function compileRoute(urlPath) {
   }
 
   try {
-    await loadModule(route.file, { bust: true });
-    for (const layout of layouts) await loadModule(layout.file, { bust: true });
-    if (notFoundFile) await loadModule(notFoundFile, { bust: true });
-    if (errorFile) await loadModule(errorFile, { bust: true });
-    if (loadingFile) await loadModule(loadingFile, { bust: true });
+    // Generation-keyed bundles: a save bumps the generation (fresh build), an
+    // unchanged file is a cache hit. The old `?t=` bust-imports created new
+    // module instances on every request — they leaked (ESM registry entries
+    // are permanent) and, under Bun, didn't even pick up child-module edits.
+    await loadModuleFresh(route.file);
+    for (const layout of layouts) await loadModuleFresh(layout.file);
+    if (notFoundFile) await loadModuleFresh(notFoundFile);
+    if (errorFile) await loadModuleFresh(errorFile);
+    if (loadingFile) await loadModuleFresh(loadingFile);
   } catch (err) {
     compileTimings.set(urlPath, performance.now() - start);
     return { ok: false, reason: "compile_error", error: err, pageFile: route.file, layoutFile: layouts[0]?.file, params: route.params, segments };
@@ -645,14 +763,33 @@ function findAppGlobalsCss() {
   return null;
 }
 
+// A require() rooted at the user's project, so Node module resolution walks the
+// real node_modules tree (project → monorepo root → …) and finds packages
+// wherever the package manager hoisted them. Critical for production builds
+// (e.g. Vercel), where hard-coded ../../node_modules guesses miss the plugin
+// and Tailwind silently doesn't compile — shipping an unstyled site.
+let _projectRequire;
+function projectRequire() {
+  if (!_projectRequire) _projectRequire = createRequire(join(cwd, "package.json"));
+  return _projectRequire;
+}
+
 let postcssInstance = null;
 async function getPostcss() {
   if (postcssInstance !== null) return postcssInstance;
+  // 1) Resolve through the project's module graph.
+  try {
+    const entry = projectRequire().resolve("postcss");
+    const mod = await import(pathToFileURL(entry).href);
+    postcssInstance = { available: true, default: mod.default ?? mod, mod };
+    return postcssInstance;
+  } catch {}
+  // 2) Hard-coded fallbacks, then a bare import.
   try {
     const candidates = [
       join(cwd, "node_modules", "postcss"),
-      join(cwd, "node_modules", "postcss", "lib", "postcss.mjs"),
-      join(cwd, "node_modules", "postcss", "lib", "postcss.js"),
+      join(cwd, "..", "..", "node_modules", "postcss"),
+      join(cwd, "..", "..", "..", "node_modules", "postcss"),
     ];
     for (const candidate of candidates) {
       if (existsSync(candidate)) {
@@ -671,9 +808,19 @@ async function getPostcss() {
 }
 
 async function loadPostcssPluginByName(name) {
+  // 1) Node resolution from the project root — finds the plugin at any hoist level.
+  try {
+    const entryPath = projectRequire().resolve(name);
+    const mod = await import(pathToFileURL(entryPath).href);
+    const result = mod.default ?? mod;
+    logLine([` ${paint("dim", "css plugin loaded:")} ${paint("cyan", name)} ${paint("dim", "(resolved)")}`], 1);
+    return result;
+  } catch {}
+  // 2) Fallback: scan a few likely node_modules locations.
   const candidates = [
     join(cwd, "node_modules", name),
     join(cwd, "..", "..", "node_modules", name),
+    join(cwd, "..", "..", "..", "node_modules", name),
   ];
   for (const candidate of candidates) {
     const pkgJsonPath = join(candidate, "package.json");
@@ -696,7 +843,7 @@ async function loadPostcssPluginByName(name) {
       }
     }
   }
-  logLine([` ${paint("dim", "css plugin not found:")} ${paint("yellow", name)}`], 1);
+  logLine([` ${paint("dim", "css plugin not found:")} ${paint("yellow", name)} ${paint("dim", "— is it in dependencies?")}`], 1);
   return null;
 }
 
@@ -890,13 +1037,13 @@ async function resolveMetadata(layoutFiles, pageFile, params, segments) {
   const metas = [];
   for (const layoutFile of layoutFiles || []) {
     try {
-      const mod = await loadModule(layoutFile, { bust: true });
+      const mod = await loadModuleFresh(layoutFile);
       if (mod.metadata) metas.push(mod.metadata);
     } catch {}
   }
   if (pageFile) {
     try {
-      const mod = await loadModule(pageFile, { bust: true });
+      const mod = await loadModuleFresh(pageFile);
       if (mod.generateMetadata) {
         const m = await mod.generateMetadata({ params: params || {}, searchParams: {} });
         if (m) metas.push(m);
@@ -1072,6 +1219,7 @@ export function hasUseDirective(file, name) {
   return false;
 }
 
+const islandBundleInflight = new Map();
 async function buildIslandBundle(pageFile) {
   if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
     throw new Error("client islands require the Bun runtime");
@@ -1079,9 +1227,16 @@ async function buildIslandBundle(pageFile) {
   assertNoServerComponentInClientPage(pageFile);
   const cached = islandBundleCache.get(pageFile);
   if (cached && cached.gen === buildGeneration) return cached.code;
-
+  return withInflight(islandBundleInflight, pageFile, buildGeneration, () =>
+    buildIslandBundleNow(pageFile),
+  );
+}
+async function buildIslandBundleNow(pageFile) {
   // Temp hydration entry, written next to the page so module resolution works.
-  const entryPath = join(dirname(pageFile), `.__sr_island_${process.pid}_${Date.now()}.js`);
+  const entryPath = join(
+    dirname(pageFile),
+    `.__sr_island_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2)}.js`,
+  );
   const entry = `import { createRoot } from "react-dom/client";
 import { createElement } from "react";
 import Page from ${JSON.stringify(pageFile)};
@@ -1796,7 +1951,7 @@ async function renderRoute(urlPath, req) {
     if (errorFile) {
       try {
         const React = await import("react");
-        const errorMod = await loadModule(errorFile, { bust: true });
+        const errorMod = await loadModuleFresh(errorFile);
         const ErrorBoundary = errorMod.default ?? errorMod.ErrorBoundary ?? errorMod.error;
         if (ErrorBoundary) {
           const html = await renderToStringCompat(React.createElement(ErrorBoundary, { error: err }));
@@ -1809,7 +1964,7 @@ async function renderRoute(urlPath, req) {
     if (recoveryFile) {
       try {
         const React = await import("react");
-        const mod = await loadModule(recoveryFile, { bust: true });
+        const mod = await loadModuleFresh(recoveryFile);
         const Recovery = mod.default ?? mod.ErrorRecovery;
         if (Recovery) {
           const html = await renderToStringCompat(
@@ -1826,7 +1981,7 @@ async function renderRoute(urlPath, req) {
     if (globalErrorFile) {
       try {
         const React = await import("react");
-        const mod = await loadModule(globalErrorFile, { bust: true });
+        const mod = await loadModuleFresh(globalErrorFile);
         const GlobalError = mod.default ?? mod.GlobalError;
         if (GlobalError) {
           const inner = await renderToStringCompat(
@@ -1914,14 +2069,14 @@ async function renderNotFound(segments) {
   try {
     const React = await import("react");
     const layouts = findLayoutsFor(segments || []);
-    const mod = await loadModule(notFoundFile, { bust: true });
+    const mod = await loadModuleFresh(notFoundFile);
     const NotFound = mod.default ?? mod.NotFound ?? mod.notFound;
     if (!NotFound) {
       return { status: 404, html: null, error: null, segments };
     }
     let tree = React.createElement(NotFound);
     for (let i = layouts.length - 1; i >= 0; i--) {
-      const layoutMod = await loadModule(layouts[i].file, { bust: true });
+      const layoutMod = await loadModuleFresh(layouts[i].file);
       const Layout = layoutMod.default ?? layoutMod.Layout ?? layoutMod.layout;
       if (Layout) tree = React.createElement(Layout, null, tree);
     }
@@ -2019,83 +2174,219 @@ function readNavigatorClient() {
   }
 }
 
-function shouldIgnoreFile(filename) {
-  if (!filename) return true;
-  const base = filename.split(sep).pop();
-  if (!base) return true;
-  if (base.startsWith(".")) return true;
+const WATCH_IGNORE_DIRS = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  "target",
+]);
+
+// Ignore anything inside a dep/build dir, any dot-prefixed path segment (which
+// also covers our own .__sr_* build temps and dirs like .git/.turbo/.next),
+// and editor scratch suffixes.
+function isIgnoredWatchPath(full) {
+  const rel = relative(cwd, full);
+  if (!rel || rel.startsWith("..")) return true;
+  const parts = rel.split(sep);
+  for (const p of parts) {
+    if (!p || p.startsWith(".")) return true;
+    if (WATCH_IGNORE_DIRS.has(p)) return true;
+  }
+  const base = parts[parts.length - 1];
   if (base.endsWith(".bak") || base.endsWith(".tmp") || base.endsWith("~")) return true;
-  if (base === "node_modules") return true;
   return false;
 }
 
+const SYNTAX_CHECK_LOADERS = { ".ts": "ts", ".tsx": "tsx", ".js": "js", ".jsx": "jsx", ".mjs": "js" };
+
+// Quick transpile of the changed sources before telling the browser to reload.
+// Editors save in stages (truncate+write, format-on-save), so the first FS
+// event often fires mid-write; compiling that state used to navigate every tab
+// into a dead 500 page. A failed check retries once after a beat (to skate
+// over partial writes); a persistent failure is a real syntax error.
+async function findSyntaxError(files) {
+  if (typeof Bun === "undefined" || typeof Bun.Transpiler !== "function") return null;
+  for (const file of files) {
+    const loader = SYNTAX_CHECK_LOADERS[extname(file)];
+    if (!loader) continue;
+    for (let attempt = 0; ; attempt++) {
+      let src;
+      try {
+        src = readFileSync(file, "utf8");
+      } catch {
+        break; // deleted — nothing to check
+      }
+      try {
+        new Bun.Transpiler({ loader }).transformSync(src);
+        break;
+      } catch (err) {
+        if (attempt >= 1) {
+          const msg = err?.message || String(err);
+          return `${relative(cwd, file)}: ${msg}`;
+        }
+        await new Promise((r) => setTimeout(r, 150));
+      }
+    }
+  }
+  return null;
+}
+
+function broadcastHmr(data) {
+  const payload = JSON.stringify({ event: "change", data });
+  for (const send of hmrClients) {
+    try {
+      send(payload);
+    } catch {}
+  }
+}
+
 function setupWatcher() {
   if (!existsSync(APP_DIR)) return;
   const watchers = new Map();
+  let recursiveMode = false;
 
-  const IGNORE_DIRS = new Set([
-    "node_modules",
-    "dist",
-    "build",
-    "out",
-    "coverage",
-    "target",
-    ".git",
-    ".vercel",
-    ".turbo",
-    ".swift-rust",
-    ".next",
-  ]);
+  // ── Debounced batch flush ──────────────────────────────────────────────────
+  // All events funnel into one pending set; a flush invalidates caches once,
+  // syntax-checks the batch, and broadcasts a single reload (or error).
+  const pendingFiles = new Set();
+  let pendingWildcard = false; // event with no usable filename → invalidate broadly
+  let flushTimer = null;
+  let flushing = false;
+  let lastFlushErrored = false;
+
+  function scheduleFlush() {
+    if (flushTimer) clearTimeout(flushTimer);
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      void flush();
+    }, 80);
+  }
+
+  function noteChange(full) {
+    pendingFiles.add(full);
+    scheduleFlush();
+  }
+
+  function noteWildcard() {
+    pendingWildcard = true;
+    scheduleFlush();
+  }
+
+  async function flush() {
+    if (flushing) {
+      scheduleFlush();
+      return;
+    }
+    flushing = true;
+    try {
+      const files = [...pendingFiles];
+      pendingFiles.clear();
+      const wildcard = pendingWildcard;
+      pendingWildcard = false;
+      if (!files.length && !wildcard) return;
+
+      buildGeneration++;
+      for (const full of files) {
+        logEvent("change", full);
+        bustCache(full);
+        if (full.endsWith(`${sep}layout.tsx`) || full.endsWith(`${sep}layout.ts`)) {
+          fontsScannedFromLayout = false;
+          GOOGLE_FONT_FAMILIES.clear();
+        }
+      }
+      // Any source edit can introduce new utility classes (Tailwind scans the
+      // source tree), so re-run the CSS pipeline on every flush — not only when
+      // globals.css itself changes. mtime caching keeps subsequent requests hot.
+      globalsCssCache = { file: null, mtime: 0, css: "" };
+      if (wildcard) {
+        fontsScannedFromLayout = false;
+        GOOGLE_FONT_FAMILIES.clear();
+      }
+
+      const syntaxError = await findSyntaxError(files);
+      if (syntaxError) {
+        // Overlay on the live page instead of reloading into a dead 500 —
+        // page state survives, and the next clean save reloads normally.
+        lastFlushErrored = true;
+        logLine([` ${paint("red", "✗")} ${paint("red", syntaxError.split("\n")[0])}`]);
+        broadcastHmr({ type: "error", message: syntaxError });
+        return;
+      }
+      if (lastFlushErrored) {
+        lastFlushErrored = false;
+        broadcastHmr({ type: "ok" });
+      }
+      broadcastHmr({ type: "reload", file: relative(cwd, files[0] ?? cwd), at: Date.now() });
+      logHmr(files[0] ?? cwd);
+    } finally {
+      flushing = false;
+      if (pendingFiles.size || pendingWildcard) scheduleFlush();
+    }
+  }
+
+  function handleEvent(full) {
+    try {
+      if (statSync(full).isDirectory()) {
+        // New directory: in fallback mode start watching it. Files may have
+        // been created inside it before the watcher attached, so invalidate
+        // broadly instead of silently dropping the event (the old behavior —
+        // one dropped event meant stale renders until the server restarted).
+        if (!recursiveMode) walk(full);
+        noteWildcard();
+        return;
+      }
+    } catch {}
+    noteChange(full);
+  }
+
+  function onWatchEvent(baseDir) {
+    return (event, filename) => {
+      if (!filename) {
+        // macOS/FSEvents can coalesce events and drop the filename. Treat it
+        // as "something changed" rather than ignoring it.
+        noteWildcard();
+        return;
+      }
+      const full = join(baseDir, filename.toString());
+      if (isIgnoredWatchPath(full)) return;
+      handleEvent(full);
+    };
+  }
+
+  // Fallback: one watcher per directory (non-recursive platforms).
   function walk(dir) {
     if (watchers.has(dir)) return;
+    // A probe child path tells us whether the directory itself is ignored
+    // (cwd resolves to rel "x", which passes).
+    if (isIgnoredWatchPath(join(dir, "x"))) return;
     try {
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const e of entries) {
-        if (e.isDirectory() && !e.name.startsWith(".") && !IGNORE_DIRS.has(e.name)) {
+        if (e.isDirectory() && !e.name.startsWith(".") && !WATCH_IGNORE_DIRS.has(e.name)) {
           walk(join(dir, e.name));
         }
       }
-      let debounce;
-      const w = fsWatch(dir, (event, filename) => {
-        if (shouldIgnoreFile(filename)) return;
-        const full = join(dir, filename.toString());
-        if (debounce) clearTimeout(debounce);
-        debounce = setTimeout(() => {
-          try {
-            const s = statSync(full);
-            if (s.isDirectory()) {
-              walk(full);
-              return;
-            }
-          } catch {}
-          logEvent("change", full);
-          buildGeneration++;
-          bustCache(full);
-          if (full.includes(`${sep}globals.${"css"}`)) {
-            globalsCssCache = { file: null, mtime: 0, css: "" };
-          }
-          if (full.endsWith(`${sep}layout.tsx`) || full.endsWith(`${sep}layout.ts`)) {
-            fontsScannedFromLayout = false;
-            GOOGLE_FONT_FAMILIES.clear();
-          }
-          const payload = { type: "reload", file: relative(cwd, full), at: Date.now() };
-          for (const send of hmrClients) {
-            try {
-              send(JSON.stringify({ event: "change", data: payload }));
-            } catch {}
-          }
-          logHmr(full);
-        }, 30);
-      });
+      const w = fsWatch(dir, onWatchEvent(dir));
       watchers.set(dir, w);
     } catch (err) {
       logLine([` ${paint("dim", "watch error:")} ${paint("red", err.message)}`], 1);
     }
   }
+
   // Watch the WHOLE project (minus dep/build dirs) so a change to *any* source
   // file — pages, components, lib, hooks, content, config, wherever — triggers
-  // a recompile + reload. No more "edit this folder and nothing happens".
-  walk(cwd);
+  // a recompile + reload. Prefer a single recursive watcher (macOS, Windows,
+  // Linux on Node 20+/Bun): hundreds of per-directory FSEvents watchers could
+  // hit OS limits and die silently, leaving saves unnoticed until a restart.
+  try {
+    const w = fsWatch(cwd, { recursive: true }, onWatchEvent(cwd));
+    watchers.set(cwd, w);
+    recursiveMode = true;
+  } catch {
+    walk(cwd);
+  }
 }
 
 const networkUrls = [];
@@ -2479,6 +2770,35 @@ async function handleFetch(req) {
     return new Response("// island not found", { status: 404, headers: { "Content-Type": "application/javascript" } });
   }
 
+  // On-demand revalidation: POST /_swift-rust/revalidate { tag?, path? }
+  // Purges the shared data cache (globalThis.__SR_CACHE__) by tag or path so
+  // webhooks / mutations can invalidate without a redeploy.
+  if (pathname === "/_swift-rust/revalidate") {
+    if (req.method !== "POST") {
+      return new Response(JSON.stringify({ error: "use POST" }), {
+        status: 405,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    let body = {};
+    try { body = await req.json(); } catch {}
+    const tag = body.tag ?? url.searchParams.get("tag");
+    const path = body.path ?? url.searchParams.get("path");
+    const store = globalThis.__SR_CACHE__;
+    let purged = 0;
+    if (store?.store) {
+      for (const [k, v] of store.store) {
+        if ((tag && v.tags?.includes(tag)) || (path && k.includes(path))) {
+          store.store.delete(k);
+          purged++;
+        }
+      }
+      if (tag) store.purged?.add(`tag:${tag}`);
+      if (path) store.purged?.add(`path:${path}`);
+    }
+    return Response.json({ revalidated: true, tag: tag ?? null, path: path ?? null, purged });
+  }
+
   if (pathname.startsWith("/_swift-rust/")) {
     return new Response("Not found", { status: 404 });
   }
@@ -2749,7 +3069,7 @@ async function handleApiRoute(req, segments, method, reqStart) {
   }
   const handlerName = method.toUpperCase();
   try {
-    const mod = await loadModule(route.file, { bust: true });
+    const mod = await loadModuleFresh(route.file);
     const handler = mod[handlerName] || mod[method.toLowerCase()];
     if (typeof handler !== "function") {
       const total = performance.now() - reqStart;

package/bin/runtime/navigator.js

@@ -54,10 +54,22 @@
   nav.prefetch = (url) => fetchDoc(new URL(url, location.href).href).catch(() => {});
 
   // Scripts inserted via DOM cloning don't execute; clone them into fresh nodes.
+  // Classic scripts re-run on re-insertion, but ES module scripts are keyed by
+  // URL in the module map and won't re-evaluate if the same src is inserted
+  // again — which would leave the swapped-in island markup un-hydrated (stale
+  // active states, dead event handlers) until a full reload. So we cache-bust
+  // module src scripts with a per-navigation token to force re-execution.
+  let swapToken = 0;
   function runScripts(root) {
+    swapToken++;
     for (const old of root.querySelectorAll("script")) {
       const s = document.createElement("script");
       for (const att of old.attributes) s.setAttribute(att.name, att.value);
+      if (s.type === "module" && s.src) {
+        const u = new URL(s.src, location.href);
+        u.searchParams.set("__srnav", String(swapToken));
+        s.src = u.href;
+      }
       s.textContent = old.textContent;
       old.replaceWith(s);
     }

package/dist/cache.d.ts

@@ -0,0 +1,37 @@
+export interface CacheEntry<T = unknown> {
+    value: T;
+    /** epoch ms when the entry goes stale; 0 = never expires (until invalidated). */
+    expires: number;
+    tags: string[];
+}
+export interface CacheOptions {
+    /** Tags for targeted invalidation via revalidateTag(). */
+    tags?: string[];
+    /** Seconds before the entry is considered stale. Omit/0 = cache until invalidated. */
+    revalidate?: number;
+    /** Custom key derivation from the call arguments (defaults to fn name + JSON args). */
+    key?: (...args: any[]) => string;
+}
+/**
+ * Wrap an async function so its result is cached by argument key, with optional
+ * TTL and tags. Returns a function with the same signature.
+ *
+ *   const getPosts = cache(fetchPosts, { tags: ["posts"], revalidate: 3600 });
+ *   await getPosts();              // miss → runs fetchPosts, caches
+ *   await getPosts();              // hit
+ *   revalidateTag("posts");        // purge
+ */
+export declare function cache<A extends unknown[], R>(fn: (...args: A) => Promise<R> | R, options?: CacheOptions): (...args: A) => Promise<R>;
+/** Invalidate every cached entry tagged with `tag`. */
+export declare function revalidateTag(tag: string): void;
+/**
+ * Invalidate cached entries whose key references `path`. (Best-effort by
+ * substring — useful for "everything derived from /blog/*".) Also records the
+ * path so the CDN/platform can purge the rendered route.
+ */
+export declare function revalidatePath(path: string): void;
+/** Drain the set of purge signals recorded since the last call (for endpoints/webhooks). */
+export declare function drainPurged(): string[];
+/** Clear the entire data cache (mainly for tests / dev HMR). */
+export declare function clearCache(): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,KAAK,EAAE,CAAC,CAAC;IACT,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAWD,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uFAAuF;IAEvF,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC1C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAClC,OAAO,GAAE,YAAiB,GACzB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAY5B;AAED,uDAAuD;AACvD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAK/C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAKjD;AAED,4FAA4F;AAC5F,wBAAgB,WAAW,IAAI,MAAM,EAAE,CAItC;AAED,gEAAgE;AAChE,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}

package/dist/cache.js

@@ -0,0 +1,76 @@
+// Data cache + on-demand revalidation.
+//
+// A single process-wide store (kept on globalThis so the app's `swift-rust`
+// import and the dev server share ONE instance regardless of how the module was
+// resolved). Entries carry an expiry (TTL) and tags; `revalidateTag` /
+// `revalidatePath` purge by tag or key substring.
+//
+// In dev and within a warm production function instance this is a real cache.
+// Across instances/CDN, invalidation also relies on the `x-vercel-cache-tags`
+// response header (emitted by the render pipeline) + the platform's tag purge;
+// `revalidateTag` records the purge so an on-demand endpoint/webhook can act on
+// it. The in-memory store is the fast path; the CDN tags are the durable path.
+const g = globalThis;
+const cacheState = (g.__SR_CACHE__ ??= { store: new Map(), purged: new Set() });
+/**
+ * Wrap an async function so its result is cached by argument key, with optional
+ * TTL and tags. Returns a function with the same signature.
+ *
+ *   const getPosts = cache(fetchPosts, { tags: ["posts"], revalidate: 3600 });
+ *   await getPosts();              // miss → runs fetchPosts, caches
+ *   await getPosts();              // hit
+ *   revalidateTag("posts");        // purge
+ */
+export function cache(fn, options = {}) {
+    const tags = options.tags ?? [];
+    const ttlMs = options.revalidate ? options.revalidate * 1000 : 0;
+    const name = fn.name || "anon";
+    return async (...args) => {
+        const key = options.key ? `${name}:${options.key(...args)}` : `${name}:${safeStringify(args)}`;
+        const hit = cacheState.store.get(key);
+        if (hit && (hit.expires === 0 || hit.expires > Date.now()))
+            return hit.value;
+        const value = await fn(...args);
+        cacheState.store.set(key, { value, expires: ttlMs ? Date.now() + ttlMs : 0, tags });
+        return value;
+    };
+}
+/** Invalidate every cached entry tagged with `tag`. */
+export function revalidateTag(tag) {
+    for (const [k, v] of cacheState.store) {
+        if (v.tags.includes(tag))
+            cacheState.store.delete(k);
+    }
+    cacheState.purged.add(`tag:${tag}`);
+}
+/**
+ * Invalidate cached entries whose key references `path`. (Best-effort by
+ * substring — useful for "everything derived from /blog/*".) Also records the
+ * path so the CDN/platform can purge the rendered route.
+ */
+export function revalidatePath(path) {
+    for (const [k] of cacheState.store) {
+        if (k.includes(path))
+            cacheState.store.delete(k);
+    }
+    cacheState.purged.add(`path:${path}`);
+}
+/** Drain the set of purge signals recorded since the last call (for endpoints/webhooks). */
+export function drainPurged() {
+    const out = [...cacheState.purged];
+    cacheState.purged.clear();
+    return out;
+}
+/** Clear the entire data cache (mainly for tests / dev HMR). */
+export function clearCache() {
+    cacheState.store.clear();
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -74,6 +74,8 @@ export { Link } from "./link";
 export { Head, Title, Meta, Style } from "./head";
 export { notFound, redirect, permanentRedirect } from "./router";
 export { NotFoundError, RedirectError } from "./router";
+export { cache, revalidateTag, revalidatePath, clearCache } from "./cache";
+export type { CacheOptions, CacheEntry } from "./cache";
 export { Video, BackgroundVideo, VideoLightbox, isYouTubeUrl, isVimeoUrl, getYouTubeId, getVimeoId, detectProvider, getYouTubeEmbedUrl, getVimeoEmbedUrl, } from "./video";
 export type { VideoProps, VideoSource, VideoCaption, VideoPreload, VideoProvider, BackgroundVideoProps, VideoLightboxProps, } from "./video";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -8,5 +8,6 @@ export { Link } from "./link";
 export { Head, Title, Meta, Style } from "./head";
 export { notFound, redirect, permanentRedirect } from "./router";
 export { NotFoundError, RedirectError } from "./router";
+export { cache, revalidateTag, revalidatePath, clearCache } from "./cache";
 export { Video, BackgroundVideo, VideoLightbox, isYouTubeUrl, isVimeoUrl, getYouTubeId, getVimeoId, detectProvider, getYouTubeEmbedUrl, getVimeoEmbedUrl, } from "./video";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA+BA,MAAM,UAAU,YAAY,CAAC,MAAuB;IAClD,OAAO,MAAM,CAAC;AAChB,CAAC;AAwBD,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAW1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,MAAM,EACN,eAAe,EACf,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,eAAe,EACf,YAAY,EACZ,YAAY,GACb,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAI7D,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EACL,KAAK,EACL,eAAe,EACf,aAAa,EACb,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA+BA,MAAM,UAAU,YAAY,CAAC,MAAuB;IAClD,OAAO,MAAM,CAAC;AAChB,CAAC;AAwBD,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAW1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,MAAM,EACN,eAAe,EACf,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,eAAe,EACf,YAAY,EACZ,YAAY,GACb,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAI7D,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE3E,OAAO,EACL,KAAK,EACL,eAAe,EACf,aAAa,EACb,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swift-rust",
-  "version": "1.8.0",
+  "version": "1.10.2",
   "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",
@@ -55,6 +55,10 @@
       "types": "./dist/router.d.ts",
       "import": "./dist/router.js"
     },
+    "./cache": {
+      "types": "./dist/cache.d.ts",
+      "import": "./dist/cache.js"
+    },
     "./head": {
       "types": "./dist/head.d.ts",
       "import": "./dist/head.js"