diff --git a/docs/api/framework-conventions/entry.server.tsx.md b/docs/api/framework-conventions/entry.server.tsx.md
index cbad2a1c67..aa9e854162 100644
--- a/docs/api/framework-conventions/entry.server.tsx.md
+++ b/docs/api/framework-conventions/entry.server.tsx.md
@@ -145,9 +145,11 @@ _Note that you generally want to avoid logging when the request was aborted, sin
 
 **Streaming Rendering Errors**
 
-When you are streaming your HTML responses via [`renderToReadableStream`][rendertoreadablestream], your own `handleError` implementation will only handle errors encountered during the initial shell render. If you encounter a rendering error during subsequent streamed rendering you will need to handle these errors manually since the React Router server has already sent the Response by that point. You can handle these errors in the `onError` callback function.
+When you are streaming your HTML responses via [`renderToPipeableStream`][rendertopipeablestream] or [`renderToReadableStream`][rendertoreadablestream], your own `handleError` implementation will only handle errors encountered during the initial shell render. If you encounter a rendering error during subsequent streamed rendering you will need to handle these errors manually since the React Router server has already sent the Response by that point.
 
-For an example, please refer to the default [`entry.server.tsx`][streaming-entry-server].
+For `renderToPipeableStream`, you can handle these errors in the `onError` callback function. You will need to toggle a boolean in `onShellReady` so you know if the error was a shell rendering error (and can be ignored) or an async
+
+For an example, please refer to the default [`entry.server.tsx`][node-streaming-entry-server] for Node.
 
 **Thrown Responses**
 
