@farm.js/core 0.1.15 → 0.1.17

package/dist/internal/build-runtime.cjs

@@ -31,6 +31,302 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/utils/runtime-env.ts
+function getFarmRuntimeBindings() {
+  const runtimeBindings = globalThis.__env__;
+  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
+}
+function readFarmEnvironmentValue(name2) {
+  const runtimeValue = getFarmRuntimeBindings()?.[name2];
+  if (typeof runtimeValue === "string") return runtimeValue;
+  return typeof process !== "undefined" ? process.env?.[name2] : void 0;
+}
+function isFarmDeployedRuntime() {
+  if (getFarmRuntimeBindings()) return true;
+  return readFarmEnvironmentValue("NODE_ENV") === "production";
+}
+var init_runtime_env = __esm({
+  "src/utils/runtime-env.ts"() {
+    "use strict";
+    __name(getFarmRuntimeBindings, "getFarmRuntimeBindings");
+    __name(readFarmEnvironmentValue, "readFarmEnvironmentValue");
+    __name(isFarmDeployedRuntime, "isFarmDeployedRuntime");
+  }
+});
+
+// src/env.ts
+function resolveEnv(config, source = getProcessEnv()) {
+  const resolved = {
+    server: resolveEnvScope(config?.server, source, "server"),
+    public: resolveEnvScope(config?.public, source, "public")
+  };
+  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 = prepareEnv(env2);
+  if (typeof window === "undefined") {
+    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
+  }
+}
+function getResolvedEnv() {
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
+}
+function resolveEnvScope(shape, source, scope) {
+  if (!shape) {
+    return {};
+  }
+  const resolved = {};
+  for (const [key, parser] of Object.entries(shape)) {
+    try {
+      resolved[key] = parseEnvValue(parser, source[key], key, scope);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
+    }
+  }
+  return resolved;
+}
+function parseEnvValue(parser, value, key, scope) {
+  if (typeof parser === "function") {
+    return parser(value, { key, scope });
+  }
+  if (parser && typeof parser.parse === "function") {
+    return parser.parse(value);
+  }
+  throw new Error("expected a parser function or schema with parse()");
+}
+function createEnvProxy(scope) {
+  return new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") {
+          return void 0;
+        }
+        const env2 = getEnvScope(scope);
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
+      },
+      ownKeys() {
+        return Reflect.ownKeys(getEnvScope(scope));
+      },
+      getOwnPropertyDescriptor(_target, property) {
+        const env2 = getEnvScope(scope);
+        if (!(property in env2)) {
+          return void 0;
+        }
+        return {
+          enumerable: true,
+          configurable: true,
+          value: env2[property]
+        };
+      },
+      has(_target, property) {
+        return property in getEnvScope(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 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 (!isPlainObject(left) || !isPlainObject(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 isPlainObject(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 (!isRecord(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") {
+    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
+  }
+}
+function getInitialEnv() {
+  const injectedEnv = getInjectedEnv();
+  if (injectedEnv) {
+    return injectedEnv;
+  }
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
+  }
+  return {
+    server: {},
+    public: getInjectedPublicEnv()
+  };
+}
+function getCurrentEnv() {
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return farmEnvGlobal[FARM_ENV_SYMBOL];
+  }
+  return currentEnv;
+}
+function getInjectedEnv() {
+  try {
+    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
+      return prepareEnv(__FARM_ENV__);
+    }
+  } catch {
+  }
+  return null;
+}
+function getInjectedPublicEnv() {
+  try {
+    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
+      return __FARM_PUBLIC_ENV__;
+    }
+  } catch {
+  }
+  return {};
+}
+function normalizeResolvedEnv(env2) {
+  return {
+    server: isRecord(env2.server) ? env2.server : {},
+    public: isRecord(env2.public) ? env2.public : {}
+  };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getProcessEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+var FARM_ENV_SYMBOL, FARM_ENV_RUNTIME_SYMBOL, farmEnvGlobal, currentEnv, env, 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");
+    env = createEnvProxy("server");
+    publicEnv = createEnvProxy("public");
+    __name(resolveEnvScope, "resolveEnvScope");
+    __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(isPlainObject, "isPlainObject");
+    __name(prepareEnv, "prepareEnv");
+    __name(assertServerEnvAccess, "assertServerEnvAccess");
+    __name(getInitialEnv, "getInitialEnv");
+    __name(getCurrentEnv, "getCurrentEnv");
+    __name(getInjectedEnv, "getInjectedEnv");
+    __name(getInjectedPublicEnv, "getInjectedPublicEnv");
+    __name(normalizeResolvedEnv, "normalizeResolvedEnv");
+    __name(isRecord, "isRecord");
+    __name(getProcessEnv, "getProcessEnv");
+  }
+});
+
 // src/plugin-dependencies.ts
 function pluginShortName(name2) {
   return name2.slice(Math.max(name2.lastIndexOf(":"), name2.lastIndexOf("/")) + 1);
@@ -4101,8 +4397,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
@@ -4253,6 +4557,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;
@@ -4284,6 +4599,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";
@@ -4436,9 +4757,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");
@@ -4514,29 +4837,6 @@ var init_secret_compare = __esm({
   }
 });
 
