@farm.js/core 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/{chunk-G3B5BRDY.mjs → chunk-4677KXB7.mjs}

@@ -9,7 +9,7 @@ import {
   FARM_DOCS_LAST_MODIFIED_MANIFEST,
   createFarmDocsLastModifiedManifest,
   getFarmDocsRouteTypeEntries
-} from "./chunk-3QJO55ZF.mjs";
+} from "./chunk-4LND3PXF.mjs";
 import {
   generateFarmDocsSearchClientRuntime,
   isFarmDocsSearchEnabled,
@@ -17,55 +17,54 @@ import {
 } from "./chunk-V7RBCSDJ.mjs";
 import {
   mergeFarmViteConfig
-} from "./chunk-RKI6TN3A.mjs";
+} from "./chunk-QM746KUO.mjs";
 import {
   hasCustomFarmRouteContext,
   resolveDeployOutputPath
-} from "./chunk-UHE2TTLK.mjs";
+} from "./chunk-K5ZTUF22.mjs";
 import {
   PluginManager
-} from "./chunk-C3DLZMBU.mjs";
+} from "./chunk-DJSGLHCN.mjs";
 import {
   createFarmApp,
+  farmFontImportsPlugin,
   generateFarmClientPluginEntryCode,
   generateFarmTypeArtifacts,
   getClientModuleMetadata,
+  mergeFarmFontCss,
   resolveRouteRenderingConfigFromFile
-} from "./chunk-CHFHNEMO.mjs";
+} from "./chunk-77BOAQHI.mjs";
 import {
   farmEnvironmentFunctionsPlugin
 } from "./chunk-V6WE6JSZ.mjs";
+import {
+  routeRulesToNitroRouteRules
+} from "./chunk-YW7OBE6Q.mjs";
 import {
   getFarmAppDirectories
 } from "./chunk-74YTBPTY.mjs";
-import {
-  routeRulesToNitroRouteRules
-} from "./chunk-OYXO65LI.mjs";
 import {
   isFarmMarkdownPageFile
-} from "./chunk-S2XHZS7W.mjs";
+} from "./chunk-ZVWA4ZQ3.mjs";
 import {
   applyFarmWorkflowVercelCrons,
   prepareFarmWorkflowsForNitro
-} from "./chunk-Y2OJJD7R.mjs";
+} from "./chunk-XIVV5IWN.mjs";
 import {
   applyFarmCronVercelCrons,
   createFarmCronCloudflareConfig,
   mergeScheduledTasks,
   prepareFarmCronForNitro
-} from "./chunk-UREJA4GZ.mjs";
+} from "./chunk-GXASWWJU.mjs";
 import {
   getFarmIntegrationPluginServerRuntime
 } from "./chunk-K4667E2Q.mjs";
 import {
   APIRouteManager
-} from "./chunk-YHU7SS6L.mjs";
+} from "./chunk-Z5CQMP54.mjs";
 import {
   readFarmI18nCatalogs
-} from "./chunk-QF4PHCMA.mjs";
-import {
-  logger
-} from "./chunk-J4FNJ5IU.mjs";
+} from "./chunk-2ED5Q2GH.mjs";
 import {
   createFarmRouteRuntimeKey,
   getFarmRouteRuntimeConfig,
@@ -74,7 +73,10 @@ import {
   normalizeFarmRouteRuntimeConfig,
   resolveFarmRouteRuleRuntimeConfig,
   resolveFarmRouteRuntimeConfig
-} from "./chunk-QM6VV26B.mjs";
+} from "./chunk-GQVGIUSN.mjs";
+import {
+  logger
+} from "./chunk-J4FNJ5IU.mjs";
 import {
   __name
 } from "./chunk-CGILA3WO.mjs";
