@farm.js/core 0.1.15 → 0.1.17

package/dist/index.cjs

@@ -7285,8 +7285,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
@@ -7496,6 +7504,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";
@@ -7653,6 +7667,7 @@ var init_markdown = __esm({
     __name(findExposedMarkdownRoute, "findExposedMarkdownRoute");
     __name(routeMatches, "routeMatches");
     __name(isHtmlResponse, "isHtmlResponse");
+    __name(isPrivateCacheControl, "isPrivateCacheControl");
     __name(createMarkdownCacheHeader, "createMarkdownCacheHeader");
     __name(extractHtmlTitle, "extractHtmlTitle");
     __name(extractHtmlBody, "extractHtmlBody");
@@ -12543,6 +12558,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;
@@ -12561,6 +12578,7 @@ var init_cache = __esm({
       configure(config = {}) {
         this.generation++;
         this.entries.clear();
+        this.entriesByTag.clear();
         this.inflight.clear();
         this.invalidatedTagVersions.clear();
         this.activeGenerations.clear();
@@ -12727,14 +12745,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));
         }
@@ -12745,6 +12761,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();
@@ -12830,23 +12847,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;
@@ -12887,7 +12913,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);
@@ -12932,18 +12958,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++;
           }
@@ -12951,10 +12968,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) {
@@ -12984,19 +13001,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;
       }
-      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;
+      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;
+      }
+      /**
+       * 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)
@@ -13394,6 +13443,7 @@ function createProgrammaticPageComponent(route2, rendererRuntime) {
     }
     return rendererRuntime.createElement(...args);
   }, "createElement");
+  const markFunctionComponent = /* @__PURE__ */ __name((component) => rendererRuntime?.markFunctionComponent?.(component) ?? component, "markFunctionComponent");
   const Component = route2.component;
   if (route2.pending) {
     const PendingComponent = route2.pending;
@@ -13415,7 +13465,9 @@ function createProgrammaticPageComponent(route2, rendererRuntime) {
         throw error;
       }
     }, "FarmProgrammaticPageContent");
-    const PageContent = FarmProgrammaticPageContent2;
+    const PageContent = markFunctionComponent(
+      FarmProgrammaticPageContent2
+    );
     const FarmProgrammaticPage = /* @__PURE__ */ __name(function FarmProgrammaticPage2(props) {
       return createElement4(
         rendererRuntime.Suspense,
@@ -13425,7 +13477,7 @@ function createProgrammaticPageComponent(route2, rendererRuntime) {
         createElement4(PageContent, props)
       );
     }, "FarmProgrammaticPage");
-    return FarmProgrammaticPage;
+    return markFunctionComponent(FarmProgrammaticPage);
   }
   const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
     try {
@@ -13444,7 +13496,7 @@ function createProgrammaticPageComponent(route2, rendererRuntime) {
       throw error;
     }
   }, "FarmProgrammaticPageContent");
