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

package/dist/index.cjs

@@ -4705,7 +4705,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 notifyFarmCacheInvalidation(key) {
@@ -4714,6 +4715,11 @@ function notifyFarmCacheInvalidation(key) {
     listener(key);
   }
 }
+function notifyFarmCacheTask(task) {
+  for (const listener of getFarmCacheInvalidationState().taskListeners) {
+    listener(task);
+  }
+}
 function applyFarmCacheInvalidations(keys) {
   if (!Array.isArray(keys)) return;
   for (const key of keys) {
@@ -4745,6 +4751,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"() {
@@ -4754,10 +4765,12 @@ var init_cache_invalidation = __esm({
     globalState = globalThis;
     __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
     __name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
+    __name(notifyFarmCacheTask, "notifyFarmCacheTask");
     __name(applyFarmCacheInvalidations, "applyFarmCacheInvalidations");
     __name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
     __name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
     __name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+    __name(subscribeFarmCacheTask, "subscribeFarmCacheTask");
   }
 });
 
@@ -4853,16 +4866,24 @@ function sanitizeServerActionError(_error) {
     message: "Server function failed"
   };
 }
-function runWithServerActionRequest(request, callback) {
+async function runWithServerActionRequest(request, callback) {
   throwIfAborted(request.signal);
-  return getServerActionStorage().run(
-    {
-      request,
-      signal: request.signal,
-      invalidations: /* @__PURE__ */ new Set()
-    },
-    callback
-  );
+  const context = {
+    request,
+    signal: request.signal,
+    invalidations: /* @__PURE__ */ new Set(),
+    cacheTasks: /* @__PURE__ */ new Set()
+  };
+  return getServerActionStorage().run(context, async () => {
+    try {
+      const result = await callback();
+      await Promise.all(context.cacheTasks);
+      return result;
+    } catch (error) {
+      await Promise.allSettled(context.cacheTasks);
+      throw error;
+    }
+  });
 }
 function getServerActionExecutionContext() {
   return getServerActionStorage().getStore();
@@ -5173,6 +5194,9 @@ var init_server_action_security = __esm({
     subscribeFarmCacheInvalidation((key) => {
       getServerActionExecutionContext()?.invalidations.add(key);
     });
+    subscribeFarmCacheTask((task) => {
+      getServerActionExecutionContext()?.cacheTasks.add(task);
+    });
     __name(getServerActionStorage, "getServerActionStorage");
     __name(getFallbackAbortController, "getFallbackAbortController");
     __name(parseBodySizeLimit, "parseBodySizeLimit");
@@ -6231,9 +6255,51 @@ function defineCacheKey() {
     });
   };
 }
+function storageCacheAdapter(storage, options = {}) {
+  if (!storage || typeof storage.getItem !== "function" || typeof storage.setItem !== "function") {
+    throw new TypeError("storageCacheAdapter expects a compatible storage client.");
+  }
+  const base = normalizeCacheNamespace(options.base || "farm-cache");
+  const entryKey = /* @__PURE__ */ __name((key) => `${base}:entry:${key}`, "entryKey");
+  const tagKey = /* @__PURE__ */ __name((tag) => `${base}:tag:${tag}`, "tagKey");
+  return {
+    name: "storage",
+    get: /* @__PURE__ */ __name((key) => storage.getItem(entryKey(key)), "get"),
+    set: /* @__PURE__ */ __name(async (key, entry) => {
+      await storage.setItem(entryKey(key), entry);
+    }, "set"),
+    delete: /* @__PURE__ */ __name(async (key) => {
+      await storage.removeItem(entryKey(key));
+    }, "delete"),
+    clear: storage.clear ? async () => {
+      await storage.clear(base);
+    } : void 0,
+    getTagVersions: /* @__PURE__ */ __name(async (tags) => {
+      const versions = await Promise.all(
+        tags.map(async (tag) => {
+          const value = await storage.getItem(tagKey(tag));
+          return [tag, normalizeAdapterVersion(value)];
+        })
+      );
+      return Object.fromEntries(versions);
+    }, "getTagVersions"),
+    invalidateTags: /* @__PURE__ */ __name(async (tags) => {
+      await Promise.all(
+        tags.map(async (tag) => {
+          const key = tagKey(tag);
+          const current = normalizeAdapterVersion(await storage.getItem(key));
+          await storage.setItem(key, Math.max(Date.now(), current + 1));
+        })
+      );
+    }, "invalidateTags")
+  };
+}
 function getFarmDataCache() {
   return sharedFarmDataCache;
 }
+function configureFarmCache(config) {
+  sharedFarmDataCache.configure(config);
+}
 function unstable_cache(fn, keyParts = [], options = {}) {
   return async (...args) => {
     const locale = getActiveFarmI18nSnapshot()?.locale;
@@ -6248,24 +6314,64 @@ function unstable_cache(fn, keyParts = [], options = {}) {
   };
 }
 function revalidateTag(_tag, _profile) {
-  getFarmDataCache().revalidateTag(_tag, {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(_tag, {
+      source: "revalidateTag",
+      profile: _profile
+    }).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidateTag(_tag, {
     source: "revalidateTag",
     profile: _profile
   });
 }
 function updateTag(tag) {
-  getFarmDataCache().revalidateTag(tag, { source: "updateTag" });
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(tag, { source: "updateTag" }).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidateTag(tag, { source: "updateTag" });
 }
 function revalidatePath(routePath) {
-  getFarmDataCache().revalidatePath(routePath);
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidatePathAsync(routePath).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidatePath(routePath);
 }
 function invalidate(key) {
   const clientKey = createRouteDataCacheKey(key);
-  getFarmDataCache().revalidateTag(createRouteDataCacheTag(key), { source: "updateTag" });
+  const task = updateTag(createRouteDataCacheTag(key));
   notifyFarmCacheInvalidation(clientKey);
+  return task;
 }
 function invalidateRouteData(key) {
-  invalidate(key);
+  return invalidate(key);
+}
+async function applyFarmCacheInvalidationTargets(targets) {
+  if (!Array.isArray(targets)) {
+    throw new TypeError("Cache invalidations must resolve to an array of targets.");
+  }
+  const clientKeys = [];
+  for (const target of targets) {
+    assertFarmCacheInvalidationTarget(target);
+    if ("key" in target) {
+      await invalidate(target.key);
+      clientKeys.push(createRouteDataCacheKey(target.key));
+    } else if ("path" in target) {
+      await revalidatePath(target.path);
+    } else {
+      await updateTag(target.tag);
+    }
+  }
+  return Array.from(new Set(clientKeys));
 }
 function createPathCacheTag(routePath) {
   return `path:${normalizeRevalidatePath(routePath)}`;
@@ -6320,6 +6426,60 @@ 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 assertFarmCacheInvalidationTarget(target) {
+  if (!target || typeof target !== "object") {
+    throw new TypeError("Cache invalidation targets must be { key }, { path }, or { tag }.");
+  }
+  if ("key" in target) {
+    const key = target.key;
+    if (typeof key === "string" || Array.isArray(key)) return;
+  } else if ("path" in target && typeof target.path === "string") {
+    return;
+  } else if ("tag" in target && typeof target.tag === "string") {
+    return;
+  }
+  throw new TypeError("Cache invalidation targets must contain a string/array key, path, or tag.");
+}
 function getFunctionCacheIdentity(fn) {
   if (fn.name) {
     return `name:${fn.name}`;
@@ -6380,12 +6540,53 @@ var init_cache = __esm({
     init_bridge();
     init_cache_invalidation();
     __name(defineCacheKey, "defineCacheKey");
+    __name(storageCacheAdapter, "storageCacheAdapter");
     _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;
@@ -6421,6 +6622,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 ?? []) {
@@ -6433,6 +6673,7 @@ var init_cache = __esm({
           key,
           value,
           tags,
+          tagVersions: void 0,
           createdAt: options.createdAt ?? Date.now(),
           createdVersion: ++this.version,
           revalidate: normalizeRevalidate(options.revalidate)
@@ -6446,11 +6687,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();
@@ -6459,6 +6734,10 @@ var init_cache = __esm({
         this.version = 0;
         emitFarmEvent({ type: "cache.clear", count });
       }
+      async clearAsync() {
+        this.clear();
+        await this.adapter?.clear?.();
+      }
       isStale(entry, now2 = Date.now()) {
         if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now2 - entry.createdAt >= entry.revalidate * 1e3) {
           return true;
@@ -6471,6 +6750,12 @@ var init_cache = __esm({
         }
         return false;
       }
+      async isStaleAsync(entry, now2 = Date.now()) {
+        if (this.adapter) {
+          return this.isAdapterEntryStale(entry, now2);
+        }
+        return this.isStale(entry, now2);
+      }
       revalidateTag(tag, options = {}) {
         const normalized = normalizeCacheTag(tag);
         const count = this.invalidateTag(normalized);
@@ -6479,6 +6764,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);
@@ -6495,8 +6789,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;
         }
@@ -6505,10 +6816,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(() => {
@@ -6517,6 +6826,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()) {
@@ -6544,11 +6887,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, now2 = Date.now()) {
+        if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now2 - 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;
@@ -6558,12 +6943,14 @@ var init_cache = __esm({
     functionIds = /* @__PURE__ */ new WeakMap();
     nextFunctionId = 0;
     __name(getFarmDataCache, "getFarmDataCache");
+    __name(configureFarmCache, "configureFarmCache");
     __name(unstable_cache, "unstable_cache");
     __name(revalidateTag, "revalidateTag");
     __name(updateTag, "updateTag");
     __name(revalidatePath, "revalidatePath");
     __name(invalidate, "invalidate");
     __name(invalidateRouteData, "invalidateRouteData");
+    __name(applyFarmCacheInvalidationTargets, "applyFarmCacheInvalidationTargets");
     __name(createPathCacheTag, "createPathCacheTag");
     __name(createRouteDataCacheTag, "createRouteDataCacheTag");
     __name(createRouteDataCacheKey, "createRouteDataCacheKey");
@@ -6571,6 +6958,13 @@ 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(assertFarmCacheInvalidationTarget, "assertFarmCacheInvalidationTarget");
     __name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
     __name(stableSerialize, "stableSerialize");
   }
@@ -7696,6 +8090,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) => {
@@ -7767,11 +8238,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();
@@ -7787,6 +8260,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();
@@ -7797,6 +8271,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)
@@ -7812,7 +8293,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;
@@ -7826,10 +8307,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
         };
       }
       /**
@@ -7844,6 +8327,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);
@@ -8002,7 +8488,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
@@ -8079,6 +8580,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);
@@ -8087,7 +8589,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]
@@ -8111,6 +8613,32 @@ var init_route_manager = __esm({
             });
           }
         }
+        for (const file of [...pageFiles, ...slotDefaultFiles]) {
+          const slot = parseRouteSlotFile(file);
+          if (!slot) continue;
+          const modulePath = import_path5.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_path5.default.basename(file, import_path5.default.extname(file));
           const kind = fileBase === "twitter-image" ? "twitter" : "opengraph";
@@ -8236,6 +8764,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);
@@ -9408,13 +10001,23 @@ function readPageState() {
   if (!state || typeof state !== "object") return null;
   return state[FARM_PAGE_STATE_KEY] ?? null;
 }
-function createHistoryState(path28, pageState, currentState) {
+function createHistoryState(path28, pageState, currentState, interceptFrom) {
   const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
-  return {
+  const nextState = {
     ...base,
     path: path28,
     [FARM_PAGE_STATE_KEY]: pageState
   };
+  if (interceptFrom === null) {
+    delete nextState[FARM_INTERCEPT_FROM_KEY];
+  } else if (interceptFrom) {
+    nextState[FARM_INTERCEPT_FROM_KEY] = interceptFrom;
+  }
+  return nextState;
+}
+function getPageDataCacheKey(path28, interceptFrom) {
+  return interceptFrom ? `${path28}
+intercept:${interceptFrom}` : path28;
 }
 function createNavigationLocation(url) {
   return {
@@ -9427,7 +10030,7 @@ function createNavigationLocation(url) {
 function getScrollElementStorageKey(path28, key) {
   return `farm-scroll-${path28}:${key}`;
 }
-var FARM_PAGE_STATE_KEY, IDLE_NAVIGATION_STATE, routerInstance, _SPARouter, SPARouter;
+var FARM_PAGE_STATE_KEY, FARM_INTERCEPT_FROM_KEY, IDLE_NAVIGATION_STATE, routerInstance, _SPARouter, SPARouter;
 var init_spa_router = __esm({
   "src/client/spa-router.ts"() {
     "use strict";
@@ -9436,6 +10039,7 @@ var init_spa_router = __esm({
     init_deployment();
     init_client_runtime();
     FARM_PAGE_STATE_KEY = "__farmPageState";
+    FARM_INTERCEPT_FROM_KEY = "__farmInterceptFrom";
     IDLE_NAVIGATION_STATE = {
       state: "idle",
       pending: false,
@@ -9506,7 +10110,11 @@ var init_spa_router = __esm({
           return;
         }
         const from = window.location.pathname + window.location.search;
-        if (await this.shouldBlockNavigation({ from, to: fullPath, action: replace ? "replace" : "push" })) {
+        if (await this.shouldBlockNavigation({
+          from,
+          to: fullPath,
+          action: replace ? "replace" : "push"
+        })) {
           return;
         }
         if (this.options.scrollRestoration) {
@@ -9524,11 +10132,11 @@ var init_spa_router = __esm({
             to: url,
             action: replace ? "replace" : "push"
           });
-          const pageData = await this.fetchPageData(fullPath);
+          const pageData = await this.fetchPageData(fullPath, true, from);
           if (clientNavigation) {
             await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
           }
-          if (pageData.isClientComponent === false) {
+          if (pageData.isClientComponent === false && !pageData.interception) {
             this.finishNavigation();
             window.location.assign(pageData.canonicalPath || fullPath);
             return;
@@ -9566,11 +10174,12 @@ var init_spa_router = __esm({
         if (isFarmLocaleChangeHref(href)) return;
         const url = new URL(href, window.location.origin);
         const fullPath = url.pathname + url.search;
+        const interceptFrom = window.location.pathname + window.location.search;
         if (this.prefetchingUrls.has(fullPath)) return;
-        if (this.isCached(fullPath)) return;
+        if (this.isCached(fullPath, interceptFrom)) return;
         this.prefetchingUrls.add(fullPath);
         try {
-          await this.fetchPageData(fullPath, false);
+          await this.fetchPageData(fullPath, false, interceptFrom);
         } catch (error) {
           console.warn("[Farm.js] Prefetch failed:", href, error);
         } finally {
@@ -9645,7 +10254,12 @@ var init_spa_router = __esm({
       }
       async commitNavigation(options) {
         const historyPath = options.pageData.canonicalPath || options.fullPath;
-        const historyState = createHistoryState(historyPath, options.state);
+        const historyState = createHistoryState(
+          historyPath,
+          options.state,
+          void 0,
+          options.pageData.interception?.from ?? null
+        );
         if (options.replace) {
           window.history.replaceState(historyState, "", historyPath);
         } else {
@@ -9700,15 +10314,17 @@ var init_spa_router = __esm({
       /**
        * Fetch page data from cache or server
        */
-      async fetchPageData(path28, recover = true) {
-        const cached = this.cache.get(path28);
+      async fetchPageData(path28, recover = true, interceptFrom) {
+        const cacheKey = getPageDataCacheKey(path28, interceptFrom);
+        const cached = this.cache.get(cacheKey);
         if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
           return cached.data;
         }
         const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path28)}`, {
           headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
             Accept: "application/x-farm-deferred+json, application/json",
-            "X-Farm-SPA": "1"
+            "X-Farm-SPA": "1",
+            ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {}
           })
         });
         if (isFarmDeploymentMismatchResponse(response, this.options.deploymentId)) {
@@ -9726,7 +10342,7 @@ var init_spa_router = __esm({
           throw new Error(`Failed to fetch page data: ${response.status}`);
         }
         const data = await readDeferredDataResponse(response);
-        this.cache.set(path28, {
+        this.cache.set(cacheKey, {
           data,
           timestamp: Date.now()
         });
@@ -9757,7 +10373,8 @@ var init_spa_router = __esm({
             to: window.location.href,
             action: "pop"
           });
-          const pageData = await this.fetchPageData(path28);
+          const interceptFrom = typeof event.state?.[FARM_INTERCEPT_FROM_KEY] === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
+          const pageData = await this.fetchPageData(path28, true, interceptFrom);
           if (clientNavigation) {
             await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
           }
@@ -9788,8 +10405,8 @@ var init_spa_router = __esm({
       /**
        * Check if URL is cached
        */
-      isCached(path28) {
-        const cached = this.cache.get(path28);
+      isCached(path28, interceptFrom) {
+        const cached = this.cache.get(getPageDataCacheKey(path28, interceptFrom));
         return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
       }
       /**
@@ -9904,6 +10521,7 @@ var init_spa_router = __esm({
     __name(replaceState, "replaceState");
     __name(readPageState, "readPageState");
     __name(createHistoryState, "createHistoryState");
+    __name(getPageDataCacheKey, "getPageDataCacheKey");
     __name(createNavigationLocation, "createNavigationLocation");
     __name(getScrollElementStorageKey, "getScrollElementStorageKey");
   }
@@ -11279,7 +11897,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) {
@@ -11302,11 +11922,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;
@@ -11318,12 +11938,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 },
           {
@@ -11335,11 +11955,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 },
           {
@@ -11437,7 +12057,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}`);
@@ -11451,7 +12071,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");
@@ -11469,9 +12089,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");
@@ -11517,6 +12140,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();
@@ -11549,7 +12173,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) {
@@ -11562,6 +12186,7 @@ var init_renderer = __esm({
           const route2 = match.route;
           params = match.params;
           layouts = match.layouts;
+          routeSlots = match.slots ?? [];
           if (!route2) {
             emitFarmEvent({ type: "route.notFound", pathname });
             await this.render404(req, res);
@@ -11578,7 +12203,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,
@@ -11642,8 +12269,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 });
@@ -11651,14 +12286,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) {
@@ -11682,14 +12325,77 @@ var init_renderer = __esm({
           );
           const moduleMetadata = routeManifestEntry || getClientModuleMetadata(route2.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__ = route2.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,
@@ -11749,12 +12455,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
                     }
                   );
                 }
@@ -11791,7 +12517,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
                   }
                 );
@@ -11839,7 +12568,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) {
@@ -11892,7 +12625,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
+              })
             );
           }
         }
@@ -12123,7 +12858,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] = {
@@ -12145,9 +12886,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)};
@@ -12160,7 +12918,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,
@@ -12271,7 +13029,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();
@@ -12282,7 +13044,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
+                });
               }
             }
           });