-// src/utils/runtime-env.ts
-function getFarmRuntimeBindings() {
-  const runtimeBindings = globalThis.__env__;
-  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
-}
-function readFarmEnvironmentValue(name2) {
-  const runtimeValue = getFarmRuntimeBindings()?.[name2];
-  if (typeof runtimeValue === "string") return runtimeValue;
-  return typeof process !== "undefined" ? process.env?.[name2] : void 0;
-}
-function isFarmDeployedRuntime() {
-  if (getFarmRuntimeBindings()) return true;
-  return readFarmEnvironmentValue("NODE_ENV") === "production";
-}
-var init_runtime_env = __esm({
-  "src/utils/runtime-env.ts"() {
-    "use strict";
-    __name(getFarmRuntimeBindings, "getFarmRuntimeBindings");
-    __name(readFarmEnvironmentValue, "readFarmEnvironmentValue");
-    __name(isFarmDeployedRuntime, "isFarmDeployedRuntime");
-  }
-});
-
 // src/utils.ts
 function parseRoutePath(filePath) {
   const segments = [];
@@ -5786,168 +6086,6 @@ var init_cron = __esm({
   }
 });
 
-// src/env.ts
-function resolveEnv(config, source = getProcessEnv()) {
-  const resolved = {
-    server: resolveEnvScope(config?.server, source, "server"),
-    public: resolveEnvScope(config?.public, source, "public")
-  };
-  return resolved;
-}
-function setEnv(env2) {
-  currentEnv = normalizeResolvedEnv(env2);
-  if (typeof window === "undefined") {
-    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
-  }
-}
-function getResolvedEnv() {
-  return getCurrentEnv();
-}
-function resolveEnvScope(shape, source, scope) {
-  if (!shape) {
-    return {};
-  }
-  const resolved = {};
-  for (const [key, parser] of Object.entries(shape)) {
-    try {
-      resolved[key] = parseEnvValue(parser, source[key], key, scope);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
-    }
-  }
-  return resolved;
-}
-function parseEnvValue(parser, value, key, scope) {
-  if (typeof parser === "function") {
-    return parser(value, { key, scope });
-  }
-  if (parser && typeof parser.parse === "function") {
-    return parser.parse(value);
-  }
-  throw new Error("expected a parser function or schema with parse()");
-}
-function createEnvProxy(scope) {
-  return new Proxy(
-    {},
-    {
-      get(_target, property) {
-        if (typeof property === "symbol") {
-          return void 0;
-        }
-        const env2 = getEnvScope(scope);
-        return env2[property];
-      },
-      ownKeys() {
-        return Reflect.ownKeys(getEnvScope(scope));
-      },
-      getOwnPropertyDescriptor(_target, property) {
-        const env2 = getEnvScope(scope);
-        if (!(property in env2)) {
-          return void 0;
-        }
-        return {
-          enumerable: true,
-          configurable: true,
-          value: env2[property]
-        };
-      },
-      has(_target, property) {
-        return property in getEnvScope(scope);
-      }
-    }
-  );
-}
-function getEnvScope(scope) {
-  if (scope === "server") {
-    assertServerEnvAccess();
-  }
-  return getCurrentEnv()[scope] || {};
-}
-function assertServerEnvAccess() {
-  if (typeof window !== "undefined") {
-    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
-  }
-}
-function getInitialEnv() {
-  const injectedEnv = getInjectedEnv();
-  if (injectedEnv) {
-    return injectedEnv;
-  }
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
-  }
-  return {
-    server: {},
-    public: getInjectedPublicEnv()
-  };
-}
-function getCurrentEnv() {
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return farmEnvGlobal[FARM_ENV_SYMBOL];
-  }
-  return currentEnv;
-}
-function getInjectedEnv() {
-  try {
-    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return normalizeResolvedEnv(__FARM_ENV__);
-    }
-  } catch {
-  }
-  return null;
-}
-function getInjectedPublicEnv() {
-  try {
-    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
-      return __FARM_PUBLIC_ENV__;
-    }
-  } catch {
-  }
-  return {};
-}
-function normalizeResolvedEnv(env2) {
-  return {
-    server: isRecord(env2.server) ? env2.server : {},
-    public: isRecord(env2.public) ? env2.public : {}
-  };
-}
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function getProcessEnv() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env;
-  }
-  return {};
-}
-var FARM_ENV_SYMBOL, farmEnvGlobal, currentEnv, env, publicEnv;
-var init_env = __esm({
-  "src/env.ts"() {
-    "use strict";
-    FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
-    farmEnvGlobal = globalThis;
-    currentEnv = getInitialEnv();
-    __name(resolveEnv, "resolveEnv");
-    __name(setEnv, "setEnv");
-    __name(getResolvedEnv, "getResolvedEnv");
-    env = createEnvProxy("server");
-    publicEnv = createEnvProxy("public");
-    __name(resolveEnvScope, "resolveEnvScope");
-    __name(parseEnvValue, "parseEnvValue");
-    __name(createEnvProxy, "createEnvProxy");
-    __name(getEnvScope, "getEnvScope");
-    __name(assertServerEnvAccess, "assertServerEnvAccess");
-    __name(getInitialEnv, "getInitialEnv");
-    __name(getCurrentEnv, "getCurrentEnv");
-    __name(getInjectedEnv, "getInjectedEnv");
-    __name(getInjectedPublicEnv, "getInjectedPublicEnv");
-    __name(normalizeResolvedEnv, "normalizeResolvedEnv");
-    __name(isRecord, "isRecord");
-    __name(getProcessEnv, "getProcessEnv");
-  }
-});
-
 // src/app-markdown-config.ts
 function resolveMdxConfig(config) {
   return {
@@ -6780,7 +6918,7 @@ function mergeFarmLayerConfig(base, override) {
       output[key] = mergeConfigListResolvers(output[key], value);
       continue;
     }
-    if (isPlainObject(output[key]) && isPlainObject(value)) {
+    if (isPlainObject2(output[key]) && isPlainObject2(value)) {
       output[key] = mergePlainObjects(output[key], value);
       continue;
     }
@@ -6792,7 +6930,7 @@ function mergePlainObjects(base, override) {
   const output = { ...base };
   for (const [key, value] of Object.entries(override)) {
     if (value === void 0) continue;
-    output[key] = isPlainObject(output[key]) && isPlainObject(value) ? mergePlainObjects(output[key], value) : value;
+    output[key] = isPlainObject2(output[key]) && isPlainObject2(value) ? mergePlainObjects(output[key], value) : value;
   }
   return output;
 }
@@ -6807,7 +6945,7 @@ function toArray(value) {
   if (value === void 0 || value === null) return [];
   return Array.isArray(value) ? value : [value];
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -6884,7 +7022,7 @@ var init_layers = __esm({
     __name(mergeConfigListResolvers, "mergeConfigListResolvers");
     __name(resolveConfigList, "resolveConfigList");
     __name(toArray, "toArray");
-    __name(isPlainObject, "isPlainObject");
+    __name(isPlainObject2, "isPlainObject");
     __name(isPathLayerSource, "isPathLayerSource");
     __name(normalizeRealPath, "normalizeRealPath");
   }
@@ -11966,6 +12104,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;
@@ -11984,6 +12124,7 @@ var init_cache = __esm({
       configure(config = {}) {
         this.generation++;
         this.entries.clear();
+        this.entriesByTag.clear();
         this.inflight.clear();
         this.invalidatedTagVersions.clear();
         this.activeGenerations.clear();
@@ -12150,14 +12291,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));
         }
@@ -12168,6 +12307,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();
@@ -12253,23 +12393,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;
@@ -12310,7 +12459,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);
@@ -12355,18 +12504,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++;
           }
@@ -12374,10 +12514,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) {
@@ -12407,19 +12547,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));
+        }
+        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);
         }
