@farm.js/core 0.1.28 → 0.1.30

package/dist/{chunk-FVCSLZWT.mjs → chunk-IVLUJUT4.mjs}

@@ -4,10 +4,13 @@ import {
 import {
   withProductionNodeEnv
 } from "./chunk-655RLQQL.mjs";
+import {
+  generateNativeMCPPluginSource
+} from "./chunk-FXEF4PPL.mjs";
 import {
   compileFarmDocsAdapterEdgeManifest,
   createFarmDocsAPIHandler
-} from "./chunk-2CNBR3EB.mjs";
+} from "./chunk-2UABTL3Y.mjs";
 import {
   FARM_DOCS_LAST_MODIFIED_MANIFEST,
   createFarmDocsHandler,
@@ -17,7 +20,7 @@ import {
   loadFarmDocsPage,
   resolveFarmDocsContentDir,
   toFarmDocsMarkdownPage
-} from "./chunk-T7HQ3I4C.mjs";
+} from "./chunk-PQD2AI3B.mjs";
 import {
   generateFarmDocsSearchClientRuntime,
   isFarmDocsSearchEnabled,
@@ -34,7 +37,7 @@ import {
   getDeployTargetForPreset,
   hasCustomFarmRouteContext,
   resolveDeployOutputPath
-} from "./chunk-PZPDGOU5.mjs";
+} from "./chunk-7CXKSRKL.mjs";
 import {
   resolveFarmInstrumentationFile
 } from "./chunk-ZZSRYEYU.mjs";
