@farm.js/core 0.1.16 → 0.1.17

package/dist/server.cjs

@@ -152,8 +152,16 @@ async function createMarkdownMirrorResponse(options) {
   if (!hasMarkdownExtension) {
     headersOut.set("Vary", "Accept");
   }
+  for (const token of pageResponse.headers.get("vary")?.split(",") ?? []) {
+    const name2 = token.trim();
+    if (name2 && name2.toLowerCase() !== "accept") appendHeaderToken(headersOut, "Vary", name2);
+  }
+  const pageCacheControl = pageResponse.headers.get("cache-control");
   const cache = target.route?.cache ?? options.config?.cache ?? false;
-  headersOut.set("Cache-Control", createMarkdownCacheHeader(cache));
+  headersOut.set(
+    "Cache-Control",
+    pageCacheControl && isPrivateCacheControl(pageCacheControl) ? pageCacheControl : createMarkdownCacheHeader(cache)
+  );
   return new Response(options.request.method === "HEAD" ? null : markdown, {
     status: pageResponse.status,
     headers: headersOut
@@ -304,6 +312,17 @@ function isFarmMarkdownMirrorExposed(config, pathname) {
 function matchesFarmMarkdownRoutePattern(pattern, pathname) {
   return routeMatches(pattern, pathname);
 }
+function appendHeaderToken(headers, name2, token) {
+  const current = headers.get(name2);
+  if (!current) {
+    headers.set(name2, token);
+    return;
+  }
+  const tokens = current.split(",").map((value) => value.trim().toLowerCase());
+  if (!tokens.includes(token.toLowerCase())) {
+    headers.set(name2, `${current}, ${token}`);
+  }
+}
 function findExposedMarkdownRoute(config, pathname) {
   if (config.expose === true) {
     return null;
@@ -335,6 +354,12 @@ function isHtmlResponse(response) {
   const contentType = response.headers.get("content-type") ?? "";
   return contentType.includes("text/html");
 }
+function isPrivateCacheControl(value) {
+  return value.split(",").some((directive) => {
+    const name2 = directive.split("=", 1)[0].trim().toLowerCase();
+    return name2 === "private" || name2 === "no-store";
+  });
+}
 function createMarkdownCacheHeader(cache) {
   if (cache === false || cache <= 0) {
     return "no-store";
@@ -487,9 +512,11 @@ var init_markdown = __esm({
     __name(getFarmMarkdownAlternatePath, "getFarmMarkdownAlternatePath");
     __name(isFarmMarkdownMirrorExposed, "isFarmMarkdownMirrorExposed");
     __name(matchesFarmMarkdownRoutePattern, "matchesFarmMarkdownRoutePattern");
+    __name(appendHeaderToken, "appendHeaderToken");
     __name(findExposedMarkdownRoute, "findExposedMarkdownRoute");
     __name(routeMatches, "routeMatches");
     __name(isHtmlResponse, "isHtmlResponse");
+    __name(isPrivateCacheControl, "isPrivateCacheControl");
     __name(createMarkdownCacheHeader, "createMarkdownCacheHeader");
     __name(extractHtmlTitle, "extractHtmlTitle");
     __name(extractHtmlBody, "extractHtmlBody");
@@ -6149,6 +6176,8 @@ var init_cache = __esm({
       constructor(config = {}) {
         this.entries = /* @__PURE__ */ new Map();
         this.inflight = /* @__PURE__ */ new Map();
+        /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
+        this.entriesByTag = /* @__PURE__ */ new Map();
         this.invalidatedTagVersions = /* @__PURE__ */ new Map();
         this.activeGenerations = /* @__PURE__ */ new Set();
         this.version = 0;
@@ -6167,6 +6196,7 @@ var init_cache = __esm({
       configure(config = {}) {
         this.generation++;
         this.entries.clear();
+        this.entriesByTag.clear();
         this.inflight.clear();
         this.invalidatedTagVersions.clear();
         this.activeGenerations.clear();
@@ -6333,14 +6363,12 @@ var init_cache = __esm({
         return entry;
       }
       delete(key) {
-        const deleted = this.entries.delete(key);
-        if (deleted) this.pruneInvalidatedTagVersions();
+        const deleted = this.deleteLocalEntry(key);
         emitFarmEvent({ type: "cache.delete", key, deleted });
         return deleted;
       }
       async deleteAsync(key) {
-        const deleted = this.entries.delete(key);
-        if (deleted) this.pruneInvalidatedTagVersions();
+        const deleted = this.deleteLocalEntry(key);
         if (this.adapter) {
           await this.adapter.delete(this.createAdapterKey(key));
         }
@@ -6351,6 +6379,7 @@ var init_cache = __esm({
         const count = this.entries.size;
         this.generation++;
         this.entries.clear();
+        this.entriesByTag.clear();
         this.inflight.clear();
         this.invalidatedTagVersions.clear();
         this.activeGenerations.clear();
@@ -6436,23 +6465,32 @@ var init_cache = __esm({
           return cached.value;
         }
         const inflight = this.inflight.get(key);
-        if (inflight) {
+        if (inflight && !this.wasInvalidatedSince(inflight.tags, inflight.startVersion)) {
           emitFarmEvent({ type: "cache.dedupe", key });
-          return inflight;
+          return inflight.promise;
         }
         const tags = Array.from(normalizeCacheOptionsTags(options));
         const generation = this.generation;
+        const startVersion = this.version;
         const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
           emitFarmEvent({ type: "cache.error", key, operation: "set", error });
           throw error;
         }).finally(() => {
-          if (this.inflight.get(key) === promise) {
+          if (this.inflight.get(key)?.promise === promise) {
             this.inflight.delete(key);
           }
         });
-        this.inflight.set(key, promise);
+        this.inflight.set(key, { promise, tags, startVersion });
         return promise;
       }
+      /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
+      wasInvalidatedSince(tags, version2) {
+        for (const tag of tags) {
+          const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+          if (invalidatedVersion !== void 0 && invalidatedVersion > version2) return true;
+        }
+        return false;
+      }
       async fillCacheEntry(key, producer, options, tags, generation) {
         const adapter = this.adapter;
         const namespace = this.namespace;
@@ -6493,7 +6531,7 @@ var init_cache = __esm({
           return value;
         } finally {
           this.activeGenerations.delete(activeGeneration);
-          this.pruneInvalidatedTagVersions();
+          this.pruneInvalidatedTagVersions(activeGeneration.tags);
           if (leaseToken && adapter?.releaseLease) {
             try {
               await adapter.releaseLease(leaseKey, leaseToken);
@@ -6538,18 +6576,9 @@ var init_cache = __esm({
         }
         return void 0;
       }
-      countEntriesForTag(tag) {
-        let count = 0;
-        for (const entry of this.entries.values()) {
-          if (entry.tags.has(tag)) {
-            count++;
-          }
-        }
-        return count;
-      }
       countEntriesForTags(tags) {
         let count = 0;
-        for (const entry of this.entries.values()) {
+        for (const entry of this.entriesByTag.get(tags[0]) ?? []) {
           if (tags.every((tag) => entry.tags.has(tag))) {
             count++;
           }
@@ -6557,10 +6586,10 @@ var init_cache = __esm({
         return count;
       }
       invalidateTag(normalizedTag) {
-        const count = this.countEntriesForTag(normalizedTag);
+        const count = this.entriesByTag.get(normalizedTag)?.size ?? 0;
         this.invalidatedTagVersions.delete(normalizedTag);
         this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-        this.pruneInvalidatedTagVersions();
+        this.pruneInvalidatedTagVersions([normalizedTag]);
         return count;
       }
       toPublicEntry(entry) {
@@ -6590,19 +6619,51 @@ var init_cache = __esm({
         this.entries.set(key, entry);
       }
       storeLocalEntry(entry) {
-        this.entries.delete(entry.key);
+        const removed = [];
+        const replaced = this.detachLocalEntry(entry.key);
+        if (replaced) removed.push(replaced);
         this.entries.set(entry.key, entry);
+        for (const tag of entry.tags) {
+          let tagged = this.entriesByTag.get(tag);
+          if (!tagged) this.entriesByTag.set(tag, tagged = /* @__PURE__ */ new Set());
+          tagged.add(entry);
+        }
         while (this.entries.size > this.maxEntries) {
           const oldestKey = this.entries.keys().next().value;
           if (oldestKey === void 0) break;
-          this.entries.delete(oldestKey);
+          removed.push(this.detachLocalEntry(oldestKey));
         }
-        this.pruneInvalidatedTagVersions();
+        for (const removedEntry of removed) this.pruneInvalidatedTagVersions(removedEntry.tags);
+      }
+      deleteLocalEntry(key) {
+        const entry = this.detachLocalEntry(key);
+        if (!entry) return false;
+        this.pruneInvalidatedTagVersions(entry.tags);
+        return true;
+      }
+      detachLocalEntry(key) {
+        const entry = this.entries.get(key);
+        if (!entry) return void 0;
+        this.entries.delete(key);
+        for (const tag of entry.tags) {
+          const tagged = this.entriesByTag.get(tag);
+          if (!tagged) continue;
+          tagged.delete(entry);
+          if (tagged.size === 0) this.entriesByTag.delete(tag);
+        }
+        return entry;
       }
-      pruneInvalidatedTagVersions() {
-        tags: for (const [tag, invalidatedVersion] of this.invalidatedTagVersions) {
-          for (const entry of this.entries.values()) {
-            if (entry.tags.has(tag) && entry.createdVersion < invalidatedVersion) continue tags;
+      /**
+       * Drop invalidation versions that no local entry or active fill can be stale against.
+       * Callers pass only the tags whose dependents just changed, so the cost is bounded by
+       * the entries sharing those tags rather than by the whole cache.
+       */
+      pruneInvalidatedTagVersions(tags) {
+        tags: for (const tag of tags) {
+          const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+          if (invalidatedVersion === void 0) continue;
+          for (const entry of this.entriesByTag.get(tag) ?? []) {
+            if (entry.createdVersion < invalidatedVersion) continue tags;
           }
           for (const generation of this.activeGenerations) {
             if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)
@@ -7000,6 +7061,7 @@ function createProgrammaticPageComponent(route, rendererRuntime) {
     }
     return rendererRuntime.createElement(...args);
   }, "createElement");
+  const markFunctionComponent = /* @__PURE__ */ __name((component) => rendererRuntime?.markFunctionComponent?.(component) ?? component, "markFunctionComponent");
   const Component = route.component;
   if (route.pending) {
     const PendingComponent = route.pending;
@@ -7021,7 +7083,9 @@ function createProgrammaticPageComponent(route, rendererRuntime) {
         throw error;
       }
     }, "FarmProgrammaticPageContent");
-    const PageContent = FarmProgrammaticPageContent2;
+    const PageContent = markFunctionComponent(
+      FarmProgrammaticPageContent2
+    );
     const FarmProgrammaticPage = /* @__PURE__ */ __name(function FarmProgrammaticPage2(props) {
       return createElement2(
         rendererRuntime.Suspense,
@@ -7031,7 +7095,7 @@ function createProgrammaticPageComponent(route, rendererRuntime) {
         createElement2(PageContent, props)
       );
     }, "FarmProgrammaticPage");
-    return FarmProgrammaticPage;
+    return markFunctionComponent(FarmProgrammaticPage);
   }
   const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
     try {
@@ -7050,7 +7114,7 @@ function createProgrammaticPageComponent(route, rendererRuntime) {
       throw error;
     }
   }, "FarmProgrammaticPageContent");
-  return FarmProgrammaticPageContent;
+  return markFunctionComponent(FarmProgrammaticPageContent);
 }
 function readProgrammaticRouteProps(route, props, resources) {
   if (isProgrammaticRoutePropsResolved(props)) {
@@ -11976,10 +12040,12 @@ function createBundledEnv(env2, source = getProcessEnv()) {
   const server = {};
   const runtime3 = {};
   for (const [key, value] of Object.entries(resolved.server)) {
-    if (source[key] === void 0) {
-      server[key] = value;
+    const raw = source[key];
+    const type = getRuntimeEnvType(value);
+    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
+      runtime3[key] = type;
     } else {
-      runtime3[key] = getRuntimeEnvType(value);
+      server[key] = value;
     }
   }
   return {
@@ -12078,9 +12144,8 @@ function readServerEnvKey(server, key) {
 function readRuntimeServerEnv(env2) {
   const state = env2[FARM_ENV_RUNTIME_SYMBOL];
   if (!state) return;
-  const source = getProcessEnv();
   for (const [key, type] of Object.entries(state.pending)) {
-    const raw = source[key];
+    const raw = readFarmEnvironmentValue(key);
     if (raw === void 0) continue;
     env2.server[key] = coerceRuntimeEnvValue(raw, type);
     delete state.pending[key];
@@ -12111,6 +12176,22 @@ function coerceRuntimeEnvValue(raw, type) {
   }
   return raw;
 }
+function isSameEnvValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
+  }
+  if (!isPlainObject3(left) || !isPlainObject3(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
+  );
+}
+function isPlainObject3(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
 function prepareEnv(env2) {
   const normalized = normalizeResolvedEnv(env2);
   const runtime3 = env2.runtime?.server;
@@ -12186,6 +12267,7 @@ var FARM_ENV_SYMBOL, FARM_ENV_RUNTIME_SYMBOL, farmEnvGlobal, currentEnv, env, pu
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
+    init_runtime_env();
     FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
     FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
     farmEnvGlobal = globalThis;
@@ -12204,6 +12286,8 @@ var init_env = __esm({
     __name(readRuntimeServerEnv, "readRuntimeServerEnv");
     __name(getRuntimeEnvType, "getRuntimeEnvType");
     __name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+    __name(isSameEnvValue, "isSameEnvValue");
+    __name(isPlainObject3, "isPlainObject");
     __name(prepareEnv, "prepareEnv");
     __name(assertServerEnvAccess, "assertServerEnvAccess");
     __name(getInitialEnv, "getInitialEnv");
@@ -17481,6 +17565,7 @@ function createFarmDocsHandler(docs, options) {
     if (!isFarmDocsRequest(docs, request2)) return null;
     const page2 = loadPage(contentDir, docs, request2);
     if (!page2) return null;
+    const negotiatesAccept = !requestUrl.pathname.endsWith(".md");
     if (shouldReturnMarkdown(request2)) {
       const origin = new URL(request2.url).origin;
       return omitFarmDocsHeadBody(
@@ -17495,7 +17580,8 @@ function createFarmDocsHandler(docs, options) {
             status: 200,
             headers: {
               "Content-Type": "text/markdown; charset=utf-8",
-              "Cache-Control": "public, max-age=60"
+              "Cache-Control": "public, max-age=60",
+              ...negotiatesAccept ? { Vary: "Accept" } : {}
             }
           }
         )
@@ -17525,6 +17611,7 @@ function createFarmDocsHandler(docs, options) {
           headers: {
             "Content-Type": "text/html; charset=utf-8",
             "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
+            Vary: "Accept",
             ...fontPreloadHeader ? { Link: fontPreloadHeader } : {}
           }
         }
@@ -24134,7 +24221,7 @@ function resolveImportedModule(importerPath, specifier, root) {
     return { path: resolveImportedModuleSourcePath(importerPath, specifier, root), local: true };
   }
   const aliased = resolveProjectAliasSourcePath(specifier, root);
-  if (aliased !== void 0) return { path: aliased, local: true };
+  if (aliased) return { path: aliased, local: true };
   return { path: resolvePackageModuleSourcePath(importerPath, specifier, root), local: false };
 }
 __name(resolveImportedModule, "resolveImportedModule");
@@ -24150,11 +24237,12 @@ function resolveProjectAliasSourcePath(specifier, root) {
     if (!match || alias.prefix.length > match.alias.prefix.length) match = { alias, captured };
   }
   if (!match) return void 0;
-  return resolveSourceCandidate(
+  const resolved = resolveSourceCandidate(
     match.alias.targets.map(
       (target) => import_path4.default.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
     )
   );
+  return resolved && /\.d\.[cm]?ts$/.test(resolved) ? null : resolved;
 }
 __name(resolveProjectAliasSourcePath, "resolveProjectAliasSourcePath");
 function matchProjectImportAlias(alias, specifier) {
@@ -24561,6 +24649,7 @@ __name(readAltText, "readAltText");
 // src/routing/route-manager.ts
 init_route_runtime();
 init_routing();
+init_base_path();
 
 // src/redirect-query.ts
 function appendFarmRedirectQuery(destination, search) {
@@ -25637,7 +25726,7 @@ var _RouteManager = class _RouteManager {
   }
   toRoutePathname(pathname) {
     const i18n = this.getI18nConfig();
-    return i18n ? stripFarmLocaleFromPathname(pathname, i18n) : pathname;
+    return i18n ? stripFarmLocaleFromPathname(pathname, i18n) : stripFarmBasePath(pathname, this.config.basePath);
   }
   localizeRedirectDestination(destination, locale) {
     if (!locale || !destination.startsWith("/") || destination.startsWith("//")) {
@@ -29760,7 +29849,7 @@ _setFarmThemeServerSnapshotResolver(() => {
 });
 
 // package.json
-var version = "0.1.16";
+var version = "0.1.17";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -30050,7 +30139,7 @@ function createPPRRefreshScript() {
 __name(createPPRRefreshScript, "createPPRRefreshScript");
 function createPreHydrationClickQueueScript() {
   const selector = JSON.stringify(FARM_ISLAND_REPLAYABLE_SELECTOR);
-  return `<script>(function(){if(window.__FARM_PREHYDRATION_CLICK_QUEUE__)return;var queue=[];window.__FARM_PREHYDRATION_CLICK_QUEUE__=queue;window.__FARM_HYDRATED__=false;document.documentElement.dataset.farmHydrated="false";function isModified(event){return !!(event.metaKey||event.altKey||event.ctrlKey||event.shiftKey)}function inHydrated(node){return !!(node&&node.closest&&node.closest('[data-farm-island-hydrated="true"]'))}function closestQueuedTarget(target){while(target&&target!==document.documentElement){if(target.matches&&target.matches(${selector}))return target;target=target.parentElement}return null}function announce(target,kind){document.dispatchEvent(new CustomEvent("farm:island-interaction",{detail:{target:target,kind:kind||null}}))}function hold(event,target,kind){if(queue.some(function(item){return item.target===target}))return;queue.push({target:target,kind:kind,createdAt:Date.now()});announce(target,kind);event.preventDefault();event.stopImmediatePropagation()}document.addEventListener("click",function(event){if(window.__FARM_HYDRATED__)return;if(event.defaultPrevented||event.button!==0||isModified(event))return;var target=closestQueuedTarget(event.target);if(!target||target.closest&&target.closest("a[href]")||inHydrated(target))return;hold(event,target,"click")},true);document.addEventListener("submit",function(event){if(window.__FARM_HYDRATED__)return;if(event.defaultPrevented)return;var form=event.target;if(!form||form.nodeName!=="FORM"||inHydrated(form))return;hold(event,form,"submit")},true);function observe(event){if(window.__FARM_HYDRATED__)return;var target=event.target;if(!(target&&target.closest)||inHydrated(target))return;announce(target,null)}document.addEventListener("pointerdown",observe,true);document.addEventListener("focusin",observe,true);})();</script>`;
+  return `<script>(function(){if(window.__FARM_PREHYDRATION_CLICK_QUEUE__)return;var queue=[];window.__FARM_PREHYDRATION_CLICK_QUEUE__=queue;window.__FARM_HYDRATED__=false;document.documentElement.dataset.farmHydrated="false";function isModified(event){return !!(event.metaKey||event.altKey||event.ctrlKey||event.shiftKey)}function inHydrated(node){return !!(node&&node.closest&&node.closest('[data-farm-island-hydrated="true"]'))}function closestQueuedTarget(target){while(target&&target!==document.documentElement){if(target.matches&&target.matches(${selector}))return target;target=target.parentElement}return null}function announce(target,kind){document.dispatchEvent(new CustomEvent("farm:island-interaction",{detail:{target:target,kind:kind||null}}))}function hold(event,target,kind){if(!queue.some(function(item){return item.target===target})){queue.push({target:target,kind:kind,createdAt:Date.now()});announce(target,kind)}event.preventDefault();event.stopImmediatePropagation()}document.addEventListener("click",function(event){if(window.__FARM_HYDRATED__)return;if(event.defaultPrevented||event.button!==0||isModified(event))return;var target=closestQueuedTarget(event.target);if(!target||target.closest&&target.closest("a[href]")||inHydrated(target))return;hold(event,target,"click")},true);document.addEventListener("submit",function(event){if(window.__FARM_HYDRATED__)return;if(event.defaultPrevented)return;var form=event.target;if(!form||form.nodeName!=="FORM"||inHydrated(form))return;hold(event,form,"submit")},true);function observe(event){if(window.__FARM_HYDRATED__)return;var target=event.target;if(!(target&&target.closest)||inHydrated(target))return;announce(target,null)}document.addEventListener("pointerdown",observe,true);document.addEventListener("focusin",observe,true);})();</script>`;
 }
 __name(createPreHydrationClickQueueScript, "createPreHydrationClickQueueScript");
 function createDocumentFooter(options) {
@@ -34141,7 +34230,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     wrappedHandler
   );
   endpoint.__path = path41 || void 0;
-  endpoint.__method = options.method || "GET";
+  endpoint.__method = options.method || (path41 ? "GET" : void 0);
   endpoint.__autoPath = !path41;
   endpoint.__handler = wrappedHandler;
   endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
@@ -35729,7 +35818,7 @@ function parseColonParam(segment) {
   };
 }
 __name(parseColonParam, "parseColonParam");
-function compilePathPattern(pattern) {
+function compilePathPattern(pattern, trailingSlash = false) {
   const params = [];
   const segments = pattern.split("/").filter(Boolean);
   if (segments.length === 0) {
@@ -35765,11 +35854,18 @@ function compilePathPattern(pattern) {
   });
   return {
     kind: "path",
-    regex: new RegExp(`^${parts.join("")}$`),
+    regex: new RegExp(`^${parts.join("")}${trailingSlash ? "/?" : ""}$`),
     params
   };
 }
 __name(compilePathPattern, "compilePathPattern");
+function compileMatcherPattern(pattern) {
+  if (typeof pattern === "string" && pattern !== "*" && !pattern.endsWith("(.*)")) {
+    return compilePathPattern(pattern, true);
+  }
+  return compilePattern(pattern);
+}
+__name(compileMatcherPattern, "compileMatcherPattern");
 function compilePattern(pattern) {
   if (pattern instanceof RegExp) {
     return { kind: "regexp", regex: pattern };
@@ -35789,7 +35885,7 @@ __name(compilePattern, "compilePattern");
 function compileMiddlewareConfig(config) {
   const compiled = {
     matcher: config.matcher ? toMatcherList(config.matcher).map(
-      (matcher) => typeof matcher === "function" ? matcher : compilePattern(matcher)
+      (matcher) => typeof matcher === "function" ? matcher : compileMatcherPattern(matcher)
     ) : void 0,
     exclude: config.exclude?.map(compilePattern)
   };
@@ -37040,6 +37136,7 @@ __name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
 // src/vite.ts
 init_routes_shared();
 init_markdown();
+init_base_path();
 init_llms_txt();
 init_agent_crawlers();
 init_response();
@@ -38969,8 +39066,8 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "emitPluginError");
       farmApp = new FarmApp(
         {
-          root: server.config.root,
-          ...options
+          ...options,
+          root: resolveDevelopmentRoot(options.root, server.config.root)
         },
         server
       );
@@ -39557,7 +39654,8 @@ window.__FARM_MANIFEST__ = ${inlineValue({
               () => middlewareManager.execute(req, res)
             );
           }, "runAppMiddlewareForContentRoute");
-          if (openAPIManager && options.openapi?.specRoute && requestPathname === options.openapi.specRoute) {
+          const openAPIRequestPathname = openAPIManager ? stripFarmBasePath(requestPathname, farmConfig.basePath) : requestPathname;
+          if (openAPIManager && options.openapi?.specRoute && openAPIRequestPathname === options.openapi.specRoute) {
             if (await runAppMiddlewareForContentRoute()) return;
             if (requestMethod !== "GET" && requestMethod !== "HEAD") {
               res.statusCode = 405;
@@ -39574,7 +39672,7 @@ window.__FARM_MANIFEST__ = ${inlineValue({
             res.end(requestMethod === "HEAD" ? void 0 : body);
             return;
           }
-          if (openAPIManager && requestPathname === options.openapi?.route) {
+          if (openAPIManager && openAPIRequestPathname === options.openapi?.route) {
             if (await runAppMiddlewareForContentRoute()) return;
             const docsHandler = openAPIManager.getDocsRouteHandler(parsedRequestUrl.origin);
             return docsHandler(req, res);
@@ -40052,6 +40150,21 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                 headers: request2.headers,
                 signal: request2.signal
               });
+              let middlewareMap = /* @__PURE__ */ new Map();
+              let middlewareContext = /* @__PURE__ */ new Map();
+              if (middlewareManager?.hasMiddleware()) {
+                const targetNodeRequest = createPageDataMiddlewareRequest(req, targetRequestUrl);
+                const handled = await runFarmMiddlewareWithNavigation(
+                  farmApp.getServerRenderer(),
+                  targetRequest,
+                  targetNodeRequest,
+                  res,
+                  () => middlewareManager.execute(targetNodeRequest, res)
+                );
+                if (handled) return;
+                middlewareMap = targetNodeRequest.__FARM_MIDDLEWARE_DATA__ ?? middlewareMap;
+                middlewareContext = targetNodeRequest.__FARM_MIDDLEWARE_CONTEXT__ ?? middlewareContext;
+              }
               await farmApp.getServerRenderer().runWithRequestContext(targetRequest, async () => {
                 const routeManager3 = farmApp.getRouteManager();
                 if (pm) {
@@ -40125,7 +40238,8 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                     {
                       params,
                       searchParams: Promise.resolve(searchParams),
-                      path: targetUrl.pathname
+                      path: targetUrl.pathname,
+                      middleware: middlewareMap.size > 0 ? { data: middlewareMap } : void 0
                     },
                     routeContext
                   ),
@@ -40213,27 +40327,34 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                   parseFarmLayoutChainHeader(request2.headers.get("x-farm-layout-chain")),
                   destinationLayoutPatterns
                 );
-                const fragmentHtml = await farmApp.getServerRenderer().renderNavigationFragment({
-                  PageComponent: routeModule.default,
-                  LoadingComponent: loadingModule?.default,
-                  pageProps: routeProps,
-                  params,
-                  layouts: layouts.map((layout2, index) => ({
-                    pattern: layout2.pattern,
-                    module: layoutModules[index]
-                  })),
-                  layoutStartIndex,
-                  slots: routeSlots.map((slot) => ({
-                    name: slot.name,
-                    ownerPattern: slot.ownerPattern,
-                    containerId: slot.containerId,
-                    module: slot.renderModule,
-                    props: slot.props
-                  })),
-                  pageShouldHydrate: shouldHydrate,
-                  layoutShouldHydrate: shouldHydrateLayout,
-                  islandStrategy: hydrationIslandStrategy
-                });
+                const renderer = farmApp.getServerRenderer();
+                const fragmentHtml = await _runWithMiddlewareData(
+                  middlewareMap,
+                  () => _runWithMiddlewareContext(
+                    middlewareContext,
+                    () => renderer.renderNavigationFragment({
+                      PageComponent: routeModule.default,
+                      LoadingComponent: loadingModule?.default,
+                      pageProps: routeProps,
+                      params,
+                      layouts: layouts.map((layout2, index) => ({
+                        pattern: layout2.pattern,
+                        module: layoutModules[index]
+                      })),
+                      layoutStartIndex,
+                      slots: routeSlots.map((slot) => ({
+                        name: slot.name,
+                        ownerPattern: slot.ownerPattern,
+                        containerId: slot.containerId,
+                        module: slot.renderModule,
+                        props: slot.props
+                      })),
+                      pageShouldHydrate: shouldHydrate,
+                      layoutShouldHydrate: shouldHydrateLayout,
+                      islandStrategy: hydrationIslandStrategy
+                    })
+                  )
+                );
                 const pageData = {
                   props: {
                     params: routeProps.params,
@@ -40243,7 +40364,9 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                     ...routeProps.__farmCanonicalPath ? {
                       __farmCanonicalPath: routeProps.__farmCanonicalPath
                     } : {},
-                    ...routeProps.__farmRoutePropsResolved ? { __farmRoutePropsResolved: true } : {}
+                    ...routeProps.__farmRoutePropsResolved ? { __farmRoutePropsResolved: true } : {},
+                    // The same serialized shape a full load embeds in __FARM_PROPS__.
+                    ...middlewareMap.size > 0 ? { middleware: { data: Object.fromEntries(middlewareMap) } } : {}
                   },
                   canonicalPath: routeProps.__farmCanonicalPath,
                   modulePath: toUrlPath(route.modulePath),
@@ -40993,6 +41116,26 @@ function runFarmMiddlewareWithNavigation(renderer, middlewareRequest, req, res,
   });
 }
 __name(runFarmMiddlewareWithNavigation, "runFarmMiddlewareWithNavigation");
+function createPageDataMiddlewareRequest(req, target) {
+  const targetNodeRequest = Object.create(req);
+  targetNodeRequest.url = `${target.pathname}${target.search}`;
+  targetNodeRequest.originalUrl = targetNodeRequest.url;
+  targetNodeRequest.method = "GET";
+  return targetNodeRequest;
+}
+__name(createPageDataMiddlewareRequest, "createPageDataMiddlewareRequest");
+function resolveDevelopmentRoot(farmRoot, viteRoot) {
+  if (!farmRoot) return viteRoot;
+  if (path38.resolve(farmRoot) === path38.resolve(viteRoot)) return farmRoot;
+  try {
+    if (fs14.realpathSync(farmRoot) === fs14.realpathSync(viteRoot)) {
+      return path38.resolve(viteRoot);
+    }
+  } catch {
+  }
+  return farmRoot;
+}
+__name(resolveDevelopmentRoot, "resolveDevelopmentRoot");
 function isFarmClientVirtualId(id) {
   const pathname = id.split("?", 1)[0];
   return pathname === "/@farm/client" || pathname === "/@farm/client.js";
@@ -41008,16 +41151,18 @@ function generateProgrammaticRouteModule(moduleId, root, renderer = REACT_RENDER
     return generateProgrammaticApiRouteModule(parsed.routePath, routeFile);
   }
   return `
-import {
-  createElement as __farmCreateElement,
-  Suspense as __farmSuspense,
-} from ${JSON.stringify(renderer.server)};
+import * as __farmRendererRuntime from ${JSON.stringify(renderer.server)};
 import {
   createLayoutModuleFromProgrammaticLayout as __farmCreateLayoutRouteModule,
   createRouteModuleFromProgrammaticPage as __farmCreatePageRouteModule,
 } from "@farm.js/core/routes";
 import * as __farmRoutesModule from ${JSON.stringify(routeFile)};
 
+const __farmCreateElement = __farmRendererRuntime.createElement;
+const __farmSuspense = __farmRendererRuntime.Suspense;
+// Optional hook: only renderers that need it export markFunctionComponent.
+const __farmMarkFunctionComponent = Reflect.get(__farmRendererRuntime, "markFunctionComponent");
+
 const __farmIsRouteDefinition = (value) => (
   value &&
   typeof value === "object" &&
@@ -41071,6 +41216,7 @@ const __farmRouteModule = __farmRoute.kind === "layout"
   : __farmCreatePageRouteModule(__farmRoute, {
       createElement: __farmCreateElement,
       Suspense: __farmSuspense,
+      markFunctionComponent: __farmMarkFunctionComponent,
     });
 
 export const metadata = __farmRouteModule.metadata;
@@ -42680,6 +42826,11 @@ async function hydrate() {
       pendingPageHydrationController = hydrationController;
       await hydrateFarmIsolatedClientBoundaries(rootContainer, hydrationController.signal);
       if (hydrationController.signal.aborted) return;
+      // The rest of the document is static server HTML with nothing to hydrate, so
+      // stop holding its clicks and submits once the load-strategy islands are live.
+      // Deferred islands capture their own interactions, and held targets outside an
+      // island are not replayed into DOM no client code owns.
+      markFarmHydrated();
       return;
     }` : ""}
     if (!shouldHydrate) {
@@ -43178,7 +43329,7 @@ function createServerFn(options) {
     try {
       input = await _parseServerFnSchema(options.input, rawInput, "input");
     } catch (cause) {
-      throw labelInputErrors ? new ServerFnInputError(cause) : cause;
+      throw labelInputErrors && isSchemaValidationFailure(cause) ? new ServerFnInputError(cause) : cause;
     }
     const executionContext = getServerActionExecutionContext();
     const request2 = executionContext?.request ?? _resolveCurrentRequest();
@@ -43398,9 +43549,17 @@ async function _parseServerFnSchema(schema, value, contract, owner = "createServ
   throw new TypeError(`${owner} ${contract} must provide parse, parseAsync, or safeParse`);
 }
 __name(_parseServerFnSchema, "_parseServerFnSchema");
+var schemaValidationFailures = /* @__PURE__ */ new WeakSet();
+function isSchemaValidationFailure(error) {
+  if (!error || typeof error !== "object") return false;
+  return schemaValidationFailures.has(error) || Array.isArray(error.issues);
+}
+__name(isSchemaValidationFailure, "isSchemaValidationFailure");
 function unwrapSafeParseResult(result) {
   if (result && typeof result === "object" && "success" in result && result.success === false) {
-    throw result.error;
+    const error = result.error;
+    if (error && typeof error === "object") schemaValidationFailures.add(error);
+    throw error;
   }
   if (result && typeof result === "object" && "success" in result && result.success === true) {
     return result.data;