@mandujs/core 0.23.0 → 0.25.0

package/src/bundler/reverse-import-graph.ts

@@ -0,0 +1,339 @@
+/**
+ * ReverseImportGraph — #189
+ *
+ * Tracks `importee -> Set<importer>` edges so the dev watcher can answer
+ * "which user modules transitively import this file?" when a file change
+ * misses every known root set (SSR / API / client / common-dir).
+ *
+ * # Why this exists
+ *
+ * Bun caches ES modules at the process level. When a common/shared file
+ * changes, `dev.ts` re-imports that file fresh, but intermediate modules
+ * that reference it transitively may retain their cached form. The three
+ * real-world patterns flagged in #189:
+ *
+ *   1. Barrel + static map — `index.ts` builds a lookup at module load,
+ *      so a new entry in a leaf `translations/ko.ts` never shows up until
+ *      the intermediate barrel is re-evaluated.
+ *   2. Deep re-export chain — `A -> B -> C -> D`. A single edit to `D`
+ *      requires every ancestor to be refreshed.
+ *   3. Module-level singletons / registries whose state is captured at
+ *      import time.
+ *
+ * The existing watcher dispatches only when the changed path itself is in
+ * `serverModuleSet` / `apiModuleSet` / `clientModuleToRoute` / a common
+ * dir. For files that live elsewhere — `app/lib/helper.ts`,
+ * `app/_utils/translations/ko.ts`, etc. — the event falls through and
+ * the user sees stale output until a manual restart.
+ *
+ * # Design
+ *
+ * - `edges: Map<importee -> Set<importer>>` — reverse index.
+ * - `forward: Map<importer -> Set<importee>>` — kept so that a
+ *   subsequent `update(importer, newImports)` can tear down stale edges
+ *   without iterating the full reverse map.
+ * - BFS closure for `transitiveImporters(file, maxDepth)` with an
+ *   explicit visited set and a defensive depth cap (default 10) to
+ *   prevent pathological full-graph walks on projects with dense
+ *   cyclic imports. Every node visited at depth d+1 is checked against
+ *   `visited` BEFORE enqueue so cycles terminate.
+ * - All keys are normalized OS-native absolute paths, lowercased on win32
+ *   so fs.watch events match regardless of drive-letter casing.
+ * - The scanner is a conservative regex over `import ... from "…"`,
+ *   `export ... from "…"`, and dynamic `import("…")`. We intentionally
+ *   skip a full AST parse — the goal is "catch the common case cheaply"
+ *   and the static table never drives code generation, only invalidation
+ *   routing. A false-negative means the change falls through the existing
+ *   silent-drop path (unchanged behavior); a false-positive triggers an
+ *   extra rebuild (acceptable cost).
+ * - Only first-party (relative / alias-resolvable) imports are recorded.
+ *   Bare `react`, `@mandujs/core`, etc. are skipped so the graph never
+ *   tracks node_modules.
+ *
+ * # What this does NOT do
+ *
+ * - Does not resolve TypeScript path aliases from `tsconfig.json`. A
+ *   future pass can wire the `compilerOptions.paths` map in, but the
+ *   relative-import case covers the scenarios in the issue.
+ * - Does not track CSS `@import` — the CSS-update path already has its
+ *   own mechanism in `dev.ts`.
+ * - Does not persist. In-memory only; rebuilt from scratch on dev-server
+ *   start.
+ */
+
+import fs from "fs";
+import path from "path";
+
+/**
+ * Default safety cap for `transitiveImporters` BFS. 10 hops is deep
+ * enough for any realistic barrel chain while stopping cold on
+ * degenerate graphs (e.g. a project with everything re-exporting
+ * everything).
+ */
+export const DEFAULT_MAX_CLOSURE_DEPTH = 10;
+
+/** Normalize an fs path to the form the watcher emits (forward slash, lowercase on win32). */
+function normalize(p: string): string {
+  const abs = path.resolve(p).replace(/\\/g, "/");
+  return process.platform === "win32" ? abs.toLowerCase() : abs;
+}
+
+/**
+ * Return true for a specifier that points at a first-party module we
+ * can resolve on disk. Bare specifiers (`react`, `@scope/pkg`) are
+ * filtered out so the graph never grows with node_modules edges.
+ */
+function isFirstPartySpecifier(spec: string): boolean {
+  if (spec.length === 0) return false;
+  // `./foo`, `../bar`, `/abs/path` — first-party for sure.
+  if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/")) {
+    return true;
+  }
+  // Windows absolute path. `fs.watch` never emits this shape, but a
+  // user file could in theory reference one — reject for the same
+  // reason we reject node_modules: the file isn't in the reactive tree.
+  if (/^[A-Za-z]:[\\/]/.test(spec)) return false;
+  // Everything else — bare module — is external.
+  return false;
+}
+
+/**
+ * Extensions we try (in order) when a specifier has no explicit
+ * extension. Mirrors the set Bun itself would walk for a relative
+ * import inside the monorepo.
+ */
+const RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] as const;
+
+/**
+ * Resolve a relative specifier from `fromFile`'s directory to an
+ * absolute on-disk path. Returns `null` when the target cannot be
+ * found (e.g. a typed-only stub, a file the user has not yet
+ * written). Callers treat `null` as "skip this edge".
+ *
+ * Exported for tests; production code uses it via `scanFileImports`.
+ */
+export function resolveRelativeImport(fromFile: string, specifier: string): string | null {
+  if (!isFirstPartySpecifier(specifier)) return null;
+  const fromDir = path.dirname(fromFile);
+  const base = path.resolve(fromDir, specifier);
+  // If the path already has a recognized extension, test it directly.
+  if (RESOLVE_EXTENSIONS.some((e) => base.endsWith(e))) {
+    return fs.existsSync(base) ? base : null;
+  }
+  // Try each extension + `/index.<ext>` so barrel directories resolve.
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const candidate = base + ext;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const candidate = path.join(base, "index" + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+// Static-import, export-from, and dynamic import patterns. Written
+// conservatively: each regex consumes a single pair of matching quotes,
+// never spans newlines, and does not attempt to handle template literals
+// (dynamic `import(\`…\`)` with interpolation is inherently unresolvable
+// statically).
+const IMPORT_PATTERNS: readonly RegExp[] = [
+  // `import foo from "…"` / `import { x } from "…"` / `import "…"` / `import type { x } from "…"`
+  /\bimport\s+(?:type\s+)?(?:[^'"\n;]*?\bfrom\s+)?['"]([^'"\n]+)['"]/g,
+  // `export { x } from "…"` / `export * from "…"`
+  /\bexport\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"\n]+)['"]/g,
+  // `import("…")` — dynamic. Template literals (`) intentionally excluded.
+  /\bimport\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g,
+];
+
+/**
+ * Scan a file's source text for first-party import specifiers. Returns
+ * the raw specifiers (not resolved). Callers usually pair this with
+ * `resolveRelativeImport` to get absolute paths.
+ *
+ * The parser is intentionally regex-based — we do not want to pay the
+ * cost of a full AST traverse on every file change. See the module
+ * header for the false-positive/negative trade-off.
+ */
+export function extractImportSpecifiers(source: string): string[] {
+  const out = new Set<string>();
+  for (const pattern of IMPORT_PATTERNS) {
+    // Reset lastIndex — the regex has `/g` so reuse across calls would
+    // otherwise skip matches in later invocations.
+    pattern.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = pattern.exec(source)) !== null) {
+      const spec = match[1];
+      if (typeof spec === "string" && spec.length > 0) out.add(spec);
+    }
+  }
+  return Array.from(out);
+}
+
+/**
+ * Read a file from disk and return the absolute paths of every
+ * resolvable first-party import it contains. Non-existent files and
+ * unreadable files both return an empty array (treated as "no edges
+ * to record"). Async so the dev server can batch this work off the
+ * main event loop.
+ */
+export async function scanFileImports(filePath: string): Promise<string[]> {
+  let source: string;
+  try {
+    source = await fs.promises.readFile(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const specifiers = extractImportSpecifiers(source);
+  const out: string[] = [];
+  for (const spec of specifiers) {
+    const resolved = resolveRelativeImport(filePath, spec);
+    if (resolved) out.push(resolved);
+  }
+  return out;
+}
+
+/**
+ * Reverse-import graph with a bounded BFS closure API. All public
+ * methods accept raw paths; normalization is applied internally.
+ */
+export class ReverseImportGraph {
+  /** importee -> set of direct importers. */
+  private readonly edges = new Map<string, Set<string>>();
+  /** importer -> set of direct importees. Kept so `update` is O(|old imports|). */
+  private readonly forward = new Map<string, Set<string>>();
+
+  /**
+   * Replace the outgoing edges for `importerFile`. Any prior importees
+   * that no longer appear drop the importer from their reverse set so
+   * the graph doesn't accumulate stale pointers.
+   */
+  update(importerFile: string, importeePaths: Iterable<string>): void {
+    const importer = normalize(importerFile);
+
+    // Tear down the previous forward entries.
+    const prev = this.forward.get(importer);
+    if (prev) {
+      for (const importee of prev) {
+        const back = this.edges.get(importee);
+        if (!back) continue;
+        back.delete(importer);
+        if (back.size === 0) this.edges.delete(importee);
+      }
+    }
+
+    // Build the new forward entry + reverse edges. We normalize inside
+    // the loop so the caller can pass unnormalized paths.
+    const next = new Set<string>();
+    for (const raw of importeePaths) {
+      const importee = normalize(raw);
+      // Self-edges would create a trivial cycle the BFS has to skip.
+      // Drop them at insert time so the visited-check is the only
+      // cycle defense we need downstream.
+      if (importee === importer) continue;
+      next.add(importee);
+      let back = this.edges.get(importee);
+      if (!back) {
+        back = new Set<string>();
+        this.edges.set(importee, back);
+      }
+      back.add(importer);
+    }
+    if (next.size === 0) {
+      this.forward.delete(importer);
+    } else {
+      this.forward.set(importer, next);
+    }
+  }
+
+  /** Forget a single importer. Reverse edges pointing at its importees are cleaned up. */
+  remove(importerFile: string): void {
+    const importer = normalize(importerFile);
+    const prev = this.forward.get(importer);
+    if (!prev) return;
+    for (const importee of prev) {
+      const back = this.edges.get(importee);
+      if (!back) continue;
+      back.delete(importer);
+      if (back.size === 0) this.edges.delete(importee);
+    }
+    this.forward.delete(importer);
+  }
+
+  /** Direct importers of `file` — the single-hop reverse lookup. */
+  directImporters(file: string): ReadonlySet<string> {
+    const set = this.edges.get(normalize(file));
+    return set ?? new Set<string>();
+  }
+
+  /**
+   * Transitive importers of `file`. Returns the normalized set
+   * excluding `file` itself. BFS with cycle detection; every node is
+   * visited at most once. Capped at `maxDepth` hops so a pathological
+   * graph cannot degrade a single file change into a full-project walk.
+   *
+   * Depth 0 is the changed file itself (not included in the result).
+   * Depth 1 is the set returned by `directImporters`. Depth N is the
+   * set of modules whose shortest path to `file` is exactly N hops.
+   */
+  transitiveImporters(
+    file: string,
+    maxDepth: number = DEFAULT_MAX_CLOSURE_DEPTH,
+  ): Set<string> {
+    const target = normalize(file);
+    const result = new Set<string>();
+    // Guard against 0 / negative depth — those are no-ops.
+    if (!Number.isFinite(maxDepth) || maxDepth <= 0) return result;
+
+    let frontier = new Set<string>([target]);
+    const visited = new Set<string>([target]);
+
+    for (let depth = 0; depth < maxDepth && frontier.size > 0; depth++) {
+      const next = new Set<string>();
+      for (const node of frontier) {
+        const directs = this.edges.get(node);
+        if (!directs) continue;
+        for (const importer of directs) {
+          if (visited.has(importer)) continue;
+          visited.add(importer);
+          result.add(importer);
+          next.add(importer);
+        }
+      }
+      frontier = next;
+    }
+    return result;
+  }
+
+  /** True if any edge points at `file`. Useful for fast "do we know this file?" checks. */
+  knows(file: string): boolean {
+    const key = normalize(file);
+    return this.edges.has(key) || this.forward.has(key);
+  }
+
+  /** Drop everything (dev-server restart). */
+  clear(): void {
+    this.edges.clear();
+    this.forward.clear();
+  }
+
+  /** Total number of tracked importer modules (for diagnostics). */
+  get size(): number {
+    return this.forward.size;
+  }
+
+  /**
+   * Dump the current state as plain JSON. Intended for debug
+   * assertions in unit tests, not for production hot paths.
+   */
+  _inspect(): {
+    forward: Record<string, string[]>;
+    reverse: Record<string, string[]>;
+  } {
+    const forward: Record<string, string[]> = {};
+    for (const [k, v] of this.forward) forward[k] = Array.from(v);
+    const reverse: Record<string, string[]> = {};
+    for (const [k, v] of this.edges) reverse[k] = Array.from(v);
+    return { forward, reverse };
+  }
+}

package/src/bundler/safe-build.test.ts

@@ -125,4 +125,58 @@ describe("safeBuild", () => {
     expect(state.active).toBe(0);
     expect(state.queued).toBe(0);
   });
+
+  it("slot handoff — new callers cannot bypass queued waiters (regression for cap+1 race)", async () => {
+    // Scenario: a build completes with a waiter queued; a NEW safeBuild call
+    // fires on the same microtask. A prior revision decremented `active`
+    // before resolving the waiter, leaving a microtask-sized window where
+    // the new caller saw `active < max`, skipped the wait, and became the
+    // cap+1 concurrent build. This test launches 3*max + 1 builds, samples
+    // active at every slot release, and asserts the peak never exceeds max.
+    const { max } = _getConcurrencyState();
+    const N = max * 3 + 1; // always enough to trigger at least one handoff
+    const entries = await Promise.all(
+      Array.from({ length: N }, (_, i) => makeEntry(`handoff-${i}`)),
+    );
+
+    let peak = 0;
+    let samples = 0;
+    // Sample at microtask granularity — more aggressive than the setInterval
+    // sampler in the earlier test — so the cap+1 window has a realistic
+    // chance of being observed if the bug returned.
+    let stop = false;
+    const sample = async () => {
+      while (!stop) {
+        const { active } = _getConcurrencyState();
+        if (active > peak) peak = active;
+        samples++;
+        await Promise.resolve(); // yield to microtask queue
+      }
+    };
+    const sampler = sample();
+
+    try {
+      const results = await Promise.all(
+        entries.map((entry) =>
+          safeBuild({
+            entrypoints: [entry],
+            outdir: rootDir,
+            target: "browser",
+            naming: path.basename(entry, ".ts") + ".[ext]",
+          }),
+        ),
+      );
+      expect(results.every((r) => r.success)).toBe(true);
+    } finally {
+      stop = true;
+      await sampler;
+    }
+
+    expect(peak).toBeLessThanOrEqual(max);
+    expect(samples).toBeGreaterThan(0);
+
+    const state = _getConcurrencyState();
+    expect(state.active).toBe(0);
+    expect(state.queued).toBe(0);
+  });
 });

