From 986323f8c65927490036183357d644974a14b8a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Markb=C3=A5ge?= <sebastian@calyptus.eu>
Date: Tue, 4 Nov 2025 22:11:33 -0500
Subject: [PATCH 1/3] [Fiber] SuspenseList with "hidden" tail row should
 "catch" suspense (#35042)

Normally if you suspend in a SuspenseList row above a Suspense boundary
in that row, it'll suspend the parent. Which can itself delay the commit
or resuspend a parent boundary. That's because SuspenseList mostly just
coordinates the state of the inner boundaries and isn't a boundary
itself.

However, for tail "hidden" and "collapsed" this is not quite the case
because the rows themselves can avoid being rendered.

In the case of "collapsed" we require at least one Suspense boundary
above to have successfully rendered before committing the list because
the idea of this mode is that you should at least always show some
indicator that things are still loading. Since we'd never try the next
one after that at all, this just works. Expect there was an unrelated
bug that meant that "suspend with delay" on a Retry didn't suspend the
commit. This caused a scenario were it'd allow a commit proceed when it
shouldn't. So I fixed that too. The counter intuitive thing here is that
we won't actually show a previous completed row if the loading state of
the next row is still loading.

For tail "hidden" it's a little different because we don't actually
require any loading indicator at all to be shown while it's loading. If
we attempt a row and it suspends, we can just hide it (and the rest) and
move to commit. Therefore this implements a path where if all the rest
of the tail are new mounts (we wouldn't be required to unmount any
existing boundaries) then we can treat the SuspenseList boundary itself
as "catching" the suspense. This is more coherent semantics since any
future row that we didn't attempt also wouldn't resuspend the parent.

This allows simple cases like `<SuspenseList>{list}</SuspenseList>` to
stream in each row without any indicator and no need for Suspense
boundaries.
---
 .../src/ReactFiberBeginWork.js                |  15 ++
 .../src/ReactFiberCompleteWork.js             |  36 ++-
 .../src/ReactFiberSuspenseContext.js          |  36 ++-
 .../react-reconciler/src/ReactFiberThrow.js   |  11 +-
 .../src/ReactFiberUnwindWork.js               |  28 ++-
 .../src/ReactFiberWorkLoop.js                 |   2 +-
 .../src/__tests__/ReactSuspenseList-test.js   | 221 ++++++++++++++++++
 7 files changed, 337 insertions(+), 12 deletions(-)

diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.js b/packages/react-reconciler/src/ReactFiberBeginWork.js
index 33fadfd5396..25918e8b387 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.js
@@ -3397,6 +3397,13 @@ function updateSuspenseListComponent(
 
   let suspenseContext: SuspenseContext = suspenseStackCursor.current;
 
+  if (workInProgress.flags & DidCapture) {
+    // This is the second pass after having suspended in a row. Proceed directly
+    // to the complete phase.
+    pushSuspenseListContext(workInProgress, suspenseContext);
+    return null;
+  }
+
   const shouldForceFallback = hasSuspenseListContext(
     suspenseContext,
     (ForceSuspenseFallback: SuspenseContext),
@@ -4011,6 +4018,14 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
       break;
     }
     case SuspenseListComponent: {
+      if (workInProgress.flags & DidCapture) {
+        // Second pass caught.
+        return updateSuspenseListComponent(
+          current,
+          workInProgress,
+          renderLanes,
+        );
+      }
       const didSuspendBefore = (current.flags & DidCapture) !== NoFlags;
 
       let hasChildWork = includesSomeLane(
diff --git a/packages/react-reconciler/src/ReactFiberCompleteWork.js b/packages/react-reconciler/src/ReactFiberCompleteWork.js
index 0b1f1e4366e..dab1b2272bd 100644
--- a/packages/react-reconciler/src/ReactFiberCompleteWork.js
+++ b/packages/react-reconciler/src/ReactFiberCompleteWork.js
@@ -138,6 +138,7 @@ import {
   popSuspenseListContext,
   popSuspenseHandler,
   pushSuspenseListContext,
+  pushSuspenseListCatch,
   setShallowSuspenseListContext,
   ForceSuspenseFallback,
   setDefaultShallowSuspenseListContext,
@@ -765,6 +766,17 @@ function cutOffTailIfNeeded(
   }
 }
 
+function isOnlyNewMounts(tail: Fiber): boolean {
+  let fiber: null | Fiber = tail;
+  while (fiber !== null) {
+    if (fiber.alternate !== null) {
+      return false;
+    }
+    fiber = fiber.sibling;
+  }
+  return true;
+}
+
 function bubbleProperties(completedWork: Fiber) {
   const didBailout =
     completedWork.alternate !== null &&
@@ -1855,7 +1867,10 @@ function completeWork(
       if (renderState.tail !== null) {
         // We still have tail rows to render.
         // Pop a row.
+        // TODO: Consider storing the first of the new mount tail in the state so
+        // that we don't have to recompute this for every row in the list.
         const next = renderState.tail;
+        const onlyNewMounts = isOnlyNewMounts(next);
         renderState.rendering = next;
         renderState.tail = next.sibling;
         renderState.renderingStartTime = now();
@@ -1874,7 +1889,26 @@ function completeWork(
           suspenseContext =
             setDefaultShallowSuspenseListContext(suspenseContext);
         }
-        pushSuspenseListContext(workInProgress, suspenseContext);
+        if (
+          renderState.tailMode === 'visible' ||
+          renderState.tailMode === 'collapsed' ||
+          !onlyNewMounts ||
+          // TODO: While hydrating, we still let it suspend the parent. Tail mode hidden has broken
+          // hydration anyway right now but this preserves the previous semantics out of caution.
+          // Once proper hydration is implemented, this special case should be removed as it should
+          // never be needed.
+          getIsHydrating()
+        ) {
+          pushSuspenseListContext(workInProgress, suspenseContext);
+        } else {
+          // If we are rendering in 'hidden' (default) tail mode, then we if we suspend in the
+          // tail itself, we can delete it rather than suspend the parent. So we act as a catch in that
+          // case. For 'collapsed' we need to render at least one in suspended state, after which we'll
+          // have cut off the rest to never attempt it so it never hits this case.
+          // If this is an updated node, we cannot delete it from the tail so it's effectively visible.
+          // As a consequence, if it resuspends it actually suspends the parent by taking the other path.
+          pushSuspenseListCatch(workInProgress, suspenseContext);
+        }
         // Do a pass over the next row.
         if (getIsHydrating()) {
           // Re-apply tree fork since we popped the tree fork context in the beginning of this function.
diff --git a/packages/react-reconciler/src/ReactFiberSuspenseContext.js b/packages/react-reconciler/src/ReactFiberSuspenseContext.js
index 3177b9d1b35..aec47af4656 100644
--- a/packages/react-reconciler/src/ReactFiberSuspenseContext.js
+++ b/packages/react-reconciler/src/ReactFiberSuspenseContext.js
@@ -48,9 +48,10 @@ export function pushPrimaryTreeSuspenseHandler(handler: Fiber): void {
   // Shallow Suspense context fields, like ForceSuspenseFallback, should only be
   // propagated a single level. For example, when ForceSuspenseFallback is set,
   // it should only force the nearest Suspense boundary into fallback mode.
-  pushSuspenseListContext(
-    handler,
+  push(
+    suspenseStackCursor,
     setDefaultShallowSuspenseListContext(suspenseStackCursor.current),
+    handler,
   );
 
   // Experimental feature: Some Suspense boundaries are marked as having an
@@ -113,7 +114,7 @@ export function pushDehydratedActivitySuspenseHandler(fiber: Fiber): void {
   // Reuse the current value on the stack.
   // TODO: We can avoid needing to push here by by forking popSuspenseHandler
   // into separate functions for Activity, Suspense and Offscreen.
-  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseStackCursor, suspenseStackCursor.current, fiber);
   push(suspenseHandlerStackCursor, fiber, fiber);
   if (shellBoundary === null) {
     // We can contain any suspense inside the Activity boundary.
@@ -127,7 +128,7 @@ export function pushOffscreenSuspenseHandler(fiber: Fiber): void {
     // Reuse the current value on the stack.
     // TODO: We can avoid needing to push here by by forking popSuspenseHandler
     // into separate functions for Activity, Suspense and Offscreen.
-    pushSuspenseListContext(fiber, suspenseStackCursor.current);
+    push(suspenseStackCursor, suspenseStackCursor.current, fiber);
     push(suspenseHandlerStackCursor, fiber, fiber);
     if (shellBoundary === null) {
       // We're rendering hidden content. If it suspends, we can handle it by
@@ -141,7 +142,7 @@ export function pushOffscreenSuspenseHandler(fiber: Fiber): void {
 }
 
 export function reuseSuspenseHandlerOnStack(fiber: Fiber) {
-  pushSuspenseListContext(fiber, suspenseStackCursor.current);
+  push(suspenseStackCursor, suspenseStackCursor.current, fiber);
   push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
 }
 
@@ -155,7 +156,7 @@ export function popSuspenseHandler(fiber: Fiber): void {
     // Popping back into the shell.
     shellBoundary = null;
   }
-  popSuspenseListContext(fiber);
+  pop(suspenseStackCursor, fiber);
 }
 
 // SuspenseList context
@@ -201,9 +202,32 @@ export function pushSuspenseListContext(
   fiber: Fiber,
   newContext: SuspenseContext,
 ): void {
+  // Push the current handler in this case since we're not catching at the SuspenseList
+  // for typical rows.
+  const handlerOnStack = suspenseHandlerStackCursor.current;
+  push(suspenseHandlerStackCursor, handlerOnStack, fiber);
+  push(suspenseStackCursor, newContext, fiber);
+}
+
+export function pushSuspenseListCatch(
+  fiber: Fiber,
+  newContext: SuspenseContext,
+): void {
+  // In this case we do want to handle catching suspending on the actual boundary itself.
+  // This is used for rows that are allowed to be hidden anyway.
+  push(suspenseHandlerStackCursor, fiber, fiber);
   push(suspenseStackCursor, newContext, fiber);
+  if (shellBoundary === null) {
+    // We can contain the effects to hiding the current row.
+    shellBoundary = fiber;
+  }
 }
 
 export function popSuspenseListContext(fiber: Fiber): void {
   pop(suspenseStackCursor, fiber);
+  pop(suspenseHandlerStackCursor, fiber);
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
 }
diff --git a/packages/react-reconciler/src/ReactFiberThrow.js b/packages/react-reconciler/src/ReactFiberThrow.js
index 92540176fe8..8ff61b02697 100644
--- a/packages/react-reconciler/src/ReactFiberThrow.js
+++ b/packages/react-reconciler/src/ReactFiberThrow.js
@@ -27,6 +27,7 @@ import {
   ActivityComponent,
   SuspenseComponent,
   OffscreenComponent,
+  SuspenseListComponent,
 } from './ReactWorkTags';
 import {
   DidCapture,
@@ -400,7 +401,8 @@ function throwException(
       if (suspenseBoundary !== null) {
         switch (suspenseBoundary.tag) {
           case ActivityComponent:
-          case SuspenseComponent: {
+          case SuspenseComponent:
+          case SuspenseListComponent: {
             // If this suspense/activity boundary is not already showing a fallback, mark
             // the in-progress render as suspended. We try to perform this logic
             // as soon as soon as possible during the render phase, so the work
@@ -561,6 +563,13 @@ function throwException(
     // Instead of surfacing the error, find the nearest Suspense boundary
     // and render it again without hydration.
     if (hydrationBoundary !== null) {
+      if (__DEV__) {
+        if (hydrationBoundary.tag === SuspenseListComponent) {
+          console.error(
+            'SuspenseList should never catch while hydrating. This is a bug in React.',
+          );
+        }
+      }
       if ((hydrationBoundary.flags & ShouldCapture) === NoFlags) {
         // Set a flag to indicate that we should try rendering the normal
         // children again, not the fallback.
diff --git a/packages/react-reconciler/src/ReactFiberUnwindWork.js b/packages/react-reconciler/src/ReactFiberUnwindWork.js
index efe08a43ac7..b2954c41f5a 100644
--- a/packages/react-reconciler/src/ReactFiberUnwindWork.js
+++ b/packages/react-reconciler/src/ReactFiberUnwindWork.js
@@ -11,7 +11,10 @@ import type {ReactContext} from 'shared/ReactTypes';
 import type {Fiber, FiberRoot} from './ReactInternalTypes';
 import type {Lanes} from './ReactFiberLane';
 import type {ActivityState} from './ReactFiberActivityComponent';
-import type {SuspenseState} from './ReactFiberSuspenseComponent';
+import type {
+  SuspenseState,
+  SuspenseListRenderState,
+} from './ReactFiberSuspenseComponent';
 import type {Cache} from './ReactFiberCacheComponent';
 import type {TracingMarkerInstance} from './ReactFiberTracingMarkerComponent';
 
@@ -31,7 +34,7 @@ import {
   CacheComponent,
   TracingMarkerComponent,
 } from './ReactWorkTags';
-import {DidCapture, NoFlags, ShouldCapture} from './ReactFiberFlags';
+import {DidCapture, NoFlags, ShouldCapture, Update} from './ReactFiberFlags';
 import {NoMode, ProfileMode} from './ReactTypeOfMode';
 import {
   enableProfilerTimer,
@@ -180,8 +183,27 @@ function unwindWork(
     }
     case SuspenseListComponent: {
       popSuspenseListContext(workInProgress);
-      // SuspenseList doesn't actually catch anything. It should've been
+      // SuspenseList doesn't normally catch anything. It should've been
       // caught by a nested boundary. If not, it should bubble through.
+      const flags = workInProgress.flags;
+      if (flags & ShouldCapture) {
+        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
+        // If we caught something on the SuspenseList itself it's because
+        // we want to ignore something. Re-enter the cycle and handle it
+        // in the complete phase.
+        const renderState: null | SuspenseListRenderState =
+          workInProgress.memoizedState;
+        if (renderState !== null) {
+          // Cut off any remaining tail work and don't commit the rendering one.
+          // This assumes that we have already confirmed that none of these are
+          // already mounted.
+          renderState.rendering = null;
+          renderState.tail = null;
+        }
+        // Schedule the commit phase to attach retry listeners.
+        workInProgress.flags |= Update;
+        return workInProgress;
+      }
       return null;
     }
     case HostPortal:
diff --git a/packages/react-reconciler/src/ReactFiberWorkLoop.js b/packages/react-reconciler/src/ReactFiberWorkLoop.js
index 3de2ab6b16f..f7200458be1 100644
--- a/packages/react-reconciler/src/ReactFiberWorkLoop.js
+++ b/packages/react-reconciler/src/ReactFiberWorkLoop.js
@@ -1355,7 +1355,7 @@ function finishConcurrentRender(
       throw new Error('Root did not complete. This is a bug in React.');
     }
     case RootSuspendedWithDelay: {
-      if (!includesOnlyTransitions(lanes)) {
+      if (!includesOnlyTransitions(lanes) && !includesOnlyRetries(lanes)) {
         // Commit the placeholder.
         break;
       }
diff --git a/packages/react-reconciler/src/__tests__/ReactSuspenseList-test.js b/packages/react-reconciler/src/__tests__/ReactSuspenseList-test.js
index ba5b668652f..c7d4de1421e 100644
--- a/packages/react-reconciler/src/__tests__/ReactSuspenseList-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactSuspenseList-test.js
@@ -2346,6 +2346,227 @@ describe('ReactSuspenseList', () => {
     );
   });
 
+  // @gate enableSuspenseList
+  it('reveals "hidden" rows one by one without suspense boundaries', async () => {
+    const A = createAsyncText('A');
+    const B = createAsyncText('B');
+    const C = createAsyncText('C');
+
+    function Foo() {
+      return (
+        <SuspenseList revealOrder="forwards" tail="hidden">
+          <div>
+            <A />
+          </div>
+          <B />
+          <C />
+        </SuspenseList>
+      );
+    }
+
+    ReactNoop.render(
+      <Suspense fallback="Loading root">
+        <Foo />
+      </Suspense>,
+    );
+
+    await waitForAll(['Suspend! [A]']);
+
+    // We can commit without any rows at all leaving empty.
+    expect(ReactNoop).toMatchRenderedOutput(null);
+
+    await act(() => A.resolve());
+    assertLog(['A', 'Suspend! [B]']);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <div>
+        <span>A</span>
+      </div>,
+    );
+
+    await act(() => B.resolve());
+    assertLog(['B', 'Suspend! [C]']);
+
+    // Incremental loading is suspended.
+    jest.advanceTimersByTime(500);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <div>
+          <span>A</span>
+        </div>
+        <span>B</span>
+      </>,
+    );
+
+    await act(() => C.resolve());
+    assertLog(['C']);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <div>
+          <span>A</span>
+        </div>
+        <span>B</span>
+        <span>C</span>
+      </>,
+    );
+  });
+
+  // @gate enableSuspenseList
+  it('preserves already mounted rows when a new hidden on is inserted in the tail', async () => {
+    const B = createAsyncText('B');
+    const C = createAsyncText('C');
+
+    let count = 0;
+    function MountCount({children}) {
+      // This component should only mount once.
+      React.useLayoutEffect(() => {
+        count++;
+      }, []);
+      return children;
+    }
+
+    function Foo({insert}) {
+      return (
+        <SuspenseList
+          revealOrder="forwards"
+          tail={insert ? 'hidden' : 'visible'}>
+          <Text text="A" />
+          {insert ? <B /> : null}
+          <MountCount>
+            <Suspense fallback={<Text text="Loading C" />}>
+              <C />
+            </Suspense>
+          </MountCount>
+        </SuspenseList>
+      );
+    }
+
+    await act(() => {
+      ReactNoop.render(<Foo insert={false} />);
+    });
+    assertLog(['A', 'Suspend! [C]', 'Loading C', 'Suspend! [C]']);
+
+    expect(count).toBe(1);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <span>A</span>
+        <span>Loading C</span>
+      </>,
+    );
+
+    await act(() => {
+      ReactNoop.render(<Foo insert={true} />);
+    });
+
+    assertLog(['A', 'Suspend! [B]', 'A', 'Suspend! [B]']);
+
+    expect(count).toBe(1);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <span>A</span>
+        <span>Loading C</span>
+      </>,
+    );
+
+    await act(async () => {
+      await B.resolve();
+      await C.resolve();
+    });
+
+    assertLog(['A', 'B', 'C']);
+
+    expect(count).toBe(1);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <span>A</span>
+        <span>B</span>
+        <span>C</span>
+      </>,
+    );
+  });
+
+  // @gate enableSuspenseList
+  it('reveals "collapsed" rows one by one after the first without boundaries', async () => {
+    const A = createAsyncText('A');
+    const B = createAsyncText('B');
+    const C = createAsyncText('C');
+
+    function Foo() {
+      return (
+        <SuspenseList revealOrder="forwards" tail="collapsed">
+          <A />
+          <Suspense fallback={<Text text="Loading B" />}>
+            <B />
+          </Suspense>
+          <C />
+        </SuspenseList>
+      );
+    }
+
+    await act(async () => {
+      ReactNoop.render(
+        <Suspense fallback="Loading root">
+          <Foo />
+        </Suspense>,
+      );
+      await waitForAll(['Suspend! [A]', 'Suspend! [A]']);
+    });
+
+    // The root is still blocked on the first row.
+    expect(ReactNoop).toMatchRenderedOutput('Loading root');
+
+    await A.resolve();
+
+    await waitForAll(['A', 'Suspend! [B]', 'Loading B']);
+
+    // Incremental loading is suspended.
+    jest.advanceTimersByTime(500);
+
+    // Because we have a Suspense boundary that can commit we can now unblock the rest.
+    // If it wasn't a boundary then we couldn't make progress because it would commit
+    // without any loading state.
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <span>A</span>
+        <span>Loading B</span>
+      </>,
+    );
+
+    await act(() => B.resolve());
+    assertLog(['B', 'Suspend! [C]', 'B', 'Suspend! [C]']);
+
+    // Incremental loading is suspended.
+    jest.advanceTimersByTime(500);
+
+    // Surprisingly unsuspending B actually causes the parent to resuspend
+    // because C is now unblocked which resuspends the parent. Preventing the
+    // Retry from committing. That's because we don't want to commit into a
+    // state that doesn't have any loading indicators at all. That's what
+    // "collapsed" is for. To ensure there's always a loading indicator.
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <span>A</span>
+        <span>Loading B</span>
+      </>,
+    );
+
+    await act(() => C.resolve());
+    assertLog(['B', 'C']);
+
+    expect(ReactNoop).toMatchRenderedOutput(
+      <>
+        <span>A</span>
+        <span>B</span>
+        <span>C</span>
+      </>,
+    );
+  });
+
   // @gate enableSuspenseList
   it('eventually resolves a nested forwards suspense list', async () => {
     const B = createAsyncText('B');

From c308cb590598b61a7fc1766e15edf454d758d226 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Markb=C3=A5ge?= <sebastian@calyptus.eu>
Date: Tue, 4 Nov 2025 23:23:25 -0500
Subject: [PATCH 2/3] Disable enablePostpone flag in experimental (#31042)

I don't think we're ready to land this yet since we're using it to run
other experiments and our tests. I'm opening this PR to indicate intent
to disable and to ensure tests in other combinations still work. Such as
enableHalt without enablePostpone. I think we'll also need to rewrite
some tests that depend on enablePostpone to preserve some coverage.

The conclusion after this experiment is that try/catch around these are
too likely to block these signals and consider them error. Throwing
works for Hooks and `use()` because the lint rule can ensure that
they're not wrapped in try/catch. Throwing in arbitrary functions not
quite ecosystem compatible. It's also why there's `use()` and not just
throwing a Promise. This might also affect the Catch proposal.

The "prerender" for SSR that's supporting "Partial Prerendering" is
still there. This just disables the `React.postpone()` API for creating
the holes.
---
 .../src/__tests__/ReactDOMFizzStatic-test.js  | 66 -------------------
 .../react/index.experimental.development.js   |  1 -
 packages/react/index.experimental.js          |  1 -
 packages/react/src/ReactClient.js             |  2 -
 .../ReactServer.experimental.development.js   |  2 -
 .../react/src/ReactServer.experimental.js     |  2 -
 packages/shared/ReactFeatureFlags.js          |  2 +-
 7 files changed, 1 insertion(+), 75 deletions(-)

diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js
index 65012023420..a4ac87c92c4 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js
@@ -400,72 +400,6 @@ describe('ReactDOMFizzStatic', () => {
     );
   });
 
-  // @gate enablePostpone
-  it('does not fatally error when aborting with a postpone during a prerender', async () => {
-    let postponedValue;
-    try {
-      React.unstable_postpone('aborting with postpone');
-    } catch (e) {
-      postponedValue = e;
-    }
-
-    const controller = new AbortController();
-    const infinitePromise = new Promise(() => {});
-    function App() {
-      React.use(infinitePromise);
-      return <div>aborted</div>;
-    }
-
-    const errors = [];
-    const pendingResult = ReactDOMFizzStatic.prerenderToNodeStream(<App />, {
-      onError: error => {
-        errors.push(error);
-      },
-      signal: controller.signal,
-    });
-    pendingResult.catch(() => {});
-
-    await Promise.resolve();
-    controller.abort(postponedValue);
-
-    const result = await pendingResult;
-
-    await act(async () => {
-      result.prelude.pipe(writable);
-    });
-    expect(getVisibleChildren(container)).toEqual(undefined);
-    expect(errors).toEqual([]);
-  });
-
-  // @gate enablePostpone
-  it('does not fatally error when aborting with a postpone during a prerender from within', async () => {
-    let postponedValue;
-    try {
-      React.unstable_postpone('aborting with postpone');
-    } catch (e) {
-      postponedValue = e;
-    }
-
-    const controller = new AbortController();
-    function App() {
-      controller.abort(postponedValue);
-      return <div>aborted</div>;
-    }
-
-    const errors = [];
-    const result = await ReactDOMFizzStatic.prerenderToNodeStream(<App />, {
-      onError: error => {
-        errors.push(error);
-      },
-      signal: controller.signal,
-    });
-    await act(async () => {
-      result.prelude.pipe(writable);
-    });
-    expect(getVisibleChildren(container)).toEqual(undefined);
-    expect(errors).toEqual([]);
-  });
-
   // @gate enableHalt
   it('will halt a prerender when aborting with an error during a render', async () => {
     const controller = new AbortController();
diff --git a/packages/react/index.experimental.development.js b/packages/react/index.experimental.development.js
index b2374493073..9b0e301a8c9 100644
--- a/packages/react/index.experimental.development.js
+++ b/packages/react/index.experimental.development.js
@@ -30,7 +30,6 @@ export {
   cacheSignal,
   startTransition,
   Activity,
-  unstable_postpone,
   unstable_getCacheForType,
   unstable_SuspenseList,
   ViewTransition,
diff --git a/packages/react/index.experimental.js b/packages/react/index.experimental.js
index 37800ede07a..0145e9137e9 100644
--- a/packages/react/index.experimental.js
+++ b/packages/react/index.experimental.js
@@ -31,7 +31,6 @@ export {
   startTransition,
   Activity,
   Activity as unstable_Activity,
-  unstable_postpone,
   unstable_getCacheForType,
   unstable_SuspenseList,
   ViewTransition,
diff --git a/packages/react/src/ReactClient.js b/packages/react/src/ReactClient.js
index 9f7c5dce36d..d881030b7d0 100644
--- a/packages/react/src/ReactClient.js
+++ b/packages/react/src/ReactClient.js
@@ -34,7 +34,6 @@ import {lazy} from './ReactLazy';
 import {forwardRef} from './ReactForwardRef';
 import {memo} from './ReactMemo';
 import {cache, cacheSignal} from './ReactCacheClient';
-import {postpone} from './ReactPostpone';
 import {
   getCacheForType,
   useCallback,
@@ -84,7 +83,6 @@ export {
   memo,
   cache,
   cacheSignal,
-  postpone as unstable_postpone,
   useCallback,
   useContext,
   useEffect,
diff --git a/packages/react/src/ReactServer.experimental.development.js b/packages/react/src/ReactServer.experimental.development.js
index df8b3d79b3a..10d0123843d 100644
--- a/packages/react/src/ReactServer.experimental.development.js
+++ b/packages/react/src/ReactServer.experimental.development.js
@@ -38,7 +38,6 @@ import {lazy} from './ReactLazy';
 import {memo} from './ReactMemo';
 import {cache, cacheSignal} from './ReactCacheServer';
 import {startTransition} from './ReactStartTransition';
-import {postpone} from './ReactPostpone';
 import {captureOwnerStack} from './ReactOwnerStack';
 import version from 'shared/ReactVersion';
 
@@ -76,7 +75,6 @@ export {
   cacheSignal,
   startTransition,
   getCacheForType as unstable_getCacheForType,
-  postpone as unstable_postpone,
   useId,
   useCallback,
   useDebugValue,
diff --git a/packages/react/src/ReactServer.experimental.js b/packages/react/src/ReactServer.experimental.js
index 06c0a9bf896..9fc26341314 100644
--- a/packages/react/src/ReactServer.experimental.js
+++ b/packages/react/src/ReactServer.experimental.js
@@ -38,7 +38,6 @@ import {lazy} from './ReactLazy';
 import {memo} from './ReactMemo';
 import {cache, cacheSignal} from './ReactCacheServer';
 import {startTransition} from './ReactStartTransition';
-import {postpone} from './ReactPostpone';
 import version from 'shared/ReactVersion';
 
 const Children = {
@@ -75,7 +74,6 @@ export {
   cacheSignal,
   startTransition,
   getCacheForType as unstable_getCacheForType,
-  postpone as unstable_postpone,
   useId,
   useCallback,
   useDebugValue,
diff --git a/packages/shared/ReactFeatureFlags.js b/packages/shared/ReactFeatureFlags.js
index 6d45a30718a..1881d3fc289 100644
--- a/packages/shared/ReactFeatureFlags.js
+++ b/packages/shared/ReactFeatureFlags.js
@@ -80,7 +80,7 @@ export const enableAsyncIterableChildren = __EXPERIMENTAL__;
 
 export const enableTaint = __EXPERIMENTAL__;
 
-export const enablePostpone = __EXPERIMENTAL__;
+export const enablePostpone: boolean = false; // Probably won't ship in this form.
 
 export const enableHalt: boolean = true;
 

From dd048c3b2d8b5760dec718fb0926ca0b68660922 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Markb=C3=A5ge?= <sebastian@calyptus.eu>
Date: Wed, 5 Nov 2025 00:05:59 -0500
Subject: [PATCH 3/3] Clean up enablePostpone Experiment (#35048)

We're not shipping this and it's a lot of code to maintain that is
blocking my refactor of Fizz for SuspenseList.
---
 .../react-client/src/ReactFlightClient.js     |  105 --
 .../ReactDOMFizzDeferredValue-test.js         |   37 -
 .../src/__tests__/ReactDOMFizzServer-test.js  | 1569 +----------------
 .../ReactDOMFizzServerBrowser-test.js         |   41 -
 .../src/__tests__/ReactDOMFizzStatic-test.js  |   40 +-
 .../ReactDOMFizzStaticBrowser-test.js         | 1230 +------------
 .../__tests__/ReactDOMFizzStaticFloat-test.js |  283 ---
 .../__tests__/ReactDOMFizzStaticNode-test.js  |   28 +-
 .../src/server/ReactDOMFizzServerBrowser.js   |   10 +-
 .../src/server/ReactDOMFizzServerBun.js       |    4 +-
 .../src/server/ReactDOMFizzServerEdge.js      |   10 +-
 .../src/server/ReactDOMFizzServerNode.js      |    7 -
 .../src/server/ReactDOMFizzStaticBrowser.js   |   29 +-
 .../src/server/ReactDOMFizzStaticEdge.js      |   29 +-
 .../src/server/ReactDOMFizzStaticNode.js      |   48 +-
 .../react-markup/src/ReactMarkupClient.js     |    1 -
 .../react-markup/src/ReactMarkupServer.js     |    2 -
 .../src/ReactNoopFlightServer.js              |    2 -
 .../src/ReactFiberBeginWork.js                |   38 +-
 .../src/ReactFiberCommitWork.js               |    4 +-
 .../react-reconciler/src/ReactFiberThrow.js   |    6 -
 .../src/server/ReactFlightDOMServerNode.js    |    4 -
 .../src/server/ReactFlightDOMServerBrowser.js |    3 -
 .../src/server/ReactFlightDOMServerEdge.js    |    3 -
 .../src/server/ReactFlightDOMServerNode.js    |    6 -
 .../src/server/ReactFlightDOMServerBrowser.js |    3 -
 .../src/server/ReactFlightDOMServerEdge.js    |    3 -
 .../src/server/ReactFlightDOMServerNode.js    |    6 -
 .../src/__tests__/ReactFlightDOM-test.js      |   89 +-
 .../__tests__/ReactFlightDOMBrowser-test.js   |  116 +-
 .../src/__tests__/ReactFlightDOMEdge-test.js  |   14 +-
 .../src/__tests__/ReactFlightDOMNode-test.js  |    4 +-
 .../src/server/ReactFlightDOMServerBrowser.js |    3 -
 .../src/server/ReactFlightDOMServerEdge.js    |    3 -
 .../src/server/ReactFlightDOMServerNode.js    |    6 -
 packages/react-server/README.md               |    2 -
 packages/react-server/src/ReactFizzServer.js  |  358 +---
 .../react-server/src/ReactFlightServer.js     |  151 +-
 packages/react/src/ReactPostpone.js           |   23 -
 packages/shared/ReactFeatureFlags.js          |    2 -
 packages/shared/ReactSymbols.js               |    2 -
 .../forks/ReactFeatureFlags.native-fb.js      |    1 -
 .../forks/ReactFeatureFlags.native-oss.js     |    1 -
 .../forks/ReactFeatureFlags.test-renderer.js  |    1 -
 ...actFeatureFlags.test-renderer.native-fb.js |    1 -
 .../ReactFeatureFlags.test-renderer.www.js    |    1 -
 .../shared/forks/ReactFeatureFlags.www.js     |    2 -
 47 files changed, 216 insertions(+), 4115 deletions(-)
 delete mode 100644 packages/react-dom/src/__tests__/ReactDOMFizzStaticFloat-test.js
 delete mode 100644 packages/react/src/ReactPostpone.js

diff --git a/packages/react-client/src/ReactFlightClient.js b/packages/react-client/src/ReactFlightClient.js
index f8cc0a80f39..7b635636157 100644
--- a/packages/react-client/src/ReactFlightClient.js
+++ b/packages/react-client/src/ReactFlightClient.js
@@ -39,12 +39,9 @@ import type {
   EncodeFormActionCallback,
 } from './ReactFlightReplyClient';
 
-import type {Postpone} from 'react/src/ReactPostpone';
-
 import type {TemporaryReferenceSet} from './ReactFlightTemporaryReferences';
 
 import {
-  enablePostpone,
   enableProfilerTimer,
   enableComponentPerformanceTrack,
   enableAsyncDebugInfo,
@@ -89,7 +86,6 @@ import {
 import {
   REACT_LAZY_TYPE,
   REACT_ELEMENT_TYPE,
-  REACT_POSTPONE_TYPE,
   ASYNC_ITERATOR,
   REACT_FRAGMENT_TYPE,
 } from 'shared/ReactSymbols';
@@ -3460,88 +3456,6 @@ function resolveErrorDev(
   return error;
 }
 
-function resolvePostponeProd(
-  response: Response,
-  id: number,
-  streamState: StreamState,
-): void {
-  if (__DEV__) {
-    // These errors should never make it into a build so we don't need to encode them in codes.json
-    // eslint-disable-next-line react-internal/prod-error-codes
-    throw new Error(
-      'resolvePostponeProd should never be called in development mode. Use resolvePostponeDev instead. This is a bug in React.',
-    );
-  }
-  const error = new Error(
-    'A Server Component was postponed. The reason is omitted in production' +
-      ' builds to avoid leaking sensitive details.',
-  );
-  const postponeInstance: Postpone = (error: any);
-  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
-  postponeInstance.stack = 'Error: ' + error.message;
-  const chunks = response._chunks;
-  const chunk = chunks.get(id);
-  if (!chunk) {
-    const newChunk: ErroredChunk<any> = createErrorChunk(
-      response,
-      postponeInstance,
-    );
-    chunks.set(id, newChunk);
-  } else {
-    triggerErrorOnChunk(response, chunk, postponeInstance);
-  }
-}
-
-function resolvePostponeDev(
-  response: Response,
-  id: number,
-  reason: string,
-  stack: ReactStackTrace,
-  env: string,
-  streamState: StreamState,
-): void {
-  if (!__DEV__) {
-    // These errors should never make it into a build so we don't need to encode them in codes.json
-    // eslint-disable-next-line react-internal/prod-error-codes
-    throw new Error(
-      'resolvePostponeDev should never be called in production mode. Use resolvePostponeProd instead. This is a bug in React.',
-    );
-  }
-  let postponeInstance: Postpone;
-  const callStack = buildFakeCallStack(
-    response,
-    stack,
-    env,
-    false,
-    // $FlowFixMe[incompatible-use]
-    Error.bind(null, reason || ''),
-  );
-  const rootTask = response._debugRootTask;
-  if (rootTask != null) {
-    postponeInstance = rootTask.run(callStack);
-  } else {
-    postponeInstance = callStack();
-  }
-  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
-  const chunks = response._chunks;
-  const chunk = chunks.get(id);
-  if (!chunk) {
-    const newChunk: ErroredChunk<any> = createErrorChunk(
-      response,
-      postponeInstance,
-    );
-    if (__DEV__) {
-      resolveChunkDebugInfo(response, streamState, newChunk);
-    }
-    chunks.set(id, newChunk);
-  } else {
-    if (__DEV__) {
-      resolveChunkDebugInfo(response, streamState, chunk);
-    }
-    triggerErrorOnChunk(response, chunk, postponeInstance);
-  }
-}
-
 function resolveErrorModel(
   response: Response,
   id: number,
@@ -4893,25 +4807,6 @@ function processFullStringRow(
       return;
     }
     // Fallthrough
-    case 80 /* "P" */: {
-      if (enablePostpone) {
-        if (__DEV__) {
-          const postponeInfo = JSON.parse(row);
-          resolvePostponeDev(
-            response,
-            id,
-            postponeInfo.reason,
-            postponeInfo.stack,
-            postponeInfo.env,
-            streamState,
-          );
-        } else {
-          resolvePostponeProd(response, id, streamState);
-        }
-        return;
-      }
-    }
-    // Fallthrough
     default: /* """ "{" "[" "t" "f" "n" "0" - "9" */ {
       if (__DEV__ && row === '') {
         resolveDebugHalt(response, id);
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzDeferredValue-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzDeferredValue-test.js
index 529e3be3132..805bf89c4f1 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzDeferredValue-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzDeferredValue-test.js
@@ -90,43 +90,6 @@ describe('ReactDOMFizzForm', () => {
     expect(container.textContent).toEqual('Final');
   });
 
-  // @gate enablePostpone
-  it(
-    'if initial value postpones during hydration, it will switch to the ' +
-      'final value instead',
-    async () => {
-      function Content() {
-        const isInitial = useDeferredValue(false, true);
-        if (isInitial) {
-          React.unstable_postpone();
-        }
-        return <Text text="Final" />;
-      }
-
-      function App() {
-        return (
-          <div>
-            <Suspense fallback={<Text text="Loading..." />}>
-              <Content />
-            </Suspense>
-          </div>
-        );
-      }
-
-      const stream = await serverAct(() =>
-        ReactDOMServer.renderToReadableStream(<App />),
-      );
-      await readIntoContainer(stream);
-      expect(container.textContent).toEqual('Loading...');
-
-      assertLog(['Loading...']);
-      // After hydration, it's updated to the final value
-      await act(() => ReactDOMClient.hydrateRoot(container, <App />));
-      expect(container.textContent).toEqual('Final');
-      assertLog(['Loading...', 'Final']);
-    },
-  );
-
   it(
     'useDeferredValue during hydration has higher priority than remaining ' +
       'incremental hydration',
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
index b988bd72caf..18cf6124444 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
@@ -6665,150 +6665,6 @@ describe('ReactDOMFizzServer', () => {
     ]);
   });
 
-  // @gate enablePostpone
-  it('client renders postponed boundaries without erroring', async () => {
-    function Postponed({isClient}) {
-      if (!isClient) {
-        React.unstable_postpone('testing postpone');
-      }
-      return 'client only';
-    }
-
-    function App({isClient}) {
-      return (
-        <div>
-          <Suspense fallback={'loading...'}>
-            <Postponed isClient={isClient} />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const errors = [];
-
-    await act(() => {
-      const {pipe} = renderToPipeableStream(<App isClient={false} />, {
-        onError(error) {
-          errors.push(error.message);
-        },
-      });
-      pipe(writable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(<div>loading...</div>);
-
-    ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
-      onRecoverableError(error) {
-        errors.push(error.message);
-      },
-    });
-    await waitForAll([]);
-    // Postponing should not be logged as a recoverable error since it's intentional.
-    expect(errors).toEqual([]);
-    expect(getVisibleChildren(container)).toEqual(<div>client only</div>);
-  });
-
-  // @gate enablePostpone
-  it('errors if trying to postpone outside a Suspense boundary', async () => {
-    function Postponed() {
-      React.unstable_postpone('testing postpone');
-      return 'client only';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Postponed />
-        </div>
-      );
-    }
-
-    const errors = [];
-    const fatalErrors = [];
-    const postponed = [];
-    let written = false;
-
-    const testWritable = new Stream.Writable();
-    testWritable._write = (chunk, encoding, next) => {
-      written = true;
-    };
-
-    await act(() => {
-      const {pipe} = renderToPipeableStream(<App />, {
-        onPostpone(reason) {
-          postponed.push(reason);
-        },
-        onError(error) {
-          errors.push(error.message);
-        },
-        onShellError(error) {
-          fatalErrors.push(error.message);
-        },
-      });
-      pipe(testWritable);
-    });
-
-    expect(written).toBe(false);
-    // Postponing is not logged as an error but as a postponed reason.
-    expect(errors).toEqual([]);
-    expect(postponed).toEqual(['testing postpone']);
-    // However, it does error the shell.
-    expect(fatalErrors).toEqual(['testing postpone']);
-  });
-
-  // @gate enablePostpone
-  it('can postpone in a fallback', async () => {
-    function Postponed({isClient}) {
-      if (!isClient) {
-        React.unstable_postpone('testing postpone');
-      }
-      return 'loading...';
-    }
-
-    const lazyText = React.lazy(async () => {
-      await 0; // causes the fallback to start work
-      return {default: 'Hello'};
-    });
-
-    function App({isClient}) {
-      return (
-        <div>
-          <Suspense fallback="Outer">
-            <Suspense fallback={<Postponed isClient={isClient} />}>
-              {lazyText}
-            </Suspense>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const errors = [];
-
-    await act(() => {
-      const {pipe} = renderToPipeableStream(<App isClient={false} />, {
-        onError(error) {
-          errors.push(error.message);
-        },
-      });
-      pipe(writable);
-    });
-
-    // TODO: This should actually be fully resolved because the value could eventually
-    // resolve on the server even though the fallback couldn't so we should have been
-    // able to render it.
-    expect(getVisibleChildren(container)).toEqual(<div>Outer</div>);
-
-    ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
-      onRecoverableError(error) {
-        errors.push(error.message);
-      },
-    });
-    await waitForAll([]);
-    // Postponing should not be logged as a recoverable error since it's intentional.
-    expect(errors).toEqual([]);
-    expect(getVisibleChildren(container)).toEqual(<div>Hello</div>);
-  });
-
   it(
     'a transition that flows into a dehydrated boundary should not suspend ' +
       'if the boundary is showing a fallback',
@@ -6860,37 +6716,63 @@ describe('ReactDOMFizzServer', () => {
     },
   );
 
-  // @gate enablePostpone
-  it('supports postponing in prerender and resuming later', async () => {
+  // @gate enableHalt
+  it('can resume a prerender that was aborted', async () => {
+    const promise = new Promise(r => {});
+
     let prerendering = true;
-    function Postpone() {
+
+    function Wait() {
       if (prerendering) {
-        React.unstable_postpone();
+        return React.use(promise);
+      } else {
+        return 'Hello';
       }
-      return 'Hello';
     }
 
     function App() {
       return (
         <div>
           <Suspense fallback="Loading...">
-            <Postpone />
+            <p>
+              <span>
+                <Suspense fallback="Loading again...">
+                  <Wait />
+                </Suspense>
+              </span>
+            </p>
+            <p>
+              <span>
+                <Suspense fallback="Loading again too...">
+                  <Wait />
+                </Suspense>
+              </span>
+            </p>
           </Suspense>
         </div>
       );
     }
 
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(<App />);
-    expect(prerendered.postponed).not.toBe(null);
+    const controller = new AbortController();
+    const signal = controller.signal;
 
-    prerendering = false;
+    const errors = [];
+    function onError(error) {
+      errors.push(error);
+    }
+    let pendingPrerender;
+    await act(() => {
+      pendingPrerender = ReactDOMFizzStatic.prerenderToNodeStream(<App />, {
+        signal,
+        onError,
+      });
+    });
+    controller.abort('boom');
 
-    const resumed = ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-    );
+    const prerendered = await pendingPrerender;
+
+    expect(errors).toEqual(['boom', 'boom']);
 
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
     const preludeWritable = new Stream.PassThrough();
     preludeWritable.setEncoding('utf8');
     preludeWritable.on('data', chunk => {
@@ -6901,1378 +6783,45 @@ describe('ReactDOMFizzServer', () => {
       prerendered.prelude.pipe(preludeWritable);
     });
 
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(<div>Hello</div>);
-  });
-
-  // @gate enablePostpone
-  it('client renders a component if it errors during resuming', async () => {
-    let prerendering = true;
-    let ssr = true;
-    function PostponeAndError() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      if (ssr) {
-        throw new Error('server error');
-      }
-      return 'Hello';
-    }
-
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    const lazyPostponeAndError = React.lazy(async () => {
-      return {default: <PostponeAndError />};
-    });
-
-    function ReplayError() {
-      if (prerendering) {
-        return <Postpone />;
-      }
-      if (ssr) {
-        throw new Error('replay error');
-      }
-      return 'Hello';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading1">
-            <PostponeAndError />
-          </Suspense>
-          <Suspense fallback="Loading2">
-            <Postpone />
-            <Suspense fallback="Loading3">{lazyPostponeAndError}</Suspense>
-          </Suspense>
-          <Suspense fallback="Loading4">
-            <ReplayError />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerenderErrors = [];
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(
-      <App />,
-      {
-        onError(x) {
-          prerenderErrors.push(x.message);
-        },
-      },
+    expect(getVisibleChildren(container)).toEqual(
+      <div>
+        <p>
+          <span>Loading again...</span>
+        </p>
+        <p>
+          <span>Loading again too...</span>
+        </p>
+      </div>,
     );
-    expect(prerendered.postponed).not.toBe(null);
 
     prerendering = false;
 
-    const ssrErrors = [];
-
-    const resumed = ReactDOMFizzServer.resumeToPipeableStream(
+    errors.length = 0;
+    const resumed = await ReactDOMFizzServer.resumeToPipeableStream(
       <App />,
       JSON.parse(JSON.stringify(prerendered.postponed)),
       {
-        onError(x) {
-          ssrErrors.push(x.message);
-        },
+        onError,
       },
     );
 
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Loading1'}
-        {'Loading2'}
-        {'Loading4'}
-      </div>,
-    );
-
     await act(() => {
       resumed.pipe(writable);
     });
 
-    expect(prerenderErrors).toEqual([]);
-
-    expect(ssrErrors).toEqual(['server error', 'server error', 'replay error']);
-
-    // Still loading...
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Loading1'}
-        {'Hello'}
-        {'Loading3'}
-        {'Loading4'}
-      </div>,
-    );
-
-    const recoverableErrors = [];
-
-    ssr = false;
-
-    await clientAct(() => {
-      ReactDOMClient.hydrateRoot(container, <App />, {
-        onRecoverableError(x) {
-          recoverableErrors.push(x.message);
-        },
-      });
-    });
-
-    expect(recoverableErrors).toEqual(
-      __DEV__
-        ? [
-            'Switched to client rendering because the server rendering errored:\n\n' +
-              'server error',
-            'Switched to client rendering because the server rendering errored:\n\n' +
-              'replay error',
-            'Switched to client rendering because the server rendering errored:\n\n' +
-              'server error',
-          ]
-        : [
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-          ],
-    );
+    expect(errors).toEqual([]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
-        {'Hello'}
-        {'Hello'}
-        {'Hello'}
-        {'Hello'}
+        <p>
+          <span>Hello</span>
+        </p>
+        <p>
+          <span>Hello</span>
+        </p>
       </div>,
     );
   });
 
-  // @gate enablePostpone
-  it('client renders a component if we abort before resuming', async () => {
-    let prerendering = true;
-    let ssr = true;
-    const promise = new Promise(() => {});
-    function PostponeAndSuspend() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      if (ssr) {
-        React.use(promise);
-      }
-      return 'Hello';
-    }
-
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function DelayedBoundary() {
-      if (!prerendering && ssr) {
-        // We delay discovery of the boundary so we can abort before finding it.
-        React.use(promise);
-      }
-      return (
-        <Suspense fallback="Loading3">
-          <Postpone />
-        </Suspense>
-      );
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading1">
-            <PostponeAndSuspend />
-          </Suspense>
-          <Suspense fallback="Loading2">
-            <Postpone />
-          </Suspense>
-          <Suspense fallback="Not used">
-            <DelayedBoundary />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerenderErrors = [];
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(
-      <App />,
-      {
-        onError(x) {
-          prerenderErrors.push(x.message);
-        },
-      },
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const ssrErrors = [];
-
-    const resumed = ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-      {
-        onError(x) {
-          ssrErrors.push(x.message);
-        },
-      },
-    );
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Loading1'}
-        {'Loading2'}
-        {'Loading3'}
-      </div>,
-    );
-
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    const recoverableErrors = [];
-
-    ssr = false;
-
-    await clientAct(() => {
-      ReactDOMClient.hydrateRoot(container, <App />, {
-        onRecoverableError(x) {
-          recoverableErrors.push(x.message);
-        },
-      });
-    });
-
-    expect(recoverableErrors).toEqual([]);
-    expect(prerenderErrors).toEqual([]);
-    expect(ssrErrors).toEqual([]);
-
-    // Still loading...
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Loading1'}
-        {/*
-          This used to show "Hello" in this slot because the boundary was able to be flushed
-          early but we now prevent flushing while pendingRootTasks is not zero. This is how Edge
-          would work anyway because you don't get the stream until the root is unblocked on a resume
-          so Node now aligns with edge bevavior
-          {'Hello'}
-        */}
-        {'Loading2'}
-        {'Loading3'}
-      </div>,
-    );
-
-    await clientAct(async () => {
-      await act(() => {
-        resumed.abort(new Error('aborted'));
-      });
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Hello'}
-        {'Hello'}
-        {'Hello'}
-      </div>,
-    );
-
-    expect(prerenderErrors).toEqual([]);
-    expect(ssrErrors).toEqual(['aborted', 'aborted']);
-    expect(recoverableErrors).toEqual(
-      __DEV__
-        ? [
-            'Switched to client rendering because the server rendering aborted due to:\n\n' +
-              'aborted',
-            'Switched to client rendering because the server rendering aborted due to:\n\n' +
-              'aborted',
-          ]
-        : [
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-          ],
-    );
-  });
-
-  // @gate enablePostpone
-  it('client renders remaining boundaries below the error in shell', async () => {
-    let prerendering = true;
-    let ssr = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function ReplayError({children}) {
-      if (!prerendering && ssr) {
-        throw new Error('replay error');
-      }
-      return children;
-    }
-
-    function App() {
-      return (
-        <div>
-          <div>
-            <Suspense fallback="Loading1">
-              <Postpone />
-            </Suspense>
-            <ReplayError>
-              <Suspense fallback="Loading2">
-                <Postpone />
-              </Suspense>
-            </ReplayError>
-            <Suspense fallback="Loading3">
-              <Postpone />
-            </Suspense>
-          </div>
-          <Suspense fallback="Not used">
-            <div>
-              <Suspense fallback="Loading4">
-                <Postpone />
-              </Suspense>
-            </div>
-          </Suspense>
-          <Suspense fallback="Loading5">
-            <Postpone />
-            <ReplayError>
-              <Suspense fallback="Loading6">
-                <Postpone />
-              </Suspense>
-            </ReplayError>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerenderErrors = [];
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(
-      <App />,
-      {
-        onError(x) {
-          prerenderErrors.push(x.message);
-        },
-      },
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const ssrErrors = [];
-
-    const resumed = ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-      {
-        onError(x) {
-          ssrErrors.push(x.message);
-        },
-      },
-    );
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <div>
-          {'Loading1'}
-          {'Loading2'}
-          {'Loading3'}
-        </div>
-        <div>{'Loading4'}</div>
-        {'Loading5'}
-      </div>,
-    );
-
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <div>
-          {'Hello' /* This was matched and completed before the error */}
-          {
-            'Loading2' /* This will be client rendered because its parent errored during replay */
-          }
-          {
-            'Hello' /* This should be renderable since we matched which previous sibling errored */
-          }
-        </div>
-        <div>
-          {
-            'Hello' /* This should be able to resume because it's in a different parent. */
-          }
-        </div>
-        {'Hello'}
-        {'Loading6' /* The parent could resolve even if the child didn't */}
-      </div>,
-    );
-
-    const recoverableErrors = [];
-
-    ssr = false;
-
-    await clientAct(() => {
-      ReactDOMClient.hydrateRoot(container, <App />, {
-        onRecoverableError(x) {
-          recoverableErrors.push(x.message);
-        },
-      });
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <div>
-          {'Hello'}
-          {'Hello'}
-          {'Hello'}
-        </div>
-        <div>{'Hello'}</div>
-        {'Hello'}
-        {'Hello'}
-      </div>,
-    );
-
-    // We should've logged once for each boundary that this affected.
-    expect(prerenderErrors).toEqual([]);
-    expect(ssrErrors).toEqual([
-      // This error triggered in two replay components.
-      'replay error',
-      'replay error',
-    ]);
-    expect(recoverableErrors).toEqual(
-      // It surfaced in two different suspense boundaries.
-      __DEV__
-        ? [
-            'Switched to client rendering because the server rendering errored:\n\n' +
-              'replay error',
-            'Switched to client rendering because the server rendering errored:\n\n' +
-              'replay error',
-          ]
-        : [
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-          ],
-    );
-  });
-
-  // @gate enablePostpone
-  it('can client render a boundary after having already postponed', async () => {
-    let prerendering = true;
-    let ssr = true;
-
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function ServerError() {
-      if (ssr) {
-        throw new Error('server error');
-      }
-      return 'World';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading1">
-            <Postpone />
-            <ServerError />
-          </Suspense>
-          <Suspense fallback="Loading2">
-            <Postpone />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerenderErrors = [];
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(
-      <App />,
-      {
-        onError(x) {
-          prerenderErrors.push(x.message);
-        },
-      },
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const ssrErrors = [];
-
-    const resumed = ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-      {
-        onError(x) {
-          ssrErrors.push(x.message);
-        },
-      },
-    );
-
-    const windowErrors = [];
-    function globalError(e) {
-      windowErrors.push(e.message);
-    }
-    window.addEventListener('error', globalError);
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(windowErrors).toEqual([]);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Loading1'}
-        {'Loading2'}
-      </div>,
-    );
-
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    expect(prerenderErrors).toEqual(['server error']);
-
-    // Since this errored, we shouldn't have to replay it.
-    expect(ssrErrors).toEqual([]);
-
-    expect(windowErrors).toEqual([]);
-
-    // Still loading...
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Loading1'}
-        {'Hello'}
-      </div>,
-    );
-
-    const recoverableErrors = [];
-
-    ssr = false;
-
-    await clientAct(() => {
-      ReactDOMClient.hydrateRoot(container, <App />, {
-        onRecoverableError(x) {
-          recoverableErrors.push(x.message);
-        },
-      });
-    });
-
-    expect(recoverableErrors).toEqual(
-      __DEV__
-        ? [
-            'Switched to client rendering because the server rendering errored:\n\n' +
-              'server error',
-          ]
-        : [
-            'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.',
-          ],
-    );
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Hello'}
-        {'World'}
-        {'Hello'}
-      </div>,
-    );
-
-    expect(windowErrors).toEqual([]);
-
-    window.removeEventListener('error', globalError);
-  });
-
-  // @gate enablePostpone
-  it('can postpone in fallback', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    let resolve;
-    const promise = new Promise(r => (resolve = r));
-
-    function PostponeAndDelay() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return React.use(promise);
-    }
-
-    const Lazy = React.lazy(async () => {
-      await 0;
-      return {default: Postpone};
-    });
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Outer">
-            <Suspense fallback={<Postpone />}>
-              <PostponeAndDelay /> World
-            </Suspense>
-            <Suspense fallback={<Postpone />}>
-              <Lazy />
-            </Suspense>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(<App />);
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    const resumed = await ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-    );
-
-    expect(getVisibleChildren(container)).toEqual(<div>Outer</div>);
-
-    // Read what we've completed so far
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    // Should have now resolved the postponed loading state, but not the promise
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Hello'}
-        {'Hello'}
-      </div>,
-    );
-
-    // Resolve the final promise
-    await act(() => {
-      resolve('Hi');
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Hi'}
-        {' World'}
-        {'Hello'}
-      </div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('can discover new suspense boundaries in the resume', async () => {
-    let prerendering = true;
-    let resolveA;
-    const promiseA = new Promise(r => (resolveA = r));
-    let resolveB;
-    const promiseB = new Promise(r => (resolveB = r));
-
-    function WaitA() {
-      return React.use(promiseA);
-    }
-    function WaitB() {
-      return React.use(promiseB);
-    }
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return (
-        <span>
-          <Suspense fallback="Loading again...">
-            <WaitA />
-          </Suspense>
-          <WaitB />
-        </span>
-      );
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <p>
-              <Postpone />
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(<App />);
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    const resumed = await ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-    );
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    // Read what we've completed so far
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    // Still blocked
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    // Resolve the first promise, this unblocks the inner boundary
-    await act(() => {
-      resolveA('Hello');
-    });
-
-    // Still blocked
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    // Resolve the second promise, this unblocks the outer boundary
-    await act(() => {
-      resolveB('World');
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>
-            {'Hello'}
-            {'World'}
-          </span>
-        </p>
-      </div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('does not call onError when you abort with a postpone instance during prerender', async () => {
-    const promise = new Promise(r => {});
-
-    function Wait() {
-      return React.use(promise);
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <p>
-              <span>
-                <Suspense fallback="Loading again...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-            <p>
-              <span>
-                <Suspense fallback="Loading again too...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    let postponeInstance;
-    try {
-      React.unstable_postpone('manufactured');
-    } catch (p) {
-      postponeInstance = p;
-    }
-
-    const controller = new AbortController();
-    const signal = controller.signal;
-
-    const errors = [];
-    function onError(error) {
-      errors.push(error);
-    }
-    const postpones = [];
-    function onPostpone(reason) {
-      postpones.push(reason);
-    }
-    let pendingPrerender;
-    await act(() => {
-      pendingPrerender = ReactDOMFizzStatic.prerenderToNodeStream(<App />, {
-        signal,
-        onError,
-        onPostpone,
-      });
-    });
-    controller.abort(postponeInstance);
-
-    const prerendered = await pendingPrerender;
-
-    expect(errors).toEqual([]);
-    expect(postpones).toEqual(['manufactured', 'manufactured']);
-
-    await act(() => {
-      prerendered.prelude.pipe(writable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>Loading again...</span>
-        </p>
-        <p>
-          <span>Loading again too...</span>
-        </p>
-      </div>,
-    );
-  });
-
-  // @gate enableHalt
-  it('can resume a prerender that was aborted', async () => {
-    const promise = new Promise(r => {});
-
-    let prerendering = true;
-
-    function Wait() {
-      if (prerendering) {
-        return React.use(promise);
-      } else {
-        return 'Hello';
-      }
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <p>
-              <span>
-                <Suspense fallback="Loading again...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-            <p>
-              <span>
-                <Suspense fallback="Loading again too...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const controller = new AbortController();
-    const signal = controller.signal;
-
-    const errors = [];
-    function onError(error) {
-      errors.push(error);
-    }
-    let pendingPrerender;
-    await act(() => {
-      pendingPrerender = ReactDOMFizzStatic.prerenderToNodeStream(<App />, {
-        signal,
-        onError,
-      });
-    });
-    controller.abort('boom');
-
-    const prerendered = await pendingPrerender;
-
-    expect(errors).toEqual(['boom', 'boom']);
-
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>Loading again...</span>
-        </p>
-        <p>
-          <span>Loading again too...</span>
-        </p>
-      </div>,
-    );
-
-    prerendering = false;
-
-    errors.length = 0;
-    const resumed = await ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-      {
-        onError,
-      },
-    );
-
-    await act(() => {
-      resumed.pipe(writable);
-    });
-
-    expect(errors).toEqual([]);
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>Hello</span>
-        </p>
-        <p>
-          <span>Hello</span>
-        </p>
-      </div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('does not call onError when you abort with a postpone instance during resume', async () => {
-    let prerendering = true;
-    const promise = new Promise(r => {});
-
-    function Wait() {
-      return React.use(promise);
-    }
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return (
-        <span>
-          <Suspense fallback="Loading again...">
-            <Wait />
-          </Suspense>
-        </span>
-      );
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <p>
-              <Postpone />
-            </p>
-            <p>
-              <Postpone />
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(<App />);
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    let postponeInstance;
-    try {
-      React.unstable_postpone('manufactured');
-    } catch (p) {
-      postponeInstance = p;
-    }
-
-    const errors = [];
-    function onError(error) {
-      errors.push(error);
-    }
-    const postpones = [];
-    function onPostpone(reason) {
-      postpones.push(reason);
-    }
-
-    prerendering = false;
-
-    const resumed = await ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-      {
-        onError,
-        onPostpone,
-      },
-    );
-
-    await act(() => {
-      resumed.pipe(writable);
-    });
-    await act(() => {
-      resumed.abort(postponeInstance);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>Loading again...</span>
-        </p>
-        <p>
-          <span>Loading again...</span>
-        </p>
-      </div>,
-    );
-
-    expect(errors).toEqual([]);
-    expect(postpones).toEqual(['manufactured', 'manufactured']);
-  });
-
-  // @gate enablePostpone
-  it('does not call onError when you abort with a postpone instance during a render', async () => {
-    const promise = new Promise(r => {});
-
-    function Wait() {
-      return React.use(promise);
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <p>
-              <span>
-                <Suspense fallback="Loading again...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-            <p>
-              <span>
-                <Suspense fallback="Loading again...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const errors = [];
-    function onError(error) {
-      errors.push(error);
-    }
-    const postpones = [];
-    function onPostpone(reason) {
-      postpones.push(reason);
-    }
-    const result = await renderToPipeableStream(<App />, {onError, onPostpone});
-    await act(() => {
-      result.pipe(writable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>Loading again...</span>
-        </p>
-        <p>
-          <span>Loading again...</span>
-        </p>
-      </div>,
-    );
-
-    let postponeInstance;
-    try {
-      React.unstable_postpone('manufactured');
-    } catch (p) {
-      postponeInstance = p;
-    }
-    await act(() => {
-      result.abort(postponeInstance);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <p>
-          <span>Loading again...</span>
-        </p>
-        <p>
-          <span>Loading again...</span>
-        </p>
-      </div>,
-    );
-
-    expect(errors).toEqual([]);
-    expect(postpones).toEqual(['manufactured', 'manufactured']);
-  });
-
-  // @gate enablePostpone
-  it('fatally errors if you abort with a postpone in the shell during resume', async () => {
-    let prerendering = true;
-    const promise = new Promise(r => {});
-
-    function Wait() {
-      return React.use(promise);
-    }
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return (
-        <span>
-          <Suspense fallback="Loading again...">
-            <Wait />
-          </Suspense>
-        </span>
-      );
-    }
-
-    function PostponeInShell() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return <span>in shell</span>;
-    }
-
-    function App() {
-      return (
-        <div>
-          <PostponeInShell />
-          <Suspense fallback="Loading...">
-            <p>
-              <Postpone />
-            </p>
-            <p>
-              <Postpone />
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await ReactDOMFizzStatic.prerenderToNodeStream(<App />);
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    // Create a separate stream so it doesn't close the writable. I.e. simple concat.
-    const preludeWritable = new Stream.PassThrough();
-    preludeWritable.setEncoding('utf8');
-    preludeWritable.on('data', chunk => {
-      writable.write(chunk);
-    });
-
-    await act(() => {
-      prerendered.prelude.pipe(preludeWritable);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(undefined);
-
-    let postponeInstance;
-    try {
-      React.unstable_postpone('manufactured');
-    } catch (p) {
-      postponeInstance = p;
-    }
-
-    const errors = [];
-    function onError(error) {
-      errors.push(error);
-    }
-    const shellErrors = [];
-    function onShellError(error) {
-      shellErrors.push(error);
-    }
-    const postpones = [];
-    function onPostpone(reason) {
-      postpones.push(reason);
-    }
-
-    prerendering = false;
-
-    const resumed = ReactDOMFizzServer.resumeToPipeableStream(
-      <App />,
-      JSON.parse(JSON.stringify(prerendered.postponed)),
-      {
-        onError,
-        onShellError,
-        onPostpone,
-      },
-    );
-    await act(() => {
-      resumed.abort(postponeInstance);
-    });
-    expect(errors).toEqual([
-      new Error(
-        'The render was aborted with postpone when the shell is incomplete. Reason: manufactured',
-      ),
-    ]);
-    expect(shellErrors).toEqual([
-      new Error(
-        'The render was aborted with postpone when the shell is incomplete. Reason: manufactured',
-      ),
-    ]);
-    expect(postpones).toEqual([]);
-  });
-
-  // @gate enablePostpone
-  it('fatally errors if you abort with a postpone in the shell during render', async () => {
-    const promise = new Promise(r => {});
-
-    function Wait() {
-      return React.use(promise);
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <p>
-              <span>
-                <Suspense fallback="Loading again...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-            <p>
-              <span>
-                <Suspense fallback="Loading again...">
-                  <Wait />
-                </Suspense>
-              </span>
-            </p>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const errors = [];
-    function onError(error) {
-      errors.push(error);
-    }
-    const shellErrors = [];
-    function onShellError(error) {
-      shellErrors.push(error);
-    }
-    const postpones = [];
-    function onPostpone(reason) {
-      postpones.push(reason);
-    }
-    const result = renderToPipeableStream(<App />, {
-      onError,
-      onShellError,
-      onPostpone,
-    });
-
-    let postponeInstance;
-    try {
-      React.unstable_postpone('manufactured');
-    } catch (p) {
-      postponeInstance = p;
-    }
-    await act(() => {
-      result.abort(postponeInstance);
-    });
-
-    expect(getVisibleChildren(container)).toEqual(undefined);
-
-    expect(errors).toEqual([
-      new Error(
-        'The render was aborted with postpone when the shell is incomplete. Reason: manufactured',
-      ),
-    ]);
-    expect(shellErrors).toEqual([
-      new Error(
-        'The render was aborted with postpone when the shell is incomplete. Reason: manufactured',
-      ),
-    ]);
-    expect(postpones).toEqual([]);
-  });
-
   it('should NOT warn for using generator functions as components', async () => {
     function* Foo() {
       yield <h1 key="1">Hello</h1>;
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js
index bc96750d460..27e74750c45 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js
@@ -551,45 +551,4 @@ describe('ReactDOMFizzServerBrowser', () => {
       `"<link rel="preload" as="script" fetchPriority="low" nonce="R4nd0m" href="init.js"/><link rel="modulepreload" fetchPriority="low" nonce="R4nd0m" href="init.mjs"/><div>hello world</div><script nonce="${nonce}" id="_R_">INIT();</script><script src="init.js" nonce="${nonce}" async=""></script><script type="module" src="init.mjs" nonce="${nonce}" async=""></script>"`,
     );
   });
-
-  // @gate enablePostpone
-  it('errors if trying to postpone outside a Suspense boundary', async () => {
-    function Postponed() {
-      React.unstable_postpone('testing postpone');
-      return 'client only';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Postponed />
-        </div>
-      );
-    }
-
-    const errors = [];
-    const postponed = [];
-
-    let caughtError = null;
-    try {
-      await serverAct(() =>
-        ReactDOMFizzServer.renderToReadableStream(<App />, {
-          onError(error) {
-            errors.push(error.message);
-          },
-          onPostpone(reason) {
-            postponed.push(reason);
-          },
-        }),
-      );
-    } catch (error) {
-      caughtError = error;
-    }
-
-    // Postponing is not logged as an error but as a postponed reason.
-    expect(errors).toEqual([]);
-    expect(postponed).toEqual(['testing postpone']);
-    // However, it does error the shell.
-    expect(caughtError.message).toEqual('testing postpone');
-  });
 });
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js
index a4ac87c92c4..4542ca618ba 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzStatic-test.js
@@ -231,9 +231,7 @@ describe('ReactDOMFizzStatic', () => {
     const result = await promise;
 
     expect(result.postponed).toBe(
-      gate(flags => flags.enableHalt || flags.enablePostpone)
-        ? null
-        : undefined,
+      gate(flags => flags.enableHalt) ? null : undefined,
     );
 
     await act(async () => {
@@ -302,42 +300,6 @@ describe('ReactDOMFizzStatic', () => {
     expect(getVisibleChildren(container)).toEqual('hello');
   });
 
-  // @gate enablePostpone
-  it('includes stylesheet preloads in onHeaders when postponing in the Shell', async () => {
-    let headers;
-    function onHeaders(x) {
-      headers = x;
-    }
-
-    function App() {
-      ReactDOM.preload('image', {as: 'image', fetchPriority: 'high'});
-      ReactDOM.preinit('style', {as: 'style'});
-      React.unstable_postpone();
-      return (
-        <html>
-          <body>hello</body>
-        </html>
-      );
-    }
-
-    const result = await ReactDOMFizzStatic.prerenderToNodeStream(<App />, {
-      onHeaders,
-    });
-    expect(headers).toEqual({
-      Link: `
-<image>; rel=preload; as="image"; fetchpriority="high",
- <style>; rel=preload; as="style"
-`
-        .replaceAll('\n', '')
-        .trim(),
-    });
-
-    await act(async () => {
-      result.prelude.pipe(writable);
-    });
-    expect(getVisibleChildren(container)).toEqual(undefined);
-  });
-
   it('will prerender Suspense fallbacks before children', async () => {
     const values = [];
     function Indirection({children}) {
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js
index cf4a65821e4..beebd3a1165 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js
@@ -25,7 +25,6 @@ global.TextDecoder = require('util').TextDecoder;
 
 let JSDOM;
 let React;
-let ReactDOM;
 let ReactDOMFizzServer;
 let ReactDOMFizzStatic;
 let Suspense;
@@ -46,7 +45,6 @@ describe('ReactDOMFizzStaticBrowser', () => {
     serverAct = require('internal-test-utils').serverAct;
 
     React = require('react');
-    ReactDOM = require('react-dom');
     ReactDOMFizzServer = require('react-dom/server.browser');
     ReactDOMFizzStatic = require('react-dom/static.browser');
     Suspense = React.Suspense;
@@ -71,36 +69,6 @@ describe('ReactDOMFizzStaticBrowser', () => {
     throw theInfinitePromise;
   }
 
-  function concat(streamA, streamB) {
-    const readerA = streamA.getReader();
-    const readerB = streamB.getReader();
-    return new ReadableStream({
-      start(controller) {
-        function readA() {
-          readerA.read().then(({done, value}) => {
-            if (done) {
-              readB();
-              return;
-            }
-            controller.enqueue(value);
-            readA();
-          });
-        }
-        function readB() {
-          readerB.read().then(({done, value}) => {
-            if (done) {
-              controller.close();
-              return;
-            }
-            controller.enqueue(value);
-            readB();
-          });
-        }
-        readA();
-      },
-    });
-  }
-
   async function readContent(stream) {
     const reader = stream.getReader();
     let content = '';
@@ -609,1202 +577,28 @@ describe('ReactDOMFizzStaticBrowser', () => {
     expect(errors).toEqual(['uh oh', 'uh oh']);
   });
 
-  // @gate enablePostpone
-  it('supports postponing in prerender and resuming later', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return ['Hello', 'World'];
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <Postpone />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>{['Hello', 'World']}</div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('supports postponing in prerender and resuming with a prefix', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'World';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            Hello
-            <Postpone />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>{['Hello', 'World']}</div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('supports postponing in lazy in prerender and resuming later', async () => {
-    let prerendering = true;
-    const Hole = React.lazy(async () => {
-      React.unstable_postpone();
-    });
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            Hi
-            {prerendering ? Hole : 'Hello'}
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Hi'}
-        {'Hello'}
-      </div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('supports postponing in a nested array', async () => {
-    let prerendering = true;
-    const Hole = React.lazy(async () => {
-      React.unstable_postpone();
-    });
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            Hi
-            {[<Postpone key="key" />, prerendering ? Hole : 'World']}
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>{['Hi', 'Hello', 'World']}</div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('supports postponing in lazy as a direct child', async () => {
-    let prerendering = true;
-    const Hole = React.lazy(async () => {
-      React.unstable_postpone();
-    });
-    function Postpone() {
-      return prerendering ? Hole : 'Hello';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <Postpone key="key" />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Hello</div>);
-  });
-
-  // @gate enablePostpone
-  it('only emits end tags once when resuming', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function App() {
-      return (
-        <html>
-          <body>
-            <Suspense fallback="Loading...">
-              <Postpone />
-            </Suspense>
-          </body>
-        </html>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    const html = await readContent(concat(prerendered.prelude, content));
-    const htmlEndTags = /<\/html\s*>/gi;
-    const bodyEndTags = /<\/body\s*>/gi;
-    expect(Array.from(html.matchAll(htmlEndTags)).length).toBe(1);
-    expect(Array.from(html.matchAll(bodyEndTags)).length).toBe(1);
-  });
-
-  // @gate enablePostpone
-  it('can prerender various hoistables and deduped resources', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return (
-        <>
-          <link rel="stylesheet" href="my-style2" precedence="low" />
-          <link rel="stylesheet" href="my-style1" precedence="high" />
-          <style precedence="high" href="my-style3">
-            style
-          </style>
-          <img src="my-img" />
-        </>
-      );
+  it('logs an error if onHeaders throws but continues the prerender', async () => {
+    const errors = [];
+    function onError(error) {
+      errors.push(error.message);
     }
 
-    function App() {
-      ReactDOM.preconnect('example.com');
-      ReactDOM.preload('my-font', {as: 'font', type: 'font/woff2'});
-      ReactDOM.preload('my-style0', {as: 'style'});
-      // This should transfer the props in to the style that loads later.
-      ReactDOM.preload('my-style2', {
-        as: 'style',
-        crossOrigin: 'use-credentials',
-      });
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <link rel="stylesheet" href="my-style1" precedence="high" />
-            <img src="my-img" />
-            <Postpone />
-          </Suspense>
-          <title>Hello World</title>
-        </div>
-      );
+    function onHeaders(x) {
+      throw new Error('bad onHeaders');
     }
 
-    let calledInit = false;
-    jest.mock(
-      'init.js',
-      () => {
-        calledInit = true;
-      },
-      {virtual: true},
-    );
-
     const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />, {
-        bootstrapScripts: ['init.js'],
+      ReactDOMFizzStatic.prerender(<div>hello</div>, {
+        onHeaders,
+        onError,
       }),
     );
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual([
-      <link href="example.com" rel="preconnect" />,
-      <link
-        as="font"
-        crossorigin=""
-        href="my-font"
-        rel="preload"
-        type="font/woff2"
-      />,
-      <link as="image" href="my-img" rel="preload" />,
-      <link data-precedence="high" href="my-style1" rel="stylesheet" />,
-      <link as="script" fetchpriority="low" href="init.js" rel="preload" />,
-      <link as="style" href="my-style0" rel="preload" />,
-      <link
-        as="style"
-        crossorigin="use-credentials"
-        href="my-style2"
-        rel="preload"
-      />,
-      <title>Hello World</title>,
-      <div>Loading...</div>,
-    ]);
-
-    prerendering = false;
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(content);
-
-    expect(calledInit).toBe(true);
-
-    // Dispatch load event to injected stylesheet
-    const link = document.querySelector(
-      'link[rel="stylesheet"][href="my-style2"]',
-    );
-    const event = document.createEvent('Events');
-    event.initEvent('load', true, true);
-    link.dispatchEvent(event);
-
-    // Wait for the instruction microtasks to flush.
-    await 0;
-    await 0;
-    jest.runAllTimers();
-
-    expect(getVisibleChildren(container)).toEqual([
-      <link href="example.com" rel="preconnect" />,
-      <link
-        as="font"
-        crossorigin=""
-        href="my-font"
-        rel="preload"
-        type="font/woff2"
-      />,
-      <link as="image" href="my-img" rel="preload" />,
-      <link data-precedence="high" href="my-style1" rel="stylesheet" />,
-      <style data-href="my-style3" data-precedence="high">
-        style
-      </style>,
-      <link
-        crossorigin="use-credentials"
-        data-precedence="low"
-        href="my-style2"
-        rel="stylesheet"
-      />,
-      <link as="script" fetchpriority="low" href="init.js" rel="preload" />,
-      <link as="style" href="my-style0" rel="preload" />,
-      <link
-        as="style"
-        crossorigin="use-credentials"
-        href="my-style2"
-        rel="preload"
-      />,
-      <title>Hello World</title>,
-      <div>
-        <img src="my-img" />
-        <img src="my-img" />
-      </div>,
-    ]);
-  });
-
-  // @gate enablePostpone
-  it('can postpone a boundary after it has already been added', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <Suspense fallback="Loading...">
-              <Postpone />
-            </Suspense>
-            <Postpone />
-            <Postpone />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
+    expect(prerendered.postponed).toBe(
+      gate(flags => flags.enableHalt) ? null : undefined,
     );
+    expect(errors).toEqual(['bad onHeaders']);
 
     await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>{['Hello', 'Hello', 'Hello']}</div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('can postpone in fallback', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    const Lazy = React.lazy(async () => {
-      await 0;
-      return {default: Postpone};
-    });
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Outer">
-            <Suspense fallback={<Postpone />}>
-              <Postpone /> World
-            </Suspense>
-            <Suspense fallback={<Postpone />}>
-              <Lazy />
-            </Suspense>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Outer</div>);
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        {'Hello'}
-        {' World'}
-        {'Hello'}
-      </div>,
-    );
-  });
-
-  // @gate enablePostpone
-  it('can postpone in fallback without postponing the tree', async () => {
-    function Postpone() {
-      React.unstable_postpone();
-    }
-
-    const lazyText = React.lazy(async () => {
-      await 0; // causes the fallback to start work
-      return {default: 'Hello'};
-    });
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Outer">
-            <Suspense fallback={<Postpone />}>{lazyText}</Suspense>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    // TODO: This should actually be null because we should've been able to fully
-    // resolve the render on the server eventually, even though the fallback postponed.
-    // So we should not need to resume.
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Outer</div>);
-
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(resumed);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Hello</div>);
-  });
-
-  // @gate enablePostpone
-  it('errors if the replay does not line up', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function Wrapper({children}) {
-      return children;
-    }
-
-    const lazySpan = React.lazy(async () => {
-      await 0;
-      return {default: <span />};
-    });
-
-    function App() {
-      const children = (
-        <Suspense fallback="Loading...">
-          <Postpone />
-        </Suspense>
-      );
-      return (
-        <>
-          <div>{prerendering ? <Wrapper>{children}</Wrapper> : children}</div>
-          <div>
-            {prerendering ? (
-              <Suspense fallback="Loading...">
-                <div>
-                  <Postpone />
-                </div>
-              </Suspense>
-            ) : (
-              lazySpan
-            )}
-          </div>
-        </>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual([
-      <div>Loading...</div>,
-      <div>Loading...</div>,
-    ]);
-
-    prerendering = false;
-
-    const errors = [];
-    const resumed = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-        {
-          onError(x) {
-            errors.push(x.message);
-          },
-        },
-      ),
-    );
-
-    expect(errors).toEqual([
-      'Expected the resume to render <Wrapper> in this slot but instead it rendered <Suspense>. ' +
-        "The tree doesn't match so React will fallback to client rendering.",
-      'Expected the resume to render <Suspense> in this slot but instead it rendered <span>. ' +
-        "The tree doesn't match so React will fallback to client rendering.",
-    ]);
-
-    // TODO: Test the component stack but we don't expose it to the server yet.
-
-    await readIntoContainer(resumed);
-
-    // Client rendered
-    expect(getVisibleChildren(container)).toEqual([
-      <div>Loading...</div>,
-      <div>Loading...</div>,
-    ]);
-  });
-
-  // @gate enablePostpone
-  it('can abort the resume', async () => {
-    let prerendering = true;
-    const infinitePromise = new Promise(() => {});
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function App() {
-      if (!prerendering) {
-        React.use(infinitePromise);
-      }
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <Postpone />
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    prerendering = false;
-
-    const controller = new AbortController();
-
-    const errors = [];
-
-    const resumedPromise = serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-        {
-          signal: controller.signal,
-          onError(x) {
-            errors.push(x);
-          },
-        },
-      ),
-    );
-
-    controller.abort('abort');
-
-    const resumed = await resumedPromise;
-    await resumed.allReady;
-
-    expect(errors).toEqual(['abort']);
-
-    await readIntoContainer(resumed);
-
-    // Client rendered
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-  });
-
-  // @gate enablePostpone
-  it('can suspend in a replayed component several layers deep', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    let resolve;
-    const promise = new Promise(r => (resolve = r));
-    function Delay({children}) {
-      if (!prerendering) {
-        React.use(promise);
-      }
-      return children;
-    }
-
-    // This wrapper will cause us to do one destructive render past this.
-    function Outer({children}) {
-      return children;
-    }
-
-    function App() {
-      return (
-        <div>
-          <Outer>
-            <Delay>
-              <Suspense fallback="Loading...">
-                <Postpone />
-              </Suspense>
-            </Delay>
-          </Outer>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    prerendering = false;
-
-    const resumedPromise = serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await jest.runAllTimers();
-
-    expect(getVisibleChildren(container)).toEqual(<div>Loading...</div>);
-
-    await resolve();
-
-    await readIntoContainer(await resumedPromise);
-
-    expect(getVisibleChildren(container)).toEqual(<div>Hello</div>);
-  });
-
-  // @gate enablePostpone
-  it('emits an empty prelude and resumes at the root if we postpone in the shell', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    function App() {
-      return (
-        <html lang="en">
-          <body>
-            <link rel="stylesheet" href="my-style" precedence="high" />
-            <Postpone />
-          </body>
-        </html>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    expect(await readContent(prerendered.prelude)).toBe('');
-
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    expect(await readContent(content)).toBe(
-      '<!DOCTYPE html><html lang="en"><head>' +
-        '<link rel="stylesheet" href="my-style" data-precedence="high"/>' +
-        (gate(flags => flags.enableFizzBlockingRender)
-          ? '<link rel="expect" href="#_R_" blocking="render"/>'
-          : '') +
-        '</head>' +
-        '<body>Hello' +
-        (gate(flags => flags.enableFizzBlockingRender)
-          ? '<template id="_R_"></template>'
-          : '') +
-        '</body></html>',
-    );
-  });
-
-  // @gate enablePostpone
-  it('emits an empty prelude if we have not rendered html or head tags yet', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return (
-        <html lang="en">
-          <body>Hello</body>
-        </html>
-      );
-    }
-
-    function App() {
-      return (
-        <>
-          <link rel="stylesheet" href="my-style" precedence="high" />
-          <Postpone />
-        </>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    expect(await readContent(prerendered.prelude)).toBe('');
-
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    expect(await readContent(content)).toBe(
-      '<!DOCTYPE html><html lang="en"><head>' +
-        '<link rel="stylesheet" href="my-style" data-precedence="high"/>' +
-        '<link rel="expect" href="#_R_" blocking="render"/></head>' +
-        '<body>Hello<template id="_R_"></template></body></html>',
-    );
-  });
-
-  // @gate enablePostpone
-  it('emits an empty prelude if a postpone in a promise in the shell', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return 'Hello';
-    }
-
-    const Lazy = React.lazy(async () => {
-      await 0;
-      return {default: Postpone};
-    });
-
-    function App() {
-      return (
-        <html>
-          <link rel="stylesheet" href="my-style" precedence="high" />
-          <body>
-            <div>
-              <Lazy />
-            </div>
-          </body>
-        </html>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    expect(await readContent(prerendered.prelude)).toBe('');
-
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    expect(await readContent(content)).toBe(
-      '<!DOCTYPE html><html><head>' +
-        '<link rel="stylesheet" href="my-style" data-precedence="high"/>' +
-        '<link rel="expect" href="#_R_" blocking="render"/></head>' +
-        '<body><div>Hello</div><template id="_R_"></template></body></html>',
-    );
-  });
-
-  // @gate enablePostpone
-  it('does not emit preloads during resume for Resources preloaded through onHeaders', async () => {
-    let prerendering = true;
-
-    let hasLoaded = false;
-    let resolve;
-    const promise = new Promise(r => (resolve = r));
-    function WaitIfResuming({children}) {
-      if (!prerendering && !hasLoaded) {
-        throw promise;
-      }
-      return children;
-    }
-
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return null;
-    }
-
-    let headers;
-    function onHeaders(x) {
-      headers = x;
-    }
-
-    function App() {
-      ReactDOM.preload('image', {as: 'image', fetchPriority: 'high'});
-      return (
-        <html>
-          <body>
-            hello
-            <Suspense fallback={null}>
-              <WaitIfResuming>
-                world
-                <link rel="stylesheet" href="style" precedence="default" />
-              </WaitIfResuming>
-            </Suspense>
-            <Postpone />
-          </body>
-        </html>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />, {
-        onHeaders,
-      }),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    prerendering = false;
-
-    expect(await readContent(prerendered.prelude)).toBe('');
-    expect(headers).toEqual(
-      new Headers({
-        Link: `
-<image>; rel=preload; as="image"; fetchpriority="high",
- <style>; rel=preload; as="style"
-`
-          .replaceAll('\n', '')
-          .trim(),
-      }),
-    );
-
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    const decoder = new TextDecoder();
-    const reader = content.getReader();
-    let {value, done} = await reader.read();
-    let result = decoder.decode(value, {stream: true});
-
-    expect(result).toBe(
-      '<!DOCTYPE html><html><head><link rel="expect" href="#_R_" blocking="render"/></head>' +
-        '<body>hello<!--$?--><template id="B:0"></template><!--/$--><script id="_R_">requestAnimationFrame(function(){$RT=performance.now()});</script>',
-    );
-
-    await 1;
-    hasLoaded = true;
-    await serverAct(resolve);
-
-    while (true) {
-      ({value, done} = await reader.read());
-      if (done) {
-        result += decoder.decode(value);
-        break;
-      }
-      result += decoder.decode(value, {stream: true});
-    }
-
-    // We are mostly just trying to assert that no preload for our stylesheet was emitted
-    // prior to sending the segment the stylesheet was for. This test is asserting this
-    // because the boundary complete instruction is sent when we are writing the
-    const instructionIndex = result.indexOf('$RX');
-    expect(instructionIndex > -1).toBe(true);
-    const slice = result.slice(0, instructionIndex + '$RX'.length);
-
-    expect(slice).toBe(
-      '<!DOCTYPE html><html><head><link rel="expect" href="#_R_" blocking="render"/></head>' +
-        '<body>hello<!--$?--><template id="B:0"></template><!--/$--><script id="_R_">requestAnimationFrame(function(){$RT=performance.now()});</script>' +
-        '<div hidden id="S:0">world<!-- --></div><script>$RX',
-    );
-  });
-
-  it('logs an error if onHeaders throws but continues the prerender', async () => {
-    const errors = [];
-    function onError(error) {
-      errors.push(error.message);
-    }
-
-    function onHeaders(x) {
-      throw new Error('bad onHeaders');
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<div>hello</div>, {
-        onHeaders,
-        onError,
-      }),
-    );
-    expect(prerendered.postponed).toBe(
-      gate(flags => flags.enableHalt || flags.enablePostpone)
-        ? null
-        : undefined,
-    );
-    expect(errors).toEqual(['bad onHeaders']);
-
-    await readIntoContainer(prerendered.prelude);
-    expect(getVisibleChildren(container)).toEqual(<div>hello</div>);
-  });
-
-  // @gate enablePostpone
-  it('does not bootstrap again in a resume if it bootstraps', async () => {
-    let prerendering = true;
-
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return null;
-    }
-
-    function App() {
-      return (
-        <html>
-          <body>
-            <Suspense fallback="loading...">
-              <Postpone />
-              hello
-            </Suspense>
-          </body>
-        </html>
-      );
-    }
-
-    let inits = 0;
-    jest.mock(
-      'init.js',
-      () => {
-        inits++;
-      },
-      {virtual: true},
-    );
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />, {
-        bootstrapScripts: ['init.js'],
-      }),
-    );
-
-    const postponedSerializedState = JSON.stringify(prerendered.postponed);
-
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual([
-      <link rel="preload" href="init.js" fetchpriority="low" as="script" />,
-      'loading...',
-    ]);
-
-    expect(inits).toBe(1);
-
-    jest.resetModules();
-    jest.mock(
-      'init.js',
-      () => {
-        inits++;
-      },
-      {virtual: true},
-    );
-
-    prerendering = false;
-
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(<App />, JSON.parse(postponedSerializedState)),
-    );
-
-    await readIntoContainer(content);
-
-    expect(inits).toBe(1);
-
-    expect(getVisibleChildren(container)).toEqual([
-      <link rel="preload" href="init.js" fetchpriority="low" as="script" />,
-      'hello',
-    ]);
-  });
-
-  // @gate enablePostpone
-  it('can render a deep list of single components where one postpones', async () => {
-    let isPrerendering = true;
-    function Outer({children}) {
-      return children;
-    }
-
-    function Middle({children}) {
-      return children;
-    }
-
-    function Inner() {
-      if (isPrerendering) {
-        React.unstable_postpone();
-      }
-      return 'hello';
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="loading...">
-            <Outer>
-              <Middle>
-                <Inner />
-              </Middle>
-            </Outer>
-          </Suspense>
-        </div>
-      );
-    }
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    const postponedState = JSON.stringify(prerendered.postponed);
-
-    await readIntoContainer(prerendered.prelude);
-    expect(getVisibleChildren(container)).toEqual(<div>loading...</div>);
-
-    isPrerendering = false;
-
-    const dynamic = await serverAct(() =>
-      ReactDOMFizzServer.resume(<App />, JSON.parse(postponedState)),
-    );
-
-    await readIntoContainer(dynamic);
     expect(getVisibleChildren(container)).toEqual(<div>hello</div>);
   });
 
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStaticFloat-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStaticFloat-test.js
deleted file mode 100644
index e806235b7fd..00000000000
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStaticFloat-test.js
+++ /dev/null
@@ -1,283 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @emails react-core
- */
-
-'use strict';
-
-import {patchMessageChannel} from '../../../../scripts/jest/patchMessageChannel';
-
-import {
-  getVisibleChildren,
-  insertNodesAndExecuteScripts,
-} from '../test-utils/FizzTestUtils';
-
-// Polyfills for test environment
-global.ReadableStream =
-  require('web-streams-polyfill/ponyfill/es6').ReadableStream;
-global.TextEncoder = require('util').TextEncoder;
-
-let React;
-let ReactDOM;
-let ReactDOMFizzServer;
-let ReactDOMFizzStatic;
-let Suspense;
-let container;
-let act;
-let serverAct;
-
-describe('ReactDOMFizzStaticFloat', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    patchMessageChannel();
-    act = require('internal-test-utils').act;
-    serverAct = require('internal-test-utils').serverAct;
-
-    React = require('react');
-    ReactDOM = require('react-dom');
-    ReactDOMFizzServer = require('react-dom/server.browser');
-    ReactDOMFizzStatic = require('react-dom/static.browser');
-    Suspense = React.Suspense;
-    container = document.createElement('div');
-    document.body.appendChild(container);
-  });
-
-  afterEach(() => {
-    document.body.removeChild(container);
-  });
-
-  async function readIntoContainer(stream) {
-    const reader = stream.getReader();
-    let result = '';
-    while (true) {
-      const {done, value} = await reader.read();
-      if (done) {
-        break;
-      }
-      result += Buffer.from(value).toString('utf8');
-    }
-    const temp = document.createElement('div');
-    temp.innerHTML = result;
-    await insertNodesAndExecuteScripts(temp, container, null);
-  }
-
-  // @gate enablePostpone
-  it('should transfer connection credentials across prerender and resume for stylesheets, scripts, and moduleScripts', async () => {
-    let prerendering = true;
-    function Postpone() {
-      if (prerendering) {
-        React.unstable_postpone();
-      }
-      return (
-        <>
-          <link rel="stylesheet" href="style creds" precedence="default" />
-          <script async={true} src="script creds" data-meaningful="" />
-          <script
-            type="module"
-            async={true}
-            src="module creds"
-            data-meaningful=""
-          />
-          <link rel="stylesheet" href="style anon" precedence="default" />
-          <script async={true} src="script anon" data-meaningful="" />
-          <script
-            type="module"
-            async={true}
-            src="module default"
-            data-meaningful=""
-          />
-        </>
-      );
-    }
-
-    function App() {
-      ReactDOM.preload('style creds', {
-        as: 'style',
-        crossOrigin: 'use-credentials',
-      });
-      ReactDOM.preload('script creds', {
-        as: 'script',
-        crossOrigin: 'use-credentials',
-        integrity: 'script-hash',
-      });
-      ReactDOM.preloadModule('module creds', {
-        crossOrigin: 'use-credentials',
-        integrity: 'module-hash',
-      });
-      ReactDOM.preload('style anon', {
-        as: 'style',
-        crossOrigin: 'anonymous',
-      });
-      ReactDOM.preload('script anon', {
-        as: 'script',
-        crossOrigin: 'foobar',
-      });
-      ReactDOM.preloadModule('module default', {
-        integrity: 'module-hash',
-      });
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <Postpone />
-          </Suspense>
-        </div>
-      );
-    }
-
-    jest.mock('script creds', () => {}, {
-      virtual: true,
-    });
-    jest.mock('module creds', () => {}, {
-      virtual: true,
-    });
-    jest.mock('script anon', () => {}, {
-      virtual: true,
-    });
-    jest.mock('module default', () => {}, {
-      virtual: true,
-    });
-
-    const prerendered = await serverAct(() =>
-      ReactDOMFizzStatic.prerender(<App />),
-    );
-    expect(prerendered.postponed).not.toBe(null);
-
-    await readIntoContainer(prerendered.prelude);
-
-    expect(getVisibleChildren(container)).toEqual([
-      <link
-        rel="preload"
-        as="style"
-        href="style creds"
-        crossorigin="use-credentials"
-      />,
-      <link
-        rel="preload"
-        as="script"
-        href="script creds"
-        crossorigin="use-credentials"
-        integrity="script-hash"
-      />,
-      <link
-        rel="modulepreload"
-        href="module creds"
-        crossorigin="use-credentials"
-        integrity="module-hash"
-      />,
-      <link rel="preload" as="style" href="style anon" crossorigin="" />,
-      <link rel="preload" as="script" href="script anon" crossorigin="" />,
-      <link
-        rel="modulepreload"
-        href="module default"
-        integrity="module-hash"
-      />,
-      <div>Loading...</div>,
-    ]);
-
-    prerendering = false;
-    const content = await serverAct(() =>
-      ReactDOMFizzServer.resume(
-        <App />,
-        JSON.parse(JSON.stringify(prerendered.postponed)),
-      ),
-    );
-
-    await readIntoContainer(content);
-
-    await act(() => {
-      // Dispatch load event to injected stylesheet
-      const linkCreds = document.querySelector(
-        'link[rel="stylesheet"][href="style creds"]',
-      );
-      const linkAnon = document.querySelector(
-        'link[rel="stylesheet"][href="style anon"]',
-      );
-      const event = document.createEvent('Events');
-      event.initEvent('load', true, true);
-      linkCreds.dispatchEvent(event);
-      linkAnon.dispatchEvent(event);
-    });
-
-    expect(getVisibleChildren(document)).toEqual(
-      <html>
-        <head>
-          <link
-            rel="stylesheet"
-            data-precedence="default"
-            href="style creds"
-            crossorigin="use-credentials"
-          />
-          <link
-            rel="stylesheet"
-            data-precedence="default"
-            href="style anon"
-            crossorigin=""
-          />
-        </head>
-        <body>
-          <div>
-            <link
-              rel="preload"
-              as="style"
-              href="style creds"
-              crossorigin="use-credentials"
-            />
-            <link
-              rel="preload"
-              as="script"
-              href="script creds"
-              crossorigin="use-credentials"
-              integrity="script-hash"
-            />
-            <link
-              rel="modulepreload"
-              href="module creds"
-              crossorigin="use-credentials"
-              integrity="module-hash"
-            />
-            <link rel="preload" as="style" href="style anon" crossorigin="" />
-            <link rel="preload" as="script" href="script anon" crossorigin="" />
-            <link
-              rel="modulepreload"
-              href="module default"
-              integrity="module-hash"
-            />
-            <div />
-            <script
-              async=""
-              src="script creds"
-              crossorigin="use-credentials"
-              integrity="script-hash"
-              data-meaningful=""
-            />
-            <script
-              type="module"
-              async=""
-              src="module creds"
-              crossorigin="use-credentials"
-              integrity="module-hash"
-              data-meaningful=""
-            />
-            <script
-              async=""
-              src="script anon"
-              crossorigin=""
-              data-meaningful=""
-            />
-            <script
-              type="module"
-              async=""
-              src="module default"
-              integrity="module-hash"
-              data-meaningful=""
-            />
-          </div>
-        </body>
-      </html>,
-    );
-  });
-});
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js
index d3c7ba9d2b7..cf98658f932 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js
@@ -56,7 +56,7 @@ describe('ReactDOMFizzStaticNode', () => {
     }
   }
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should call prerenderToNodeStream', async () => {
     const result = await ReactDOMFizzStatic.prerenderToNodeStream(
       <div>hello world</div>,
@@ -65,14 +65,14 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(prelude).toMatchInlineSnapshot(`"<div>hello world</div>"`);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should suppport web streams', async () => {
     const result = await ReactDOMFizzStatic.prerender(<div>hello world</div>);
     const prelude = await readContentWeb(result.prelude);
     expect(prelude).toMatchInlineSnapshot(`"<div>hello world</div>"`);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should emit DOCTYPE at the root of the document', async () => {
     const result = await ReactDOMFizzStatic.prerenderToNodeStream(
       <html>
@@ -91,7 +91,7 @@ describe('ReactDOMFizzStaticNode', () => {
     }
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should emit bootstrap script src at the end', async () => {
     const result = await ReactDOMFizzStatic.prerenderToNodeStream(
       <div>hello world</div>,
@@ -107,7 +107,7 @@ describe('ReactDOMFizzStaticNode', () => {
     );
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('emits all HTML as one unit', async () => {
     let hasLoaded = false;
     let resolve;
@@ -137,7 +137,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(prelude).toMatchInlineSnapshot(`"<div><!--$-->Done<!--/$--></div>"`);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should reject the promise when an error is thrown at the root', async () => {
     const reportedErrors = [];
     let caughtError = null;
@@ -159,7 +159,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(reportedErrors).toEqual([theError]);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should reject the promise when an error is thrown inside a fallback', async () => {
     const reportedErrors = [];
     let caughtError = null;
@@ -183,7 +183,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(reportedErrors).toEqual([theError]);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should not error the stream when an error is thrown inside suspense boundary', async () => {
     const reportedErrors = [];
     const result = await ReactDOMFizzStatic.prerenderToNodeStream(
@@ -204,7 +204,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(reportedErrors).toEqual([theError]);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should be able to complete by aborting even if the promise never resolves', async () => {
     const errors = [];
     const controller = new AbortController();
@@ -234,7 +234,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(errors).toEqual(['This operation was aborted']);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   // @gate !enableHalt
   it('should reject if aborting before the shell is complete and enableHalt is disabled', async () => {
     const errors = [];
@@ -300,7 +300,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(content).toBe('');
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should be able to abort before something suspends', async () => {
     const errors = [];
     const controller = new AbortController();
@@ -341,7 +341,7 @@ describe('ReactDOMFizzStaticNode', () => {
     }
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   // @gate !enableHalt
   it('should reject if passing an already aborted signal and enableHalt is disabled', async () => {
     const errors = [];
@@ -412,7 +412,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(content).toBe('');
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('supports custom abort reasons with a string', async () => {
     const promise = new Promise(r => {});
     function Wait() {
@@ -454,7 +454,7 @@ describe('ReactDOMFizzStaticNode', () => {
     expect(errors).toEqual(['foobar', 'foobar']);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('supports custom abort reasons with an Error', async () => {
     const promise = new Promise(r => {});
     function Wait() {
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js b/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js
index f240db34de3..75c0768b324 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js
@@ -7,11 +7,7 @@
  * @flow
  */
 
-import type {
-  PostponedState,
-  ErrorInfo,
-  PostponeInfo,
-} from 'react-server/src/ReactFizzServer';
+import type {PostponedState, ErrorInfo} from 'react-server/src/ReactFizzServer';
 import type {ReactNodeList, ReactFormState} from 'shared/ReactTypes';
 import type {
   BootstrapScriptDescriptor,
@@ -57,7 +53,6 @@ type Options = {
   progressiveChunkSize?: number,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   formState?: ReactFormState<any, any> | null,
@@ -69,7 +64,6 @@ type ResumeOptions = {
   nonce?: NonceOption,
   signal?: AbortSignal,
   onError?: (error: mixed) => ?string,
-  onPostpone?: (reason: string) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
 };
 
@@ -150,7 +144,6 @@ function renderToReadableStream(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
       options ? options.formState : undefined,
     );
     if (options && options.signal) {
@@ -220,7 +213,6 @@ function resume(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerBun.js b/packages/react-dom/src/server/ReactDOMFizzServerBun.js
index b59d15462ce..90d6ccdad2e 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerBun.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerBun.js
@@ -13,7 +13,7 @@ import type {
   HeadersDescriptor,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
 import type {ImportMap} from '../shared/ReactDOMTypes';
-import type {ErrorInfo, PostponeInfo} from 'react-server/src/ReactFizzServer';
+import type {ErrorInfo} from 'react-server/src/ReactFizzServer';
 
 import ReactVersion from 'shared/ReactVersion';
 
@@ -49,7 +49,6 @@ type Options = {
   progressiveChunkSize?: number,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   formState?: ReactFormState<any, any> | null,
@@ -135,7 +134,6 @@ function renderToReadableStream(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
       options ? options.formState : undefined,
     );
     if (options && options.signal) {
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerEdge.js b/packages/react-dom/src/server/ReactDOMFizzServerEdge.js
index f240db34de3..75c0768b324 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerEdge.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerEdge.js
@@ -7,11 +7,7 @@
  * @flow
  */
 
-import type {
-  PostponedState,
-  ErrorInfo,
-  PostponeInfo,
-} from 'react-server/src/ReactFizzServer';
+import type {PostponedState, ErrorInfo} from 'react-server/src/ReactFizzServer';
 import type {ReactNodeList, ReactFormState} from 'shared/ReactTypes';
 import type {
   BootstrapScriptDescriptor,
@@ -57,7 +53,6 @@ type Options = {
   progressiveChunkSize?: number,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   formState?: ReactFormState<any, any> | null,
@@ -69,7 +64,6 @@ type ResumeOptions = {
   nonce?: NonceOption,
   signal?: AbortSignal,
   onError?: (error: mixed) => ?string,
-  onPostpone?: (reason: string) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
 };
 
@@ -150,7 +144,6 @@ function renderToReadableStream(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
       options ? options.formState : undefined,
     );
     if (options && options.signal) {
@@ -220,7 +213,6 @@ function resume(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerNode.js b/packages/react-dom/src/server/ReactDOMFizzServerNode.js
index 0bf6ba5452f..c0a3cf1096e 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerNode.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerNode.js
@@ -11,7 +11,6 @@ import type {
   Request,
   PostponedState,
   ErrorInfo,
-  PostponeInfo,
 } from 'react-server/src/ReactFizzServer';
 import type {ReactNodeList, ReactFormState} from 'shared/ReactTypes';
 import type {Writable} from 'stream';
@@ -77,7 +76,6 @@ type Options = {
   onShellError?: (error: mixed) => void,
   onAllReady?: () => void,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   formState?: ReactFormState<any, any> | null,
@@ -91,7 +89,6 @@ type ResumeOptions = {
   onShellError?: (error: mixed) => void,
   onAllReady?: () => void,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
 };
 
 type PipeableStream = {
@@ -127,7 +124,6 @@ function createRequestImpl(children: ReactNodeList, options: void | Options) {
     options ? options.onShellReady : undefined,
     options ? options.onShellError : undefined,
     undefined,
-    options ? options.onPostpone : undefined,
     options ? options.formState : undefined,
   );
 }
@@ -285,7 +281,6 @@ function renderToReadableStream(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
       options ? options.formState : undefined,
     );
     if (options && options.signal) {
@@ -321,7 +316,6 @@ function resumeRequestImpl(
     options ? options.onShellReady : undefined,
     options ? options.onShellError : undefined,
     undefined,
-    options ? options.onPostpone : undefined,
   );
 }
 
@@ -423,7 +417,6 @@ function resume(
       onShellReady,
       onShellError,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzStaticBrowser.js b/packages/react-dom/src/server/ReactDOMFizzStaticBrowser.js
index be548c2d204..ba0e24c1878 100644
--- a/packages/react-dom/src/server/ReactDOMFizzStaticBrowser.js
+++ b/packages/react-dom/src/server/ReactDOMFizzStaticBrowser.js
@@ -12,11 +12,7 @@ import type {
   BootstrapScriptDescriptor,
   HeadersDescriptor,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
-import type {
-  PostponedState,
-  ErrorInfo,
-  PostponeInfo,
-} from 'react-server/src/ReactFizzServer';
+import type {PostponedState, ErrorInfo} from 'react-server/src/ReactFizzServer';
 import type {ImportMap} from '../shared/ReactDOMTypes';
 
 import ReactVersion from 'shared/ReactVersion';
@@ -38,7 +34,7 @@ import {
   createRootFormatContext,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
 
-import {enablePostpone, enableHalt} from 'shared/ReactFeatureFlags';
+import {enableHalt} from 'shared/ReactFeatureFlags';
 
 import {ensureCorrectIsomorphicReactVersion} from '../shared/ensureCorrectIsomorphicReactVersion';
 ensureCorrectIsomorphicReactVersion();
@@ -59,7 +55,6 @@ type Options = {
   progressiveChunkSize?: number,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   onHeaders?: (headers: Headers) => void,
@@ -94,15 +89,14 @@ function prerender(
         {highWaterMark: 0},
       );
 
-      const result: StaticResult =
-        enablePostpone || enableHalt
-          ? {
-              postponed: getPostponedState(request),
-              prelude: stream,
-            }
-          : ({
-              prelude: stream,
-            }: any);
+      const result: StaticResult = enableHalt
+        ? {
+            postponed: getPostponedState(request),
+            prelude: stream,
+          }
+        : ({
+            prelude: stream,
+          }: any);
       resolve(result);
     }
 
@@ -139,7 +133,6 @@ function prerender(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
@@ -161,7 +154,6 @@ type ResumeOptions = {
   nonce?: NonceOption,
   signal?: AbortSignal,
   onError?: (error: mixed) => ?string,
-  onPostpone?: (reason: string) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
 };
 
@@ -205,7 +197,6 @@ function resumeAndPrerender(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzStaticEdge.js b/packages/react-dom/src/server/ReactDOMFizzStaticEdge.js
index 8894fcc8a7e..785a8b2f2a4 100644
--- a/packages/react-dom/src/server/ReactDOMFizzStaticEdge.js
+++ b/packages/react-dom/src/server/ReactDOMFizzStaticEdge.js
@@ -12,11 +12,7 @@ import type {
   BootstrapScriptDescriptor,
   HeadersDescriptor,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
-import type {
-  PostponedState,
-  ErrorInfo,
-  PostponeInfo,
-} from 'react-server/src/ReactFizzServer';
+import type {PostponedState, ErrorInfo} from 'react-server/src/ReactFizzServer';
 import type {ImportMap} from '../shared/ReactDOMTypes';
 
 import ReactVersion from 'shared/ReactVersion';
@@ -38,7 +34,7 @@ import {
   createRootFormatContext,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
 
-import {enablePostpone, enableHalt} from 'shared/ReactFeatureFlags';
+import {enableHalt} from 'shared/ReactFeatureFlags';
 
 import {ensureCorrectIsomorphicReactVersion} from '../shared/ensureCorrectIsomorphicReactVersion';
 ensureCorrectIsomorphicReactVersion();
@@ -59,7 +55,6 @@ type Options = {
   progressiveChunkSize?: number,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   onHeaders?: (headers: Headers) => void,
@@ -94,15 +89,14 @@ function prerender(
         {highWaterMark: 0},
       );
 
-      const result: StaticResult =
-        enablePostpone || enableHalt
-          ? {
-              postponed: getPostponedState(request),
-              prelude: stream,
-            }
-          : ({
-              prelude: stream,
-            }: any);
+      const result: StaticResult = enableHalt
+        ? {
+            postponed: getPostponedState(request),
+            prelude: stream,
+          }
+        : ({
+            prelude: stream,
+          }: any);
       resolve(result);
     }
 
@@ -138,7 +132,6 @@ function prerender(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
@@ -160,7 +153,6 @@ type ResumeOptions = {
   nonce?: NonceOption,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
 };
 
 function resumeAndPrerender(
@@ -203,7 +195,6 @@ function resumeAndPrerender(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzStaticNode.js b/packages/react-dom/src/server/ReactDOMFizzStaticNode.js
index 10316a20d26..60c602cc2aa 100644
--- a/packages/react-dom/src/server/ReactDOMFizzStaticNode.js
+++ b/packages/react-dom/src/server/ReactDOMFizzStaticNode.js
@@ -12,11 +12,7 @@ import type {
   BootstrapScriptDescriptor,
   HeadersDescriptor,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
-import type {
-  PostponedState,
-  ErrorInfo,
-  PostponeInfo,
-} from 'react-server/src/ReactFizzServer';
+import type {PostponedState, ErrorInfo} from 'react-server/src/ReactFizzServer';
 import type {ImportMap} from '../shared/ReactDOMTypes';
 
 import {Writable, Readable} from 'stream';
@@ -40,7 +36,7 @@ import {
   createRootFormatContext,
 } from 'react-dom-bindings/src/server/ReactFizzConfigDOM';
 
-import {enablePostpone, enableHalt} from 'shared/ReactFeatureFlags';
+import {enableHalt} from 'shared/ReactFeatureFlags';
 
 import {textEncoder} from 'react-server/src/ReactServerStreamConfigNode';
 
@@ -63,7 +59,6 @@ type Options = {
   progressiveChunkSize?: number,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
   unstable_externalRuntimeSrc?: string | BootstrapScriptDescriptor,
   importMap?: ImportMap,
   onHeaders?: (headers: HeadersDescriptor) => void,
@@ -135,15 +130,14 @@ function prerenderToNodeStream(
       });
       const writable = createFakeWritableFromReadable(readable);
 
-      const result: StaticResult =
-        enablePostpone || enableHalt
-          ? {
-              postponed: getPostponedState(request),
-              prelude: readable,
-            }
-          : ({
-              prelude: readable,
-            }: any);
+      const result: StaticResult = enableHalt
+        ? {
+            postponed: getPostponedState(request),
+            prelude: readable,
+          }
+        : ({
+            prelude: readable,
+          }: any);
       resolve(result);
     }
     const resumableState = createResumableState(
@@ -171,7 +165,6 @@ function prerenderToNodeStream(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
@@ -222,15 +215,14 @@ function prerender(
         {highWaterMark: 0},
       );
 
-      const result =
-        enablePostpone || enableHalt
-          ? {
-              postponed: getPostponedState(request),
-              prelude: stream,
-            }
-          : ({
-              prelude: stream,
-            }: any);
+      const result = enableHalt
+        ? {
+            postponed: getPostponedState(request),
+            prelude: stream,
+          }
+        : ({
+            prelude: stream,
+          }: any);
       resolve(result);
     }
 
@@ -266,7 +258,6 @@ function prerender(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
@@ -288,7 +279,6 @@ type ResumeOptions = {
   nonce?: NonceOption,
   signal?: AbortSignal,
   onError?: (error: mixed, errorInfo: ErrorInfo) => ?string,
-  onPostpone?: (reason: string, postponeInfo: PostponeInfo) => void,
 };
 
 function resumeAndPrerenderToNodeStream(
@@ -322,7 +312,6 @@ function resumeAndPrerenderToNodeStream(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
@@ -388,7 +377,6 @@ function resumeAndPrerender(
       undefined,
       undefined,
       onFatalError,
-      options ? options.onPostpone : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-markup/src/ReactMarkupClient.js b/packages/react-markup/src/ReactMarkupClient.js
index e9cf6891041..25ff9ebc0c3 100644
--- a/packages/react-markup/src/ReactMarkupClient.js
+++ b/packages/react-markup/src/ReactMarkupClient.js
@@ -85,7 +85,6 @@ export function experimental_renderToHTML(
       undefined,
       undefined,
       undefined,
-      undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-markup/src/ReactMarkupServer.js b/packages/react-markup/src/ReactMarkupServer.js
index 6f1e35e6156..5d22f1a4c94 100644
--- a/packages/react-markup/src/ReactMarkupServer.js
+++ b/packages/react-markup/src/ReactMarkupServer.js
@@ -184,7 +184,6 @@ export function experimental_renderToHTML(
       handleFlightError,
       options ? options.identifierPrefix : undefined,
       undefined,
-      undefined,
       'Markup',
       undefined,
       false,
@@ -214,7 +213,6 @@ export function experimental_renderToHTML(
       undefined,
       undefined,
       undefined,
-      undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-noop-renderer/src/ReactNoopFlightServer.js b/packages/react-noop-renderer/src/ReactNoopFlightServer.js
index d54ebe30c89..469e5465f30 100644
--- a/packages/react-noop-renderer/src/ReactNoopFlightServer.js
+++ b/packages/react-noop-renderer/src/ReactNoopFlightServer.js
@@ -73,7 +73,6 @@ type Options = {
   signal?: AbortSignal,
   debugChannel?: {onMessage?: (message: string) => void},
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function render(model: ReactClientValue, options?: Options): Destination {
@@ -84,7 +83,6 @@ function render(model: ReactClientValue, options?: Options): Destination {
     bundlerConfig,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.js b/packages/react-reconciler/src/ReactFiberBeginWork.js
index 25918e8b387..5875455f34c 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.js
@@ -115,7 +115,6 @@ import {
   enableTransitionTracing,
   enableLegacyHidden,
   enableCPUSuspense,
-  enablePostpone,
   disableLegacyMode,
   enableHydrationLaneScheduling,
   enableViewTransition,
@@ -2973,28 +2972,25 @@ function updateDehydratedSuspenseComponent(
         ({digest} = getSuspenseInstanceFallbackErrorDetails(suspenseInstance));
       }
 
-      // TODO: Figure out a better signal than encoding a magic digest value.
-      if (!enablePostpone || digest !== 'POSTPONE') {
-        let error: Error;
-        if (__DEV__ && message) {
-          // eslint-disable-next-line react-internal/prod-error-codes
-          error = new Error(message);
-        } else {
-          error = new Error(
-            'The server could not finish this Suspense boundary, likely ' +
-              'due to an error during server rendering. ' +
-              'Switched to client rendering.',
-          );
-        }
-        // Replace the stack with the server stack
-        error.stack = (__DEV__ && stack) || '';
-        (error: any).digest = digest;
-        const capturedValue = createCapturedValueFromError(
-          error,
-          componentStack === undefined ? null : componentStack,
+      let error: Error;
+      if (__DEV__ && message) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        error = new Error(message);
+      } else {
+        error = new Error(
+          'The server could not finish this Suspense boundary, likely ' +
+            'due to an error during server rendering. ' +
+            'Switched to client rendering.',
         );
-        queueHydrationError(capturedValue);
       }
+      // Replace the stack with the server stack
+      error.stack = (__DEV__ && stack) || '';
+      (error: any).digest = digest;
+      const capturedValue = createCapturedValueFromError(
+        error,
+        componentStack === undefined ? null : componentStack,
+      );
+      queueHydrationError(capturedValue);
       return retrySuspenseComponentWithoutHydrating(
         current,
         workInProgress,
diff --git a/packages/react-reconciler/src/ReactFiberCommitWork.js b/packages/react-reconciler/src/ReactFiberCommitWork.js
index adff6647f6d..87764464c40 100644
--- a/packages/react-reconciler/src/ReactFiberCommitWork.js
+++ b/packages/react-reconciler/src/ReactFiberCommitWork.js
@@ -3767,7 +3767,7 @@ function commitPassiveMountOnFiber(
             inHydratedSubtree = false;
             const hydrationErrors = prevState.hydrationErrors;
             // If there were no hydration errors, that suggests that this was an intentional client
-            // rendered boundary. Such as postpone.
+            // rendered boundary.
             if (hydrationErrors !== null) {
               const startTime: number = (finishedWork.actualStartTime: any);
               logComponentErrored(
@@ -3825,7 +3825,7 @@ function commitPassiveMountOnFiber(
             inHydratedSubtree = false;
             const hydrationErrors = prevState.hydrationErrors;
             // If there were no hydration errors, that suggests that this was an intentional client
-            // rendered boundary. Such as postpone.
+            // rendered boundary.
             if (hydrationErrors !== null) {
               const startTime: number = (finishedWork.actualStartTime: any);
               logComponentErrored(
diff --git a/packages/react-reconciler/src/ReactFiberThrow.js b/packages/react-reconciler/src/ReactFiberThrow.js
index 8ff61b02697..02163636312 100644
--- a/packages/react-reconciler/src/ReactFiberThrow.js
+++ b/packages/react-reconciler/src/ReactFiberThrow.js
@@ -42,7 +42,6 @@ import {
 import {NoMode, ConcurrentMode} from './ReactTypeOfMode';
 import {
   enableUpdaterTracking,
-  enablePostpone,
   disableLegacyMode,
 } from 'shared/ReactFeatureFlags';
 import {createCapturedValueAtFiber} from './ReactCapturedValue';
@@ -85,7 +84,6 @@ import {
 } from './ReactFiberHydrationContext';
 import {ConcurrentRoot} from './ReactRootTags';
 import {noopSuspenseyCommitThenable} from './ReactFiberThenable';
-import {REACT_POSTPONE_TYPE} from 'shared/ReactSymbols';
 import {runWithFiberInDEV} from './ReactCurrentFiber';
 import {callComponentDidCatchInDEV} from './ReactFiberCallUserSpace';
 
@@ -378,10 +376,6 @@ function throwException(
   }
 
   if (value !== null && typeof value === 'object') {
-    if (enablePostpone && value.$$typeof === REACT_POSTPONE_TYPE) {
-      // Act as if this is an infinitely suspending promise.
-      value = {then: function () {}};
-    }
     if (typeof value.then === 'function') {
       // This is a wakeable. The component suspended.
       const wakeable: Wakeable = (value: any);
diff --git a/packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js b/packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js
index 7e63fe9fd19..c45b784d24e 100644
--- a/packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js
+++ b/packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js
@@ -144,7 +144,6 @@ type Options = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
 };
@@ -183,7 +182,6 @@ function renderToPipeableStream(
     moduleBasePath,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -271,7 +269,6 @@ type PrerenderOptions = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
   signal?: AbortSignal,
@@ -305,7 +302,6 @@ function prerenderToNodeStream(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerBrowser.js b/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerBrowser.js
index b55b4768874..31c3e5cd8b6 100644
--- a/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerBrowser.js
+++ b/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerBrowser.js
@@ -67,7 +67,6 @@ type Options = {
   signal?: AbortSignal,
   temporaryReferences?: TemporaryReferenceSet,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function startReadingFromDebugChannelReadableStream(
@@ -128,7 +127,6 @@ export function renderToReadableStream(
     null,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -216,7 +214,6 @@ export function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerEdge.js b/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerEdge.js
index 627124225c4..63218160d8d 100644
--- a/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerEdge.js
+++ b/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerEdge.js
@@ -72,7 +72,6 @@ type Options = {
   signal?: AbortSignal,
   temporaryReferences?: TemporaryReferenceSet,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function startReadingFromDebugChannelReadableStream(
@@ -133,7 +132,6 @@ export function renderToReadableStream(
     null,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -221,7 +219,6 @@ export function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js b/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js
index d51cf3bc0ce..bd828d31780 100644
--- a/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js
+++ b/packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js
@@ -157,7 +157,6 @@ type Options = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
 };
@@ -195,7 +194,6 @@ export function renderToPipeableStream(
     null,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -353,7 +351,6 @@ export function renderToReadableStream(
     null,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -434,7 +431,6 @@ type PrerenderOptions = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
   signal?: AbortSignal,
@@ -467,7 +463,6 @@ export function prerenderToNodeStream(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
@@ -530,7 +525,6 @@ export function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerBrowser.js b/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerBrowser.js
index 83add4abd97..7ad138e62f5 100644
--- a/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerBrowser.js
+++ b/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerBrowser.js
@@ -64,7 +64,6 @@ type Options = {
   signal?: AbortSignal,
   temporaryReferences?: TemporaryReferenceSet,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function startReadingFromDebugChannelReadableStream(
@@ -126,7 +125,6 @@ function renderToReadableStream(
     turbopackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -215,7 +213,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerEdge.js b/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerEdge.js
index 54f3d773318..52b4468dcd3 100644
--- a/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerEdge.js
+++ b/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerEdge.js
@@ -69,7 +69,6 @@ type Options = {
   signal?: AbortSignal,
   temporaryReferences?: TemporaryReferenceSet,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function startReadingFromDebugChannelReadableStream(
@@ -131,7 +130,6 @@ function renderToReadableStream(
     turbopackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -220,7 +218,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerNode.js b/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerNode.js
index 4cea9ca149a..44bb6209ada 100644
--- a/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerNode.js
+++ b/packages/react-server-dom-turbopack/src/server/ReactFlightDOMServerNode.js
@@ -150,7 +150,6 @@ type Options = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
 };
@@ -189,7 +188,6 @@ function renderToPipeableStream(
     turbopackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -348,7 +346,6 @@ function renderToReadableStream(
     turbopackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -429,7 +426,6 @@ type PrerenderOptions = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
   signal?: AbortSignal,
@@ -463,7 +459,6 @@ function prerenderToNodeStream(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
@@ -527,7 +522,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOM-test.js b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOM-test.js
index a2e08383264..0b12f80c08d 100644
--- a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOM-test.js
+++ b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOM-test.js
@@ -34,7 +34,6 @@ let ReactServerDOMServer;
 let ReactServerDOMStaticServer;
 let ReactServerDOMClient;
 let ReactDOMFizzServer;
-let ReactDOMStaticServer;
 let Suspense;
 let ErrorBoundary;
 let JSDOM;
@@ -88,7 +87,6 @@ describe('ReactFlightDOM', () => {
     Suspense = React.Suspense;
     ReactDOMClient = require('react-dom/client');
     ReactDOMFizzServer = require('react-dom/server.node');
-    ReactDOMStaticServer = require('react-dom/static.node');
     ReactServerDOMClient = require('react-server-dom-webpack/client');
 
     ErrorBoundary = class extends React.Component {
@@ -1633,89 +1631,6 @@ describe('ReactFlightDOM', () => {
     expect(getMeaningfulChildren(container)).toEqual(<p>hello world</p>);
   });
 
-  // @gate enablePostpone
-  it('should allow postponing in Flight through a serialized promise', async () => {
-    const Context = React.createContext();
-    const ContextProvider = Context.Provider;
-
-    function Foo() {
-      const value = React.use(React.useContext(Context));
-      return <span>{value}</span>;
-    }
-
-    const ClientModule = clientExports({
-      ContextProvider,
-      Foo,
-    });
-
-    async function getFoo() {
-      React.unstable_postpone('foo');
-    }
-
-    function App() {
-      return (
-        <ClientModule.ContextProvider value={getFoo()}>
-          <div>
-            <Suspense fallback="loading...">
-              <ClientModule.Foo />
-            </Suspense>
-          </div>
-        </ClientModule.ContextProvider>
-      );
-    }
-
-    const {writable, readable} = getTestStream();
-
-    const {pipe} = await serverAct(() =>
-      ReactServerDOMServer.renderToPipeableStream(<App />, webpackMap),
-    );
-    pipe(writable);
-
-    let response = null;
-    function getResponse() {
-      if (response === null) {
-        response = ReactServerDOMClient.createFromReadableStream(readable);
-      }
-      return response;
-    }
-
-    function Response() {
-      return getResponse();
-    }
-
-    const errors = [];
-    function onError(error, errorInfo) {
-      errors.push(error, errorInfo);
-    }
-    const result = await serverAct(() =>
-      ReactDOMStaticServer.prerenderToNodeStream(<Response />, {
-        onError,
-      }),
-    );
-
-    const prelude = await new Promise((resolve, reject) => {
-      let content = '';
-      result.prelude.on('data', chunk => {
-        content += Buffer.from(chunk).toString('utf8');
-      });
-      result.prelude.on('error', error => {
-        reject(error);
-      });
-      result.prelude.on('end', () => resolve(content));
-    });
-
-    expect(errors).toEqual([]);
-    const doc = new JSDOM(prelude).window.document;
-    expect(getMeaningfulChildren(doc)).toEqual(
-      <html>
-        <head />
-        <body>
-          <div>loading...</div>
-        </body>
-      </html>,
-    );
-  });
-
   it('should support float methods when rendering in Fizz', async () => {
     function Component() {
       return <p>hello world</p>;
@@ -2870,7 +2785,7 @@ describe('ReactFlightDOM', () => {
     );
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('can prerender', async () => {
     let resolveGreeting;
     const greetingPromise = new Promise(resolve => {
@@ -3016,7 +2931,7 @@ describe('ReactFlightDOM', () => {
   });
 
   // This could be a bug. Discovered while making enableAsyncDebugInfo dynamic for www.
-  // @gate enableHalt || enablePostpone || (enableAsyncDebugInfo && __DEV__)
+  // @gate enableHalt || (enableAsyncDebugInfo && __DEV__)
   it('will leave async iterables in an incomplete state when halting', async () => {
     let resolve;
     const wait = new Promise(r => (resolve = r));
diff --git a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMBrowser-test.js b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMBrowser-test.js
index d52003be1d7..e2c1e74d5c3 100644
--- a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMBrowser-test.js
+++ b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMBrowser-test.js
@@ -1934,52 +1934,6 @@ describe('ReactFlightDOMBrowser', () => {
     );
   });
 
-  // @gate enablePostpone
-  it('supports postpone in Server Components', async () => {
-    function Server() {
-      React.unstable_postpone('testing postpone');
-      return 'Not shown';
-    }
-
-    let postponed = null;
-
-    const stream = await serverAct(() =>
-      ReactServerDOMServer.renderToReadableStream(
-        <Suspense fallback="Loading...">
-          <Server />
-        </Suspense>,
-        null,
-        {
-          onPostpone(reason) {
-            postponed = reason;
-          },
-        },
-      ),
-    );
-    const response = ReactServerDOMClient.createFromReadableStream(stream);
-
-    function Client() {
-      return use(response);
-    }
-
-    const container = document.createElement('div');
-    const root = ReactDOMClient.createRoot(container);
-    await act(async () => {
-      root.render(
-        <div>
-          Shell: <Client />
-        </div>,
-      );
-    });
-    // We should have reserved the shell already. Which means that the Server
-    // Component should've been a lazy component.
-    expect(container.innerHTML).toContain('Shell:');
-    expect(container.innerHTML).toContain('Loading...');
-    expect(container.innerHTML).not.toContain('Not shown');
-
-    expect(postponed).toBe('testing postpone');
-  });
-
   it('should not continue rendering after the reader cancels', async () => {
     let hasLoaded = false;
     let resolve;
@@ -2031,66 +1985,6 @@ describe('ReactFlightDOMBrowser', () => {
     ]);
   });
 
-  // @gate enablePostpone
-  it('postpones when abort passes a postpone signal', async () => {
-    const infinitePromise = new Promise(() => {});
-    function Server() {
-      return infinitePromise;
-    }
-
-    let postponed = null;
-    let error = null;
-
-    const controller = new AbortController();
-    const stream = await serverAct(() =>
-      ReactServerDOMServer.renderToReadableStream(
-        <Suspense fallback="Loading...">
-          <Server />
-        </Suspense>,
-        null,
-        {
-          onError(x) {
-            error = x;
-          },
-          onPostpone(reason) {
-            postponed = reason;
-          },
-          signal: controller.signal,
-        },
-      ),
-    );
-
-    try {
-      React.unstable_postpone('testing postpone');
-    } catch (reason) {
-      controller.abort(reason);
-    }
-
-    const response = ReactServerDOMClient.createFromReadableStream(stream);
-
-    function Client() {
-      return use(response);
-    }
-
-    const container = document.createElement('div');
-    const root = ReactDOMClient.createRoot(container);
-    await act(() => {
-      root.render(
-        <div>
-          Shell: <Client />
-        </div>,
-      );
-    });
-    // We should have reserved the shell already. Which means that the Server
-    // Component should've been a lazy component.
-    expect(container.innerHTML).toContain('Shell:');
-    expect(container.innerHTML).toContain('Loading...');
-    expect(container.innerHTML).not.toContain('Not shown');
-
-    expect(postponed).toBe('testing postpone');
-    expect(error).toBe(null);
-  });
-
   function passThrough(stream) {
     // Simulate more realistic network by splitting up and rejoining some chunks.
     // This lets us test that we don't accidentally rely on particular bounds of the chunks.
@@ -2495,7 +2389,7 @@ describe('ReactFlightDOMBrowser', () => {
     expect(errors).toEqual([reason]);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('can prerender', async () => {
     let resolveGreeting;
     const greetingPromise = new Promise(resolve => {
@@ -3009,9 +2903,9 @@ describe('ReactFlightDOMBrowser', () => {
               [
                 "",
                 "/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMBrowser-test.js",
-                2935,
+                2829,
                 27,
-                2929,
+                2823,
                 34,
               ],
               [
@@ -3025,9 +2919,9 @@ describe('ReactFlightDOMBrowser', () => {
               [
                 "Object.<anonymous>",
                 "/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMBrowser-test.js",
-                2929,
+                2823,
                 18,
-                2916,
+                2810,
                 89,
               ],
             ],
diff --git a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMEdge-test.js b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMEdge-test.js
index 9e024107fc5..f5758ec22cf 100644
--- a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMEdge-test.js
+++ b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMEdge-test.js
@@ -1365,7 +1365,7 @@ describe('ReactFlightDOMEdge', () => {
     ]);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('can prerender', async () => {
     let resolveGreeting;
     const greetingPromise = new Promise(resolve => {
@@ -1547,7 +1547,7 @@ describe('ReactFlightDOMEdge', () => {
     expect(error.message).toBe('Connection closed.');
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should be able to handle a rejected promise in prerender', async () => {
     const expectedError = new Error('Bam!');
     const errors = [];
@@ -1586,7 +1586,7 @@ describe('ReactFlightDOMEdge', () => {
     expect(error.message).toBe(expectedMessage);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should be able to handle an erroring async iterable in prerender', async () => {
     const expectedError = new Error('Bam!');
     const errors = [];
@@ -1633,7 +1633,7 @@ describe('ReactFlightDOMEdge', () => {
     expect(error.message).toBe(expectedMessage);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('should be able to handle an erroring readable stream in prerender', async () => {
     const expectedError = new Error('Bam!');
     const errors = [];
@@ -1681,7 +1681,7 @@ describe('ReactFlightDOMEdge', () => {
     expect(error.message).toBe(expectedMessage);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('can prerender an async iterable', async () => {
     const errors = [];
 
@@ -1725,7 +1725,7 @@ describe('ReactFlightDOMEdge', () => {
     expect(text).toBe('hello world');
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('can prerender a readable stream', async () => {
     const errors = [];
 
@@ -1759,7 +1759,7 @@ describe('ReactFlightDOMEdge', () => {
     expect(result).toBe('hello world');
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('does not return a prerender prelude early when an error is emitted and there are still pending tasks', async () => {
     let rejectPromise;
     const rejectingPromise = new Promise(
diff --git a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMNode-test.js b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMNode-test.js
index d9de7df43d3..38a95f67628 100644
--- a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMNode-test.js
+++ b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMNode-test.js
@@ -500,7 +500,7 @@ describe('ReactFlightDOMNode', () => {
     expect(errors).toEqual([reason]);
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   it('can prerender', async () => {
     let resolveGreeting;
     const greetingPromise = new Promise(resolve => {
@@ -920,7 +920,7 @@ describe('ReactFlightDOMNode', () => {
     }
   });
 
-  // @gate enableHalt || enablePostpone
+  // @gate enableHalt
   // @gate enableHalt
   it('can handle an empty prelude when prerendering', async () => {
     function App() {
diff --git a/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerBrowser.js b/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerBrowser.js
index 06f837d431b..08192fd1e52 100644
--- a/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerBrowser.js
+++ b/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerBrowser.js
@@ -64,7 +64,6 @@ type Options = {
   signal?: AbortSignal,
   temporaryReferences?: TemporaryReferenceSet,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function startReadingFromDebugChannelReadableStream(
@@ -126,7 +125,6 @@ function renderToReadableStream(
     webpackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -215,7 +213,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerEdge.js b/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerEdge.js
index 806a0870005..73fc74d4fa4 100644
--- a/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerEdge.js
+++ b/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerEdge.js
@@ -69,7 +69,6 @@ type Options = {
   signal?: AbortSignal,
   temporaryReferences?: TemporaryReferenceSet,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
 };
 
 function startReadingFromDebugChannelReadableStream(
@@ -131,7 +130,6 @@ function renderToReadableStream(
     webpackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -220,7 +218,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerNode.js b/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerNode.js
index 0b6669a3ba1..10162fe33df 100644
--- a/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerNode.js
+++ b/packages/react-server-dom-webpack/src/server/ReactFlightDOMServerNode.js
@@ -150,7 +150,6 @@ type Options = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
 };
@@ -189,7 +188,6 @@ function renderToPipeableStream(
     webpackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -348,7 +346,6 @@ function renderToReadableStream(
     webpackMap,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -429,7 +426,6 @@ type PrerenderOptions = {
   environmentName?: string | (() => string),
   filterStackFrame?: (url: string, functionName: string) => boolean,
   onError?: (error: mixed) => void,
-  onPostpone?: (reason: string) => void,
   identifierPrefix?: string,
   temporaryReferences?: TemporaryReferenceSet,
   signal?: AbortSignal,
@@ -463,7 +459,6 @@ function prerenderToNodeStream(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
@@ -527,7 +522,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server/README.md b/packages/react-server/README.md
index 60637bbff68..e88807a267f 100644
--- a/packages/react-server/README.md
+++ b/packages/react-server/README.md
@@ -43,7 +43,6 @@ function render(
     clientManifest,
     options ? options.onError : undefined,
     options ? options.identifierPrefix : undefined,
-    options ? options.onPostpone : undefined,
     options ? options.temporaryReferences : undefined,
     __DEV__ && options ? options.environmentName : undefined,
     __DEV__ && options ? options.filterStackFrame : undefined,
@@ -214,7 +213,6 @@ function prerender(
       onFatalError,
       options ? options.onError : undefined,
       options ? options.identifierPrefix : undefined,
-      options ? options.onPostpone : undefined,
       options ? options.temporaryReferences : undefined,
       __DEV__ && options ? options.environmentName : undefined,
       __DEV__ && options ? options.filterStackFrame : undefined,
diff --git a/packages/react-server/src/ReactFizzServer.js b/packages/react-server/src/ReactFizzServer.js
index 6259357c839..531f1202762 100644
--- a/packages/react-server/src/ReactFizzServer.js
+++ b/packages/react-server/src/ReactFizzServer.js
@@ -168,7 +168,6 @@ import {
   REACT_CONTEXT_TYPE,
   REACT_CONSUMER_TYPE,
   REACT_SCOPE_TYPE,
-  REACT_POSTPONE_TYPE,
   REACT_VIEW_TRANSITION_TYPE,
   REACT_ACTIVITY_TYPE,
 } from 'shared/ReactSymbols';
@@ -177,7 +176,6 @@ import {
   disableLegacyContext,
   disableLegacyContextForFunctionComponents,
   enableScopeAPI,
-  enablePostpone,
   enableHalt,
   enableAsyncIterableChildren,
   enableViewTransition,
@@ -190,7 +188,6 @@ import noop from 'shared/noop';
 import getComponentNameFromType from 'shared/getComponentNameFromType';
 import isArray from 'shared/isArray';
 import {SuspenseException, getSuspendedThenable} from './ReactFizzThenable';
-import type {Postpone} from 'react/src/ReactPostpone';
 
 // Linked list representing the identity of a component given the component/tag name and key.
 // The name might be minified but we assume that it's going to be the same generated name. Typically
@@ -391,9 +388,6 @@ export opaque type Request = {
   // emit a different response to the stream instead.
   onShellError: (error: mixed) => void,
   onFatalError: (error: mixed) => void,
-  // onPostpone is called when postpone() is called anywhere in the tree, which will defer
-  // rendering - e.g. to the client. This is considered intentional and not an error.
-  onPostpone: (reason: string, postponeInfo: ThrownInfo) => void,
   // Form state that was the result of an MPA submission, if it was provided.
   formState: null | ReactFormState<any, any>,
   // DEV-only, warning dedupe
@@ -496,7 +490,6 @@ function RequestInstance(
   onShellReady: void | (() => void),
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
-  onPostpone: void | ((reason: string, postponeInfo: PostponeInfo) => void),
   formState: void | null | ReactFormState<any, any>,
 ) {
   const pingedTasks: Array<Task> = [];
@@ -525,7 +518,6 @@ function RequestInstance(
   this.partialBoundaries = ([]: Array<SuspenseBoundary>);
   this.trackedPostpones = null;
   this.onError = onError === undefined ? defaultErrorHandler : onError;
-  this.onPostpone = onPostpone === undefined ? noop : onPostpone;
   this.onAllReady = onAllReady === undefined ? noop : onAllReady;
   this.onShellReady = onShellReady === undefined ? noop : onShellReady;
   this.onShellError = onShellError === undefined ? noop : onShellError;
@@ -547,7 +539,6 @@ export function createRequest(
   onShellReady: void | (() => void),
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
-  onPostpone: void | ((reason: string, postponeInfo: PostponeInfo) => void),
   formState: void | null | ReactFormState<any, any>,
 ): Request {
   if (__DEV__) {
@@ -565,7 +556,6 @@ export function createRequest(
     onShellReady,
     onShellError,
     onFatalError,
-    onPostpone,
     formState,
   );
 
@@ -616,7 +606,6 @@ export function createPrerenderRequest(
   onShellReady: void | (() => void),
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
-  onPostpone: void | ((reason: string, postponeInfo: PostponeInfo) => void),
 ): Request {
   const request = createRequest(
     children,
@@ -629,7 +618,6 @@ export function createPrerenderRequest(
     onShellReady,
     onShellError,
     onFatalError,
-    onPostpone,
     undefined,
   );
   // Start tracking postponed holes during this render.
@@ -650,7 +638,6 @@ export function resumeRequest(
   onShellReady: void | (() => void),
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
-  onPostpone: void | ((reason: string, postponeInfo: PostponeInfo) => void),
 ): Request {
   if (__DEV__) {
     resetOwnerStackLimit();
@@ -667,7 +654,6 @@ export function resumeRequest(
     onShellReady,
     onShellError,
     onFatalError,
-    onPostpone,
     null,
   );
   request.nextSegmentId = postponedState.nextSegmentId;
@@ -746,7 +732,6 @@ export function resumeAndPrerenderRequest(
   onShellReady: void | (() => void),
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
-  onPostpone: void | ((reason: string, postponeInfo: PostponeInfo) => void),
 ): Request {
   const request = resumeRequest(
     children,
@@ -757,7 +742,6 @@ export function resumeAndPrerenderRequest(
     onShellReady,
     onShellError,
     onFatalError,
-    onPostpone,
   );
   // Start tracking postponed holes during this render.
   request.trackedPostpones = {
@@ -1137,7 +1121,6 @@ type ThrownInfo = {
   componentStack?: string,
 };
 export type ErrorInfo = ThrownInfo;
-export type PostponeInfo = ThrownInfo;
 
 function getThrownInfo(node: null | ComponentStackNode): ThrownInfo {
   const errorInfo: ThrownInfo = {};
@@ -1191,22 +1174,6 @@ function encodeErrorForBoundary(
   }
 }
 
-function logPostpone(
-  request: Request,
-  reason: string,
-  postponeInfo: ThrownInfo,
-  debugTask: null | ConsoleTask,
-): void {
-  // If this callback errors, we intentionally let that error bubble up to become a fatal error
-  // so that someone fixes the error reporting instead of hiding it.
-  const onPostpone = request.onPostpone;
-  if (__DEV__ && debugTask) {
-    debugTask.run(onPostpone.bind(null, reason, postponeInfo));
-  } else {
-    onPostpone(reason, postponeInfo);
-  }
-}
-
 function logRecoverableError(
   request: Request,
   error: any,
@@ -1525,30 +1492,12 @@ function renderSuspenseBoundary(
       }
 
       const thrownInfo = getThrownInfo(task.componentStack);
-      let errorDigest;
-      if (
-        enablePostpone &&
-        typeof error === 'object' &&
-        error !== null &&
-        error.$$typeof === REACT_POSTPONE_TYPE
-      ) {
-        const postponeInstance: Postpone = (error: any);
-        logPostpone(
-          request,
-          postponeInstance.message,
-          thrownInfo,
-          __DEV__ ? task.debugTask : null,
-        );
-        // TODO: Figure out a better signal than a magic digest value.
-        errorDigest = 'POSTPONE';
-      } else {
-        errorDigest = logRecoverableError(
-          request,
-          error,
-          thrownInfo,
-          __DEV__ ? task.debugTask : null,
-        );
-      }
+      const errorDigest = logRecoverableError(
+        request,
+        error,
+        thrownInfo,
+        __DEV__ ? task.debugTask : null,
+      );
       encodeErrorForBoundary(
         newBoundary,
         errorDigest,
@@ -1696,30 +1645,12 @@ function replaySuspenseBoundary(
   } catch (error: mixed) {
     resumedBoundary.status = CLIENT_RENDERED;
     const thrownInfo = getThrownInfo(task.componentStack);
-    let errorDigest;
-    if (
-      enablePostpone &&
-      typeof error === 'object' &&
-      error !== null &&
-      error.$$typeof === REACT_POSTPONE_TYPE
-    ) {
-      const postponeInstance: Postpone = (error: any);
-      logPostpone(
-        request,
-        postponeInstance.message,
-        thrownInfo,
-        __DEV__ ? task.debugTask : null,
-      );
-      // TODO: Figure out a better signal than a magic digest value.
-      errorDigest = 'POSTPONE';
-    } else {
-      errorDigest = logRecoverableError(
-        request,
-        error,
-        thrownInfo,
-        __DEV__ ? task.debugTask : null,
-      );
-    }
+    const errorDigest = logRecoverableError(
+      request,
+      error,
+      thrownInfo,
+      __DEV__ ? task.debugTask : null,
+    );
     encodeErrorForBoundary(
       resumedBoundary,
       errorDigest,
@@ -4025,32 +3956,6 @@ function untrackBoundary(request: Request, boundary: SuspenseBoundary) {
   // we don't replay the path to it.
 }
 
-function injectPostponedHole(
-  request: Request,
-  task: RenderTask,
-  reason: string,
-  thrownInfo: ThrownInfo,
-): Segment {
-  logPostpone(request, reason, thrownInfo, __DEV__ ? task.debugTask : null);
-  // Something suspended, we'll need to create a new segment and resolve it later.
-  const segment = task.blockedSegment;
-  const insertionIndex = segment.chunks.length;
-  const newSegment = createPendingSegment(
-    request,
-    insertionIndex,
-    null,
-    task.formatContext,
-    // Adopt the parent segment's leading text embed
-    segment.lastPushedText,
-    // Assume we are text embedded at the trailing edge
-    true,
-  );
-  segment.children.push(newSegment);
-  // Reset lastPushedText for current Segment since the new Segment "consumed" it
-  segment.lastPushedText = false;
-  return newSegment;
-}
-
 function spawnNewSuspendedReplayTask(
   request: Request,
   task: ReplayTask,
@@ -4297,45 +4202,6 @@ function renderNode(
           switchContext(previousContext);
           return;
         }
-        if (
-          enablePostpone &&
-          x.$$typeof === REACT_POSTPONE_TYPE &&
-          request.trackedPostpones !== null &&
-          task.blockedBoundary !== null // bubble if we're postponing in the shell
-        ) {
-          // If we're tracking postpones, we inject a hole here and continue rendering
-          // sibling. Similar to suspending. If we're not tracking, we treat it more like
-          // an error. Notably this doesn't spawn a new task since nothing will fill it
-          // in during this prerender.
-          const trackedPostpones = request.trackedPostpones;
-
-          const postponeInstance: Postpone = (x: any);
-          const thrownInfo = getThrownInfo(task.componentStack);
-          const postponedSegment = injectPostponedHole(
-            request,
-            ((task: any): RenderTask), // We don't use ReplayTasks in prerenders.
-            postponeInstance.message,
-            thrownInfo,
-          );
-          trackPostpone(request, trackedPostpones, task, postponedSegment);
-
-          // Restore the context. We assume that this will be restored by the inner
-          // functions in case nothing throws so we don't use "finally" here.
-          task.formatContext = previousFormatContext;
-          if (!disableLegacyContext) {
-            task.legacyContext = previousLegacyContext;
-          }
-          task.context = previousContext;
-          task.keyPath = previousKeyPath;
-          task.treeContext = previousTreeContext;
-          task.componentStack = previousComponentStack;
-          if (__DEV__) {
-            task.debugTask = previousDebugTask;
-          }
-          // Restore all active ReactContexts to what they were before.
-          switchContext(previousContext);
-          return;
-        }
         if (x.message === 'Maximum call stack size exceeded') {
           // This was a stack overflow. We do a lot of recursion in React by default for
           // performance but it can lead to stack overflows in extremely deep trees.
@@ -4411,20 +4277,7 @@ function erroredReplay(
   // that doesn't error the parent Suspense boundary.
   // This might be a bit strange that the error in a parent gets thrown at a child.
   // We log it only once and reuse the digest.
-  let errorDigest;
-  if (
-    enablePostpone &&
-    typeof error === 'object' &&
-    error !== null &&
-    error.$$typeof === REACT_POSTPONE_TYPE
-  ) {
-    const postponeInstance: Postpone = (error: any);
-    logPostpone(request, postponeInstance.message, errorInfo, debugTask);
-    // TODO: Figure out a better signal than a magic digest value.
-    errorDigest = 'POSTPONE';
-  } else {
-    errorDigest = logRecoverableError(request, error, errorInfo, debugTask);
-  }
+  const errorDigest = logRecoverableError(request, error, errorInfo, debugTask);
   abortRemainingReplayNodes(
     request,
     boundary,
@@ -4454,23 +4307,10 @@ function erroredTask(
   request.allPendingTasks--;
 
   // Report the error to a global handler.
-  let errorDigest;
   // We don't handle halts here because we only halt when prerendering and
   // when prerendering we should be finishing tasks not erroring them when
   // they halt or postpone
-  if (
-    enablePostpone &&
-    typeof error === 'object' &&
-    error !== null &&
-    error.$$typeof === REACT_POSTPONE_TYPE
-  ) {
-    const postponeInstance: Postpone = (error: any);
-    logPostpone(request, postponeInstance.message, errorInfo, debugTask);
-    // TODO: Figure out a better signal than a magic digest value.
-    errorDigest = 'POSTPONE';
-  } else {
-    errorDigest = logRecoverableError(request, error, errorInfo, debugTask);
-  }
+  const errorDigest = logRecoverableError(request, error, errorInfo, debugTask);
   if (boundary === null) {
     fatalError(request, error, errorInfo, debugTask);
   } else {
@@ -4691,34 +4531,6 @@ function abortTask(task: Task, request: Request, error: mixed): void {
         // We didn't complete the root so we have nothing to show. We can close
         // the request;
         if (
-          enablePostpone &&
-          typeof error === 'object' &&
-          error !== null &&
-          error.$$typeof === REACT_POSTPONE_TYPE
-        ) {
-          const postponeInstance: Postpone = (error: any);
-          const trackedPostpones = request.trackedPostpones;
-
-          if (trackedPostpones !== null && segment !== null) {
-            // We are prerendering. We don't want to fatal when the shell postpones
-            // we just need to mark it as postponed.
-            logPostpone(
-              request,
-              postponeInstance.message,
-              errorInfo,
-              task.debugTask,
-            );
-            trackPostpone(request, trackedPostpones, task, segment);
-            finishedTask(request, null, task.row, segment);
-          } else {
-            const fatal = new Error(
-              'The render was aborted with postpone when the shell is incomplete. Reason: ' +
-                postponeInstance.message,
-            );
-            logRecoverableError(request, fatal, errorInfo, task.debugTask);
-            fatalError(request, fatal, errorInfo, task.debugTask);
-          }
-        } else if (
           enableHalt &&
           request.trackedPostpones !== null &&
           segment !== null
@@ -4740,25 +4552,12 @@ function abortTask(task: Task, request: Request, error: mixed): void {
         // the ReplaySet.
         replay.pendingTasks--;
         if (replay.pendingTasks === 0 && replay.nodes.length > 0) {
-          let errorDigest;
-          if (
-            enablePostpone &&
-            typeof error === 'object' &&
-            error !== null &&
-            error.$$typeof === REACT_POSTPONE_TYPE
-          ) {
-            const postponeInstance: Postpone = (error: any);
-            logPostpone(
-              request,
-              postponeInstance.message,
-              errorInfo,
-              task.debugTask,
-            );
-            // TODO: Figure out a better signal than a magic digest value.
-            errorDigest = 'POSTPONE';
-          } else {
-            errorDigest = logRecoverableError(request, error, errorInfo, null);
-          }
+          const errorDigest = logRecoverableError(
+            request,
+            error,
+            errorInfo,
+            null,
+          );
           abortRemainingReplayNodes(
             request,
             null,
@@ -4783,25 +4582,9 @@ function abortTask(task: Task, request: Request, error: mixed): void {
     if (boundary.status !== CLIENT_RENDERED) {
       if (enableHalt) {
         if (trackedPostpones !== null && segment !== null) {
-          // We are aborting a prerender
-          if (
-            enablePostpone &&
-            typeof error === 'object' &&
-            error !== null &&
-            error.$$typeof === REACT_POSTPONE_TYPE
-          ) {
-            const postponeInstance: Postpone = (error: any);
-            logPostpone(
-              request,
-              postponeInstance.message,
-              errorInfo,
-              task.debugTask,
-            );
-          } else {
-            // We are aborting a prerender and must halt this boundary.
-            // We treat this like other postpones during prerendering
-            logRecoverableError(request, error, errorInfo, task.debugTask);
-          }
+          // We are aborting a prerender and must halt this boundary.
+          // We treat this like other postpones during prerendering
+          logRecoverableError(request, error, errorInfo, task.debugTask);
           trackPostpone(request, trackedPostpones, task, segment);
           // If this boundary was still pending then we haven't already cancelled its fallbacks.
           // We'll need to abort the fallbacks, which will also error that parent boundary.
@@ -4815,42 +4598,12 @@ function abortTask(task: Task, request: Request, error: mixed): void {
       boundary.status = CLIENT_RENDERED;
       // We are aborting a render or resume which should put boundaries
       // into an explicitly client rendered state
-      let errorDigest;
-      if (
-        enablePostpone &&
-        typeof error === 'object' &&
-        error !== null &&
-        error.$$typeof === REACT_POSTPONE_TYPE
-      ) {
-        const postponeInstance: Postpone = (error: any);
-        logPostpone(
-          request,
-          postponeInstance.message,
-          errorInfo,
-          task.debugTask,
-        );
-        if (request.trackedPostpones !== null && segment !== null) {
-          trackPostpone(request, request.trackedPostpones, task, segment);
-          finishedTask(request, task.blockedBoundary, task.row, segment);
-
-          // If this boundary was still pending then we haven't already cancelled its fallbacks.
-          // We'll need to abort the fallbacks, which will also error that parent boundary.
-          boundary.fallbackAbortableTasks.forEach(fallbackTask =>
-            abortTask(fallbackTask, request, error),
-          );
-          boundary.fallbackAbortableTasks.clear();
-          return;
-        }
-        // TODO: Figure out a better signal than a magic digest value.
-        errorDigest = 'POSTPONE';
-      } else {
-        errorDigest = logRecoverableError(
-          request,
-          error,
-          errorInfo,
-          task.debugTask,
-        );
-      }
+      const errorDigest = logRecoverableError(
+        request,
+        error,
+        errorInfo,
+        task.debugTask,
+      );
       boundary.status = CLIENT_RENDERED;
       encodeErrorForBoundary(boundary, errorDigest, error, errorInfo, true);
 
@@ -5254,27 +5007,12 @@ function retryRenderTask(
       const thrownInfo = getThrownInfo(task.componentStack);
       task.abortSet.delete(task);
 
-      if (
-        enablePostpone &&
-        typeof x === 'object' &&
-        x !== null &&
-        x.$$typeof === REACT_POSTPONE_TYPE
-      ) {
-        const postponeInstance: Postpone = (x: any);
-        logPostpone(
-          request,
-          postponeInstance.message,
-          thrownInfo,
-          __DEV__ ? task.debugTask : null,
-        );
-      } else {
-        logRecoverableError(
-          request,
-          x,
-          thrownInfo,
-          __DEV__ ? task.debugTask : null,
-        );
-      }
+      logRecoverableError(
+        request,
+        x,
+        thrownInfo,
+        __DEV__ ? task.debugTask : null,
+      );
 
       trackPostpone(request, trackedPostpones, task, segment);
       finishedTask(request, task.blockedBoundary, task.row, segment);
@@ -5294,28 +5032,6 @@ function retryRenderTask(
         // We've asserted that x is a thenable above
         (x: any).then(ping, ping);
         return;
-      } else if (
-        enablePostpone &&
-        request.trackedPostpones !== null &&
-        x.$$typeof === REACT_POSTPONE_TYPE
-      ) {
-        // If we're tracking postpones, we mark this segment as postponed and finish
-        // the task without filling it in. If we're not tracking, we treat it more like
-        // an error.
-        const trackedPostpones = request.trackedPostpones;
-        task.abortSet.delete(task);
-        const postponeInstance: Postpone = (x: any);
-
-        const postponeInfo = getThrownInfo(task.componentStack);
-        logPostpone(
-          request,
-          postponeInstance.message,
-          postponeInfo,
-          __DEV__ ? task.debugTask : null,
-        );
-        trackPostpone(request, trackedPostpones, task, segment);
-        finishedTask(request, task.blockedBoundary, task.row, segment);
-        return;
       }
     }
 
@@ -6166,9 +5882,7 @@ function flushCompletedQueues(
       request.flushScheduled = false;
       // We write the trailing tags but only if don't have any data to resume.
       // If we need to resume we'll write the postamble in the resume instead.
-      if (!enablePostpone || request.trackedPostpones === null) {
-        writePostamble(destination, request.resumableState);
-      }
+      writePostamble(destination, request.resumableState);
       completeWriting(destination);
       flushBuffered(destination);
       if (__DEV__) {
diff --git a/packages/react-server/src/ReactFlightServer.js b/packages/react-server/src/ReactFlightServer.js
index dcdf631a3d7..1f5e24ff596 100644
--- a/packages/react-server/src/ReactFlightServer.js
+++ b/packages/react-server/src/ReactFlightServer.js
@@ -9,12 +9,9 @@
 
 import type {Chunk, BinaryChunk, Destination} from './ReactServerStreamConfig';
 
-import type {Postpone} from 'react/src/ReactPostpone';
-
 import type {TemporaryReferenceSet} from './ReactFlightServerTemporaryReferences';
 
 import {
-  enablePostpone,
   enableHalt,
   enableTaint,
   enableProfilerTimer,
@@ -138,7 +135,6 @@ import {
   REACT_FRAGMENT_TYPE,
   REACT_LAZY_TYPE,
   REACT_MEMO_TYPE,
-  REACT_POSTPONE_TYPE,
   ASYNC_ITERATOR,
 } from 'shared/ReactSymbols';
 
@@ -593,7 +589,6 @@ export type Request = {
   identifierCount: number,
   taintCleanupQueue: Array<string | bigint>,
   onError: (error: mixed) => ?string,
-  onPostpone: (reason: string) => void,
   onAllReady: () => void,
   onFatalError: mixed => void,
   // Profiling-only
@@ -649,15 +644,12 @@ function defaultErrorHandler(error: mixed) {
   // Don't transform to our wrapper
 }
 
-const defaultPostponeHandler: (reason: string) => void = noop;
-
 function RequestInstance(
   this: $FlowFixMe,
   type: 20 | 21,
   model: ReactClientValue,
   bundlerConfig: ClientManifest,
   onError: void | ((error: mixed) => ?string),
-  onPostpone: void | ((reason: string) => void),
   onAllReady: () => void,
   onFatalError: (error: mixed) => void,
   identifierPrefix?: string,
@@ -715,8 +707,6 @@ function RequestInstance(
   this.identifierCount = 1;
   this.taintCleanupQueue = cleanupQueue;
   this.onError = onError === undefined ? defaultErrorHandler : onError;
-  this.onPostpone =
-    onPostpone === undefined ? defaultPostponeHandler : onPostpone;
   this.onAllReady = onAllReady;
   this.onFatalError = onFatalError;
 
@@ -787,7 +777,6 @@ export function createRequest(
   bundlerConfig: ClientManifest,
   onError: void | ((error: mixed) => ?string),
   identifierPrefix: void | string,
-  onPostpone: void | ((reason: string) => void),
   temporaryReferences: void | TemporaryReferenceSet,
   environmentName: void | string | (() => string), // DEV-only
   filterStackFrame: void | ((url: string, functionName: string) => boolean), // DEV-only
@@ -803,7 +792,6 @@ export function createRequest(
     model,
     bundlerConfig,
     onError,
-    onPostpone,
     noop,
     noop,
     identifierPrefix,
@@ -821,7 +809,6 @@ export function createPrerenderRequest(
   onFatalError: () => void,
   onError: void | ((error: mixed) => ?string),
   identifierPrefix: void | string,
-  onPostpone: void | ((reason: string) => void),
   temporaryReferences: void | TemporaryReferenceSet,
   environmentName: void | string | (() => string), // DEV-only
   filterStackFrame: void | ((url: string, functionName: string) => boolean), // DEV-only
@@ -837,7 +824,6 @@ export function createPrerenderRequest(
     model,
     bundlerConfig,
     onError,
-    onPostpone,
     onAllReady,
     onFatalError,
     identifierPrefix,
@@ -3392,28 +3378,15 @@ function renderModel(
     // Something errored. We'll still send everything we have up until this point.
     request.pendingChunks++;
     const errorId = request.nextChunkId++;
-    if (
-      enablePostpone &&
-      typeof x === 'object' &&
-      x !== null &&
-      x.$$typeof === REACT_POSTPONE_TYPE
-    ) {
-      // Something postponed. We'll still send everything we have up until this point.
-      // We'll replace this element with a lazy reference that postpones on the client.
-      const postponeInstance: Postpone = (x: any);
-      logPostpone(request, postponeInstance.message, task);
-      emitPostponeChunk(request, errorId, postponeInstance);
-    } else {
-      const digest = logRecoverableError(request, x, task);
-      emitErrorChunk(
-        request,
-        errorId,
-        digest,
-        x,
-        false,
-        __DEV__ ? task.debugOwner : null,
-      );
-    }
+    const digest = logRecoverableError(request, x, task);
+    emitErrorChunk(
+      request,
+      errorId,
+      digest,
+      x,
+      false,
+      __DEV__ ? task.debugOwner : null,
+    );
     if (wasReactNode) {
       // We'll replace this element with a lazy reference that throws on the client
       // once it gets rendered.
@@ -4030,41 +4003,6 @@ function renderModelDestructive(
   );
 }
 
-function logPostpone(
-  request: Request,
-  reason: string,
-  task: Task | null, // DEV-only
-): void {
-  const prevRequest = currentRequest;
-  // We clear the request context so that console.logs inside the callback doesn't
-  // get forwarded to the client.
-  currentRequest = null;
-  try {
-    const onPostpone = request.onPostpone;
-    if (__DEV__ && task !== null) {
-      if (supportsRequestStorage) {
-        requestStorage.run(
-          undefined,
-          callWithDebugContextInDEV,
-          request,
-          task,
-          onPostpone,
-          reason,
-        );
-      } else {
-        callWithDebugContextInDEV(request, task, onPostpone, reason);
-      }
-    } else if (supportsRequestStorage) {
-      // Exit the request context while running callbacks.
-      requestStorage.run(undefined, onPostpone, reason);
-    } else {
-      onPostpone(reason);
-    }
-  } finally {
-    currentRequest = prevRequest;
-  }
-}
-
 function logRecoverableError(
   request: Request,
   error: mixed,
@@ -4131,32 +4069,6 @@ function fatalError(request: Request, error: mixed): void {
   request.cacheController.abort(abortReason);
 }
 
-function emitPostponeChunk(
-  request: Request,
-  id: number,
-  postponeInstance: Postpone,
-): void {
-  let row;
-  if (__DEV__) {
-    let reason = '';
-    let stack: ReactStackTrace;
-    const env = request.environmentName();
-    try {
-      // eslint-disable-next-line react-internal/safe-string-coercion
-      reason = String(postponeInstance.message);
-      stack = filterStackTrace(request, parseStackTrace(postponeInstance, 0));
-    } catch (x) {
-      stack = [];
-    }
-    row = serializeRowHeader('P', id) + stringify({reason, stack, env}) + '\n';
-  } else {
-    // No reason included in prod.
-    row = serializeRowHeader('P', id) + '\n';
-  }
-  const processedChunk = stringToChunk(row);
-  request.completedErrorChunks.push(processedChunk);
-}
-
 function serializeErrorValue(request: Request, error: Error): string {
   if (__DEV__) {
     let name: string = 'Error';
@@ -5716,26 +5628,15 @@ function erroredTask(request: Request, task: Task, error: mixed): void {
     }
   }
   task.status = ERRORED;
-  if (
-    enablePostpone &&
-    typeof error === 'object' &&
-    error !== null &&
-    error.$$typeof === REACT_POSTPONE_TYPE
-  ) {
-    const postponeInstance: Postpone = (error: any);
-    logPostpone(request, postponeInstance.message, task);
-    emitPostponeChunk(request, task.id, postponeInstance);
-  } else {
-    const digest = logRecoverableError(request, error, task);
-    emitErrorChunk(
-      request,
-      task.id,
-      digest,
-      error,
-      false,
-      __DEV__ ? task.debugOwner : null,
-    );
-  }
+  const digest = logRecoverableError(request, error, task);
+  emitErrorChunk(
+    request,
+    task.id,
+    digest,
+    error,
+    false,
+    __DEV__ ? task.debugOwner : null,
+  );
   request.abortableTasks.delete(task);
   callOnAllReadyIfReady(request);
 }
@@ -6274,22 +6175,6 @@ export function abort(request: Request, reason: mixed): void {
         // and leave the reference unfulfilled.
         abortableTasks.forEach(task => haltTask(task, request));
         scheduleWork(() => finishHalt(request, abortableTasks));
-      } else if (
-        enablePostpone &&
-        typeof reason === 'object' &&
-        reason !== null &&
-        (reason: any).$$typeof === REACT_POSTPONE_TYPE
-      ) {
-        const postponeInstance: Postpone = (reason: any);
-        logPostpone(request, postponeInstance.message, null);
-        // When rendering we produce a shared postpone chunk and then
-        // fulfill each task with a reference to that chunk.
-        const errorId = request.nextChunkId++;
-        request.fatalError = errorId;
-        request.pendingChunks++;
-        emitPostponeChunk(request, errorId, postponeInstance);
-        abortableTasks.forEach(task => abortTask(task, request, errorId));
-        scheduleWork(() => finishAbort(request, abortableTasks, errorId));
       } else {
         const error =
           reason === undefined
diff --git a/packages/react/src/ReactPostpone.js b/packages/react/src/ReactPostpone.js
deleted file mode 100644
index 0496d2985b3..00000000000
--- a/packages/react/src/ReactPostpone.js
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import {REACT_POSTPONE_TYPE} from 'shared/ReactSymbols';
-
-declare class Postpone extends Error {
-  $$typeof: symbol;
-}
-
-export type {Postpone};
-
-export function postpone(reason: string): void {
-  // eslint-disable-next-line react-internal/prod-error-codes
-  const postponeInstance: Postpone = (new Error(reason): any);
-  postponeInstance.$$typeof = REACT_POSTPONE_TYPE;
-  throw postponeInstance;
-}
diff --git a/packages/shared/ReactFeatureFlags.js b/packages/shared/ReactFeatureFlags.js
index 1881d3fc289..c31809276bd 100644
--- a/packages/shared/ReactFeatureFlags.js
+++ b/packages/shared/ReactFeatureFlags.js
@@ -80,8 +80,6 @@ export const enableAsyncIterableChildren = __EXPERIMENTAL__;
 
 export const enableTaint = __EXPERIMENTAL__;
 
-export const enablePostpone: boolean = false; // Probably won't ship in this form.
-
 export const enableHalt: boolean = true;
 
 export const enableViewTransition: boolean = true;
diff --git a/packages/shared/ReactSymbols.js b/packages/shared/ReactSymbols.js
index 2d478ffc676..f8ebf703f46 100644
--- a/packages/shared/ReactSymbols.js
+++ b/packages/shared/ReactSymbols.js
@@ -44,8 +44,6 @@ export const REACT_MEMO_CACHE_SENTINEL: symbol = Symbol.for(
   'react.memo_cache_sentinel',
 );
 
-export const REACT_POSTPONE_TYPE: symbol = Symbol.for('react.postpone');
-
 export const REACT_VIEW_TRANSITION_TYPE: symbol = Symbol.for(
   'react.view_transition',
 );
diff --git a/packages/shared/forks/ReactFeatureFlags.native-fb.js b/packages/shared/forks/ReactFeatureFlags.native-fb.js
index dbf92a2190e..e1b26cdb83b 100644
--- a/packages/shared/forks/ReactFeatureFlags.native-fb.js
+++ b/packages/shared/forks/ReactFeatureFlags.native-fb.js
@@ -51,7 +51,6 @@ export const enableLegacyCache: boolean = false;
 export const enableLegacyFBSupport: boolean = false;
 export const enableLegacyHidden: boolean = false;
 export const enableNoCloningMemoCache: boolean = false;
-export const enablePostpone: boolean = false;
 export const enableProfilerCommitHooks: boolean = __PROFILE__;
 export const enableProfilerNestedUpdatePhase: boolean = __PROFILE__;
 export const enableProfilerTimer: boolean = __PROFILE__;
diff --git a/packages/shared/forks/ReactFeatureFlags.native-oss.js b/packages/shared/forks/ReactFeatureFlags.native-oss.js
index c509dbce69f..3880556d247 100644
--- a/packages/shared/forks/ReactFeatureFlags.native-oss.js
+++ b/packages/shared/forks/ReactFeatureFlags.native-oss.js
@@ -38,7 +38,6 @@ export const enableLegacyFBSupport: boolean = false;
 export const enableLegacyHidden: boolean = false;
 export const enableNoCloningMemoCache: boolean = false;
 export const enableObjectFiber: boolean = false;
-export const enablePostpone: boolean = false;
 export const enableReactTestRendererWarning: boolean = false;
 export const enableRetryLaneExpiration: boolean = false;
 export const enableComponentPerformanceTrack: boolean = true;
diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.js
index 5ae58dab14d..88c46d26e2e 100644
--- a/packages/shared/forks/ReactFeatureFlags.test-renderer.js
+++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.js
@@ -21,7 +21,6 @@ export const enableUpdaterTracking: boolean = false;
 export const enableLegacyCache: boolean = __EXPERIMENTAL__;
 export const enableAsyncIterableChildren: boolean = false;
 export const enableTaint: boolean = true;
-export const enablePostpone: boolean = false;
 export const enableHalt: boolean = true;
 export const disableCommentsAsDOMContainers: boolean = true;
 export const disableInputAttributeSyncing: boolean = false;
diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js
index 91803ab38ac..d9c425319f9 100644
--- a/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js
+++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js
@@ -33,7 +33,6 @@ export const enableLegacyFBSupport = false;
 export const enableLegacyHidden = false;
 export const enableNoCloningMemoCache = false;
 export const enableObjectFiber = false;
-export const enablePostpone = false;
 export const enableProfilerCommitHooks = __PROFILE__;
 export const enableProfilerNestedUpdatePhase = __PROFILE__;
 export const enableProfilerTimer = __PROFILE__;
diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
index dd982851075..d815fd7ddc8 100644
--- a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
+++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
@@ -21,7 +21,6 @@ export const enableUpdaterTracking: boolean = false;
 export const enableLegacyCache: boolean = true;
 export const enableAsyncIterableChildren: boolean = false;
 export const enableTaint: boolean = true;
-export const enablePostpone: boolean = false;
 export const enableHalt: boolean = true;
 export const disableCommentsAsDOMContainers: boolean = true;
 export const disableInputAttributeSyncing: boolean = false;
diff --git a/packages/shared/forks/ReactFeatureFlags.www.js b/packages/shared/forks/ReactFeatureFlags.www.js
index 542d72c2f6f..4ace06ed4c4 100644
--- a/packages/shared/forks/ReactFeatureFlags.www.js
+++ b/packages/shared/forks/ReactFeatureFlags.www.js
@@ -73,8 +73,6 @@ export const enableAsyncIterableChildren: boolean = false;
 
 export const enableTaint: boolean = false;
 
-export const enablePostpone: boolean = false;
-
 export const enableHalt: boolean = true;
 
 // TODO: www currently relies on this feature. It's disabled in open source.