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

package/dist/{chunk-CHFHNEMO.mjs → chunk-77BOAQHI.mjs}

@@ -5,7 +5,7 @@ import {
   addMetadataImageReference,
   mergeMetadata,
   renderMetadataHead
-} from "./chunk-ZJQNATYV.mjs";
+} from "./chunk-FRPWCMMG.mjs";
 import {
   farmEnvironmentFunctionsPlugin
 } from "./chunk-V6WE6JSZ.mjs";
@@ -13,11 +13,23 @@ import {
   createFarmImageHandler
 } from "./chunk-3XNTL3FQ.mjs";
 import {
+  createEnvTypeDeclarations,
   generateEnvTypes
-} from "./chunk-BHG3LVHH.mjs";
+} from "./chunk-CGIXMLSY.mjs";
 import {
   writeFileIfChanged
 } from "./chunk-USWZZUEH.mjs";
+import {
+  getFarmRedirectError,
+  isFarmNotFoundError,
+  isFarmRedirectError
+} from "./chunk-7HO6AEOP.mjs";
+import {
+  resolveFarmAuthConfig
+} from "./chunk-I4CUBGVF.mjs";
+import {
+  normalizeRouteRules
+} from "./chunk-YW7OBE6Q.mjs";
 import {
   getFarmAppDirectories,
   getFarmLayerAliases,
@@ -28,33 +40,31 @@ import {
   FARM_DEVTOOLS_PATH,
   resolveFarmDevtoolsConfig
 } from "./chunk-7MABZJIM.mjs";
-import {
-  normalizeRouteRules
-} from "./chunk-OYXO65LI.mjs";
 import {
   getPublicFarmImageConfig,
   resolveFarmImageConfig
 } from "./chunk-GY2STC2S.mjs";
 import {
-  createMarkdownMirrorResponse,
-  resolveMarkdownConfig
-} from "./chunk-LLC7BNXW.mjs";
+  resolveServerActionsConfig
+} from "./chunk-UB5UOSHB.mjs";
 import {
   createFarmMarkdownRouteModuleFromFile,
   createFarmMarkdownSourceResponse,
   isFarmMarkdownPageFile,
   loadFarmMdxComponents,
   resolveMdxConfig
-} from "./chunk-S2XHZS7W.mjs";
+} from "./chunk-ZVWA4ZQ3.mjs";
+import {
+  createMarkdownMirrorResponse,
+  resolveMarkdownConfig,
+  resolveMarkdownMirrorTarget
+} from "./chunk-7FBJLMQH.mjs";
 import {
   resolveWorkflowsConfig
-} from "./chunk-Y2OJJD7R.mjs";
+} from "./chunk-XIVV5IWN.mjs";
 import {
   resolveCronConfig
-} from "./chunk-UREJA4GZ.mjs";
-import {
-  resolveServerActionsConfig
-} from "./chunk-AGS7UJ52.mjs";
+} from "./chunk-GXASWWJU.mjs";
 import {
   dispatchIntegrationRequest,
   getIntegrationDocumentNavigationMatchers,
@@ -63,14 +73,9 @@ import {
   getRequestContextSnapshot,
   matchIntegrationRoute
 } from "./chunk-K4667E2Q.mjs";
-import {
-  getFarmRedirectError,
-  isFarmNotFoundError,
-  isFarmRedirectError
-} from "./chunk-7HO6AEOP.mjs";
 import {
   MiddlewareManager
-} from "./chunk-O3HADRW6.mjs";
+} from "./chunk-MIUW47JX.mjs";
 import {
   _clearCurrentMiddlewareContext,
   _clearCurrentMiddlewareData,
@@ -91,14 +96,14 @@ import {
   discoverProgrammaticRoutePaths,
   findProgrammaticRouteFiles,
   loadProgrammaticRouteManifests
-} from "./chunk-YHU7SS6L.mjs";
+} from "./chunk-Z5CQMP54.mjs";
 import {
   _runWithFarmI18nRequest,
   _setDefaultFarmI18nRuntime,
   createFarmI18nRuntime,
   getFarmI18nClientSnapshot,
   readFarmI18nCatalogs
-} from "./chunk-QF4PHCMA.mjs";
+} from "./chunk-2ED5Q2GH.mjs";
 import {
   createFarmLocaleCookie,
   getFarmLocaleVaryHeaders
@@ -106,19 +111,6 @@ import {
 import {
   resolveFarmI18nConfig
 } from "./chunk-FQYDHKKU.mjs";
-import {
-  fileExists,
-  globFiles,
-  logger,
-  matchRoute,
-  parseRoutePath,
-  resolveAppPath,
-  toViteModuleId
-} from "./chunk-J4FNJ5IU.mjs";
-import {
-  _runWithCurrentRequest,
-  createWebRequestFromFarmRequest
-} from "./chunk-RHIFZZUI.mjs";
 import {
   createLayoutModuleFromProgrammaticLayout,
   createProgrammaticRouteModuleId,
@@ -128,7 +120,7 @@ import {
   parseProgrammaticRouteModuleId,
   parseProgrammaticRoutePath,
   scanProgrammaticPagePaths
-} from "./chunk-B6N4ZB2H.mjs";
+} from "./chunk-C2ROET2V.mjs";
 import {
   resolveFarmRouteContext,
   withFarmRouteContext
@@ -139,7 +131,23 @@ import {
   normalizeFarmRouteRuntimeConfig,
   resolveFarmRouteRuleRuntimeConfig,
   resolveFarmRouteRuntimeConfig
-} from "./chunk-QM6VV26B.mjs";
+} from "./chunk-GQVGIUSN.mjs";
+import {
+  fileExists,
+  globFiles,
+  logger,
+  matchRoute,
+  parseRoutePath,
+  resolveAppPath,
+  toViteModuleId
+} from "./chunk-J4FNJ5IU.mjs";
+import {
+  _runWithCurrentRequest,
+  createWebRequestFromFarmRequest
+} from "./chunk-RHIFZZUI.mjs";
+import {
+  FARM_VERSION
+} from "./chunk-5EVQFRL2.mjs";
 import {
   FARM_DEPLOYMENT_ID_HEADER,
   createFarmDeploymentCookie,
@@ -158,10 +166,11 @@ import {
   stripFarmLocaleFromPathname
 } from "./chunk-44ZCFSKE.mjs";
 import {
+  configureFarmCache,
   createFarmCacheKey,
   getFarmDataCache,
   normalizeRevalidatePath
-} from "./chunk-4PTK6KT4.mjs";
+} from "./chunk-V3XURYJO.mjs";
 import {
   configureFarmObservability,
   emitFarmEvent
@@ -775,6 +784,76 @@ async function readAltText(filePath) {
 }
 __name(readAltText, "readAltText");
 
+// src/routing/route-slots.ts
+var SLOT_SEGMENT = /^@([A-Za-z][A-Za-z0-9_-]*)$/;
+function parseRouteSlotFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  const fileName = parts.at(-1) ?? "";
+  const baseName = fileName.replace(/\.(tsx?|jsx?)$/, "");
+  if (baseName !== "page" && baseName !== "default") return null;
+  const slotIndex = parts.findIndex((part) => SLOT_SEGMENT.test(part));
+  if (slotIndex < 0) return null;
+  if (parts.slice(slotIndex + 1, -1).some((part) => SLOT_SEGMENT.test(part))) {
+    throw new Error(`Nested route slots are not supported in "${filePath}"`);
+  }
+  const slotMatch = parts[slotIndex].match(SLOT_SEGMENT);
+  const name = slotMatch?.[1];
+  if (!name) return null;
+  const ownerParts = parts.slice(0, slotIndex);
+  const contentParts = parts.slice(slotIndex + 1, -1);
+  const marker = parseInterceptionMarker(contentParts[0]);
+  let targetBase = ownerParts;
+  let targetParts = contentParts;
+  if (marker) {
+    targetBase = marker.root === true ? [] : ownerParts.slice(0, Math.max(0, ownerParts.length - marker.up));
+    targetParts = [...marker.remainder ? [marker.remainder] : [], ...contentParts.slice(1)];
+  }
+  const ownerFile = [...ownerParts, "layout.tsx"].join("/");
+  const routeFile = [
+    ...baseName === "default" ? ownerParts : targetBase,
+    ...baseName === "default" ? [] : targetParts,
+    "page.tsx"
+  ].join("/");
+  return {
+    name,
+    ownerRoute: parseRoutePath(ownerFile || "layout.tsx"),
+    route: parseRoutePath(routeFile || "page.tsx"),
+    interception: marker !== null,
+    fallback: baseName === "default"
+  };
+}
+__name(parseRouteSlotFile, "parseRouteSlotFile");
+function createRouteSlotContainerId(name, ownerPattern) {
+  const owner = ownerPattern === "/" ? "root" : ownerPattern.replace(/^\//, "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `__farm_slot_${name}_${owner || "root"}__`;
+}
+__name(createRouteSlotContainerId, "createRouteSlotContainerId");
+function parseInterceptionMarker(segment) {
+  if (!segment) return null;
+  if (segment.startsWith("(...)")) {
+    return {
+      up: 0,
+      root: true,
+      remainder: segment.slice(5)
+    };
+  }
+  if (segment.startsWith("(.)")) {
+    return {
+      up: 0,
+      remainder: segment.slice(3)
+    };
+  }
+  let remainder = segment;
+  let up = 0;
+  while (remainder.startsWith("(..)")) {
+    up += 1;
+    remainder = remainder.slice(4);
+  }
+  return up > 0 ? { up, remainder } : null;
+}
+__name(parseInterceptionMarker, "parseInterceptionMarker");
+
 // src/routing/route-manager.ts
 function routeSpecificity(entry) {
   return entry.route.segments.reduce((score, segment) => {
@@ -788,6 +867,7 @@ var _RouteManager = class _RouteManager {
   constructor(config, viteServer) {
     this.routes = /* @__PURE__ */ new Map();
     this.layouts = /* @__PURE__ */ new Map();
+    this.routeSlots = /* @__PURE__ */ new Map();
     this.loadings = /* @__PURE__ */ new Map();
     this.errors = /* @__PURE__ */ new Map();
     this.metadataImages = /* @__PURE__ */ new Map();
@@ -803,6 +883,7 @@ var _RouteManager = class _RouteManager {
   async discoverRoutes() {
     this.routes.clear();
     this.layouts.clear();
+    this.routeSlots.clear();
     this.loadings.clear();
     this.errors.clear();
     this.metadataImages.clear();
@@ -813,6 +894,13 @@ var _RouteManager = class _RouteManager {
       await this.discoverFileRoutes(source);
       await this.discoverProgrammaticRoutes(source);
     }
+    for (const slot of this.routeSlots.values()) {
+      if (slot.interception && !this.routes.has(slot.pattern)) {
+        throw new Error(
+          `Intercepting route slot "${slot.name}" targets "${slot.pattern}", but no canonical page exists for that URL`
+        );
+      }
+    }
     this.routes = new Map(
       Array.from(this.routes.entries()).sort(
         ([, left], [, right]) => routeSpecificity(right) - routeSpecificity(left)
@@ -828,7 +916,7 @@ var _RouteManager = class _RouteManager {
   /**
    * Find matching route for a given URL path
    */
-  matchRoute(pathname) {
+  matchRoute(pathname, options = {}) {
     const routePathname = this.toRoutePathname(pathname);
     const normalizedPath = routePathname === "/" ? "/" : routePathname.replace(/\/$/, "");
     let matchedRoute = null;
@@ -842,10 +930,12 @@ var _RouteManager = class _RouteManager {
       }
     }
     const layouts = this.findMatchingLayouts(normalizedPath);
+    const slots = this.findMatchingRouteSlots(normalizedPath, options.interceptFrom);
     return {
       route: matchedRoute,
       params,
-      layouts
+      layouts,
+      slots
     };
   }
   /**
@@ -860,6 +950,9 @@ var _RouteManager = class _RouteManager {
   getLayouts() {
     return new Map(this.layouts);
   }
+  getRouteSlots() {
+    return new Map(this.routeSlots);
+  }
   /** Resolve route rules, inherited layouts, and the page export in precedence order. */
   async resolveRouteRuntimeConfig(pattern) {
     const routeEntry = this.routes.get(pattern);
@@ -1018,7 +1111,22 @@ var _RouteManager = class _RouteManager {
       pattern: entry.pattern,
       modulePath: toUrlPath(entry.modulePath)
     }));
-    return { routes, layouts };
+    const slots = Array.from(this.routeSlots.values()).map((entry) => {
+      const metadata = getClientModuleMetadata(entry.modulePath, projectRoot);
+      return {
+        name: entry.name,
+        ownerPattern: entry.ownerPattern,
+        pattern: entry.pattern,
+        modulePath: toUrlPath(entry.modulePath),
+        containerId: entry.containerId,
+        interception: entry.interception,
+        fallback: entry.fallback,
+        shouldHydrate: metadata.shouldHydrate,
+        isClientComponent: metadata.isClientComponent,
+        segments: entry.route.segments
+      };
+    });
+    return { routes, layouts, slots };
   }
   /**
    * Load a route module dynamically
@@ -1095,6 +1203,7 @@ var _RouteManager = class _RouteManager {
   async discoverFileRoutes(source) {
     const appDir = resolveAppPath(source.root, source.srcDir, "app");
     const pageFiles = await safeGlobFiles("**/page.{ts,tsx,js,jsx,md,mdx}", appDir);
+    const slotDefaultFiles = await safeGlobFiles("**/@*/**/default.{ts,tsx,js,jsx}", appDir);
     const layoutFiles = await safeGlobFiles("**/layout.{ts,tsx,js,jsx}", appDir);
     const loadingFiles = await safeGlobFiles("**/loading.{ts,tsx,js,jsx}", appDir);
     const errorFiles = await safeGlobFiles("**/error.{ts,tsx,js,jsx}", appDir);
@@ -1102,8 +1211,56 @@ var _RouteManager = class _RouteManager {
       "**/{opengraph-image,twitter-image}.{ts,tsx,js,jsx,png,jpg,jpeg,gif,webp}",
       appDir
     );
+    const canonicalPageGroups = /* @__PURE__ */ new Map();
+    for (const file of pageFiles.filter((candidate) => parseRouteSlotFile(candidate) === null)) {
+      const route = parseRoutePath(file);
+      const pattern = this.createRoutePattern(route);
+      const group = canonicalPageGroups.get(pattern);
+      if (group) {
+        group.files.push(file);
+      } else {
+        canonicalPageGroups.set(pattern, {
+          route,
+          files: [file]
+        });
+      }
+    }
+    for (const [pattern, group] of canonicalPageGroups) {
+      const componentFiles = group.files.filter((file) => !isFarmMarkdownPageFile(file));
+      const markdownFiles = group.files.filter(isFarmMarkdownPageFile);
+      if (componentFiles.length > 1) {
+        throw new Error(
+          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+        );
+      }
+      if (markdownFiles.length > 1) {
+        throw new Error(
+          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+        );
+      }
+      const componentFile = componentFiles[0];
+      const markdownFile = markdownFiles[0];
+      const primaryFile = componentFile || markdownFile;
+      if (!primaryFile) continue;
+      const modulePath = path3.join(appDir, primaryFile);
+      const existing = this.routes.get(pattern);
+      if (existing?.sourceRoot === source.root) {
+        throw new Error(
+          `Duplicate page route "${pattern}". Found both ${existing.modulePath} and ${modulePath}.`
+        );
+      }
+      this.routes.set(pattern, {
+        route: group.route,
+        modulePath,
+        ...markdownFile ? {
+          markdownSourcePath: path3.join(appDir, markdownFile)
+        } : {},
+        pattern,
+        source: "file",
+        sourceRoot: source.root
+      });
+    }
     for (const [kind, files, target] of [
-      ["page", pageFiles, this.routes],
       ["layout", layoutFiles, this.layouts],
       ["loading", loadingFiles, this.loadings],
       ["error", errorFiles, this.errors]
@@ -1127,6 +1284,32 @@ var _RouteManager = class _RouteManager {
         });
       }
     }
+    for (const file of [...pageFiles, ...slotDefaultFiles]) {
+      const slot = parseRouteSlotFile(file);
+      if (!slot) continue;
+      const modulePath = path3.join(appDir, file);
+      const pattern = this.createRoutePattern(slot.route);
+      const ownerPattern = this.createRoutePattern(slot.ownerRoute);
+      const key = `${ownerPattern}:${slot.name}:${slot.interception ? "intercept" : "slot"}:${slot.fallback ? "default" : pattern}`;
+      const existing = this.routeSlots.get(key);
+      if (existing?.sourceRoot === source.root) {
+        throw new Error(
+          `Duplicate route slot "${slot.name}" for "${pattern}". Found both ${existing.modulePath} and ${modulePath}.`
+        );
+      }
+      this.routeSlots.set(key, {
+        route: slot.route,
+        modulePath,
+        pattern,
+        source: "file",
+        sourceRoot: source.root,
+        name: slot.name,
+        ownerPattern,
+        interception: slot.interception,
+        fallback: slot.fallback,
+        containerId: createRouteSlotContainerId(slot.name, ownerPattern)
+      });
+    }
     for (const file of metadataImageFiles) {
       const fileBase = path3.basename(file, path3.extname(file));
       const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
@@ -1252,6 +1435,71 @@ var _RouteManager = class _RouteManager {
     }
     return matchingLayouts;
   }
+  findMatchingRouteSlots(pathname, interceptFrom) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of this.routeSlots.values()) {
+      if (!this.matchesRoutePrefix(pathname, entry.ownerPattern)) continue;
+      const key = `${entry.ownerPattern}:${entry.name}`;
+      const entries = groups.get(key) ?? [];
+      entries.push(entry);
+      groups.set(key, entries);
+    }
+    const normalizedFrom = interceptFrom ? this.toRoutePathname(new URL(interceptFrom, "http://farm.local").pathname) : void 0;
+    const matches = [];
+    for (const entries of groups.values()) {
+      const candidates = entries.filter((entry) => !entry.fallback).filter(
+        (entry) => !entry.interception || normalizedFrom !== void 0 && this.matchesRoutePrefix(normalizedFrom, entry.ownerPattern)
+      ).map((entry) => ({
+        entry,
+        match: matchRoute(pathname, entry.route.segments)
+      })).filter((candidate) => candidate.match.matches).sort((left, right) => {
+        if (left.entry.interception !== right.entry.interception) {
+          return left.entry.interception ? -1 : 1;
+        }
+        return routeSpecificity(right.entry) - routeSpecificity(left.entry);
+      });
+      const selected = candidates[0];
+      if (selected) {
+        matches.push({
+          name: selected.entry.name,
+          ownerPattern: selected.entry.ownerPattern,
+          containerId: selected.entry.containerId,
+          interception: selected.entry.interception,
+          fallback: false,
+          route: selected.entry,
+          params: selected.match.params
+        });
+        continue;
+      }
+      const fallback = entries.find((entry) => entry.fallback);
+      if (fallback) {
+        matches.push({
+          name: fallback.name,
+          ownerPattern: fallback.ownerPattern,
+          containerId: fallback.containerId,
+          interception: false,
+          fallback: true,
+          route: fallback,
+          params: {}
+        });
+      }
+    }
+    return matches.sort((left, right) => {
+      const ownerDifference = left.route.route.segments.length - right.route.route.segments.length;
+      return ownerDifference || left.name.localeCompare(right.name);
+    });
+  }
+  matchesRoutePrefix(pathname, pattern) {
+    if (pattern === "/") return true;
+    const patternSegments = parseRoutePath(`${pattern}/page.tsx`).segments;
+    const pathSegments = pathname.split("/").filter(Boolean);
+    if (patternSegments.length > pathSegments.length) return false;
+    for (let index = 0; index < patternSegments.length; index++) {
+      const segment = patternSegments[index];
+      if (!segment.isDynamic && segment.segment !== pathSegments[index]) return false;
+    }
+    return true;
+  }
   findNearestBoundary(pathname, boundaries) {
     const normalizedPath = pathname === "/" ? "/" : pathname.replace(/\/$/, "");
     const pathSegments = normalizedPath.split("/").filter(Boolean);
@@ -1447,8 +1695,1052 @@ __name(safeGlobFiles, "safeGlobFiles");
 import React from "react";
 import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
 import * as fs2 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 import { Writable } from "stream";
+
+// src/font-vite.ts
+import { createHash as createHash2, timingSafeEqual } from "crypto";
+import { existsSync } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import path4 from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+var FONT_IMPORTS = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/font"]);
+var FONT_FUNCTIONS = /* @__PURE__ */ new Set(["localFont", "remoteFont"]);
+var FONT_CSS_PREFIX = "\0farm:font-css:";
+var FONT_RUNTIME_ID = "\0farm:font-runtime";
+var PUBLIC_FONT_RUNTIME_ID = "virtual:farm-font-runtime";
+var PRELOAD_HEADER_MARKER = "__FARM_FONT_PRELOAD_HEADER__";
+var FONT_SECTION_START = "/* farm-fonts:start */";
+var FONT_SECTION_END = "/* farm-fonts:end */";
+var MODULE_EXTENSION_RE = /\.[cm]?[jt]sx?$/;
+var FONT_EXTENSION_RE = /\.(woff2?|ttf|otf)$/i;
+var MAX_REMOTE_FONT_BYTES = 20 * 1024 * 1024;
+var FONT_REGISTRIES_KEY = /* @__PURE__ */ Symbol.for("farm.fontRegistries");
+var FONT_REMOTE_BYTES_KEY = /* @__PURE__ */ Symbol.for("farm.fontRemoteBytes");
+var registries = getGlobalMap(FONT_REGISTRIES_KEY);
+var remoteBytes = getGlobalMap(FONT_REMOTE_BYTES_KEY);
+function farmFontImportsPlugin(options = {}) {
+  let root = normalizeRoot(options.root || process.cwd());
+  let production = process.env.NODE_ENV === "production";
+  let registry = getOrCreateRegistry(root, options.basePath, options.publicDir);
+  const updateRoot = /* @__PURE__ */ __name((nextRoot, basePath, publicDir) => {
+    const normalized = normalizeRoot(nextRoot);
+    root = normalized;
+    registry = getOrCreateRegistry(root, basePath, publicDir);
+  }, "updateRoot");
+  return {
+    name: "farm:font-imports",
+    enforce: "post",
+    configResolved(config) {
+      production = config.command === "build";
+      updateRoot(
+        config.root,
+        options.basePath || config.base,
+        options.publicDir === void 0 ? config.publicDir : options.publicDir
+      );
+      registry.production = production;
+    },
+    configureServer(server) {
+      updateRoot(
+        server.config.root,
+        options.basePath || server.config.base,
+        options.publicDir === void 0 ? server.config.publicDir : options.publicDir
+      );
+      registry.production = false;
+      server.middlewares.use(async (req, res, next) => {
+        const pathname = new URL(req.url || "/", "http://farm.local").pathname;
+        if (pathname === "/@farm/fonts.css") {
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "text/css; charset=utf-8");
+          res.setHeader("Cache-Control", "no-store");
+          res.end(registry.renderCss(false));
+          return;
+        }
+        const resource = registry.getDevResource(pathname);
+        if (!resource?.bytes) {
+          next();
+          return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", fontContentType(resource.extension));
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+        res.end(resource.bytes);
+      });
+    },
+    resolveId(id) {
+      if (id === PUBLIC_FONT_RUNTIME_ID || id === FONT_RUNTIME_ID) return FONT_RUNTIME_ID;
+      if (id.startsWith("virtual:farm-font-css/")) {
+        return `${FONT_CSS_PREFIX}${id.slice("virtual:farm-font-css/".length)}`;
+      }
+      if (id.startsWith(FONT_CSS_PREFIX)) return id;
+      return null;
+    },
+    load(id) {
+      if (id === FONT_RUNTIME_ID) {
+        return `export const farmFontPreloadHeader = decodeURIComponent(${JSON.stringify(PRELOAD_HEADER_MARKER)});`;
+      }
+      if (!id.startsWith(FONT_CSS_PREFIX)) return null;
+      return registry.renderFontCss(
+        id.slice(FONT_CSS_PREFIX.length).replace(/\.css$/, ""),
+        production
+      );
+    },
+    async transform(code, id) {
+      const result = await transformFarmFontCalls({
+        code,
+        id,
+        root,
+        production,
+        parse: /* @__PURE__ */ __name((source) => this.parse(source), "parse"),
+        register: /* @__PURE__ */ __name((moduleId, calls) => registry.register(moduleId, calls, production), "register")
+      });
+      if (!result) registry.clearModule(id.split("?", 1)[0]);
+      return result ? { code: result.code, map: null } : null;
+    },
+    async generateBundle(_options, bundle) {
+      registry.emitAssets(this, bundle);
+    }
+  };
+}
+__name(farmFontImportsPlugin, "farmFontImportsPlugin");
+async function transformFarmFontCalls(options) {
+  const cleanId = options.id.split("?", 1)[0];
+  if (!MODULE_EXTENSION_RE.test(cleanId) || /\.d\.[cm]?ts$/.test(cleanId) || !containsFontFunction(options.code)) {
+    return null;
+  }
+  const ast = options.parse(options.code);
+  const bindings = findFontBindings(ast);
+  if (bindings.named.size === 0 && bindings.namespaces.size === 0) return null;
+  const calls = findFontCalls(ast, bindings);
+  if (calls.length === 0) return null;
+  validateFontBindingReferences(ast, calls, cleanId);
+  const registeredCalls = calls.map((call) => ({
+    kind: call.kind,
+    options: readFontOptions(options.code, cleanId, call)
+  }));
+  const fonts = await options.register(cleanId, registeredCalls);
+  const replacements = calls.map((call, index) => ({
+    start: call.node.start,
+    end: call.node.end,
+    code: serializeFontResult(fonts[index])
+  }));
+  replacements.push(
+    ...createFontImportReplacements(
+      options.code,
+      ast,
+      new Set(calls.map((call) => call.binding).filter((value) => Boolean(value)))
+    )
+  );
+  const imports = options.production ? "" : Array.from(new Set(fonts.map((font) => font.id))).map((id) => `import ${JSON.stringify(`virtual:farm-font-css/${id}.css`)};`).join("\n");
+  return {
+    code: `${applyReplacements(options.code, replacements)}
+${imports}
+`,
+    fonts
+  };
+}
+__name(transformFarmFontCalls, "transformFarmFontCalls");
+function renderFarmFontDevHead(root) {
+  const registry = registries.get(normalizeRoot(root));
+  if (!registry || registry.production || registry.size === 0) return "";
+  return `${registry.renderPreloadTags(false)}
+  <link rel="stylesheet" href="/@farm/fonts.css">`;
+}
+__name(renderFarmFontDevHead, "renderFarmFontDevHead");
+var _FarmFontRegistry = class _FarmFontRegistry {
+  constructor(root, basePath = "/", publicDir) {
+    this.production = false;
+    this.modules = /* @__PURE__ */ new Map();
+    this.definitions = /* @__PURE__ */ new Map();
+    this.resources = /* @__PURE__ */ new Map();
+    this.root = root;
+    this.basePath = normalizeBasePath(basePath);
+    this.publicDir = normalizePublicDir(root, publicDir);
+  }
+  get size() {
+    return this.getDefinitions().length;
+  }
+  async register(moduleId, calls, production) {
+    const definitions = [];
+    for (const call of calls) {
+      definitions.push(await this.createDefinition(moduleId, call.kind, call.options, production));
+    }
+    this.modules.set(moduleId, definitions);
+    for (const definition of definitions) this.definitions.set(definition.id, definition);
+    return definitions;
+  }
+  clearModule(moduleId) {
+    this.modules.delete(moduleId);
+  }
+  renderFontCss(id, production) {
+    const definition = this.definitions.get(id);
+    return definition ? renderFontDefinitionCss(definition, production, this.basePath) : "";
+  }
+  renderCss(production) {
+    const css = this.getDefinitions().map((definition) => renderFontDefinitionCss(definition, production, this.basePath)).join("\n\n");
+    return css ? `${FONT_SECTION_START}
+${css}
+${FONT_SECTION_END}
+` : "";
+  }
+  renderPreloadHeader(production) {
+    return this.getPreloadResources(production).map(
+      ({ url, resource }) => `<${url}>; rel=preload; as=font; type=${fontContentType(resource.extension)}; crossorigin`
+    ).join(", ");
+  }
+  renderPreloadTags(production) {
+    return this.getPreloadResources(production).map(
+      ({ url, resource }) => `<link rel="preload" href="${escapeHtmlAttribute(url)}" as="font" type="${fontContentType(resource.extension)}" crossorigin>`
+    ).join("\n  ");
+  }
+  getDevResource(pathname) {
+    for (const resource of this.getActiveResources()) {
+      if (resource.bytes && resourceUrl(resource, false, this.basePath) === pathname) {
+        return resource;
+      }
+    }
+    return void 0;
+  }
+  emitAssets(context, bundle) {
+    for (const resource of this.getActiveResources()) {
+      if (!resource.bytes || !resource.outputFileName) continue;
+      if (bundle[resource.outputFileName]) continue;
+      context.emitFile({
+        type: "asset",
+        fileName: resource.outputFileName,
+        source: resource.bytes
+      });
+    }
+    const css = this.renderCss(true);
+    if (css) {
+      const cssAssets = Object.values(bundle).filter(
+        (entry) => entry.type === "asset" && entry.fileName.endsWith(".css")
+      );
+      const clientCss = cssAssets.find(
+        (entry) => entry.type === "asset" && entry.fileName === "farm-client.css"
+      ) ?? (cssAssets.length === 1 ? cssAssets[0] : void 0);
+      if (clientCss) {
+        clientCss.source = replaceFontSection(assetSourceToString(clientCss.source), css);
+      } else if (!bundle["farm-fonts.css"]) {
+        context.emitFile({
+          type: "asset",
+          fileName: "farm-fonts.css",
+          source: css
+        });
+      }
+    }
+    const preloadHeader = encodeURIComponent(this.renderPreloadHeader(true));
+    for (const entry of Object.values(bundle)) {
+      if (entry.type === "chunk" && entry.code.includes(PRELOAD_HEADER_MARKER)) {
+        entry.code = entry.code.split(PRELOAD_HEADER_MARKER).join(preloadHeader);
+      }
+    }
+  }
+  getDefinitions() {
+    const active = /* @__PURE__ */ new Map();
+    for (const definitions of this.modules.values()) {
+      for (const definition of definitions) active.set(definition.id, definition);
+    }
+    return Array.from(active.values()).sort((left, right) => left.id.localeCompare(right.id));
+  }
+  getActiveResources() {
+    const active = /* @__PURE__ */ new Set();
+    for (const definition of this.getDefinitions()) {
+      for (const source of definition.sources) active.add(source.resource);
+    }
+    return Array.from(active);
+  }
+  getPreloadResources(production) {
+    const seen = /* @__PURE__ */ new Set();
+    const resources = [];
+    for (const definition of this.getDefinitions()) {
+      if (!definition.preload) continue;
+      for (const source of definition.sources) {
+        const url = resourceUrl(source.resource, production, this.basePath);
+        if (seen.has(url)) continue;
+        seen.add(url);
+        resources.push({ url, resource: source.resource });
+      }
+    }
+    return resources;
+  }
+  async createDefinition(moduleId, kind, raw, production) {
+    validateOptionKeys(moduleId, kind, raw);
+    const family = requireString(raw.family, moduleId, `${kind}() family`);
+    const display = raw.display ?? "swap";
+    if (!["auto", "block", "swap", "fallback", "optional"].includes(display)) {
+      throw fontError(moduleId, `invalid font-display value ${JSON.stringify(display)}`);
+    }
+    const variable = optionalString(raw.variable, moduleId, `${kind}() variable`);
+    if (variable && !/^--[A-Za-z_][\w-]*$/.test(variable)) {
+      throw fontError(moduleId, `font variable must be a CSS custom property such as --font-sans`);
+    }
+    const fallback = readStringArray(raw.fallback, moduleId, `${kind}() fallback`);
+    const defaultWeight = optionalWeight(raw.weight, moduleId);
+    const defaultStyle = optionalCssDescriptor(raw.style, moduleId, "style") || "normal";
+    const sources = readSources(raw.src, moduleId, kind, defaultWeight, defaultStyle);
+    const strategy = kind === "remoteFont" ? raw.strategy ?? "self-host" : "self-host";
+    if (strategy !== "self-host" && strategy !== "external") {
+      throw fontError(moduleId, `remoteFont() strategy must be "self-host" or "external"`);
+    }
+    const integrity = optionalString(raw.integrity, moduleId, `${kind}() integrity`);
+    const normalizedSources = [];
+    for (const source of sources) {
+      const resource = await this.resolveResource({
+        kind,
+        moduleId,
+        source: source.path,
+        strategy,
+        integrity: source.integrity ?? integrity,
+        production
+      });
+      normalizedSources.push({
+        source: source.path,
+        weight: String(source.weight ?? defaultWeight ?? "400"),
+        style: source.style || defaultStyle,
+        unicodeRange: source.unicodeRange,
+        resource
+      });
+    }
+    const identity = JSON.stringify({
+      family,
+      display,
+      variable,
+      fallback,
+      preload: raw.preload !== false,
+      sources: normalizedSources.map((source) => ({
+        hash: source.resource.hash,
+        url: source.resource.publicUrl,
+        weight: source.weight,
+        style: source.style,
+        unicodeRange: source.unicodeRange
+      }))
+    });
+    const id = createHash2("sha256").update(identity).digest("hex").slice(0, 10);
+    return {
+      id,
+      family,
+      className: `farm-font-${id}`,
+      variableClassName: variable ? `farm-font-variable-${id}` : "",
+      variable,
+      fallback,
+      display,
+      preload: raw.preload !== false,
+      weight: defaultWeight,
+      style: raw.style === void 0 ? void 0 : defaultStyle,
+      sources: normalizedSources
+    };
+  }
+  async resolveResource(input) {
+    if (input.kind === "remoteFont") {
+      let url;
+      try {
+        url = new URL(input.source);
+      } catch {
+        throw fontError(input.moduleId, `remoteFont() source must be an absolute HTTPS URL`);
+      }
+      if (url.protocol !== "https:") {
+        throw fontError(input.moduleId, `remoteFont() only accepts HTTPS URLs`);
+      }
+      const extension = extensionFromPath(url.pathname);
+      if (input.strategy === "external") {
+        const hash = createHash2("sha256").update(url.href).digest("hex").slice(0, 12);
+        const resource = {
+          extension,
+          format: fontFormat(extension),
+          hash,
+          publicUrl: url.href
+        };
+        this.resources.set(`external:${url.href}`, resource);
+        return resource;
+      }
+      const bytes2 = await fetchRemoteFont(url, input.integrity);
+      return this.createSelfHostedResource(bytes2, extension, path4.basename(url.pathname));
+    }
+    if (input.source.startsWith("/")) {
+      return this.createPublicResource(input.moduleId, input.source);
+    }
+    const resolvedPath = resolveLocalFontPath(input.source, input.moduleId, this.root);
+    if (!FONT_EXTENSION_RE.test(resolvedPath)) {
+      throw fontError(
+        input.moduleId,
+        `unsupported local font file ${JSON.stringify(input.source)}`
+      );
+    }
+    let bytes;
+    try {
+      bytes = await readFile3(resolvedPath);
+    } catch (error) {
+      throw fontError(
+        input.moduleId,
+        `could not read ${JSON.stringify(input.source)}: ${error.message}`
+      );
+    }
+    return this.createSelfHostedResource(
+      bytes,
+      path4.extname(resolvedPath),
+      path4.basename(resolvedPath)
+    );
+  }
+  async createPublicResource(moduleId, source) {
+    if (!this.publicDir) {
+      throw fontError(
+        moduleId,
+        `cannot resolve ${JSON.stringify(source)} because publicDir is disabled`
+      );
+    }
+    const publicPath = normalizePublicFontPath(source, moduleId);
+    const resolvedPath = path4.resolve(this.publicDir, `.${publicPath}`);
+    if (!isPathInside(this.publicDir, resolvedPath)) {
+      throw fontError(moduleId, `public font path must stay inside publicDir`);
+    }
+    if (!FONT_EXTENSION_RE.test(resolvedPath)) {
+      throw fontError(moduleId, `unsupported public font file ${JSON.stringify(source)}`);
+    }
+    let bytes;
+    try {
+      bytes = await readFile3(resolvedPath);
+    } catch (error) {
+      throw fontError(
+        moduleId,
+        `could not read ${JSON.stringify(source)} from publicDir: ${error.message}`
+      );
+    }
+    const extension = path4.extname(resolvedPath).toLowerCase();
+    const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
+    const resource = {
+      extension,
+      format: fontFormat(extension),
+      hash,
+      publicPath,
+      publicUrl: ""
+    };
+    this.resources.set(`public:${publicPath}`, resource);
+    return resource;
+  }
+  createSelfHostedResource(bytes, extension, fileName) {
+    const normalizedExtension = extension.toLowerCase();
+    const hash = createHash2("sha256").update(bytes).digest("hex").slice(0, 12);
+    const baseName = sanitizeFileName(path4.basename(fileName, extension)) || "font";
+    const outputFileName = `assets/fonts/${baseName}-${hash}${normalizedExtension}`;
+    const key = `${hash}${normalizedExtension}`;
+    const existing = this.resources.get(key);
+    if (existing) return existing;
+    const resource = {
+      bytes,
+      extension: normalizedExtension,
+      format: fontFormat(normalizedExtension),
+      hash,
+      outputFileName,
+      publicUrl: ""
+    };
+    this.resources.set(key, resource);
+    return resource;
+  }
+};
+__name(_FarmFontRegistry, "FarmFontRegistry");
+var FarmFontRegistry = _FarmFontRegistry;
+function findFontBindings(ast) {
+  const named = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const body = Array.isArray(ast.body) ? ast.body : [];
+  for (const statement of body) {
+    if (!isAstNode(statement) || statement.type !== "ImportDeclaration") continue;
+    const source = isAstNode(statement.source) ? statement.source.value : void 0;
+    if (typeof source !== "string" || !FONT_IMPORTS.has(source)) continue;
+    const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers : [];
+    for (const specifier of specifiers) {
+      if (!isAstNode(specifier) || !isAstNode(specifier.local)) continue;
+      const localName = specifier.local.name;
+      if (typeof localName !== "string") continue;
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        namespaces.add(localName);
+        continue;
+      }
+      if (specifier.type !== "ImportSpecifier" || !isAstNode(specifier.imported)) continue;
+      const importedName = specifier.imported.name ?? specifier.imported.value;
+      if (isFontLoaderKind(importedName)) named.set(localName, importedName);
+    }
+  }
+  return { named, namespaces };
+}
+__name(findFontBindings, "findFontBindings");
+function findFontCalls(ast, bindings) {
+  const calls = [];
+  walkAst(ast, (node, ancestors) => {
+    if (node.type !== "CallExpression" || !isAstNode(node.callee)) return;
+    let kind;
+    if (node.callee.type === "Identifier" && typeof node.callee.name === "string") {
+      kind = bindings.named.get(node.callee.name);
+      if (kind) calls.push({ kind, binding: node.callee.name, node, ancestors });
+    } else if (node.callee.type === "MemberExpression" && node.callee.computed !== true && isAstNode(node.callee.object) && isAstNode(node.callee.property) && node.callee.object.type === "Identifier" && node.callee.property.type === "Identifier" && typeof node.callee.object.name === "string" && typeof node.callee.property.name === "string" && bindings.namespaces.has(node.callee.object.name) && isFontLoaderKind(node.callee.property.name)) {
+      kind = node.callee.property.name;
+    }
+    if (kind && node.callee.type !== "Identifier") calls.push({ kind, node, ancestors });
+  });
+  return calls;
+}
+__name(findFontCalls, "findFontCalls");
+function validateFontBindingReferences(ast, calls, id) {
+  const calledBindings = new Set(
+    calls.map((call) => call.binding).filter((binding) => Boolean(binding))
+  );
+  const transformedCallees = new Set(
+    calls.flatMap((call) => {
+      const callee = call.node.callee;
+      return call.binding && isAstNode(callee) ? [`${callee.start}:${callee.end}`] : [];
+    })
+  );
+  walkAst(ast, (node, ancestors) => {
+    if (node.type !== "Identifier" || typeof node.name !== "string" || !calledBindings.has(node.name)) {
+      return;
+    }
+    const parent = ancestors.at(-1);
+    if (!parent || isNonReferenceIdentifier(node, parent)) return;
+    if (transformedCallees.has(`${node.start}:${node.end}`)) return;
+    throw fontError(
+      id,
+      `${node.name} can only be referenced by statically compiled font declarations`
+    );
+  });
+}
+__name(validateFontBindingReferences, "validateFontBindingReferences");
+function isNonReferenceIdentifier(node, parent) {
+  if (parent.type === "ImportSpecifier") return true;
+  if ((parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && parent.property === node && parent.computed !== true) {
+    return true;
+  }
+  if ((parent.type === "Property" || parent.type === "PropertyDefinition") && parent.key === node && parent.computed !== true && parent.shorthand !== true) {
+    return true;
+  }
+  return false;
+}
+__name(isNonReferenceIdentifier, "isNonReferenceIdentifier");
+function createFontImportReplacements(code, ast, calledBindings) {
+  if (calledBindings.size === 0) return [];
+  const replacements = [];
+  const body = Array.isArray(ast.body) ? ast.body : [];
+  for (const statement of body) {
+    if (!isAstNode(statement) || statement.type !== "ImportDeclaration") continue;
+    const source = isAstNode(statement.source) ? statement.source.value : void 0;
+    if (typeof source !== "string" || !FONT_IMPORTS.has(source)) continue;
+    const specifiers = (Array.isArray(statement.specifiers) ? statement.specifiers : []).filter(
+      isAstNode
+    );
+    const retained = specifiers.filter((specifier) => {
+      if (specifier.type !== "ImportSpecifier" || !isAstNode(specifier.local)) return true;
+      return typeof specifier.local.name !== "string" || !calledBindings.has(specifier.local.name);
+    });
+    if (retained.length === specifiers.length) continue;
+    replacements.push({
+      start: statement.start,
+      end: statement.end,
+      code: renderImportDeclaration(code, source, retained)
+    });
+  }
+  return replacements;
+}
+__name(createFontImportReplacements, "createFontImportReplacements");
+function renderImportDeclaration(code, source, specifiers) {
+  if (specifiers.length === 0) return "";
+  const defaultSpecifier = specifiers.find(
+    (specifier) => specifier.type === "ImportDefaultSpecifier"
+  );
+  const namespaceSpecifier = specifiers.find(
+    (specifier) => specifier.type === "ImportNamespaceSpecifier"
+  );
+  const namedSpecifiers = specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+  const parts = [];
+  if (defaultSpecifier && isAstNode(defaultSpecifier.local)) {
+    parts.push(code.slice(defaultSpecifier.local.start, defaultSpecifier.local.end));
+  }
+  if (namespaceSpecifier && isAstNode(namespaceSpecifier.local)) {
+    parts.push(`* as ${code.slice(namespaceSpecifier.local.start, namespaceSpecifier.local.end)}`);
+  }
+  if (namedSpecifiers.length > 0) {
+    parts.push(
+      `{ ${namedSpecifiers.map((specifier) => code.slice(specifier.start, specifier.end)).join(", ")} }`
+    );
+  }
+  return parts.length > 0 ? `import ${parts.join(", ")} from ${JSON.stringify(source)};` : "";
+}
+__name(renderImportDeclaration, "renderImportDeclaration");
+function readFontOptions(code, id, call) {
+  if (!call.binding) {
+    throw fontError(id, `${call.kind}() must use a named import from @farm.js/core/font`);
+  }
+  const args = Array.isArray(call.node.arguments) ? call.node.arguments : [];
+  if (args.length !== 1 || !isAstNode(args[0]) || args[0].type !== "ObjectExpression") {
+    throw fontError(id, `${call.kind}() requires one inline options object`);
+  }
+  const parent = call.ancestors.at(-1);
+  if (!parent || parent.type !== "VariableDeclarator" || parent.init !== call.node) {
+    throw fontError(id, `${call.kind}() must initialize a module-scope variable`);
+  }
+  const declaration = call.ancestors.at(-2);
+  const statement = call.ancestors.at(-3);
+  const statementParent = call.ancestors.at(-4);
+  const isModuleScope = declaration?.type === "VariableDeclaration" && (statement?.type === "Program" || statement?.type === "ExportNamedDeclaration" && statementParent?.type === "Program");
+  if (!isModuleScope || call.ancestors.some((ancestor) => isFunctionNode(ancestor))) {
+    throw fontError(id, `${call.kind}() must be declared directly at module scope`);
+  }
+  return evaluateStaticObject(code, id, args[0]);
+}
+__name(readFontOptions, "readFontOptions");
+function evaluateStaticObject(code, id, node) {
+  const result = {};
+  const properties = Array.isArray(node.properties) ? node.properties : [];
+  for (const property of properties) {
+    if (!isAstNode(property) || property.type !== "Property" || property.computed === true) {
+      throw fontError(id, "font options do not support spreads or computed properties");
+    }
+    const key = readPropertyName(property.key);
+    if (!key || !isAstNode(property.value)) {
+      throw fontError(id, "font options must use static property names and values");
+    }
+    result[key] = evaluateStaticValue(code, id, property.value);
+  }
+  return result;
+}
+__name(evaluateStaticObject, "evaluateStaticObject");
+function evaluateStaticValue(code, id, node) {
+  if (node.type === "Literal") return node.value;
+  if (node.type === "TemplateLiteral") {
+    const expressions = Array.isArray(node.expressions) ? node.expressions : [];
+    const quasis = Array.isArray(node.quasis) ? node.quasis : [];
+    if (expressions.length === 0 && quasis.length === 1 && isAstNode(quasis[0])) {
+      const templateValue = quasis[0].value;
+      const value = templateValue && typeof templateValue === "object" ? templateValue.cooked : void 0;
+      if (typeof value === "string") return value;
+    }
+  }
+  if (node.type === "ArrayExpression") {
+    const elements = Array.isArray(node.elements) ? node.elements : [];
+    return elements.map((element) => {
+      if (!isAstNode(element) || element.type === "SpreadElement") {
+        throw fontError(id, "font option arrays must contain static values");
+      }
+      return evaluateStaticValue(code, id, element);
+    });
+  }
+  if (node.type === "ObjectExpression") return evaluateStaticObject(code, id, node);
+  if (node.type === "UnaryExpression" && (node.operator === "+" || node.operator === "-") && isAstNode(node.argument)) {
+    const value = evaluateStaticValue(code, id, node.argument);
+    if (typeof value === "number") return node.operator === "-" ? -value : value;
+  }
+  throw fontError(
+    id,
+    `font options must be statically analyzable near ${code.slice(node.start, node.end)}`
+  );
+}
+__name(evaluateStaticValue, "evaluateStaticValue");
+function readSources(value, id, kind, weight, style) {
+  if (typeof value === "string") return [{ path: value, weight, style }];
+  if (!Array.isArray(value) || value.length === 0) {
+    throw fontError(id, `${kind}() src must be a string or a non-empty source array`);
+  }
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw fontError(id, `${kind}() src[${index}] must be an object`);
+    }
+    const source = entry;
+    const unknown = Object.keys(source).filter(
+      (key) => ![
+        "path",
+        "weight",
+        "style",
+        "unicodeRange",
+        ...kind === "remoteFont" ? ["integrity"] : []
+      ].includes(key)
+    );
+    if (unknown.length) throw fontError(id, `unknown src[${index}] option ${unknown[0]}`);
+    return {
+      path: requireString(source.path, id, `${kind}() src[${index}].path`),
+      weight: optionalWeight(source.weight, id) ?? weight,
+      style: optionalCssDescriptor(source.style, id, "style") || style,
+      unicodeRange: optionalUnicodeRange(source.unicodeRange, id),
+      integrity: optionalString(source.integrity, id, `${kind}() src[${index}].integrity`)
+    };
+  });
+}
+__name(readSources, "readSources");
+function validateOptionKeys(id, kind, raw) {
+  const allowed = /* @__PURE__ */ new Set([
+    "src",
+    "family",
+    "weight",
+    "style",
+    "display",
+    "variable",
+    "fallback",
+    "preload",
+    ...kind === "remoteFont" ? ["strategy", "integrity"] : []
+  ]);
+  const unknown = Object.keys(raw).find((key) => !allowed.has(key));
+  if (unknown) throw fontError(id, `unknown ${kind}() option ${JSON.stringify(unknown)}`);
+  if (typeof raw.preload !== "undefined" && typeof raw.preload !== "boolean") {
+    throw fontError(id, `${kind}() preload must be a boolean`);
+  }
+}
+__name(validateOptionKeys, "validateOptionKeys");
+function serializeFontResult(font) {
+  const stack = renderFamilyStack(font.family, font.fallback);
+  return JSON.stringify({
+    className: font.className,
+    variable: font.variableClassName,
+    style: {
+      fontFamily: stack,
+      ...font.style ? { fontStyle: font.style } : {},
+      ...font.weight !== void 0 && !String(font.weight).includes(" ") ? { fontWeight: font.weight } : {}
+    }
+  });
+}
+__name(serializeFontResult, "serializeFontResult");
+function renderFontDefinitionCss(font, production, basePath) {
+  const faces = font.sources.map((source) => {
+    const descriptors = [
+      `  font-family: ${quoteCssString(font.family)};`,
+      `  src: url(${quoteCssString(resourceUrl(source.resource, production, basePath))}) format(${quoteCssString(source.resource.format)});`,
+      `  font-display: ${font.display};`,
+      `  font-weight: ${source.weight};`,
+      `  font-style: ${source.style};`,
+      ...source.unicodeRange ? [`  unicode-range: ${source.unicodeRange};`] : []
+    ];
+    return `@font-face {
+${descriptors.join("\n")}
+}`;
+  });
+  const stack = renderFamilyStack(font.family, font.fallback);
+  faces.push(`.${font.className} {
+  font-family: ${stack};
+}`);
+  if (font.variable && font.variableClassName) {
+    faces.push(`.${font.variableClassName} {
+  ${font.variable}: ${stack};
+}`);
+  }
+  return faces.join("\n\n");
+}
+__name(renderFontDefinitionCss, "renderFontDefinitionCss");
+function resourceUrl(resource, production, basePath) {
+  if (resource.publicPath) {
+    return production ? joinBasePath(basePath, resource.publicPath) : resource.publicPath;
+  }
+  if (!resource.bytes) return resource.publicUrl;
+  if (!production) {
+    return joinBasePath(basePath, `/@farm/font/${resource.hash}${resource.extension}`);
+  }
+  return joinBasePath(basePath, `/${resource.outputFileName}`);
+}
+__name(resourceUrl, "resourceUrl");
+async function fetchRemoteFont(url, integrity) {
+  const key = `${url.href}\0${integrity || ""}`;
+  let pending = remoteBytes.get(key);
+  if (!pending) {
+    pending = (async () => {
+      const response = await fetch(url, {
+        headers: { "User-Agent": "Farm.js font compiler" },
+        redirect: "follow"
+      });
+      if (!response.ok)
+        throw new Error(`request returned ${response.status} ${response.statusText}`);
+      const length = Number(response.headers.get("content-length") || 0);
+      if (length > MAX_REMOTE_FONT_BYTES) throw new Error("font exceeds the 20 MB limit");
+      const bytes = await readResponseBodyWithLimit(response, MAX_REMOTE_FONT_BYTES);
+      if (integrity) verifyIntegrity(bytes, integrity);
+      return bytes;
+    })().catch((error) => {
+      throw new Error(`[Farm fonts] Failed to download ${url.href}: ${error.message}`);
+    });
+    remoteBytes.set(key, pending);
+    const clearPending = /* @__PURE__ */ __name(() => {
+      if (remoteBytes.get(key) === pending) remoteBytes.delete(key);
+    }, "clearPending");
+    void pending.then(clearPending, clearPending);
+  }
+  return pending;
+}
+__name(fetchRemoteFont, "fetchRemoteFont");
+async function readResponseBodyWithLimit(response, limit) {
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    total += chunk.value.byteLength;
+    if (total > limit) {
+      await reader.cancel("font exceeds the configured byte limit");
+      throw new Error("font exceeds the 20 MB limit");
+    }
+    chunks.push(chunk.value);
+  }
+  return Buffer.concat(chunks, total);
+}
+__name(readResponseBodyWithLimit, "readResponseBodyWithLimit");
+function verifyIntegrity(bytes, integrity) {
+  const entries = integrity.trim().split(/\s+/);
+  const supported = entries.map((entry) => entry.match(/^(sha(?:256|384|512))-(.+)$/)).filter((entry) => Boolean(entry));
+  if (supported.length === 0) throw new Error("integrity must use sha256, sha384, or sha512");
+  const matches = supported.some((entry) => {
+    const actual = createHash2(entry[1]).update(bytes).digest();
+    const expected = Buffer.from(entry[2], "base64");
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+  });
+  if (!matches) throw new Error("downloaded font did not match its integrity value");
+}
+__name(verifyIntegrity, "verifyIntegrity");
+function resolveLocalFontPath(source, importer, root) {
+  if (source.startsWith(".")) return path4.resolve(path4.dirname(importer), source);
+  if (path4.isAbsolute(source)) {
+    return source;
+  }
+  try {
+    return createRequire(pathToFileURL(importer)).resolve(source);
+  } catch {
+    const segments = source.replace(/\\/g, "/").split("/");
+    if (segments.includes("..")) return path4.resolve(root, source);
+    let current = path4.dirname(importer);
+    const filesystemRoot = path4.parse(current).root;
+    while (true) {
+      const candidate = path4.join(current, "node_modules", ...segments);
+      if (existsSync(candidate)) return candidate;
+      if (current === filesystemRoot) break;
+      current = path4.dirname(current);
+    }
+    return path4.resolve(root, "node_modules", ...segments);
+  }
+}
+__name(resolveLocalFontPath, "resolveLocalFontPath");
+function replaceFontSection(css, section) {
+  const start = css.indexOf(FONT_SECTION_START);
+  const end = css.indexOf(FONT_SECTION_END);
+  const withoutExisting = start >= 0 && end >= start ? `${css.slice(0, start)}${css.slice(end + FONT_SECTION_END.length)}`.trimEnd() : css.trimEnd();
+  return `${withoutExisting}${withoutExisting ? "\n\n" : ""}${section}`;
+}
+__name(replaceFontSection, "replaceFontSection");
+function mergeFarmFontCss(clientCss, fontCss) {
+  return replaceFontSection(clientCss, fontCss);
+}
+__name(mergeFarmFontCss, "mergeFarmFontCss");
+function getOrCreateRegistry(root, basePath = "/", publicDir) {
+  const normalized = normalizeRoot(root);
+  const existing = registries.get(normalized);
+  if (existing) {
+    existing.basePath = normalizeBasePath(basePath);
+    existing.publicDir = normalizePublicDir(normalized, publicDir);
+    return existing;
+  }
+  const registry = new FarmFontRegistry(normalized, basePath, publicDir);
+  registries.set(normalized, registry);
+  return registry;
+}
+__name(getOrCreateRegistry, "getOrCreateRegistry");
+function getGlobalMap(key) {
+  const runtime = globalThis;
+  const existing = runtime[key];
+  if (existing instanceof Map) return existing;
+  const created = /* @__PURE__ */ new Map();
+  runtime[key] = created;
+  return created;
+}
+__name(getGlobalMap, "getGlobalMap");
+function normalizeRoot(root) {
+  return path4.resolve(root).replace(/\\/g, "/");
+}
+__name(normalizeRoot, "normalizeRoot");
+function normalizePublicDir(root, publicDir) {
+  if (publicDir === false || publicDir === "") return false;
+  return path4.resolve(root, publicDir || "public");
+}
+__name(normalizePublicDir, "normalizePublicDir");
+function normalizePublicFontPath(source, moduleId) {
+  if (source.includes("?") || source.includes("#")) {
+    throw fontError(moduleId, `public font paths cannot contain a query string or fragment`);
+  }
+  return `/${source.replace(/\\/g, "/").replace(/^\/+/, "")}`;
+}
+__name(normalizePublicFontPath, "normalizePublicFontPath");
+function isPathInside(parent, child) {
+  const relative = path4.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+__name(isPathInside, "isPathInside");
+function normalizeBasePath(value) {
+  if (!value || value === "/") return "/";
+  return `/${value.replace(/^\/+|\/+$/g, "")}/`;
+}
+__name(normalizeBasePath, "normalizeBasePath");
+function joinBasePath(basePath, value) {
+  return basePath === "/" ? value : `${basePath.replace(/\/$/, "")}${value}`;
+}
+__name(joinBasePath, "joinBasePath");
+function extensionFromPath(pathname) {
+  const extension = path4.extname(pathname).toLowerCase();
+  if (!FONT_EXTENSION_RE.test(extension)) {
+    throw new Error(`[Farm fonts] Remote font URL must end in .woff2, .woff, .ttf, or .otf`);
+  }
+  return extension;
+}
+__name(extensionFromPath, "extensionFromPath");
+function fontFormat(extension) {
+  switch (extension.toLowerCase()) {
+    case ".woff2":
+      return "woff2";
+    case ".woff":
+      return "woff";
+    case ".ttf":
+      return "truetype";
+    case ".otf":
+      return "opentype";
+    default:
+      throw new Error(`[Farm fonts] Unsupported font extension ${extension}`);
+  }
+}
+__name(fontFormat, "fontFormat");
+function fontContentType(extension) {
+  switch (extension.toLowerCase()) {
+    case ".woff2":
+      return "font/woff2";
+    case ".woff":
+      return "font/woff";
+    case ".ttf":
+      return "font/ttf";
+    case ".otf":
+      return "font/otf";
+    default:
+      return "application/octet-stream";
+  }
+}
+__name(fontContentType, "fontContentType");
+function renderFamilyStack(family, fallback) {
+  return [quoteCssString(family), ...fallback.map(formatFallbackFamily)].join(", ");
+}
+__name(renderFamilyStack, "renderFamilyStack");
+function formatFallbackFamily(value) {
+  return /^(?:serif|sans-serif|monospace|cursive|fantasy|system-ui|ui-serif|ui-sans-serif|ui-monospace|emoji|math|fangsong)$/.test(
+    value
+  ) ? value : quoteCssString(value);
+}
+__name(formatFallbackFamily, "formatFallbackFamily");
+function quoteCssString(value) {
+  return JSON.stringify(value.replace(/[\n\r\f]/g, " "));
+}
+__name(quoteCssString, "quoteCssString");
+function sanitizeFileName(value) {
+  return value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+__name(sanitizeFileName, "sanitizeFileName");
+function assetSourceToString(source) {
+  return typeof source === "string" ? source : Buffer.from(source).toString("utf8");
+}
+__name(assetSourceToString, "assetSourceToString");
+function applyReplacements(code, replacements) {
+  let output = code;
+  for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+    output = output.slice(0, replacement.start) + replacement.code + output.slice(replacement.end);
+  }
+  return output;
+}
+__name(applyReplacements, "applyReplacements");
+function walkAst(node, visit, ancestors = []) {
+  visit(node, ancestors);
+  const childAncestors = [...ancestors, node];
+  for (const [key, value] of Object.entries(node)) {
+    if (["start", "end", "loc", "range"].includes(key)) continue;
+    if (isAstNode(value)) walkAst(value, visit, childAncestors);
+    else if (Array.isArray(value)) {
+      for (const item of value) if (isAstNode(item)) walkAst(item, visit, childAncestors);
+    }
+  }
+}
+__name(walkAst, "walkAst");
+function readPropertyName(value) {
+  if (!isAstNode(value)) return void 0;
+  if (value.type === "Identifier" && typeof value.name === "string") return value.name;
+  if (value.type === "Literal" && typeof value.value === "string") return value.value;
+  return void 0;
+}
+__name(readPropertyName, "readPropertyName");
+function isAstNode(value) {
+  return Boolean(value) && typeof value === "object" && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+__name(isAstNode, "isAstNode");
+function isFunctionNode(node) {
+  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+__name(isFunctionNode, "isFunctionNode");
+function isFontLoaderKind(value) {
+  return typeof value === "string" && FONT_FUNCTIONS.has(value);
+}
+__name(isFontLoaderKind, "isFontLoaderKind");
+function containsFontFunction(code) {
+  return Array.from(FONT_FUNCTIONS).some((name) => code.includes(name));
+}
+__name(containsFontFunction, "containsFontFunction");
+function requireString(value, id, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw fontError(id, `${label} must be a non-empty string`);
+  }
+  return value;
+}
+__name(requireString, "requireString");
+function optionalString(value, id, label) {
+  if (value === void 0) return void 0;
+  return requireString(value, id, label);
+}
+__name(optionalString, "optionalString");
+function readStringArray(value, id, label) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw fontError(id, `${label} must be an array of family names`);
+  }
+  return value;
+}
+__name(readStringArray, "readStringArray");
+function optionalWeight(value, id) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 1e3) {
+    return value;
+  }
+  if (typeof value === "string" && /^(?:[1-9]\d{0,2}|1000)(?:\s+(?:[1-9]\d{0,2}|1000))?$/.test(value)) {
+    const bounds = value.split(/\s+/).map(Number);
+    if (bounds.length === 2 && bounds[0] > bounds[1]) {
+      throw fontError(id, `font weight range must be ordered from lowest to highest`);
+    }
+    return value;
+  }
+  throw fontError(id, `font weight must be a number or range such as "100 900"`);
+}
+__name(optionalWeight, "optionalWeight");
+function optionalCssDescriptor(value, id, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !/^[A-Za-z0-9 .-]+$/.test(value)) {
+    throw fontError(id, `font ${label} contains unsupported characters`);
+  }
+  return value;
+}
+__name(optionalCssDescriptor, "optionalCssDescriptor");
+function optionalUnicodeRange(value, id) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !/^[Uu+0-9A-Fa-f?*, -]+$/.test(value)) {
+    throw fontError(id, `font unicodeRange contains unsupported characters`);
+  }
+  return value;
+}
+__name(optionalUnicodeRange, "optionalUnicodeRange");
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+__name(escapeHtmlAttribute, "escapeHtmlAttribute");
+function fontError(id, message) {
+  return new Error(`[Farm fonts] ${message} in ${id.split("?", 1)[0]}`);
+}
+__name(fontError, "fontError");
+
+// src/server/renderer.ts
 var cachedClerkProvider = null;
 var importRuntimeModule = new Function("specifier", "return import(specifier);");
 function hasRequestHeader(req, name) {
@@ -1460,10 +2752,10 @@ function serializeInlineValue(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 __name(serializeInlineValue, "serializeInlineValue");
-function escapeHtmlAttribute(value) {
+function escapeHtmlAttribute2(value) {
   return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-__name(escapeHtmlAttribute, "escapeHtmlAttribute");
+__name(escapeHtmlAttribute2, "escapeHtmlAttribute");
 function appendResponseHeader(res, name, value) {
   const current = res.getHeader(name);
   if (current === void 0) {
@@ -1489,10 +2781,10 @@ function renderI18nAlternateLinks(requestPath, snapshot) {
   const url = new URL(requestPath, "http://farm.local");
   const links = snapshot.locales.map((locale) => {
     const href = localizeFarmPathname(url.pathname, locale, snapshot);
-    return `<link rel="alternate" hreflang="${escapeHtmlAttribute(locale)}" href="${escapeHtmlAttribute(href)}">`;
+    return `<link rel="alternate" hreflang="${escapeHtmlAttribute2(locale)}" href="${escapeHtmlAttribute2(href)}">`;
   });
   links.push(
-    `<link rel="alternate" hreflang="x-default" href="${escapeHtmlAttribute(
+    `<link rel="alternate" hreflang="x-default" href="${escapeHtmlAttribute2(
       localizeFarmPathname(url.pathname, snapshot.defaultLocale, snapshot)
     )}">`
   );
@@ -1656,7 +2948,9 @@ var _ServerRenderer = class _ServerRenderer {
   async runWithRequestContext(request, fn) {
     return _runWithCurrentRequest(
       request,
-      () => this.i18nRuntime?.config.enabled ? _runWithFarmI18nRequest(this.i18nRuntime, request, fn, { redirect: false }) : fn()
+      () => this.i18nRuntime?.config.enabled ? _runWithFarmI18nRequest(this.i18nRuntime, request, fn, {
+        redirect: false
+      }) : fn()
     );
   }
   async resolveRouteContext(input) {
@@ -1667,7 +2961,7 @@ var _ServerRenderer = class _ServerRenderer {
    */
   loadSSGManifest() {
     try {
-      const manifestPath = path4.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
+      const manifestPath = path5.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
       if (fs2.existsSync(manifestPath)) {
         const content = fs2.readFileSync(manifestPath, "utf-8");
         this.ssgManifest = JSON.parse(content);
@@ -1679,11 +2973,11 @@ var _ServerRenderer = class _ServerRenderer {
   /**
    * Check if a path should be served from SSG cache
    */
-  shouldServeSSG(pathname) {
+  async shouldServeSSG(pathname) {
     const ssgPage = matchSSGPage(pathname, this.ssgManifest);
     if (!ssgPage) return null;
-    const cached = this.getCachedSSGPage(pathname);
-    if (cached && this.dataCache.isStale(cached)) {
+    const cached = await this.getCachedSSGPage(pathname);
+    if (cached && await this.dataCache.isStaleAsync(cached)) {
       this.regenerateSSGPage(ssgPage);
     }
     return ssgPage;
@@ -1695,12 +2989,12 @@ var _ServerRenderer = class _ServerRenderer {
     return createFarmCacheKey(["ppr", normalizeRevalidatePath(pathname), search]);
   }
   getCachedSSGPage(urlPath) {
-    return this.dataCache.getEntry(this.getSSGCacheKey(urlPath), {
+    return this.dataCache.getEntryAsync(this.getSSGCacheKey(urlPath), {
       allowStale: true
     });
   }
-  cacheSSGPage(page, html, options) {
-    this.dataCache.set(
+  async cacheSSGPage(page, html, options) {
+    await this.dataCache.setAsync(
       this.getSSGCacheKey(page.urlPath),
       { html, document: options.document },
       {
@@ -1712,11 +3006,11 @@ var _ServerRenderer = class _ServerRenderer {
     );
   }
   getCachedPPRShell(pathname, search) {
-    return this.dataCache.getEntry(this.getPPRCacheKey(pathname, search));
+    return this.dataCache.getEntryAsync(this.getPPRCacheKey(pathname, search));
   }
-  cachePPRShell(options, html) {
+  async cachePPRShell(options, html) {
     const key = this.getPPRCacheKey(options.pathname, options.search);
-    this.dataCache.set(
+    await this.dataCache.setAsync(
       key,
       { html },
       {
@@ -1814,7 +3108,7 @@ var _ServerRenderer = class _ServerRenderer {
           }
           const { renderToString } = await import("react-dom/server");
           const html = renderToString(await this.wrapWithIntegrationProviders(pageElement));
-          this.cacheSSGPage(page, html, { document: false });
+          await this.cacheSSGPage(page, html, { document: false });
           logger.info(`ISR: Regenerated ${page.urlPath}`);
         } catch (error) {
           logger.error(`ISR regeneration failed for ${page.urlPath}: ${error}`);
@@ -1828,7 +3122,7 @@ var _ServerRenderer = class _ServerRenderer {
    * Serve a pre-rendered SSG page
    */
   async serveSSGPage(req, res, page) {
-    const cached = this.getCachedSSGPage(page.urlPath);
+    const cached = await this.getCachedSSGPage(page.urlPath);
     if (cached) {
       res.setHeader("Content-Type", "text/html; charset=utf-8");
       res.setHeader("X-Farm-SSG", "cached");
@@ -1842,13 +3136,16 @@ var _ServerRenderer = class _ServerRenderer {
       return true;
     }
     try {
-      const htmlPath = page.urlPath === "/" ? path4.join(this.config.root, this.config.outDir, "client", "index.html") : path4.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
+      const htmlPath = page.urlPath === "/" ? path5.join(this.config.root, this.config.outDir, "client", "index.html") : path5.join(this.config.root, this.config.outDir, "client", page.urlPath + ".html");
       if (fs2.existsSync(htmlPath)) {
         const stat = fs2.statSync(htmlPath);
         const html = fs2.readFileSync(htmlPath, "utf-8");
-        this.cacheSSGPage(page, html, { document: true, createdAt: stat.mtimeMs });
-        const fileCacheEntry = this.getCachedSSGPage(page.urlPath);
-        if (fileCacheEntry && this.dataCache.isStale(fileCacheEntry)) {
+        await this.cacheSSGPage(page, html, {
+          document: true,
+          createdAt: stat.mtimeMs
+        });
+        const fileCacheEntry = await this.getCachedSSGPage(page.urlPath);
+        if (fileCacheEntry && await this.dataCache.isStaleAsync(fileCacheEntry)) {
           this.regenerateSSGPage(page);
         }
         res.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -1894,6 +3191,7 @@ var _ServerRenderer = class _ServerRenderer {
     let pathname = "/";
     let params = {};
     let layouts = [];
+    let routeSlots = [];
     let searchParamsObject = {};
     let middlewareMap = /* @__PURE__ */ new Map();
     let middlewareContext = /* @__PURE__ */ new Map();
@@ -1926,7 +3224,7 @@ var _ServerRenderer = class _ServerRenderer {
       }
       this.applyDeploymentHeaders(req, res);
       if (process.env.NODE_ENV === "production") {
-        const ssgPage = this.shouldServeSSG(pathname);
+        const ssgPage = await this.shouldServeSSG(pathname);
         if (ssgPage) {
           const served = await this.serveSSGPage(req, res, ssgPage);
           if (served) {
@@ -1939,6 +3237,7 @@ var _ServerRenderer = class _ServerRenderer {
       const route = match.route;
       params = match.params;
       layouts = match.layouts;
+      routeSlots = match.slots ?? [];
       if (!route) {
         emitFarmEvent({ type: "route.notFound", pathname });
         await this.render404(req, res);
@@ -1955,7 +3254,9 @@ var _ServerRenderer = class _ServerRenderer {
       errorBoundaryEntry = this.routeManager.getMatchingError(pathname);
       middlewareMap = toMiddlewareMap(req.__FARM_MIDDLEWARE_DATA__);
       middlewareContext = toMiddlewareMap(req.__FARM_MIDDLEWARE_CONTEXT__);
-      pluginExposedContext = getRequestContextSnapshot(req, { exposedOnly: true });
+      pluginExposedContext = getRequestContextSnapshot(req, {
+        exposedOnly: true
+      });
       const currentRequest = createWebRequestFromFarmRequest(req);
       const routeContext = await this.resolveRouteContext({
         request: currentRequest,
@@ -2019,8 +3320,16 @@ var _ServerRenderer = class _ServerRenderer {
         revalidate: renderingConfig.revalidate
       } : void 0;
       if (renderingConfig.ppr && pprBypassReason) {
-        emitFarmEvent({ type: "ppr.shell.bypass", route: pathname, reason: pprBypassReason });
-        emitFarmEvent({ type: "cache.bypass", route: pathname, reason: pprBypassReason });
+        emitFarmEvent({
+          type: "ppr.shell.bypass",
+          route: pathname,
+          reason: pprBypassReason
+        });
+        emitFarmEvent({
+          type: "cache.bypass",
+          route: pathname,
+          reason: pprBypassReason
+        });
         if (pprBypassReason === "refresh") {
           pprRefreshRoute = pathname;
           emitFarmEvent({ type: "ppr.refresh.start", route: pathname });
@@ -2028,14 +3337,22 @@ var _ServerRenderer = class _ServerRenderer {
       }
       if (pprShellOptions) {
         const pprCacheKey = this.getPPRCacheKey(pathname, url.search);
-        const cachedPPRShell = this.getCachedPPRShell(pathname, url.search);
+        const cachedPPRShell = await this.getCachedPPRShell(pathname, url.search);
         if (cachedPPRShell) {
-          emitFarmEvent({ type: "ppr.shell.hit", route: pathname, key: pprCacheKey });
+          emitFarmEvent({
+            type: "ppr.shell.hit",
+            route: pathname,
+            key: pprCacheKey
+          });
           this.serveCachedPPRShell(res, cachedPPRShell.value, renderingConfig.revalidate);
           completeRender(res.statusCode || 200, pathname);
           return;
         }
-        emitFarmEvent({ type: "ppr.shell.miss", route: pathname, key: pprCacheKey });
+        emitFarmEvent({
+          type: "ppr.shell.miss",
+          route: pathname,
+          key: pprCacheKey
+        });
       }
       let LoadingFallbackComponent = null;
       if (loadingBoundaryEntry) {
@@ -2059,14 +3376,77 @@ var _ServerRenderer = class _ServerRenderer {
       );
       const moduleMetadata = routeManifestEntry || getClientModuleMetadata(route.modulePath, this.config.root);
       const isClientComponent = moduleMetadata.isClientComponent;
+      const renderedRouteSlots = await Promise.all(
+        routeSlots.map(async (slot) => {
+          const slotModule = await this.routeManager.loadRouteModule(slot.route.modulePath);
+          if (!slotModule.default) {
+            throw new Error(
+              `Route slot "${slot.name}" module ${slot.route.modulePath} does not export a default component`
+            );
+          }
+          const slotContext = await this.resolveRouteContext({
+            request: currentRequest,
+            rawRequest: req,
+            params: slot.params,
+            search: searchParamsObject,
+            path: pathname
+          });
+          const rawSlotProps = withFarmRouteContext(
+            {
+              params: slot.params,
+              searchParams: Promise.resolve(searchParamsObject),
+              path: pathname,
+              middleware: middlewareMap.size > 0 ? { data: middlewareMap } : void 0,
+              context: pluginExposedContext.size > 0 ? { data: pluginExposedContext } : void 0
+            },
+            slotContext
+          );
+          const slotProps = await parseRouteModuleProps(slotModule, {
+            props: rawSlotProps,
+            search: searchParamsObject,
+            routePath: slot.route.pattern
+          });
+          const metadata = getClientModuleMetadata(slot.route.modulePath, this.config.root);
+          return {
+            ...slot,
+            module: slotModule,
+            props: slotProps,
+            isClientComponent: metadata.isClientComponent,
+            shouldHydrate: metadata.shouldHydrate
+          };
+        })
+      );
       const shouldHydrate = moduleMetadata.shouldHydrate;
+      const hasHydratableRouteSlots = renderedRouteSlots.some(
+        (slot) => slot.isClientComponent || slot.shouldHydrate
+      );
       req.__FARM_PAGE_PATH__ = route.modulePath;
       req.__FARM_ROUTE__ = pathname;
       req.__FARM_IS_CLIENT_COMPONENT__ = isClientComponent;
       req.__FARM_SHOULD_HYDRATE__ = shouldHydrate;
+      req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ = hasHydratableRouteSlots;
       req.__FARM_LOADING_MODULE_PATH__ = loadingBoundaryEntry?.modulePath ? loadingBoundaryEntry.modulePath.substring(
         loadingBoundaryEntry.modulePath.indexOf("/src/app/")
       ) : null;
+      req.__FARM_ROUTE_SLOTS__ = renderedRouteSlots.map((slot) => ({
+        name: slot.name,
+        ownerPattern: slot.ownerPattern,
+        containerId: slot.containerId,
+        interception: slot.interception,
+        fallback: slot.fallback,
+        modulePath: slot.route.modulePath,
+        isClientComponent: slot.isClientComponent,
+        shouldHydrate: slot.shouldHydrate,
+        props: {
+          params: slot.props.params,
+          search: slot.props.search,
+          searchParams: slot.props.search,
+          ..."data" in slot.props ? { data: slot.props.data } : {},
+          ...slot.props.__farmCanonicalPath ? { __farmCanonicalPath: slot.props.__farmCanonicalPath } : {},
+          ...slot.props.__farmRoutePropsResolved ? { __farmRoutePropsResolved: true } : {},
+          path: pathname
+        }
+      }));
       req.__FARM_PROPS__ = {
         params: pageProps.params,
         search: pageProps.search,
@@ -2126,12 +3506,32 @@ var _ServerRenderer = class _ServerRenderer {
             let wrappedElement = pageElement;
             for (let i = layoutModules.length - 1; i >= 0; i--) {
               const layoutModule = layoutModules[i];
+              const layoutEntry = layouts[i];
               const LayoutComponent = layoutModule.default;
+              const slotProps = {};
+              for (const slot of renderedRouteSlots) {
+                if (slot.ownerPattern !== layoutEntry.pattern) continue;
+                let slotElement = React.createElement(
+                  slot.module.default,
+                  slot.props
+                );
+                slotElement = React.createElement(
+                  "div",
+                  {
+                    id: slot.containerId,
+                    "data-farm-route-slot": slot.name,
+                    "data-farm-slot-owner": slot.ownerPattern
+                  },
+                  slotElement
+                );
+                slotProps[slot.name] = slotElement;
+              }
               wrappedElement = React.createElement(
                 LayoutComponent,
                 {
                   children: wrappedElement,
-                  params
+                  params,
+                  ...slotProps
                 }
               );
             }
@@ -2168,7 +3568,10 @@ var _ServerRenderer = class _ServerRenderer {
                 routeManifest,
                 captureStaticShell: Boolean(pprShellOptions),
                 observabilityRoute: pathname,
-                onSuspenseHoleDetected: pprShellOptions ? () => emitFarmEvent({ type: "ppr.suspense.holeDetected", route: pathname }) : void 0,
+                onSuspenseHoleDetected: pprShellOptions ? () => emitFarmEvent({
+                  type: "ppr.suspense.holeDetected",
+                  route: pathname
+                }) : void 0,
                 onComplete: pprShellOptions && req.method !== "HEAD" ? (html) => this.cachePPRShell(pprShellOptions, html) : void 0
               }
             );
@@ -2184,6 +3587,15 @@ var _ServerRenderer = class _ServerRenderer {
         });
       });
     } catch (error) {
+      if (isWebResponse(error)) {
+        if (!res.headersSent && !res.writableEnded) {
+          await sendWebResponse(res, error);
+        } else if (!res.writableEnded) {
+          res.end();
+        }
+        completeRender(error.status, pathname);
+        return;
+      }
       if (isFarmRedirectError(error)) {
         const redirect = getFarmRedirectError(error);
         const snapshot = getFarmI18nClientSnapshot();
@@ -2216,7 +3628,11 @@ var _ServerRenderer = class _ServerRenderer {
       }
       emitFarmEvent({ type: "render.error", route: pathname, error });
       if (pprRefreshRoute) {
-        emitFarmEvent({ type: "ppr.refresh.error", route: pprRefreshRoute, error });
+        emitFarmEvent({
+          type: "ppr.refresh.error",
+          route: pprRefreshRoute,
+          error
+        });
       }
       logger.error(`Error rendering page: ${error}`);
       if (res.headersSent || res.writableEnded) {
@@ -2269,7 +3685,9 @@ var _ServerRenderer = class _ServerRenderer {
       if (typeof layoutModule.generateMetadata === "function") {
         metadata = mergeMetadata(
           metadata,
-          await layoutModule.generateMetadata({ params: options.pageProps.params })
+          await layoutModule.generateMetadata({
+            params: options.pageProps.params
+          })
         );
       }
     }
@@ -2478,7 +3896,7 @@ var _ServerRenderer = class _ServerRenderer {
     }
   }
   async renderWithSSR(element, req, res, clearMiddlewareData, options = {}) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const streamStartTime = Date.now();
       const observabilityRoute = options.observabilityRoute || req.__FARM_ROUTE__ || req.url || "/";
       const deploymentId = this.getDeploymentId();
@@ -2500,7 +3918,13 @@ var _ServerRenderer = class _ServerRenderer {
         clientEntry: "/@farm/client.js",
         routes: {},
         layouts: {},
-        sharedAssets: [{ tag: "link", attrs: { rel: "stylesheet", href: "/src/app/globals.css" } }]
+        slots: [],
+        sharedAssets: [
+          {
+            tag: "link",
+            attrs: { rel: "stylesheet", href: "/src/app/globals.css" }
+          }
+        ]
       };
       for (const routeEntry of manifest.routes) {
         clientManifest.routes[routeEntry.pattern] = {
@@ -2522,9 +3946,26 @@ var _ServerRenderer = class _ServerRenderer {
           assets: []
         };
       }
-      const deferredProps = prepareDeferredData(req.__FARM_PROPS__ || {});
+      for (const slotEntry of manifest.slots ?? []) {
+        clientManifest.slots.push({
+          ...slotEntry,
+          preloads: [slotEntry.modulePath],
+          assets: []
+        });
+      }
+      const routeSlotPayload = (req.__FARM_ROUTE_SLOTS__ || []).map(
+        (slot) => ({
+          ...slot,
+          modulePath: typeof slot.modulePath === "string" && slot.modulePath.startsWith(this.config.root) ? slot.modulePath.slice(this.config.root.length) : slot.modulePath
+        })
+      );
+      const deferredProps = prepareDeferredData({
+        page: req.__FARM_PROPS__ || {},
+        slots: routeSlotPayload
+      });
       const propsScript = `<script>
-window.__FARM_PROPS__ = ${serializeInlineValue(deferredProps.data)};
+window.__FARM_PROPS__ = ${serializeInlineValue(deferredProps.data.page)};
+window.__FARM_ROUTE_SLOTS__ = ${serializeInlineValue(deferredProps.data.slots)};
 window.__FARM_DEPLOYMENT_ID__ = ${serializeInlineValue(deploymentId)};
 window.__FARM_PATH__ = ${JSON.stringify(req.__FARM_ROUTE__ || req.url || "/")};
 window.__FARM_IS_CLIENT__ = ${JSON.stringify(isClientComponent)};
@@ -2537,7 +3978,7 @@ window.__FARM_MANIFEST__ = ${JSON.stringify(clientManifest)};
 window.__FARM_INTEGRATION_API_MANIFEST__ = ${JSON.stringify(getRegisteredIntegrationAPIManifest())};
 ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(getFarmI18nClientSnapshot())};` : ""}
 </script>`;
-      const hydrationClickQueueScript = isClientComponent || req.__FARM_SHOULD_HYDRATE__ === true ? createPreHydrationClickQueueScript() : "";
+      const hydrationClickQueueScript = isClientComponent || req.__FARM_SHOULD_HYDRATE__ === true || req.__FARM_HAS_HYDRATABLE_ROUTE_SLOTS__ === true ? createPreHydrationClickQueueScript() : "";
       const {
         title,
         tags: metaTags,
@@ -2545,6 +3986,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
       } = renderMetadataHead(req.__FARM_METADATA__);
       const i18nSnapshot = getFarmI18nClientSnapshot();
       const i18nAlternateTags = i18nSnapshot ? renderI18nAlternateLinks(req.__FARM_ROUTE__ || req.url || "/", i18nSnapshot) : "";
+      const fontHead = renderFarmFontDevHead(this.config.root || process.cwd());
       const streamRoot = React.createElement("div", { style: { display: "contents" } }, element);
       const { pipe, abort } = renderToPipeableStream(streamRoot, {
         onShellReady() {
@@ -2558,13 +4000,14 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
             console.log(`[FARM STREAM] onShellReady at ${shellReadyMs}ms`);
           }
           const shell = `<!DOCTYPE html>
-<html lang="${escapeHtmlAttribute(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}>
+<html lang="${escapeHtmlAttribute2(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}>
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="farm-deployment-id" content="${escapeHtmlAttribute(deploymentId)}">
+  <meta name="farm-deployment-id" content="${escapeHtmlAttribute2(deploymentId)}">
   ${hasFavicon ? "" : '<link rel="icon" href="data:,">'}
   <title>${title}</title>${metaTags}${i18nAlternateTags}
+  ${fontHead}
   <link rel="stylesheet" href="/src/app/globals.css" />
   <script type="module" src="/@vite/client"></script>
   ${propsScript}
@@ -2635,7 +4078,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                 route: observabilityRoute,
                 durationMs: Date.now() - streamStartTime
               });
-              resolve4();
+              resolve5();
             }
           });
           res.write(shell);
@@ -2646,9 +4089,13 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         },
         onShellError(error) {
           didError = true;
-          if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
+          if (!isWebResponse(error) && !isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
             logger.error(`SSR shell error: ${error}`);
-            emitFarmEvent({ type: "render.error", route: observabilityRoute, error });
+            emitFarmEvent({
+              type: "render.error",
+              route: observabilityRoute,
+              error
+            });
           }
           if (clearMiddlewareData) {
             clearMiddlewareData();
@@ -2657,9 +4104,13 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         },
         onError(error) {
           didError = true;
-          if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
+          if (!isWebResponse(error) && !isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
             logger.error(`SSR streaming error: ${error}`);
-            emitFarmEvent({ type: "render.error", route: observabilityRoute, error });
+            emitFarmEvent({
+              type: "render.error",
+              route: observabilityRoute,
+              error
+            });
           }
         }
       });
@@ -2669,11 +4120,11 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
     res.statusCode = 404;
     const pathname = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`).pathname;
     try {
-      const appDir = path4.join(this.config.root, this.config.srcDir, "app");
+      const appDir = path5.join(this.config.root, this.config.srcDir, "app");
       const notFoundExtensions = [".tsx", ".jsx", ".ts", ".js"];
       let notFoundPath = null;
       for (const ext of notFoundExtensions) {
-        const checkPath = path4.join(appDir, `not-found${ext}`);
+        const checkPath = path5.join(appDir, `not-found${ext}`);
         if (fs2.existsSync(checkPath)) {
           notFoundPath = checkPath;
           break;
@@ -2685,7 +4136,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         if (NotFoundComponent) {
           let LayoutComponent = null;
           for (const ext of notFoundExtensions) {
-            const layoutPath = path4.join(appDir, `layout${ext}`);
+            const layoutPath = path5.join(appDir, `layout${ext}`);
             if (fs2.existsSync(layoutPath)) {
               try {
                 const layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
@@ -2766,14 +4217,16 @@ window.__FARM_INTEGRATION_API_MANIFEST__ = ${JSON.stringify(getRegisteredIntegra
 ${i18nSnapshot ? `window.__FARM_I18N__ = ${serializeInlineValue(i18nSnapshot)};` : ""}
 </script>`;
     const alternateLinks = i18nSnapshot ? renderI18nAlternateLinks(requestPath, i18nSnapshot) : "";
+    const fontHead = renderFarmFontDevHead(this.config.root || process.cwd());
     return `<!DOCTYPE html>
-<html lang="${escapeHtmlAttribute(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}>
+<html lang="${escapeHtmlAttribute2(i18nSnapshot?.locale || "en")}"${i18nSnapshot ? ` dir="${i18nSnapshot.direction}"` : ""}>
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="farm-deployment-id" content="${escapeHtmlAttribute(this.getDeploymentId())}">
+  <meta name="farm-deployment-id" content="${escapeHtmlAttribute2(this.getDeploymentId())}">
   <link rel="icon" href="data:,">
   <title>Farm.js App</title>${alternateLinks}
+  ${fontHead}
   <link rel="stylesheet" href="/src/app/globals.css" />
   <script type="module" src="/@vite/client"></script>
   ${integrationManifestScript}
@@ -2808,7 +4261,7 @@ __name(_ServerRenderer, "ServerRenderer");
 var ServerRenderer = _ServerRenderer;
 
 // src/app.ts
-import path5 from "path";
+import path6 from "path";
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -2826,17 +4279,14 @@ var _FarmApp = class _FarmApp {
     _setDefaultFarmI18nRuntime(this.i18nRuntime);
     this.viteServer = viteServer;
     this.routeManager = new RouteManager(this.config, viteServer);
-    this.serverRenderer = new ServerRenderer(
-      this.config,
-      this.routeManager,
-      this.i18nRuntime
-    );
+    this.serverRenderer = new ServerRenderer(this.config, this.routeManager, this.i18nRuntime);
   }
   async initialize() {
     if (process.env.FARM_VERBOSE) {
       logger.info("Initializing Farm.js application...");
     }
     await initStorage(this.config.storage);
+    await configureFarmCache(this.config.cache);
     await this.i18nRuntime.initialize();
     await this.verifyAppStructure();
     await this.routeManager.discoverRoutes();
@@ -2868,6 +4318,8 @@ var _FarmApp = class _FarmApp {
       preset: config.preset ?? "node-server",
       deploy: config.deploy || {},
       storage: config.storage || {},
+      cache: config.cache || {},
+      auth: isResolvedAuthConfig(config.auth) ? config.auth : resolveFarmAuthConfig(config.auth),
       integrations: config.integrations || {},
       plugins: config.plugins || [],
       migrations: config.migrations || { commands: [] },
@@ -2919,10 +4371,10 @@ var _FarmApp = class _FarmApp {
       );
     }
     const rootLayoutPaths = appDirs.flatMap((appDir) => [
-      path5.join(appDir, "layout.tsx"),
-      path5.join(appDir, "layout.ts"),
-      path5.join(appDir, "layout.jsx"),
-      path5.join(appDir, "layout.js")
+      path6.join(appDir, "layout.tsx"),
+      path6.join(appDir, "layout.ts"),
+      path6.join(appDir, "layout.jsx"),
+      path6.join(appDir, "layout.js")
     ]);
     const hasRootLayout = await Promise.all(rootLayoutPaths.map((p) => fileExists(p))).then(
       (results) => results.some(Boolean)
@@ -2940,6 +4392,12 @@ function isResolvedI18nConfig(value) {
   return Boolean(value && typeof value === "object" && "enabled" in value);
 }
 __name(isResolvedI18nConfig, "isResolvedI18nConfig");
+function isResolvedAuthConfig(value) {
+  return Boolean(
+    value && typeof value === "object" && "enabled" in value && "emailAndPassword" in value && "database" in value
+  );
+}
+__name(isResolvedAuthConfig, "isResolvedAuthConfig");
 function createFarmApp(config, viteServer) {
   return new FarmApp(config, viteServer);
 }
@@ -3275,11 +4733,11 @@ __name(_HMRManager, "HMRManager");
 var HMRManager = _HMRManager;
 
 // src/type-artifacts.ts
-import { mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 
 // src/routing/generate-route-types.ts
-import * as path6 from "path";
+import * as path7 from "path";
 import * as fs3 from "fs";
 function routeSegmentsToTsTypeLiteral(segments) {
   if (segments.length === 0) return '"/"';
@@ -3321,25 +4779,30 @@ function createRoutePattern(route) {
 __name(createRoutePattern, "createRoutePattern");
 var DEFAULT_OUT_FILE = "farm-routes.d.ts";
 async function generateRouteTypes(options) {
-  const {
-    root,
-    srcDir = "src",
-    outFile = DEFAULT_OUT_FILE,
-    extraRoutes = [],
-    suppressLintOnLink = false
-  } = options;
+  const root = path7.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path7.isAbsolute(outFile) ? outFile : path7.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs3.mkdirSync(path7.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+__name(generateRouteTypes, "generateRouteTypes");
+async function createRouteTypeDeclarations(options, outPath) {
+  const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
-  const outPath = path6.join(root, srcDir, outFile);
   const patterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path6.join(source.root, source.srcDir, "app");
+    const appDir = path7.join(source.root, source.srcDir, "app");
     if (fs3.existsSync(appDir)) {
       const pageFiles = await glob.default("**/page.{ts,tsx,js,jsx,md,mdx}", {
         cwd: appDir,
         absolute: false
       });
       for (const file of pageFiles) {
+        if (parseRouteSlotFile(file)) continue;
         const route = parseRoutePath(file);
         if (route.type === "page") {
           const pattern = createRoutePattern(route);
@@ -3361,18 +4824,19 @@ async function generateRouteTypes(options) {
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
   const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
   const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
+  const routeTypesImportPath = `./${path7.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const augmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
 
 declare module "@farm.js/core" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
   // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
   const Link: typeof import("@farm.js/core/client").Link;
@@ -3381,8 +4845,8 @@ declare module "@farm.js/core" {
 // Internal declaration path used by @farm.js/core root type re-exports.
 declare module "@farm.js/core/dist/client.js" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
 `;
@@ -3394,19 +4858,17 @@ declare module "@farm.js/core/dist/client.js" {
 export type RoutePath = ${routePathType};
 export type RoutePattern = ${routePatternType};${augmentationBlock}
 `;
-  fs3.mkdirSync(path6.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
+  return content;
 }
-__name(generateRouteTypes, "generateRouteTypes");
+__name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
 
 // src/image-types.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import path7 from "path";
+import path8 from "path";
 var FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? path7.resolve(options.root, options.outFile) : path7.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  mkdirSync2(path7.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? path8.resolve(options.root, options.outFile) : path8.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  mkdirSync2(path8.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -3435,11 +4897,11 @@ __name(createFarmImageTypeDeclarations, "createFarmImageTypeDeclarations");
 
 // src/i18n/type-generator.ts
 import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join3, resolve } from "path";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? resolve(options.root, options.outFile) : join3(resolve(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? resolve2(options.root, options.outFile) : join3(resolve2(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
   mkdirSync3(dirname2(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
@@ -3489,7 +4951,7 @@ __name(argumentType, "argumentType");
 
 // src/type-artifacts.ts
 async function generateFarmTypeArtifacts(options) {
-  const root = resolve2(options.root);
+  const root = resolve3(options.root);
   const srcDir = options.srcDir || "src";
   const shouldGenerateRoutes = options.routes !== false;
   const shouldGenerateApi = options.api !== false;
@@ -3501,7 +4963,10 @@ async function generateFarmTypeArtifacts(options) {
   const result = {
     apiRoutes: []
   };
-  if (shouldGenerateRoutes) {
+  const unifiedTypesPath = join4(root, srcDir, "farm.d.ts");
+  const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
+  const unifiedSections = [];
+  if (shouldRefreshUnifiedTypes && !options.routeTypesOutFile) {
     const routeOptions = {
       root,
       srcDir,
@@ -3509,37 +4974,62 @@ async function generateFarmTypeArtifacts(options) {
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
     };
-    if (options.routeTypesOutFile) {
-      routeOptions.outFile = options.routeTypesOutFile;
-    }
-    result.routeTypesPath = await generateRouteTypes(routeOptions);
+    unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
+    result.routeTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateRoutes) {
+    result.routeTypesPath = await generateRouteTypes({
+      root,
+      srcDir,
+      outFile: options.routeTypesOutFile,
+      extraRoutes: options.extraRoutes || [],
+      suppressLintOnLink: options.suppressLintOnLink,
+      sourceRoots
+    });
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
-    const apiTypesPath = options.apiTypesOutFile ? resolve2(root, options.apiTypesOutFile) : join4(root, srcDir, "lib", "api.generated.ts");
+    const apiTypesPath = options.apiTypesOutFile ? resolve3(root, options.apiTypesOutFile) : join4(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
     mkdirSync4(dirname3(apiTypesPath), { recursive: true });
     writeFileIfChanged(apiTypesPath, content);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
-  if (shouldGenerateEnv) {
+  if (shouldRefreshUnifiedTypes && !options.envTypesOutFile) {
+    unifiedSections.push(
+      createEnvTypeDeclarations(
+        {
+          root,
+          srcDir,
+          configPath: options.configPath,
+          layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
+        },
+        unifiedTypesPath
+      )
+    );
+    result.envTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateEnv) {
     result.envTypesPath = await generateEnvTypes({
       root,
       srcDir,
       outFile: options.envTypesOutFile,
+      configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
     });
   }
-  if (shouldGenerateImages) {
+  if (shouldGenerateImages && options.imageTypesOutFile) {
     result.imageTypesPath = generateFarmImageTypes({
       root,
       srcDir,
       outFile: options.imageTypesOutFile
     });
   }
-  if (shouldGenerateI18n && options.i18nConfig) {
+  if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
+    const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+    unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
+    result.i18nTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateI18n && options.i18nConfig) {
     result.i18nTypesPath = await generateFarmI18nTypes({
       root,
       srcDir,
@@ -3547,17 +5037,50 @@ async function generateFarmTypeArtifacts(options) {
       outFile: options.i18nTypesOutFile
     });
   }
+  if (shouldRefreshUnifiedTypes) {
+    mkdirSync4(dirname3(unifiedTypesPath), { recursive: true });
+    writeFileIfChanged(
+      unifiedTypesPath,
+      `/**
+ * Generated by Farm.js. Do not edit.
+ * Contains project-specific route, environment, and internationalization types.
+ */
+
+import "@farm.js/core/image";
+
+${unifiedSections.join("\n")}`
+    );
+    result.typesPath = unifiedTypesPath;
+    removeLegacyTypeArtifacts(root, srcDir);
+  }
   return result;
 }
 __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+var LEGACY_TYPE_ARTIFACTS = [
+  ["farm-routes.d.ts", "Auto-generated route types"],
+  ["farm-env.d.ts", "Auto-generated env types"],
+  ["farm-images.d.ts", "Generated by Farm.js"],
+  ["farm-i18n.d.ts", "Generated by Farm.js"]
+];
+function removeLegacyTypeArtifacts(root, srcDir) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = join4(root, srcDir, fileName);
+    if (!existsSync4(filePath)) continue;
+    const source = readFileSync2(filePath, "utf8");
+    if (source.includes(marker)) {
+      unlinkSync(filePath);
+    }
+  }
+}
+__name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
 
 // src/vite.ts
 import * as fs4 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // src/image-vite.ts
-import { readFile as readFile3 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile4 } from "fs/promises";
+import path9 from "path";
 import { imageSize as imageSize2 } from "image-size";
 var FARM_IMAGE_ID_PREFIX = "\0farm:image:";
 var STATIC_IMAGE_RE = /\.(?:avif|gif|jpe?g|png|webp)$/i;
@@ -3591,7 +5114,7 @@ function farmImageImportsPlugin() {
 }
 __name(farmImageImportsPlugin, "farmImageImportsPlugin");
 async function createStaticImageModule(filePath, sourceDeclaration) {
-  const bytes = await readFile3(filePath);
+  const bytes = await readFile4(filePath);
   const dimensions = imageSize2(bytes);
   if (!dimensions.width || !dimensions.height) {
     throw new Error(`Could not determine image dimensions for ${filePath}`);
@@ -3629,7 +5152,7 @@ var ALL_TYPE_ARTIFACTS = {
   routes: true,
   api: true,
   env: true,
-  images: true,
+  images: false,
   i18n: true
 };
 var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
@@ -3666,7 +5189,7 @@ function loadFarmWorkflowsDevRuntime() {
 }
 __name(loadFarmWorkflowsDevRuntime, "loadFarmWorkflowsDevRuntime");
 function loadFarmDevtoolsSnapshotRuntime() {
-  return import("./devtools-AE4RVXCM.mjs");
+  return import("./devtools-A22KUJZT.mjs");
 }
 __name(loadFarmDevtoolsSnapshotRuntime, "loadFarmDevtoolsSnapshotRuntime");
 function loadFarmDevtoolsUIRuntime() {
@@ -3674,7 +5197,7 @@ function loadFarmDevtoolsUIRuntime() {
 }
 __name(loadFarmDevtoolsUIRuntime, "loadFarmDevtoolsUIRuntime");
 function loadFarmDevtoolsClientRuntime() {
-  return import("./devtools-client-6WPY2AQU.mjs");
+  return import("./devtools-client-3XRTBND5.mjs");
 }
 __name(loadFarmDevtoolsClientRuntime, "loadFarmDevtoolsClientRuntime");
 function farmI18nClientBridgePlugin() {
@@ -3829,7 +5352,7 @@ function isResolvedEnvScope(value) {
 }
 __name(isResolvedEnvScope, "isResolvedEnvScope");
 function isPotentialProgrammaticRouteSourceFile(normalizedFile, srcDirSlug) {
-  return normalizedFile.startsWith(`${srcDirSlug}/`) && /\.(ts|tsx|js|jsx)$/.test(normalizedFile) && !/\.d\.ts$/.test(normalizedFile) && !normalizedFile.endsWith("/farm-routes.d.ts") && !normalizedFile.endsWith("/farm-env.d.ts") && !normalizedFile.endsWith("/lib/api.generated.ts");
+  return normalizedFile.startsWith(`${srcDirSlug}/`) && /\.(ts|tsx|js|jsx)$/.test(normalizedFile) && !normalizedFile.endsWith(".d.ts") && !normalizedFile.endsWith("/farm-routes.d.ts") && !normalizedFile.endsWith("/farm-env.d.ts") && !normalizedFile.endsWith("/lib/api.generated.ts");
 }
 __name(isPotentialProgrammaticRouteSourceFile, "isPotentialProgrammaticRouteSourceFile");
 function fileContainsProgrammaticPageRoute(file) {
@@ -3845,7 +5368,7 @@ function fileContainsProgrammaticPageRoute(file) {
 __name(fileContainsProgrammaticPageRoute, "fileContainsProgrammaticPageRoute");
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path9.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path10.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -3865,7 +5388,7 @@ function rewriteEarlySsrRelativeImports(options) {
     const suffixIndex = source.value.search(/[?#]/);
     const sourcePath = suffixIndex === -1 ? source.value : source.value.slice(0, suffixIndex);
     const suffix = suffixIndex === -1 ? "" : source.value.slice(suffixIndex);
-    const resolvedPath = path9.resolve(path9.dirname(cleanId), sourcePath);
+    const resolvedPath = path10.resolve(path10.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -3909,6 +5432,11 @@ function isFarmConfigFile(file, root) {
 __name(isFarmConfigFile, "isFarmConfigFile");
 function farmPlugin(options = {}, initialPluginManager) {
   const imageImports = farmImageImportsPlugin();
+  const fontImports = farmFontImportsPlugin({
+    root: options.root,
+    basePath: options.basePath,
+    publicDir: options.publicDir
+  });
   let farmApp;
   let server;
   let hmrManager;
@@ -3945,15 +5473,21 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path9.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path10.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
       };
     },
     async configResolved(config) {
+      if (typeof fontImports.configResolved === "function") {
+        await fontImports.configResolved.call(this, config);
+      }
     },
     async configureServer(viteServer) {
+      if (typeof fontImports.configureServer === "function") {
+        await fontImports.configureServer.call(this, viteServer);
+      }
       server = viteServer;
       const pm = initialPluginManager;
       const emitPluginError = /* @__PURE__ */ __name(async (phase, error, meta) => {
@@ -3970,9 +5504,9 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path9.join(server.config.root, "src/app/globals.css");
+      const globalsCSSPath = path10.join(server.config.root, "src/app/globals.css");
       if (!fs4.existsSync(globalsCSSPath)) {
-        const appDir = path9.join(server.config.root, "src/app");
+        const appDir = path10.join(server.config.root, "src/app");
         if (!fs4.existsSync(appDir)) {
           fs4.mkdirSync(appDir, { recursive: true });
         }
@@ -3994,10 +5528,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path9.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path10.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path9.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path10.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -4007,7 +5541,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path9.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path10.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -4047,7 +5581,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path9.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path10.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -4072,7 +5606,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "isProgrammaticRouteSourceFile");
       const isAppRuntimeFile = /* @__PURE__ */ __name((file) => {
         const normalized = file.replace(/\\/g, "/");
-        return appDirSlugs.some((appDir) => normalized.startsWith(`${appDir}/`)) && /\/(?:page|layout|loading|error|middleware|route)\.(?:ts|tsx|js|jsx|md|mdx)$|\/(?:opengraph-image|twitter-image)(?:\.(?:ts|tsx|js|jsx|png|jpg|jpeg|gif|webp)|\.alt\.txt)$/.test(
+        return appDirSlugs.some((appDir) => normalized.startsWith(`${appDir}/`)) && /\/(?:page|default|layout|loading|error|middleware|route)\.(?:ts|tsx|js|jsx|md|mdx)$|\/(?:opengraph-image|twitter-image)(?:\.(?:ts|tsx|js|jsx|png|jpg|jpeg|gif|webp)|\.alt\.txt)$/.test(
           normalized
         );
       }, "isAppRuntimeFile");
@@ -4165,7 +5699,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs4.existsSync(path9.isAbsolute(dir) ? dir : path9.join(farmConfig.root, dir))
+        (dir) => fs4.existsSync(path10.isAbsolute(dir) ? dir : path10.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler, discoverFarmWorkflows } = await loadFarmWorkflowsDevRuntime();
@@ -4243,14 +5777,14 @@ function farmPlugin(options = {}, initialPluginManager) {
         farmDocsDevRuntime ? [
           [
             "/assets/Geist-Variable-CrgPqtmy.woff2",
-            path9.join(
+            path10.join(
               farmConfig.root,
               "node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2"
             )
           ],
           [
             "/assets/GeistMono-Variable-BNLlm6Cd.woff2",
-            path9.join(
+            path10.join(
               farmConfig.root,
               "node_modules/geist/dist/fonts/geist-mono/GeistMono-Variable.woff2"
             )
@@ -4414,12 +5948,13 @@ function farmPlugin(options = {}, initialPluginManager) {
             config: farmApp.getConfig().mdx,
             resolveSource: /* @__PURE__ */ __name(async (pathname2) => {
               const match = farmApp.getRouteManager().matchRoute(pathname2);
-              if (!match.route || !isFarmMarkdownPageFile(match.route.modulePath)) {
+              const sourcePath = match.route?.markdownSourcePath || (match.route && isFarmMarkdownPageFile(match.route.modulePath) ? match.route.modulePath : null);
+              if (!sourcePath) {
                 return null;
               }
               return {
-                source: await fs4.promises.readFile(match.route.modulePath, "utf8"),
-                filePath: match.route.modulePath
+                source: await fs4.promises.readFile(sourcePath, "utf8"),
+                filePath: sourcePath
               };
             }, "resolveSource")
           });
@@ -4440,16 +5975,37 @@ function farmPlugin(options = {}, initialPluginManager) {
             await sendWebResponse(res, markdownResponse);
             return;
           }
+          const markdownPageTarget = resolveMarkdownMirrorTarget(
+            farmApp.getConfig().md,
+            requestPathname,
+            {
+              accept: "text/markdown"
+            }
+          );
+          if (markdownPageTarget && farmApp.getRouteManager().matchRoute(markdownPageTarget.pathname).route) {
+            const vary = res.getHeader("Vary");
+            const varyValues = String(vary || "").split(",").map((value) => value.trim()).filter(Boolean);
+            if (!varyValues.some((value) => value.toLowerCase() === "accept")) {
+              res.setHeader("Vary", [...varyValues, "Accept"].join(", "));
+            }
+            const alternatePath = markdownPageTarget.pathname === "/" ? "/index.md" : `${markdownPageTarget.pathname}.md`;
+            const alternateLink = `<${alternatePath}>; rel="alternate"; type="text/markdown"`;
+            const currentLink = res.getHeader("Link");
+            res.setHeader(
+              "Link",
+              currentLink ? `${String(currentLink)}, ${alternateLink}` : alternateLink
+            );
+          }
           if (workflowHandler && (requestPathname === workflowConfig.route || requestPathname.startsWith(`${workflowConfig.route}/`))) {
             let workflowBody;
             if (requestMethod !== "GET" && requestMethod !== "HEAD") {
-              workflowBody = await new Promise((resolve4) => {
+              workflowBody = await new Promise((resolve5) => {
                 let data = "";
                 req.on("data", (chunk) => {
                   data += chunk;
                 });
                 req.on("end", () => {
-                  resolve4(data);
+                  resolve5(data);
                 });
               });
             }
@@ -4492,13 +6048,13 @@ function farmPlugin(options = {}, initialPluginManager) {
               }
               let body;
               if (req.method !== "GET" && req.method !== "HEAD") {
-                body = await new Promise((resolve4) => {
+                body = await new Promise((resolve5) => {
                   let data = "";
                   req.on("data", (chunk) => {
                     data += chunk;
                   });
                   req.on("end", () => {
-                    resolve4(data);
+                    resolve5(data);
                   });
                 });
               }
@@ -4604,13 +6160,13 @@ function farmPlugin(options = {}, initialPluginManager) {
                 }
                 let body;
                 if (req.method !== "GET" && req.method !== "HEAD") {
-                  body = await new Promise((resolve4) => {
+                  body = await new Promise((resolve5) => {
                     let data = "";
                     req.on("data", (chunk) => {
                       data += chunk;
                     });
                     req.on("end", () => {
-                      resolve4(data);
+                      resolve5(data);
                     });
                   });
                 }
@@ -4667,13 +6223,13 @@ function farmPlugin(options = {}, initialPluginManager) {
                 }
                 let body;
                 if (req.method !== "GET" && req.method !== "HEAD") {
-                  body = await new Promise((resolve4) => {
+                  body = await new Promise((resolve5) => {
                     let data = "";
                     req.on("data", (chunk) => {
                       data += chunk;
                     });
                     req.on("end", () => {
-                      resolve4(data);
+                      resolve5(data);
                     });
                   });
                 }
@@ -4763,7 +6319,10 @@ function farmPlugin(options = {}, initialPluginManager) {
                     method: req.method || "GET"
                   });
                 }
-                const match = routeManager3.matchRoute(targetPath);
+                const interceptFromHeader = request.headers.get("x-farm-intercept-from") || void 0;
+                const match = routeManager3.matchRoute(targetRequestUrl.pathname, {
+                  interceptFrom: interceptFromHeader
+                });
                 if (pm) {
                   await pm.runHookParallel("afterRouteMatch", {
                     pathname: targetPath,
@@ -4779,7 +6338,7 @@ function farmPlugin(options = {}, initialPluginManager) {
                   res.end(JSON.stringify({ error: "Route not found" }));
                   return;
                 }
-                const { route, params, layouts } = match;
+                const { route, params, layouts, slots } = match;
                 if (!route) {
                   res.statusCode = 404;
                   res.setHeader("Content-Type", "application/json");
@@ -4834,6 +6393,54 @@ function farmPlugin(options = {}, initialPluginManager) {
                   search: searchParams,
                   routePath: route.pattern
                 });
+                const routeSlots = await Promise.all(
+                  slots.map(async (slot) => {
+                    const slotModule = await routeManager3.loadRouteModule(slot.route.modulePath);
+                    const slotMetadata = getClientModuleMetadata(
+                      slot.route.modulePath,
+                      server.config.root
+                    );
+                    const slotContext = await resolveFarmRouteContext(farmApp.getConfig(), {
+                      request,
+                      params: slot.params,
+                      search: searchParams,
+                      path: targetUrl.pathname
+                    });
+                    const slotProps = await parseRouteModuleProps2(slotModule, {
+                      props: withFarmRouteContext(
+                        {
+                          params: slot.params,
+                          searchParams: Promise.resolve(searchParams),
+                          path: targetUrl.pathname
+                        },
+                        slotContext
+                      ),
+                      search: searchParams,
+                      routePath: slot.route.pattern
+                    });
+                    return {
+                      name: slot.name,
+                      ownerPattern: slot.ownerPattern,
+                      containerId: slot.containerId,
+                      interception: slot.interception,
+                      fallback: slot.fallback,
+                      modulePath: slot.route.modulePath,
+                      isClientComponent: slotMetadata.isClientComponent,
+                      shouldHydrate: slotMetadata.shouldHydrate,
+                      props: {
+                        params: slotProps.params,
+                        search: slotProps.search,
+                        searchParams: slotProps.search,
+                        ..."data" in slotProps ? { data: slotProps.data } : {},
+                        ...slotProps.__farmCanonicalPath ? {
+                          __farmCanonicalPath: slotProps.__farmCanonicalPath
+                        } : {},
+                        ...slotProps.__farmRoutePropsResolved ? { __farmRoutePropsResolved: true } : {},
+                        path: targetUrl.pathname
+                      }
+                    };
+                  })
+                );
                 const projectRoot = server.config.root;
                 const toUrlPath = /* @__PURE__ */ __name((absolutePath) => {
                   if (absolutePath.startsWith(projectRoot)) {
@@ -4854,13 +6461,21 @@ function farmPlugin(options = {}, initialPluginManager) {
                   },
                   canonicalPath: routeProps.__farmCanonicalPath,
                   modulePath: toUrlPath(route.modulePath),
-                  isClientComponent,
-                  shouldHydrate,
+                  isClientComponent: routeSlots.length > 0 ? false : isClientComponent,
+                  shouldHydrate: shouldHydrate || routeSlots.some((slot) => slot.isClientComponent || slot.shouldHydrate),
                   metadata: {
                     title: mergedMetadata.title,
                     description: mergedMetadata.description
                   },
                   layoutModules: layouts.map((l) => toUrlPath(l.modulePath)),
+                  routeSlots: routeSlots.map((slot) => ({
+                    ...slot,
+                    modulePath: toUrlPath(slot.modulePath)
+                  })),
+                  interception: routeSlots.some((slot) => slot.interception) ? {
+                    from: interceptFromHeader,
+                    slots: routeSlots.filter((slot) => slot.interception).map((slot) => slot.name)
+                  } : void 0,
                   i18n: getFarmI18nClientSnapshot()
                 };
                 await sendWebResponse(
@@ -5132,6 +6747,10 @@ function farmPlugin(options = {}, initialPluginManager) {
       );
     },
     async resolveId(id, importer, resolveOptions) {
+      if (typeof fontImports.resolveId === "function") {
+        const fontId = await fontImports.resolveId.call(this, id, importer, resolveOptions);
+        if (fontId) return fontId;
+      }
       if (typeof imageImports.resolveId === "function") {
         const imageId = await imageImports.resolveId.call(this, id, importer, resolveOptions);
         if (imageId) return imageId;
@@ -5150,6 +6769,10 @@ function farmPlugin(options = {}, initialPluginManager) {
       }
     },
     async load(id) {
+      if (typeof fontImports.load === "function") {
+        const fontModule = await fontImports.load.call(this, id);
+        if (fontModule) return fontModule;
+      }
       if (typeof imageImports.load === "function") {
         const imageModule = await imageImports.load.call(this, id);
         if (imageModule) return imageModule;
@@ -5196,6 +6819,7 @@ function farmPlugin(options = {}, initialPluginManager) {
 export const getManifest = () => ({
   routes: {},
   layouts: {},
+  slots: [],
   clientEntry: "/@farm/client.js",
   sharedAssets: []
 });
@@ -5206,6 +6830,7 @@ export const getManifest = () => ({
           clientEntry: "/@farm/client.js",
           routes: {},
           layouts: {},
+          slots: [],
           sharedAssets: [
             {
               tag: "link",
@@ -5235,6 +6860,13 @@ export const getManifest = () => ({
             assets: []
           };
         }
+        for (const slot of manifest.slots) {
+          fullManifest.slots.push({
+            ...slot,
+            preloads: [slot.modulePath],
+            assets: []
+          });
+        }
         return `
 // Auto-generated manifest for SPA navigation (TanStack Start pattern)
 // This manifest is inlined in the server bundle - no file on disk
@@ -5251,6 +6883,19 @@ export const manifest = getManifest();
       }
       let transformedCode = code;
       let transformed = false;
+      if (typeof fontImports.transform === "function") {
+        const fontResult = await fontImports.transform.call(
+          this,
+          transformedCode,
+          id,
+          transformOptions
+        );
+        const fontCode = typeof fontResult === "string" ? fontResult : fontResult?.code;
+        if (fontCode) {
+          transformedCode = fontCode;
+          transformed = true;
+        }
+      }
       if (transformOptions?.ssr && server) {
         const rewrittenImports = rewriteEarlySsrRelativeImports({
           code: transformedCode,
@@ -5305,7 +6950,10 @@ if (import.meta.hot) {
       }
       return transformed ? { code: transformedCode, map: null } : null;
     },
-    generateBundle(options2, bundle) {
+    async generateBundle(options2, bundle) {
+      if (typeof fontImports.generateBundle === "function") {
+        await fontImports.generateBundle.call(this, options2, bundle, false);
+      }
       const clientManifest = generateClientManifest(bundle);
       this.emitFile({
         type: "asset",
@@ -5325,8 +6973,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path9.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path9.join(outDir, "client");
+        const outDir = path10.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path10.join(outDir, "client");
         for (const page of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page.urlPath, "http://farm.static"));
@@ -5378,8 +7026,8 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page.urlPath === "/" ? path9.join(clientDir, "index.html") : path9.join(clientDir, page.urlPath + ".html");
-              fs4.mkdirSync(path9.dirname(outputPath), { recursive: true });
+              const outputPath = page.urlPath === "/" ? path10.join(clientDir, "index.html") : path10.join(clientDir, page.urlPath + ".html");
+              fs4.mkdirSync(path10.dirname(outputPath), { recursive: true });
               fs4.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page.revalidate ? ` (revalidate: ${page.revalidate}s)` : "";
               logger.success(`  \u2713 ${page.urlPath}${revalidateInfo}`);
@@ -5388,7 +7036,7 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path9.join(outDir, "__ssg_manifest.json");
+        const manifestPath = path10.join(outDir, "__ssg_manifest.json");
         fs4.writeFileSync(
           manifestPath,
           JSON.stringify(
@@ -5424,9 +7072,9 @@ if (import.meta.hot) {
       }
       const currentFarmConfig = farmApp?.getConfig();
       const normalizedFile = file.replace(/\\/g, "/");
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path9.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path10.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path9.basename(file)}`);
+        logUpdate("PAGE", `updated ${path10.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -5877,7 +7525,7 @@ window.__FARM_WRAP_PROVIDERS__ = wrapWithIntegrationProviders;
 
 // Get manifest from window (inlined by server in HTML)
 // Fallback to empty manifest if not available yet
-const getManifest = () => window.__FARM_MANIFEST__ || { routes: {}, layouts: {}, clientEntry: '', sharedAssets: [] };
+const getManifest = () => window.__FARM_MANIFEST__ || { routes: {}, layouts: {}, slots: [], clientEntry: '', sharedAssets: [] };
 
 // ====== CLIENT-SIDE ROUTE MATCHING ======
 // Matches URL to route using manifest (no server request!)
@@ -6216,6 +7864,9 @@ let LayoutComponent = null;
 
 // Track if we've taken over rendering from SSR
 let hasClientTakenOver = false;
+const routeSlotRoots = new Map();
+const routeSlotDefinitions = new Map();
+let activeRouteInterception = null;
 
 function normalizeServerProps(rawProps) {
   const props = rawProps && typeof rawProps === 'object' ? { ...rawProps } : {};
@@ -6228,6 +7879,123 @@ function normalizeServerProps(rawProps) {
   return props;
 }
 
+function getRouteSlotKey(slot) {
+  return slot.ownerPattern + ':' + slot.name;
+}
+
+async function renderRouteSlot(slot, mode = 'render') {
+  const container = document.getElementById(slot.containerId);
+  if (!container || !slot.modulePath) return false;
+  if (mode === 'intercept' && !slot.isClientComponent && !slot.shouldHydrate) {
+    return false;
+  }
+
+  let slotModule = pageModuleCache.get(slot.modulePath);
+  if (!slotModule) {
+    slotModule = await import(/* @vite-ignore */ slot.modulePath);
+    pageModuleCache.set(slot.modulePath, slotModule);
+  }
+  const SlotComponent = slotModule?.default;
+  if (!SlotComponent) return false;
+
+  const props = reviveDeferredData(
+    normalizeServerProps(slot.props || {}),
+    window.__FARM_DEFERRED_DATA__ || {},
+  );
+  const element = wrapWithIntegrationProviders(
+    React.createElement(SlotComponent, props),
+  );
+  const key = getRouteSlotKey(slot);
+  const existingRoot = routeSlotRoots.get(key);
+
+  if (mode === 'hydrate') {
+    if (existingRoot) return true;
+    const root = hydrateRoot(container, element);
+    routeSlotRoots.set(key, root);
+  } else {
+    if (existingRoot) {
+      try { existingRoot.unmount(); } catch (error) {}
+    }
+    const root = createRoot(container);
+    root.render(element);
+    routeSlotRoots.set(key, root);
+  }
+
+  routeSlotDefinitions.set(key, slot);
+  return true;
+}
+
+async function hydrateInitialRouteSlots() {
+  const slots = Array.isArray(window.__FARM_ROUTE_SLOTS__)
+    ? window.__FARM_ROUTE_SLOTS__
+    : [];
+  let hydrated = false;
+
+  for (const slot of slots) {
+    routeSlotDefinitions.set(getRouteSlotKey(slot), slot);
+    if (!slot.isClientComponent && !slot.shouldHydrate) continue;
+    try {
+      hydrated = (await renderRouteSlot(slot, 'hydrate')) || hydrated;
+    } catch (error) {
+      console.warn('[Farm.js] Could not hydrate route slot:', slot.name, error);
+    }
+  }
+
+  return hydrated;
+}
+
+async function renderRouteInterception(pageData) {
+  const slots = Array.isArray(pageData.routeSlots)
+    ? pageData.routeSlots.filter((slot) => slot.interception)
+    : [];
+  if (!pageData.interception || slots.length === 0) return false;
+
+  const previous = new Map();
+  for (const slot of slots) {
+    const key = getRouteSlotKey(slot);
+    previous.set(key, routeSlotDefinitions.get(key) || null);
+    if (!(await renderRouteSlot(slot, 'intercept'))) {
+      return false;
+    }
+  }
+
+  activeRouteInterception = {
+    from: pageData.interception.from,
+    slots,
+    previous,
+  };
+  return true;
+}
+
+async function clearRouteInterception(destination) {
+  if (!activeRouteInterception) return false;
+  const active = activeRouteInterception;
+  activeRouteInterception = null;
+
+  for (const slot of active.slots) {
+    const key = getRouteSlotKey(slot);
+    const root = routeSlotRoots.get(key);
+    if (root) {
+      try { root.unmount(); } catch (error) {}
+      routeSlotRoots.delete(key);
+    }
+
+    const previous = active.previous.get(key);
+    if (previous && (previous.isClientComponent || previous.shouldHydrate)) {
+      await renderRouteSlot(previous, 'render');
+    } else {
+      const container = document.getElementById(slot.containerId);
+      if (container) container.replaceChildren();
+      if (previous) routeSlotDefinitions.set(key, previous);
+      else routeSlotDefinitions.delete(key);
+    }
+  }
+
+  if (!active.from) return false;
+  const background = new URL(active.from, window.location.origin);
+  return destination === background.pathname + background.search;
+}
+
 function applyCanonicalPathFromProps(props) {
   const canonicalPath = props && typeof props.__farmCanonicalPath === 'string'
     ? props.__farmCanonicalPath
@@ -6349,6 +8117,7 @@ async function buildRouteComponentProps(pageModule, params, searchParams, path,
   const parsedSearch = parseClientRouteSchema(schemas?.search, searchParams, 'search');
 
   return {
+    ...(existingProps || {}),
     params: parsedParams,
     search: parsedSearch,
     searchParams: schemas ? Promise.resolve(parsedSearch) : parsedSearch,
@@ -6462,6 +8231,17 @@ async function tryHydrateImportedPage(
 async function renderPage(pageData) {
   const container = document.getElementById('root');
   if (!container) return;
+  const destination = window.location.pathname + window.location.search;
+
+  if (pageData.interception) {
+    if (await renderRouteInterception(pageData)) return;
+    window.location.assign(destination);
+    return;
+  }
+
+  if (await clearRouteInterception(destination)) {
+    return;
+  }
 
   const route = {
     modulePath: pageData.modulePath,
@@ -6690,7 +8470,9 @@ async function hydrate() {
       window.__FARM_SHOULD_HYDRATE__ === true ||
       isClientComponent ||
       await moduleLooksClient(modulePath);
+    const hydratedSlots = await hydrateInitialRouteSlots();
     if (!shouldHydrate) {
+      if (hydratedSlots) replayPreHydrationClicks();
       console.log('[Farm.js] Server component - SPA router ready')
       return
     }
@@ -6852,7 +8634,7 @@ function generateClientManifest(bundle) {
 __name(generateClientManifest, "generateClientManifest");
 async function defineConfig(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path9.resolve(config.root || process.cwd());
+  const appRoot = path10.resolve(config.root || process.cwd());
   if (config.extends?.length) {
     const { config: layeredConfig } = await import("./layers-VWVDTPUZ.mjs").then(
       ({ resolveFarmLayers }) => resolveFarmLayers(config, {
@@ -6955,7 +8737,7 @@ async function defineConfig(config = {}) {
           const isExposed = hostConfig === true || hostConfig === "0.0.0.0";
           console.log("");
           console.log(
-            `  ${pc.bold(pc.green("Farm.js"))} ${pc.dim("v1.0.0")} ${pc.dim(`ready in ${elapsed}ms`)}`
+            `  ${pc.bold(pc.green("Farm.js"))} ${pc.dim(`v${FARM_VERSION}`)} ${pc.dim(`ready in ${elapsed}ms`)}`
           );
           console.log("");
           console.log(
@@ -7038,7 +8820,7 @@ async function defineConfig(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path9.resolve(appRoot, "src"),
+        "@": path10.resolve(appRoot, "src"),
         // Nitro internals that should not be resolved in browser
         "supports-color": "data:text/javascript,export default false; export const supportsColor = false; export const stdout = false; export const stderr = false;",
         "@poppinss/dumper": "data:text/javascript,export default {};",
@@ -7070,6 +8852,8 @@ export {
   matchSSGPage,
   getClientModuleMetadata,
   RouteManager,
+  farmFontImportsPlugin,
+  mergeFarmFontCss,
   ServerRenderer,
   FarmApp,
   createFarmApp,
@@ -7085,4 +8869,4 @@ export {
   farmPlugin,
   defineConfig
 };
-//# sourceMappingURL=chunk-CHFHNEMO.mjs.map
+//# sourceMappingURL=chunk-77BOAQHI.mjs.map