package/src/bundler/safe-build.ts

@@ -20,6 +20,15 @@
  * - In-process only. Cross-worker coordination is not this module's job;
  *   per-worker throttling already prevents the observed failure modes in
  *   our test matrix.
+ *
+ * Correctness — slot handoff:
+ * - The semaphore does slot *handoff* rather than release-then-acquire. When
+ *   a build completes with waiters queued, the slot is transferred directly
+ *   to the next waiter (active count never drops). A previous revision had
+ *   a classic acquire race: `releaseSlot()` decremented `active` before the
+ *   waiter's `active++` ran, which opened a microtask-sized window where a
+ *   concurrent `safeBuild()` call could observe `active < max`, skip the
+ *   wait, and join in — yielding `cap+1` concurrent builds.
  */
 
 import type { BuildConfig, BuildOutput } from "bun";
@@ -38,16 +47,36 @@ const maxConcurrent = parseMaxConcurrent();
 let active = 0;
 const waiters: Array<() => void> = [];
 
-function waitForSlot(): Promise<void> {
+/**
+ * Acquire a slot. When `active < max`, increment synchronously and return.
+ * Otherwise, queue and await a direct handoff from a completing build —
+ * the completing build does NOT decrement `active`; it resolves our waiter,
+ * and `active` stays at `max` through the transition. This prevents a
+ * microtask-window race where a third caller could see `active < max` and
+ * skip the wait entirely.
+ */
+function acquireSlot(): Promise<void> {
+  if (active < maxConcurrent) {
+    active++;
+    return Promise.resolve();
+  }
   return new Promise<void>((resolve) => {
     waiters.push(resolve);
   });
 }
 
+/**
+ * Release a slot. If a waiter is queued, hand the slot off directly (keep
+ * `active` at `max`, resolve the waiter). Otherwise decrement `active`.
+ */
 function releaseSlot(): void {
-  active--;
   const next = waiters.shift();
-  if (next) next();
+  if (next) {
+    // Direct handoff — `active` stays at max, waiter resumes holding the slot.
+    next();
+  } else {
+    active--;
+  }
 }
 
 /**
@@ -60,10 +89,7 @@ function releaseSlot(): void {
  * coordination work.
  */
 export async function safeBuild(options: BuildConfig): Promise<BuildOutput> {
-  if (active >= maxConcurrent) {
-    await waitForSlot();
-  }
-  active++;
+  await acquireSlot();
   try {
     return await Bun.build(options);
   } finally {

package/src/client/globals.ts

@@ -1,44 +1,61 @@
-/**
- * Mandu 전역 타입 선언
- * 클라이언트 측 전역 상태의 타입 정의
- */
-import type { Root } from "react-dom/client";
-import type { RouterState } from "./router";
-
-interface ManduRouteInfo {
-  id: string;
-  pattern: string;
-  params: Record<string, string>;
-}
-
-interface ManduDataEntry {
-  serverData: unknown;
-  timestamp?: number;
-}
-
-declare global {
-  interface Window {
-    /** 서버에서 전달된 데이터 (routeId → data) */
-    __MANDU_DATA__?: Record<string, ManduDataEntry>;
-
-    /** 직렬화된 서버 데이터 (raw JSON) */
-    __MANDU_DATA_RAW__?: string;
-
-    /** 현재 라우트 정보 */
-    __MANDU_ROUTE__?: ManduRouteInfo;
-
-    /** 클라이언트 라우터 상태 */
-    __MANDU_ROUTER_STATE__?: RouterState;
-
-    /** 라우터 상태 변경 리스너 */
-    __MANDU_ROUTER_LISTENERS__?: Set<(state: RouterState) => void>;
-
-    /** Hydrated roots 추적 (unmount용) */
-    __MANDU_ROOTS__?: Map<string, Root>;
-
-    /** React 인스턴스 공유 */
-    __MANDU_REACT__?: typeof import("react");
-  }
-}
-
-export {};
+/**
+ * Mandu 전역 타입 선언
+ * 클라이언트 측 전역 상태의 타입 정의
+ */
+import type { Root } from "react-dom/client";
+import type { RouterState } from "./router";
+
+interface ManduRouteInfo {
+  id: string;
+  pattern: string;
+  params: Record<string, string>;
+}
+
+interface ManduDataEntry {
+  serverData: unknown;
+  timestamp?: number;
+}
+
+declare global {
+  interface Window {
+    /** 서버에서 전달된 데이터 (routeId → data) */
+    __MANDU_DATA__?: Record<string, ManduDataEntry>;
+
+    /** 직렬화된 서버 데이터 (raw JSON) */
+    __MANDU_DATA_RAW__?: string;
+
+    /** 현재 라우트 정보 */
+    __MANDU_ROUTE__?: ManduRouteInfo;
+
+    /** 클라이언트 라우터 상태 */
+    __MANDU_ROUTER_STATE__?: RouterState;
+
+    /** 라우터 상태 변경 리스너 */
+    __MANDU_ROUTER_LISTENERS__?: Set<(state: RouterState) => void>;
+
+    /** Hydrated roots 추적 (unmount용) */
+    __MANDU_ROOTS__?: Map<string, Root>;
+
+    /** React 인스턴스 공유 */
+    __MANDU_REACT__?: typeof import("react");
+
+    /**
+     * Issue #193 — global SPA navigation toggle.
+     *
+     *   - `undefined` (not set) → default. Plain `<a href="/about">`
+     *     is intercepted and routed through the client-side router.
+     *   - `false`               → legacy opt-in behavior. Only `<a>`
+     *     tags with `data-mandu-link` are intercepted; all other
+     *     internal links perform a full browser navigation.
+     *   - `true`                → same as undefined; present only for
+     *     symmetry and forward compat.
+     *
+     * SSR injects this global only when `mandu.config.ts` sets
+     * `spa: false` — the default case emits nothing to keep the
+     * typical response payload unchanged.
+     */
+    __MANDU_SPA__?: boolean;
+  }
+}
+
+export {};

package/src/client/prefetch-helper.ts

@@ -0,0 +1,55 @@
+/**
+ * Issue #192 — Hover prefetch helper
+ *
+ * Self-contained IIFE that watches `mouseover` events bubbling from
+ * internal `<a href="/...">` anchors and issues a one-shot
+ * `<link rel="prefetch" as="document">` per unique anchor. The browser
+ * cache services the subsequent full-reload navigation, so most
+ * above-the-fold links feel instantaneous without requiring a SPA
+ * runtime.
+ *
+ * Design choices (locked to keep the payload tiny — target ≤500 bytes
+ * minified + gzipped):
+ *
+ *   1. **WeakSet-based dedup**: we never attach per-anchor listeners;
+ *      we use a single `document`-level capture listener and stamp
+ *      each anchor we've seen into a `WeakSet`. Anchors removed from
+ *      the DOM collect automatically.
+ *
+ *   2. **Scope: same-origin `/...` paths only**: we deliberately skip
+ *      absolute URLs, `mailto:`, `tel:`, `javascript:`, hash-only
+ *      fragments, and `#`-on-same-page links. The `a[href^="/"]`
+ *      selector implicitly covers this and avoids a surprise
+ *      cross-origin DNS lookup.
+ *
+ *   3. **Opt-out per-link via `data-no-prefetch`**: mirrors Next.js'
+ *      `prefetch={false}` ergonomics while being framework-agnostic —
+ *      works with plain `<a>` and with Mandu's `<Link>` component.
+ *
+ *   4. **`as="document"` hint**: the correct token for HTML documents
+ *      that will be navigated to via a subsequent click. Without it
+ *      Chrome 121+ logs a `rel=prefetch as=missing` warning.
+ *
+ *   5. **Capture phase + `passive: true`**: listening in the capture
+ *      phase catches the event before any app-level bubble handlers
+ *      can cancel it (defensive against apps that `stopPropagation`
+ *      on `<a>`). `passive` ensures we can never accidentally block
+ *      scroll.
+ *
+ *   6. **Inline, not external bundle**: the helper is under 1KB and
+ *      emitting it as a `<script>` child (rather than
+ *      `<script src=".../_prefetch.js">`) avoids one HTTP round-trip
+ *      on every SSR response and keeps the module graph unchanged.
+ *
+ * The exported `PREFETCH_HELPER_SCRIPT` wraps the IIFE in a
+ * `<script>` tag, ready to paste into `<head>`. Callers MUST keep it
+ * nonce-aware if they plan to enable CSP (future work — right now the
+ * Fast Refresh preamble is the only inline script covered by Mandu's
+ * CSP header).
+ */
+
+/** Inner IIFE — exposed for unit tests that want to parse the source. */
+export const PREFETCH_HELPER_BODY = `(function(){var s=new WeakSet();document.addEventListener("mouseover",function(e){var t=e.target;if(!t||typeof t.closest!=="function")return;var a=t.closest("a[href^='/']");if(!a||s.has(a))return;if(a.dataset&&a.dataset.noPrefetch!==undefined)return;if(a.hasAttribute&&a.hasAttribute("download"))return;if(a.target&&a.target!=="_self")return;s.add(a);try{var l=document.createElement("link");l.rel="prefetch";l.href=a.href;l.as="document";document.head.appendChild(l);}catch(_){}},{passive:true,capture:true});})();`;
+
+/** Ready-to-inject `<script>` tag for SSR `<head>` injection. */
+export const PREFETCH_HELPER_SCRIPT = `<script>${PREFETCH_HELPER_BODY}</script>`;