@@ -70,7 +73,7 @@ import {
   resolveFarmImageProviderForRuntime,
   resolveFarmIsolatedClientHydrationMode,
   resolveFarmNotFoundComponentPath
-} from "./chunk-ZRIE4KMG.mjs";
+} from "./chunk-S4K74WI4.mjs";
 import {
   findRequestBoundSourceBlockers,
   generateFarmTypeArtifacts,
@@ -80,7 +83,7 @@ import {
 import {
   FARM_API_CATALOG_PATH,
   resolveFarmApiCatalogInput
-} from "./chunk-FB3H4INL.mjs";
+} from "./chunk-D234YWNA.mjs";
 import {
   isFarmPreviewDeploymentEnvironment
 } from "./chunk-BOYNDCZL.mjs";
@@ -112,7 +115,7 @@ import {
 } from "./chunk-DAATZTKJ.mjs";
 import {
   applyFarmCspHashesToHtml
-} from "./chunk-REGFZJEJ.mjs";
+} from "./chunk-YMUE7L3D.mjs";
 import {
   applyFarmCronVercelCrons,
   createFarmCronCloudflareConfig,
@@ -124,14 +127,14 @@ import {
 } from "./chunk-4OOBRCJX.mjs";
 import {
   isFarmMarkdownPageFile
-} from "./chunk-2DLN6HG4.mjs";
+} from "./chunk-BZ3CHOFX.mjs";
 import {
   resolveFarmMdxComponentsModulePath,
   resolveMdxConfig
 } from "./chunk-FA2W42OV.mjs";
 import {
   getFarmMarkdownAlternatePath
-} from "./chunk-K3YEZLSY.mjs";
+} from "./chunk-ATXI6LGT.mjs";
 import {
   applyFarmWorkflowVercelCrons,
   prepareFarmWorkflowsForNitro
@@ -1255,6 +1258,19 @@ function isNitroRollupExternal(id) {
 }
 __name(isNitroRollupExternal, "isNitroRollupExternal");
 var FARM_METADATA_IMAGE_WASM_PREFIX = "\0farm-metadata-image-wasm:";
+function createReactProductionModePlugin() {
+  const nodeEnvExpression = ["process", "env", "NODE_ENV"].join(".");
+  return {
+    name: "farm-react-production-mode",
+    transform(code, id) {
+      const normalizedId = id.replace(/\\/g, "/");
+      const isReactRuntime = normalizedId.includes("/node_modules/react/") || normalizedId.includes("/node_modules/react-dom/");
+      if (!isReactRuntime || !code.includes(nodeEnvExpression)) return null;
+      return { code: code.split(nodeEnvExpression).join('"production"'), map: null };
+    }
+  };
+}
+__name(createReactProductionModePlugin, "createReactProductionModePlugin");
 function createMetadataImageWasmPlugin() {
   return {
     name: "farm-metadata-image-wasm",
@@ -1349,42 +1365,75 @@ async function minifyFarmServerChunk(code, fileName, options) {
 }
 __name(minifyFarmServerChunk, "minifyFarmServerChunk");
 function restoreLiteralModuleSpecifiers(code, fileName, { parseSync, Visitor }) {
-  if (!code.includes("import(`") && !code.includes("require(`")) return code;
+  const hasImportTemplate = code.includes("import(`");
+  const hasRequireTemplate = code.includes("require(`");
+  if (!hasImportTemplate && !hasRequireTemplate) return code;
   const parsed = parseSync(fileName, code, { lang: "js", sourceType: "module" });
   if (parsed.errors.length > 0) {
     throw new Error(`Failed to minify ${fileName}: ${parsed.errors[0].message}`);
   }
   const replacements = [];
-  const restore = /* @__PURE__ */ __name((node) => {
-    if (node?.type !== "TemplateLiteral") return;
-    const template = node;
-    const value = template.quasis[0]?.value.cooked;
-    if (template.expressions.length > 0 || typeof value !== "string") return;
-    const text = JSON.stringify(value).replace(
-      /[\u007f-￿]/g,
-      (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`
-    );
-    replacements.push({ start: template.start, end: template.end, text });
-  }, "restore");
-  new Visitor({
-    ImportExpression(node) {
-      restore(node.source);
-    },
-    CallExpression(node) {
-      if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1) {
-        restore(node.arguments[0]);
+  let needsAst = hasRequireTemplate;
+  if (!needsAst) {
+    const seenStarts = /* @__PURE__ */ new Set();
+    for (const { moduleRequest } of parsed.module.dynamicImports) {
+      if (seenStarts.has(moduleRequest.start)) continue;
+      seenStarts.add(moduleRequest.start);
+      const source = code.slice(moduleRequest.start, moduleRequest.end);
+      if (!source.startsWith("`")) continue;
+      const value = source.slice(1, -1);
+      if (source.length < 2 || !source.endsWith("`") || /[\\\r\n`]|\$\{/.test(value)) {
+        needsAst = true;
+        break;
       }
+      replacements.push({
+        start: moduleRequest.start,
+        end: moduleRequest.end,
+        text: toAsciiStringLiteral(value)
+      });
     }
-  }).visit(parsed.program);
+  }
+  if (needsAst) {
+    replacements.length = 0;
+    const restore = /* @__PURE__ */ __name((node) => {
+      if (node?.type !== "TemplateLiteral") return;
+      const template = node;
+      const value = template.quasis[0]?.value.cooked;
+      if (template.expressions.length > 0 || typeof value !== "string") return;
+      replacements.push({
+        start: template.start,
+        end: template.end,
+        text: toAsciiStringLiteral(value)
+      });
+    }, "restore");
+    new Visitor({
+      ImportExpression(node) {
+        restore(node.source);
+      },
+      CallExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1) {
+          restore(node.arguments[0]);
+        }
+      }
+    }).visit(parsed.program);
+  }
   let restored = "";
   let offset = 0;
   for (const { start, end, text } of replacements.sort((a, b) => a.start - b.start)) {
+    if (start < offset) continue;
     restored += code.slice(offset, start) + text;
     offset = end;
   }
   return restored + code.slice(offset);
 }
 __name(restoreLiteralModuleSpecifiers, "restoreLiteralModuleSpecifiers");
+function toAsciiStringLiteral(value) {
+  return JSON.stringify(value).replace(
+    /[\u007f-￿]/g,
+    (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+__name(toAsciiStringLiteral, "toAsciiStringLiteral");
 function createServerChunkMinifyPlugin(options) {
   return {
     name: "farm-server-chunk-minify",
@@ -4713,20 +4762,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         ...rendererVitePlugins,
         ...config.vite.plugins || [],
         ...!useExternalMetadataImageRuntime && metadataImageRoutes.some((image) => image.sourceType === "module") ? [createMetadataImageWasmPlugin()] : [],
-        {
-          name: "farm-react-production-mode",
-          enforce: "pre",
-          transform(code, id) {
-            const normalizedId = id.replace(/\\/g, "/");
-            const isReactRuntime = normalizedId.includes("/node_modules/react/") || normalizedId.includes("/node_modules/react-dom/");
-            const nodeEnvExpression = ["process", "env", "NODE_ENV"].join(".");
-            if (!isReactRuntime || !code.includes(nodeEnvExpression)) return null;
-            return {
-              code: code.split(nodeEnvExpression).join('"production"'),
-              map: null
-            };
-          }
-        },
+        { ...createReactProductionModePlugin(), enforce: "pre" },
         farmServerOnlyEntriesPlugin(),
         farmPlugin({ ...config, isolatedClientBoundaryModules }, pluginManager),
         farmEnvironmentFunctionsPlugin(),
@@ -4857,44 +4893,6 @@ function generateNativeAuthIntegrationSource(auth) {
   };
 }
 __name(generateNativeAuthIntegrationSource, "generateNativeAuthIntegrationSource");
-function generateNativeMCPPluginSource(mcp) {
-  if (mcp?.enabled !== true) {
-    return { importSource: "", registerSource: "", pluginSource: "" };
-  }
-  return {
-    importSource: `import { createFarmMCPPlugin as __farmCreateMCPPlugin } from "@farm.js/mcp/internal";`,
-    registerSource: `function __farmMCPIsPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-
-function __farmMergeMCPConfig(base, override) {
-  const output = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === undefined) continue;
-    output[key] =
-      __farmMCPIsPlainObject(output[key]) && __farmMCPIsPlainObject(value)
-        ? __farmMergeMCPConfig(output[key], value)
-        : value;
-  }
-  return output;
-}
-
-const farmNativeMCPConfig = farmRuntimeConfigs.reduce((merged, runtimeConfig) => {
-  const value = runtimeConfig?.mcp;
-  if (value === undefined) return merged;
-  if (value === false) return false;
-  return __farmMergeMCPConfig(merged && merged !== false ? merged : {}, value);
-}, undefined);
-const farmNativeMCPPlugin =
-  farmNativeMCPConfig && farmNativeMCPConfig.enabled !== false
-    ? __farmCreateMCPPlugin(farmNativeMCPConfig)
-    : null;`,
-    pluginSource: `...(farmNativeMCPPlugin ? [farmNativeMCPPlugin] : []),`
-  };
-}
-__name(generateNativeMCPPluginSource, "generateNativeMCPPluginSource");
 function generateIntegrationRequestRuntimeSource(options) {
   return `
 function matchLocalIntegrationRequest(request) {
@@ -4945,6 +4943,24 @@ function getConfiguredSetCookieHeaders(headers) {
   return value ? [value] : [];
 }
 
+// Owned responses (core's owned-response.ts, RFC 0002) are edited in place.
+function farmEditableHeaders(response) {
+  return (globalThis[Symbol.for("farm.ownedResponses")] ??= new WeakSet()).has(response)
+    ? response.headers
+    : new Headers(response.headers);
+}
+
+function farmResponseWithHeaders(response, headers) {
+  if (!headers || headers === response.headers) return response;
+  const output = new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+  (globalThis[Symbol.for("farm.ownedResponses")] ??= new WeakSet()).add(output);
+  return output;
+}
+
 function applyConfiguredResponseHeaders(response, pathname) {
   if (preparedHeaderRoutes.length === 0) return response;
   const pathnameSegments = splitRuntimePath(pathname).map(decodeRouteSegment);
@@ -4959,12 +4975,12 @@ function applyConfiguredResponseHeaders(response, pathname) {
       const normalizedKey = header.key.toLowerCase();
       if (normalizedKey === "set-cookie") {
         if (getConfiguredSetCookieHeaders(currentHeaders).includes(header.value)) continue;
-        if (!headers) headers = new Headers(response.headers);
+        if (!headers) headers = farmEditableHeaders(response);
         headers.append("Set-Cookie", header.value);
       } else {
         const currentValue = currentHeaders.get(header.key);
         if (currentValue === header.value) continue;
-        if (!headers) headers = new Headers(response.headers);
+        if (!headers) headers = farmEditableHeaders(response);
         if (normalizedKey === "link") {
           appendFarmLinkHeader(headers, header.value);
         } else {
@@ -4974,12 +4990,7 @@ function applyConfiguredResponseHeaders(response, pathname) {
     }
   }
 
-  if (!headers) return response;
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers,
-  });
+  return farmResponseWithHeaders(response, headers);
 }
 `.trim();
 }
@@ -5006,7 +5017,73 @@ function generatePreloadResponseRuntimeSource() {
 // reading it, so a changed body is never paired with a stale string.
 const farmBufferedHtml = new WeakMap();
 
+// A Response Farm creates for this request. Later header steps edit it in place
+// instead of copying it; responses from app code are never owned. Same registry
+// as core's owned-response.ts (RFC 0002).
+function farmOwnedResponse(body, init) {
+  const response = new Response(body, init);
+  (globalThis[Symbol.for("farm.ownedResponses")] ??= new WeakSet()).add(response);
+  return response;
+}
+
+// node-server registers srvx's FastResponse here (RFC 0002). A buffered page
+// built with it keeps its HTML as a string until something reads the body, and
+// srvx writes that string in one call; other runtimes keep the Web Response.
+let FarmNodePageResponse;
+function useFarmNodePageResponse(ResponseClass) {
+  FarmNodePageResponse = ResponseClass;
+}
+
+// HTML of buffered pages built as FarmNodePageResponse, keyed by the response:
+// its body always comes from this string, and looking it up never creates the
+// Web body the way reading response.body would.
+const farmLazyBufferedHtml = new WeakMap();
+
+function hasFarmContentType(headers) {
+  if (!headers) return false;
+  if (typeof headers.has === "function") return headers.has("content-type");
+  for (const key in headers) if (key.toLowerCase() === "content-type") return true;
+  return false;
+}
+
+// A complete HTML document Farm built for this request. Same contract as
+// farmOwnedResponse followed by rememberFarmBufferedHtml.
+function farmOwnedHtmlResponse(html, init) {
+  if (
+    !FarmNodePageResponse ||
+    typeof html !== "string" ||
+    html.charCodeAt(0) === 0xfeff ||
+    !hasFarmContentType(init?.headers)
+  ) {
+    return rememberFarmBufferedHtml(farmOwnedResponse(html, init), html);
+  }
+  const response = new FarmNodePageResponse(html, init);
+  (globalThis[Symbol.for("farm.ownedResponses")] ??= new WeakSet()).add(response);
+  farmLazyBufferedHtml.set(response, html);
+  return response;
+}
+
+function isFarmOwnedResponseForPreload(response) {
+  return (globalThis[Symbol.for("farm.ownedResponses")] ??= new WeakSet()).has(response);
+}
+
+// Header-only rebuild: in place for an owned response, otherwise a copy Farm owns.
+function farmPreloadHeadersResponse(response, edit) {
+  if (isFarmOwnedResponseForPreload(response)) {
+    edit(response.headers);
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  edit(headers);
+  return farmOwnedResponse(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
 function rememberFarmBufferedHtml(response, html) {
+  if (farmLazyBufferedHtml.has(response)) return response;
   // Response.text() strips a leading BOM, so a BOM document keeps reading its
   // body to preserve that behavior.
   if (typeof html === "string" && html.charCodeAt(0) !== 0xfeff && response.body) {
@@ -5016,6 +5093,8 @@ function rememberFarmBufferedHtml(response, html) {
 }
 
 function getFarmOwnedBufferedHtml(response) {
+  const lazyHtml = farmLazyBufferedHtml.get(response);
+  if (lazyHtml !== undefined) return lazyHtml;
   const body = response.body;
   if (!body || response.bodyUsed || body.locked) return undefined;
   return farmBufferedHtml.get(body);
@@ -5038,17 +5117,14 @@ async function applyFarmPreloadBudget(response, pathname, request) {
   const isBuffered = bufferedMarker === "1" || hasNoHtmlPreloads;
   if (!isHtml) {
     if (!isStreaming && !isBuffered) return response;
-    headers = new Headers(headers);
-    headers.delete("x-farm-preload-streaming");
-    headers.delete("x-farm-preload-buffered");
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers,
+    return farmPreloadHeadersResponse(response, (editable) => {
+      editable.delete("x-farm-preload-streaming");
+      editable.delete("x-farm-preload-buffered");
     });
   }
 
-  if (isStreaming || !isBuffered || response.body === null) {
+  const isLazyPage = farmLazyBufferedHtml.has(response);
+  if (isStreaming || !isBuffered || (!isLazyPage && response.body === null)) {
     const managed = manageFarmLinkHeaderPreloads(linkHeader, farmPreloadConfig);
     reportFarmPreloadWarnings(managed.warnings, managed.warnings.length > 0
       ? "route " + (pathname ?? getFarmRoutePathname(new URL(request.url).pathname))
@@ -5058,42 +5134,43 @@ async function applyFarmPreloadBudget(response, pathname, request) {
     if (!headers.has("x-farm-preload-streaming") &&
         !headers.has("x-farm-preload-buffered") &&
         (managed.value || null) === headers.get("Link")) return response;
-    headers = new Headers(headers);
-    headers.delete("x-farm-preload-streaming");
-    headers.delete("x-farm-preload-buffered");
-    if (managed.value) headers.set("Link", managed.value);
-    else headers.delete("Link");
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers,
+    return farmPreloadHeadersResponse(response, (editable) => {
+      editable.delete("x-farm-preload-streaming");
+      editable.delete("x-farm-preload-buffered");
+      if (managed.value) editable.set("Link", managed.value);
+      else editable.delete("Link");
     });
   }
 
   // Keep the document/header budget semantics (including unchanged Link
   // formatting), but do not consume and re-encode a proven preload-free body.
-  headers = new Headers(headers);
-  headers.delete("x-farm-preload-streaming");
-  headers.delete("x-farm-preload-buffered");
   const ownedHtml = hasNoHtmlPreloads ? undefined : getFarmOwnedBufferedHtml(response);
   const html = hasNoHtmlPreloads ? "" : (ownedHtml ?? await response.text());
   const managed = manageFarmDocumentPreloads(html, linkHeader, farmPreloadConfig);
   // A remembered document the budget left unchanged keeps its unread body.
   const reusesBody = hasNoHtmlPreloads || (ownedHtml !== undefined && managed.html === html);
-  if (ownedHtml !== undefined && !reusesBody) response.body?.cancel().catch(() => {});
-  if (managed.linkHeader) headers.set("Link", managed.linkHeader);
-  else headers.delete("Link");
-  if (managed.html !== html) headers.delete("Content-Length");
+  if (ownedHtml !== undefined && !reusesBody && !isLazyPage) {
+    response.body?.cancel().catch(() => {});
+  }
   reportFarmPreloadWarnings(managed.warnings, managed.warnings.length > 0
     ? "route " + (pathname ?? getFarmRoutePathname(new URL(request.url).pathname))
     : undefined);
-  const output = new Response(reusesBody ? response.body : managed.html, {
+  const applyBudgetHeaders = (editable) => {
+    editable.delete("x-farm-preload-streaming");
+    editable.delete("x-farm-preload-buffered");
+    if (managed.linkHeader) editable.set("Link", managed.linkHeader);
+    else editable.delete("Link");
+    if (managed.html !== html) editable.delete("Content-Length");
+  };
+  if (reusesBody) return farmPreloadHeadersResponse(response, applyBudgetHeaders);
+  const rebuiltHeaders = new Headers(headers);
+  applyBudgetHeaders(rebuiltHeaders);
+  // A rebuilt document is still a complete string Farm holds.
+  return farmOwnedHtmlResponse(managed.html, {
     status: response.status,
     statusText: response.statusText,
-    headers,
+    headers: rebuiltHeaders,
   });
-  // A rebuilt document is still a complete string Farm holds.
-  return reusesBody ? output : rememberFarmBufferedHtml(output, managed.html);
 }
 `.trim();
 }
@@ -5126,6 +5203,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
     config.renderer,
     getFarmPresetRuntime(preset)
   );
+  const hasReactSyncRender = isReactRenderer(config.renderer);
   const rendererServerImports = isReactRenderer(config.renderer) ? `import * as React from "react";
 import * as ReactDOMServer from "react-dom/server";${hasIsolatedClientGraphRuntime ? '\nimport { isolateFarmServerPageGraph, wrapFarmIsolatedClientGraph } from "@farm.js/core/internal/isolated-boundary";' : ""}` : `import React, * as ReactDOMServer from ${JSON.stringify(config.renderer.server)};${generateFarmRendererAppSetupServerCode(config)}`;
   const routeClientGraphServerRuntime = hasIsolatedClientGraphRuntime ? `function wrapFarmRouteClientGraph(element) {
@@ -5651,6 +5729,7 @@ ${routeClientGraphServerRuntime}
 
 const farmRendererStreamingCapabilities = ${JSON.stringify(rendererStreamingCapabilities)};
 const farmRendererName = ${JSON.stringify(config.renderer.name)};
+const farmReactSyncRender = ${JSON.stringify(hasReactSyncRender)};
 const farmRendererRuntime = ${JSON.stringify(getFarmPresetRuntime(preset))};
 const farmRendererRuntimeStreamingCapabilities = ReactDOMServer.capabilities &&
   ReactDOMServer.capabilities.streaming;
@@ -6050,8 +6129,10 @@ function escapeFarmHtmlAttribute(value) {
     .replace(/>/g, "&gt;");
 }
 
-async function renderFarmElement(ReactDOMServer, element) {
+async function renderFarmElement(ReactDOMServer, element, routeKey) {
   const streamErrors = [];
+  const syncHtml = renderFarmElementSync(ReactDOMServer, element, routeKey);
+  if (syncHtml !== undefined) return { html: syncHtml, shellHtml: syncHtml, streamErrors };
   let encoder;
   const normalizeChunk = function(chunk) {
     if (typeof chunk === "string") return (encoder ||= new TextEncoder()).encode(chunk);
@@ -6122,6 +6203,7 @@ async function renderFarmElement(ReactDOMServer, element) {
       }
       throwStreamError();
       const html = decodeChunks(chunks);
+      rememberFarmSyncRender(routeKey, html);
       return { html, shellHtml: html, streamErrors };
     }
 
@@ -6253,6 +6335,7 @@ async function renderFarmElement(ReactDOMServer, element) {
       await complete;
       throwStreamError();
       const html = decodeChunks(chunks);
+      rememberFarmSyncRender(routeKey, html);
       return { html, shellHtml: html, streamErrors };
     }
 
@@ -6293,6 +6376,45 @@ async function renderFarmElementToString(ReactDOMServer, element) {
   return html;
 }
 
+// Most pages render without suspending. React's renderToString renders them in
+// one synchronous pass with string output, about half the CPU of the streaming
+// renderer, and the same markup, except that React 19's streaming renderer adds
+// a doctype before an <html> root. A route uses it only after a streaming render
+// of that route finished without suspending (remembering whether that render
+// started with a doctype), so a page that suspends keeps streaming and renders
+// once. If such a route suspends later (a Suspense boundary left to the
+// client, marked <!--$!-->, or a throw), that request renders again through the
+// streaming path and the route streams for the rest of this server process.
+const farmSyncRenderRoutes = new Map();
+const farmStreamingRenderRoutes = new Set();
+const FARM_STREAMED_DOCTYPE = "<!DOCTYPE html>";
+
+function rememberFarmSyncRender(routeKey, streamedHtml) {
+  if (!farmReactSyncRender || routeKey === undefined) return;
+  if (!farmStreamingRenderRoutes.has(routeKey)) {
+    farmSyncRenderRoutes.set(routeKey, streamedHtml.startsWith(FARM_STREAMED_DOCTYPE));
+  }
+}
+
+function renderFarmElementSync(ReactDOMServer, element, routeKey) {
+  if (!farmReactSyncRender) return undefined;
+  const addsDoctype = routeKey === undefined ? undefined : farmSyncRenderRoutes.get(routeKey);
+  if (addsDoctype === undefined) return undefined;
+  if (typeof ReactDOMServer.renderToString !== "function") return undefined;
+  let html;
+  try {
+    html = ReactDOMServer.renderToString(element);
+  } catch {
+    html = undefined;
+  }
+  if (typeof html !== "string" || html.includes("<!--$!-->")) {
+    farmSyncRenderRoutes.delete(routeKey);
+    farmStreamingRenderRoutes.add(routeKey);
+    return undefined;
+  }
+  return addsDoctype && html.startsWith("<html") ? FARM_STREAMED_DOCTYPE + html : html;
+}
+
 function createFarmDocumentStream(contentStream, prefix, suffix, onComplete) {
   const encoder = new TextEncoder();
   const reader = contentStream.getReader();
@@ -7422,7 +7544,7 @@ async function handleFarmRequestInContext(
       url.search,
     );
     if (redirectMatch) {
-      return new Response("Redirecting to " + redirectMatch.destination, {
+      return farmOwnedResponse("Redirecting to " + redirectMatch.destination, {
         status: redirectMatch.statusCode,
         headers: { Location: redirectMatch.destination },
       });
@@ -7526,7 +7648,7 @@ async function handleFarmRequestInContext(
       );
       const docsHeaders = new Headers(wrappedDocsResponse.headers);
       docsHeaders.set("x-farm-preload-buffered", "1");
-      return applyProductionMiddlewareHeaders(new Response(wrappedDocsResponse.body, {
+      return applyProductionMiddlewareHeaders(farmOwnedResponse(wrappedDocsResponse.body, {
         status: wrappedDocsResponse.status,
         statusText: wrappedDocsResponse.statusText,
         headers: docsHeaders,
@@ -7572,9 +7694,13 @@ async function handleFarmRequestInContext(
   ` : ""}
 
   ${apiRoutes.length > 0 ? `
-  const apiResponse = await handleAPIRequest(cloneFarmRequestWithContext(request));
-  if (apiResponse) {
-    return applyProductionMiddlewareHeaders(apiResponse, middlewareHeaders);
+  // Clone only for an API request: cloning a Request costs more than the match,
+  // and handleAPIRequest returns null without one.
+  if (matchLocalAPIRequest(request)) {
+    const apiResponse = await handleAPIRequest(cloneFarmRequestWithContext(request));
+    if (apiResponse) {
+      return applyProductionMiddlewareHeaders(apiResponse, middlewareHeaders);
+    }
   }
   ` : ""}
 
@@ -7585,7 +7711,7 @@ async function handleFarmRequestInContext(
   ) {
     const method = request.method.toUpperCase();
     const specResponse = method === "GET" || method === "HEAD"
-      ? new Response(method === "HEAD" ? null : JSON.stringify(farmOpenAPIReference.spec), {
+      ? farmOwnedResponse(method === "HEAD" ? null : JSON.stringify(farmOpenAPIReference.spec), {
           status: 200,
           headers: {
             "Content-Type": "application/json; charset=utf-8",
@@ -7593,7 +7719,7 @@ async function handleFarmRequestInContext(
             "X-Content-Type-Options": "nosniff",
           },
         })
-      : new Response("Method Not Allowed", {
+      : farmOwnedResponse("Method Not Allowed", {
           status: 405,
           headers: {
             "Allow": "GET, HEAD",
@@ -7609,7 +7735,7 @@ async function handleFarmRequestInContext(
   ) {
     const method = request.method.toUpperCase();
     const response = method === "GET" || method === "HEAD"
-      ? new Response(method === "HEAD" ? null : farmOpenAPIReference.html, {
+      ? farmOwnedResponse(method === "HEAD" ? null : farmOpenAPIReference.html, {
           status: 200,
           headers: {
             "Content-Type": "text/html; charset=utf-8",
@@ -7617,7 +7743,7 @@ async function handleFarmRequestInContext(
             "X-Content-Type-Options": "nosniff",
           },
         })
-      : new Response("Method Not Allowed", {
+      : farmOwnedResponse("Method Not Allowed", {
           status: 405,
           headers: {
             "Allow": "GET, HEAD",
@@ -7712,7 +7838,7 @@ async function handleFarmRequestInContext(
 
   // Preserve the explicit JSON 404 for misses below the configured local API path.
   if (isFarmLocalAPIPathname(pathname)) {
-    return applyProductionMiddlewareHeaders(new Response(
+    return applyProductionMiddlewareHeaders(farmOwnedResponse(
       JSON.stringify({ error: "API route not found", pathname }),
       { status: 404, headers: { "Content-Type": "application/json" } }
     ), middlewareHeaders);
@@ -7728,7 +7854,7 @@ async function handleFarmRequestInContext(
     );
     if (trailingSlashLocation) {
       return applyProductionMiddlewareHeaders(
-        new Response(null, {
+        farmOwnedResponse(null, {
           status: 308,
           headers: { Location: trailingSlashLocation },
         }),
@@ -7771,7 +7897,7 @@ async function handleFarmRequestInContext(
             status: 200,
             durationMs: Date.now() - requestStartTime,
           });
-          return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(new Response(cachedPPRShell, {
+          return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(farmOwnedHtmlResponse(cachedPPRShell, {
             status: 200,
             headers: {
               "Content-Type": "text/html; charset=utf-8",
@@ -8078,7 +8204,7 @@ async function handleFarmRequestInContext(
           }
 
           wrappedElement = wrapWithFarmIntegrationProviders(wrappedElement);
-          return renderFarmElement(ReactDOMServer, wrappedElement);
+          return renderFarmElement(ReactDOMServer, wrappedElement, route.pattern);
         };
         const renderedPage = ${hasMiddlewareRuntime ? `await _runWithMiddlewareData(middlewareData, () =>
           _runWithMiddlewareContext(middlewareContext, renderPageElement)
@@ -8266,7 +8392,7 @@ async function handleFarmRequestInContext(
               });
             }
           );
-          return applyProductionMiddlewareHeaders(new Response(streamedDocument, {
+          return applyProductionMiddlewareHeaders(farmOwnedResponse(streamedDocument, {
             status: pageStatus,
             headers: { ...responseHeaders, "x-farm-preload-streaming": "1" },
           }), middlewareHeaders);
@@ -8407,7 +8533,7 @@ async function handleFarmRequestInContext(
           durationMs: Date.now() - requestStartTime,
         });
 
-        return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(new Response(
+        return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(farmOwnedHtmlResponse(
           fullHtml,
           { 
             status: pageStatus,
@@ -8441,7 +8567,7 @@ async function handleFarmRequestInContext(
           status: redirect.status,
           durationMs: Date.now() - requestStartTime,
         });
-        return applyProductionMiddlewareHeaders(new Response(null, {
+        return applyProductionMiddlewareHeaders(farmOwnedResponse(null, {
           status: redirect.status,
           headers: {
             Location: redirectUrl,
@@ -8509,7 +8635,7 @@ async function handleFarmRequestInContext(
             status: errorStatus,
             durationMs: Date.now() - requestStartTime,
           });
-          return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(new Response(errorDocument, {
+          return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(farmOwnedHtmlResponse(errorDocument, {
             status: errorStatus,
             headers: {
               "Content-Type": "text/html; charset=utf-8",
@@ -8544,7 +8670,7 @@ async function handleFarmRequestInContext(
         farmResolvedRuntimeConfig.basePath,
         getFarmTheme(request)
       );
-      return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(new Response(
+      return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(farmOwnedHtmlResponse(
         fallbackDocument,
         {
           status: errorStatus,
@@ -8575,7 +8701,7 @@ async function handleFarmRequestInContext(
       status: 404,
       durationMs: Date.now() - requestStartTime,
     });
-    return applyProductionMiddlewareHeaders(new Response(
+    return applyProductionMiddlewareHeaders(farmOwnedResponse(
       createFarmMarkdownErrorBody(404, pathname, applyFarmBasePath("/", farmResolvedRuntimeConfig.basePath)),
       {
         status: 404,
@@ -8672,7 +8798,7 @@ async function handleFarmRequestInContext(
       durationMs: Date.now() - requestStartTime,
     });
 
-    return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(new Response(fullHtml, {
+    return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(farmOwnedHtmlResponse(fullHtml, {
       status: 404,
       headers: {
         "Content-Type": "text/html; charset=utf-8",
@@ -8687,7 +8813,7 @@ async function handleFarmRequestInContext(
       farmResolvedRuntimeConfig.basePath,
       getFarmTheme(request)
     );
-    return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(new Response(
+    return rememberFarmBufferedHtml(applyProductionMiddlewareHeaders(farmOwnedHtmlResponse(
       fallbackDocument,
       {
         status: 404,
@@ -8750,11 +8876,11 @@ async function handleFarmPluginRequest(request, runtimeOptions, adapterContext)
   headers.delete("content-length");
   headers.delete("x-farm-preload-streaming");
   headers.set("x-farm-preload-buffered", getFarmBufferedPreloadMarker(html));
-  return rememberFarmBufferedHtml(new Response(html, {
+  return farmOwnedHtmlResponse(html, {
     status: response.status,
     statusText: response.statusText,
     headers,
-  }), html);
+  });
 }
 
 ${generatePreloadResponseRuntimeSource()}
@@ -8831,7 +8957,7 @@ async function handleFarmFetch(request, context) {
         const response = await _runWithCurrentRequest(request, () =>
           _runWithAfterRequest(request, runRequest, context),
         );
-        return ${hasCompressionRuntime && !hasPluginRuntime ? "compressFarmResponse(request, response, getFarmOwnedBufferedHtml(response))" : "response"};
+        return ${hasCompressionRuntime && !hasPluginRuntime ? "compressFarmResponse(request, response, getFarmOwnedBufferedHtml(response), farmLazyBufferedHtml.has(response))" : "response"};
       }),
     {
       onResponseFinished: typeof context?.onResponseFinished === "function"
@@ -8840,7 +8966,7 @@ async function handleFarmFetch(request, context) {
     },
   );
 }
-export { createFarmNodeRequestAbortSignal };
+export { createFarmNodeRequestAbortSignal, getFarmOwnedBufferedHtml, useFarmNodePageResponse };
 export default { fetch, lifecycle: farmProductionLifecycle };
   `.trim();
 }
@@ -9081,12 +9207,16 @@ async function buildNitroUniversal(config, routeManager, apiRouteManager, server
     await fs.writeFile(filePath, output.type === "chunk" ? output.code : output.source);
   }
   const nitroEntryPath = path5.join(ssrOutputDir, "nitro-entry.mjs");
+  const nodeAdapterModule = preset === "node-server" ? resolveNitroRuntimeDependency(root, "srvx/node") : null;
   const nitroEntryCode = `
 // Farm.js Nitro Entry
 // This file adapts Farm's Web fetch handler to Nitro's event handler contract.
 
 import { useNitroHooks } from '#nitro/runtime/app'
-import handler, { farmProductionLifecycle, createFarmNodeRequestAbortSignal } from './${ssrEntryFile}'
+import handler, { farmProductionLifecycle, createFarmNodeRequestAbortSignal${nodeAdapterModule ? ", getFarmOwnedBufferedHtml, useFarmNodePageResponse" : ""} } from './${ssrEntryFile}'${nodeAdapterModule ? `
+import { FastResponse } from ${JSON.stringify(nodeAdapterModule)}
+
+useFarmNodePageResponse(FastResponse)` : ""}
 
 export { farmProductionLifecycle }
 
@@ -9182,11 +9312,14 @@ function resolveTrustedLocalOrigin(event, request) {
 // Export the event handler for Nitro
 export default async function farmNitroEventHandler(event) {
   registerFarmCloseHook()
-  // Some Node adapters abort their Request on normal IncomingMessage close.
-  // Use the same actual disconnect events as Farm's development server.
+  // Abort only on an actual disconnect, the same events as Farm's development
+  // server. srvx's Request already aborts that way (on a response close before
+  // it ended, never on a normal IncomingMessage close), so use it as is. Other
+  // Node adapters get a copy with Farm's own signal.
   const node = event.node
-  const webRequest = event.req?._request || event.req
-  const request = node?.req && node?.res
+  const srvxRequest = event.req?._request
+  const webRequest = srvxRequest || event.req
+  const request = !srvxRequest && node?.req && node?.res
     ? new Request(webRequest, { signal: createFarmNodeRequestAbortSignal(node.req, node.res) })
     : webRequest
   const response = await handler.fetch(request, {
@@ -9197,20 +9330,42 @@ export default async function farmNitroEventHandler(event) {
   })
 
   // Nitro records asset compression negotiation on the event response. Merge
-  // Farm's cache signals there so H3 preserves both sets of Vary values.
+  // Farm's cache signals there so H3 preserves both sets of Vary values. Only
+  // merge into a Vary Nitro set: any event header makes H3 rebuild the response
+  // around its body, and without one H3 keeps Farm's Vary as it is.
   const farmVary = response.headers.get('Vary')
-  if (farmVary) mergeVaryHeaders(event.res.headers, farmVary)
-  return response
-}
+  if (farmVary) {
+    const nitroHeaders = event.res.headers
+    if (nitroHeaders.has('Vary')) mergeVaryHeaders(nitroHeaders, farmVary)
+  }
+  return ${nodeAdapterModule ? "toFarmNodeResponse(request, response)" : "response"}
+}${nodeAdapterModule ? `
+
+// A page Farm still holds as one complete string is sent in a single write with
+// Content-Length, instead of srvx reading the Web stream chunk by chunk. Any
+// step that read, cloned or replaced the body made a new stream, so its lookup
+// misses and that response is sent as it is.
+function toFarmNodeResponse(request, response) {
+  if (request.method === 'HEAD') return response
+  // Already a FastResponse (a buffered page built as one): srvx sends it as is.
+  if (typeof response._toNodeResponse === 'function') return response
+  const html = getFarmOwnedBufferedHtml(response)
+  if (html === undefined) return response
+  return new FastResponse(html, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  })
+}` : ""}
   `.trim();
   await fs.writeFile(nitroEntryPath, nitroEntryCode);
   const farmNodeServerEntryPath = preset === "node-server" ? path5.join(ssrOutputDir, "farm-node-server-entry.mjs") : null;
-  if (farmNodeServerEntryPath) {
+  if (farmNodeServerEntryPath && nodeAdapterModule) {
     await fs.writeFile(
       farmNodeServerEntryPath,
       createFarmNodeServerEntry({
         nitroEntryFile: path5.basename(nitroEntryPath),
-        nodeAdapterModule: resolveNitroRuntimeDependency(root, "srvx/node"),
+        nodeAdapterModule,
         server: config.server,
         websocketAdapterModule: resolveNitroRuntimeDependency(root, "crossws/adapters/node")
       })
@@ -9301,7 +9456,13 @@ export default async function farmNitroEventHandler(event) {
     },
     rollupConfig: {
       external: nitroRollupExternal,
-      plugins: hasGeneratedMetadataImages && !useExternalMetadataImageRuntime ? [createMetadataImageWasmPlugin()] : []
+      plugins: [
+        ...hasGeneratedMetadataImages && !useExternalMetadataImageRuntime ? [createMetadataImageWasmPlugin()] : [],
+        // Workers bundle React here rather than loading it from node_modules.
+        // Unenv rewrites `process` before Nitro's own replacements run, so
+        // React's development builds would otherwise ship next to production.
+        ...isCloudflareWorker ? [createReactProductionModePlugin()] : []
+      ]
     },
     // Keep the public Nitro boolean intact for build hooks. Farm replaces
     // Nitro's minifier only when no custom OXC transform was requested.