@@ -299,8 +301,8 @@ function compareRuntimeRoutes(left, right) {
 __name(compareRuntimeRoutes, "compareRuntimeRoutes");
 function getPatternSpecificity(pattern) {
   return normalizePattern(pattern).split("/").filter(Boolean).reduce((score, segment) => {
-    if (segment === "**" || /^\[\[\.\.\./.test(segment)) return score + 1;
-    if (segment === "*" || /^\[\.\.\./.test(segment)) return score + 10;
+    if (segment === "**" || segment.startsWith("[[...")) return score + 1;
+    if (segment === "*" || segment.startsWith("[...")) return score + 10;
     if (/^\[.+\]$/.test(segment)) return score + 50;
     return score + 100;
   }, 0);
@@ -743,12 +745,28 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
     const routeRuntimeManifestResultPromise = Promise.allSettled([routeRuntimeManifestPromise]);
     const pageRoutes = [];
     for (const [pattern, entry] of routeManager.getRoutes()) {
+      const markdownSourcePath = entry.markdownSourcePath || (isFarmMarkdownPageFile(entry.modulePath) ? entry.modulePath : void 0);
       pageRoutes.push({
         pattern,
         modulePath: entry.modulePath,
-        ...isFarmMarkdownPageFile(entry.modulePath) ? { source: readFileSync(entry.modulePath, "utf8") } : {}
+        ...markdownSourcePath ? {
+          source: readFileSync(markdownSourcePath, "utf8"),
+          markdownSourcePath
+        } : {}
       });
     }
+    const routeSlots = Array.from(
+      routeManager.getRouteSlots().values(),
+      (entry) => ({
+        name: entry.name,
+        ownerPattern: entry.ownerPattern,
+        pattern: entry.pattern,
+        modulePath: entry.modulePath,
+        containerId: entry.containerId,
+        interception: entry.interception,
+        fallback: entry.fallback
+      })
+    );
     logger.info(`\u{1F4CB} Found ${pageRoutes.length} page routes`);
     const fs = await import("fs/promises");
     const layoutRoutes = [];
@@ -792,7 +810,16 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
     logger.info("\u{1F4E6} Building client and SSR bundles in parallel...");
     const [clientBuildResult, ssrBuildResult] = await Promise.allSettled([
       // Client build (to disk)
-      buildClient(productionVite, config, root, srcDir, clientOutputDir, pageRoutes, layoutRoutes),
+      buildClient(
+        productionVite,
+        config,
+        root,
+        srcDir,
+        clientOutputDir,
+        pageRoutes,
+        layoutRoutes,
+        routeSlots
+      ),
       // SSR build (in memory)
       buildSSRInMemory(
         productionVite,
@@ -803,7 +830,8 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         serverRenderer,
         preset,
         pageRoutes,
-        layoutRoutes
+        layoutRoutes,
+        routeSlots
       )
     ]);
     const [routeRuntimeManifestResult] = await routeRuntimeManifestResultPromise;
@@ -823,7 +851,8 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         srcDir,
         clientOutputDir,
         pageRoutes,
-        layoutRoutes
+        layoutRoutes,
+        routeSlots
       );
     }
     const ssrResult = ssrBuildResult.value;
@@ -878,12 +907,41 @@ async function writeSSRAssetsToClient(bundle, outputDir) {
   const fs = await import("fs/promises");
   for (const [fileName, output] of Object.entries(bundle)) {
     if (output.type !== "asset") continue;
+    if (fileName === "farm-fonts.css") {
+      await mergeBuiltFontCss(outputDir, output.source);
+      continue;
+    }
     const filePath = path3.join(outputDir, fileName);
     await fs.mkdir(path3.dirname(filePath), { recursive: true });
     await fs.writeFile(filePath, output.source);
   }
 }
 __name(writeSSRAssetsToClient, "writeSSRAssetsToClient");
+async function mergeBuiltFontCss(outputDir, fontCssSource) {
+  const fs = await import("fs/promises");
+  const fontCssPath = path3.join(outputDir, "farm-fonts.css");
+  let fontCss = fontCssSource;
+  if (fontCss === void 0) {
+    try {
+      fontCss = await fs.readFile(fontCssPath);
+    } catch {
+      return;
+    }
+  }
+  const clientCssPath = path3.join(outputDir, "farm-client.css");
+  let clientCss = "";
+  try {
+    clientCss = await fs.readFile(clientCssPath, "utf8");
+  } catch {
+  }
+  const normalizedFontCss = typeof fontCss === "string" ? fontCss : Buffer.from(fontCss).toString("utf8");
+  await fs.writeFile(clientCssPath, mergeFarmFontCss(clientCss, normalizedFontCss));
+  try {
+    await fs.rm(fontCssPath, { force: true });
+  } catch {
+  }
+}
+__name(mergeBuiltFontCss, "mergeBuiltFontCss");
 var _IncompleteClientBuildOutputError = class _IncompleteClientBuildOutputError extends Error {
   constructor(detail) {
     super(`Farm client build produced incomplete output: ${detail}`);
@@ -926,7 +984,7 @@ async function validateClientBuildOutput(root, srcDir, outputDir) {
   }
 }
 __name(validateClientBuildOutput, "validateClientBuildOutput");
-async function buildClient(productionVite, config, root, srcDir, outputDir, pageRoutes, layoutRoutes = []) {
+async function buildClient(productionVite, config, root, srcDir, outputDir, pageRoutes, layoutRoutes = [], routeSlots = []) {
   const viteBuild = productionVite.build;
   const { farmPlugin } = await import("./vite.mjs");
   const { PluginManager: PluginManager2 } = await import("./plugin.mjs");
@@ -953,8 +1011,16 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
       logger.warn(`\u26A0\uFE0F  Could not inspect route file ${route.modulePath}: ${error}`);
     }
   }
+  const clientRouteSlots = routeSlots.filter((slot) => {
+    try {
+      return getClientModuleMetadata(slot.modulePath, root).shouldHydrate;
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F  Could not inspect route slot ${slot.modulePath}: ${error}`);
+      return false;
+    }
+  });
   logger.info(
-    `\u{1F4F1} Total hydratable routes detected: ${clientPages.length} out of ${pageRoutes.length} pages`
+    `\u{1F4F1} Total hydratable routes detected: ${clientPages.length} pages and ${clientRouteSlots.length} slots`
   );
   const clientEntryRoot = path3.join(root, ".farm", "tmp");
   await fs.mkdir(clientEntryRoot, { recursive: true });
@@ -963,6 +1029,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
   const clientHydrationCode = generateClientHydrationEntry(
     clientPages,
     layoutRoutes,
+    clientRouteSlots,
     root,
     srcDir,
     isFarmDocsSearchEnabled(config.docs),
@@ -1089,7 +1156,8 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
                 'export { Link } from "@farm.js/core/client";',
                 'export { useRouter } from "@farm.js/core/client";',
                 'export { usePathname, useSearchParams } from "@farm.js/core/navigation";',
-                'export { createAPIClient } from "@farm.js/core/client";'
+                'export { createAPIClient } from "@farm.js/core/client";',
+                'export { localFont, remoteFont } from "@farm.js/core/font";'
               ].join("\n");
             }
             return null;
@@ -1116,6 +1184,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
         ]
       }
     });
+    await mergeBuiltFontCss(outputDir);
     await validateClientBuildOutput(root, srcDir, outputDir);
   } finally {
     try {
@@ -1295,7 +1364,7 @@ function generateUniversalRouterStateProperties() {
 `.trim();
 }
 __name(generateUniversalRouterStateProperties, "generateUniversalRouterStateProperties");
-function generateClientHydrationEntry(clientPages, layoutRoutes, root, srcDir, docsSearchEnabled, docsSearchModuleId, i18nConfig = {
+function generateClientHydrationEntry(clientPages, layoutRoutes, clientRouteSlots, root, srcDir, docsSearchEnabled, docsSearchModuleId, i18nConfig = {
   enabled: false,
   locales: ["en"],
   defaultLocale: "en",
@@ -1363,7 +1432,7 @@ function isFarmLocaleDocumentChange() {
   return false;
 }
 `;
-  if (clientPages.length === 0) {
+  if (clientPages.length === 0 && clientRouteSlots.length === 0) {
     return `
 // Farm.js Client Runtime (no client components)
 ${cssImport}
@@ -1613,11 +1682,25 @@ document.addEventListener("click", function(e) {
   }
   const imports = [];
   const routeEntries = [];
+  const routeSlotEntries = [];
   clientPages.forEach((page, index) => {
     const importPath = toImportPath(page.modulePath);
     imports.push(`import Page${index} from "${importPath}";`);
     routeEntries.push(`  { pattern: ${JSON.stringify(page.pattern)}, Component: Page${index} }`);
   });
+  clientRouteSlots.forEach((slot, index) => {
+    const importPath = toImportPath(slot.modulePath);
+    imports.push(`import RouteSlot${index} from "${importPath}";`);
+    routeSlotEntries.push(`  {
+    name: ${JSON.stringify(slot.name)},
+    ownerPattern: ${JSON.stringify(slot.ownerPattern)},
+    pattern: ${JSON.stringify(slot.pattern)},
+    containerId: ${JSON.stringify(slot.containerId)},
+    interception: ${JSON.stringify(slot.interception)},
+    fallback: ${JSON.stringify(slot.fallback)},
+    Component: RouteSlot${index},
+  }`);
+  });
   return `
 // Farm.js Client Runtime - SPA with Hydration
 ${cssImport}
@@ -1639,6 +1722,10 @@ const clientRoutes = [
 ${routeEntries.join(",\n")}
 ];
 
+const clientRouteSlots = [
+${routeSlotEntries.join(",\n")}
+];
+
 // Layout routes for wrapping client components
 const layoutRoutes = [
 ${layoutRegistrations.join(",\n")}
@@ -1693,6 +1780,146 @@ function matchRoute(pathname) {
   return null;
 }
 
+function matchesRoutePrefix(pathname, pattern) {
+  if (pattern === "/") return true;
+  const pathSegments = getFarmRoutePathname(pathname).split("/").filter(Boolean);
+  const patternSegments = pattern.split("/").filter(Boolean);
+  if (patternSegments.length > pathSegments.length) return false;
+  const candidate = "/" + pathSegments.slice(0, patternSegments.length).join("/");
+  return matchFarmRoute(pattern, candidate) !== null;
+}
+
+function matchInterceptedRouteSlot(pathname, from) {
+  for (const slot of clientRouteSlots) {
+    if (!slot.interception || !matchesRoutePrefix(from, slot.ownerPattern)) continue;
+    const params = matchFarmRoute(slot.pattern, getFarmRoutePathname(pathname));
+    if (params !== null) return { slot: slot, params: params };
+  }
+  return null;
+}
+
+function routeSlotKey(slot) {
+  return slot.ownerPattern + ":" + slot.name;
+}
+
+function findClientRouteSlot(slot) {
+  return clientRouteSlots.find(function(candidate) {
+    return candidate.name === slot.name &&
+      candidate.ownerPattern === slot.ownerPattern &&
+      candidate.pattern === slot.pattern &&
+      candidate.interception === slot.interception &&
+      candidate.fallback === slot.fallback;
+  });
+}
+
+function readRouteSlotPayload(doc) {
+  const script = doc.getElementById("__farm_route_slots_data__");
+  if (!script?.textContent) return [];
+  try {
+    const parsed = JSON.parse(script.textContent);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+const routeSlotRoots = new Map();
+let activeRouteInterception = null;
+
+function resetRouteSlotRoots() {
+  for (const root of routeSlotRoots.values()) {
+    try { root.unmount(); } catch {}
+  }
+  routeSlotRoots.clear();
+  activeRouteInterception = null;
+}
+
+function renderClientRouteSlot(slot, registration, mode) {
+  const container = document.getElementById(slot.containerId);
+  if (!container || !registration?.Component) return false;
+  const key = routeSlotKey(slot);
+  const existingRoot = routeSlotRoots.get(key);
+  const props = slot.props && typeof slot.props === "object" ? slot.props : {};
+  const element = React.createElement(registration.Component, props);
+
+  if (mode === "hydrate") {
+    if (existingRoot) return true;
+    const root = hydrateRoot(container, element);
+    routeSlotRoots.set(key, root);
+    return true;
+  }
+
+  if (existingRoot) {
+    try { existingRoot.unmount(); } catch {}
+    routeSlotRoots.delete(key);
+  } else {
+    container.replaceChildren();
+  }
+  const root = createRoot(container);
+  root.render(element);
+  routeSlotRoots.set(key, root);
+  return true;
+}
+
+function hydrateInitialRouteSlots() {
+  const slots = Array.isArray(window.__FARM_ROUTE_SLOTS__)
+    ? window.__FARM_ROUTE_SLOTS__
+    : [];
+  for (const slot of slots) {
+    const registration = findClientRouteSlot(slot);
+    if (!registration) continue;
+    try {
+      renderClientRouteSlot(slot, registration, "hydrate");
+    } catch (error) {
+      console.warn("[Farm.js] Could not hydrate route slot:", slot.name, error);
+    }
+  }
+}
+
+function renderRouteInterception(slot, registration, from) {
+  const container = document.getElementById(slot.containerId);
+  if (!container) return false;
+  const key = routeSlotKey(slot);
+  const previousSlot = (window.__FARM_ROUTE_SLOTS__ || []).find(function(candidate) {
+    return routeSlotKey(candidate) === key;
+  }) || null;
+  const previousHtml = container.innerHTML;
+
+  if (!renderClientRouteSlot(slot, registration, "render")) return false;
+  activeRouteInterception = {
+    from: from,
+    key: key,
+    slot: slot,
+    previousSlot: previousSlot,
+    previousHtml: previousHtml,
+  };
+  return true;
+}
+
+function clearRouteInterception(destination) {
+  if (!activeRouteInterception) return false;
+  const active = activeRouteInterception;
+  activeRouteInterception = null;
+  const root = routeSlotRoots.get(active.key);
+  if (root) {
+    try { root.unmount(); } catch {}
+    routeSlotRoots.delete(active.key);
+  }
+  const container = document.getElementById(active.slot.containerId);
+  if (container) {
+    container.innerHTML = active.previousHtml;
+    if (active.previousSlot) {
+      const registration = findClientRouteSlot(active.previousSlot);
+      if (registration) {
+        try {
+          renderClientRouteSlot(active.previousSlot, registration, "hydrate");
+        } catch {}
+      }
+    }
+  }
+  return destination === active.from;
+}
+
 // State
 let reactRoot = null;
 let currentPathname = null;
@@ -1711,12 +1938,17 @@ function resetReactRoot() {
 async function hydrate() {
   const pathname = window.location.pathname;
   const matched = matchRoute(pathname);
-  
+  hydrateInitialRouteSlots();
+
   if (!matched) {
     return;
   }
   
-  const container = document.getElementById("root");
+  const hasRouteSlots =
+    Array.isArray(window.__FARM_ROUTE_SLOTS__) && window.__FARM_ROUTE_SLOTS__.length > 0;
+  const container =
+    (hasRouteSlots ? document.getElementById("__farm_page__") : null) ||
+    document.getElementById("root");
   if (!container) {
     console.error("[Farm.js] No root element found");
     return;
@@ -1730,7 +1962,9 @@ async function hydrate() {
   
   // Create page element and wrap with layouts
   const pageElement = React.createElement(Component, props);
-  const wrappedElement = wrapWithLayouts(pageElement, pathname, params);
+  const wrappedElement = hasRouteSlots
+    ? pageElement
+    : wrapWithLayouts(pageElement, pathname, params);
 
   const shouldHydrate = !isHydrated && Boolean(container.innerHTML.trim());
   const hydrationSession = await farmClientRuntime.beginHydration({
@@ -1795,6 +2029,57 @@ ${generateUniversalRouterStateProperties()}
           : undefined,
       });
 
+      if (activeRouteInterception && clearRouteInterception(to)) {
+        await farmClientRuntime.markNavigationLoaded(clientNavigation, {
+          routeSlots: "restored",
+        });
+        await farmClientRuntime.resolveNavigation(clientNavigation);
+        void farmClientRuntime.scheduleNavigationRendered(clientNavigation);
+        this.currentPath = to;
+        this.finishNavigation();
+        return;
+      }
+      if (activeRouteInterception) {
+        clearRouteInterception(to);
+      }
+
+      const intercepted = matchInterceptedRouteSlot(pathname, from);
+      if (intercepted) {
+        const html = await this.fetchPage(to, from);
+        const doc = new DOMParser().parseFromString(html, "text/html");
+        const slotPayload = readRouteSlotPayload(doc);
+        const selectedSlot = slotPayload.find(function(slot) {
+          return slot.interception &&
+            slot.name === intercepted.slot.name &&
+            slot.ownerPattern === intercepted.slot.ownerPattern;
+        });
+
+        if (
+          selectedSlot &&
+          renderRouteInterception(selectedSlot, intercepted.slot, from)
+        ) {
+          await farmClientRuntime.markNavigationLoaded(clientNavigation, {
+            route: intercepted.slot.pattern,
+            params: intercepted.params,
+          });
+          const historyState = createHistoryState(
+            to,
+            options.state,
+            window.history.state,
+          );
+          if (action === "replace") {
+            window.history.replaceState(historyState, "", url);
+          } else if (action !== "pop") {
+            window.history.pushState(historyState, "", url);
+          }
+          await farmClientRuntime.resolveNavigation(clientNavigation);
+          void farmClientRuntime.scheduleNavigationRendered(clientNavigation);
+          this.currentPath = to;
+          this.finishNavigation();
+          return;
+        }
+      }
+
       if (matched) {
         const Component = matched.route.Component;
         const params = matched.params;
@@ -1871,21 +2156,28 @@ ${generateUniversalRouterStateProperties()}
     }
   },
   
-  fetchPage: async function(url) {
-    const cached = this.prefetchCache.get(url);
+  fetchPage: async function(url, interceptFrom) {
+    const cacheKey = interceptFrom ? url + "\\nintercept:" + interceptFrom : url;
+    const cached = this.prefetchCache.get(cacheKey);
     if (cached) return cached;
     
     const response = await fetch(url, {
-      headers: { "Accept": "text/html" }
+      headers: {
+        "Accept": "text/html",
+        ...(interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {}),
+      }
     });
     if (!response.ok) throw new Error("Failed to fetch page");
-    return response.text();
+    const html = await response.text();
+    this.prefetchCache.set(cacheKey, html);
+    return html;
   },
   
   swapContent: function(html, targetPath) {
     const parser = new DOMParser();
     const doc = parser.parseFromString(html, "text/html");
     if (isFarmLocaleDocumentChange(doc)) return false;
+    const nextRouteSlots = readRouteSlotPayload(doc);
     
     // Update title
     const newTitle = doc.querySelector("title");
@@ -1910,7 +2202,10 @@ ${generateUniversalRouterStateProperties()}
     const currentRoot = document.getElementById("root");
     if (!newRoot || !currentRoot) return this.swapDocument(doc);
     resetReactRoot();
+    resetRouteSlotRoots();
     currentRoot.innerHTML = newRoot.innerHTML;
+    window.__FARM_ROUTE_SLOTS__ = nextRouteSlots;
+    hydrateInitialRouteSlots();
 
     // Check if new page has a client component
     const targetUrl = new URL(targetPath || window.location.href, window.location.origin);
@@ -1922,13 +2217,15 @@ ${generateUniversalRouterStateProperties()}
       const params = matched.params;
       const searchParams = Object.fromEntries(targetUrl.searchParams);
       const props = { params: params, searchParams: Promise.resolve(searchParams) };
-      
-      if (!reactRoot) {
-        reactRoot = createRoot(currentRoot);
-      }
       const pageElement = React.createElement(Component, props);
-      const wrappedElement = wrapWithLayouts(pageElement, newPathname, params);
-      reactRoot.render(wrappedElement);
+      const hasRouteSlots = nextRouteSlots.length > 0;
+      const pageContainer =
+        (hasRouteSlots ? document.getElementById("__farm_page__") : null) || currentRoot;
+      const wrappedElement = hasRouteSlots
+        ? pageElement
+        : wrapWithLayouts(pageElement, newPathname, params);
+      reactRoot = hydrateRoot(pageContainer, wrappedElement);
+      isHydrated = true;
     }
     return true;
   },
@@ -1937,6 +2234,7 @@ ${generateUniversalRouterStateProperties()}
     if (!doc.documentElement || !doc.body) return false;
 
     resetReactRoot();
+    resetRouteSlotRoots();
 
     Array.from(document.documentElement.attributes).forEach(function(attr) {
       if (!doc.documentElement.hasAttribute(attr.name)) {
@@ -1970,10 +2268,12 @@ ${generateUniversalRouterStateProperties()}
     if (url.origin !== window.location.origin) return;
     
     const pathname = url.pathname + url.search;
-    if (this.prefetchCache.has(pathname)) return;
+    const interceptFrom = this.currentPath;
+    const cacheKey = pathname + "\\nintercept:" + interceptFrom;
+    if (this.prefetchCache.has(cacheKey)) return;
     
-    this.fetchPage(pathname)
-      .then(function(html) { spaRouter.prefetchCache.set(pathname, html); })
+    this.fetchPage(pathname, interceptFrom)
+      .then(function(html) { spaRouter.prefetchCache.set(cacheKey, html); })
       .catch(function() {});
   },
   
@@ -2064,7 +2364,7 @@ if (isFarmDocsSearchPage()) {
 `.trim();
 }
 __name(generateClientHydrationEntry, "generateClientHydrationEntry");
-async function buildSSRInMemory(productionVite, config, root, routeManager, apiRouteManager, serverRenderer, preset, collectedPageRoutes, collectedLayoutRoutes) {
+async function buildSSRInMemory(productionVite, config, root, routeManager, apiRouteManager, serverRenderer, preset, collectedPageRoutes, collectedLayoutRoutes, collectedRouteSlots) {
   const viteBuild = productionVite.build;
   const { farmPlugin } = await import("./vite.mjs");
   const { PluginManager: PluginManager2 } = await import("./plugin.mjs");
@@ -2097,6 +2397,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   let ssrEntryFile;
   const pageRoutes = collectedPageRoutes.map((route) => ({ ...route }));
   const layoutRoutes = collectedLayoutRoutes.map((route) => ({ ...route }));
+  const routeSlots = collectedRouteSlots.map((slot) => ({ ...slot }));
   const metadataImageRoutes = [];
   for (const entry of routeManager.getMetadataImages().values()) {
     if (entry.sourceType === "static") {
@@ -2197,6 +2498,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     apiRoutes,
     pageRoutes,
     layoutRoutes,
+    routeSlots,
     errorRoutes,
     metadataImageRoutes,
     middlewareRoutes,
@@ -2283,14 +2585,11 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
           ".prisma/client",
           ".prisma/client/default"
         ],
-        // Don't externalize these - bundle them into the SSR output
-        // Keep this list minimal for faster builds
-        noExternal: [
-          "@farm.js/core",
-          "@farm.js/core/image",
-          "better-call",
-          ...preset === "cloudflare-module" ? [] : ["react", "react-dom", "react-dom/server"]
-        ]
+        // Node deployments must bundle application dependencies with Farm's
+        // React runtime. Leaving a React component package external can make it
+        // resolve a second React instance at runtime and break hooks during SSR.
+        // Native and build-only packages above remain explicitly external.
+        noExternal: preset === "cloudflare-module" ? ["@farm.js/core", "@farm.js/core/image", "better-call"] : true
       },
       define: {
         __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
@@ -2367,10 +2666,14 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       }
     }
   }
-  return { bundle: ssrBundle, entryFile: ssrEntryFile, configuredHeaderRoutes };
+  return {
+    bundle: ssrBundle,
+    entryFile: ssrEntryFile,
+    configuredHeaderRoutes
+  };
 }
 __name(buildSSRInMemory, "buildSSRInMemory");
-function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRoutes, metadataImageRoutes, middlewareRoutes, redirectRoutes, configuredRewriteRoutes, configuredHeaderRoutes, notFoundPath, config, configModulePath, hasServerRuntimeIntegrations, hasRuntimeIntegrationConfig, hasConfiguredRuntimePlugins, preset, i18nCatalogs) {
+function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlots, errorRoutes, metadataImageRoutes, middlewareRoutes, redirectRoutes, configuredRewriteRoutes, configuredHeaderRoutes, notFoundPath, config, configModulePath, hasServerRuntimeIntegrations, hasRuntimeIntegrationConfig, hasConfiguredRuntimePlugins, preset, i18nCatalogs) {
   const hasPluginRuntime = hasRuntimeIntegrationConfig || hasConfiguredRuntimePlugins;
   const hasMiddlewareRuntime = middlewareRoutes.length > 0 || hasFarmMiddlewareConfig(config.middleware);
   const farmDocsBaseConfig = config.docs?.enabled ? { ...config.docs, config: void 0 } : void 0;
@@ -2388,15 +2691,13 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
   });
   const pageImports = [];
   const pageRegistrations = [];
-  const hasMarkdownPages = pageRoutes.some(
-    (route) => route.source !== void 0 || isFarmMarkdownPageFile(route.modulePath)
-  );
+  const hasMarkdownPages = pageRoutes.some((route) => route.source !== void 0);
   const orderedPageRoutes = pageRoutes.map((route, index) => ({ route, index })).sort(
     (left, right) => routePatternSpecificity(right.route.pattern) - routePatternSpecificity(left.route.pattern) || left.index - right.index
   ).map(({ route }) => route);
   orderedPageRoutes.forEach((route, index) => {
     const varName = `pageRoute${index}`;
-    if (route.source !== void 0 || isFarmMarkdownPageFile(route.modulePath)) {
+    if (isFarmMarkdownPageFile(route.modulePath)) {
       pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route.pattern)},
@@ -2408,16 +2709,22 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
     }),
     markdownSource: {
       source: ${JSON.stringify(route.source ?? "")},
-      filePath: ${JSON.stringify(route.modulePath)},
+      filePath: ${JSON.stringify(route.markdownSourcePath ?? route.modulePath)},
     },
   }`);
       return;
     }
     pageImports.push(`import * as ${varName} from "${route.modulePath}";`);
+    const shouldHydrate = getClientModuleMetadata(route.modulePath, config.root).shouldHydrate;
     pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route.pattern)},
     module: ${varName},
+    shouldHydrate: ${JSON.stringify(shouldHydrate)},
+    ${route.source !== void 0 ? `markdownSource: {
+      source: ${JSON.stringify(route.source)},
+      filePath: ${JSON.stringify(route.markdownSourcePath)},
+    },` : ""}
   }`);
   });
   const layoutImports = [];
@@ -2431,6 +2738,22 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
     module: ${varName},
   }`);
   });
+  const routeSlotImports = [];
+  const routeSlotRegistrations = [];
+  routeSlots.forEach((slot, index) => {
+    const varName = `routeSlot${index}`;
+    routeSlotImports.push(`import * as ${varName} from "${slot.modulePath}";`);
+    routeSlotRegistrations.push(`
+  {
+    name: ${JSON.stringify(slot.name)},
+    ownerPattern: ${JSON.stringify(slot.ownerPattern)},
+    pattern: ${JSON.stringify(slot.pattern)},
+    containerId: ${JSON.stringify(slot.containerId)},
+    interception: ${JSON.stringify(slot.interception)},
+    fallback: ${JSON.stringify(slot.fallback)},
+    module: ${varName},
+  }`);
+  });
   const errorImports = [];
   const errorRegistrations = [];
   errorRoutes.forEach((errorRoute, index) => {
@@ -2480,7 +2803,9 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
   _runWithMiddlewareContext,
   _runWithMiddlewareData,
   addMetadataImageReference,
+  appendFarmLinkHeader,
   applyProductionMiddlewareHeaders,
+  configureFarmCache,
   configureFarmObservability,
   createFarmCacheKey,
   createFarmLocaleCookie,
@@ -2506,7 +2831,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
   const docsRuntimeImport = config.docs?.enabled ? `import { existsSync as farmDocsExistsSync } from "node:fs";
 import { dirname as farmDocsDirname, join as farmDocsJoin } from "node:path";
 import { fileURLToPath as farmDocsFileURLToPath } from "node:url";` : "";
-  const markdownHandlerImport = config.md?.enabled ? `import { createMarkdownMirrorResponse } from "@farm.js/core/markdown";` : "";
+  const markdownHandlerImport = config.md?.enabled ? `import { applyMarkdownNegotiationHeaders, createMarkdownMirrorResponse } from "@farm.js/core/markdown";` : "";
   const appMarkdownImport = hasMarkdownPages ? `import { createFarmMarkdownRouteModule, createFarmMarkdownSourceResponse } from "@farm.js/core/app-markdown";` : "const createFarmMarkdownSourceResponse = null;";
   const mdxComponentsPath = typeof config.mdx?.components === "string" ? path3.isAbsolute(config.mdx.components) ? config.mdx.components : path3.join(config.root, config.mdx.components) : null;
   const mdxComponentsImport = mdxComponentsPath ? `import * as FarmMdxComponentsModule from "${mdxComponentsPath.replace(/\\/g, "/")}";` : "";
@@ -2583,6 +2908,7 @@ async function handleAPIRequest(request) {
 ${apiImports.join("\n")}
 ${pageImports.join("\n")}
 ${layoutImports.join("\n")}
+${routeSlotImports.join("\n")}
 ${errorImports.join("\n")}
 ${metadataImageImports.join("\n")}
 ${middlewareImports.join("\n")}
@@ -2599,6 +2925,7 @@ ${mdxComponentsImport}
 ${integrationImports}
 ${imageRuntimeImport}
 ${imageNodeRuntimeImport}
+import { farmFontPreloadHeader } from "virtual:farm-font-runtime";
 import * as React from "react";
 import * as ReactDOMServer from "react-dom/server";
 
@@ -2660,6 +2987,7 @@ const farmObservabilityConfig = farmUserConfig?.observability ?? ${JSON.stringif
     config.observability ?? false
   )};
 configureFarmObservability(farmObservabilityConfig);
+configureFarmCache(farmResolvedRuntimeConfig.cache);
 const farmI18nConfig = ${JSON.stringify(config.i18n)};
 const farmI18nRuntime = ${config.i18n.enabled ? `createFarmI18nRuntime(farmI18nConfig, ${JSON.stringify(i18nCatalogs)})` : "null"};
 ${config.i18n.enabled ? "_setDefaultFarmI18nRuntime(farmI18nRuntime);" : ""}
@@ -2717,6 +3045,9 @@ for (const route of pageRoutes) {
 const layoutRoutes = [${layoutRegistrations.join(",")}
 ];
 
+const routeSlots = [${routeSlotRegistrations.join(",")}
+];
+
 // Route-level error boundaries bundled at build time.
 const errorRoutes = [${errorRegistrations.join(",")}
 ];
@@ -2751,18 +3082,23 @@ function serializeFarmInlineValue(value) {
     .replace(/\\u2029/g, "\\\\u2029");
 }
 
-function renderFarmClientBootstrapScript(canonicalPath) {
+function renderFarmClientBootstrapScript(canonicalPath, selectedRouteSlots, pageProps) {
   const integrationManifest = ${hasRuntimeIntegrationConfig ? "getRegisteredIntegrationAPIManifest()" : "{}"};
-  let source = 'window.__FARM_INTEGRATION_API_MANIFEST__=' +
+  const serializedRouteSlots = serializeFarmInlineValue(selectedRouteSlots || []);
+  const serializedPageProps = serializeFarmInlineValue(pageProps || {});
+  let source = 'window.__FARM_PROPS__=' + serializedPageProps +
+    ';window.__FARM_INTEGRATION_API_MANIFEST__=' +
     serializeFarmInlineValue(integrationManifest) +
-    ';';
+    ';window.__FARM_ROUTE_SLOTS__=' + serializedRouteSlots + ';';
   if (typeof canonicalPath === "string" && canonicalPath.startsWith("/")) {
     const serializedPath = serializeFarmInlineValue(canonicalPath);
     source += 'if(location.pathname+location.search!==' + serializedPath + '){' +
       'history.replaceState(Object.assign({},history.state||{},{path:' + serializedPath + '}),"",' +
       serializedPath + ');}';
   }
-  return '<script>' + source + '</script>';
+  return '<script id="__farm_route_slots_data__" type="application/json">' +
+    serializedRouteSlots +
+    '</script><script>' + source + '</script>';
 }
 
 function escapeFarmHtmlAttribute(value) {
@@ -3447,9 +3783,14 @@ function applyConfiguredResponseHeaders(response, pathname) {
   for (const headerRoute of configuredHeaderRoutes) {
     if (!matchRuntimePathPattern(headerRoute.source, pathname)) continue;
     for (const header of headerRoute.headers) {
-      if ((headers || response.headers).get(header.key) === header.value) continue;
+      const currentValue = (headers || response.headers).get(header.key);
+      if (currentValue === header.value) continue;
       if (!headers) headers = new Headers(response.headers);
-      headers.set(header.key, header.value);
+      if (header.key.toLowerCase() === "link") {
+        appendFarmLinkHeader(headers, header.value);
+      } else {
+        headers.set(header.key, header.value);
+      }
     }
   }
 
@@ -3512,6 +3853,79 @@ function matchPageRoute(pathname) {
   return null;
 }
 
+function matchesRoutePrefix(pathname, pattern) {
+  if (pattern === "/") return true;
+  const pathSegments = normalizeRuntimePath(pathname).split("/").filter(Boolean);
+  const patternSegments = normalizeRuntimePath(pattern).split("/").filter(Boolean);
+  if (patternSegments.length > pathSegments.length) return false;
+  const candidate = "/" + pathSegments.slice(0, patternSegments.length).join("/");
+  return matchRuntimePathPattern(pattern, candidate) !== null;
+}
+
+function routeSlotSpecificity(slot) {
+  return slot.pattern.split("/").reduce(function(score, segment) {
+    if (!segment) return score;
+    if (segment.startsWith("[[...")) return score + 1;
+    if (segment.startsWith("[...")) return score + 2;
+    if (segment.startsWith("[")) return score + 3;
+    return score + 10;
+  }, 0);
+}
+
+function matchRouteSlots(pathname, interceptFrom) {
+  const groups = new Map();
+  for (const slot of routeSlots) {
+    if (!matchesRoutePrefix(pathname, slot.ownerPattern)) continue;
+    const key = slot.ownerPattern + ":" + slot.name;
+    const entries = groups.get(key) || [];
+    entries.push(slot);
+    groups.set(key, entries);
+  }
+
+  const normalizedFrom =
+    typeof interceptFrom === "string" && interceptFrom.startsWith("/")
+      ? new URL(interceptFrom, "http://farm.local").pathname
+      : null;
+  const matches = [];
+
+  for (const entries of groups.values()) {
+    const candidates = entries
+      .filter(function(entry) { return !entry.fallback; })
+      .filter(function(entry) {
+        return !entry.interception ||
+          (normalizedFrom && matchesRoutePrefix(normalizedFrom, entry.ownerPattern));
+      })
+      .map(function(entry) {
+        return {
+          entry: entry,
+          params: matchRuntimePathPattern(entry.pattern, pathname),
+        };
+      })
+      .filter(function(candidate) { return candidate.params !== null; })
+      .sort(function(left, right) {
+        if (left.entry.interception !== right.entry.interception) {
+          return left.entry.interception ? -1 : 1;
+        }
+        return routeSlotSpecificity(right.entry) - routeSlotSpecificity(left.entry);
+      });
+
+    if (candidates[0]) {
+      matches.push({ ...candidates[0].entry, params: candidates[0].params });
+      continue;
+    }
+
+    const fallback = entries.find(function(entry) { return entry.fallback; });
+    if (fallback) matches.push({ ...fallback, params: {} });
+  }
+
+  return matches.sort(function(left, right) {
+    const ownerDepth =
+      left.ownerPattern.split("/").filter(Boolean).length -
+      right.ownerPattern.split("/").filter(Boolean).length;
+    return ownerDepth || left.name.localeCompare(right.name);
+  });
+}
+
 function hasLocalRequestRoute(request, routePathname) {
   const pathname = new URL(request.url).pathname;
   if (matchLocalAPIRequest(request) || matchLocalIntegrationRequest(request)) {
@@ -3662,6 +4076,7 @@ function getPPRShellBypassReason(request, middlewareData, middlewareContext) {
   if (method !== "GET" && method !== "HEAD") return "method";
   if (request.headers.get("cookie")) return "cookie";
   if (request.headers.get("authorization")) return "authorization";
+  if (request.headers.get("x-farm-intercept-from")) return "route-interception";
   if (request.headers.get("x-farm-ppr-refresh")) return "refresh";
   if (hasConfiguredRouteContext) return "route-context";
   if (middlewareData?.size) return "middleware-data";
@@ -3715,8 +4130,8 @@ function getRouteSharedCacheControl(routeModule, pprCanCache) {
   return "public, s-maxage=" + revalidate + ", stale-while-revalidate=300";
 }
 
-function getCachedPPRShell(cacheKey) {
-  const entry = pprShellCache.getEntry(cacheKey);
+async function getCachedPPRShell(cacheKey) {
+  const entry = await pprShellCache.getEntryAsync(cacheKey);
   if (!entry) {
     return null;
   }
@@ -3728,7 +4143,7 @@ function getCachedPPRShell(cacheKey) {
  * Main request handler - created at runtime with bundled routes
  */
 async function handleFarmRequest(request) {
-  ${config.i18n.enabled ? `return _runWithFarmI18nRequest(
+  const response = await ${config.i18n.enabled ? `_runWithFarmI18nRequest(
     farmI18nRuntime,
     request,
     async function(farmLocaleResolution) {
@@ -3747,7 +4162,15 @@ async function handleFarmRequest(request) {
       const response = await handleFarmRequestInContext(request, farmLocaleResolution);
       return applyFarmI18nResponse(response, farmLocaleResolution);
     }
-  );` : "return handleFarmRequestInContext(request, null);"}
+  )` : "handleFarmRequestInContext(request, null)"};
+  ${config.md?.enabled ? `const pathname = getFarmRoutePathname(new URL(request.url).pathname);
+  if (matchPageRoute(pathname)) {
+    return applyMarkdownNegotiationHeaders(response, {
+      config: farmMarkdownConfig,
+      pathname,
+    });
+  }` : ""}
+  return response;
 }
 
 async function handleFarmRequestInContext(
@@ -3931,7 +4354,7 @@ async function handleFarmRequestInContext(
         }
       }
       if (pprCacheKey) {
-        const cachedPPRShell = getCachedPPRShell(pprCacheKey);
+        const cachedPPRShell = await getCachedPPRShell(pprCacheKey);
         if (cachedPPRShell) {
           emitFarmEvent({ type: "ppr.shell.hit", route: pathname, key: pprCacheKey });
           emitFarmEvent({
@@ -3945,6 +4368,7 @@ async function handleFarmRequestInContext(
             status: 200,
             headers: {
               "Content-Type": "text/html; charset=utf-8",
+              ...(farmFontPreloadHeader ? { "Link": farmFontPreloadHeader } : {}),
               ...getPPRHeaders("hit", pprConfig),
             },
           }), middlewareHeaders);
@@ -3959,6 +4383,10 @@ async function handleFarmRequestInContext(
       
       // Get applicable layouts for this page
       const applicableLayouts = getApplicableLayouts(routePathname);
+      const selectedRouteSlots = matchRouteSlots(
+        routePathname,
+        request.headers.get("x-farm-intercept-from"),
+      );
       
       if (PageComponent) {
         // Parse search params - make it a resolved Promise for async components
@@ -4046,6 +4474,100 @@ async function handleFarmRequestInContext(
             throw routeStateError;
           }
         }
+
+        const renderedRouteSlots = await Promise.all(
+          selectedRouteSlots.map(async function(slot) {
+            const slotContext = hasConfiguredRouteContext
+              ? await resolveFarmRouteContext(farmResolvedRuntimeConfig, {
+                  request,
+                  params: slot.params,
+                  search: searchParamsObj,
+                  path: pathname,
+                })
+              : undefined;
+            const rawSlotProps = withFarmRouteContext(
+              {
+                params: slot.params,
+                searchParams: Promise.resolve(searchParamsObj),
+                path: pathname,
+                ...(middlewareData?.size ? { middleware: { data: middlewareData } } : {}),
+              },
+              slotContext,
+            );
+            if (slot.module.__farmResolveRouteProps && slotContext !== undefined) {
+              Object.defineProperty(rawSlotProps, "context", {
+                value: slotContext,
+                enumerable: true,
+                configurable: true,
+              });
+            }
+
+            const slotSchemas = slot.module.__farmRouteParsesProps
+              ? {}
+              : slot.module.__farmRouteSchemas || {};
+            let slotProps = slot.module.__farmResolveRouteProps
+              ? await slot.module.__farmResolveRouteProps(rawSlotProps)
+              : {
+                  ...rawSlotProps,
+                  params: slotSchemas.params?.parse
+                    ? slotSchemas.params.parse(slot.params)
+                    : slot.params,
+                  search: slotSchemas.search?.parse
+                    ? slotSchemas.search.parse(searchParamsObj)
+                    : searchParamsObj,
+                  searchParams: Promise.resolve(
+                    slotSchemas.search?.parse
+                      ? slotSchemas.search.parse(searchParamsObj)
+                      : searchParamsObj,
+                  ),
+                };
+            if (
+              slot.module.__farmResolveRouteProps &&
+              slotContext !== undefined &&
+              slotProps.context === slotContext
+            ) {
+              const { context: _slotContext, ...renderSlotProps } = slotProps;
+              slotProps = renderSlotProps;
+            }
+
+            return { ...slot, props: slotProps };
+          }),
+        );
+        const clientMiddleware = middlewareData?.size
+          ? { data: Object.fromEntries(middlewareData) }
+          : undefined;
+        const clientPageProps = {
+          params: pageProps.params,
+          search: pageProps.search ?? searchParamsObj,
+          searchParams: pageProps.search ?? searchParamsObj,
+          ...("data" in pageProps ? { data: pageProps.data } : {}),
+          ...(pageProps.__farmCanonicalPath
+            ? { __farmCanonicalPath: pageProps.__farmCanonicalPath }
+            : {}),
+          ...(pageProps.__farmRoutePropsResolved
+            ? { __farmRoutePropsResolved: true }
+            : {}),
+          path: pathname,
+          ...(clientMiddleware ? { middleware: clientMiddleware } : {}),
+        };
+        const routeSlotPayload = renderedRouteSlots.map(function(slot) {
+          return {
+            name: slot.name,
+            ownerPattern: slot.ownerPattern,
+            pattern: slot.pattern,
+            containerId: slot.containerId,
+            interception: slot.interception,
+            fallback: slot.fallback,
+            props: {
+              params: slot.props.params,
+              search: slot.props.search || searchParamsObj,
+              searchParams: slot.props.search || searchParamsObj,
+              ...("data" in slot.props ? { data: slot.props.data } : {}),
+              path: pathname,
+              ...(clientMiddleware ? { middleware: clientMiddleware } : {}),
+            },
+          };
+        });
         
         const renderPageElement = async () => {
             // First, render the page content
@@ -4073,6 +4595,14 @@ async function handleFarmRequestInContext(
               pageElement = React.createElement(PageComponent, pageProps);
             }
 
+            if (route.shouldHydrate && renderedRouteSlots.length > 0) {
+              pageElement = React.createElement(
+                "div",
+                { id: "__farm_page__", "data-farm-client": "true" },
+                pageElement,
+              );
+            }
+
             // Wrap with layouts (from innermost to outermost)
             // Layouts are sorted by depth (root first), so we process in reverse
             let wrappedElement = pageElement;
@@ -4080,9 +4610,23 @@ async function handleFarmRequestInContext(
               const layout = applicableLayouts[i];
               const LayoutComponent = layout.module.default;
               if (LayoutComponent) {
+                const slotProps = {};
+                for (const slot of renderedRouteSlots) {
+                  if (slot.ownerPattern !== layout.pattern) continue;
+                  slotProps[slot.name] = React.createElement(
+                    "div",
+                    {
+                      id: slot.containerId,
+                      "data-farm-route-slot": slot.name,
+                      "data-farm-slot-owner": slot.ownerPattern,
+                    },
+                    React.createElement(slot.module.default, slot.props),
+                  );
+                }
                 wrappedElement = React.createElement(LayoutComponent, {
                   children: wrappedElement,
                   params,
+                  ...slotProps,
                 });
               }
             }
@@ -4134,6 +4678,7 @@ async function handleFarmRequestInContext(
         );
         const hasRequestScopedRender = Boolean(
           pageStatus >= 400 ||
+          request.headers.get("x-farm-intercept-from") ||
           hasPrivateRequestHeaders ||
           hasConfiguredRouteContext ||
           middlewareData?.size ||
@@ -4145,6 +4690,7 @@ async function handleFarmRequestInContext(
           "Cache-Control": renderedPage.stream || hasRequestScopedRender || !sharedCacheControl
             ? "private, no-store"
             : sharedCacheControl,
+          ...(farmFontPreloadHeader ? { "Link": farmFontPreloadHeader } : {}),
           ...(pprConfig.enabled ? getPPRHeaders(pprCanCache ? "miss" : "bypass", pprConfig) : {}),
         };
         const farmI18nSnapshot = getFarmI18nSnapshot();
@@ -4173,7 +4719,11 @@ async function handleFarmRequestInContext(
             '  <link rel="modulepreload" href="/farm-client.js">\\n' +
             '</head>\\n<body>\\n  <div id="root">';
           const streamSuffix = '</div>\\n' +
-            '  ' + renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath) + '\\n' +
+            '  ' + renderFarmClientBootstrapScript(
+              pageProps.__farmCanonicalPath,
+              routeSlotPayload,
+              clientPageProps
+            ) + '\\n' +
             '  <script type="module" src="/farm-client.js"></script>\\n' +
             '</body>\\n</html>';
           const streamedDocument = createFarmDocumentStream(
@@ -4230,7 +4780,11 @@ async function handleFarmRequestInContext(
             // Inject client script before closing body tag
             .replace(
               /<\\/body>/i,
-              '  ' + renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath) + '\\n' +
+              '  ' + renderFarmClientBootstrapScript(
+                pageProps.__farmCanonicalPath,
+                routeSlotPayload,
+                clientPageProps
+              ) + '\\n' +
                 '  <script type="module" src="/farm-client.js"></script>\\n</body>',
             );
           
@@ -4251,7 +4805,7 @@ async function handleFarmRequestInContext(
 </head>
 <body>
   <div id="root">\${html}</div>
-  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath)}
+  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath, routeSlotPayload, clientPageProps)}
   <script type="module" src="/farm-client.js"></script>
 </body>
 </html>\`;
@@ -4259,7 +4813,7 @@ async function handleFarmRequestInContext(
         fullHtml = applyFarmI18nDocument(fullHtml, pathname, farmI18nSnapshot);
 
         if (pageStatus === 200 && pprCacheKey && request.method.toUpperCase() !== "HEAD") {
-          pprShellCache.set(
+          await pprShellCache.setAsync(
             pprCacheKey,
             { html: fullHtml },
             {
@@ -4876,9 +5430,8 @@ async function buildNitroUniversal(config, routeManager, apiRouteManager, server
   const nitroEntryPath = path3.join(ssrOutputDir, "nitro-entry.mjs");
   const nitroEntryCode = `
 // Farm.js Nitro Entry
-// This file imports h3 and the SSR handler, wrapping it for Nitro
+// This file adapts Farm's Web fetch handler to Nitro's event handler contract.
 
-import { defineEventHandler } from 'h3'
 import handler from './${ssrEntryFile}'
 
 function mergeVaryHeaders(target, source) {
@@ -4916,8 +5469,8 @@ function createResponseFinishedHook(event) {
   }
 }
 
-// Export the wrapped handler for Nitro
-export default defineEventHandler(async (event) => {
+// Export the event handler for Nitro
+export default async function farmNitroEventHandler(event) {
   const response = await handler.fetch(event.req, {
     waitUntil: (promise) => event.waitUntil(promise),
     onResponseFinished: createResponseFinishedHook(event),
@@ -4928,7 +5481,7 @@ export default defineEventHandler(async (event) => {
   const farmVary = response.headers.get('Vary')
   if (farmVary) mergeVaryHeaders(event.res.headers, farmVary)
   return response
-})
+}
   `.trim();
   await fs.writeFile(nitroEntryPath, nitroEntryCode);
   const prebuiltSSRPlugin = createExternalSSRBundlePlugin(
@@ -5346,8 +5899,8 @@ async function copySharpRuntime(config, root, nitroFuncDir, fs) {
     await fs.mkdir(path3.dirname(targetDir), { recursive: true });
     const packageRequire = createRequire(packageJsonPath);
     const dependencies = {
-      ...packageJson.dependencies || {},
-      ...packageJson.optionalDependencies || {}
+      ...packageJson.dependencies,
+      ...packageJson.optionalDependencies
     };
     await Promise.all([
       fs.cp(packageDir, targetDir, {
@@ -5571,7 +6124,14 @@ async function createProjectModuleServer(createViteServer, config, root) {
           plugins: []
         }
       },
-      plugins: [farmEnvironmentFunctionsPlugin()],
+      plugins: [
+        farmFontImportsPlugin({
+          root,
+          basePath: config.basePath,
+          publicDir: config.publicDir
+        }),
+        farmEnvironmentFunctionsPlugin()
+      ],
       server: {
         middlewareMode: true,
         hmr: false
@@ -5667,7 +6227,7 @@ async function buildSSR(viteBuild, config, root, srcDir, outputDir) {
 __name(buildSSR, "buildSSR");
 async function buildNitro(config, routeManager, apiRouteManager, serverRenderer, preset, root, distDir, pluginManager) {
   const [{ createNitroConfig }, { createNitro, build: nitroBuild }] = await Promise.all([
-    import("./nitro-KME62MWG.mjs"),
+    import("./nitro-QO5LV6QK.mjs"),
     import("nitro")
   ]);
   let nitroConfig = await createNitroConfig(
@@ -5760,4 +6320,4 @@ __name(buildNitro, "buildNitro");
 export {
   build
 };
-//# sourceMappingURL=chunk-G3B5BRDY.mjs.map
+//# sourceMappingURL=chunk-4677KXB7.mjs.map