-        this.pruneInvalidatedTagVersions();
+        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)
@@ -12814,6 +12986,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;
@@ -12835,7 +13008,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,
@@ -12845,7 +13020,7 @@ function createProgrammaticPageComponent(route, rendererRuntime) {
         createElement2(PageContent, props)
       );
     }, "FarmProgrammaticPage");
-    return FarmProgrammaticPage;
+    return markFunctionComponent(FarmProgrammaticPage);
   }
   const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
     try {
@@ -12864,7 +13039,7 @@ function createProgrammaticPageComponent(route, rendererRuntime) {
       throw error;
     }
   }, "FarmProgrammaticPageContent");
-  return FarmProgrammaticPageContent;
+  return markFunctionComponent(FarmProgrammaticPageContent);
 }
 function readProgrammaticRouteProps(route, props, resources) {
   if (isProgrammaticRoutePropsResolved(props)) {
@@ -14524,7 +14699,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) {
@@ -14537,11 +14712,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_path5.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;
@@ -15261,6 +15437,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();
@@ -16242,7 +16419,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("//")) {
@@ -17363,7 +17540,7 @@ async function readFarmI18nCatalogs(config) {
   return { catalogs, signatures };
 }
 function flattenFarmI18nCatalog(input, source = "i18n catalog") {
-  if (!isPlainObject2(input)) {
+  if (!isPlainObject3(input)) {
     throw new Error(`${source} must contain a JSON object at its root.`);
   }
   const output = {};
@@ -17377,7 +17554,7 @@ function flattenFarmI18nCatalog(input, source = "i18n catalog") {
       output[key] = value;
       return;
     }
-    if (!isPlainObject2(value)) {
+    if (!isPlainObject3(value)) {
       const key = segments.join(".") || "<root>";
       throw new Error(`${source} message "${key}" must be a string or nested object.`);
     }
@@ -17471,7 +17648,7 @@ function sameSignature(expected, actual) {
   const actualEntries = Object.entries(actual).sort(([a], [b]) => a.localeCompare(b));
   return JSON.stringify(expectedEntries) === JSON.stringify(actualEntries);
 }
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function messageOf(error) {
@@ -17491,7 +17668,7 @@ var init_catalog = __esm({
     __name(collectArguments, "collectArguments");
     __name(addArgument, "addArgument");
     __name(sameSignature, "sameSignature");
-    __name(isPlainObject2, "isPlainObject");
+    __name(isPlainObject3, "isPlainObject");
     __name(messageOf, "messageOf");
   }
 });
@@ -20387,7 +20564,7 @@ var init_server3 = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.15";
+    version = "0.1.17";
   }
 });
 
@@ -20815,7 +20992,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>
@@ -23653,7 +23830,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     wrappedHandler
   );
   endpoint.__path = path47 || void 0;
-  endpoint.__method = options.method || "GET";
+  endpoint.__method = options.method || (path47 ? "GET" : void 0);
   endpoint.__autoPath = !path47;
   endpoint.__handler = wrappedHandler;
   endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
@@ -24456,6 +24633,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();
@@ -27717,6 +27895,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(
@@ -27731,7 +27910,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" } : {}
             }
           }
         )