@@ -158,5 +160,5 @@ Note that this does not handle thrown `Response` instances from your `loader`/`a
 [streaming]: ../../how-to/suspense
 [rendertopipeablestream]: https://react.dev/reference/react-dom/server/renderToPipeableStream
 [rendertoreadablestream]: https://react.dev/reference/react-dom/server/renderToReadableStream
-[streaming-entry-server]: https://github.com/remix-run/react-router/blob/main/packages/react-router-dev/config/defaults/entry.server.tsx
+[node-streaming-entry-server]: https://github.com/remix-run/react-router/blob/main/packages/react-router-dev/config/defaults/entry.server.node.tsx
 [templates-repo]: https://github.com/remix-run/react-router-templates
diff --git a/integration/defer-test.ts b/integration/defer-test.ts
index a016b6abb6..945683bce3 100644
--- a/integration/defer-test.ts
+++ b/integration/defer-test.ts
@@ -35,7 +35,7 @@ function counterHtml(id: string, val: number) {
   return `<p id="count-${id}">${val}</p>`;
 }
 
-const deferredHTMLStartString = '<script id="_R_">';
+const deferredHTMLStartString = "<template id=";
 
 async function getHtmlSections(
   fixture: Fixture,
@@ -46,14 +46,7 @@ async function getHtmlSections(
   let html = await response.text();
   let deferredIndex = html.indexOf(deferredHTMLStartString);
 
-  // If nothing is deferred then we never get the streaming JS code
-  if (deferredIndex === -1) {
-    return {
-      status: response.status,
-      criticalHTML: html,
-      deferredHTML: "",
-    };
-  }
+  expect(deferredIndex).toBeGreaterThan(-1);
 
   return {
     status: response.status,
@@ -98,7 +91,7 @@ test.describe("non-aborted", () => {
           }
         `,
         "app/root.tsx": js`
-          import { Links, Meta, Outlet, Scripts, useLoaderData, useLocation } from "react-router";
+          import { Links, Meta, Outlet, Scripts, useLoaderData } from "react-router";
           import Counter from "~/components/counter";
           import Interactive from "~/components/interactive";
 
@@ -112,7 +105,6 @@ test.describe("non-aborted", () => {
 
           export default function Root() {
             let { id } = useLoaderData();
-            let location = useLocation();
             return (
               <html lang="en">
                 <head>
@@ -122,13 +114,13 @@ test.describe("non-aborted", () => {
                   <Links />
                 </head>
                 <body>
-                  <main id={id}>
+                  <div id={id}>
                     <p>{id}</p>
                     <Counter id={id} />
                     <Outlet />
                     <Interactive />
-                  </main>
-                  {location.pathname.startsWith("/deferred-noscript-") ? null : <Scripts />}
+                  </div>
+                  <Scripts />
                   {/* Send arbitrary data so safari renders the initial shell before
                       the document finishes downloading. */}
                   {Array(1000).fill(null).map((_, i)=><p key={i}>YOOOOOOOOOO   {i}</p>)}
@@ -579,10 +571,11 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(INDEX_ID, 0));
-    expect(deferredHTML).toBe("");
+    expect(deferredHTML.replace("</body></html>", "")).not.toBe("");
+    expect(deferredHTML).not.toContain('<p id="count-');
   });
 
-  test("resolved promises render in initial payload (noscript)", async () => {
+  test("resolved promises do not render in initial payload", async () => {
     let { status, criticalHTML, deferredHTML } = await getHtmlSections(
       fixture,
       "/deferred-noscript-resolved",
@@ -591,14 +584,12 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(DEFERRED_ID, 0));
-    expect(criticalHTML).toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
-    expect(criticalHTML).not.toContain(FALLBACK_ID);
-    expect(deferredHTML).not.toContain(FALLBACK_ID);
+    expect(criticalHTML).not.toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
+    expect(deferredHTML).toContain(FALLBACK_ID);
+    expect(deferredHTML).toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
   });
 
-  test("unresolved promises render in subsequent payload (noscript)", async ({
-    page,
-  }) => {
+  test("slow promises render in subsequent payload", async () => {
     let { status, criticalHTML, deferredHTML } = await getHtmlSections(
       fixture,
       "/deferred-noscript-unresolved",
@@ -607,23 +598,9 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(DEFERRED_ID, 0));
-    expect(criticalHTML).toContain(`<div id="${FALLBACK_ID}">`);
     expect(criticalHTML).not.toContain(RESOLVED_DEFERRED_ID);
+    expect(deferredHTML).toContain(`<div id="${FALLBACK_ID}">`);
     expect(deferredHTML).toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
-
-    // Hydrates out-of-order streamed content, but does not become interactive
-    // because we didn't include Scripts
-    let app = new PlaywrightFixture(appFixture, page);
-    await app.goto("/deferred-noscript-unresolved", true);
-    await page.waitForSelector(`main #${RESOLVED_DEFERRED_ID}`);
-    await page.waitForSelector(
-      `main #count-${RESOLVED_DEFERRED_ID}:has-text("0")`,
-    );
-    await page.locator(`main #increment-${RESOLVED_DEFERRED_ID}`).click();
-    await new Promise((r) => setTimeout(r, 100));
-    expect(
-      await page.locator(`main #count-${RESOLVED_DEFERRED_ID}`).innerText(),
-    ).toBe("0");
   });
 
   test("resolved promises render in initial payload", async () => {
@@ -635,12 +612,11 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(DEFERRED_ID, 0));
-    expect(criticalHTML).toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
-    expect(criticalHTML).not.toContain(FALLBACK_ID);
-    expect(deferredHTML).not.toContain(FALLBACK_ID);
+    expect(deferredHTML).toContain(FALLBACK_ID);
+    expect(deferredHTML).toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
   });
 
