@farm.js/core 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/internal/build-runtime.cjs

@@ -4225,7 +4225,8 @@ var init_route_rules = __esm({
 // src/cache-invalidation.ts
 function getFarmCacheInvalidationState() {
   return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set()
+    listeners: /* @__PURE__ */ new Set(),
+    taskListeners: /* @__PURE__ */ new Set()
   });
 }
 function encodeFarmCacheInvalidations(keys) {
@@ -4251,6 +4252,11 @@ function subscribeFarmCacheInvalidation(listener) {
   state.listeners.add(listener);
   return () => state.listeners.delete(listener);
 }
+function subscribeFarmCacheTask(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.taskListeners.add(listener);
+  return () => state.taskListeners.delete(listener);
+}
 var FARM_CACHE_INVALIDATION_HEADER, FARM_CACHE_INVALIDATION_STATE, globalState;
 var init_cache_invalidation = __esm({
   "src/cache-invalidation.ts"() {
@@ -4262,6 +4268,7 @@ var init_cache_invalidation = __esm({
     __name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
     __name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
     __name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+    __name(subscribeFarmCacheTask, "subscribeFarmCacheTask");
   }
 });
 
@@ -4365,6 +4372,9 @@ var init_server_action_security = __esm({
     subscribeFarmCacheInvalidation((key) => {
       getServerActionExecutionContext()?.invalidations.add(key);
     });
+    subscribeFarmCacheTask((task) => {
+      getServerActionExecutionContext()?.cacheTasks.add(task);
+    });
     __name(getServerActionStorage, "getServerActionStorage");
     __name(parseBodySizeLimit, "parseBodySizeLimit");
     __name(normalizeAllowedOriginPattern, "normalizeAllowedOriginPattern");
@@ -5522,6 +5532,7 @@ async function resolveConfig(userConfig, mode) {
     observability: userConfig.observability ?? false,
     devtools: resolveFarmDevtoolsConfig(userConfig.devtools, mode),
     storage: userConfig.storage || {},
+    cache: userConfig.cache || {},
     suppressLintOnLink: userConfig.suppressLintOnLink ?? false,
     experimental: {
       serverComponents: false,
@@ -6316,6 +6327,9 @@ var init_bridge = __esm({
 function getFarmDataCache() {
   return sharedFarmDataCache;
 }
+function configureFarmCache(config) {
+  sharedFarmDataCache.configure(config);
+}
 function createPathCacheTag(routePath) {
   return `path:${normalizeRevalidatePath(routePath)}`;
 }
@@ -6369,6 +6383,46 @@ function normalizeCacheTag(tag) {
   }
   return normalized;
 }
+function normalizeCacheNamespace(namespace) {
+  if (typeof namespace !== "string") {
+    throw new TypeError("Cache namespace must be a string.");
+  }
+  const normalized = namespace.trim().replace(/:+$/g, "");
+  if (!normalized) {
+    throw new Error("Cache namespace cannot be empty.");
+  }
+  return normalized;
+}
+function normalizeAdapterVersion(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function normalizePositiveDuration(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive number of milliseconds.`);
+  }
+  return Math.floor(value);
+}
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+function normalizeCacheOptionsTags(options) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of options.tags ?? []) {
+    tags.add(normalizeCacheTag(tag));
+  }
+  for (const routePath of options.paths ?? []) {
+    tags.add(createPathCacheTag(routePath));
+  }
+  return tags;
+}
+function assertFarmCacheEntry(entry, expectedKey) {
+  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
+    throw new TypeError(
+      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
+    );
+  }
+}
 function getFunctionCacheIdentity(fn) {
   if (fn.name) {
     return `name:${fn.name}`;
@@ -6429,11 +6483,51 @@ var init_cache = __esm({
     init_bridge();
     init_cache_invalidation();
     _FarmDataCache = class _FarmDataCache {
-      constructor() {
+      constructor(config = {}) {
         this.entries = /* @__PURE__ */ new Map();
         this.inflight = /* @__PURE__ */ new Map();
         this.invalidatedTagVersions = /* @__PURE__ */ new Map();
         this.version = 0;
+        this.namespace = "farm";
+        this.local = true;
+        this.lease = {
+          enabled: true,
+          ttlMs: 1e4,
+          waitTimeoutMs: 1e4,
+          pollIntervalMs: 25
+        };
+        this.configure(config);
+      }
+      configure(config = {}) {
+        this.adapter = config.adapter;
+        this.namespace = normalizeCacheNamespace(config.namespace || "farm");
+        this.local = !config.adapter;
+        this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
+          enabled: true,
+          ttlMs: normalizePositiveDuration(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
+          waitTimeoutMs: normalizePositiveDuration(
+            config.lease?.waitTimeoutMs,
+            1e4,
+            "cache.lease.waitTimeoutMs"
+          ),
+          pollIntervalMs: normalizePositiveDuration(
+            config.lease?.pollIntervalMs,
+            25,
+            "cache.lease.pollIntervalMs"
+          )
+        };
+        if (!this.local) {
+          this.entries.clear();
+          this.inflight.clear();
+          this.invalidatedTagVersions.clear();
+          this.version = 0;
+        }
+      }
+      get adapterName() {
+        return this.adapter?.name || (this.adapter ? "custom" : "memory");
+      }
+      get hasAdapter() {
+        return this.adapter !== void 0;
       }
       get size() {
         return this.entries.size;
@@ -6469,6 +6563,45 @@ var init_cache = __esm({
         });
         return this.toPublicEntry(entry);
       }
+      async getEntryAsync(key, options = {}) {
+        if (this.local) {
+          const localEntry = this.getEntry(key, options);
+          if (localEntry) return localEntry;
+        }
+        if (!this.adapter) {
+          return this.local ? void 0 : this.getEntry(key, options);
+        }
+        const entry = await this.adapter.get(this.createAdapterKey(key));
+        if (!entry) {
+          emitFarmEvent({ type: "cache.miss", key });
+          return void 0;
+        }
+        assertFarmCacheEntry(entry, key);
+        const stale = await this.isAdapterEntryStale(entry, options.now);
+        if (stale) {
+          emitFarmEvent({
+            type: "cache.stale",
+            key,
+            tags: [...entry.tags],
+            revalidate: entry.revalidate
+          });
+          if (!options.allowStale) {
+            emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+            return void 0;
+          }
+        }
+        emitFarmEvent({
+          type: "cache.hit",
+          key,
+          tags: [...entry.tags],
+          revalidate: entry.revalidate,
+          stale
+        });
+        if (this.local && !stale) {
+          this.hydrateLocalEntry(entry);
+        }
+        return { ...entry, key };
+      }
       set(key, value, options = {}) {
         const tags = /* @__PURE__ */ new Set();
         for (const tag of options.tags ?? []) {
@@ -6481,6 +6614,7 @@ var init_cache = __esm({
           key,
           value,
           tags,
+          tagVersions: void 0,
           createdAt: options.createdAt ?? Date.now(),
           createdVersion: ++this.version,
           revalidate: normalizeRevalidate(options.revalidate)
@@ -6494,11 +6628,45 @@ var init_cache = __esm({
         });
         return this.toPublicEntry(entry);
       }
+      async setAsync(key, value, options = {}, tagVersions) {
+        const tags = normalizeCacheOptionsTags(options);
+        const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
+        const entry = {
+          key,
+          value,
+          tags: Array.from(tags),
+          tagVersions: capturedVersions,
+          createdAt: options.createdAt ?? Date.now(),
+          createdVersion: ++this.version,
+          revalidate: normalizeRevalidate(options.revalidate)
+        };
+        if (this.local) {
+          this.hydrateLocalEntry(entry);
+        }
+        if (this.adapter) {
+          await this.adapter.set(this.createAdapterKey(key), entry);
+        }
+        emitFarmEvent({
+          type: "cache.set",
+          key,
+          tags: [...entry.tags],
+          revalidate: entry.revalidate
+        });
+        return entry;
+      }
       delete(key) {
         const deleted = this.entries.delete(key);
         emitFarmEvent({ type: "cache.delete", key, deleted });
         return deleted;
       }
+      async deleteAsync(key) {
+        const deleted = this.entries.delete(key);
+        if (this.adapter) {
+          await this.adapter.delete(this.createAdapterKey(key));
+        }
+        emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
+        return this.adapter ? true : deleted;
+      }
       clear() {
         const count = this.entries.size;
         this.entries.clear();
@@ -6507,6 +6675,10 @@ var init_cache = __esm({
         this.version = 0;
         emitFarmEvent({ type: "cache.clear", count });
       }
+      async clearAsync() {
+        this.clear();
+        await this.adapter?.clear?.();
+      }
       isStale(entry, now = Date.now()) {
         if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
           return true;
@@ -6519,6 +6691,12 @@ var init_cache = __esm({
         }
         return false;
       }
+      async isStaleAsync(entry, now = Date.now()) {
+        if (this.adapter) {
+          return this.isAdapterEntryStale(entry, now);
+        }
+        return this.isStale(entry, now);
+      }
       revalidateTag(tag, options = {}) {
         const normalized = normalizeCacheTag(tag);
         const count = this.invalidateTag(normalized);
@@ -6527,6 +6705,15 @@ var init_cache = __esm({
         );
         return count;
       }
+      async revalidateTagAsync(tag, options = {}) {
+        const normalized = normalizeCacheTag(tag);
+        const count = this.invalidateTag(normalized);
+        await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
+        emitFarmEvent(
+          options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+        );
+        return count;
+      }
       revalidatePath(routePath) {
         const normalizedPath = normalizeRevalidatePath(routePath);
         const pathTag = createPathCacheTag(normalizedPath);
@@ -6543,8 +6730,25 @@ var init_cache = __esm({
         }
         return count;
       }
+      async revalidatePathAsync(routePath) {
+        const normalizedPath = normalizeRevalidatePath(routePath);
+        const pathTag = createPathCacheTag(normalizedPath);
+        const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+        const count = this.invalidateTag(pathTag);
+        await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
+        emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+        if (pprCount > 0) {
+          emitFarmEvent({
+            type: "ppr.shell.invalidated",
+            route: normalizedPath,
+            reason: "revalidatePath",
+            count: pprCount
+          });
+        }
+        return count;
+      }
       async getOrSet(key, producer, options = {}) {
-        const cached = this.getEntry(key);
+        const cached = await this.getEntryAsync(key);
         if (cached) {
           return cached.value;
         }
@@ -6553,10 +6757,8 @@ var init_cache = __esm({
           emitFarmEvent({ type: "cache.dedupe", key });
           return inflight;
         }
-        const promise = Promise.resolve().then(producer).then((value) => {
-          this.set(key, value, options);
-          return value;
-        }).catch((error) => {
+        const tags = Array.from(normalizeCacheOptionsTags(options));
+        const promise = this.fillCacheEntry(key, producer, options, tags).catch((error) => {
           emitFarmEvent({ type: "cache.error", key, operation: "set", error });
           throw error;
         }).finally(() => {
@@ -6565,6 +6767,40 @@ var init_cache = __esm({
         this.inflight.set(key, promise);
         return promise;
       }
+      async fillCacheEntry(key, producer, options, tags) {
+        const leaseKey = `${this.namespace}:lease:${key}`;
+        let leaseToken;
+        if (this.adapter?.acquireLease && this.adapter.releaseLease && this.lease.enabled) {
+          leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
+          if (!leaseToken) {
+            const shared = await this.waitForAdapterEntry(key);
+            if (shared) {
+              emitFarmEvent({ type: "cache.dedupe", key });
+              return shared.value;
+            }
+            leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
+          }
+        }
+        try {
+          const initialTagVersions = await this.getAdapterTagVersions(tags);
+          const value = await producer();
+          await this.setAsync(key, value, options, initialTagVersions);
+          return value;
+        } finally {
+          if (leaseToken && this.adapter?.releaseLease) {
+            await this.adapter.releaseLease(leaseKey, leaseToken);
+          }
+        }
+      }
+      async waitForAdapterEntry(key) {
+        const deadline = Date.now() + this.lease.waitTimeoutMs;
+        while (Date.now() < deadline) {
+          await delay(this.lease.pollIntervalMs);
+          const entry = await this.getEntryAsync(key);
+          if (entry) return entry;
+        }
+        return void 0;
+      }
       countEntriesForTag(tag) {
         let count = 0;
         for (const entry of this.entries.values()) {
@@ -6592,11 +6828,53 @@ var init_cache = __esm({
           key: entry.key,
           value: entry.value,
           tags: Array.from(entry.tags),
+          tagVersions: entry.tagVersions,
           createdAt: entry.createdAt,
           createdVersion: entry.createdVersion,
           revalidate: entry.revalidate
         };
       }
+      hydrateLocalEntry(entry) {
+        this.entries.set(entry.key, {
+          key: entry.key,
+          value: entry.value,
+          tags: new Set(entry.tags.map(normalizeCacheTag)),
+          tagVersions: entry.tagVersions,
+          createdAt: entry.createdAt,
+          createdVersion: entry.createdVersion ?? ++this.version,
+          revalidate: normalizeRevalidate(entry.revalidate)
+        });
+      }
+      createAdapterKey(key) {
+        return `${this.namespace}:entry:${key}`;
+      }
+      createAdapterTag(tag) {
+        return `${this.namespace}:tag:${tag}`;
+      }
+      async getAdapterTagVersions(tags) {
+        if (!this.adapter?.getTagVersions || tags.length === 0) return {};
+        const normalized = tags.map(normalizeCacheTag);
+        const physicalTags = normalized.map((tag) => this.createAdapterTag(tag));
+        const versions = await this.adapter.getTagVersions(physicalTags);
+        return Object.fromEntries(
+          normalized.map((tag, index) => [
+            tag,
+            normalizeAdapterVersion(versions[physicalTags[index]])
+          ])
+        );
+      }
+      async isAdapterEntryStale(entry, now = Date.now()) {
+        if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+          return true;
+        }
+        const currentVersions = await this.getAdapterTagVersions(entry.tags);
+        for (const tag of entry.tags) {
+          if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
+            return true;
+          }
+        }
+        return false;
+      }
     };
     __name(_FarmDataCache, "FarmDataCache");
     FarmDataCache = _FarmDataCache;
@@ -6606,6 +6884,7 @@ var init_cache = __esm({
     functionIds = /* @__PURE__ */ new WeakMap();
     nextFunctionId = 0;
     __name(getFarmDataCache, "getFarmDataCache");
+    __name(configureFarmCache, "configureFarmCache");
     __name(createPathCacheTag, "createPathCacheTag");
     __name(createRouteDataCacheTag, "createRouteDataCacheTag");
     __name(createRouteDataCacheKey, "createRouteDataCacheKey");
@@ -6613,6 +6892,12 @@ var init_cache = __esm({
     __name(createFarmCacheKey, "createFarmCacheKey");
     __name(normalizeRevalidate, "normalizeRevalidate");
     __name(normalizeCacheTag, "normalizeCacheTag");
+    __name(normalizeCacheNamespace, "normalizeCacheNamespace");
+    __name(normalizeAdapterVersion, "normalizeAdapterVersion");
+    __name(normalizePositiveDuration, "normalizePositiveDuration");
+    __name(delay, "delay");
+    __name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
+    __name(assertFarmCacheEntry, "assertFarmCacheEntry");
     __name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
     __name(stableSerialize, "stableSerialize");
   }
@@ -7734,6 +8019,83 @@ var init_routing = __esm({
   }
 });
 
+// src/routing/route-slots.ts
+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"
+  };
+}
+function createRouteSlotContainerId(name, ownerPattern) {
+  const owner = ownerPattern === "/" ? "root" : ownerPattern.replace(/^\//, "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `__farm_slot_${name}_${owner || "root"}__`;
+}
+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;
+}
+var SLOT_SEGMENT;
+var init_route_slots = __esm({
+  "src/routing/route-slots.ts"() {
+    "use strict";
+    init_utils();
+    SLOT_SEGMENT = /^@([A-Za-z][A-Za-z0-9_-]*)$/;
+    __name(parseRouteSlotFile, "parseRouteSlotFile");
+    __name(createRouteSlotContainerId, "createRouteSlotContainerId");
+    __name(parseInterceptionMarker, "parseInterceptionMarker");
+  }
+});
+
 // src/routing/route-manager.ts
 function routeSpecificity(entry) {
   return entry.route.segments.reduce((score, segment) => {
@@ -7805,11 +8167,13 @@ var init_route_manager = __esm({
     init_static_metadata_image();
     init_route_runtime();
     init_routing();
+    init_route_slots();
     __name(routeSpecificity, "routeSpecificity");
     _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();
@@ -7825,6 +8189,7 @@ var init_route_manager = __esm({
       async discoverRoutes() {
         this.routes.clear();
         this.layouts.clear();
+        this.routeSlots.clear();
         this.loadings.clear();
         this.errors.clear();
         this.metadataImages.clear();
@@ -7835,6 +8200,13 @@ var init_route_manager = __esm({
           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)
@@ -7850,7 +8222,7 @@ var init_route_manager = __esm({
       /**
        * 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;
@@ -7864,10 +8236,12 @@ var init_route_manager = __esm({
           }
         }
         const layouts = this.findMatchingLayouts(normalizedPath);
+        const slots = this.findMatchingRouteSlots(normalizedPath, options.interceptFrom);
         return {
           route: matchedRoute,
           params,
-          layouts
+          layouts,
+          slots
         };
       }
       /**
@@ -7882,6 +8256,9 @@ var init_route_manager = __esm({
       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);
@@ -8040,7 +8417,22 @@ var init_route_manager = __esm({
           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
@@ -8117,6 +8509,7 @@ var init_route_manager = __esm({
       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);
@@ -8125,7 +8518,7 @@ var init_route_manager = __esm({
           appDir
         );
         for (const [kind, files, target] of [
-          ["page", pageFiles, this.routes],
+          ["page", pageFiles.filter((file) => parseRouteSlotFile(file) === null), this.routes],
           ["layout", layoutFiles, this.layouts],
           ["loading", loadingFiles, this.loadings],
           ["error", errorFiles, this.errors]
@@ -8149,6 +8542,32 @@ var init_route_manager = __esm({
             });
           }
         }
+        for (const file of [...pageFiles, ...slotDefaultFiles]) {
+          const slot = parseRouteSlotFile(file);
+          if (!slot) continue;
+          const modulePath = import_path6.default.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 = import_path6.default.basename(file, import_path6.default.extname(file));
           const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
@@ -8274,6 +8693,71 @@ var init_route_manager = __esm({
         }
         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);
@@ -9868,7 +10352,9 @@ var init_renderer = __esm({
       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) {
@@ -9891,11 +10377,11 @@ var init_renderer = __esm({
       /**
        * 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;
@@ -9907,12 +10393,12 @@ var init_renderer = __esm({
         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(page2, html, options) {
-        this.dataCache.set(
+      async cacheSSGPage(page2, html, options) {
+        await this.dataCache.setAsync(
           this.getSSGCacheKey(page2.urlPath),
           { html, document: options.document },
           {
@@ -9924,11 +10410,11 @@ var init_renderer = __esm({
         );
       }
       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 },
           {
@@ -10026,7 +10512,7 @@ var init_renderer = __esm({
               }
               const { renderToString } = await import("react-dom/server");
               const html = renderToString(await this.wrapWithIntegrationProviders(pageElement));
-              this.cacheSSGPage(page2, html, { document: false });
+              await this.cacheSSGPage(page2, html, { document: false });
               logger.info(`ISR: Regenerated ${page2.urlPath}`);
             } catch (error) {
               logger.error(`ISR regeneration failed for ${page2.urlPath}: ${error}`);
@@ -10040,7 +10526,7 @@ var init_renderer = __esm({
        * Serve a pre-rendered SSG page
        */
       async serveSSGPage(req, res, page2) {
-        const cached = this.getCachedSSGPage(page2.urlPath);
+        const cached = await this.getCachedSSGPage(page2.urlPath);
         if (cached) {
           res.setHeader("Content-Type", "text/html; charset=utf-8");
           res.setHeader("X-Farm-SSG", "cached");
@@ -10058,9 +10544,12 @@ var init_renderer = __esm({
           if (fs2.existsSync(htmlPath)) {
             const stat = fs2.statSync(htmlPath);
             const html = fs2.readFileSync(htmlPath, "utf-8");
-            this.cacheSSGPage(page2, html, { document: true, createdAt: stat.mtimeMs });
-            const fileCacheEntry = this.getCachedSSGPage(page2.urlPath);
-            if (fileCacheEntry && this.dataCache.isStale(fileCacheEntry)) {
+            await this.cacheSSGPage(page2, html, {
+              document: true,
+              createdAt: stat.mtimeMs
+            });
+            const fileCacheEntry = await this.getCachedSSGPage(page2.urlPath);
+            if (fileCacheEntry && await this.dataCache.isStaleAsync(fileCacheEntry)) {
               this.regenerateSSGPage(page2);
             }
             res.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -10106,6 +10595,7 @@ var init_renderer = __esm({
         let pathname = "/";
         let params = {};
         let layouts = [];
+        let routeSlots = [];
         let searchParamsObject = {};
         let middlewareMap = /* @__PURE__ */ new Map();
         let middlewareContext = /* @__PURE__ */ new Map();
@@ -10138,7 +10628,7 @@ var init_renderer = __esm({
           }
           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) {
@@ -10151,6 +10641,7 @@ var init_renderer = __esm({
           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);
@@ -10167,7 +10658,9 @@ var init_renderer = __esm({
           errorBoundaryEntry = this.routeManager.getMatchingError(pathname);
           middlewareMap = toMiddlewareMap2(req.__FARM_MIDDLEWARE_DATA__);
           middlewareContext = toMiddlewareMap2(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,
@@ -10231,8 +10724,16 @@ var init_renderer = __esm({
             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 });
@@ -10240,14 +10741,22 @@ var init_renderer = __esm({
           }
           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) {
@@ -10271,14 +10780,77 @@ var init_renderer = __esm({
           );
           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,
@@ -10338,12 +10910,32 @@ var init_renderer = __esm({
                 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 = import_react4.default.createElement(
+                      slot.module.default,
+                      slot.props
+                    );
+                    slotElement = import_react4.default.createElement(
+                      "div",
+                      {
+                        id: slot.containerId,
+                        "data-farm-route-slot": slot.name,
+                        "data-farm-slot-owner": slot.ownerPattern
+                      },
+                      slotElement
+                    );
+                    slotProps[slot.name] = slotElement;
+                  }
                   wrappedElement = import_react4.default.createElement(
                     LayoutComponent,
                     {
                       children: wrappedElement,
-                      params
+                      params,
+                      ...slotProps
                     }
                   );
                 }
@@ -10380,7 +10972,10 @@ var init_renderer = __esm({
                     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
                   }
                 );
@@ -10428,7 +11023,11 @@ var init_renderer = __esm({
           }
           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) {
@@ -10481,7 +11080,9 @@ var init_renderer = __esm({
           if (typeof layoutModule.generateMetadata === "function") {
             metadata = mergeMetadata(
               metadata,
-              await layoutModule.generateMetadata({ params: options.pageProps.params })
+              await layoutModule.generateMetadata({
+                params: options.pageProps.params
+              })
             );
           }
         }
@@ -10712,7 +11313,13 @@ var init_renderer = __esm({
             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] = {
@@ -10734,9 +11341,26 @@ var init_renderer = __esm({
               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)};
@@ -10749,7 +11373,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,
@@ -10860,7 +11484,11 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
               didError = true;
               if (!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();
@@ -10871,7 +11499,11 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
               didError = true;
               if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
                 logger.error(`SSR streaming error: ${error}`);
-                emitFarmEvent({ type: "render.error", route: observabilityRoute, error });
+                emitFarmEvent({
+                  type: "render.error",
+                  route: observabilityRoute,
+                  error
+                });
               }
             }
           });
@@ -11053,6 +11685,7 @@ var init_app = __esm({
     init_devtools_config();
     init_config();
     init_server2();
+    init_cache();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -11074,6 +11707,7 @@ var init_app = __esm({
           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();
@@ -11105,6 +11739,7 @@ var init_app = __esm({
           preset: config.preset ?? "node-server",
           deploy: config.deploy || {},
           storage: config.storage || {},
+          cache: config.cache || {},
           integrations: config.integrations || {},
           plugins: config.plugins || [],
           migrations: config.migrations || { commands: [] },
@@ -11178,6 +11813,13 @@ var init_app = __esm({
   }
 });
 
+// src/api/transport.ts
+var init_transport = __esm({
+  "src/api/transport.ts"() {
+    "use strict";
+  }
+});
+
 // src/api/endpoint.ts
 function isEndpointFailure(value) {
   return value instanceof EndpointFailure;
@@ -11188,6 +11830,7 @@ var init_endpoint = __esm({
     "use strict";
     import_better_call = require("better-call");
     init_cache();
+    init_transport();
     _EndpointFailure = class _EndpointFailure extends Error {
       constructor(code, data, options) {
         super(options.message);
@@ -11247,7 +11890,7 @@ async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
   });
   let body = void 0;
   if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
-    body = await readJSONBody(request);
+    body = await readRequestBody2(request);
   }
   const headers = Object.fromEntries(request.headers.entries());
   const types = endpoint.__types || {};
@@ -11345,16 +11988,46 @@ function isFarmContextHandler(endpoint) {
   const firstParameter = (arrowMatch?.[1] || arrowMatch?.[2] || functionMatch?.[1] || "").split(",")[0].trim();
   return firstParameter === "ctx" || firstParameter === "context" || firstParameter.startsWith("{");
 }
-async function readJSONBody(request) {
+async function readRequestBody2(request) {
+  const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
   try {
+    if (contentType === "multipart/form-data") {
+      return formDataToObject(await request.clone().formData());
+    }
     const text2 = await request.clone().text();
-    if (text2) {
+    if (!text2) return void 0;
+    if (contentType === "application/x-www-form-urlencoded") {
+      return searchParamsToObject2(new URLSearchParams(text2));
+    }
+    if (contentType === "application/json" || contentType?.endsWith("+json")) {
       return JSON.parse(text2);
     }
+    return JSON.parse(text2);
   } catch {
   }
   return void 0;
 }
+function formDataToObject(formData) {
+  return entriesToObject(formData.entries());
+}
+function searchParamsToObject2(searchParams) {
+  return entriesToObject(searchParams.entries());
+}
+function entriesToObject(entries) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of entries) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
 function validateInput(schema, value, error) {
   if (!schema || typeof schema.parse !== "function") {
     return value;
@@ -11453,7 +12126,10 @@ var init_runtime2 = __esm({
     __name(attachEndpointInvalidations, "attachEndpointInvalidations");
     __name(createEndpointFailureResponse, "createEndpointFailureResponse");
     __name(isFarmContextHandler, "isFarmContextHandler");
-    __name(readJSONBody, "readJSONBody");
+    __name(readRequestBody2, "readRequestBody");
+    __name(formDataToObject, "formDataToObject");
+    __name(searchParamsToObject2, "searchParamsToObject");
+    __name(entriesToObject, "entriesToObject");
     __name(validateInput, "validateInput");
     __name(matchRoutePath, "matchRoutePath");
     __name(getPathSegments, "getPathSegments");
@@ -13810,6 +14486,7 @@ async function generateRouteTypes(options) {
         absolute: false
       });
       for (const file of pageFiles) {
+        if (parseRouteSlotFile(file)) continue;
         const route = parseRoutePath(file);
         if (route.type === "page") {
           const pattern = createRoutePattern(route);
@@ -13875,6 +14552,7 @@ var init_generate_route_types = __esm({
     path17 = __toESM(require("path"));
     fs5 = __toESM(require("fs"));
     init_utils();
+    init_route_slots();
     init_routes_server();
     init_write_file_if_changed();
     __name(routeSegmentsToTsTypeLiteral, "routeSegmentsToTsTypeLiteral");
@@ -14243,7 +14921,7 @@ var init_type_artifacts = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.3";
+    version = "0.1.0-beta.5";
   }
 });
 
@@ -21213,7 +21891,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");
@@ -21904,7 +22582,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,
@@ -21920,7 +22601,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");
@@ -21975,6 +22656,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)) {
@@ -21995,13 +22724,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(
@@ -22337,6 +23074,7 @@ function farmPlugin(options = {}, initialPluginManager) {
 export const getManifest = () => ({
   routes: {},
   layouts: {},
+  slots: [],
   clientEntry: "/@farm/client.js",
   sharedAssets: []
 });
@@ -22347,6 +23085,7 @@ export const getManifest = () => ({
           clientEntry: "/@farm/client.js",
           routes: {},
           layouts: {},
+          slots: [],
           sharedAssets: [
             {
               tag: "link",
@@ -22376,6 +23115,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
@@ -23012,7 +23758,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!)
@@ -23351,6 +24097,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 } : {};
@@ -23363,6 +24112,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
@@ -23597,6 +24463,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,
@@ -23825,7 +24702,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
     }
@@ -26338,6 +27217,18 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         ...isFarmMarkdownPageFile(entry.modulePath) ? { source: (0, import_fs5.readFileSync)(entry.modulePath, "utf8") } : {}
       });
     }
+    const routeSlots = Array.from(
+      routeManager.getRouteSlots().values(),
+      (entry) => ({
+        name: entry.name,
+        ownerPattern: entry.ownerPattern,
+        pattern: entry.pattern,
+        modulePath: entry.modulePath,
+        containerId: entry.containerId,
+        interception: entry.interception,
+        fallback: entry.fallback
+      })
+    );
     logger.info(`\u{1F4CB} Found ${pageRoutes.length} page routes`);
     const fs8 = await import("fs/promises");
     const layoutRoutes = [];
@@ -26381,7 +27272,16 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
     logger.info("\u{1F4E6} Building client and SSR bundles in parallel...");
     const [clientBuildResult, ssrBuildResult] = await Promise.allSettled([
       // Client build (to disk)
-      buildClient(productionVite, config, root, srcDir, clientOutputDir, pageRoutes, layoutRoutes),
+      buildClient(
+        productionVite,
+        config,
+        root,
+        srcDir,
+        clientOutputDir,
+        pageRoutes,
+        layoutRoutes,
+        routeSlots
+      ),
       // SSR build (in memory)
       buildSSRInMemory(
         productionVite,
@@ -26392,7 +27292,8 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         serverRenderer,
         preset,
         pageRoutes,
-        layoutRoutes
+        layoutRoutes,
+        routeSlots
       )
     ]);
     const [routeRuntimeManifestResult] = await routeRuntimeManifestResultPromise;
@@ -26412,7 +27313,8 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         srcDir,
         clientOutputDir,
         pageRoutes,
-        layoutRoutes
+        layoutRoutes,
+        routeSlots
       );
     }
     const ssrResult = ssrBuildResult.value;
@@ -26515,7 +27417,7 @@ async function validateClientBuildOutput(root, srcDir, outputDir) {
   }
 }
 __name(validateClientBuildOutput, "validateClientBuildOutput");
-async function buildClient(productionVite, config, root, srcDir, outputDir, pageRoutes, layoutRoutes = []) {
+async function buildClient(productionVite, config, root, srcDir, outputDir, pageRoutes, layoutRoutes = [], routeSlots = []) {
   const viteBuild = productionVite.build;
   const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
@@ -26542,8 +27444,16 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
       logger.warn(`\u26A0\uFE0F  Could not inspect route file ${route.modulePath}: ${error}`);
     }
   }
+  const clientRouteSlots = routeSlots.filter((slot) => {
+    try {
+      return getClientModuleMetadata(slot.modulePath, root).shouldHydrate;
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F  Could not inspect route slot ${slot.modulePath}: ${error}`);
+      return false;
+    }
+  });
   logger.info(
-    `\u{1F4F1} Total hydratable routes detected: ${clientPages.length} out of ${pageRoutes.length} pages`
+    `\u{1F4F1} Total hydratable routes detected: ${clientPages.length} pages and ${clientRouteSlots.length} slots`
   );
   const clientEntryRoot = import_path12.default.join(root, ".farm", "tmp");
   await fs8.mkdir(clientEntryRoot, { recursive: true });
@@ -26552,6 +27462,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
   const clientHydrationCode = generateClientHydrationEntry(
     clientPages,
     layoutRoutes,
+    clientRouteSlots,
     root,
     srcDir,
     isFarmDocsSearchEnabled(config.docs),
@@ -26884,7 +27795,7 @@ function generateUniversalRouterStateProperties() {
 `.trim();
 }
 __name(generateUniversalRouterStateProperties, "generateUniversalRouterStateProperties");
-function generateClientHydrationEntry(clientPages, layoutRoutes, root, srcDir, docsSearchEnabled, docsSearchModuleId, i18nConfig = {
+function generateClientHydrationEntry(clientPages, layoutRoutes, clientRouteSlots, root, srcDir, docsSearchEnabled, docsSearchModuleId, i18nConfig = {
   enabled: false,
   locales: ["en"],
   defaultLocale: "en",
@@ -26952,7 +27863,7 @@ function isFarmLocaleDocumentChange() {
   return false;
 }
 `;
-  if (clientPages.length === 0) {
+  if (clientPages.length === 0 && clientRouteSlots.length === 0) {
     return `
 // Farm.js Client Runtime (no client components)
 ${cssImport}
@@ -27202,11 +28113,25 @@ document.addEventListener("click", function(e) {
   }
   const imports = [];
   const routeEntries = [];
+  const routeSlotEntries = [];
   clientPages.forEach((page2, index) => {
     const importPath = toImportPath(page2.modulePath);
     imports.push(`import Page${index} from "${importPath}";`);
     routeEntries.push(`  { pattern: ${JSON.stringify(page2.pattern)}, Component: Page${index} }`);
   });
+  clientRouteSlots.forEach((slot, index) => {
+    const importPath = toImportPath(slot.modulePath);
+    imports.push(`import RouteSlot${index} from "${importPath}";`);
+    routeSlotEntries.push(`  {
+    name: ${JSON.stringify(slot.name)},
+    ownerPattern: ${JSON.stringify(slot.ownerPattern)},
+    pattern: ${JSON.stringify(slot.pattern)},
+    containerId: ${JSON.stringify(slot.containerId)},
+    interception: ${JSON.stringify(slot.interception)},
+    fallback: ${JSON.stringify(slot.fallback)},
+    Component: RouteSlot${index},
+  }`);
+  });
   return `
 // Farm.js Client Runtime - SPA with Hydration
 ${cssImport}
@@ -27228,6 +28153,10 @@ const clientRoutes = [
 ${routeEntries.join(",\n")}
 ];
 
+const clientRouteSlots = [
+${routeSlotEntries.join(",\n")}
+];
+
 // Layout routes for wrapping client components
 const layoutRoutes = [
 ${layoutRegistrations.join(",\n")}
@@ -27282,6 +28211,146 @@ function matchRoute(pathname) {
   return null;
 }
 
+function matchesRoutePrefix(pathname, pattern) {
+  if (pattern === "/") return true;
+  const pathSegments = getFarmRoutePathname(pathname).split("/").filter(Boolean);
+  const patternSegments = pattern.split("/").filter(Boolean);
+  if (patternSegments.length > pathSegments.length) return false;
+  const candidate = "/" + pathSegments.slice(0, patternSegments.length).join("/");
+  return matchFarmRoute(pattern, candidate) !== null;
+}
+
+function matchInterceptedRouteSlot(pathname, from) {
+  for (const slot of clientRouteSlots) {
+    if (!slot.interception || !matchesRoutePrefix(from, slot.ownerPattern)) continue;
+    const params = matchFarmRoute(slot.pattern, getFarmRoutePathname(pathname));
+    if (params !== null) return { slot: slot, params: params };
+  }
+  return null;
+}
+
+function routeSlotKey(slot) {
+  return slot.ownerPattern + ":" + slot.name;
+}
+
+function findClientRouteSlot(slot) {
+  return clientRouteSlots.find(function(candidate) {
+    return candidate.name === slot.name &&
+      candidate.ownerPattern === slot.ownerPattern &&
+      candidate.pattern === slot.pattern &&
+      candidate.interception === slot.interception &&
+      candidate.fallback === slot.fallback;
+  });
+}
+
+function readRouteSlotPayload(doc) {
+  const script = doc.getElementById("__farm_route_slots_data__");
+  if (!script?.textContent) return [];
+  try {
+    const parsed = JSON.parse(script.textContent);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+const routeSlotRoots = new Map();
+let activeRouteInterception = null;
+
+function resetRouteSlotRoots() {
+  for (const root of routeSlotRoots.values()) {
+    try { root.unmount(); } catch {}
+  }
+  routeSlotRoots.clear();
+  activeRouteInterception = null;
+}
+
+function renderClientRouteSlot(slot, registration, mode) {
+  const container = document.getElementById(slot.containerId);
+  if (!container || !registration?.Component) return false;
+  const key = routeSlotKey(slot);
+  const existingRoot = routeSlotRoots.get(key);
+  const props = slot.props && typeof slot.props === "object" ? slot.props : {};
+  const element = React.createElement(registration.Component, props);
+
+  if (mode === "hydrate") {
+    if (existingRoot) return true;
+    const root = hydrateRoot(container, element);
+    routeSlotRoots.set(key, root);
+    return true;
+  }
+
+  if (existingRoot) {
+    try { existingRoot.unmount(); } catch {}
+    routeSlotRoots.delete(key);
+  } else {
+    container.replaceChildren();
+  }
+  const root = createRoot(container);
+  root.render(element);
+  routeSlotRoots.set(key, root);
+  return true;
+}
+
+function hydrateInitialRouteSlots() {
+  const slots = Array.isArray(window.__FARM_ROUTE_SLOTS__)
+    ? window.__FARM_ROUTE_SLOTS__
+    : [];
+  for (const slot of slots) {
+    const registration = findClientRouteSlot(slot);
+    if (!registration) continue;
+    try {
+      renderClientRouteSlot(slot, registration, "hydrate");
+    } catch (error) {
+      console.warn("[Farm.js] Could not hydrate route slot:", slot.name, error);
+    }
+  }
+}
+
+function renderRouteInterception(slot, registration, from) {
+  const container = document.getElementById(slot.containerId);
+  if (!container) return false;
+  const key = routeSlotKey(slot);
+  const previousSlot = (window.__FARM_ROUTE_SLOTS__ || []).find(function(candidate) {
+    return routeSlotKey(candidate) === key;
+  }) || null;
+  const previousHtml = container.innerHTML;
+
+  if (!renderClientRouteSlot(slot, registration, "render")) return false;
+  activeRouteInterception = {
+    from: from,
+    key: key,
+    slot: slot,
+    previousSlot: previousSlot,
+    previousHtml: previousHtml,
+  };
+  return true;
+}
+
+function clearRouteInterception(destination) {
+  if (!activeRouteInterception) return false;
+  const active = activeRouteInterception;
+  activeRouteInterception = null;
+  const root = routeSlotRoots.get(active.key);
+  if (root) {
+    try { root.unmount(); } catch {}
+    routeSlotRoots.delete(active.key);
+  }
+  const container = document.getElementById(active.slot.containerId);
+  if (container) {
+    container.innerHTML = active.previousHtml;
+    if (active.previousSlot) {
+      const registration = findClientRouteSlot(active.previousSlot);
+      if (registration) {
+        try {
+          renderClientRouteSlot(active.previousSlot, registration, "hydrate");
+        } catch {}
+      }
+    }
+  }
+  return destination === active.from;
+}
+
 // State
 let reactRoot = null;
 let currentPathname = null;
@@ -27300,12 +28369,17 @@ function resetReactRoot() {
 async function hydrate() {
   const pathname = window.location.pathname;
   const matched = matchRoute(pathname);
-  
+  hydrateInitialRouteSlots();
+
   if (!matched) {
     return;
   }
   
-  const container = document.getElementById("root");
+  const hasRouteSlots =
+    Array.isArray(window.__FARM_ROUTE_SLOTS__) && window.__FARM_ROUTE_SLOTS__.length > 0;
+  const container =
+    (hasRouteSlots ? document.getElementById("__farm_page__") : null) ||
+    document.getElementById("root");
   if (!container) {
     console.error("[Farm.js] No root element found");
     return;
@@ -27319,7 +28393,9 @@ async function hydrate() {
   
   // Create page element and wrap with layouts
   const pageElement = React.createElement(Component, props);
-  const wrappedElement = wrapWithLayouts(pageElement, pathname, params);
+  const wrappedElement = hasRouteSlots
+    ? pageElement
+    : wrapWithLayouts(pageElement, pathname, params);
 
   const shouldHydrate = !isHydrated && Boolean(container.innerHTML.trim());
   const hydrationSession = await farmClientRuntime.beginHydration({
@@ -27384,6 +28460,57 @@ ${generateUniversalRouterStateProperties()}
           : undefined,
       });
 
+      if (activeRouteInterception && clearRouteInterception(to)) {
+        await farmClientRuntime.markNavigationLoaded(clientNavigation, {
+          routeSlots: "restored",
+        });
+        await farmClientRuntime.resolveNavigation(clientNavigation);
+        void farmClientRuntime.scheduleNavigationRendered(clientNavigation);
+        this.currentPath = to;
+        this.finishNavigation();
+        return;
+      }
+      if (activeRouteInterception) {
+        clearRouteInterception(to);
+      }
+
+      const intercepted = matchInterceptedRouteSlot(pathname, from);
+      if (intercepted) {
+        const html = await this.fetchPage(to, from);
+        const doc = new DOMParser().parseFromString(html, "text/html");
+        const slotPayload = readRouteSlotPayload(doc);
+        const selectedSlot = slotPayload.find(function(slot) {
+          return slot.interception &&
+            slot.name === intercepted.slot.name &&
+            slot.ownerPattern === intercepted.slot.ownerPattern;
+        });
+
+        if (
+          selectedSlot &&
+          renderRouteInterception(selectedSlot, intercepted.slot, from)
+        ) {
+          await farmClientRuntime.markNavigationLoaded(clientNavigation, {
+            route: intercepted.slot.pattern,
+            params: intercepted.params,
+          });
+          const historyState = createHistoryState(
+            to,
+            options.state,
+            window.history.state,
+          );
+          if (action === "replace") {
+            window.history.replaceState(historyState, "", url);
+          } else if (action !== "pop") {
+            window.history.pushState(historyState, "", url);
+          }
+          await farmClientRuntime.resolveNavigation(clientNavigation);
+          void farmClientRuntime.scheduleNavigationRendered(clientNavigation);
+          this.currentPath = to;
+          this.finishNavigation();
+          return;
+        }
+      }
+
       if (matched) {
         const Component = matched.route.Component;
         const params = matched.params;
@@ -27460,21 +28587,28 @@ ${generateUniversalRouterStateProperties()}
     }
   },
   
-  fetchPage: async function(url) {
-    const cached = this.prefetchCache.get(url);
+  fetchPage: async function(url, interceptFrom) {
+    const cacheKey = interceptFrom ? url + "\\nintercept:" + interceptFrom : url;
+    const cached = this.prefetchCache.get(cacheKey);
     if (cached) return cached;
     
     const response = await fetch(url, {
-      headers: { "Accept": "text/html" }
+      headers: {
+        "Accept": "text/html",
+        ...(interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {}),
+      }
     });
     if (!response.ok) throw new Error("Failed to fetch page");
-    return response.text();
+    const html = await response.text();
+    this.prefetchCache.set(cacheKey, html);
+    return html;
   },
   
   swapContent: function(html, targetPath) {
     const parser = new DOMParser();
     const doc = parser.parseFromString(html, "text/html");
     if (isFarmLocaleDocumentChange(doc)) return false;
+    const nextRouteSlots = readRouteSlotPayload(doc);
     
     // Update title
     const newTitle = doc.querySelector("title");
@@ -27499,7 +28633,10 @@ ${generateUniversalRouterStateProperties()}
     const currentRoot = document.getElementById("root");
     if (!newRoot || !currentRoot) return this.swapDocument(doc);
     resetReactRoot();
+    resetRouteSlotRoots();
     currentRoot.innerHTML = newRoot.innerHTML;
+    window.__FARM_ROUTE_SLOTS__ = nextRouteSlots;
+    hydrateInitialRouteSlots();
 
     // Check if new page has a client component
     const targetUrl = new URL(targetPath || window.location.href, window.location.origin);
@@ -27511,13 +28648,15 @@ ${generateUniversalRouterStateProperties()}
       const params = matched.params;
       const searchParams = Object.fromEntries(targetUrl.searchParams);
       const props = { params: params, searchParams: Promise.resolve(searchParams) };
-      
-      if (!reactRoot) {
-        reactRoot = createRoot(currentRoot);
-      }
       const pageElement = React.createElement(Component, props);
-      const wrappedElement = wrapWithLayouts(pageElement, newPathname, params);
-      reactRoot.render(wrappedElement);
+      const hasRouteSlots = nextRouteSlots.length > 0;
+      const pageContainer =
+        (hasRouteSlots ? document.getElementById("__farm_page__") : null) || currentRoot;
+      const wrappedElement = hasRouteSlots
+        ? pageElement
+        : wrapWithLayouts(pageElement, newPathname, params);
+      reactRoot = hydrateRoot(pageContainer, wrappedElement);
+      isHydrated = true;
     }
     return true;
   },
@@ -27526,6 +28665,7 @@ ${generateUniversalRouterStateProperties()}
     if (!doc.documentElement || !doc.body) return false;
 
     resetReactRoot();
+    resetRouteSlotRoots();
 
     Array.from(document.documentElement.attributes).forEach(function(attr) {
       if (!doc.documentElement.hasAttribute(attr.name)) {
@@ -27559,10 +28699,12 @@ ${generateUniversalRouterStateProperties()}
     if (url.origin !== window.location.origin) return;
     
     const pathname = url.pathname + url.search;
-    if (this.prefetchCache.has(pathname)) return;
+    const interceptFrom = this.currentPath;
+    const cacheKey = pathname + "\\nintercept:" + interceptFrom;
+    if (this.prefetchCache.has(cacheKey)) return;
     
-    this.fetchPage(pathname)
-      .then(function(html) { spaRouter.prefetchCache.set(pathname, html); })
+    this.fetchPage(pathname, interceptFrom)
+      .then(function(html) { spaRouter.prefetchCache.set(cacheKey, html); })
       .catch(function() {});
   },
   
@@ -27653,7 +28795,7 @@ if (isFarmDocsSearchPage()) {
 `.trim();
 }
 __name(generateClientHydrationEntry, "generateClientHydrationEntry");
-async function buildSSRInMemory(productionVite, config, root, routeManager, apiRouteManager, serverRenderer, preset, collectedPageRoutes, collectedLayoutRoutes) {
+async function buildSSRInMemory(productionVite, config, root, routeManager, apiRouteManager, serverRenderer, preset, collectedPageRoutes, collectedLayoutRoutes, collectedRouteSlots) {
   const viteBuild = productionVite.build;
   const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
@@ -27686,6 +28828,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   let ssrEntryFile;
   const pageRoutes = collectedPageRoutes.map((route) => ({ ...route }));
   const layoutRoutes = collectedLayoutRoutes.map((route) => ({ ...route }));
+  const routeSlots = collectedRouteSlots.map((slot) => ({ ...slot }));
   const metadataImageRoutes = [];
   for (const entry of routeManager.getMetadataImages().values()) {
     if (entry.sourceType === "static") {
@@ -27786,6 +28929,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     apiRoutes,
     pageRoutes,
     layoutRoutes,
+    routeSlots,
     errorRoutes,
     metadataImageRoutes,
     middlewareRoutes,
@@ -27956,10 +29100,14 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       }
     }
   }
-  return { bundle: ssrBundle, entryFile: ssrEntryFile, configuredHeaderRoutes };
+  return {
+    bundle: ssrBundle,
+    entryFile: ssrEntryFile,
+    configuredHeaderRoutes
+  };
 }
 __name(buildSSRInMemory, "buildSSRInMemory");
-function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRoutes, metadataImageRoutes, middlewareRoutes, redirectRoutes, configuredRewriteRoutes, configuredHeaderRoutes, notFoundPath, config, configModulePath, hasServerRuntimeIntegrations, hasRuntimeIntegrationConfig, hasConfiguredRuntimePlugins, preset, i18nCatalogs) {
+function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlots, errorRoutes, metadataImageRoutes, middlewareRoutes, redirectRoutes, configuredRewriteRoutes, configuredHeaderRoutes, notFoundPath, config, configModulePath, hasServerRuntimeIntegrations, hasRuntimeIntegrationConfig, hasConfiguredRuntimePlugins, preset, i18nCatalogs) {
   const hasPluginRuntime = hasRuntimeIntegrationConfig || hasConfiguredRuntimePlugins;
   const hasMiddlewareRuntime = middlewareRoutes.length > 0 || hasFarmMiddlewareConfig(config.middleware);
   const farmDocsBaseConfig = config.docs?.enabled ? { ...config.docs, config: void 0 } : void 0;
@@ -28003,10 +29151,12 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
       return;
     }
     pageImports.push(`import * as ${varName} from "${route.modulePath}";`);
+    const shouldHydrate = getClientModuleMetadata(route.modulePath, config.root).shouldHydrate;
     pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route.pattern)},
     module: ${varName},
+    shouldHydrate: ${JSON.stringify(shouldHydrate)},
   }`);
   });
   const layoutImports = [];
@@ -28020,6 +29170,22 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
     module: ${varName},
   }`);
   });
+  const routeSlotImports = [];
+  const routeSlotRegistrations = [];
+  routeSlots.forEach((slot, index) => {
+    const varName = `routeSlot${index}`;
+    routeSlotImports.push(`import * as ${varName} from "${slot.modulePath}";`);
+    routeSlotRegistrations.push(`
+  {
+    name: ${JSON.stringify(slot.name)},
+    ownerPattern: ${JSON.stringify(slot.ownerPattern)},
+    pattern: ${JSON.stringify(slot.pattern)},
+    containerId: ${JSON.stringify(slot.containerId)},
+    interception: ${JSON.stringify(slot.interception)},
+    fallback: ${JSON.stringify(slot.fallback)},
+    module: ${varName},
+  }`);
+  });
   const errorImports = [];
   const errorRegistrations = [];
   errorRoutes.forEach((errorRoute, index) => {
@@ -28070,6 +29236,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
   _runWithMiddlewareData,
   addMetadataImageReference,
   applyProductionMiddlewareHeaders,
+  configureFarmCache,
   configureFarmObservability,
   createFarmCacheKey,
   createFarmLocaleCookie,
@@ -28172,6 +29339,7 @@ async function handleAPIRequest(request) {
 ${apiImports.join("\n")}
 ${pageImports.join("\n")}
 ${layoutImports.join("\n")}
+${routeSlotImports.join("\n")}
 ${errorImports.join("\n")}
 ${metadataImageImports.join("\n")}
 ${middlewareImports.join("\n")}
@@ -28249,6 +29417,7 @@ const farmObservabilityConfig = farmUserConfig?.observability ?? ${JSON.stringif
     config.observability ?? false
   )};
 configureFarmObservability(farmObservabilityConfig);
+configureFarmCache(farmResolvedRuntimeConfig.cache);
 const farmI18nConfig = ${JSON.stringify(config.i18n)};
 const farmI18nRuntime = ${config.i18n.enabled ? `createFarmI18nRuntime(farmI18nConfig, ${JSON.stringify(i18nCatalogs)})` : "null"};
 ${config.i18n.enabled ? "_setDefaultFarmI18nRuntime(farmI18nRuntime);" : ""}
@@ -28306,6 +29475,9 @@ for (const route of pageRoutes) {
 const layoutRoutes = [${layoutRegistrations.join(",")}
 ];
 
+const routeSlots = [${routeSlotRegistrations.join(",")}
+];
+
 // Route-level error boundaries bundled at build time.
 const errorRoutes = [${errorRegistrations.join(",")}
 ];
@@ -28340,18 +29512,21 @@ function serializeFarmInlineValue(value) {
     .replace(/\\u2029/g, "\\\\u2029");
 }
 
-function renderFarmClientBootstrapScript(canonicalPath) {
+function renderFarmClientBootstrapScript(canonicalPath, selectedRouteSlots) {
   const integrationManifest = ${hasRuntimeIntegrationConfig ? "getRegisteredIntegrationAPIManifest()" : "{}"};
+  const serializedRouteSlots = serializeFarmInlineValue(selectedRouteSlots || []);
   let source = 'window.__FARM_INTEGRATION_API_MANIFEST__=' +
     serializeFarmInlineValue(integrationManifest) +
-    ';';
+    ';window.__FARM_ROUTE_SLOTS__=' + serializedRouteSlots + ';';
   if (typeof canonicalPath === "string" && canonicalPath.startsWith("/")) {
     const serializedPath = serializeFarmInlineValue(canonicalPath);
     source += 'if(location.pathname+location.search!==' + serializedPath + '){' +
       'history.replaceState(Object.assign({},history.state||{},{path:' + serializedPath + '}),"",' +
       serializedPath + ');}';
   }
-  return '<script>' + source + '</script>';
+  return '<script id="__farm_route_slots_data__" type="application/json">' +
+    serializedRouteSlots +
+    '</script><script>' + source + '</script>';
 }
 
 function escapeFarmHtmlAttribute(value) {
@@ -29101,6 +30276,79 @@ function matchPageRoute(pathname) {
   return null;
 }
 
+function matchesRoutePrefix(pathname, pattern) {
+  if (pattern === "/") return true;
+  const pathSegments = normalizeRuntimePath(pathname).split("/").filter(Boolean);
+  const patternSegments = normalizeRuntimePath(pattern).split("/").filter(Boolean);
+  if (patternSegments.length > pathSegments.length) return false;
+  const candidate = "/" + pathSegments.slice(0, patternSegments.length).join("/");
+  return matchRuntimePathPattern(pattern, candidate) !== null;
+}
+
+function routeSlotSpecificity(slot) {
+  return slot.pattern.split("/").reduce(function(score, segment) {
+    if (!segment) return score;
+    if (segment.startsWith("[[...")) return score + 1;
+    if (segment.startsWith("[...")) return score + 2;
+    if (segment.startsWith("[")) return score + 3;
+    return score + 10;
+  }, 0);
+}
+
+function matchRouteSlots(pathname, interceptFrom) {
+  const groups = new Map();
+  for (const slot of routeSlots) {
+    if (!matchesRoutePrefix(pathname, slot.ownerPattern)) continue;
+    const key = slot.ownerPattern + ":" + slot.name;
+    const entries = groups.get(key) || [];
+    entries.push(slot);
+    groups.set(key, entries);
+  }
+
+  const normalizedFrom =
+    typeof interceptFrom === "string" && interceptFrom.startsWith("/")
+      ? new URL(interceptFrom, "http://farm.local").pathname
+      : null;
+  const matches = [];
+
+  for (const entries of groups.values()) {
+    const candidates = entries
+      .filter(function(entry) { return !entry.fallback; })
+      .filter(function(entry) {
+        return !entry.interception ||
+          (normalizedFrom && matchesRoutePrefix(normalizedFrom, entry.ownerPattern));
+      })
+      .map(function(entry) {
+        return {
+          entry: entry,
+          params: matchRuntimePathPattern(entry.pattern, pathname),
+        };
+      })
+      .filter(function(candidate) { return candidate.params !== null; })
+      .sort(function(left, right) {
+        if (left.entry.interception !== right.entry.interception) {
+          return left.entry.interception ? -1 : 1;
+        }
+        return routeSlotSpecificity(right.entry) - routeSlotSpecificity(left.entry);
+      });
+
+    if (candidates[0]) {
+      matches.push({ ...candidates[0].entry, params: candidates[0].params });
+      continue;
+    }
+
+    const fallback = entries.find(function(entry) { return entry.fallback; });
+    if (fallback) matches.push({ ...fallback, params: {} });
+  }
+
+  return matches.sort(function(left, right) {
+    const ownerDepth =
+      left.ownerPattern.split("/").filter(Boolean).length -
+      right.ownerPattern.split("/").filter(Boolean).length;
+    return ownerDepth || left.name.localeCompare(right.name);
+  });
+}
+
 function hasLocalRequestRoute(request, routePathname) {
   const pathname = new URL(request.url).pathname;
   if (matchLocalAPIRequest(request) || matchLocalIntegrationRequest(request)) {
@@ -29251,6 +30499,7 @@ function getPPRShellBypassReason(request, middlewareData, middlewareContext) {
   if (method !== "GET" && method !== "HEAD") return "method";
   if (request.headers.get("cookie")) return "cookie";
   if (request.headers.get("authorization")) return "authorization";
+  if (request.headers.get("x-farm-intercept-from")) return "route-interception";
   if (request.headers.get("x-farm-ppr-refresh")) return "refresh";
   if (hasConfiguredRouteContext) return "route-context";
   if (middlewareData?.size) return "middleware-data";
@@ -29304,8 +30553,8 @@ function getRouteSharedCacheControl(routeModule, pprCanCache) {
   return "public, s-maxage=" + revalidate + ", stale-while-revalidate=300";
 }
 
-function getCachedPPRShell(cacheKey) {
-  const entry = pprShellCache.getEntry(cacheKey);
+async function getCachedPPRShell(cacheKey) {
+  const entry = await pprShellCache.getEntryAsync(cacheKey);
   if (!entry) {
     return null;
   }
@@ -29520,7 +30769,7 @@ async function handleFarmRequestInContext(
         }
       }
       if (pprCacheKey) {
-        const cachedPPRShell = getCachedPPRShell(pprCacheKey);
+        const cachedPPRShell = await getCachedPPRShell(pprCacheKey);
         if (cachedPPRShell) {
           emitFarmEvent({ type: "ppr.shell.hit", route: pathname, key: pprCacheKey });
           emitFarmEvent({
@@ -29548,6 +30797,10 @@ async function handleFarmRequestInContext(
       
       // Get applicable layouts for this page
       const applicableLayouts = getApplicableLayouts(routePathname);
+      const selectedRouteSlots = matchRouteSlots(
+        routePathname,
+        request.headers.get("x-farm-intercept-from"),
+      );
       
       if (PageComponent) {
         // Parse search params - make it a resolved Promise for async components
@@ -29635,6 +30888,82 @@ async function handleFarmRequestInContext(
             throw routeStateError;
           }
         }
+
+        const renderedRouteSlots = await Promise.all(
+          selectedRouteSlots.map(async function(slot) {
+            const slotContext = hasConfiguredRouteContext
+              ? await resolveFarmRouteContext(farmResolvedRuntimeConfig, {
+                  request,
+                  params: slot.params,
+                  search: searchParamsObj,
+                  path: pathname,
+                })
+              : undefined;
+            const rawSlotProps = withFarmRouteContext(
+              {
+                params: slot.params,
+                searchParams: Promise.resolve(searchParamsObj),
+                path: pathname,
+                ...(middlewareData?.size ? { middleware: { data: middlewareData } } : {}),
+              },
+              slotContext,
+            );
+            if (slot.module.__farmResolveRouteProps && slotContext !== undefined) {
+              Object.defineProperty(rawSlotProps, "context", {
+                value: slotContext,
+                enumerable: true,
+                configurable: true,
+              });
+            }
+
+            const slotSchemas = slot.module.__farmRouteParsesProps
+              ? {}
+              : slot.module.__farmRouteSchemas || {};
+            let slotProps = slot.module.__farmResolveRouteProps
+              ? await slot.module.__farmResolveRouteProps(rawSlotProps)
+              : {
+                  ...rawSlotProps,
+                  params: slotSchemas.params?.parse
+                    ? slotSchemas.params.parse(slot.params)
+                    : slot.params,
+                  search: slotSchemas.search?.parse
+                    ? slotSchemas.search.parse(searchParamsObj)
+                    : searchParamsObj,
+                  searchParams: Promise.resolve(
+                    slotSchemas.search?.parse
+                      ? slotSchemas.search.parse(searchParamsObj)
+                      : searchParamsObj,
+                  ),
+                };
+            if (
+              slot.module.__farmResolveRouteProps &&
+              slotContext !== undefined &&
+              slotProps.context === slotContext
+            ) {
+              const { context: _slotContext, ...renderSlotProps } = slotProps;
+              slotProps = renderSlotProps;
+            }
+
+            return { ...slot, props: slotProps };
+          }),
+        );
+        const routeSlotPayload = renderedRouteSlots.map(function(slot) {
+          return {
+            name: slot.name,
+            ownerPattern: slot.ownerPattern,
+            pattern: slot.pattern,
+            containerId: slot.containerId,
+            interception: slot.interception,
+            fallback: slot.fallback,
+            props: {
+              params: slot.props.params,
+              search: slot.props.search || searchParamsObj,
+              searchParams: slot.props.search || searchParamsObj,
+              ...("data" in slot.props ? { data: slot.props.data } : {}),
+              path: pathname,
+            },
+          };
+        });
         
         const renderPageElement = async () => {
             // First, render the page content
@@ -29662,6 +30991,14 @@ async function handleFarmRequestInContext(
               pageElement = React.createElement(PageComponent, pageProps);
             }
 
+            if (route.shouldHydrate && renderedRouteSlots.length > 0) {
+              pageElement = React.createElement(
+                "div",
+                { id: "__farm_page__", "data-farm-client": "true" },
+                pageElement,
+              );
+            }
+
             // Wrap with layouts (from innermost to outermost)
             // Layouts are sorted by depth (root first), so we process in reverse
             let wrappedElement = pageElement;
@@ -29669,9 +31006,23 @@ async function handleFarmRequestInContext(
               const layout = applicableLayouts[i];
               const LayoutComponent = layout.module.default;
               if (LayoutComponent) {
+                const slotProps = {};
+                for (const slot of renderedRouteSlots) {
+                  if (slot.ownerPattern !== layout.pattern) continue;
+                  slotProps[slot.name] = React.createElement(
+                    "div",
+                    {
+                      id: slot.containerId,
+                      "data-farm-route-slot": slot.name,
+                      "data-farm-slot-owner": slot.ownerPattern,
+                    },
+                    React.createElement(slot.module.default, slot.props),
+                  );
+                }
                 wrappedElement = React.createElement(LayoutComponent, {
                   children: wrappedElement,
                   params,
+                  ...slotProps,
                 });
               }
             }
@@ -29723,6 +31074,7 @@ async function handleFarmRequestInContext(
         );
         const hasRequestScopedRender = Boolean(
           pageStatus >= 400 ||
+          request.headers.get("x-farm-intercept-from") ||
           hasPrivateRequestHeaders ||
           hasConfiguredRouteContext ||
           middlewareData?.size ||
@@ -29762,7 +31114,10 @@ async function handleFarmRequestInContext(
             '  <link rel="modulepreload" href="/farm-client.js">\\n' +
             '</head>\\n<body>\\n  <div id="root">';
           const streamSuffix = '</div>\\n' +
-            '  ' + renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath) + '\\n' +
+            '  ' + renderFarmClientBootstrapScript(
+              pageProps.__farmCanonicalPath,
+              routeSlotPayload
+            ) + '\\n' +
             '  <script type="module" src="/farm-client.js"></script>\\n' +
             '</body>\\n</html>';
           const streamedDocument = createFarmDocumentStream(
@@ -29819,7 +31174,10 @@ async function handleFarmRequestInContext(
             // Inject client script before closing body tag
             .replace(
               /<\\/body>/i,
-              '  ' + renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath) + '\\n' +
+              '  ' + renderFarmClientBootstrapScript(
+                pageProps.__farmCanonicalPath,
+                routeSlotPayload
+              ) + '\\n' +
                 '  <script type="module" src="/farm-client.js"></script>\\n</body>',
             );
           
@@ -29840,7 +31198,7 @@ async function handleFarmRequestInContext(
 </head>
 <body>
   <div id="root">\${html}</div>
-  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath)}
+  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath, routeSlotPayload)}
   <script type="module" src="/farm-client.js"></script>
 </body>
 </html>\`;
@@ -29848,7 +31206,7 @@ async function handleFarmRequestInContext(
         fullHtml = applyFarmI18nDocument(fullHtml, pathname, farmI18nSnapshot);
 
         if (pageStatus === 200 && pprCacheKey && request.method.toUpperCase() !== "HEAD") {
-          pprShellCache.set(
+          await pprShellCache.setAsync(
             pprCacheKey,
             { html: fullHtml },
             {
@@ -31041,6 +32399,13 @@ function mergeFarmViteConfig(farmConfig, userConfig = {}) {
       ...farmConfig.server,
       ...userConfig.server
     },
+    resolve: {
+      ...farmConfig.resolve,
+      ...userConfig.resolve,
+      dedupe: Array.from(
+        /* @__PURE__ */ new Set([...farmConfig.resolve?.dedupe || [], ...userConfig.resolve?.dedupe || []])
+      )
+    },
     optimizeDeps: {
       ...farmConfig.optimizeDeps,
       ...userConfig.optimizeDeps,