@@ -27761,6 +27941,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 } : {}
           }
         }
@@ -28705,6 +28886,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_path21, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
 var init_vite_config = __esm({
   "src/server/vite-config.ts"() {
@@ -28733,6 +28974,8 @@ var init_vite_config = __esm({
     __name(mergeNoExternal, "mergeNoExternal");
     __name(mergeAlias, "mergeAlias");
     __name(mergeFarmViteConfig, "mergeFarmViteConfig");
+    __name(mergeExternal, "mergeExternal");
+    __name(mergeFarmProductionViteConfig, "mergeFarmProductionViteConfig");
   }
 });
 
@@ -30355,7 +30598,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) {
@@ -30391,10 +30634,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 };
@@ -30413,7 +30662,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)
   };
@@ -30501,6 +30750,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");
@@ -36471,7 +36721,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;
 }
@@ -36734,8 +36984,8 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "emitPluginError");
       farmApp = new FarmApp(
         {
-          root: server.config.root,
-          ...options
+          ...options,
+          root: resolveDevelopmentRoot(options.root, server.config.root)
         },
         server
       );
@@ -37322,7 +37572,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;
@@ -37339,7 +37590,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);
@@ -37817,6 +38068,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) {
@@ -37890,7 +38156,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
                   ),
@@ -37978,27 +38245,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,
@@ -38008,7 +38282,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),
@@ -38756,6 +39032,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 (path43.resolve(farmRoot) === path43.resolve(viteRoot)) return farmRoot;
+  try {
+    if (fs15.realpathSync(farmRoot) === fs15.realpathSync(viteRoot)) {
+      return path43.resolve(viteRoot);
+    }
+  } catch {
+  }
+  return farmRoot;
+}
 function isFarmClientVirtualId(id) {
   const pathname = id.split("?", 1)[0];
   return pathname === "/@farm/client" || pathname === "/@farm/client.js";
@@ -38770,16 +39064,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" &&
@@ -38833,6 +39129,7 @@ const __farmRouteModule = __farmRoute.kind === "layout"
   : __farmCreatePageRouteModule(__farmRoute, {
       createElement: __farmCreateElement,
       Suspense: __farmSuspense,
+      markFunctionComponent: __farmMarkFunctionComponent,
     });
 
 export const metadata = __farmRouteModule.metadata;
@@ -40437,6 +40734,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) {
@@ -40866,6 +41168,7 @@ var fs15, path43, import_node_url12, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifact
 var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
+    init_env();
     init_app();
     init_utils();
     init_plugin();
@@ -40877,9 +41180,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();
@@ -41017,6 +41322,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");
@@ -41081,7 +41388,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)},
@@ -41585,7 +41892,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;
         };