-  test("unresolved promises render in subsequent payload", async ({ page }) => {
+  test("slow to resolve promises render in subsequent payload", async () => {
     let { status, criticalHTML, deferredHTML } = await getHtmlSections(
       fixture,
       "/deferred-script-unresolved",
@@ -649,22 +625,9 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(DEFERRED_ID, 0));
-    expect(criticalHTML).toContain(`<div id="${FALLBACK_ID}">`);
     expect(criticalHTML).not.toContain(RESOLVED_DEFERRED_ID);
+    expect(deferredHTML).toContain(`<div id="${FALLBACK_ID}">`);
     expect(deferredHTML).toContain(counterHtml(RESOLVED_DEFERRED_ID, 0));
-
-    // Hydrates out-of-order streamed content and becomes interactive
-    let app = new PlaywrightFixture(appFixture, page);
-    await app.goto("/deferred-script-unresolved", true);
-    await page.waitForSelector(`main #${RESOLVED_DEFERRED_ID}`);
-    await page.waitForSelector(
-      `main #count-${RESOLVED_DEFERRED_ID}:has-text("0")`,
-    );
-    await page.locator(`main #increment-${RESOLVED_DEFERRED_ID}`).click();
-    await new Promise((r) => setTimeout(r, 100));
-    expect(
-      await page.locator(`main #count-${RESOLVED_DEFERRED_ID}`).innerText(),
-    ).toBe("1");
   });
 
   test("rejected promises render in initial payload", async () => {
@@ -676,9 +639,8 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(DEFERRED_ID, 0));
-    expect(criticalHTML).toContain(counterHtml(ERROR_ID, 0));
-    expect(criticalHTML).not.toContain(FALLBACK_ID);
-    expect(deferredHTML).not.toContain(FALLBACK_ID);
+    expect(deferredHTML).toContain(FALLBACK_ID);
+    expect(deferredHTML).toContain(counterHtml(ERROR_ID, 0));
   });
 
   test("slow to reject promises render in subsequent payload", async () => {
@@ -690,8 +652,8 @@ test.describe("non-aborted", () => {
     expect(status).toBe(200);
     expect(criticalHTML).toContain(counterHtml(ROOT_ID, 0));
     expect(criticalHTML).toContain(counterHtml(DEFERRED_ID, 0));
-    expect(criticalHTML).toContain(`<div id="${FALLBACK_ID}">`);
     expect(criticalHTML).not.toContain(ERROR_ID);
+    expect(deferredHTML).toContain(`<div id="${FALLBACK_ID}">`);
     expect(deferredHTML).toContain(counterHtml(ERROR_ID, 0));
   });
 
diff --git a/packages/react-router-dev/config/defaults/entry.server.tsx b/integration/helpers/vite-plugin-cloudflare-template/app/entry.server.tsx
similarity index 79%
rename from packages/react-router-dev/config/defaults/entry.server.tsx
rename to integration/helpers/vite-plugin-cloudflare-template/app/entry.server.tsx
index b8e9fcd328..6ac910a0f8 100644
--- a/packages/react-router-dev/config/defaults/entry.server.tsx
+++ b/integration/helpers/vite-plugin-cloudflare-template/app/entry.server.tsx
@@ -3,8 +3,6 @@ import { ServerRouter } from "react-router";
 import { isbot } from "isbot";
 import { renderToReadableStream } from "react-dom/server";
 
-export const streamTimeout = 5_000;
-
 export default async function handleRequest(
   request: Request,
   responseStatusCode: number,
@@ -12,24 +10,15 @@ export default async function handleRequest(
   routerContext: EntryContext,
   _loadContext: RouterContextProvider,
 ) {
-  // https://httpwg.org/specs/rfc9110.html#HEAD
-  if (request.method.toUpperCase() === "HEAD") {
-    return new Response(null, {
-      status: responseStatusCode,
-      headers: responseHeaders,
-    });
-  }
-
   let shellRendered = false;
-  let userAgent = request.headers.get("user-agent");
+  const userAgent = request.headers.get("user-agent");
 
   const body = await renderToReadableStream(
     <ServerRouter context={routerContext} url={request.url} />,
     {
-      signal: AbortSignal.timeout(streamTimeout + 1000),
       onError(error: unknown) {
         responseStatusCode = 500;
-        // Log streaming rendering errors from inside the shell. Don't log
+        // Log streaming rendering errors from inside the shell.  Don't log
         // errors encountered during initial shell rendering since they'll
         // reject and get logged in handleDocumentRequest.
         if (shellRendered) {
diff --git a/integration/link-test.ts b/integration/link-test.ts
index c811ba1339..8cdfa79863 100644
--- a/integration/link-test.ts
+++ b/integration/link-test.ts
@@ -623,9 +623,12 @@ test.describe("route module link export", () => {
           // Scripts:
           // RR:    window.__reactRouterContext
           // RR:    window.__reactRouterManifest/window.__reactRouterRouteModules
+          // React: requestAnimationFrame(function(){$RT=performance.now()});
           // RR:    window.__reactRouterContext.streamController.enqueue()
+          // React: $RC=function(b,c,e){...
           // RR:    window.__reactRouterContext.streamController.close();
-          expect(scripts.length).toEqual(4);
+          // React: $RC("B:1","S:1")
+          expect(scripts.length).toEqual(7);
 
           expect(await scripts[0].innerText()).toContain(
             "__reactRouterContext",
diff --git a/integration/vite-plugin-cloudflare-test.ts b/integration/vite-plugin-cloudflare-test.ts
index 6b6adfdf44..a8ceb5754a 100644
--- a/integration/vite-plugin-cloudflare-test.ts
+++ b/integration/vite-plugin-cloudflare-test.ts
@@ -2,13 +2,7 @@ import { expect } from "@playwright/test";
 import dedent from "dedent";
 import getPort from "get-port";
 
-import {
-  type Files,
-  test,
-  viteConfig,
-  createProject,
-  build,
-} from "./helpers/vite.js";
+import { type Files, test, viteConfig } from "./helpers/vite.js";
 
 const tsx = dedent;
 const css = dedent;
@@ -183,15 +177,4 @@ test.describe("vite-plugin-cloudflare", () => {
       "20px",
     );
   });
-
-  test("builds project with default server entry", async () => {
-    const files = defineFiles();
-    const cwd = await createProject(
-      await files({ port: 0 }),
-      "vite-plugin-cloudflare-template",
-    );
-    const buildResult = build({ cwd });
-
-    expect(buildResult.status).toBe(0);
-  });
 });
diff --git a/packages/react-router-dev/.changes/minor.web-streams-entry.md b/packages/react-router-dev/.changes/minor.web-streams-entry.md
deleted file mode 100644
index 6bf0db252e..0000000000
--- a/packages/react-router-dev/.changes/minor.web-streams-entry.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Change the default `entry.server.tsx` to use React's `renderToReadableStream` which is now available in React Router v8's Node 22 baseline
-
-- Framework mode apps no longer require a custom `entry.server.tsx` file to run in non-Node runtimes (i.e., Cloudflare)
-- This should not have any functional changes for your app
-  - You may see a small performance boost because of the reduced conversions between node streams and web streams
-  - You may eliminate initial fallback flickers for promises resolved prior to render
-    - Our testing showed that `renderToPipeableStream` would render the fallback and stream an immediate chunk with the resolved value
-    - `renderToReadableStream` skips the fallback and renders the resolved value in the critical HTML
-- If you have your own `entry.server.tsx` using `renderToReadableStream`, you may be able to remove it from your app if the logic matches the [default implementation](https://github.com/remix-run/react-router/blob/main/packages/react-router-dev/config/defaults/entry.server.tsx)
-- If you wish to continue using `renderToPipeableStream`, you can add your own `entry.server.tsx` file based on the previous [node implementation](https://github.com/remix-run/react-router/blob/react-router%408.0.0/packages/react-router-dev/config/defaults/entry.server.node.tsx)
-- You can also remove `@react-router/node` from your dependencies if you also have `@react-router/serve` or `@react-router/express`, since we no longer need the dependency to determine server entry compatibility across runtimes
diff --git a/packages/react-router-dev/cli/commands.ts b/packages/react-router-dev/cli/commands.ts
index 21b0c921fc..481a2cc886 100644
--- a/packages/react-router-dev/cli/commands.ts
+++ b/packages/react-router-dev/cli/commands.ts
@@ -3,6 +3,7 @@ import { readFile, writeFile, copyFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import exitHook from "exit-hook";
+import { readPackageJSON } from "pkg-types";
 import colors from "picocolors";
 // Workaround for "ERR_REQUIRE_CYCLE_MODULE" in Node 22.10.0+
 import "react-router";
@@ -169,6 +170,14 @@ export async function generateEntry(
 
     await copyFile(defaultEntry, outputFile);
   } else {
+    let pkgJson = await readPackageJSON(rootDirectory);
+    let deps = pkgJson.dependencies ?? {};
+
+    if (!deps["@react-router/node"]) {
+      console.error(colors.red(`No default server entry detected.`));
+      return;
+    }
+
     let defaultEntryClient = path.resolve(
       defaultsDirectory,
       "entry.client.tsx",
@@ -176,7 +185,7 @@ export async function generateEntry(
 
     let defaultEntryServer = path.resolve(
       defaultsDirectory,
-      `entry.server.tsx`,
+      `entry.server.node.tsx`,
     );
 
     let isServerEntry = entry === "entry.server";
diff --git a/packages/react-router-dev/config/config.ts b/packages/react-router-dev/config/config.ts
index 6c5d3a2ddd..edce424a69 100644
--- a/packages/react-router-dev/config/config.ts
+++ b/packages/react-router-dev/config/config.ts
@@ -1045,6 +1045,12 @@ export async function resolveEntryFiles({
     let pkgJson = await readPackageJSON(packageJsonDirectory);
     let deps = pkgJson.dependencies ?? {};
 
+    if (!deps["@react-router/node"]) {
+      throw new Error(
+        `Could not determine server runtime. Please install @react-router/node, or provide a custom entry.server.tsx/jsx file in your app directory.`,
+      );
+    }
+
     if (!deps["isbot"]) {
       console.log(
         "adding `isbot@5` to your package.json, you should commit this change",
@@ -1064,7 +1070,7 @@ export async function resolveEntryFiles({
       });
     }
 
-    entryServerFile = `entry.server.tsx`;
+    entryServerFile = `entry.server.node.tsx`;
   }
 
   let entryClientFilePath = userEntryClientFile
diff --git a/packages/react-router-dev/config/defaults/entry.server.node.tsx b/packages/react-router-dev/config/defaults/entry.server.node.tsx
new file mode 100644
index 0000000000..34d8af2ad3
--- /dev/null
+++ b/packages/react-router-dev/config/defaults/entry.server.node.tsx
@@ -0,0 +1,86 @@
+import { PassThrough } from "node:stream";
+
+import type { EntryContext, RouterContextProvider } from "react-router";
+import { createReadableStreamFromReadable } from "@react-router/node";
+import { ServerRouter } from "react-router";
+import { isbot } from "isbot";
+import type { RenderToPipeableStreamOptions } from "react-dom/server";
+import { renderToPipeableStream } from "react-dom/server";
+
+export const streamTimeout = 5_000;
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: RouterContextProvider,
+) {
+  // https://httpwg.org/specs/rfc9110.html#HEAD
+  if (request.method.toUpperCase() === "HEAD") {
+    return new Response(null, {
+      status: responseStatusCode,
+      headers: responseHeaders,
+    });
+  }
+
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    let userAgent = request.headers.get("user-agent");
+
+    // Ensure requests from bots and SPA Mode renders wait for all content to load before responding
+    // https://react.dev/reference/react-dom/server/renderToPipeableStream#waiting-for-all-content-to-load-for-crawlers-and-static-generation
+    let readyOption: keyof RenderToPipeableStreamOptions =
+      (userAgent && isbot(userAgent)) || routerContext.isSpaMode
+        ? "onAllReady"
+        : "onShellReady";
+
+    // Abort the rendering stream after the `streamTimeout` so it has time to
+    // flush down the rejected boundaries
+    let timeoutId: ReturnType<typeof setTimeout> | undefined = setTimeout(
+      () => abort(),
+      streamTimeout + 1000,
+    );
+
+    const { pipe, abort } = renderToPipeableStream(
+      <ServerRouter context={routerContext} url={request.url} />,
+      {
+        [readyOption]() {
+          shellRendered = true;
+          const body = new PassThrough({
+            final(callback) {
+              // Clear the timeout to prevent retaining the closure and memory leak
+              clearTimeout(timeoutId);
+              timeoutId = undefined;
+              callback();
+            },
+          });
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set("Content-Type", "text/html");
+
+          pipe(body);
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            }),
+          );
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          // Log streaming rendering errors from inside the shell.  Don't log
+          // errors encountered during initial shell rendering since they'll
+          // reject and get logged in handleDocumentRequest.
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      },
+    );
+  });
+}
diff --git a/playground/vite-plugin-cloudflare/app/entry.server.tsx b/playground/vite-plugin-cloudflare/app/entry.server.tsx
new file mode 100644
index 0000000000..6ac910a0f8
--- /dev/null
+++ b/playground/vite-plugin-cloudflare/app/entry.server.tsx
@@ -0,0 +1,43 @@
+import type { EntryContext, RouterContextProvider } from "react-router";
+import { ServerRouter } from "react-router";
+import { isbot } from "isbot";
+import { renderToReadableStream } from "react-dom/server";
+
+export default async function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  _loadContext: RouterContextProvider,
+) {
+  let shellRendered = false;
+  const userAgent = request.headers.get("user-agent");
+
+  const body = await renderToReadableStream(
+    <ServerRouter context={routerContext} url={request.url} />,
+    {
+      onError(error: unknown) {
+        responseStatusCode = 500;
+        // Log streaming rendering errors from inside the shell.  Don't log
+        // errors encountered during initial shell rendering since they'll
+        // reject and get logged in handleDocumentRequest.
+        if (shellRendered) {
+          console.error(error);
+        }
+      },
+    },
+  );
+  shellRendered = true;
+
+  // Ensure requests from bots and SPA Mode renders wait for all content to load before responding
+  // https://react.dev/reference/react-dom/server/renderToPipeableStream#waiting-for-all-content-to-load-for-crawlers-and-static-generation
+  if ((userAgent && isbot(userAgent)) || routerContext.isSpaMode) {
+    await body.allReady;
+  }
+
+  responseHeaders.set("Content-Type", "text/html");
+  return new Response(body, {
+    headers: responseHeaders,
+    status: responseStatusCode,
+  });
+}