-  return FarmProgrammaticPageContent;
+  return markFunctionComponent(FarmProgrammaticPageContent);
 }
 function readProgrammaticRouteProps(route2, props, resources) {
   if (isProgrammaticRoutePropsResolved(props)) {
@@ -15104,7 +15156,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 };
 }
 function resolveProjectAliasSourcePath(specifier, root) {
@@ -15117,11 +15169,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;
 }
 function matchProjectImportAlias(alias, specifier) {
   if (!alias.wildcard) return specifier === alias.prefix ? "" : null;
@@ -15841,6 +15894,7 @@ var init_route_manager = __esm({
     init_static_metadata_image();
     init_route_runtime();
     init_routing();
+    init_base_path();
     init_redirect_query();
     init_route_slots();
     init_renderer();
@@ -16822,7 +16876,7 @@ var init_route_manager = __esm({
       }
       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("//")) {
@@ -22038,7 +22092,7 @@ var init_server3 = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.15";
+    version = "0.1.17";
   }
 });
 
@@ -22947,7 +23001,7 @@ function 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>`;
 }
 function createDocumentFooter(options) {
   return `</div>
@@ -26373,21 +26427,42 @@ function resolveEnv(config, source = getProcessEnv()) {
   };
   return resolved;
 }
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime3 = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    const raw = source[key];
+    const type = getRuntimeEnvType(value);
+    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
+      runtime3[key] = type;
+    } else {
+      server[key] = value;
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime3).length > 0 ? { runtime: { server: runtime3 } } : {}
+  };
+}
 function setEnv(env2) {
-  currentEnv = normalizeResolvedEnv(env2);
+  currentEnv = prepareEnv(env2);
   if (typeof window === "undefined") {
     farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
   }
 }
 function getResolvedEnv() {
-  return getCurrentEnv();
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
 }
 function getEnv(key) {
-  assertServerEnvAccess();
+  const server = getEnvScope("server");
   if (key === void 0) {
-    return getCurrentEnv().server;
+    return server;
   }
-  return getCurrentEnv().server[key];
+  return readServerEnvKey(server, key);
 }
 function getPublicEnv(key) {
   if (key === void 0) {
@@ -26428,7 +26503,7 @@ function createEnvProxy(scope) {
           return void 0;
         }
         const env2 = getEnvScope(scope);
-        return env2[property];
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
       },
       ownKeys() {
         return Reflect.ownKeys(getEnvScope(scope));
@@ -26451,10 +26526,90 @@ function createEnvProxy(scope) {
   );
 }
 function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
   if (scope === "server") {
     assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = readFarmEnvironmentValue(key);
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
   }
-  return getCurrentEnv()[scope] || {};
+  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;
+  if (!isRecord4(runtime3) || Object.keys(runtime3).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime3 },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
 }
 function assertServerEnvAccess() {
   if (typeof window !== "undefined") {
@@ -26483,7 +26638,7 @@ function getCurrentEnv() {
 function getInjectedEnv() {
   try {
     if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return normalizeResolvedEnv(__FARM_ENV__);
+      return prepareEnv(__FARM_ENV__);
     }
   } catch {
   }
@@ -26513,14 +26668,17 @@ function getProcessEnv() {
   }
   return {};
 }
-var FARM_ENV_SYMBOL, farmEnvGlobal, currentEnv, env, serverEnv, publicEnv;
+var FARM_ENV_SYMBOL, FARM_ENV_RUNTIME_SYMBOL, farmEnvGlobal, currentEnv, env, serverEnv, publicEnv;
 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;
     currentEnv = getInitialEnv();
     __name(resolveEnv, "resolveEnv");
+    __name(createBundledEnv, "createBundledEnv");
     __name(setEnv, "setEnv");
     __name(getResolvedEnv, "getResolvedEnv");
     __name(getEnv, "getEnv");
@@ -26532,6 +26690,13 @@ var init_env = __esm({
     __name(parseEnvValue, "parseEnvValue");
     __name(createEnvProxy, "createEnvProxy");
     __name(getEnvScope, "getEnvScope");
+    __name(readServerEnvKey, "readServerEnvKey");
+    __name(readRuntimeServerEnv, "readRuntimeServerEnv");
+    __name(getRuntimeEnvType, "getRuntimeEnvType");
+    __name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+    __name(isSameEnvValue, "isSameEnvValue");
+    __name(isPlainObject3, "isPlainObject");
+    __name(prepareEnv, "prepareEnv");
     __name(assertServerEnvAccess, "assertServerEnvAccess");
     __name(getInitialEnv, "getInitialEnv");
     __name(getCurrentEnv, "getCurrentEnv");
@@ -27442,7 +27607,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     wrappedHandler
   );
   endpoint2.__path = path48 || void 0;
-  endpoint2.__method = options.method || "GET";
+  endpoint2.__method = options.method || (path48 ? "GET" : void 0);
   endpoint2.__autoPath = !path48;
   endpoint2.__handler = wrappedHandler;
   endpoint2.__farmInvoke = (ctx) => runEndpointMiddleware(middleware2, ctx, handler, error, options.invalidates);
@@ -28301,6 +28466,7 @@ var init_runtime2 = __esm({
     init_response_body();
     init_route_shape();
     init_route_schema();
+    init_endpoint();
     init_plugin_route_runtime();
     init_route_pattern2();
     init_route_pattern2();
@@ -29209,7 +29375,7 @@ function parseColonParam(segment) {
     modifier
   };
 }
-function compilePathPattern(pattern) {
+function compilePathPattern(pattern, trailingSlash = false) {
   const params = [];
   const segments = pattern.split("/").filter(Boolean);
   if (segments.length === 0) {
@@ -29245,10 +29411,16 @@ function compilePathPattern(pattern) {
   });
   return {
     kind: "path",
-    regex: new RegExp(`^${parts.join("")}$`),
+    regex: new RegExp(`^${parts.join("")}${trailingSlash ? "/?" : ""}$`),
     params
   };
 }
+function compileMatcherPattern(pattern) {
+  if (typeof pattern === "string" && pattern !== "*" && !pattern.endsWith("(.*)")) {
+    return compilePathPattern(pattern, true);
+  }
+  return compilePattern(pattern);
+}
 function compilePattern(pattern) {
   if (pattern instanceof RegExp) {
     return { kind: "regexp", regex: pattern };
@@ -29267,7 +29439,7 @@ function compilePattern(pattern) {
 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)
   };
@@ -29355,6 +29527,7 @@ var init_matcher = __esm({
     __name(escapeRegex, "escapeRegex");
     __name(parseColonParam, "parseColonParam");
     __name(compilePathPattern, "compilePathPattern");
+    __name(compileMatcherPattern, "compileMatcherPattern");
     __name(compilePattern, "compilePattern");
     __name(compileMiddlewareConfig, "compileMiddlewareConfig");
     __name(matchPattern, "matchPattern");
@@ -32637,6 +32810,66 @@ function mergeFarmViteConfig(farmConfig, userConfig = {}) {
     }
   };
 }
+function mergeExternal(farmValue, userValue) {
+  if (farmValue === void 0) return userValue;
+  if (userValue === void 0) return farmValue;
+  if (farmValue === true || userValue === true) return true;
+  return Array.from(/* @__PURE__ */ new Set([...farmValue, ...userValue]));
+}
+function mergeFarmProductionViteConfig(farmConfig, userConfig = {}) {
+  const {
+    plugins: _plugins,
+    root: _root,
+    base: _base,
+    mode: _mode,
+    appType: _appType,
+    publicDir: _publicDir,
+    build: userBuild = {},
+    css: userCss,
+    define: userDefine,
+    esbuild: userEsbuild,
+    ...shared2
+  } = userConfig;
+  const {
+    outDir: _outDir,
+    emptyOutDir: _emptyOutDir,
+    ssr: _ssr,
+    ssrEmitAssets: _ssrEmitAssets,
+    write: _write,
+    lib: _lib,
+    watch: _watch,
+    rollupOptions: userRollupOptions,
+    rolldownOptions: userRolldownOptions,
+    ...userBuildOptions
+  } = userBuild;
+  const {
+    input: _input,
+    output: _output,
+    ...userBundlerOptions
+  } = {
+    ...userRollupOptions,
+    ...userRolldownOptions
+  };
+  const merged = mergeFarmViteConfig(farmConfig, shared2);
+  return {
+    ...merged,
+    build: {
+      ...userBuildOptions,
+      ...farmConfig.build,
+      rollupOptions: {
+        ...userBundlerOptions,
+        ...farmConfig.build?.rollupOptions
+      }
+    },
+    css: farmConfig.css || userCss ? { ...farmConfig.css, ...userCss } : void 0,
+    define: farmConfig.define || userDefine ? { ...userDefine, ...farmConfig.define } : void 0,
+    esbuild: typeof userEsbuild === "object" && farmConfig.esbuild !== false ? { ...userEsbuild, ...farmConfig.esbuild } : farmConfig.esbuild ?? userEsbuild,
+    ssr: {
+      ...merged.ssr,
+      external: mergeExternal(farmConfig.ssr?.external, userConfig.ssr?.external)
+    }
+  };
+}
 var import_node_path16, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
 var init_vite_config = __esm({
   "src/server/vite-config.ts"() {
@@ -32665,6 +32898,8 @@ var init_vite_config = __esm({
     __name(mergeNoExternal, "mergeNoExternal");
     __name(mergeAlias, "mergeAlias");
     __name(mergeFarmViteConfig, "mergeFarmViteConfig");
+    __name(mergeExternal, "mergeExternal");
+    __name(mergeFarmProductionViteConfig, "mergeFarmProductionViteConfig");
   }
 });
 
@@ -34884,6 +35119,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(
@@ -34898,7 +35134,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" } : {}
             }
           }
         )
@@ -34928,6 +35165,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 } : {}
           }
         }
@@ -39798,7 +40036,7 @@ function getEnvDefines(config, configEnv) {
     )
   };
   if (configEnv?.isSsrBuild) {
-    defines.__FARM_ENV__ = JSON.stringify(getFullEnvDefine(config));
+    defines.__FARM_ENV__ = JSON.stringify(createBundledEnv(getFullEnvDefine(config)));
   }
   return defines;
 }
@@ -40061,8 +40299,8 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "emitPluginError");
       farmApp = new FarmApp(
         {
-          root: server.config.root,
-          ...options
+          ...options,
+          root: resolveDevelopmentRoot(options.root, server.config.root)
         },
         server
       );