@@ -12488,6 +13254,7 @@ var init_app = __esm({
     init_devtools_config();
     init_config();
     init_server2();
+    init_cache();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -12509,6 +13276,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();
@@ -12540,6 +13308,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: [] },
@@ -13138,6 +13907,184 @@ var init_hmr = __esm({
   }
 });
 
+// src/api/transport.ts
+function multipart(schema) {
+  if (!Object.isExtensible(schema) && !isMultipartSchema(schema)) {
+    throw new TypeError("multipart() requires an extensible schema object");
+  }
+  if (!isMultipartSchema(schema)) {
+    Object.defineProperty(schema, "__farmMultipartSchema", {
+      value: true,
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
+  }
+  return schema;
+}
+function isMultipartSchema(value) {
+  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
+}
+function toFormData(values) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(values)) {
+    if (isUnsafeFormKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) appendFormValue(formData, key, entry);
+      continue;
+    }
+    appendFormValue(formData, key, value);
+  }
+  return formData;
+}
+function jsonStream(source, init = {}) {
+  const iterator = toAsyncIterator(source);
+  const encoder = new TextEncoder();
+  let finished = false;
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        if (finished) return;
+        try {
+          const next = await iterator.next();
+          if (next.done) {
+            finished = true;
+            controller.close();
+            return;
+          }
+          controller.enqueue(encoder.encode(`${JSON.stringify(next.value)}
+`));
+        } catch (error) {
+          finished = true;
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        finished = true;
+        await iterator.return?.(reason);
+      }
+    },
+    {
+      // Do not read the next application event until the response consumer
+      // requests another chunk.
+      highWaterMark: 0
+    }
+  );
+  const headers2 = new Headers(init.headers);
+  if (!headers2.has("content-type")) {
+    headers2.set("content-type", "application/x-ndjson; charset=utf-8");
+  }
+  headers2.set("cache-control", headers2.get("cache-control") ?? "no-store");
+  return new Response(body, {
+    ...init,
+    headers: headers2
+  });
+}
+function isJSONStreamResponse(response) {
+  const contentType = response.headers?.get?.("content-type")?.toLowerCase() ?? "";
+  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
+}
+function readJSONStream(response) {
+  if (!response.body) {
+    throw new TypeError("Cannot read a JSON stream response without a body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  let claimed = false;
+  const iterator = {
+    async next() {
+      while (true) {
+        const lineEnd = buffer.indexOf("\n");
+        if (lineEnd >= 0) {
+          const line = buffer.slice(0, lineEnd).trim();
+          buffer = buffer.slice(lineEnd + 1);
+          if (!line) continue;
+          return { done: false, value: JSON.parse(line) };
+        }
+        if (completed) {
+          const line = buffer.trim();
+          buffer = "";
+          if (!line) return { done: true, value: void 0 };
+          return { done: false, value: JSON.parse(line) };
+        }
+        const chunk = await reader.read();
+        completed = chunk.done;
+        buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+      }
+    },
+    async return() {
+      completed = true;
+      buffer = "";
+      await reader.cancel();
+      return { done: true, value: void 0 };
+    }
+  };
+  return {
+    response,
+    async cancel(reason) {
+      completed = true;
+      buffer = "";
+      await reader.cancel(reason);
+    },
+    [Symbol.asyncIterator]() {
+      if (claimed) {
+        throw new TypeError("Farm API streams can only be consumed once");
+      }
+      claimed = true;
+      return iterator;
+    }
+  };
+}
+function isFarmAPIStream(value) {
+  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function appendFormValue(formData, key, value) {
+  if (value === void 0) return;
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (value instanceof Blob) {
+    formData.append(key, value);
+    return;
+  }
+  if (value instanceof Date) {
+    formData.append(key, value.toISOString());
+    return;
+  }
+  formData.append(key, String(value));
+}
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function toAsyncIterator(source) {
+  if (Symbol.asyncIterator in Object(source)) {
+    return source[Symbol.asyncIterator]();
+  }
+  const iterator = source[Symbol.iterator]();
+  return {
+    next: /* @__PURE__ */ __name(async () => iterator.next(), "next"),
+    return: iterator.return ? async (value) => iterator.return(value) : void 0
+  };
+}
+var init_transport = __esm({
+  "src/api/transport.ts"() {
+    "use strict";
+    __name(multipart, "multipart");
+    __name(isMultipartSchema, "isMultipartSchema");
+    __name(toFormData, "toFormData");
+    __name(jsonStream, "jsonStream");
+    __name(isJSONStreamResponse, "isJSONStreamResponse");
+    __name(readJSONStream, "readJSONStream");
+    __name(isFarmAPIStream, "isFarmAPIStream");
+    __name(appendFormValue, "appendFormValue");
+    __name(isUnsafeFormKey, "isUnsafeFormKey");
+    __name(toAsyncIterator, "toAsyncIterator");
+  }
+});
+
 // src/api/endpoint.ts
 function isEndpointFailure(value) {
   return value instanceof EndpointFailure;
@@ -13193,6 +14140,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
   endpoint2.__errors = errors;
   endpoint2.__types = {
     body: options.body,
+    inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
     query: options.query,
     headers: options.headers,
     response: null,
@@ -13303,34 +14251,10 @@ async function applyEndpointInvalidations(declaration, context, result) {
   const targets = typeof declaration === "function" ? await declaration(context) : declaration;
   if (!Array.isArray(targets)) {
     throw new TypeError(
-      "Endpoint invalidates must resolve to an array of { key } or { path } targets"
+      "Endpoint invalidates must resolve to an array of { key }, { path }, or { tag } targets"
     );
   }
-  const clientKeys = [];
-  for (const target of targets) {
-    assertEndpointInvalidationTarget(target);
-    if ("key" in target) {
-      invalidate(target.key);
-      clientKeys.push(createRouteDataCacheKey(target.key));
-    } else {
-      revalidatePath(target.path);
-    }
-  }
-  return Array.from(new Set(clientKeys));
-}
-function assertEndpointInvalidationTarget(target) {
-  if (!target || typeof target !== "object") {
-    throw new TypeError("Endpoint invalidation targets must be { key } or { path } objects");
-  }
-  if ("key" in target) {
-    const key = target.key;
-    if (typeof key === "string" || Array.isArray(key)) return;
-  } else if ("path" in target && typeof target.path === "string") {
-    return;
-  }
-  throw new TypeError(
-    "Endpoint invalidation targets must contain a string/array key or a path string"
-  );
+  return applyFarmCacheInvalidationTargets(targets);
 }
 function createInitialEndpointContext(value) {
   if (value === void 0 || value === null) return EMPTY_ENDPOINT_CONTEXT;
@@ -13416,6 +14340,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);
@@ -13437,7 +14362,6 @@ var init_endpoint = __esm({
     __name(normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
     __name(runEndpointMiddleware, "runEndpointMiddleware");
     __name(applyEndpointInvalidations, "applyEndpointInvalidations");
-    __name(assertEndpointInvalidationTarget, "assertEndpointInvalidationTarget");
     __name(createInitialEndpointContext, "createInitialEndpointContext");
     __name(mergeEndpointContext, "mergeEndpointContext");
     __name(isPlainEndpointContext, "isPlainEndpointContext");
@@ -13495,7 +14419,7 @@ async function invokeAPIRouteEndpointInContext(endpoint2, request, params) {
   });
   let body = void 0;
   if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
-    body = await readJSONBody(request);
+    body = await readRequestBody2(request);
   }
   const headers2 = Object.fromEntries(request.headers.entries());
   const types = endpoint2.__types || {};
@@ -13593,16 +14517,46 @@ function isFarmContextHandler(endpoint2) {
   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;
@@ -13701,7 +14655,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");
@@ -15034,6 +15991,7 @@ async function generateRouteTypes(options) {
         absolute: false
       });
       for (const file of pageFiles) {
+        if (parseRouteSlotFile(file)) continue;
         const route2 = parseRoutePath(file);
         if (route2.type === "page") {
           const pattern = createRoutePattern(route2);
@@ -15099,6 +16057,7 @@ var init_generate_route_types = __esm({
     path12 = __toESM(require("path"));
     fs5 = __toESM(require("fs"));
     init_utils();
+    init_route_slots();
     init_routes_server();
     init_write_file_if_changed();
     __name(routeSegmentsToTsTypeLiteral, "routeSegmentsToTsTypeLiteral");
@@ -15816,7 +16775,7 @@ var init_environment_vite = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.3";
+    version = "0.1.0-beta.4";
   }
 });
 
@@ -20003,6 +20962,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,
@@ -23644,7 +24604,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");
@@ -24335,7 +25295,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,
@@ -24351,7 +25314,7 @@ function farmPlugin(options = {}, initialPluginManager) {
                   res.end(JSON.stringify({ error: "Route not found" }));
                   return;
                 }
-                const { route: route2, params, layouts } = match;
+                const { route: route2, params, layouts, slots } = match;
                 if (!route2) {
                   res.statusCode = 404;
                   res.setHeader("Content-Type", "application/json");
@@ -24406,6 +25369,54 @@ function farmPlugin(options = {}, initialPluginManager) {
                   search: searchParams,
                   routePath: route2.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)) {
@@ -24426,13 +25437,21 @@ function farmPlugin(options = {}, initialPluginManager) {
                   },
                   canonicalPath: routeProps.__farmCanonicalPath,
                   modulePath: toUrlPath(route2.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(
@@ -24768,6 +25787,7 @@ function farmPlugin(options = {}, initialPluginManager) {
 export const getManifest = () => ({
   routes: {},
   layouts: {},
+  slots: [],
   clientEntry: "/@farm/client.js",
   sharedAssets: []
 });
@@ -24778,6 +25798,7 @@ export const getManifest = () => ({
           clientEntry: "/@farm/client.js",
           routes: {},
           layouts: {},
+          slots: [],
           sharedAssets: [
             {
               tag: "link",
@@ -24807,6 +25828,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
@@ -25443,7 +26471,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!)
@@ -25782,6 +26810,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 } : {};
@@ -25794,6 +26825,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
@@ -26028,6 +27176,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,
@@ -26256,7 +27415,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
     }
@@ -28023,6 +29184,7 @@ __export(src_exports, {
   DeferredDataError: () => DeferredDataError,
   DocsRoute: () => DocsRoute,
   EndpointFailure: () => EndpointFailure,
+  FARM_API_ROUTE_META_SYMBOL: () => FARM_API_ROUTE_META_SYMBOL,
   FARM_API_ROUTE_REF_SYMBOL: () => FARM_API_ROUTE_REF_SYMBOL,
   FARM_CRON_MANIFEST: () => FARM_CRON_MANIFEST,
   FARM_DEFERRED_BRAND: () => FARM_DEFERRED_BRAND,
@@ -28067,6 +29229,7 @@ __export(src_exports, {
   _withAfterNodeMiddleware: () => _withAfterNodeMiddleware,
   after: () => after,
   api: () => api,
+  applyFarmCacheInvalidationTargets: () => applyFarmCacheInvalidationTargets,
   applyFarmCacheInvalidations: () => applyFarmCacheInvalidations,
   applyFarmCronVercelCrons: () => applyFarmCronVercelCrons,
   applyFarmWorkflowVercelCrons: () => applyFarmWorkflowVercelCrons,
@@ -28084,6 +29247,7 @@ __export(src_exports, {
   buildFarmRoutePath: () => buildFarmRoutePath,
   collectSSGPages: () => collectSSGPages,
   completeFarmServerQueryAction: () => completeFarmServerQueryAction,
+  configureFarmCache: () => configureFarmCache,
   configureFarmObservability: () => configureFarmObservability,
   cookies: () => cookies,
   createAPIClient: () => createAPIClient,
@@ -28183,6 +29347,7 @@ __export(src_exports, {
   generateFarmTypeArtifacts: () => generateFarmTypeArtifacts,
   generateRouteTypes: () => generateRouteTypes,
   generateSSGManifest: () => generateSSGManifest,
+  getAPIRouteRefMetadata: () => getAPIRouteRefMetadata,
   getCurrentRequest: () => getCurrentRequest,
   getDeployTargetForPreset: () => getDeployTargetForPreset,
   getEnv: () => getEnv,
@@ -28242,6 +29407,7 @@ __export(src_exports, {
   isCronRequestAuthorized: () => isCronRequestAuthorized,
   isDeferred: () => isDeferred,
   isEndpointFailure: () => isEndpointFailure,
+  isFarmAPIStream: () => isFarmAPIStream,
   isFarmDeploymentMismatchResponse: () => isFarmDeploymentMismatchResponse,
   isFarmDocsAPIRequest: () => isFarmDocsAPIRequest,
   isFarmDocsRequest: () => isFarmDocsRequest,
@@ -28250,10 +29416,13 @@ __export(src_exports, {
   isFarmNotFoundError: () => isFarmNotFoundError,
   isFarmRedirectError: () => isFarmRedirectError,
   isFarmRouteActive: () => isFarmRouteActive,
+  isJSONStreamResponse: () => isJSONStreamResponse,
+  isMultipartSchema: () => isMultipartSchema,
   isProgrammaticRouteManifest: () => isProgrammaticRouteManifest,
   isProgrammaticRoutesFileName: () => isProgrammaticRoutesFileName,
   isSSGModule: () => isSSGModule,
   isWebResponse: () => isWebResponse2,
+  jsonStream: () => jsonStream,
   layout: () => layout,
   libsqlStorage: () => libsqlStorage,
   loadConfig: () => loadConfig,
@@ -28273,6 +29442,7 @@ __export(src_exports, {
   mergeScheduledTasks: () => mergeScheduledTasks,
   middleware: () => middleware,
   mongodbStorage: () => mongodbStorage,
+  multipart: () => multipart,
   mysql2Storage: () => mysql2Storage,
   mysqlStorage: () => mysqlStorage,
   navigateTo: () => navigateTo,
@@ -28309,6 +29479,7 @@ __export(src_exports, {
   publicEnv: () => publicEnv,
   pushState: () => pushState,
   readDeferredDataResponse: () => readDeferredDataResponse,
+  readJSONStream: () => readJSONStream,
   readPageState: () => readPageState,
   redirect: () => redirect2,
   redisStorage: () => redisStorage,
@@ -28353,13 +29524,16 @@ __export(src_exports, {
   setEnv: () => setEnv,
   snapshotDeferredData: () => snapshotDeferredData,
   sqliteStorage: () => sqliteStorage,
+  storageCacheAdapter: () => storageCacheAdapter,
   titleFromMarkdown: () => titleFromMarkdown,
+  toFormData: () => toFormData,
   toViteModuleId: () => toViteModuleId,
   unstable_cache: () => unstable_cache,
   unwrapMiddleware: () => unwrapMiddleware,
   updateTag: () => updateTag,
   upstashStorage: () => upstashStorage,
   useBlocker: () => useBlocker,
+  useFetcher: () => useFetcher,
   useMutation: () => useMutation,
   useNavigation: () => useNavigation,
   usePageState: () => usePageState,
@@ -29540,7 +30714,9 @@ __name(normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
 
 // src/api/client.ts
 init_cache_invalidation();
+init_transport();
 var FARM_API_ROUTE_REF_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-ref");
+var FARM_API_ROUTE_META_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-meta");
 var _APIClientError = class _APIClientError extends Error {
   constructor(code, data, options) {
     super(options.message);
@@ -29578,16 +30754,22 @@ function createAPIClient(options = {}) {
         }
       });
     }
+    const headers2 = {
+      "Content-Type": "application/json",
+      ...options.headers,
+      ...requestOptions.headers
+    };
     const fetchOptions = {
       method: requestOptions.method || "GET",
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers,
-        ...requestOptions.headers
-      }
+      headers: headers2
     };
-    if (requestOptions.body) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
+    if (requestOptions.body !== void 0) {
+      if (isFormData(requestOptions.body)) {
+        deleteHeader(headers2, "content-type");
+        fetchOptions.body = requestOptions.body;
+      } else {
+        fetchOptions.body = JSON.stringify(requestOptions.body);
+      }
     }
     const response = await fetch(url.toString(), fetchOptions);
     applyFarmCacheInvalidations(
@@ -29595,7 +30777,7 @@ function createAPIClient(options = {}) {
     );
     let data = void 0;
     if (response.status !== 204 && response.status !== 205) {
-      data = await response.json();
+      data = isJSONStreamResponse(response) ? readJSONStream(response) : await response.json();
     }
     return { response, data };
   }, "fetchClient");
@@ -29741,16 +30923,16 @@ function createAPIClient(options = {}) {
             }
           }
           attempt += 1;
-          const delay = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
-          if (delay > 0) {
-            await new Promise((resolve5) => setTimeout(resolve5, delay));
+          const delay2 = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
+          if (delay2 > 0) {
+            await new Promise((resolve5) => setTimeout(resolve5, delay2));
           }
         }
       })();
       inflightState.set(cacheKey, { promise, startedAt: now2 });
       try {
         const result2 = await promise;
-        if (!result2.error && isCacheEnabled) {
+        if (!result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
           const updatedAt = Date.now();
           cacheState.set(cacheKey, {
             data: result2.data,
@@ -29823,10 +31005,17 @@ function createAPIClient(options = {}) {
     clientOptions?.onSettled?.(result.data, result.error);
     return result;
   }, "request");
-  return createNestedProxy([], request, routeMeta, baseURL, rootAliases);
+  return createNestedProxy(
+    [],
+    request,
+    routeMeta,
+    baseURL,
+    options.baseURL === void 0,
+    rootAliases
+  );
 }
 __name(createAPIClient, "createAPIClient");
-function createNestedProxy(path28, client, routeMeta, baseURL, rootAliases) {
+function createNestedProxy(path28, client, routeMeta, baseURL, sameOrigin, rootAliases) {
   const target = /* @__PURE__ */ __name(() => {
   }, "target");
   const proxy = new Proxy(target, {
@@ -29835,13 +31024,29 @@ function createNestedProxy(path28, client, routeMeta, baseURL, rootAliases) {
       if (prop === FARM_API_ROUTE_REF_SYMBOL) {
         return path28.length > 0;
       }
+      if (prop === FARM_API_ROUTE_META_SYMBOL) {
+        const metadata = resolveRouteMeta({ path: path28, baseURL });
+        return Object.freeze({
+          path: metadata.routePath,
+          method: metadata.method,
+          baseURL,
+          sameOrigin
+        });
+      }
       if (path28.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
         return rootAliases[prop];
       }
       if (typeof prop !== "string") {
         return Reflect.get(_target, prop);
       }
-      return createNestedProxy([...path28, prop], client, routeMeta, baseURL, rootAliases);
+      return createNestedProxy(
+        [...path28, prop],
+        client,
+        routeMeta,
+        baseURL,
+        sameOrigin,
+        rootAliases
+      );
     },
     // When calling as a function
     apply(_target, _thisArg, args) {
@@ -29867,6 +31072,22 @@ function isAPIRouteRef(value) {
   return typeof value === "function" && value[FARM_API_ROUTE_REF_SYMBOL] === true;
 }
 __name(isAPIRouteRef, "isAPIRouteRef");
+function getAPIRouteRefMetadata(value) {
+  if (!isAPIRouteRef(value)) return null;
+  const metadata = value[FARM_API_ROUTE_META_SYMBOL];
+  if (!metadata || typeof metadata !== "object") return null;
+  const candidate = metadata;
+  if (typeof candidate.path !== "string" || typeof candidate.method !== "string" || typeof candidate.baseURL !== "string" || typeof candidate.sameOrigin !== "boolean") {
+    return null;
+  }
+  return {
+    path: candidate.path,
+    method: candidate.method,
+    baseURL: candidate.baseURL,
+    sameOrigin: candidate.sameOrigin
+  };
+}
+__name(getAPIRouteRefMetadata, "getAPIRouteRefMetadata");
 function createServerAPIClient(endpoints, options = {}) {
   if (options.integrations === false || Object.prototype.hasOwnProperty.call(endpoints, "integrations")) {
     return endpoints;
@@ -29971,6 +31192,17 @@ function normalizeError(error) {
   return normalized;
 }
 __name(normalizeError, "normalizeError");
+function isFormData(value) {
+  return typeof value === "object" && value !== null && (typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function");
+}
+__name(isFormData, "isFormData");
+function deleteHeader(headers2, name) {
+  const normalized = name.toLowerCase();
+  for (const key of Object.keys(headers2)) {
+    if (key.toLowerCase() === normalized) delete headers2[key];
+  }
+}
+__name(deleteHeader, "deleteHeader");
 function createResponseError2(response, data) {
   const expected = readEndpointErrorEnvelope(data);
   if (expected) {
@@ -30002,6 +31234,9 @@ function readEndpointErrorEnvelope(data) {
 }
 __name(readEndpointErrorEnvelope, "readEndpointErrorEnvelope");
 
+// src/api/index.ts
+init_transport();
+
 // src/api/vite-plugin.ts
 init_route_manager2();
 init_response();
@@ -31728,6 +32963,7 @@ init_image_types();
 // src/server-fn.ts
 init_server_action_security();
 init_request_bridge();
+init_cache();
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerMiddleware(options) {
@@ -31751,8 +32987,8 @@ function createServerFn(options) {
   }
   const middleware2 = resolveServerFnMiddleware(options.middleware);
   const serverFn = /* @__PURE__ */ __name(async (value) => {
-    const formData = isFormData(value) ? value : void 0;
-    const rawInput = formData ? formDataToObject(formData) : value;
+    const formData = isFormData2(value) ? value : void 0;
+    const rawInput = formData ? formDataToObject2(formData) : value;
     const input = await _parseServerFnSchema(options.input, rawInput, "input");
     const executionContext = getServerActionExecutionContext();
     const request = executionContext?.request ?? _resolveCurrentRequest();
@@ -31764,8 +33000,21 @@ function createServerFn(options) {
       request,
       signal
     };
-    const result = await runServerFnMiddleware(middleware2, handlerContext, options.handler);
-    return _parseServerFnSchema(options.output, result, "output");
+    let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const result = await runServerFnMiddleware(middleware2, handlerContext, async (context) => {
+      resolvedContext = context.context;
+      return options.handler(context);
+    });
+    const parsedResult = await _parseServerFnSchema(options.output, result, "output");
+    if (options.invalidates) {
+      const declaration = typeof options.invalidates === "function" ? await options.invalidates({
+        ...handlerContext,
+        context: resolvedContext,
+        result: parsedResult
+      }) : options.invalidates;
+      await applyFarmCacheInvalidationTargets(declaration);
+    }
+    return parsedResult;
   }, "serverFn");
   Object.defineProperties(serverFn, {
     [FARM_SERVER_FN_SYMBOL]: {
@@ -31787,6 +33036,10 @@ function createServerFn(options) {
     __farmServerFnMiddleware: {
       value: middleware2,
       enumerable: false
+    },
+    __farmServerFnInvalidates: {
+      value: options.invalidates,
+      enumerable: false
     }
   });
   return serverFn;
@@ -31884,7 +33137,7 @@ function unwrapSafeParseResult(result) {
   return result;
 }
 __name(unwrapSafeParseResult, "unwrapSafeParseResult");
-function formDataToObject(formData) {
+function formDataToObject2(formData) {
   const output = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of formData.entries()) {
     if (!isSafeFormKey(key)) continue;
@@ -31899,19 +33152,19 @@ function formDataToObject(formData) {
   }
   return output;
 }
-__name(formDataToObject, "formDataToObject");
+__name(formDataToObject2, "formDataToObject");
 function isSafeFormKey(key) {
   return !key.startsWith("$ACTION_") && !UNSAFE_FORM_KEYS.has(key);
 }
 __name(isSafeFormKey, "isSafeFormKey");
-function isFormData(value) {
+function isFormData2(value) {
   if (!value || typeof value !== "object") return false;
   if (typeof FormData !== "undefined" && value instanceof FormData) {
     return true;
   }
   return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
 }
-__name(isFormData, "isFormData");
+__name(isFormData2, "isFormData");
 
 // src/server-fn-client.ts
 var import_react7 = require("react");
@@ -31946,7 +33199,7 @@ function useServerFn(serverFn, options = {}) {
   const submit = (0, import_react7.useCallback)(
     async (input) => {
       const requestId = ++requestIdRef.current;
-      const formData = isFormData2(input) ? input : void 0;
+      const formData = isFormData3(input) ? input : void 0;
       const previousResult = stateRef.current.result;
       const optimisticResult = options.optimistic?.({
         input,
@@ -32054,14 +33307,14 @@ function normalizeServerFnError(error) {
   return normalized;
 }
 __name(normalizeServerFnError, "normalizeServerFnError");
-function isFormData2(value) {
+function isFormData3(value) {
   if (!value || typeof value !== "object") return false;
   if (typeof FormData !== "undefined" && value instanceof FormData) {
     return true;
   }
   return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
 }
-__name(isFormData2, "isFormData");
+__name(isFormData3, "isFormData");
 
 // src/server-query.ts
 init_cache();
@@ -32121,7 +33374,7 @@ function createServerQuery(options) {
           tags: [createRouteDataCacheTag(routeKey)],
           revalidate: staleTime === false ? false : Math.max(1, Math.ceil(staleTime / 1e3))
         });
-        updatedAt = cache.getEntry(cacheKey, { allowStale: true })?.createdAt ?? Date.now();
+        updatedAt = (await cache.getEntryAsync(cacheKey, { allowStale: true }))?.createdAt ?? Date.now();
       }
       return createFarmServerQueryResult(data, {
         key: clientKey,
@@ -33151,6 +34404,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 fs9 = await import("fs/promises");
     const layoutRoutes = [];
@@ -33194,7 +34459,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,
@@ -33205,7 +34479,8 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         serverRenderer,
         preset,
         pageRoutes,
-        layoutRoutes
+        layoutRoutes,
+        routeSlots
       )
     ]);
     const [routeRuntimeManifestResult] = await routeRuntimeManifestResultPromise;
@@ -33225,7 +34500,8 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
         srcDir,
         clientOutputDir,
         pageRoutes,
-        layoutRoutes
+        layoutRoutes,
+        routeSlots
       );
     }
     const ssrResult = ssrBuildResult.value;
@@ -33328,7 +34604,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));
@@ -33355,8 +34631,16 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
       logger.warn(`\u26A0\uFE0F  Could not inspect route file ${route2.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 fs9.mkdir(clientEntryRoot, { recursive: true });
@@ -33365,6 +34649,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
   const clientHydrationCode = generateClientHydrationEntry(
     clientPages,
     layoutRoutes,
+    clientRouteSlots,
     root,
     srcDir,
     isFarmDocsSearchEnabled(config.docs),
@@ -33697,7 +34982,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",
@@ -33765,7 +35050,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}
@@ -34015,11 +35300,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}
@@ -34041,6 +35340,10 @@ const clientRoutes = [
 ${routeEntries.join(",\n")}
 ];
 
+const clientRouteSlots = [
+${routeSlotEntries.join(",\n")}
+];
+
 // Layout routes for wrapping client components
 const layoutRoutes = [
 ${layoutRegistrations.join(",\n")}
@@ -34095,6 +35398,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;
@@ -34113,12 +35556,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;
@@ -34132,7 +35580,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({
@@ -34197,6 +35647,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;
@@ -34273,21 +35774,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");
@@ -34312,7 +35820,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);
@@ -34324,13 +35835,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;
   },
@@ -34339,6 +35852,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)) {
@@ -34372,10 +35886,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() {});
   },
   
@@ -34466,7 +35982,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));
@@ -34499,6 +36015,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   let ssrEntryFile;
   const pageRoutes = collectedPageRoutes.map((route2) => ({ ...route2 }));
   const layoutRoutes = collectedLayoutRoutes.map((route2) => ({ ...route2 }));
+  const routeSlots = collectedRouteSlots.map((slot) => ({ ...slot }));
   const metadataImageRoutes = [];
   for (const entry of routeManager.getMetadataImages().values()) {
     if (entry.sourceType === "static") {
@@ -34599,6 +36116,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     apiRoutes,
     pageRoutes,
     layoutRoutes,
+    routeSlots,
     errorRoutes,
     metadataImageRoutes,
     middlewareRoutes,
@@ -34769,10 +36287,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;
@@ -34816,10 +36338,12 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
       return;
     }
     pageImports.push(`import * as ${varName} from "${route2.modulePath}";`);
+    const shouldHydrate = getClientModuleMetadata(route2.modulePath, config.root).shouldHydrate;
     pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route2.pattern)},
     module: ${varName},
+    shouldHydrate: ${JSON.stringify(shouldHydrate)},
   }`);
   });
   const layoutImports = [];
@@ -34833,6 +36357,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) => {
@@ -34883,6 +36423,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, errorRout
   _runWithMiddlewareData,
   addMetadataImageReference,
   applyProductionMiddlewareHeaders,
+  configureFarmCache,
   configureFarmObservability,
   createFarmCacheKey,
   createFarmLocaleCookie,
@@ -34985,6 +36526,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")}
@@ -35062,6 +36604,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);" : ""}
@@ -35119,6 +36662,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(",")}
 ];
@@ -35153,18 +36699,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) {
@@ -35914,6 +37463,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)) {
@@ -36064,6 +37686,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";
@@ -36117,8 +37740,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;
   }
@@ -36333,7 +37956,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({
@@ -36361,6 +37984,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
@@ -36448,6 +38075,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
@@ -36475,6 +38178,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;
@@ -36482,9 +38193,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,
                 });
               }
             }
@@ -36536,6 +38261,7 @@ async function handleFarmRequestInContext(
         );
         const hasRequestScopedRender = Boolean(
           pageStatus >= 400 ||
+          request.headers.get("x-farm-intercept-from") ||
           hasPrivateRequestHeaders ||
           hasConfiguredRouteContext ||
           middlewareData?.size ||
@@ -36575,7 +38301,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(
@@ -36632,7 +38361,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>',
             );
           
@@ -36653,7 +38385,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>\`;
@@ -36661,7 +38393,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 },
             {
@@ -37854,6 +39586,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,
@@ -38400,11 +40139,174 @@ function normalizeMutationError(error) {
 }
 __name(normalizeMutationError, "normalizeMutationError");
 
+// src/fetcher-client.tsx
+var import_react10 = require("react");
+var formDataContexts = /* @__PURE__ */ new WeakMap();
+function useFetcher(target, options = {}) {
+  const targetRef = (0, import_react10.useRef)(target);
+  const optionsRef = (0, import_react10.useRef)(options);
+  const submissionIdRef = (0, import_react10.useRef)(0);
+  const [formData, setFormData] = (0, import_react10.useState)(null);
+  const mutation = useMutation(target, options);
+  targetRef.current = target;
+  optionsRef.current = options;
+  const submitAsync = (0, import_react10.useCallback)(
+    async (input) => {
+      const submissionId = ++submissionIdRef.current;
+      const submittedFormData = isFormData4(input) ? input : null;
+      setFormData(submittedFormData);
+      try {
+        const variables = submittedFormData ? mapFetcherFormData(targetRef.current, submittedFormData, optionsRef.current) : input;
+        return await mutation.mutateAsync(variables);
+      } finally {
+        if (submissionId === submissionIdRef.current) {
+          setFormData(null);
+        }
+      }
+    },
+    [mutation.mutateAsync]
+  );
+  const submit = (0, import_react10.useCallback)(
+    (input) => {
+      void submitAsync(input).catch(() => {
+      });
+    },
+    [submitAsync]
+  );
+  const Form = (0, import_react10.useMemo)(() => {
+    const FetcherForm = /* @__PURE__ */ __name(({ action, method, encType, onSubmit, ...props }) => {
+      const targetValue = targetRef.current;
+      const metadata = getAPIRouteRefMetadata(targetValue);
+      const nativeAction = action ?? resolveFetcherFormAction(targetValue, metadata);
+      const nativeMethod = method ?? (metadata && (metadata.method === "GET" || metadata.method === "POST") ? metadata.method.toLowerCase() : metadata ? "post" : void 0);
+      const functionAction = typeof nativeAction === "function";
+      const handleSubmit = /* @__PURE__ */ __name((event) => {
+        onSubmit?.(event);
+        if (event.defaultPrevented) return;
+        event.preventDefault();
+        const submitter = getSubmitter(event);
+        const nextFormData = createSubmitterFormData(event.currentTarget, submitter);
+        formDataContexts.set(nextFormData, {
+          form: event.currentTarget,
+          submitter
+        });
+        void submitAsync(nextFormData).catch(() => {
+        });
+      }, "handleSubmit");
+      return (0, import_react10.createElement)("form", {
+        ...props,
+        action: nativeAction,
+        method: functionAction ? void 0 : nativeMethod,
+        encType: functionAction ? void 0 : encType,
+        onSubmit: handleSubmit
+      });
+    }, "FetcherForm");
+    FetcherForm.displayName = "FetcherForm";
+    return FetcherForm;
+  }, [submitAsync]);
+  const reset = (0, import_react10.useCallback)(() => {
+    submissionIdRef.current += 1;
+    setFormData(null);
+    mutation.reset();
+  }, [mutation.reset]);
+  return (0, import_react10.useMemo)(
+    () => ({
+      state: mutation.pending ? "submitting" : "idle",
+      status: mutation.status,
+      pending: mutation.pending,
+      data: mutation.data,
+      error: mutation.error,
+      variables: mutation.variables,
+      formData,
+      submit,
+      submitAsync,
+      Form,
+      reset
+    }),
+    [
+      Form,
+      formData,
+      mutation.data,
+      mutation.error,
+      mutation.pending,
+      mutation.status,
+      mutation.variables,
+      reset,
+      submit,
+      submitAsync
+    ]
+  );
+}
+__name(useFetcher, "useFetcher");
+function mapFetcherFormData(target, formData, options) {
+  const context = formDataContexts.get(formData) ?? { form: null, submitter: null };
+  if (options.mapFormData) {
+    return options.mapFormData(formData, context);
+  }
+  if (!isAPIRouteRef(target)) {
+    return formData;
+  }
+  const values = formDataToObject3(formData);
+  const method = getAPIRouteRefMetadata(target)?.method;
+  return method === "GET" || method === "HEAD" ? { query: values } : { body: values };
+}
+__name(mapFetcherFormData, "mapFetcherFormData");
+function resolveFetcherFormAction(target, metadata) {
+  if (!metadata) return isProgressiveFormAction(target) ? target : void 0;
+  if (metadata.sameOrigin) return metadata.path;
+  return new URL(metadata.path, metadata.baseURL).href;
+}
+__name(resolveFetcherFormAction, "resolveFetcherFormAction");
+function formDataToObject3(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.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;
+}
+__name(formDataToObject3, "formDataToObject");
+function createSubmitterFormData(form, submitter) {
+  try {
+    return new FormData(form, submitter);
+  } catch {
+    const formData = new FormData(form);
+    const candidate = submitter;
+    if (candidate && !candidate.disabled && candidate.name) {
+      formData.append(candidate.name, candidate.value ?? "");
+    }
+    return formData;
+  }
+}
+__name(createSubmitterFormData, "createSubmitterFormData");
+function getSubmitter(event) {
+  const nativeEvent = event.nativeEvent;
+  return nativeEvent.submitter instanceof HTMLElement ? nativeEvent.submitter : null;
+}
+__name(getSubmitter, "getSubmitter");
+function isProgressiveFormAction(target) {
+  const candidate = target;
+  return candidate.__farmServerFn === true || typeof candidate.$$FORM_ACTION === "function" || candidate.$$typeof === /* @__PURE__ */ Symbol.for("react.server.reference");
+}
+__name(isProgressiveFormAction, "isProgressiveFormAction");
+function isFormData4(value) {
+  if (!value || typeof value !== "object") return false;
+  return typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+__name(isFormData4, "isFormData");
+
 // src/client.ts
 init_integration_api();
 
 // src/store.ts
-var import_react10 = require("react");
+var import_react11 = require("react");
 var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
   "use",
   "get",
@@ -38536,20 +40438,20 @@ function createStore(initialState, extend) {
         }
         return lastSlice;
       }, "getSnapshot");
-      return (0, import_react10.useSyncExternalStore)(
+      return (0, import_react11.useSyncExternalStore)(
         (notify) => addSubscription(keys, () => notify()),
         getSnapshot,
         getSnapshot
       );
     }
     if (typeof keyOrKeys === "string") {
-      return (0, import_react10.useSyncExternalStore)(
+      return (0, import_react11.useSyncExternalStore)(
         (notify) => addSubscription([keyOrKeys], () => notify()),
         () => state[keyOrKeys],
         () => state[keyOrKeys]
       );
     }
-    return (0, import_react10.useSyncExternalStore)(
+    return (0, import_react11.useSyncExternalStore)(
       (notify) => addSubscription(null, () => notify()),
       () => state,
       () => state
@@ -38601,7 +40503,7 @@ function createStore(initialState, extend) {
 __name(createStore, "createStore");
 
 // src/client/link.tsx
-var import_react11 = require("react");
+var import_react12 = require("react");
 init_router();
 init_client_runtime();
 var import_jsx_runtime4 = require("react/jsx-runtime");
@@ -38663,9 +40565,9 @@ function LinkInner({
   onTouchStart,
   ...props
 }, ref) {
-  const elementRef = (0, import_react11.useRef)(null);
-  const intentTimeoutRef = (0, import_react11.useRef)(null);
-  const hasPrefetched = (0, import_react11.useRef)(false);
+  const elementRef = (0, import_react12.useRef)(null);
+  const intentTimeoutRef = (0, import_react12.useRef)(null);
+  const hasPrefetched = (0, import_react12.useRef)(false);
   const { intent, viewport, render } = normalizePrefetch(prefetch2);
   const baseHref = resolveLinkHref(href, params, {
     query,
@@ -38674,17 +40576,17 @@ function LinkInner({
   });
   const resolvedHref = localizeActiveFarmHref(baseHref, locale);
   const isExternal = isExternalUrl(resolvedHref);
-  const doPrefetch = (0, import_react11.useCallback)(() => {
+  const doPrefetch = (0, import_react12.useCallback)(() => {
     if (isExternal || hasPrefetched.current) return;
     const router = getRouter2();
     if (!router) return;
     hasPrefetched.current = true;
     router.prefetch(resolvedHref);
   }, [resolvedHref, isExternal]);
-  (0, import_react11.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     hasPrefetched.current = false;
   }, [resolvedHref]);
-  (0, import_react11.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     const element = elementRef.current;
     if (!element || isExternal) return;
     const router = getRouter2();
@@ -38694,7 +40596,7 @@ function LinkInner({
       return () => router.unobserveForPrefetch(element);
     }
   }, [resolvedHref, viewport, isExternal]);
-  (0, import_react11.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     if (!render || isExternal) return;
     let cancelled = false;
     let timeoutId = null;
@@ -38716,7 +40618,7 @@ function LinkInner({
       }
     };
   }, [render, isExternal, resolvedHref]);
-  (0, import_react11.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     return () => {
       if (intentTimeoutRef.current) {
         clearTimeout(intentTimeoutRef.current);
@@ -38724,13 +40626,13 @@ function LinkInner({
       }
     };
   }, []);
-  const cancelIntent = (0, import_react11.useCallback)(() => {
+  const cancelIntent = (0, import_react12.useCallback)(() => {
     if (intentTimeoutRef.current) {
       clearTimeout(intentTimeoutRef.current);
       intentTimeoutRef.current = null;
     }
   }, []);
-  const scheduleIntentPrefetch = (0, import_react11.useCallback)(() => {
+  const scheduleIntentPrefetch = (0, import_react12.useCallback)(() => {
     if (isExternal || !intent || hasPrefetched.current) return;
     cancelIntent();
     intentTimeoutRef.current = setTimeout(() => {
@@ -38738,42 +40640,42 @@ function LinkInner({
       doPrefetch();
     }, prefetchDelay);
   }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
-  const handleMouseEnter = (0, import_react11.useCallback)(
+  const handleMouseEnter = (0, import_react12.useCallback)(
     (event) => {
       onMouseEnter?.(event);
       scheduleIntentPrefetch();
     },
     [onMouseEnter, scheduleIntentPrefetch]
   );
-  const handleMouseLeave = (0, import_react11.useCallback)(
+  const handleMouseLeave = (0, import_react12.useCallback)(
     (event) => {
       onMouseLeave?.(event);
       cancelIntent();
     },
     [onMouseLeave, cancelIntent]
   );
-  const handleTouchStart = (0, import_react11.useCallback)(
+  const handleTouchStart = (0, import_react12.useCallback)(
     (event) => {
       onTouchStart?.(event);
       scheduleIntentPrefetch();
     },
     [onTouchStart, scheduleIntentPrefetch]
   );
-  const handleFocus = (0, import_react11.useCallback)(
+  const handleFocus = (0, import_react12.useCallback)(
     (event) => {
       onFocus?.(event);
       scheduleIntentPrefetch();
     },
     [onFocus, scheduleIntentPrefetch]
   );
-  const handleBlur = (0, import_react11.useCallback)(
+  const handleBlur = (0, import_react12.useCallback)(
     (event) => {
       onBlur?.(event);
       cancelIntent();
     },
     [onBlur, cancelIntent]
   );
-  const handleClick = (0, import_react11.useCallback)(
+  const handleClick = (0, import_react12.useCallback)(
     (event) => {
       onClick?.(event);
       if (event.defaultPrevented) return;
@@ -38798,7 +40700,7 @@ function LinkInner({
     },
     [resolvedHref, replace, scroll, viewTransition, target, isExternal, onClick]
   );
-  const setRefs = (0, import_react11.useCallback)(
+  const setRefs = (0, import_react12.useCallback)(
     (node) => {
       elementRef.current = node;
       if (typeof ref === "function") ref(node);
@@ -38827,7 +40729,7 @@ function LinkInner({
   );
 }
 __name(LinkInner, "LinkInner");
-var LinkWithRef = (0, import_react11.forwardRef)(LinkInner);
+var LinkWithRef = (0, import_react12.forwardRef)(LinkInner);
 LinkWithRef.displayName = "Link";
 var Link = LinkWithRef;
 function resolveLinkHref(href, params, options) {
@@ -39553,6 +41455,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   DeferredDataError,
   DocsRoute,
   EndpointFailure,
+  FARM_API_ROUTE_META_SYMBOL,
   FARM_API_ROUTE_REF_SYMBOL,
   FARM_CRON_MANIFEST,
   FARM_DEFERRED_BRAND,
@@ -39597,6 +41500,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   _withAfterNodeMiddleware,
   after,
   api,
+  applyFarmCacheInvalidationTargets,
   applyFarmCacheInvalidations,
   applyFarmCronVercelCrons,
   applyFarmWorkflowVercelCrons,
@@ -39614,6 +41518,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   buildFarmRoutePath,
   collectSSGPages,
   completeFarmServerQueryAction,
+  configureFarmCache,
   configureFarmObservability,
   cookies,
   createAPIClient,
@@ -39713,6 +41618,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   generateFarmTypeArtifacts,
   generateRouteTypes,
   generateSSGManifest,
+  getAPIRouteRefMetadata,
   getCurrentRequest,
   getDeployTargetForPreset,
   getEnv,
@@ -39772,6 +41678,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   isCronRequestAuthorized,
   isDeferred,
   isEndpointFailure,
+  isFarmAPIStream,
   isFarmDeploymentMismatchResponse,
   isFarmDocsAPIRequest,
   isFarmDocsRequest,
@@ -39780,10 +41687,13 @@ __name(decodeCookiePart, "decodeCookiePart");
   isFarmNotFoundError,
   isFarmRedirectError,
   isFarmRouteActive,
+  isJSONStreamResponse,
+  isMultipartSchema,
   isProgrammaticRouteManifest,
   isProgrammaticRoutesFileName,
   isSSGModule,
   isWebResponse,
+  jsonStream,
   layout,
   libsqlStorage,
   loadConfig,
@@ -39803,6 +41713,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   mergeScheduledTasks,
   middleware,
   mongodbStorage,
+  multipart,
   mysql2Storage,
   mysqlStorage,
   navigateTo,
@@ -39839,6 +41750,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   publicEnv,
   pushState,
   readDeferredDataResponse,
+  readJSONStream,
   readPageState,
   redirect,
   redisStorage,
@@ -39883,13 +41795,16 @@ __name(decodeCookiePart, "decodeCookiePart");
   setEnv,
   snapshotDeferredData,
   sqliteStorage,
+  storageCacheAdapter,
   titleFromMarkdown,
+  toFormData,
   toViteModuleId,
   unstable_cache,
   unwrapMiddleware,
   updateTag,
   upstashStorage,
   useBlocker,
+  useFetcher,
   useMutation,
   useNavigation,
   usePageState,