@@ -41650,6 +41957,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();
@@ -41672,6 +41980,7 @@ __export(build_runtime_exports, {
 module.exports = __toCommonJS(build_runtime_exports);
 
 // src/build/index.ts
+init_env();
 init_config4();
 var import_path17 = __toESM(require("path"));
 var import_node_fs14 = require("fs");
@@ -41682,6 +41991,7 @@ init_server_path();
 init_layers();
 
 // src/nitro/universal-build.ts
+init_env();
 init_config4();
 
 // src/nitro/client-css-href.ts
@@ -43793,7 +44103,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.
@@ -43929,7 +44239,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 {
@@ -46275,7 +46586,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     "react-dom/server"
   ];
   try {
-    await viteBuild({
+    const serverViteConfig = {
       root,
       build: {
         target: "esnext",
@@ -46366,7 +46677,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: [
@@ -46436,7 +46747,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 {
@@ -48644,7 +48956,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;
   }
@@ -48680,7 +48992,7 @@ function getFarmPluginRequestOptions(request) {
   const route = { pathname };
   if (
     farmOpenAPIReference &&
-    normalizeRuntimePath(pathname) === normalizeRuntimePath(farmOpenAPIReference.route)
+    normalizeRuntimePath(stripFarmBasePath(pathname)) === normalizeRuntimePath(farmOpenAPIReference.route)
   ) {
     return {
       kind: "docs",
@@ -49009,9 +49321,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;
@@ -49199,7 +49512,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"
@@ -49223,7 +49536,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"
@@ -49761,12 +50074,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;
         
@@ -51817,7 +52133,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: [
@@ -51900,7 +52216,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");