@@ -40649,7 +40887,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;
@@ -40666,7 +40905,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);
@@ -41144,6 +41383,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) {
@@ -41217,7 +41471,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
                   ),
@@ -41305,27 +41560,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,
@@ -41335,7 +41597,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(route2.modulePath),
@@ -42083,6 +42347,24 @@ function runFarmMiddlewareWithNavigation(renderer, middlewareRequest, req, res,
     }
   });
 }
+function createPageDataMiddlewareRequest(req, target) {
+  const targetNodeRequest = Object.create(req);
+  targetNodeRequest.url = `${target.pathname}${target.search}`;
+  targetNodeRequest.originalUrl = targetNodeRequest.url;
+  targetNodeRequest.method = "GET";
+  return targetNodeRequest;
+}
+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;
+}
 function isFarmClientVirtualId(id) {
   const pathname = id.split("?", 1)[0];
   return pathname === "/@farm/client" || pathname === "/@farm/client.js";
@@ -42097,16 +42379,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" &&
@@ -42160,6 +42444,7 @@ const __farmRouteModule = __farmRoute.kind === "layout"
   : __farmCreatePageRouteModule(__farmRoute, {
       createElement: __farmCreateElement,
       Suspense: __farmSuspense,
+      markFunctionComponent: __farmMarkFunctionComponent,
     });
 
 export const metadata = __farmRouteModule.metadata;
@@ -43764,6 +44049,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) {
@@ -44193,6 +44483,7 @@ var fs14, path38, import_node_url11, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifact
 var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
+    init_env();
     init_app();
     init_utils();
     init_plugin();
@@ -44204,9 +44495,11 @@ var init_vite2 = __esm({
     init_server_path();
     init_runtime2();
     init_manager();
+    init_server();
     init_type_artifacts();
     init_routes_shared();
     init_markdown();
+    init_base_path();
     init_llms_txt();
     init_agent_crawlers();
     init_app_markdown();
@@ -44344,6 +44637,8 @@ async function mountFarmDocsSearch() {
     __name(hasViteAlias, "hasViteAlias");
     __name(farmPlugin, "farmPlugin");
     __name(runFarmMiddlewareWithNavigation, "runFarmMiddlewareWithNavigation");
+    __name(createPageDataMiddlewareRequest, "createPageDataMiddlewareRequest");
+    __name(resolveDevelopmentRoot, "resolveDevelopmentRoot");
     __name(isFarmClientVirtualId, "isFarmClientVirtualId");
     __name(generateProgrammaticRouteModule, "generateProgrammaticRouteModule");
     __name(generateProgrammaticApiRouteModule, "generateProgrammaticApiRouteModule");
@@ -45263,7 +45558,7 @@ export const farmRegistry: {
   clientManifest?: any;
   routePaths?: Record<string, string>;
 } = {
-  env: ${JSON.stringify(config.env || { server: {}, public: {} }, null, 2)},
+  env: ${JSON.stringify(createBundledEnv(config.env), null, 2)},
   deploymentId: ${JSON.stringify(config.deploymentId)},
   basePath: ${JSON.stringify(config.basePath)},
   apiBasePath: ${JSON.stringify(apiBasePath)},
@@ -45767,7 +46062,7 @@ export default defineEventHandler(async (event: H3Event) => {
           farmRegistry.apiRouteManager = apiRouteManager;
           farmRegistry.routeManager = routeManager;
           farmRegistry.serverRenderer = serverRenderer;
-          farmRegistry.env = config.env || { server: {}, public: {} };
+          farmRegistry.env = createBundledEnv(config.env);
           farmRegistry.deploymentId = config.deploymentId;
           farmRegistry.basePath = config.basePath;
         };
@@ -45832,6 +46127,7 @@ var import_path16;
 var init_nitro = __esm({
   "src/nitro/index.ts"() {
     "use strict";
+    init_env();
     import_path16 = __toESM(require("path"));
     init_workflows();
     init_cron();
@@ -45914,7 +46210,11 @@ __export(src_exports, {
   ServerActionRequestError: () => ServerActionRequestError,
   ServerFnFailure: () => ServerFnFailure,
   UnsupportedRateLimitStorageError: () => UnsupportedRateLimitStorageError,
+  _attachServerFunctionDescriptor: () => _attachServerFunctionDescriptor,
+  _describeServerFunction: () => _describeServerFunction,
+  _invokeServerFunction: () => _invokeServerFunction,
   _parseServerFnSchema: () => _parseServerFnSchema,
+  _runServerFunctionForCaller: () => _runServerFunctionForCaller,
   _runWithAfterNodeResponse: () => _runWithAfterNodeResponse,
   _runWithAfterRequest: () => _runWithAfterRequest,
   _runWithMiddlewareContext: () => _runWithMiddlewareContext,
@@ -45960,6 +46260,7 @@ __export(src_exports, {
   cookies: () => cookies,
   createAPIClient: () => createAPIClient,
   createApiClients: () => createApiClients,
+  createBundledEnv: () => createBundledEnv,
   createClientOnlyFn: () => createClientOnlyFn,
   createClientPluginManager: () => createClientPluginManager,
   createCompressionPlugin: () => createCompressionPlugin,
@@ -46022,6 +46323,7 @@ __export(src_exports, {
   createServerActionRequestErrorResponse: () => createServerActionRequestErrorResponse,
   createServerFn: () => createServerFn,
   createServerFnTransportError: () => createServerFnTransportError,
+  createServerFunctionDescriptor: () => createServerFunctionDescriptor,
   createServerMiddleware: () => createServerMiddleware,
   createServerOnlyFn: () => createServerOnlyFn,
   createServerQuery: () => createServerQuery,
@@ -50477,6 +50779,7 @@ init_transport();
 init_route_manager2();
 init_runtime2();
 init_response();
+init_request();
 init_route_files();
 init_after();
 init_server_context();
@@ -50833,7 +51136,7 @@ function farmApiPlugin(options = {}) {
             if (currentPathname !== pathname && !matchAPIRouteAtBasePath(apiRoutesCache, currentPathname, basePath)) {
               return next();
             }
-            const fullUrl = `http://${req.headers.host || "localhost:3000"}${currentUrl}`;
+            const fullUrl = resolveFarmRequestURL(req);
             const headers2 = new Headers();
             for (const [key, value] of Object.entries(req.headers)) {
               if (value) {
@@ -52793,8 +53096,74 @@ init_server_action_security();
 init_request_bridge();
 init_cache();
 init_server_fn_error();
+init_navigation_errors();
 init_server_fn_error();
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var _ServerFnInputError = class _ServerFnInputError extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+__name(_ServerFnInputError, "ServerFnInputError");
+var ServerFnInputError = _ServerFnInputError;
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+__name(createServerFunctionDescriptor, "createServerFunctionDescriptor");
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+__name(_attachServerFunctionDescriptor, "_attachServerFunctionDescriptor");
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+__name(getServerFunctionRunner, "getServerFunctionRunner");
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+__name(_runServerFunctionForCaller, "_runServerFunctionForCaller");
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+__name(_describeServerFunction, "_describeServerFunction");
+async function _invokeServerFunction(value, input, request2) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await runWithServerActionRequest(request2, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (isServerFnFailure(error)) return { ok: false, reason: "failure", failure: error };
+    const redirect3 = getFarmRedirectError(error);
+    if (redirect3) {
+      return { ok: false, reason: "redirect", url: redirect3.url, status: redirect3.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+__name(_invokeServerFunction, "_invokeServerFunction");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerMiddleware(options) {
   if (!options || typeof options.handler !== "function") {
@@ -52818,10 +53187,15 @@ function createServerFn(options) {
   const middleware2 = resolveServerFnMiddleware(options.middleware);
   const errors = normalizeServerFnErrors(options.errors);
   const error = createServerFnErrorHandler(errors);
-  const serverFn = /* @__PURE__ */ __name(async (value) => {
+  const run = /* @__PURE__ */ __name(async (value, labelInputErrors) => {
     const formData = isFormData2(value) ? value : void 0;
     const rawInput = formData ? formDataToObject2(formData) : value;
-    const input = await _parseServerFnSchema(options.input, rawInput, "input");
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors && isSchemaValidationFailure(cause) ? new ServerFnInputError(cause) : cause;
+    }
     const executionContext = getServerActionExecutionContext();
     const request2 = executionContext?.request ?? _resolveCurrentRequest();
     const signal = executionContext?.signal ?? request2?.signal ?? getServerActionSignal();
@@ -52847,7 +53221,8 @@ function createServerFn(options) {
       await applyFarmCacheInvalidationTargets(declaration);
     }
     return parsedResult;
-  }, "serverFn");
+  }, "run");
+  const serverFn = /* @__PURE__ */ __name((value) => run(value, false), "serverFn");
   Object.defineProperties(serverFn, {
     [FARM_SERVER_FN_SYMBOL]: {
       value: true,
@@ -52878,6 +53253,10 @@ function createServerFn(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
   return serverFn;
 }
 __name(createServerFn, "createServerFn");
@@ -53035,9 +53414,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;
@@ -53429,6 +53816,16 @@ function createServerQuery(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    query,
+    createServerFunctionDescriptor("query", options, async (value) => {
+      const result = await _runServerFunctionForCaller(
+        execute,
+        value
+      );
+      return result.data;
+    })
+  );
   return query;
 }
 __name(createServerQuery, "createServerQuery");
@@ -53786,6 +54183,7 @@ init_deployment();
 init_generate_route_types();
 
 // src/build/index.ts
+init_env();
 init_config4();
 var import_path17 = __toESM(require("path"));
 var import_node_fs15 = require("fs");
@@ -53796,6 +54194,7 @@ init_server_path();
 init_layers();
 
 // src/nitro/universal-build.ts
+init_env();
 init_config4();
 
 // src/nitro/client-css-href.ts
@@ -55907,7 +56306,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     }
   }
   try {
-    await viteBuild({
+    const clientViteConfig = {
       root,
       // Vite otherwise falls back to <root>/public, silently dropping every
       // asset in a custom config.publicDir from the production client output.
@@ -56043,7 +56442,8 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
           "@farm.js/core/headers"
         ]
       }
-    });
+    };
+    await viteBuild(mergeFarmProductionViteConfig(clientViteConfig, config.vite));
     await mergeBuiltFontCss(outputDir);
     await validateClientBuildOutput(root, srcDir, outputDir);
   } finally {
@@ -58389,7 +58789,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     "react-dom/server"
   ];
   try {
-    await viteBuild({
+    const serverViteConfig = {
       root,
       build: {
         target: "esnext",
@@ -58480,7 +58880,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       },
       define: {
         __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-        __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+        __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
         __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
       },
       plugins: [
@@ -58550,7 +58950,8 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         // Route modules and the renderer adapter must share one runtime instance.
         dedupe: [...config.renderer.dedupe || []]
       }
-    });
+    };
+    await viteBuild(mergeFarmProductionViteConfig(serverViteConfig, config.vite));
   } finally {
     if (postcssConfigDir) {
       try {
@@ -60758,7 +61159,7 @@ function hasLocalRequestRoute(request, routePathname) {
   const pathname = new URL(request.url).pathname;
   if (
     farmOpenAPIReference &&
-    normalizeRuntimePath(pathname) === normalizeRuntimePath(farmOpenAPIReference.route)
+    normalizeRuntimePath(stripFarmBasePath(pathname)) === normalizeRuntimePath(farmOpenAPIReference.route)
   ) {
     return true;
   }
@@ -60794,7 +61195,7 @@ function getFarmPluginRequestOptions(request) {
   const route = { pathname };
   if (
     farmOpenAPIReference &&
-    normalizeRuntimePath(pathname) === normalizeRuntimePath(farmOpenAPIReference.route)
+    normalizeRuntimePath(stripFarmBasePath(pathname)) === normalizeRuntimePath(farmOpenAPIReference.route)
   ) {
     return {
       kind: "docs",
@@ -61123,9 +61524,10 @@ async function handleFarmRequest(request, adapterContext) {
   )` : "handleFarmRequestInContext(request, null, false, Date.now(), adapterContext, requestUrl)"};
   ${config.md?.enabled ? `const pathname = getFarmRoutePathname(requestUrl.pathname);
   if (matchPageRoute(pathname)) {
+    // The Link header advertises the public .md URL, like the head alternate.
     return applyMarkdownNegotiationHeaders(response, {
       config: farmMarkdownConfig,
-      pathname,
+      pathname: requestUrl.pathname,
     });
   }` : ""}
   return response;
@@ -61313,7 +61715,7 @@ async function handleFarmRequestInContext(
   if (
     farmOpenAPIReference &&
     farmOpenAPIReference.specRoute &&
-    normalizeRuntimePath(pathname) === normalizeRuntimePath(farmOpenAPIReference.specRoute)
+    normalizeRuntimePath(stripFarmBasePath(pathname)) === normalizeRuntimePath(farmOpenAPIReference.specRoute)
   ) {
     const method = request.method.toUpperCase();
     const specResponse = method === "GET" || method === "HEAD"
@@ -61337,7 +61739,7 @@ async function handleFarmRequestInContext(
 
   if (
     farmOpenAPIReference &&
-    normalizeRuntimePath(pathname) === normalizeRuntimePath(farmOpenAPIReference.route)
+    normalizeRuntimePath(stripFarmBasePath(pathname)) === normalizeRuntimePath(farmOpenAPIReference.route)
   ) {
     const method = request.method.toUpperCase();
     const response = method === "GET" || method === "HEAD"
@@ -61875,12 +62277,15 @@ async function handleFarmRequestInContext(
         const sharedCacheControl = getRouteSharedCacheControl(route, pprCanCache);
         const responseHeaders = {
           "Content-Type": "text/html; charset=utf-8",
-          "Cache-Control": renderedPage.stream || hasRequestScopedRender || !sharedCacheControl
-            ? "private, no-store"
-            : sharedCacheControl,
+          "Cache-Control": sharedCacheControl,
           ...(farmFontPreloadHeader ? { "Link": farmFontPreloadHeader } : {}),
           ...(pprConfig.enabled ? getPPRHeaders(pprCanCache ? "miss" : "bypass", pprConfig) : {}),
         };
+        // An error status or a request-scoped render is never shareable, even when
+        // the PPR shell headers would otherwise grant a shared max-age.
+        if (renderedPage.stream || hasRequestScopedRender || !sharedCacheControl) {
+          responseHeaders["Cache-Control"] = "private, no-store";
+        }
         const farmI18nSnapshot = getFarmI18nSnapshot();
         let html = renderedPage.html;
         
@@ -63931,7 +64336,7 @@ async function buildSSR(viteBuild, config, root, srcDir, outputDir) {
     },
     define: {
       __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-      __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+      __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
       __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
     },
     plugins: [
@@ -64014,7 +64419,7 @@ async function buildNitro(config, routeManager, apiRouteManager, serverRenderer,
     farmRegistry.apiRouteManager = apiRouteManager;
     farmRegistry.routeManager = routeManager;
     farmRegistry.serverRenderer = serverRenderer;
-    farmRegistry.env = config.env || { server: {}, public: {} };
+    farmRegistry.env = createBundledEnv(config.env);
     const routePaths = {};
     for (const [pattern, entry] of routeManager.getRoutes()) {
       const bundledPath = entry.modulePath.replace(/.*\/src\/app\//, "").replace(/\.(tsx?|jsx?)$/, ".js");
@@ -67557,7 +67962,11 @@ __name(cookies, "cookies");
   ServerActionRequestError,
   ServerFnFailure,
   UnsupportedRateLimitStorageError,
+  _attachServerFunctionDescriptor,
+  _describeServerFunction,
+  _invokeServerFunction,
   _parseServerFnSchema,
+  _runServerFunctionForCaller,
   _runWithAfterNodeResponse,
   _runWithAfterRequest,
   _runWithMiddlewareContext,
@@ -67603,6 +68012,7 @@ __name(cookies, "cookies");
   cookies,
   createAPIClient,
   createApiClients,
+  createBundledEnv,
   createClientOnlyFn,
   createClientPluginManager,
   createCompressionPlugin,
@@ -67665,6 +68075,7 @@ __name(cookies, "cookies");
   createServerActionRequestErrorResponse,
   createServerFn,
   createServerFnTransportError,
+  createServerFunctionDescriptor,
   createServerMiddleware,
   createServerOnlyFn,
   createServerQuery,