diff --git a/.github/stale.yml b/.github/stale.yml
index 25f65e7c3d4aa..0d33381a10deb 100644
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -12,6 +12,7 @@ exemptLabels:
   - "Type: Discussion"
   - "Type: Needs Investigation"
   - "Type: Regression"
+  - "Type: Feature Request"
 # Label to use when marking an issue as stale
 staleLabel: "Resolution: Stale"
 issues:
diff --git a/CHANGELOG-canary.md b/CHANGELOG-canary.md
index 6040a0b246cb3..048f6a542e642 100644
--- a/CHANGELOG-canary.md
+++ b/CHANGELOG-canary.md
@@ -1,3 +1,8 @@
+## March 22, 2024 (18.3.0-canary-670811593-20240322)
+
+## React
+- Added `useActionState` to replace `useFormState` and added `pending` value ([#28491](https://github.com/facebook/react/pull/28491)).
+
 ## October 5, 2023 (18.3.0-canary-546178f91-20231005)
 
 ### React
diff --git a/ReactVersions.js b/ReactVersions.js
index ef97ee7e3afc3..e70d2e5ad60f2 100644
--- a/ReactVersions.js
+++ b/ReactVersions.js
@@ -7,18 +7,18 @@
 //
 // The @latest channel uses the version as-is, e.g.:
 //
-//   18.3.0
+//   19.0.0
 //
 // The @canary channel appends additional information, with the scheme
 // <version>-<label>-<commit_sha>, e.g.:
 //
-//   18.3.0-canary-a1c2d3e4
+//   19.0.0-canary-a1c2d3e4
 //
 // The @experimental channel doesn't include a version, only a date and a sha, e.g.:
 //
 //   0.0.0-experimental-241c4467e-20200129
 
-const ReactVersion = '18.3.0';
+const ReactVersion = '19.0.0';
 
 // The label used by the @canary channel. Represents the upcoming release's
 // stability. Most of the time, this will be "canary", but we may temporarily
@@ -29,20 +29,20 @@ const ReactVersion = '18.3.0';
 const canaryChannelLabel = 'canary';
 
 const stablePackages = {
-  'eslint-plugin-react-hooks': '5.0.0',
-  'jest-react': '0.15.0',
+  'eslint-plugin-react-hooks': '5.1.0',
+  'jest-react': '0.16.0',
   react: ReactVersion,
   'react-art': ReactVersion,
   'react-dom': ReactVersion,
   'react-server-dom-webpack': ReactVersion,
   'react-server-dom-turbopack': ReactVersion,
   'react-is': ReactVersion,
-  'react-reconciler': '0.30.0',
-  'react-refresh': '0.15.0',
+  'react-reconciler': '0.31.0',
+  'react-refresh': '0.16.0',
   'react-test-renderer': ReactVersion,
-  'use-subscription': '1.9.0',
-  'use-sync-external-store': '1.3.0',
-  scheduler: '0.24.0',
+  'use-subscription': '1.10.0',
+  'use-sync-external-store': '1.4.0',
+  scheduler: '0.25.0',
 };
 
 // These packages do not exist in the @canary or @latest channel, only
diff --git a/fixtures/art/package.json b/fixtures/art/package.json
index ff3229769bdb9..7bab6d59eb1c7 100644
--- a/fixtures/art/package.json
+++ b/fixtures/art/package.json
@@ -5,9 +5,9 @@
     "@babel/preset-env": "^7.10.4",
     "@babel/preset-react": "^7.10.4",
     "babel-loader": "^8.1.0",
-    "react": "^18.2.0",
-    "react-art": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "react": "^19.0.0",
+    "react-art": "^19.0.0",
+    "react-dom": "^19.0.0",
     "webpack": "^1.14.0"
   },
   "scripts": {
diff --git a/fixtures/dom/yarn.lock b/fixtures/dom/yarn.lock
index 9a96e2ea4dd9a..d72a492e5e995 100644
--- a/fixtures/dom/yarn.lock
+++ b/fixtures/dom/yarn.lock
@@ -2679,16 +2679,17 @@ es-to-primitive@^1.2.1:
     is-date-object "^1.0.1"
     is-symbol "^1.0.2"
 
-es5-ext@^0.10.35, es5-ext@^0.10.46, es5-ext@^0.10.50, es5-ext@~0.10.14:
-  version "0.10.53"
-  resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.53.tgz#93c5a3acfdbef275220ad72644ad02ee18368de1"
-  integrity sha512-Xs2Stw6NiNHWypzRTY1MtaG/uJlwCk8kH81920ma8mvN8Xq1gsfhZvpkImLQArw8AHnv8MT2I45J3c0R8slE+Q==
+es5-ext@^0.10.35, es5-ext@^0.10.46, es5-ext@^0.10.50, es5-ext@^0.10.62, es5-ext@~0.10.14:
+  version "0.10.63"
+  resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.63.tgz#9c222a63b6a332ac80b1e373b426af723b895bd6"
+  integrity sha512-hUCZd2Byj/mNKjfP9jXrdVZ62B8KuA/VoK7X8nUh5qT+AxDmcbvZz041oDVZdbIN1qW6XY9VDNwzkvKnZvK2TQ==
   dependencies:
-    es6-iterator "~2.0.3"
-    es6-symbol "~3.1.3"
-    next-tick "~1.0.0"
+    es6-iterator "^2.0.3"
+    es6-symbol "^3.1.3"
+    esniff "^2.0.1"
+    next-tick "^1.1.0"
 
-es6-iterator@^2.0.3, es6-iterator@~2.0.1, es6-iterator@~2.0.3:
+es6-iterator@^2.0.3, es6-iterator@~2.0.1:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7"
   integrity sha1-p96IkUGgWpSwhUQDstCg+/qY87c=
@@ -2733,7 +2734,7 @@ es6-symbol@3.1.1:
     d "1"
     es5-ext "~0.10.14"
 
-es6-symbol@^3.1.1, es6-symbol@~3.1.1, es6-symbol@~3.1.3:
+es6-symbol@^3.1.1, es6-symbol@^3.1.3, es6-symbol@~3.1.1:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
   integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==
@@ -2912,6 +2913,16 @@ eslint@4.10.0:
     table "^4.0.1"
     text-table "~0.2.0"
 
+esniff@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/esniff/-/esniff-2.0.1.tgz#a4d4b43a5c71c7ec51c51098c1d8a29081f9b308"
+  integrity sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==
+  dependencies:
+    d "^1.0.1"
+    es5-ext "^0.10.62"
+    event-emitter "^0.3.5"
+    type "^2.7.2"
+
 espree@^3.5.1:
   version "3.5.4"
   resolved "https://registry.yarnpkg.com/espree/-/espree-3.5.4.tgz#b0f447187c8a8bed944b815a660bddf5deb5d1a7"
@@ -2964,7 +2975,7 @@ etag@~1.8.1:
   resolved "https://registry.yarnpkg.com/etag/-/etag-1.8.1.tgz#41ae2eeb65efa62268aebfea83ac7d79299b0887"
   integrity sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=
 
-event-emitter@~0.3.5:
+event-emitter@^0.3.5, event-emitter@~0.3.5:
   version "0.3.5"
   resolved "https://registry.yarnpkg.com/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39"
   integrity sha1-34xp7vFkeSPHFXuc6DhAYQsCzDk=
@@ -5444,10 +5455,10 @@ neo-async@^2.5.0, neo-async@^2.6.0:
   resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
 
-next-tick@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.0.0.tgz#ca86d1fe8828169b0120208e3dc8424b9db8342c"
-  integrity sha1-yobR/ogoFpsBICCOPchCS524NCw=
+next-tick@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb"
+  integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==
 
 no-case@^2.2.0:
   version "2.3.2"
@@ -7845,6 +7856,11 @@ type@^2.0.0:
   resolved "https://registry.yarnpkg.com/type/-/type-2.1.0.tgz#9bdc22c648cf8cf86dd23d32336a41cfb6475e3f"
   integrity sha512-G9absDWvhAWCV2gmF1zKud3OyC61nZDwWvBL2DApaVFogI07CprggiQAOOjvp2NRjYWFzPyu7vwtDrQFq8jeSA==
 
+type@^2.7.2:
+  version "2.7.2"
+  resolved "https://registry.yarnpkg.com/type/-/type-2.7.2.tgz#2376a15a3a28b1efa0f5350dcf72d24df6ef98d0"
+  integrity sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==
+
 typedarray@^0.0.6:
   version "0.0.6"
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
diff --git a/fixtures/fizz/package.json b/fixtures/fizz/package.json
index 1684ba6c1bd7f..096a392f4b524 100644
--- a/fixtures/fizz/package.json
+++ b/fixtures/fizz/package.json
@@ -15,8 +15,8 @@
     "concurrently": "^5.3.0",
     "express": "^4.17.1",
     "nodemon": "^2.0.6",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "react-error-boundary": "^3.1.3",
     "resolve": "1.12.0",
     "rimraf": "^3.0.2",
diff --git a/fixtures/flight/package.json b/fixtures/flight/package.json
index 968f404fcf8fd..a2d61155ac661 100644
--- a/fixtures/flight/package.json
+++ b/fixtures/flight/package.json
@@ -59,7 +59,7 @@
     "terser-webpack-plugin": "^5.2.5",
     "undici": "^5.20.0",
     "webpack": "^5.64.4",
-    "webpack-dev-middleware": "^5.3.1",
+    "webpack-dev-middleware": "^5.3.4",
     "webpack-hot-middleware": "^2.25.3",
     "webpack-manifest-plugin": "^4.0.2"
   },
diff --git a/fixtures/flight/yarn.lock b/fixtures/flight/yarn.lock
index 4954b0e89a04c..af1b29b1c0677 100644
--- a/fixtures/flight/yarn.lock
+++ b/fixtures/flight/yarn.lock
@@ -6183,52 +6183,18 @@ micromatch@^4.0.4:
     braces "^3.0.2"
     picomatch "^2.3.1"
 
-mime-db@1.40.0:
-  version "1.40.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.40.0.tgz#a65057e998db090f732a68f6c276d387d4126c32"
-  integrity sha512-jYdeOMPy9vnxEqFRRo6ZvTZ8d9oPb+k18PKoYNYUe2stVEBPPwsln/qWzdbmaIvnhZ9v2P+CuecK+fpUfsV2mA==
-
-mime-db@1.44.0:
-  version "1.44.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.44.0.tgz#fa11c5eb0aca1334b4233cb4d52f10c5a6272f92"
-  integrity sha512-/NOTfLrsPBVeH7YtFPgsVWveuL+4SjjYxaQ1xtM1KMFj7HdxlBlxeyNLzhyJVx7r4rZGJAZ/6lkKCitSc/Nmpg==
-
 mime-db@1.52.0, "mime-db@>= 1.43.0 < 2":
   version "1.52.0"
   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
   integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
 
-mime-db@~1.36.0:
-  version "1.36.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.36.0.tgz#5020478db3c7fe93aad7bbcc4dcf869c43363397"
-
-mime-types@^2.1.12:
-  version "2.1.20"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.20.tgz#930cb719d571e903738520f8470911548ca2cc19"
-  dependencies:
-    mime-db "~1.36.0"
-
-mime-types@^2.1.27:
-  version "2.1.27"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.27.tgz#47949f98e279ea53119f5722e0f34e529bec009f"
-  integrity sha512-JIhqnCasI9yD+SsmkquHBxTSEuZdQX5BuQnS2Vc7puQQQ+8yiP5AY5uWhpdv4YL4VM5c6iliiYWPgJ/nJQLp7w==
-  dependencies:
-    mime-db "1.44.0"
-
-mime-types@^2.1.31, mime-types@~2.1.34:
+mime-types@^2.1.12, mime-types@^2.1.27, mime-types@^2.1.31, mime-types@~2.1.24, mime-types@~2.1.34:
   version "2.1.35"
   resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
   integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
   dependencies:
     mime-db "1.52.0"
 
-mime-types@~2.1.24:
-  version "2.1.24"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.24.tgz#b6f8d0b3e951efb77dedeca194cff6d16f676f81"
-  integrity sha512-WaFHS3MCl5fapm3oLxU4eYDw77IQM2ACcxQ9RIxfaC3ooc6PFuBMGZZsYpvoXS5D5QTWPieo1jjLdAm3TBP3cQ==
-  dependencies:
-    mime-db "1.40.0"
-
 mimic-fn@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
@@ -7720,7 +7686,7 @@ schema-utils@^2.6.5:
     ajv "^6.12.4"
     ajv-keywords "^3.5.2"
 
-schema-utils@^3.0.0:
+schema-utils@^3.0.0, schema-utils@^3.1.0, schema-utils@^3.1.1:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.3.0.tgz#f50a88877c3c01652a15b622ae9e9795df7a60fe"
   integrity sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==
@@ -7729,15 +7695,6 @@ schema-utils@^3.0.0:
     ajv "^6.12.5"
     ajv-keywords "^3.5.2"
 
-schema-utils@^3.1.0, schema-utils@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.1.1.tgz#bc74c4b6b6995c1d88f76a8b77bea7219e0c8281"
-  integrity sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==
-  dependencies:
-    "@types/json-schema" "^7.0.8"
-    ajv "^6.12.5"
-    ajv-keywords "^3.5.2"
-
 schema-utils@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-4.0.0.tgz#60331e9e3ae78ec5d16353c467c34b3a0a1d3df7"
@@ -8485,10 +8442,10 @@ webidl-conversions@^6.1.0:
   resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-6.1.0.tgz#9111b4d7ea80acd40f5270d666621afa78b69514"
   integrity sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==
 
-webpack-dev-middleware@^5.3.1:
-  version "5.3.3"
-  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-5.3.3.tgz#efae67c2793908e7311f1d9b06f2a08dcc97e51f"
-  integrity sha512-hj5CYrY0bZLB+eTO+x/j67Pkrquiy7kWepMHmUMoPsmcUaeEnQJqFzHJOyxgWlq746/wUuA64p9ta34Kyb01pA==
+webpack-dev-middleware@^5.3.4:
+  version "5.3.4"
+  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz#eb7b39281cbce10e104eb2b8bf2b63fce49a3517"
+  integrity sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==
   dependencies:
     colorette "^2.0.10"
     memfs "^3.4.3"
diff --git a/fixtures/ssr/package.json b/fixtures/ssr/package.json
index b474a791b46d3..33ea7add74e89 100644
--- a/fixtures/ssr/package.json
+++ b/fixtures/ssr/package.json
@@ -12,8 +12,8 @@
     "ignore-styles": "^5.0.1",
     "import-export": "^1.0.1",
     "node-fetch": "^1.6.3",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
   },
   "scripts": {
     "predev": "cp -r ../../build/oss-experimental/* ./node_modules/",
diff --git a/fixtures/ssr2/package.json b/fixtures/ssr2/package.json
index c05f8282ce03d..1acf976d85c6c 100644
--- a/fixtures/ssr2/package.json
+++ b/fixtures/ssr2/package.json
@@ -15,8 +15,8 @@
     "concurrently": "^5.3.0",
     "express": "^4.17.1",
     "nodemon": "^2.0.6",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "react-error-boundary": "^3.1.3",
     "resolve": "1.12.0",
     "rimraf": "^3.0.2",
diff --git a/packages/internal-test-utils/ReactInternalTestUtils.js b/packages/internal-test-utils/ReactInternalTestUtils.js
index df77f23448b13..c6cb39fd73e08 100644
--- a/packages/internal-test-utils/ReactInternalTestUtils.js
+++ b/packages/internal-test-utils/ReactInternalTestUtils.js
@@ -13,6 +13,8 @@ import simulateBrowserEventDispatch from './simulateBrowserEventDispatch';
 
 export {act} from './internalAct';
 
+import {thrownErrors, actingUpdatesScopeDepth} from './internalAct';
+
 function assertYieldsWereCleared(caller) {
   const actualYields = SchedulerMock.unstable_clearLog();
   if (actualYields.length !== 0) {
@@ -110,6 +112,14 @@ ${diff(expectedLog, actualLog)}
   throw error;
 }
 
+function aggregateErrors(errors: Array<mixed>): mixed {
+  if (errors.length > 1 && typeof AggregateError === 'function') {
+    // eslint-disable-next-line no-undef
+    return new AggregateError(errors);
+  }
+  return errors[0];
+}
+
 export async function waitForThrow(expectedError: mixed): mixed {
   assertYieldsWereCleared(waitForThrow);
 
@@ -126,31 +136,72 @@ export async function waitForThrow(expectedError: mixed): mixed {
       error.message = 'Expected something to throw, but nothing did.';
       throw error;
     }
+
+    const errorHandlerDOM = function (event: ErrorEvent) {
+      // Prevent logs from reprinting this error.
+      event.preventDefault();
+      thrownErrors.push(event.error);
+    };
+    const errorHandlerNode = function (err: mixed) {
+      thrownErrors.push(err);
+    };
+    // We track errors that were logged globally as if they occurred in this scope and then rethrow them.
+    if (actingUpdatesScopeDepth === 0) {
+      if (
+        typeof window === 'object' &&
+        typeof window.addEventListener === 'function'
+      ) {
+        // We're in a JS DOM environment.
+        window.addEventListener('error', errorHandlerDOM);
+      } else if (typeof process === 'object') {
+        // Node environment
+        process.on('uncaughtException', errorHandlerNode);
+      }
+    }
     try {
       SchedulerMock.unstable_flushAllWithoutAsserting();
     } catch (x) {
+      thrownErrors.push(x);
+    } finally {
+      if (actingUpdatesScopeDepth === 0) {
+        if (
+          typeof window === 'object' &&
+          typeof window.addEventListener === 'function'
+        ) {
+          // We're in a JS DOM environment.
+          window.removeEventListener('error', errorHandlerDOM);
+        } else if (typeof process === 'object') {
+          // Node environment
+          process.off('uncaughtException', errorHandlerNode);
+        }
+      }
+    }
+    if (thrownErrors.length > 0) {
+      const thrownError = aggregateErrors(thrownErrors);
+      thrownErrors.length = 0;
+
       if (expectedError === undefined) {
         // If no expected error was provided, then assume the caller is OK with
         // any error being thrown. We're returning the error so they can do
         // their own checks, if they wish.
-        return x;
+        return thrownError;
       }
-      if (equals(x, expectedError)) {
-        return x;
+      if (equals(thrownError, expectedError)) {
+        return thrownError;
       }
       if (
         typeof expectedError === 'string' &&
-        typeof x === 'object' &&
-        x !== null &&
-        typeof x.message === 'string'
+        typeof thrownError === 'object' &&
+        thrownError !== null &&
+        typeof thrownError.message === 'string'
       ) {
-        if (x.message.includes(expectedError)) {
-          return x;
+        if (thrownError.message.includes(expectedError)) {
+          return thrownError;
         } else {
           error.message = `
 Expected error was not thrown.
 
-${diff(expectedError, x.message)}
+${diff(expectedError, thrownError.message)}
 `;
           throw error;
         }
@@ -158,7 +209,7 @@ ${diff(expectedError, x.message)}
       error.message = `
 Expected error was not thrown.
 
-${diff(expectedError, x)}
+${diff(expectedError, thrownError)}
 `;
       throw error;
     }
diff --git a/packages/internal-test-utils/internalAct.js b/packages/internal-test-utils/internalAct.js
index 082be156dc89b..7b22c44697e36 100644
--- a/packages/internal-test-utils/internalAct.js
+++ b/packages/internal-test-utils/internalAct.js
@@ -20,7 +20,9 @@ import * as Scheduler from 'scheduler/unstable_mock';
 
 import enqueueTask from './enqueueTask';
 
-let actingUpdatesScopeDepth: number = 0;
+export let actingUpdatesScopeDepth: number = 0;
+
+export const thrownErrors: Array<mixed> = [];
 
 async function waitForMicrotasks() {
   return new Promise(resolve => {
@@ -28,6 +30,14 @@ async function waitForMicrotasks() {
   });
 }
 
+function aggregateErrors(errors: Array<mixed>): mixed {
+  if (errors.length > 1 && typeof AggregateError === 'function') {
+    // eslint-disable-next-line no-undef
+    return new AggregateError(errors);
+  }
+  return errors[0];
+}
+
 export async function act<T>(scope: () => Thenable<T>): Thenable<T> {
   if (Scheduler.unstable_flushUntilNextPaint === undefined) {
     throw Error(
@@ -63,6 +73,28 @@ export async function act<T>(scope: () => Thenable<T>): Thenable<T> {
   // public version of `act`, though we maybe should in the future.
   await waitForMicrotasks();
 
+  const errorHandlerDOM = function (event: ErrorEvent) {
+    // Prevent logs from reprinting this error.
+    event.preventDefault();
+    thrownErrors.push(event.error);
+  };
+  const errorHandlerNode = function (err: mixed) {
+    thrownErrors.push(err);
+  };
+  // We track errors that were logged globally as if they occurred in this scope and then rethrow them.
+  if (actingUpdatesScopeDepth === 1) {
+    if (
+      typeof window === 'object' &&
+      typeof window.addEventListener === 'function'
+    ) {
+      // We're in a JS DOM environment.
+      window.addEventListener('error', errorHandlerDOM);
+    } else if (typeof process === 'object') {
+      // Node environment
+      process.on('uncaughtException', errorHandlerNode);
+    }
+  }
+
   try {
     const result = await scope();
 
@@ -106,10 +138,27 @@ export async function act<T>(scope: () => Thenable<T>): Thenable<T> {
       Scheduler.unstable_flushUntilNextPaint();
     } while (true);
 
+    if (thrownErrors.length > 0) {
+      // Rethrow any errors logged by the global error handling.
+      const thrownError = aggregateErrors(thrownErrors);
+      thrownErrors.length = 0;
+      throw thrownError;
+    }
+
     return result;
   } finally {
     const depth = actingUpdatesScopeDepth;
     if (depth === 1) {
+      if (
+        typeof window === 'object' &&
+        typeof window.addEventListener === 'function'
+      ) {
+        // We're in a JS DOM environment.
+        window.removeEventListener('error', errorHandlerDOM);
+      } else if (typeof process === 'object') {
+        // Node environment
+        process.off('uncaughtException', errorHandlerNode);
+      }
       global.IS_REACT_ACT_ENVIRONMENT = previousIsActEnvironment;
     }
     actingUpdatesScopeDepth = depth - 1;
diff --git a/packages/jest-react/package.json b/packages/jest-react/package.json
index f51b4c7503c8d..ca872bf1c9bdf 100644
--- a/packages/jest-react/package.json
+++ b/packages/jest-react/package.json
@@ -20,8 +20,8 @@
   "homepage": "https://react.dev/",
   "peerDependencies": {
     "jest": "^23.0.1 || ^24.0.0 || ^25.1.0 || ^26.0.0 || ^27.0.0 || ^28.0.0 || ^29.0.0",
-    "react": "^18.2.0",
-    "react-test-renderer": "^18.2.0"
+    "react": "^19.0.0",
+    "react-test-renderer": "^19.0.0"
   },
   "files": [
     "LICENSE",
diff --git a/packages/react-art/package.json b/packages/react-art/package.json
index 56824432539ac..386bd57237d94 100644
--- a/packages/react-art/package.json
+++ b/packages/react-art/package.json
@@ -1,7 +1,7 @@
 {
   "name": "react-art",
   "description": "React ART is a JavaScript library for drawing vector graphics using React. It provides declarative and reactive bindings to the ART library. Using the same declarative API you can render the output to either Canvas, SVG or VML (IE8).",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
     "scheduler": "^0.23.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0"
+    "react": "^19.0.0"
   },
   "files": [
     "LICENSE",
diff --git a/packages/react-client/src/ReactFlightClient.js b/packages/react-client/src/ReactFlightClient.js
index 63342962e2a08..435ee06aac44b 100644
--- a/packages/react-client/src/ReactFlightClient.js
+++ b/packages/react-client/src/ReactFlightClient.js
@@ -35,6 +35,8 @@ import type {
 
 import type {Postpone} from 'react/src/ReactPostpone';
 
+import type {TemporaryReferenceSet} from './ReactFlightTemporaryReferences';
+
 import {
   enableBinaryFlight,
   enablePostpone,
@@ -55,6 +57,8 @@ import {
 
 import {registerServerReference} from './ReactFlightReplyClient';
 
+import {readTemporaryReference} from './ReactFlightTemporaryReferences';
+
 import {
   REACT_LAZY_TYPE,
   REACT_ELEMENT_TYPE,
@@ -224,6 +228,7 @@ export type Response = {
   _rowTag: number, // 0 indicates that we're currently parsing the row ID
   _rowLength: number, // remaining bytes in the row. 0 indicates that we're looking for a newline.
   _buffer: Array<Uint8Array>, // chunks received so far as part of this row
+  _tempRefs: void | TemporaryReferenceSet, // the set temporary references can be resolved from
 };
 
 function readChunk<T>(chunk: SomeChunk<T>): T {
@@ -689,6 +694,18 @@ function parseModelString(
         const metadata = getOutlinedModel(response, id);
         return createServerReferenceProxy(response, metadata);
       }
+      case 'T': {
+        // Temporary Reference
+        const id = parseInt(value.slice(2), 16);
+        const temporaryReferences = response._tempRefs;
+        if (temporaryReferences == null) {
+          throw new Error(
+            'Missing a temporary reference set but the RSC response returned a temporary reference. ' +
+              'Pass a temporaryReference option with the set that was used with the reply.',
+          );
+        }
+        return readTemporaryReference(temporaryReferences, id);
+      }
       case 'Q': {
         // Map
         const id = parseInt(value.slice(2), 16);
@@ -837,6 +854,7 @@ export function createResponse(
   callServer: void | CallServerCallback,
   encodeFormAction: void | EncodeFormActionCallback,
   nonce: void | string,
+  temporaryReferences: void | TemporaryReferenceSet,
 ): Response {
   const chunks: Map<number, SomeChunk<any>> = new Map();
   const response: Response = {
@@ -853,6 +871,7 @@ export function createResponse(
     _rowTag: 0,
     _rowLength: 0,
     _buffer: [],
+    _tempRefs: temporaryReferences,
   };
   // Don't inline this call because it causes closure to outline the call above.
   response._fromJSON = createFromJSONCallback(response);
diff --git a/packages/react-client/src/ReactFlightReplyClient.js b/packages/react-client/src/ReactFlightReplyClient.js
index 6bae3d1a14de5..e3d19319c2f45 100644
--- a/packages/react-client/src/ReactFlightReplyClient.js
+++ b/packages/react-client/src/ReactFlightReplyClient.js
@@ -14,6 +14,9 @@ import type {
   RejectedThenable,
   ReactCustomFormAction,
 } from 'shared/ReactTypes';
+import type {LazyComponent} from 'react/src/ReactLazy';
+import type {TemporaryReferenceSet} from './ReactFlightTemporaryReferences';
+
 import {enableRenderableContext} from 'shared/ReactFeatureFlags';
 
 import {
@@ -30,6 +33,8 @@ import {
   objectName,
 } from 'shared/ReactSerializationErrors';
 
+import {writeTemporaryReference} from './ReactFlightTemporaryReferences';
+
 import isArray from 'shared/isArray';
 import getPrototypeOf from 'shared/getPrototypeOf';
 
@@ -84,9 +89,9 @@ export type ReactServerValue =
 
 type ReactServerObject = {+[key: string]: ReactServerValue};
 
-// function serializeByValueID(id: number): string {
-//   return '$' + id.toString(16);
-// }
+function serializeByValueID(id: number): string {
+  return '$' + id.toString(16);
+}
 
 function serializePromiseID(id: number): string {
   return '$@' + id.toString(16);
@@ -96,8 +101,8 @@ function serializeServerReferenceID(id: number): string {
   return '$F' + id.toString(16);
 }
 
-function serializeSymbolReference(name: string): string {
-  return '$S' + name;
+function serializeTemporaryReferenceID(id: number): string {
+  return '$T' + id.toString(16);
 }
 
 function serializeFormDataReference(id: number): string {
@@ -158,6 +163,7 @@ function escapeStringValue(value: string): string {
 export function processReply(
   root: ReactServerValue,
   formFieldPrefix: string,
+  temporaryReferences: void | TemporaryReferenceSet,
   resolve: (string | FormData) => void,
   reject: (error: mixed) => void,
 ): void {
@@ -206,6 +212,81 @@ export function processReply(
     }
 
     if (typeof value === 'object') {
+      switch ((value: any).$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          if (temporaryReferences === undefined) {
+            throw new Error(
+              'React Element cannot be passed to Server Functions from the Client without a ' +
+                'temporary reference set. Pass a TemporaryReferenceSet to the options.' +
+                (__DEV__ ? describeObjectForErrorMessage(parent, key) : ''),
+            );
+          }
+          return serializeTemporaryReferenceID(
+            writeTemporaryReference(temporaryReferences, value),
+          );
+        }
+        case REACT_LAZY_TYPE: {
+          // Resolve lazy as if it wasn't here. In the future this will be encoded as a Promise.
+          const lazy: LazyComponent<any, any> = (value: any);
+          const payload = lazy._payload;
+          const init = lazy._init;
+          if (formData === null) {
+            // Upgrade to use FormData to allow us to stream this value.
+            formData = new FormData();
+          }
+          pendingParts++;
+          try {
+            const resolvedModel = init(payload);
+            // We always outline this as a separate part even though we could inline it
+            // because it ensures a more deterministic encoding.
+            const lazyId = nextPartId++;
+            const partJSON = JSON.stringify(resolvedModel, resolveToJSON);
+            // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+            const data: FormData = formData;
+            // eslint-disable-next-line react-internal/safe-string-coercion
+            data.append(formFieldPrefix + lazyId, partJSON);
+            return serializeByValueID(lazyId);
+          } catch (x) {
+            if (
+              typeof x === 'object' &&
+              x !== null &&
+              typeof x.then === 'function'
+            ) {
+              // Suspended
+              pendingParts++;
+              const lazyId = nextPartId++;
+              const thenable: Thenable<any> = (x: any);
+              const retry = function () {
+                // While the first promise resolved, its value isn't necessarily what we'll
+                // resolve into because we might suspend again.
+                try {
+                  const partJSON = JSON.stringify(value, resolveToJSON);
+                  // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+                  const data: FormData = formData;
+                  // eslint-disable-next-line react-internal/safe-string-coercion
+                  data.append(formFieldPrefix + lazyId, partJSON);
+                  pendingParts--;
+                  if (pendingParts === 0) {
+                    resolve(data);
+                  }
+                } catch (reason) {
+                  reject(reason);
+                }
+              };
+              thenable.then(retry, retry);
+              return serializeByValueID(lazyId);
+            } else {
+              // In the future we could consider serializing this as an error
+              // that throws on the server instead.
+              reject(x);
+              return null;
+            }
+          } finally {
+            pendingParts--;
+          }
+        }
+      }
+
       // $FlowFixMe[method-unbinding]
       if (typeof value.then === 'function') {
         // We assume that any object with a .then property is a "Thenable" type,
@@ -219,14 +300,18 @@ export function processReply(
         const thenable: Thenable<any> = (value: any);
         thenable.then(
           partValue => {
-            const partJSON = JSON.stringify(partValue, resolveToJSON);
-            // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
-            const data: FormData = formData;
-            // eslint-disable-next-line react-internal/safe-string-coercion
-            data.append(formFieldPrefix + promiseId, partJSON);
-            pendingParts--;
-            if (pendingParts === 0) {
-              resolve(data);
+            try {
+              const partJSON = JSON.stringify(partValue, resolveToJSON);
+              // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+              const data: FormData = formData;
+              // eslint-disable-next-line react-internal/safe-string-coercion
+              data.append(formFieldPrefix + promiseId, partJSON);
+              pendingParts--;
+              if (pendingParts === 0) {
+                resolve(data);
+              }
+            } catch (reason) {
+              reject(reason);
             }
           },
           reason => {
@@ -288,23 +373,19 @@ export function processReply(
         proto !== ObjectPrototype &&
         (proto === null || getPrototypeOf(proto) !== null)
       ) {
-        throw new Error(
-          'Only plain objects, and a few built-ins, can be passed to Server Actions. ' +
-            'Classes or null prototypes are not supported.',
+        if (temporaryReferences === undefined) {
+          throw new Error(
+            'Only plain objects, and a few built-ins, can be passed to Server Actions. ' +
+              'Classes or null prototypes are not supported.',
+          );
+        }
+        // We can serialize class instances as temporary references.
+        return serializeTemporaryReferenceID(
+          writeTemporaryReference(temporaryReferences, value),
         );
       }
       if (__DEV__) {
-        if ((value: any).$$typeof === REACT_ELEMENT_TYPE) {
-          console.error(
-            'React Element cannot be passed to Server Functions from the Client.%s',
-            describeObjectForErrorMessage(parent, key),
-          );
-        } else if ((value: any).$$typeof === REACT_LAZY_TYPE) {
-          console.error(
-            'React Lazy cannot be passed to Server Functions from the Client.%s',
-            describeObjectForErrorMessage(parent, key),
-          );
-        } else if (
+        if (
           (value: any).$$typeof ===
           (enableRenderableContext ? REACT_CONTEXT_TYPE : REACT_PROVIDER_TYPE)
         ) {
@@ -382,25 +463,28 @@ export function processReply(
         formData.set(formFieldPrefix + refId, metaDataJSON);
         return serializeServerReferenceID(refId);
       }
-      throw new Error(
-        'Client Functions cannot be passed directly to Server Functions. ' +
-          'Only Functions passed from the Server can be passed back again.',
+      if (temporaryReferences === undefined) {
+        throw new Error(
+          'Client Functions cannot be passed directly to Server Functions. ' +
+            'Only Functions passed from the Server can be passed back again.',
+        );
+      }
+      return serializeTemporaryReferenceID(
+        writeTemporaryReference(temporaryReferences, value),
       );
     }
 
     if (typeof value === 'symbol') {
-      // $FlowFixMe[incompatible-type] `description` might be undefined
-      const name: string = value.description;
-      if (Symbol.for(name) !== value) {
+      if (temporaryReferences === undefined) {
         throw new Error(
-          'Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' +
-            `The symbol Symbol.for(${
-              // $FlowFixMe[incompatible-type] `description` might be undefined
-              value.description
-            }) cannot be found among global symbols.`,
+          'Symbols cannot be passed to a Server Function without a ' +
+            'temporary reference set. Pass a TemporaryReferenceSet to the options.' +
+            (__DEV__ ? describeObjectForErrorMessage(parent, key) : ''),
         );
       }
-      return serializeSymbolReference(name);
+      return serializeTemporaryReferenceID(
+        writeTemporaryReference(temporaryReferences, value),
+      );
     }
 
     if (typeof value === 'bigint') {
@@ -443,6 +527,7 @@ function encodeFormData(reference: any): Thenable<FormData> {
   processReply(
     reference,
     '',
+    undefined, // TODO: This means React Elements can't be used as state in progressive enhancement.
     (body: string | FormData) => {
       if (typeof body === 'string') {
         const data = new FormData();
diff --git a/packages/react-client/src/ReactFlightTemporaryReferences.js b/packages/react-client/src/ReactFlightTemporaryReferences.js
new file mode 100644
index 0000000000000..7060562eb2291
--- /dev/null
+++ b/packages/react-client/src/ReactFlightTemporaryReferences.js
@@ -0,0 +1,41 @@
+/**
+ * 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.
+ *
+ * @flow
+ */
+
+interface Reference {}
+
+export opaque type TemporaryReferenceSet = Array<Reference | symbol>;
+
+export function createTemporaryReferenceSet(): TemporaryReferenceSet {
+  return [];
+}
+
+export function writeTemporaryReference(
+  set: TemporaryReferenceSet,
+  object: Reference | symbol,
+): number {
+  // We always create a new entry regardless if we've already written the same
+  // object. This ensures that we always generate a deterministic encoding of
+  // each slot in the reply for cacheability.
+  const newId = set.length;
+  set.push(object);
+  return newId;
+}
+
+export function readTemporaryReference<T>(
+  set: TemporaryReferenceSet,
+  id: number,
+): T {
+  if (id < 0 || id >= set.length) {
+    throw new Error(
+      "The RSC response contained a reference that doesn't exist in the temporary reference set. " +
+        'Always pass the matching set that was used to create the reply when parsing its response.',
+    );
+  }
+  return (set[id]: any);
+}
diff --git a/packages/react-client/src/forks/ReactFlightClientConfig.custom.js b/packages/react-client/src/forks/ReactFlightClientConfig.custom.js
index 45a47a8c1405f..3add5988aab8a 100644
--- a/packages/react-client/src/forks/ReactFlightClientConfig.custom.js
+++ b/packages/react-client/src/forks/ReactFlightClientConfig.custom.js
@@ -23,7 +23,7 @@
 // So `$$$config` looks like a global variable, but it's
 // really an argument to a top-level wrapping function.
 
-declare var $$$config: any;
+declare const $$$config: any;
 
 export opaque type ModuleLoading = mixed;
 export opaque type SSRModuleMap = mixed;
diff --git a/packages/react-debug-tools/src/ReactDebugHooks.js b/packages/react-debug-tools/src/ReactDebugHooks.js
index 8e1809435d724..8d7477490da21 100644
--- a/packages/react-debug-tools/src/ReactDebugHooks.js
+++ b/packages/react-debug-tools/src/ReactDebugHooks.js
@@ -16,6 +16,8 @@ import type {
   ReactDebugInfo,
 } from 'shared/ReactTypes';
 import type {
+  ContextDependency,
+  Dependencies,
   Fiber,
   Dispatcher as DispatcherType,
 } from 'react-reconciler/src/ReactInternalTypes';
@@ -33,6 +35,7 @@ import {
   REACT_MEMO_CACHE_SENTINEL,
   REACT_CONTEXT_TYPE,
 } from 'shared/ReactSymbols';
+import hasOwnProperty from 'shared/hasOwnProperty';
 
 type CurrentDispatcherRef = typeof ReactSharedInternals.ReactCurrentDispatcher;
 
@@ -103,6 +106,10 @@ function getPrimitiveStackCache(): Map<string, Array<any>> {
         // This type check is for Flow only.
         Dispatcher.useFormState((s: mixed, p: mixed) => s, null);
       }
+      if (typeof Dispatcher.useActionState === 'function') {
+        // This type check is for Flow only.
+        Dispatcher.useActionState((s: mixed, p: mixed) => s, null);
+      }
       if (typeof Dispatcher.use === 'function') {
         // This type check is for Flow only.
         Dispatcher.use(
@@ -139,6 +146,7 @@ function getPrimitiveStackCache(): Map<string, Array<any>> {
 
 let currentFiber: null | Fiber = null;
 let currentHook: null | Hook = null;
+let currentContextDependency: null | ContextDependency<mixed> = null;
 
 function nextHook(): null | Hook {
   const hook = currentHook;
@@ -149,8 +157,29 @@ function nextHook(): null | Hook {
 }
 
 function readContext<T>(context: ReactContext<T>): T {
-  // For now we don't expose readContext usage in the hooks debugging info.
-  return context._currentValue;
+  if (currentFiber === null) {
+    // Hook inspection without access to the Fiber tree
+    // e.g. when warming up the primitive stack cache or during `ReactDebugTools.inspectHooks()`.
+    return context._currentValue;
+  } else {
+    if (currentContextDependency === null) {
+      throw new Error(
+        'Context reads do not line up with context dependencies. This is a bug in React Debug Tools.',
+      );
+    }
+
+    // For now we don't expose readContext usage in the hooks debugging info.
+    const value = hasOwnProperty.call(currentContextDependency, 'memoizedValue')
+      ? // $FlowFixMe[incompatible-use] Flow thinks `hasOwnProperty` mutates `currentContextDependency`
+        ((currentContextDependency.memoizedValue: any): T)
+      : // Before React 18, we did not have `memoizedValue` so we rely on `setupContexts` in those versions.
+        // $FlowFixMe[incompatible-use] Flow thinks `hasOwnProperty` mutates `currentContextDependency`
+        ((currentContextDependency.context._currentValue: any): T);
+    // $FlowFixMe[incompatible-use] Flow thinks `hasOwnProperty` mutates `currentContextDependency`
+    currentContextDependency = currentContextDependency.next;
+
+    return value;
+  }
 }
 
 const SuspenseException: mixed = new Error(
@@ -218,14 +247,15 @@ function use<T>(usable: Usable<T>): T {
 }
 
 function useContext<T>(context: ReactContext<T>): T {
+  const value = readContext(context);
   hookLog.push({
     displayName: context.displayName || null,
     primitive: 'Context',
     stackError: new Error(),
-    value: context._currentValue,
+    value: value,
     debugInfo: null,
   });
-  return context._currentValue;
+  return value;
 }
 
 function useState<S>(
@@ -587,6 +617,75 @@ function useFormState<S, P>(
   return [state, (payload: P) => {}, false];
 }
 
+function useActionState<S, P>(
+  action: (Awaited<S>, P) => S,
+  initialState: Awaited<S>,
+  permalink?: string,
+): [Awaited<S>, (P) => void, boolean] {
+  const hook = nextHook(); // FormState
+  nextHook(); // PendingState
+  nextHook(); // ActionQueue
+  const stackError = new Error();
+  let value;
+  let debugInfo = null;
+  let error = null;
+
+  if (hook !== null) {
+    const actionResult = hook.memoizedState;
+    if (
+      typeof actionResult === 'object' &&
+      actionResult !== null &&
+      // $FlowFixMe[method-unbinding]
+      typeof actionResult.then === 'function'
+    ) {
+      const thenable: Thenable<Awaited<S>> = (actionResult: any);
+      switch (thenable.status) {
+        case 'fulfilled': {
+          value = thenable.value;
+          debugInfo =
+            thenable._debugInfo === undefined ? null : thenable._debugInfo;
+          break;
+        }
+        case 'rejected': {
+          const rejectedError = thenable.reason;
+          error = rejectedError;
+          break;
+        }
+        default:
+          // If this was an uncached Promise we have to abandon this attempt
+          // but we can still emit anything up until this point.
+          error = SuspenseException;
+          debugInfo =
+            thenable._debugInfo === undefined ? null : thenable._debugInfo;
+          value = thenable;
+      }
+    } else {
+      value = (actionResult: any);
+    }
+  } else {
+    value = initialState;
+  }
+
+  hookLog.push({
+    displayName: null,
+    primitive: 'ActionState',
+    stackError: stackError,
+    value: value,
+    debugInfo: debugInfo,
+  });
+
+  if (error !== null) {
+    throw error;
+  }
+
+  // value being a Thenable is equivalent to error being not null
+  // i.e. we only reach this point with Awaited<S>
+  const state = ((value: any): Awaited<S>);
+
+  // TODO: support displaying pending value
+  return [state, (payload: P) => {}, false];
+}
+
 const Dispatcher: DispatcherType = {
   use,
   readContext,
@@ -609,6 +708,7 @@ const Dispatcher: DispatcherType = {
   useDeferredValue,
   useId,
   useFormState,
+  useActionState,
 };
 
 // create a proxy to throw a custom error
@@ -1090,15 +1190,44 @@ export function inspectHooksOfFiber(
   currentHook = (fiber.memoizedState: Hook);
   currentFiber = fiber;
 
+  if (hasOwnProperty.call(currentFiber, 'dependencies')) {
+    // $FlowFixMe[incompatible-use]: Flow thinks hasOwnProperty might have nulled `currentFiber`
+    const dependencies = currentFiber.dependencies;
+    currentContextDependency =
+      dependencies !== null ? dependencies.firstContext : null;
+  } else if (hasOwnProperty.call(currentFiber, 'dependencies_old')) {
+    const dependencies: Dependencies = (currentFiber: any).dependencies_old;
+    currentContextDependency =
+      dependencies !== null ? dependencies.firstContext : null;
+  } else if (hasOwnProperty.call(currentFiber, 'dependencies_new')) {
+    const dependencies: Dependencies = (currentFiber: any).dependencies_new;
+    currentContextDependency =
+      dependencies !== null ? dependencies.firstContext : null;
+  } else if (hasOwnProperty.call(currentFiber, 'contextDependencies')) {
+    const contextDependencies = (currentFiber: any).contextDependencies;
+    currentContextDependency =
+      contextDependencies !== null ? contextDependencies.first : null;
+  } else {
+    throw new Error(
+      'Unsupported React version. This is a bug in React Debug Tools.',
+    );
+  }
+
   const type = fiber.type;
   let props = fiber.memoizedProps;
   if (type !== fiber.elementType) {
     props = resolveDefaultProps(type, props);
   }
 
+  // Only used for versions of React without memoized context value in context dependencies.
   const contextMap = new Map<ReactContext<any>, any>();
   try {
-    setupContexts(contextMap, fiber);
+    if (
+      currentContextDependency !== null &&
+      !hasOwnProperty.call(currentContextDependency, 'memoizedValue')
+    ) {
+      setupContexts(contextMap, fiber);
+    }
 
     if (fiber.tag === ForwardRef) {
       return inspectHooksOfForwardRef(
@@ -1113,6 +1242,7 @@ export function inspectHooksOfFiber(
   } finally {
     currentFiber = null;
     currentHook = null;
+    currentContextDependency = null;
 
     restoreContexts(contextMap);
   }
diff --git a/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js b/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js
index 0e0993268343b..0d87dbd81aaa6 100644
--- a/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js
+++ b/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js
@@ -51,7 +51,12 @@ describe('ReactHooksInspectionIntegration', () => {
         </div>
       );
     }
-    const renderer = ReactTestRenderer.create(<Foo prop="prop" />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo prop="prop" />, {
+        unstable_isConcurrent: true,
+      });
+    });
 
     let childFiber = renderer.root.findByType(Foo)._currentFiber();
     let tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
@@ -204,7 +209,9 @@ describe('ReactHooksInspectionIntegration', () => {
     }
     let renderer;
     await act(() => {
-      renderer = ReactTestRenderer.create(<Foo prop="prop" />);
+      renderer = ReactTestRenderer.create(<Foo prop="prop" />, {
+        unstable_isConcurrent: true,
+      });
     });
 
     let childFiber = renderer.root.findByType(Foo)._currentFiber();
@@ -434,7 +441,7 @@ describe('ReactHooksInspectionIntegration', () => {
           "isStateEditable": false,
           "name": "Memo",
           "subHooks": [],
-          "value": "Ab",
+          "value": "AB",
         },
         {
           "debugInfo": null,
@@ -492,7 +499,9 @@ describe('ReactHooksInspectionIntegration', () => {
     }
     let renderer;
     await act(() => {
-      renderer = ReactTestRenderer.create(<Foo prop="prop" />);
+      renderer = ReactTestRenderer.create(<Foo prop="prop" />, {
+        unstable_isConcurrent: true,
+      });
     });
 
     let childFiber = renderer.root.findByType(Foo)._currentFiber();
@@ -750,7 +759,7 @@ describe('ReactHooksInspectionIntegration', () => {
           "isStateEditable": false,
           "name": "Memo",
           "subHooks": [],
-          "value": "Ab",
+          "value": "AB",
         },
         {
           "debugInfo": null,
@@ -770,7 +779,7 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should inspect the value of the current provider in useContext', () => {
+  it('should inspect the value of the current provider in useContext', async () => {
     const MyContext = React.createContext('default');
     const ThemeContext = React.createContext('default');
     ThemeContext.displayName = 'Theme';
@@ -779,11 +788,15 @@ describe('ReactHooksInspectionIntegration', () => {
       React.useContext(ThemeContext);
       return <div>{value}</div>;
     }
-    const renderer = ReactTestRenderer.create(
-      <MyContext.Provider value="contextual">
-        <Foo prop="prop" />
-      </MyContext.Provider>,
-    );
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(
+        <MyContext.Provider value="contextual">
+          <Foo prop="prop" />
+        </MyContext.Provider>,
+        {unstable_isConcurrent: true},
+      );
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -820,14 +833,19 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should inspect forwardRef', () => {
+  it('should inspect forwardRef', async () => {
     const obj = function () {};
     const Foo = React.forwardRef(function (props, ref) {
       React.useImperativeHandle(ref, () => obj);
       return <div />;
     });
     const ref = React.createRef();
-    const renderer = ReactTestRenderer.create(<Foo ref={ref} />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo ref={ref} />, {
+        unstable_isConcurrent: true,
+      });
+    });
 
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
@@ -851,13 +869,18 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should inspect memo', () => {
+  it('should inspect memo', async () => {
     function InnerFoo(props) {
       const [value] = React.useState('hello');
       return <div>{value}</div>;
     }
     const Foo = React.memo(InnerFoo);
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     // TODO: Test renderer findByType is broken for memo. Have to search for the inner.
     const childFiber = renderer.root.findByType(InnerFoo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
@@ -881,7 +904,7 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should inspect custom hooks', () => {
+  it('should inspect custom hooks', async () => {
     function useCustom() {
       const [value] = React.useState('hello');
       return value;
@@ -890,7 +913,12 @@ describe('ReactHooksInspectionIntegration', () => {
       const value = useCustom();
       return <div>{value}</div>;
     }
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -928,14 +956,19 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should support composite useTransition hook', () => {
+  it('should support composite useTransition hook', async () => {
     function Foo(props) {
       React.useTransition();
       const memoizedValue = React.useMemo(() => 'hello', []);
       React.useMemo(() => 'not used', []);
       return <div>{memoizedValue}</div>;
     }
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -1148,14 +1181,19 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should support useDeferredValue hook', () => {
+  it('should support useDeferredValue hook', async () => {
     function Foo(props) {
       React.useDeferredValue('abc');
       const memoizedValue = React.useMemo(() => 1, []);
       React.useMemo(() => 2, []);
       return <div>{memoizedValue}</div>;
     }
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -1464,14 +1502,19 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should support useId hook', () => {
+  it('should support useId hook', async () => {
     function Foo(props) {
       const id = React.useId();
       const [state] = React.useState('hello');
       return <div id={id}>{state}</div>;
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
 
@@ -1502,7 +1545,7 @@ describe('ReactHooksInspectionIntegration', () => {
 
   describe('useMemoCache', () => {
     // @gate enableUseMemoCacheHook
-    it('should not be inspectable', () => {
+    it('should not be inspectable', async () => {
       function Foo() {
         const $ = useMemoCache(1);
         let t0;
@@ -1517,7 +1560,12 @@ describe('ReactHooksInspectionIntegration', () => {
         return t0;
       }
 
-      const renderer = ReactTestRenderer.create(<Foo />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Foo />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Foo)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
 
@@ -1525,7 +1573,7 @@ describe('ReactHooksInspectionIntegration', () => {
     });
 
     // @gate enableUseMemoCacheHook
-    it('should work in combination with other hooks', () => {
+    it('should work in combination with other hooks', async () => {
       function useSomething() {
         const [something] = React.useState(null);
         const changeOtherSomething = React.useCallback(() => {}, [something]);
@@ -1552,7 +1600,12 @@ describe('ReactHooksInspectionIntegration', () => {
         return t0;
       }
 
-      const renderer = ReactTestRenderer.create(<Foo />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Foo />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Foo)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
 
@@ -1561,7 +1614,7 @@ describe('ReactHooksInspectionIntegration', () => {
   });
 
   describe('useDebugValue', () => {
-    it('should support inspectable values for multiple custom hooks', () => {
+    it('should support inspectable values for multiple custom hooks', async () => {
       function useLabeledValue(label) {
         const [value] = React.useState(label);
         React.useDebugValue(`custom label ${label}`);
@@ -1578,7 +1631,12 @@ describe('ReactHooksInspectionIntegration', () => {
         useLabeledValue('d');
         return null;
       }
-      const renderer = ReactTestRenderer.create(<Example />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Example />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Example)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
       if (__DEV__) {
@@ -1795,7 +1853,7 @@ describe('ReactHooksInspectionIntegration', () => {
         `);
     });
 
-    it('should support inspectable values for nested custom hooks', () => {
+    it('should support inspectable values for nested custom hooks', async () => {
       function useInner() {
         React.useDebugValue('inner');
         React.useState(0);
@@ -1808,7 +1866,12 @@ describe('ReactHooksInspectionIntegration', () => {
         useOuter();
         return null;
       }
-      const renderer = ReactTestRenderer.create(<Example />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Example />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Example)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
       if (__DEV__) {
@@ -1911,7 +1974,7 @@ describe('ReactHooksInspectionIntegration', () => {
         `);
     });
 
-    it('should support multiple inspectable values per custom hooks', () => {
+    it('should support multiple inspectable values per custom hooks', async () => {
       function useMultiLabelCustom() {
         React.useDebugValue('one');
         React.useDebugValue('two');
@@ -1928,7 +1991,12 @@ describe('ReactHooksInspectionIntegration', () => {
         useSingleLabelCustom('two');
         return null;
       }
-      const renderer = ReactTestRenderer.create(<Example />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Example />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Example)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
       if (__DEV__) {
@@ -2121,18 +2189,23 @@ describe('ReactHooksInspectionIntegration', () => {
         `);
     });
 
-    it('should ignore useDebugValue() made outside of a custom hook', () => {
+    it('should ignore useDebugValue() made outside of a custom hook', async () => {
       function Example() {
         React.useDebugValue('this is invalid');
         return null;
       }
-      const renderer = ReactTestRenderer.create(<Example />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Example />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Example)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
       expect(tree).toHaveLength(0);
     });
 
-    it('should support an optional formatter function param', () => {
+    it('should support an optional formatter function param', async () => {
       function useCustom() {
         React.useDebugValue({bar: 123}, object => `bar:${object.bar}`);
         React.useState(0);
@@ -2141,7 +2214,12 @@ describe('ReactHooksInspectionIntegration', () => {
         useCustom();
         return null;
       }
-      const renderer = ReactTestRenderer.create(<Example />);
+      let renderer;
+      await act(() => {
+        renderer = ReactTestRenderer.create(<Example />, {
+          unstable_isConcurrent: true,
+        });
+      });
       const childFiber = renderer.root.findByType(Example)._currentFiber();
       const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
       if (__DEV__) {
@@ -2266,7 +2344,7 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should support an injected dispatcher', () => {
+  it('should support an injected dispatcher', async () => {
     function Foo(props) {
       const [state] = React.useState('hello world');
       return <div>{state}</div>;
@@ -2287,7 +2365,12 @@ describe('ReactHooksInspectionIntegration', () => {
       },
     };
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root._currentFiber();
 
     let didCatch = false;
@@ -2332,7 +2415,12 @@ describe('ReactHooksInspectionIntegration', () => {
       return <div>count: {data.count}</div>;
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {},
@@ -2384,7 +2472,7 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should support composite useSyncExternalStore hook', () => {
+  it('should support composite useSyncExternalStore hook', async () => {
     const useSyncExternalStore = React.useSyncExternalStore;
     function Foo() {
       const value = useSyncExternalStore(
@@ -2396,7 +2484,12 @@ describe('ReactHooksInspectionIntegration', () => {
       return value;
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -2447,7 +2540,7 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  it('should support use(Context) hook', () => {
+  it('should support use(Context) hook', async () => {
     const Context = React.createContext('default');
     function Foo() {
       const value = React.use(Context);
@@ -2457,7 +2550,12 @@ describe('ReactHooksInspectionIntegration', () => {
       return value;
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -2509,7 +2607,7 @@ describe('ReactHooksInspectionIntegration', () => {
   });
 
   // @gate enableAsyncActions
-  it('should support useOptimistic hook', () => {
+  it('should support useOptimistic hook', async () => {
     const useOptimistic = React.useOptimistic;
     function Foo() {
       const [value] = useOptimistic('abc', currentState => currentState);
@@ -2518,7 +2616,12 @@ describe('ReactHooksInspectionIntegration', () => {
       return value;
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
@@ -2569,8 +2672,8 @@ describe('ReactHooksInspectionIntegration', () => {
     `);
   });
 
-  // @gate enableFormActions && enableAsyncActions
-  it('should support useFormState hook', () => {
+  // @gate enableAsyncActions
+  it('should support useFormState hook', async () => {
     function Foo() {
       const [value] = ReactDOM.useFormState(function increment(n) {
         return n;
@@ -2581,7 +2684,12 @@ describe('ReactHooksInspectionIntegration', () => {
       return value;
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />, {
+        unstable_isConcurrent: true,
+      });
+    });
     const childFiber = renderer.root.findByType(Foo)._currentFiber();
     const tree = ReactDebugTools.inspectHooksOfFiber(childFiber);
     expect(normalizeSourceLoc(tree)).toMatchInlineSnapshot(`
diff --git a/packages/react-devtools-extensions/flow-typed/jest.js b/packages/react-devtools-extensions/flow-typed/jest.js
index 066655593abb3..cdbe32bee7ba6 100644
--- a/packages/react-devtools-extensions/flow-typed/jest.js
+++ b/packages/react-devtools-extensions/flow-typed/jest.js
@@ -960,7 +960,7 @@ declare function beforeAll(
 ): void;
 
 /** A context for grouping tests together */
-declare var describe: {
+declare const describe: {
   /**
    * Creates a block that groups together several related tests in one "test suite"
    */
@@ -991,7 +991,7 @@ declare var describe: {
 };
 
 /** An individual test unit */
-declare var it: {
+declare const it: {
   /**
    * An individual test unit
    *
@@ -1079,15 +1079,15 @@ declare function fit(
   timeout?: number
 ): void;
 /** An individual test unit */
-declare var test: typeof it;
+declare const test: typeof it;
 /** A disabled group of tests */
-declare var xdescribe: typeof describe;
+declare const xdescribe: typeof describe;
 /** A focused group of tests */
-declare var fdescribe: typeof describe;
+declare const fdescribe: typeof describe;
 /** A disabled individual test */
-declare var xit: typeof it;
+declare const xit: typeof it;
 /** A disabled individual test */
-declare var xtest: typeof it;
+declare const xtest: typeof it;
 
 type JestPrettyFormatColors = {
   comment: {close: string, open: string},
@@ -1139,7 +1139,7 @@ type JestPrettyFormatPlugin = {
 type JestPrettyFormatPlugins = Array<JestPrettyFormatPlugin>;
 
 /** The expect function is used every time you want to test a value */
-declare var expect: {
+declare const expect: {
   /** The object that you want to make assertions against */
   (
     value: any
@@ -1173,4 +1173,4 @@ declare var expect: {
 };
 
 /** Holds all functions related to manipulating test runner */
-declare var jest: JestObjectType;
+declare const jest: JestObjectType;
diff --git a/packages/react-devtools-shared/src/__tests__/inspectedElement-test.js b/packages/react-devtools-shared/src/__tests__/inspectedElement-test.js
index d579db1bdd639..f32971a1d814f 100644
--- a/packages/react-devtools-shared/src/__tests__/inspectedElement-test.js
+++ b/packages/react-devtools-shared/src/__tests__/inspectedElement-test.js
@@ -2159,7 +2159,7 @@ describe('InspectedElement', () => {
       const container = document.createElement('div');
       container.innerHTML = '<div></div>';
       withErrorsOrWarningsIgnored(
-        ['ReactDOM.hydrate is no longer supported in React 18'],
+        ['ReactDOM.hydrate has not been supported since React 18'],
         () => {
           ReactDOM.hydrate(<Example />, container);
         },
diff --git a/packages/react-devtools-shared/src/__tests__/profilingCache-test.js b/packages/react-devtools-shared/src/__tests__/profilingCache-test.js
index dbb2c1bee1467..90075ec7ea066 100644
--- a/packages/react-devtools-shared/src/__tests__/profilingCache-test.js
+++ b/packages/react-devtools-shared/src/__tests__/profilingCache-test.js
@@ -310,7 +310,8 @@ describe('ProfilingCache', () => {
   });
 
   // @reactVersion >= 16.9
-  it('should record changed props/state/context/hooks', () => {
+  // @reactVersion <= 18.2
+  it('should record changed props/state/context/hooks for React version [16.9; 18.2] with legacy context', () => {
     let instance = null;
 
     const ModernContext = React.createContext(0);
@@ -411,21 +412,6 @@ describe('ProfilingCache', () => {
         },
       }
     `);
-
-    if (gate(flags => !flags.disableLegacyContext)) {
-      expect(changeDescriptions[1].get(6).context).toEqual(['count']);
-      expect(changeDescriptions[1].get(7).props).toEqual(['count']);
-      expect(changeDescriptions[2].get(6).context).toEqual([]);
-      expect(changeDescriptions[3].get(6).context).toEqual([]);
-      expect(changeDescriptions[4].get(6).context).toEqual([]);
-
-      changeDescriptions[1].get(6).context = null;
-      changeDescriptions[1].get(7).props = [];
-      changeDescriptions[2].get(6).context = null;
-      changeDescriptions[3].get(6).context = null;
-      changeDescriptions[4].get(6).context = null;
-    }
-
     expect(changeDescriptions[1]).toMatchInlineSnapshot(`
       Map {
         5 => {
@@ -451,11 +437,15 @@ describe('ProfilingCache', () => {
           "didHooksChange": false,
           "hooks": [],
           "isFirstMount": false,
-          "props": [],
+          "props": [
+            "count",
+          ],
           "state": null,
         },
         6 => {
-          "context": null,
+          "context": [
+            "count",
+          ],
           "didHooksChange": false,
           "hooks": null,
           "isFirstMount": false,
@@ -501,7 +491,7 @@ describe('ProfilingCache', () => {
           "state": null,
         },
         6 => {
-          "context": null,
+          "context": [],
           "didHooksChange": false,
           "hooks": null,
           "isFirstMount": false,
@@ -547,7 +537,7 @@ describe('ProfilingCache', () => {
           "state": null,
         },
         6 => {
-          "context": null,
+          "context": [],
           "didHooksChange": false,
           "hooks": null,
           "isFirstMount": false,
@@ -594,7 +584,7 @@ describe('ProfilingCache', () => {
           "state": null,
         },
         6 => {
-          "context": null,
+          "context": [],
           "didHooksChange": false,
           "hooks": null,
           "isFirstMount": false,
@@ -630,6 +620,381 @@ describe('ProfilingCache', () => {
     }
   });
 
+  // @reactVersion > 18.2
+  // @gate !disableLegacyContext
+  it('should record changed props/state/context/hooks for React version (18.2; ∞) with legacy context enabled', () => {
+    let instance = null;
+
+    const ModernContext = React.createContext(0);
+
+    class LegacyContextProvider extends React.Component<any, {count: number}> {
+      static childContextTypes = {
+        count: PropTypes.number,
+      };
+      state = {count: 0};
+      getChildContext() {
+        return this.state;
+      }
+      render() {
+        instance = this;
+        return (
+          <ModernContext.Provider value={this.state.count}>
+            <React.Fragment>
+              <ModernContextConsumer />
+              <LegacyContextConsumer />
+            </React.Fragment>
+          </ModernContext.Provider>
+        );
+      }
+    }
+
+    const FunctionComponentWithHooks = ({count}) => {
+      React.useMemo(() => count, [count]);
+      return null;
+    };
+
+    class ModernContextConsumer extends React.Component<any> {
+      static contextType = ModernContext;
+      render() {
+        return <FunctionComponentWithHooks count={this.context} />;
+      }
+    }
+
+    class LegacyContextConsumer extends React.Component<any> {
+      static contextTypes = {
+        count: PropTypes.number,
+      };
+      render() {
+        return <FunctionComponentWithHooks count={this.context.count} />;
+      }
+    }
+
+    utils.act(() => store.profilerStore.startProfiling());
+    utils.act(() => render(<LegacyContextProvider />));
+    expect(instance).not.toBeNull();
+    utils.act(() => (instance: any).setState({count: 1}));
+    utils.act(() => render(<LegacyContextProvider foo={123} />));
+    utils.act(() => render(<LegacyContextProvider bar="abc" />));
+    utils.act(() => render(<LegacyContextProvider />));
+    utils.act(() => store.profilerStore.stopProfiling());
+
+    const rootID = store.roots[0];
+
+    let changeDescriptions = store.profilerStore
+      .getDataForRoot(rootID)
+      .commitData.map(commitData => commitData.changeDescriptions);
+    expect(changeDescriptions).toHaveLength(5);
+    expect(changeDescriptions[0]).toEqual(
+      new Map([
+        [
+          2,
+          {
+            context: null,
+            didHooksChange: false,
+            isFirstMount: true,
+            props: null,
+            state: null,
+          },
+        ],
+        [
+          4,
+          {
+            context: null,
+            didHooksChange: false,
+            isFirstMount: true,
+            props: null,
+            state: null,
+          },
+        ],
+        [
+          5,
+          {
+            context: null,
+            didHooksChange: false,
+            isFirstMount: true,
+            props: null,
+            state: null,
+          },
+        ],
+        [
+          6,
+          {
+            context: null,
+            didHooksChange: false,
+            isFirstMount: true,
+            props: null,
+            state: null,
+          },
+        ],
+        [
+          7,
+          {
+            context: null,
+            didHooksChange: false,
+            isFirstMount: true,
+            props: null,
+            state: null,
+          },
+        ],
+      ]),
+    );
+
+    expect(changeDescriptions[1]).toEqual(
+      new Map([
+        [
+          5,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: ['count'],
+            state: null,
+          },
+        ],
+        [
+          4,
+          {
+            context: true,
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          7,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: ['count'],
+            state: null,
+          },
+        ],
+        [
+          6,
+          {
+            context: ['count'],
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          2,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: ['count'],
+          },
+        ],
+      ]),
+    );
+
+    expect(changeDescriptions[2]).toEqual(
+      new Map([
+        [
+          5,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          4,
+          {
+            context: false,
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          7,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          6,
+          {
+            context: [],
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          2,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: ['foo'],
+            state: [],
+          },
+        ],
+      ]),
+    );
+
+    expect(changeDescriptions[3]).toEqual(
+      new Map([
+        [
+          5,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          4,
+          {
+            context: false,
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          7,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          6,
+          {
+            context: [],
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          2,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: ['foo', 'bar'],
+            state: [],
+          },
+        ],
+      ]),
+    );
+
+    expect(changeDescriptions[4]).toEqual(
+      new Map([
+        [
+          5,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          4,
+          {
+            context: false,
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          7,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          6,
+          {
+            context: [],
+            didHooksChange: false,
+            hooks: null,
+            isFirstMount: false,
+            props: [],
+            state: null,
+          },
+        ],
+        [
+          2,
+          {
+            context: null,
+            didHooksChange: false,
+            hooks: [],
+            isFirstMount: false,
+            props: ['bar'],
+            state: [],
+          },
+        ],
+      ]),
+    );
+
+    utils.exportImportHelper(bridge, store);
+
+    const prevChangeDescriptions = [...changeDescriptions];
+
+    changeDescriptions = store.profilerStore
+      .getDataForRoot(rootID)
+      .commitData.map(commitData => commitData.changeDescriptions);
+    expect(changeDescriptions).toHaveLength(5);
+
+    for (let commitIndex = 0; commitIndex < 5; commitIndex++) {
+      expect(changeDescriptions[commitIndex]).toEqual(
+        prevChangeDescriptions[commitIndex],
+      );
+    }
+  });
+
   // @reactVersion >= 18.0
   it('should properly detect changed hooks', () => {
     const Context = React.createContext(0);
diff --git a/packages/react-devtools-shared/src/__tests__/setupTests.js b/packages/react-devtools-shared/src/__tests__/setupTests.js
index e73b655cee1d3..ea9aefa588122 100644
--- a/packages/react-devtools-shared/src/__tests__/setupTests.js
+++ b/packages/react-devtools-shared/src/__tests__/setupTests.js
@@ -129,7 +129,9 @@ beforeEach(() => {
   jest.useFakeTimers();
 
   // Use utils.js#withErrorsOrWarningsIgnored instead of directly mutating this array.
-  global._ignoredErrorOrWarningMessages = [];
+  global._ignoredErrorOrWarningMessages = [
+    'react-test-renderer is deprecated.',
+  ];
   function shouldIgnoreConsoleErrorOrWarn(args) {
     let firstArg = args[0];
     if (
diff --git a/packages/react-devtools-shared/src/__tests__/treeContext-test.js b/packages/react-devtools-shared/src/__tests__/treeContext-test.js
index 185e11461bfe4..b6249cfdc4490 100644
--- a/packages/react-devtools-shared/src/__tests__/treeContext-test.js
+++ b/packages/react-devtools-shared/src/__tests__/treeContext-test.js
@@ -2586,14 +2586,14 @@ describe('TreeListContext', () => {
         utils.act(() => TestRenderer.create(<Contexts />));
 
         expect(store).toMatchInlineSnapshot(`
-          ✕ 1, ⚠ 0
+          ✕ 1, ⚠ 1
           [root]
               <ErrorBoundary> ✕
         `);
 
         selectNextErrorOrWarning();
         expect(state).toMatchInlineSnapshot(`
-          ✕ 1, ⚠ 0
+          ✕ 1, ⚠ 1
           [root]
           →    <ErrorBoundary> ✕
         `);
@@ -2648,14 +2648,14 @@ describe('TreeListContext', () => {
         utils.act(() => TestRenderer.create(<Contexts />));
 
         expect(store).toMatchInlineSnapshot(`
-          ✕ 1, ⚠ 0
+          ✕ 1, ⚠ 1
           [root]
               <ErrorBoundary> ✕
         `);
 
         selectNextErrorOrWarning();
         expect(state).toMatchInlineSnapshot(`
-          ✕ 1, ⚠ 0
+          ✕ 1, ⚠ 1
           [root]
           →    <ErrorBoundary> ✕
         `);
@@ -2705,7 +2705,7 @@ describe('TreeListContext', () => {
         utils.act(() => TestRenderer.create(<Contexts />));
 
         expect(store).toMatchInlineSnapshot(`
-          ✕ 2, ⚠ 0
+          ✕ 2, ⚠ 1
           [root]
             ▾ <ErrorBoundary> ✕
                 <Child> ✕
@@ -2713,7 +2713,7 @@ describe('TreeListContext', () => {
 
         selectNextErrorOrWarning();
         expect(state).toMatchInlineSnapshot(`
-          ✕ 2, ⚠ 0
+          ✕ 2, ⚠ 1
           [root]
           →  ▾ <ErrorBoundary> ✕
                  <Child> ✕
diff --git a/packages/react-devtools-shared/src/__tests__/utils.js b/packages/react-devtools-shared/src/__tests__/utils.js
index 2b2f98aae86f4..c0c472e6816c2 100644
--- a/packages/react-devtools-shared/src/__tests__/utils.js
+++ b/packages/react-devtools-shared/src/__tests__/utils.js
@@ -151,7 +151,7 @@ export function getLegacyRenderImplementation(): RenderImplementation {
 
   function render(elements) {
     withErrorsOrWarningsIgnored(
-      ['ReactDOM.render is no longer supported in React 18'],
+      ['ReactDOM.render has not been supported since React 18'],
       () => {
         ReactDOM.render(elements, container);
       },
@@ -340,7 +340,7 @@ export function legacyRender(elements, container) {
 
   const ReactDOM = require('react-dom');
   withErrorsOrWarningsIgnored(
-    ['ReactDOM.render is no longer supported in React 18'],
+    ['ReactDOM.render has not been supported since React 18'],
     () => {
       ReactDOM.render(elements, container);
     },
diff --git a/packages/react-devtools-shell/src/app/InspectableElements/Contexts.js b/packages/react-devtools-shell/src/app/InspectableElements/Contexts.js
index 256cd908518f2..ace7af6d55d3b 100644
--- a/packages/react-devtools-shell/src/app/InspectableElements/Contexts.js
+++ b/packages/react-devtools-shell/src/app/InspectableElements/Contexts.js
@@ -273,15 +273,46 @@ class ModernClassContextConsumerWithUpdates extends Component<any> {
   }
 }
 
+type LegacyContextState = {
+  supportsLegacyContext: boolean,
+};
+class LegacyContext extends React.Component {
+  state: LegacyContextState = {supportsLegacyContext: true};
+
+  static getDerivedStateFromError(error: any): LegacyContextState {
+    return {supportsLegacyContext: false};
+  }
+
+  componentDidCatch(error: any, info: any) {
+    console.info(
+      'Assuming legacy context is not supported in this React version due to: ',
+      error,
+      info,
+    );
+  }
+
+  render(): React.Node {
+    if (!this.state.supportsLegacyContext) {
+      return <p>This version of React does not support legacy context.</p>;
+    }
+
+    return (
+      <React.Fragment>
+        <LegacyContextProvider>
+          <LegacyContextConsumer />
+        </LegacyContextProvider>
+        <LegacyContextProviderWithUpdates />
+      </React.Fragment>
+    );
+  }
+}
+
 export default function Contexts(): React.Node {
   return (
     <div>
       <h1>Contexts</h1>
       <ul>
-        <LegacyContextProvider>
-          <LegacyContextConsumer />
-        </LegacyContextProvider>
-        <LegacyContextProviderWithUpdates />
+        <LegacyContext />
         <ModernContext.Provider value={contextData}>
           <ModernContext.Consumer>
             {(value: $FlowFixMe) =>
diff --git a/packages/react-devtools-shell/src/app/index.js b/packages/react-devtools-shell/src/app/index.js
index 0dcb81ca21000..69769f80d25a6 100644
--- a/packages/react-devtools-shell/src/app/index.js
+++ b/packages/react-devtools-shell/src/app/index.js
@@ -30,7 +30,7 @@ ignoreErrors([
   'Warning: Legacy context API',
   'Warning: Unsafe lifecycle methods',
   'Warning: %s is deprecated in StrictMode.', // findDOMNode
-  'Warning: ReactDOM.render is no longer supported in React 18',
+  'Warning: ReactDOM.render was removed in React 19',
 ]);
 ignoreWarnings(['Warning: componentWillReceiveProps has been renamed']);
 ignoreLogs([]);
diff --git a/packages/react-dom-bindings/package.json b/packages/react-dom-bindings/package.json
index 71526e783a9e6..9aa4fbaa97ad5 100644
--- a/packages/react-dom-bindings/package.json
+++ b/packages/react-dom-bindings/package.json
@@ -1,7 +1,7 @@
 {
   "name": "react-dom-bindings",
   "description": "React implementation details for react-dom.",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "private": true,
   "main": "index.js",
   "repository": {
@@ -18,6 +18,6 @@
   },
   "homepage": "https://react.dev/",
   "peerDependencies": {
-    "react": "^18.2.0"
+    "react": "^19.0.0"
   }
 }
diff --git a/packages/react-dom-bindings/src/client/DOMPropertyOperations.js b/packages/react-dom-bindings/src/client/DOMPropertyOperations.js
index ad14b6498c835..867eeba4a0869 100644
--- a/packages/react-dom-bindings/src/client/DOMPropertyOperations.js
+++ b/packages/react-dom-bindings/src/client/DOMPropertyOperations.js
@@ -8,10 +8,7 @@
  */
 
 import isAttributeNameSafe from '../shared/isAttributeNameSafe';
-import {
-  enableTrustedTypesIntegration,
-  enableCustomElementPropertySupport,
-} from 'shared/ReactFeatureFlags';
+import {enableTrustedTypesIntegration} from 'shared/ReactFeatureFlags';
 import {checkAttributeStringCoercion} from 'shared/CheckStringCoercion';
 import {getFiberCurrentPropsFromNode} from './ReactDOMComponentTree';
 
@@ -73,25 +70,18 @@ export function getValueForAttributeOnCustomComponent(
           // it would be expected that they end up not having an attribute.
           return expected;
         case 'function':
-          if (enableCustomElementPropertySupport) {
-            return expected;
-          }
-          break;
+          return expected;
         case 'boolean':
-          if (enableCustomElementPropertySupport) {
-            if (expected === false) {
-              return expected;
-            }
+          if (expected === false) {
+            return expected;
           }
       }
       return expected === undefined ? undefined : null;
     }
     const value = node.getAttribute(name);
 
-    if (enableCustomElementPropertySupport) {
-      if (value === '' && expected === true) {
-        return true;
-      }
+    if (value === '' && expected === true) {
+      return true;
     }
 
     if (__DEV__) {
diff --git a/packages/react-dom-bindings/src/client/ReactDOMComponent.js b/packages/react-dom-bindings/src/client/ReactDOMComponent.js
index bd071b4fd17bc..715b241cdb02f 100644
--- a/packages/react-dom-bindings/src/client/ReactDOMComponent.js
+++ b/packages/react-dom-bindings/src/client/ReactDOMComponent.js
@@ -67,13 +67,9 @@ import sanitizeURL from '../shared/sanitizeURL';
 
 import {
   enableBigIntSupport,
-  enableCustomElementPropertySupport,
-  enableClientRenderFallbackOnTextMismatch,
-  enableFormActions,
   disableIEWorkarounds,
   enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM,
-  enableNewBooleanProps,
 } from 'shared/ReactFeatureFlags';
 import {
   mediaEventTypes,
@@ -82,7 +78,6 @@ import {
 
 let didWarnControlledToUncontrolled = false;
 let didWarnUncontrolledToControlled = false;
-let didWarnInvalidHydration = false;
 let didWarnFormActionType = false;
 let didWarnFormActionName = false;
 let didWarnFormActionTarget = false;
@@ -229,11 +224,9 @@ function warnForPropDifference(
   propName: string,
   serverValue: mixed,
   clientValue: mixed,
-) {
+  serverDifferences: {[propName: string]: mixed},
+): void {
   if (__DEV__) {
-    if (didWarnInvalidHydration) {
-      return;
-    }
     if (serverValue === clientValue) {
       return;
     }
@@ -244,27 +237,23 @@ function warnForPropDifference(
     if (normalizedServerValue === normalizedClientValue) {
       return;
     }
-    didWarnInvalidHydration = true;
-    console.error(
-      'Prop `%s` did not match. Server: %s Client: %s',
-      propName,
-      JSON.stringify(normalizedServerValue),
-      JSON.stringify(normalizedClientValue),
-    );
+
+    serverDifferences[propName] = serverValue;
   }
 }
 
-function warnForExtraAttributes(attributeNames: Set<string>) {
+function warnForExtraAttributes(
+  domElement: Element,
+  attributeNames: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
+) {
   if (__DEV__) {
-    if (didWarnInvalidHydration) {
-      return;
-    }
-    didWarnInvalidHydration = true;
-    const names = [];
-    attributeNames.forEach(function (name) {
-      names.push(name);
+    attributeNames.forEach(function (attributeName) {
+      serverDifferences[getPropNameFromAttributeName(attributeName)] =
+        attributeName === 'style'
+          ? getStylesObjectFromElement(domElement)
+          : domElement.getAttribute(attributeName);
     });
-    console.error('Extra attributes from the server: %s', names);
   }
 }
 
@@ -328,36 +317,16 @@ function normalizeMarkupForTextOrAttribute(markup: mixed): string {
     .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');
 }
 
-export function checkForUnmatchedText(
+function checkForUnmatchedText(
   serverText: string,
   clientText: string | number | bigint,
-  isConcurrentMode: boolean,
-  shouldWarnDev: boolean,
 ) {
   const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
   const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
   if (normalizedServerText === normalizedClientText) {
-    return;
-  }
-
-  if (shouldWarnDev) {
-    if (__DEV__) {
-      if (!didWarnInvalidHydration) {
-        didWarnInvalidHydration = true;
-        console.error(
-          'Text content did not match. Server: "%s" Client: "%s"',
-          normalizedServerText,
-          normalizedClientText,
-        );
-      }
-    }
-  }
-
-  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
-    // In concurrent roots, we throw when there's a text mismatch and revert to
-    // client rendering, up to the nearest Suspense boundary.
-    throw new Error('Text content does not match server-rendered HTML.');
+    return true;
   }
+  return false;
 }
 
 function noop() {}
@@ -498,71 +467,54 @@ function setProp(
       if (__DEV__) {
         validateFormActionInDevelopment(tag, key, value, props);
       }
-      if (enableFormActions) {
-        if (typeof value === 'function') {
-          // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
-          // because we'll preventDefault, but it can happen if a form is manually submitted or
-          // if someone calls stopPropagation before React gets the event.
-          // If CSP is used to block javascript: URLs that's fine too. It just won't show this
-          // error message but the URL will be logged.
-          domElement.setAttribute(
-            key,
-            // eslint-disable-next-line no-script-url
-            "javascript:throw new Error('" +
-              'A React form was unexpectedly submitted. If you called form.submit() manually, ' +
-              "consider using form.requestSubmit() instead. If you\\'re trying to use " +
-              'event.stopPropagation() in a submit event handler, consider also calling ' +
-              'event.preventDefault().' +
-              "')",
-          );
-          break;
-        } else if (typeof prevValue === 'function') {
-          // When we're switching off a Server Action that was originally hydrated.
-          // The server control these fields during SSR that are now trailing.
-          // The regular diffing doesn't apply since we compare against the previous props.
-          // Instead, we need to force them to be set to whatever they should be now.
-          // This would be a lot cleaner if we did this whole fork in the per-tag approach.
-          if (key === 'formAction') {
-            if (tag !== 'input') {
-              // Setting the name here isn't completely safe for inputs if this is switching
-              // to become a radio button. In that case we let the tag based override take
-              // control.
-              setProp(domElement, tag, 'name', props.name, props, null);
-            }
-            setProp(
-              domElement,
-              tag,
-              'formEncType',
-              props.formEncType,
-              props,
-              null,
-            );
-            setProp(
-              domElement,
-              tag,
-              'formMethod',
-              props.formMethod,
-              props,
-              null,
-            );
-            setProp(
-              domElement,
-              tag,
-              'formTarget',
-              props.formTarget,
-              props,
-              null,
-            );
-          } else {
-            setProp(domElement, tag, 'encType', props.encType, props, null);
-            setProp(domElement, tag, 'method', props.method, props, null);
-            setProp(domElement, tag, 'target', props.target, props, null);
+      if (typeof value === 'function') {
+        // Set a javascript URL that doesn't do anything. We don't expect this to be invoked
+        // because we'll preventDefault, but it can happen if a form is manually submitted or
+        // if someone calls stopPropagation before React gets the event.
+        // If CSP is used to block javascript: URLs that's fine too. It just won't show this
+        // error message but the URL will be logged.
+        domElement.setAttribute(
+          key,
+          // eslint-disable-next-line no-script-url
+          "javascript:throw new Error('" +
+            'A React form was unexpectedly submitted. If you called form.submit() manually, ' +
+            "consider using form.requestSubmit() instead. If you\\'re trying to use " +
+            'event.stopPropagation() in a submit event handler, consider also calling ' +
+            'event.preventDefault().' +
+            "')",
+        );
+        break;
+      } else if (typeof prevValue === 'function') {
+        // When we're switching off a Server Action that was originally hydrated.
+        // The server control these fields during SSR that are now trailing.
+        // The regular diffing doesn't apply since we compare against the previous props.
+        // Instead, we need to force them to be set to whatever they should be now.
+        // This would be a lot cleaner if we did this whole fork in the per-tag approach.
+        if (key === 'formAction') {
+          if (tag !== 'input') {
+            // Setting the name here isn't completely safe for inputs if this is switching
+            // to become a radio button. In that case we let the tag based override take
+            // control.
+            setProp(domElement, tag, 'name', props.name, props, null);
           }
+          setProp(
+            domElement,
+            tag,
+            'formEncType',
+            props.formEncType,
+            props,
+            null,
+          );
+          setProp(domElement, tag, 'formMethod', props.formMethod, props, null);
+          setProp(domElement, tag, 'formTarget', props.formTarget, props, null);
+        } else {
+          setProp(domElement, tag, 'encType', props.encType, props, null);
+          setProp(domElement, tag, 'method', props.method, props, null);
+          setProp(domElement, tag, 'target', props.target, props, null);
         }
       }
       if (
         value == null ||
-        (!enableFormActions && typeof value === 'function') ||
         typeof value === 'symbol' ||
         typeof value === 'boolean'
       ) {
@@ -715,24 +667,20 @@ function setProp(
       break;
     }
     // Boolean
-    case 'inert':
-      if (!enableNewBooleanProps) {
-        setValueForAttribute(domElement, key, value);
-        break;
-      } else {
-        if (__DEV__) {
-          if (value === '' && !didWarnForNewBooleanPropsWithEmptyValue[key]) {
-            didWarnForNewBooleanPropsWithEmptyValue[key] = true;
-            console.error(
-              'Received an empty string for a boolean attribute `%s`. ' +
-                'This will treat the attribute as if it were false. ' +
-                'Either pass `false` to silence this warning, or ' +
-                'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
-              key,
-            );
-          }
+    case 'inert': {
+      if (__DEV__) {
+        if (value === '' && !didWarnForNewBooleanPropsWithEmptyValue[key]) {
+          didWarnForNewBooleanPropsWithEmptyValue[key] = true;
+          console.error(
+            'Received an empty string for a boolean attribute `%s`. ' +
+              'This will treat the attribute as if it were false. ' +
+              'Either pass `false` to silence this warning, or ' +
+              'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
+            key,
+          );
         }
       }
+    }
     // fallthrough for new boolean props without the flag on
     case 'allowFullScreen':
     case 'async':
@@ -916,9 +864,7 @@ function setProp(
     }
     case 'innerText':
     case 'textContent':
-      if (enableCustomElementPropertySupport) {
-        break;
-      }
+      break;
     // Fall through
     default: {
       if (
@@ -1029,9 +975,7 @@ function setPropOnCustomElement(
     }
     case 'innerText': // Properties
     case 'textContent':
-      if (enableCustomElementPropertySupport) {
-        break;
-      }
+      break;
     // Fall through
     default: {
       if (registrationNameDependencies.hasOwnProperty(key)) {
@@ -1039,15 +983,7 @@ function setPropOnCustomElement(
           warnForInvalidEventListener(key, value);
         }
       } else {
-        if (enableCustomElementPropertySupport) {
-          setValueForPropertyOnCustomComponent(domElement, key, value);
-        } else {
-          if (typeof value === 'boolean') {
-            // Special case before the new flag is on
-            value = '' + (value: any);
-          }
-          setValueForAttribute(domElement, key, value);
-        }
+        setValueForPropertyOnCustomComponent(domElement, key, value);
       }
     }
   }
@@ -1875,18 +1811,81 @@ function getPossibleStandardName(propName: string): string | null {
   return null;
 }
 
-function diffHydratedStyles(domElement: Element, value: mixed) {
+function getPropNameFromAttributeName(attrName: string): string {
+  switch (attrName) {
+    case 'class':
+      return 'className';
+    case 'for':
+      return 'htmlFor';
+    // TODO: The rest of the aliases.
+    default:
+      return attrName;
+  }
+}
+
+export function getPropsFromElement(domElement: Element): Object {
+  const serverDifferences: {[propName: string]: mixed} = {};
+  const attributes = domElement.attributes;
+  for (let i = 0; i < attributes.length; i++) {
+    const attr = attributes[i];
+    serverDifferences[getPropNameFromAttributeName(attr.name)] =
+      attr.name.toLowerCase() === 'style'
+        ? getStylesObjectFromElement(domElement)
+        : attr.value;
+  }
+  return serverDifferences;
+}
+
+function getStylesObjectFromElement(domElement: Element): {
+  [styleName: string]: string,
+} {
+  const serverValueInObjectForm: {[prop: string]: string} = {};
+  const style = ((domElement: any): HTMLElement).style;
+  for (let i = 0; i < style.length; i++) {
+    const styleName: string = style[i];
+    // TODO: We should use the original prop value here if it is equivalent.
+    // TODO: We could use the original client capitalization if the equivalent
+    // other capitalization exists in the DOM.
+    serverValueInObjectForm[styleName] = style.getPropertyValue(styleName);
+  }
+  return serverValueInObjectForm;
+}
+
+function diffHydratedStyles(
+  domElement: Element,
+  value: mixed,
+  serverDifferences: {[propName: string]: mixed},
+): void {
   if (value != null && typeof value !== 'object') {
-    throw new Error(
-      'The `style` prop expects a mapping from style properties to values, ' +
-        "not a string. For example, style={{marginRight: spacing + 'em'}} when " +
-        'using JSX.',
-    );
+    if (__DEV__) {
+      console.error(
+        'The `style` prop expects a mapping from style properties to values, ' +
+          "not a string. For example, style={{marginRight: spacing + 'em'}} when " +
+          'using JSX.',
+      );
+    }
+    return;
   }
   if (canDiffStyleForHydrationWarning) {
-    const expectedStyle = createDangerousStringForStyles(value);
+    // First we compare the string form and see if it's equivalent.
+    // This lets us bail out on anything that used to pass in this form.
+    // It also lets us compare anything that's not parsed by this browser.
+    const clientValue = createDangerousStringForStyles(value);
     const serverValue = domElement.getAttribute('style');
-    warnForPropDifference('style', serverValue, expectedStyle);
+
+    if (serverValue === clientValue) {
+      return;
+    }
+    const normalizedClientValue =
+      normalizeMarkupForTextOrAttribute(clientValue);
+    const normalizedServerValue =
+      normalizeMarkupForTextOrAttribute(serverValue);
+    if (normalizedServerValue === normalizedClientValue) {
+      return;
+    }
+
+    // Otherwise, we create the object from the DOM for the diff view.
+    serverDifferences.style = getStylesObjectFromElement(domElement);
   }
 }
 
@@ -1896,6 +1895,7 @@ function hydrateAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -1928,7 +1928,7 @@ function hydrateAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function hydrateBooleanAttribute(
@@ -1937,6 +1937,7 @@ function hydrateBooleanAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -1964,7 +1965,7 @@ function hydrateBooleanAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function hydrateOverloadedBooleanAttribute(
@@ -1973,6 +1974,7 @@ function hydrateOverloadedBooleanAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -2012,7 +2014,7 @@ function hydrateOverloadedBooleanAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function hydrateBooleanishAttribute(
@@ -2021,6 +2023,7 @@ function hydrateBooleanishAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -2051,7 +2054,7 @@ function hydrateBooleanishAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function hydrateNumericAttribute(
@@ -2060,6 +2063,7 @@ function hydrateNumericAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -2101,7 +2105,7 @@ function hydrateNumericAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function hydratePositiveNumericAttribute(
@@ -2110,6 +2114,7 @@ function hydratePositiveNumericAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -2151,7 +2156,7 @@ function hydratePositiveNumericAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function hydrateSanitizedAttribute(
@@ -2160,6 +2165,7 @@ function hydrateSanitizedAttribute(
   attributeName: string,
   value: any,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ): void {
   extraAttributes.delete(attributeName);
   const serverValue = domElement.getAttribute(attributeName);
@@ -2193,7 +2199,7 @@ function hydrateSanitizedAttribute(
       }
     }
   }
-  warnForPropDifference(propKey, serverValue, value);
+  warnForPropDifference(propKey, serverValue, value, serverDifferences);
 }
 
 function diffHydratedCustomComponent(
@@ -2202,6 +2208,7 @@ function diffHydratedCustomComponent(
   props: Object,
   hostContext: HostContext,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ) {
   for (const propKey in props) {
     if (!props.hasOwnProperty(propKey)) {
@@ -2223,7 +2230,18 @@ function diffHydratedCustomComponent(
     }
     // Validate that the properties correspond to their expected values.
     switch (propKey) {
-      case 'children': // Checked above already
+      case 'children': {
+        if (typeof value === 'string' || typeof value === 'number') {
+          warnForPropDifference(
+            'children',
+            domElement.textContent,
+            value,
+            serverDifferences,
+          );
+        }
+        continue;
+      }
+      // Checked above already
       case 'suppressContentEditableWarning':
       case 'suppressHydrationWarning':
       case 'defaultValue':
@@ -2237,12 +2255,17 @@ function diffHydratedCustomComponent(
         const nextHtml = value ? value.__html : undefined;
         if (nextHtml != null) {
           const expectedHTML = normalizeHTML(domElement, nextHtml);
-          warnForPropDifference(propKey, serverHTML, expectedHTML);
+          warnForPropDifference(
+            propKey,
+            serverHTML,
+            expectedHTML,
+            serverDifferences,
+          );
         }
         continue;
       case 'style':
         extraAttributes.delete(propKey);
-        diffHydratedStyles(domElement, value);
+        diffHydratedStyles(domElement, value, serverDifferences);
         continue;
       case 'offsetParent':
       case 'offsetTop':
@@ -2252,30 +2275,30 @@ function diffHydratedCustomComponent(
       case 'isContentEditable':
       case 'outerText':
       case 'outerHTML':
-        if (enableCustomElementPropertySupport) {
-          extraAttributes.delete(propKey.toLowerCase());
-          if (__DEV__) {
-            console.error(
-              'Assignment to read-only property will result in a no-op: `%s`',
-              propKey,
-            );
-          }
-          continue;
-        }
-      // Fall through
-      case 'className':
-        if (enableCustomElementPropertySupport) {
-          // className is a special cased property on the server to render as an attribute.
-          extraAttributes.delete('class');
-          const serverValue = getValueForAttributeOnCustomComponent(
-            domElement,
-            'class',
-            value,
+        extraAttributes.delete(propKey.toLowerCase());
+        if (__DEV__) {
+          console.error(
+            'Assignment to read-only property will result in a no-op: `%s`',
+            propKey,
           );
-          warnForPropDifference('className', serverValue, value);
-          continue;
         }
+        continue;
       // Fall through
+      case 'className':
+        // className is a special cased property on the server to render as an attribute.
+        extraAttributes.delete('class');
+        const serverValue = getValueForAttributeOnCustomComponent(
+          domElement,
+          'class',
+          value,
+        );
+        warnForPropDifference(
+          'className',
+          serverValue,
+          value,
+          serverDifferences,
+        );
+        continue;
       default: {
         // This is a DEV-only path
         const hostContextDev: HostContextDev = (hostContext: any);
@@ -2289,12 +2312,17 @@ function diffHydratedCustomComponent(
         } else {
           extraAttributes.delete(propKey);
         }
-        const serverValue = getValueForAttributeOnCustomComponent(
+        const valueOnCustomComponent = getValueForAttributeOnCustomComponent(
           domElement,
           propKey,
           value,
         );
-        warnForPropDifference(propKey, serverValue, value);
+        warnForPropDifference(
+          propKey,
+          valueOnCustomComponent,
+          value,
+          serverDifferences,
+        );
       }
     }
   }
@@ -2313,6 +2341,7 @@ function diffHydratedGenericElement(
   props: Object,
   hostContext: HostContext,
   extraAttributes: Set<string>,
+  serverDifferences: {[propName: string]: mixed},
 ) {
   for (const propKey in props) {
     if (!props.hasOwnProperty(propKey)) {
@@ -2334,7 +2363,18 @@ function diffHydratedGenericElement(
     }
     // Validate that the properties correspond to their expected values.
     switch (propKey) {
-      case 'children': // Checked above already
+      case 'children': {
+        if (typeof value === 'string' || typeof value === 'number') {
+          warnForPropDifference(
+            'children',
+            domElement.textContent,
+            value,
+            serverDifferences,
+          );
+        }
+        continue;
+      }
+      // Checked above already
       case 'suppressContentEditableWarning':
       case 'suppressHydrationWarning':
       case 'value': // Controlled attributes are not validated
@@ -2351,11 +2391,22 @@ function diffHydratedGenericElement(
         const nextHtml = value ? value.__html : undefined;
         if (nextHtml != null) {
           const expectedHTML = normalizeHTML(domElement, nextHtml);
-          warnForPropDifference(propKey, serverHTML, expectedHTML);
+          if (serverHTML !== expectedHTML) {
+            serverDifferences[propKey] = {
+              __html: serverHTML,
+            };
+          }
         }
         continue;
       case 'className':
-        hydrateAttribute(domElement, propKey, 'class', value, extraAttributes);
+        hydrateAttribute(
+          domElement,
+          propKey,
+          'class',
+          value,
+          extraAttributes,
+          serverDifferences,
+        );
         continue;
       case 'tabIndex':
         hydrateAttribute(
@@ -2364,28 +2415,29 @@ function diffHydratedGenericElement(
           'tabindex',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'style':
         extraAttributes.delete(propKey);
-        diffHydratedStyles(domElement, value);
+        diffHydratedStyles(domElement, value, serverDifferences);
         continue;
       case 'multiple': {
         extraAttributes.delete(propKey);
         const serverValue = (domElement: any).multiple;
-        warnForPropDifference(propKey, serverValue, value);
+        warnForPropDifference(propKey, serverValue, value, serverDifferences);
         continue;
       }
       case 'muted': {
         extraAttributes.delete(propKey);
         const serverValue = (domElement: any).muted;
-        warnForPropDifference(propKey, serverValue, value);
+        warnForPropDifference(propKey, serverValue, value, serverDifferences);
         continue;
       }
       case 'autoFocus': {
         extraAttributes.delete('autofocus');
         const serverValue = (domElement: any).autofocus;
-        warnForPropDifference(propKey, serverValue, value);
+        warnForPropDifference(propKey, serverValue, value, serverDifferences);
         continue;
       }
       case 'src':
@@ -2422,6 +2474,7 @@ function diffHydratedGenericElement(
               propKey,
               null,
               extraAttributes,
+              serverDifferences,
             );
             continue;
           }
@@ -2432,38 +2485,37 @@ function diffHydratedGenericElement(
           propKey,
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'action':
-      case 'formAction':
-        if (enableFormActions) {
-          const serverValue = domElement.getAttribute(propKey);
-          if (typeof value === 'function') {
-            extraAttributes.delete(propKey.toLowerCase());
-            // The server can set these extra properties to implement actions.
-            // So we remove them from the extra attributes warnings.
-            if (propKey === 'formAction') {
-              extraAttributes.delete('name');
-              extraAttributes.delete('formenctype');
-              extraAttributes.delete('formmethod');
-              extraAttributes.delete('formtarget');
-            } else {
-              extraAttributes.delete('enctype');
-              extraAttributes.delete('method');
-              extraAttributes.delete('target');
-            }
-            // Ideally we should be able to warn if the server value was not a function
-            // however since the function can return any of these attributes any way it
-            // wants as a custom progressive enhancement, there's nothing to compare to.
-            // We can check if the function has the $FORM_ACTION property on the client
-            // and if it's not, warn, but that's an unnecessary constraint that they
-            // have to have the extra extension that doesn't do anything on the client.
-            continue;
-          } else if (serverValue === EXPECTED_FORM_ACTION_URL) {
-            extraAttributes.delete(propKey.toLowerCase());
-            warnForPropDifference(propKey, 'function', value);
-            continue;
+      case 'formAction': {
+        const serverValue = domElement.getAttribute(propKey);
+        if (typeof value === 'function') {
+          extraAttributes.delete(propKey.toLowerCase());
+          // The server can set these extra properties to implement actions.
+          // So we remove them from the extra attributes warnings.
+          if (propKey === 'formAction') {
+            extraAttributes.delete('name');
+            extraAttributes.delete('formenctype');
+            extraAttributes.delete('formmethod');
+            extraAttributes.delete('formtarget');
+          } else {
+            extraAttributes.delete('enctype');
+            extraAttributes.delete('method');
+            extraAttributes.delete('target');
           }
+          // Ideally we should be able to warn if the server value was not a function
+          // however since the function can return any of these attributes any way it
+          // wants as a custom progressive enhancement, there's nothing to compare to.
+          // We can check if the function has the $FORM_ACTION property on the client
+          // and if it's not, warn, but that's an unnecessary constraint that they
+          // have to have the extra extension that doesn't do anything on the client.
+          continue;
+        } else if (serverValue === EXPECTED_FORM_ACTION_URL) {
+          extraAttributes.delete(propKey.toLowerCase());
+          warnForPropDifference(propKey, 'function', value, serverDifferences);
+          continue;
         }
         hydrateSanitizedAttribute(
           domElement,
@@ -2471,8 +2523,10 @@ function diffHydratedGenericElement(
           propKey.toLowerCase(),
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
+      }
       case 'xlinkHref':
         hydrateSanitizedAttribute(
           domElement,
@@ -2480,6 +2534,7 @@ function diffHydratedGenericElement(
           'xlink:href',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'contentEditable': {
@@ -2490,6 +2545,7 @@ function diffHydratedGenericElement(
           'contenteditable',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2501,6 +2557,7 @@ function diffHydratedGenericElement(
           'spellcheck',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2516,6 +2573,7 @@ function diffHydratedGenericElement(
           propKey,
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2548,6 +2606,7 @@ function diffHydratedGenericElement(
           propKey.toLowerCase(),
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2559,6 +2618,7 @@ function diffHydratedGenericElement(
           propKey,
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2572,6 +2632,7 @@ function diffHydratedGenericElement(
           propKey,
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2582,6 +2643,7 @@ function diffHydratedGenericElement(
           'rowspan',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2592,6 +2654,7 @@ function diffHydratedGenericElement(
           propKey,
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       }
@@ -2602,6 +2665,7 @@ function diffHydratedGenericElement(
           'x-height',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xlinkActuate':
@@ -2611,6 +2675,7 @@ function diffHydratedGenericElement(
           'xlink:actuate',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xlinkArcrole':
@@ -2620,6 +2685,7 @@ function diffHydratedGenericElement(
           'xlink:arcrole',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xlinkRole':
@@ -2629,6 +2695,7 @@ function diffHydratedGenericElement(
           'xlink:role',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xlinkShow':
@@ -2638,6 +2705,7 @@ function diffHydratedGenericElement(
           'xlink:show',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xlinkTitle':
@@ -2647,6 +2715,7 @@ function diffHydratedGenericElement(
           'xlink:title',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xlinkType':
@@ -2656,6 +2725,7 @@ function diffHydratedGenericElement(
           'xlink:type',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xmlBase':
@@ -2665,6 +2735,7 @@ function diffHydratedGenericElement(
           'xml:base',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xmlLang':
@@ -2674,6 +2745,7 @@ function diffHydratedGenericElement(
           'xml:lang',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'xmlSpace':
@@ -2683,34 +2755,34 @@ function diffHydratedGenericElement(
           'xml:space',
           value,
           extraAttributes,
+          serverDifferences,
         );
         continue;
       case 'inert':
-        if (enableNewBooleanProps) {
-          if (__DEV__) {
-            if (
-              value === '' &&
-              !didWarnForNewBooleanPropsWithEmptyValue[propKey]
-            ) {
-              didWarnForNewBooleanPropsWithEmptyValue[propKey] = true;
-              console.error(
-                'Received an empty string for a boolean attribute `%s`. ' +
-                  'This will treat the attribute as if it were false. ' +
-                  'Either pass `false` to silence this warning, or ' +
-                  'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
-                propKey,
-              );
-            }
+        if (__DEV__) {
+          if (
+            value === '' &&
+            !didWarnForNewBooleanPropsWithEmptyValue[propKey]
+          ) {
+            didWarnForNewBooleanPropsWithEmptyValue[propKey] = true;
+            console.error(
+              'Received an empty string for a boolean attribute `%s`. ' +
+                'This will treat the attribute as if it were false. ' +
+                'Either pass `false` to silence this warning, or ' +
+                'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
+              propKey,
+            );
           }
-          hydrateBooleanAttribute(
-            domElement,
-            propKey,
-            propKey,
-            value,
-            extraAttributes,
-          );
-          continue;
         }
+        hydrateBooleanAttribute(
+          domElement,
+          propKey,
+          propKey,
+          value,
+          extraAttributes,
+          serverDifferences,
+        );
+        continue;
       // fallthrough for new boolean props without the flag on
       default: {
         if (
@@ -2754,21 +2826,19 @@ function diffHydratedGenericElement(
           value,
         );
         if (!isMismatchDueToBadCasing) {
-          warnForPropDifference(propKey, serverValue, value);
+          warnForPropDifference(propKey, serverValue, value, serverDifferences);
         }
       }
     }
   }
 }
 
-export function diffHydratedProperties(
+export function hydrateProperties(
   domElement: Element,
   tag: string,
   props: Object,
-  isConcurrentMode: boolean,
-  shouldWarnDev: boolean,
   hostContext: HostContext,
-): void {
+): boolean {
   if (__DEV__) {
     validatePropertiesInDevelopment(tag, props);
   }
@@ -2881,26 +2951,13 @@ export function diffHydratedProperties(
     typeof children === 'number' ||
     (enableBigIntSupport && typeof children === 'bigint')
   ) {
-    // $FlowFixMe[unsafe-addition] Flow doesn't want us to use `+` operator with string and bigint
-    if (domElement.textContent !== '' + children) {
-      if (props.suppressHydrationWarning !== true) {
-        checkForUnmatchedText(
-          domElement.textContent,
-          children,
-          isConcurrentMode,
-          shouldWarnDev,
-        );
-      }
-      if (!isConcurrentMode || !enableClientRenderFallbackOnTextMismatch) {
-        // We really should be patching this in the commit phase but since
-        // this only affects legacy mode hydration which is deprecated anyway
-        // we can get away with it.
-        // Host singletons get their children appended and don't use the text
-        // content mechanism.
-        if (tag !== 'body') {
-          domElement.textContent = (children: any);
-        }
-      }
+    if (
+      // $FlowFixMe[unsafe-addition] Flow doesn't want us to use `+` operator with string and bigint
+      domElement.textContent !== '' + children &&
+      props.suppressHydrationWarning !== true &&
+      !checkForUnmatchedText(domElement.textContent, children)
+    ) {
+      return false;
     }
   }
 
@@ -2917,7 +2974,17 @@ export function diffHydratedProperties(
     trapClickOnNonInteractiveElement(((domElement: any): HTMLElement));
   }
 
-  if (__DEV__ && shouldWarnDev) {
+  return true;
+}
+
+export function diffHydratedProperties(
+  domElement: Element,
+  tag: string,
+  props: Object,
+  hostContext: HostContext,
+): null | Object {
+  const serverDifferences: {[propName: string]: mixed} = {};
+  if (__DEV__) {
     const extraAttributes: Set<string> = new Set();
     const attributes = domElement.attributes;
     for (let i = 0; i < attributes.length; i++) {
@@ -2944,6 +3011,7 @@ export function diffHydratedProperties(
         props,
         hostContext,
         extraAttributes,
+        serverDifferences,
       );
     } else {
       diffHydratedGenericElement(
@@ -2952,90 +3020,47 @@ export function diffHydratedProperties(
         props,
         hostContext,
         extraAttributes,
+        serverDifferences,
       );
     }
     if (extraAttributes.size > 0 && props.suppressHydrationWarning !== true) {
-      warnForExtraAttributes(extraAttributes);
+      warnForExtraAttributes(domElement, extraAttributes, serverDifferences);
     }
   }
+  if (Object.keys(serverDifferences).length === 0) {
+    return null;
+  }
+  return serverDifferences;
 }
 
-export function diffHydratedText(
+export function hydrateText(
   textNode: Text,
   text: string,
-  isConcurrentMode: boolean,
+  parentProps: null | Object,
 ): boolean {
   const isDifferent = textNode.nodeValue !== text;
-  return isDifferent;
-}
-
-export function warnForDeletedHydratableElement(
-  parentNode: Element | Document | DocumentFragment,
-  child: Element,
-) {
-  if (__DEV__) {
-    if (didWarnInvalidHydration) {
-      return;
-    }
-    didWarnInvalidHydration = true;
-    console.error(
-      'Did not expect server HTML to contain a <%s> in <%s>.',
-      child.nodeName.toLowerCase(),
-      parentNode.nodeName.toLowerCase(),
-    );
+  if (
+    isDifferent &&
+    (parentProps === null || parentProps.suppressHydrationWarning !== true) &&
+    !checkForUnmatchedText(textNode.nodeValue, text)
+  ) {
+    return false;
   }
+  return true;
 }
 
-export function warnForDeletedHydratableText(
-  parentNode: Element | Document | DocumentFragment,
-  child: Text,
-) {
-  if (__DEV__) {
-    if (didWarnInvalidHydration) {
-      return;
-    }
-    didWarnInvalidHydration = true;
-    console.error(
-      'Did not expect server HTML to contain the text node "%s" in <%s>.',
-      child.nodeValue,
-      parentNode.nodeName.toLowerCase(),
-    );
+export function diffHydratedText(textNode: Text, text: string): null | string {
+  if (textNode.nodeValue === text) {
+    return null;
   }
-}
-
-export function warnForInsertedHydratedElement(
-  parentNode: Element | Document | DocumentFragment,
-  tag: string,
-  props: Object,
-) {
-  if (__DEV__) {
-    if (didWarnInvalidHydration) {
-      return;
-    }
-    didWarnInvalidHydration = true;
-    console.error(
-      'Expected server HTML to contain a matching <%s> in <%s>.',
-      tag,
-      parentNode.nodeName.toLowerCase(),
-    );
-  }
-}
-
-export function warnForInsertedHydratedText(
-  parentNode: Element | Document | DocumentFragment,
-  text: string,
-) {
-  if (__DEV__) {
-    if (didWarnInvalidHydration) {
-      return;
-    }
-    didWarnInvalidHydration = true;
-    console.error(
-      'Expected server HTML to contain a matching text node for "%s" in <%s>.',
-      text,
-      parentNode.nodeName.toLowerCase(),
-    );
+  const normalizedClientText = normalizeMarkupForTextOrAttribute(text);
+  const normalizedServerText = normalizeMarkupForTextOrAttribute(
+    textNode.nodeValue,
+  );
+  if (normalizedServerText === normalizedClientText) {
+    return null;
   }
+  return textNode.nodeValue;
 }
 
 export function restoreControlledState(
diff --git a/packages/react-dom-bindings/src/client/ReactDOMComponentTree.js b/packages/react-dom-bindings/src/client/ReactDOMComponentTree.js
index 7007a520b88db..39d47a369ecc6 100644
--- a/packages/react-dom-bindings/src/client/ReactDOMComponentTree.js
+++ b/packages/react-dom-bindings/src/client/ReactDOMComponentTree.js
@@ -34,7 +34,7 @@ import {
 
 import {getParentSuspenseInstance} from './ReactFiberConfigDOM';
 
-import {enableScopeAPI, enableFloat} from 'shared/ReactFeatureFlags';
+import {enableScopeAPI} from 'shared/ReactFeatureFlags';
 
 const randomKey = Math.random().toString(36).slice(2);
 const internalInstanceKey = '__reactFiber$' + randomKey;
@@ -175,7 +175,7 @@ export function getInstanceFromNode(node: Node): Fiber | null {
       tag === HostComponent ||
       tag === HostText ||
       tag === SuspenseComponent ||
-      (enableFloat ? tag === HostHoistable : false) ||
+      tag === HostHoistable ||
       tag === HostSingleton ||
       tag === HostRoot
     ) {
@@ -195,7 +195,7 @@ export function getNodeFromInstance(inst: Fiber): Instance | TextInstance {
   const tag = inst.tag;
   if (
     tag === HostComponent ||
-    (enableFloat ? tag === HostHoistable : false) ||
+    tag === HostHoistable ||
     tag === HostSingleton ||
     tag === HostText
   ) {
diff --git a/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js b/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
index b3293ea83bd8a..395392650904a 100644
--- a/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
+++ b/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
@@ -30,8 +30,6 @@ import type {
 import {NotPending} from 'react-dom-bindings/src/shared/ReactDOMFormActions';
 import {getCurrentRootHostContainer} from 'react-reconciler/src/ReactFiberHostContext';
 import {DefaultEventPriority} from 'react-reconciler/src/ReactEventPriorities';
-// TODO: Remove this deep import when we delete the legacy root API
-import {ConcurrentMode, NoMode} from 'react-reconciler/src/ReactTypeOfMode';
 
 import hasOwnProperty from 'shared/hasOwnProperty';
 import {checkAttributeStringCoercion} from 'shared/CheckStringCoercion';
@@ -54,14 +52,12 @@ import {hasRole} from './DOMAccessibilityRoles';
 import {
   setInitialProperties,
   updateProperties,
+  hydrateProperties,
+  hydrateText,
   diffHydratedProperties,
+  getPropsFromElement,
   diffHydratedText,
   trapClickOnNonInteractiveElement,
-  checkForUnmatchedText,
-  warnForDeletedHydratableElement,
-  warnForDeletedHydratableText,
-  warnForInsertedHydratedElement,
-  warnForInsertedHydratedText,
 } from './ReactDOMComponent';
 import {getSelectionInformation, restoreSelection} from './ReactInputSelection';
 import setTextContent from './setTextContent';
@@ -91,9 +87,7 @@ import {
   enableBigIntSupport,
   enableCreateEventHandleAPI,
   enableScopeAPI,
-  enableFloat,
   enableTrustedTypesIntegration,
-  enableFormActions,
   enableAsyncActions,
 } from 'shared/ReactFeatureFlags';
 import {
@@ -1041,11 +1035,7 @@ export function canHydrateInstance(
     if (element.nodeName.toLowerCase() !== type.toLowerCase()) {
       if (!inRootOrSingleton) {
         // Usually we error for mismatched tags.
-        if (
-          enableFormActions &&
-          element.nodeName === 'INPUT' &&
-          (element: any).type === 'hidden'
-        ) {
+        if (element.nodeName === 'INPUT' && (element: any).type === 'hidden') {
           // If we have extra hidden inputs, we don't mismatch. This allows us to embed
           // extra form data in the original form.
         } else {
@@ -1055,11 +1045,7 @@ export function canHydrateInstance(
       // In root or singleton parents we skip past mismatched instances.
     } else if (!inRootOrSingleton) {
       // Match
-      if (
-        enableFormActions &&
-        type === 'input' &&
-        (element: any).type === 'hidden'
-      ) {
+      if (type === 'input' && (element: any).type === 'hidden') {
         if (__DEV__) {
           checkAttributeStringCoercion(anyProps.name, 'name');
         }
@@ -1191,7 +1177,6 @@ export function canHydrateTextInstance(
 
   while (instance.nodeType !== TEXT_NODE) {
     if (
-      enableFormActions &&
       instance.nodeType === ELEMENT_NODE &&
       instance.nodeName === 'INPUT' &&
       (instance: any).type === 'hidden'
@@ -1317,8 +1302,7 @@ function getNextHydratable(node: ?Node) {
         nodeData === SUSPENSE_START_DATA ||
         nodeData === SUSPENSE_FALLBACK_START_DATA ||
         nodeData === SUSPENSE_PENDING_START_DATA ||
-        (enableFormActions &&
-          enableAsyncActions &&
+        (enableAsyncActions &&
           (nodeData === FORM_STATE_IS_MATCHING ||
             nodeData === FORM_STATE_IS_NOT_MATCHING))
       ) {
@@ -1356,6 +1340,26 @@ export function getFirstHydratableChildWithinSuspenseInstance(
   return getNextHydratable(parentInstance.nextSibling);
 }
 
+export function describeHydratableInstanceForDevWarnings(
+  instance: HydratableInstance,
+): string | {type: string, props: $ReadOnly<Props>} {
+  // Reverse engineer a pseudo react-element from hydratable instnace
+  if (instance.nodeType === ELEMENT_NODE) {
+    // Reverse engineer a set of props that can print for dev warnings
+    return {
+      type: instance.nodeName.toLowerCase(),
+      props: getPropsFromElement((instance: any)),
+    };
+  } else if (instance.nodeType === COMMENT_NODE) {
+    return {
+      type: 'Suspense',
+      props: {},
+    };
+  } else {
+    return instance.nodeValue;
+  }
+}
+
 export function validateHydratableInstance(
   type: string,
   props: Props,
@@ -1375,26 +1379,23 @@ export function hydrateInstance(
   props: Props,
   hostContext: HostContext,
   internalInstanceHandle: Object,
-  shouldWarnDev: boolean,
-): void {
+): boolean {
   precacheFiberNode(internalInstanceHandle, instance);
   // TODO: Possibly defer this until the commit phase where all the events
   // get attached.
   updateFiberProps(instance, props);
 
-  // TODO: Temporary hack to check if we're in a concurrent root. We can delete
-  // when the legacy root API is removed.
-  const isConcurrentMode =
-    ((internalInstanceHandle: Fiber).mode & ConcurrentMode) !== NoMode;
+  return hydrateProperties(instance, type, props, hostContext);
+}
 
-  diffHydratedProperties(
-    instance,
-    type,
-    props,
-    isConcurrentMode,
-    shouldWarnDev,
-    hostContext,
-  );
+// Returns a Map of properties that were different on the server.
+export function diffHydratedPropsForDevWarnings(
+  instance: Instance,
+  type: string,
+  props: Props,
+  hostContext: HostContext,
+): null | $ReadOnly<Props> {
+  return diffHydratedProperties(instance, type, props, hostContext);
 }
 
 export function validateHydratableTextInstance(
@@ -1415,16 +1416,26 @@ export function hydrateTextInstance(
   textInstance: TextInstance,
   text: string,
   internalInstanceHandle: Object,
-  shouldWarnDev: boolean,
+  parentInstanceProps: null | Props,
 ): boolean {
   precacheFiberNode(internalInstanceHandle, textInstance);
 
-  // TODO: Temporary hack to check if we're in a concurrent root. We can delete
-  // when the legacy root API is removed.
-  const isConcurrentMode =
-    ((internalInstanceHandle: Fiber).mode & ConcurrentMode) !== NoMode;
+  return hydrateText(textInstance, text, parentInstanceProps);
+}
 
-  return diffHydratedText(textInstance, text, isConcurrentMode);
+// Returns the server text if it differs from the client.
+export function diffHydratedTextForDevWarnings(
+  textInstance: TextInstance,
+  text: string,
+  parentProps: null | Props,
+): null | string {
+  if (
+    parentProps === null ||
+    parentProps[SUPPRESS_HYDRATION_WARNING] !== true
+  ) {
+    return diffHydratedText(textInstance, text);
+  }
+  return null;
 }
 
 export function hydrateSuspenseInstance(
@@ -1513,207 +1524,7 @@ export function commitHydratedSuspenseInstance(
 export function shouldDeleteUnhydratedTailInstances(
   parentType: string,
 ): boolean {
-  return (
-    !enableFormActions || (parentType !== 'form' && parentType !== 'button')
-  );
-}
-
-export function didNotMatchHydratedContainerTextInstance(
-  parentContainer: Container,
-  textInstance: TextInstance,
-  text: string,
-  isConcurrentMode: boolean,
-  shouldWarnDev: boolean,
-) {
-  checkForUnmatchedText(
-    textInstance.nodeValue,
-    text,
-    isConcurrentMode,
-    shouldWarnDev,
-  );
-}
-
-export function didNotMatchHydratedTextInstance(
-  parentType: string,
-  parentProps: Props,
-  parentInstance: Instance,
-  textInstance: TextInstance,
-  text: string,
-  isConcurrentMode: boolean,
-  shouldWarnDev: boolean,
-) {
-  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-    checkForUnmatchedText(
-      textInstance.nodeValue,
-      text,
-      isConcurrentMode,
-      shouldWarnDev,
-    );
-  }
-}
-
-export function didNotHydrateInstanceWithinContainer(
-  parentContainer: Container,
-  instance: HydratableInstance,
-) {
-  if (__DEV__) {
-    if (instance.nodeType === ELEMENT_NODE) {
-      warnForDeletedHydratableElement(parentContainer, (instance: any));
-    } else if (instance.nodeType === COMMENT_NODE) {
-      // TODO: warnForDeletedHydratableSuspenseBoundary
-    } else {
-      warnForDeletedHydratableText(parentContainer, (instance: any));
-    }
-  }
-}
-
-export function didNotHydrateInstanceWithinSuspenseInstance(
-  parentInstance: SuspenseInstance,
-  instance: HydratableInstance,
-) {
-  if (__DEV__) {
-    // $FlowFixMe[incompatible-type]: Only Element or Document can be parent nodes.
-    const parentNode: Element | Document | null = parentInstance.parentNode;
-    if (parentNode !== null) {
-      if (instance.nodeType === ELEMENT_NODE) {
-        warnForDeletedHydratableElement(parentNode, (instance: any));
-      } else if (instance.nodeType === COMMENT_NODE) {
-        // TODO: warnForDeletedHydratableSuspenseBoundary
-      } else {
-        warnForDeletedHydratableText(parentNode, (instance: any));
-      }
-    }
-  }
-}
-
-export function didNotHydrateInstance(
-  parentType: string,
-  parentProps: Props,
-  parentInstance: Instance,
-  instance: HydratableInstance,
-  isConcurrentMode: boolean,
-) {
-  if (__DEV__) {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      if (instance.nodeType === ELEMENT_NODE) {
-        warnForDeletedHydratableElement(parentInstance, (instance: any));
-      } else if (instance.nodeType === COMMENT_NODE) {
-        // TODO: warnForDeletedHydratableSuspenseBoundary
-      } else {
-        warnForDeletedHydratableText(parentInstance, (instance: any));
-      }
-    }
-  }
-}
-
-export function didNotFindHydratableInstanceWithinContainer(
-  parentContainer: Container,
-  type: string,
-  props: Props,
-) {
-  if (__DEV__) {
-    warnForInsertedHydratedElement(parentContainer, type, props);
-  }
-}
-
-export function didNotFindHydratableTextInstanceWithinContainer(
-  parentContainer: Container,
-  text: string,
-) {
-  if (__DEV__) {
-    warnForInsertedHydratedText(parentContainer, text);
-  }
-}
-
-export function didNotFindHydratableSuspenseInstanceWithinContainer(
-  parentContainer: Container,
-) {
-  if (__DEV__) {
-    // TODO: warnForInsertedHydratedSuspense(parentContainer);
-  }
-}
-
-export function didNotFindHydratableInstanceWithinSuspenseInstance(
-  parentInstance: SuspenseInstance,
-  type: string,
-  props: Props,
-) {
-  if (__DEV__) {
-    // $FlowFixMe[incompatible-type]: Only Element or Document can be parent nodes.
-    const parentNode: Element | Document | null = parentInstance.parentNode;
-    if (parentNode !== null)
-      warnForInsertedHydratedElement(parentNode, type, props);
-  }
-}
-
-export function didNotFindHydratableTextInstanceWithinSuspenseInstance(
-  parentInstance: SuspenseInstance,
-  text: string,
-) {
-  if (__DEV__) {
-    // $FlowFixMe[incompatible-type]: Only Element or Document can be parent nodes.
-    const parentNode: Element | Document | null = parentInstance.parentNode;
-    if (parentNode !== null) warnForInsertedHydratedText(parentNode, text);
-  }
-}
-
-export function didNotFindHydratableSuspenseInstanceWithinSuspenseInstance(
-  parentInstance: SuspenseInstance,
-) {
-  if (__DEV__) {
-    // const parentNode: Element | Document | null = parentInstance.parentNode;
-    // TODO: warnForInsertedHydratedSuspense(parentNode);
-  }
-}
-
-export function didNotFindHydratableInstance(
-  parentType: string,
-  parentProps: Props,
-  parentInstance: Instance,
-  type: string,
-  props: Props,
-  isConcurrentMode: boolean,
-) {
-  if (__DEV__) {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      warnForInsertedHydratedElement(parentInstance, type, props);
-    }
-  }
-}
-
-export function didNotFindHydratableTextInstance(
-  parentType: string,
-  parentProps: Props,
-  parentInstance: Instance,
-  text: string,
-  isConcurrentMode: boolean,
-) {
-  if (__DEV__) {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      warnForInsertedHydratedText(parentInstance, text);
-    }
-  }
-}
-
-export function didNotFindHydratableSuspenseInstance(
-  parentType: string,
-  parentProps: Props,
-  parentInstance: Instance,
-) {
-  if (__DEV__) {
-    // TODO: warnForInsertedHydratedSuspense(parentInstance);
-  }
-}
-
-export function errorHydratingContainer(parentContainer: Container): void {
-  if (__DEV__) {
-    // TODO: This gets logged by onRecoverableError, too, so we should be
-    // able to remove it.
-    console.error(
-      'An error occurred during hydration. The server HTML was replaced with client content in <%s>.',
-      parentContainer.nodeName.toLowerCase(),
-    );
-  }
+  return parentType !== 'form' && parentType !== 'button';
 }
 
 // -------------------
@@ -2161,25 +1972,16 @@ function preconnectAs(
 }
 
 function prefetchDNS(href: string) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.prefetchDNS(href);
   preconnectAs('dns-prefetch', href, null);
 }
 
 function preconnect(href: string, crossOrigin?: ?CrossOriginEnum) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.preconnect(href, crossOrigin);
   preconnectAs('preconnect', href, crossOrigin);
 }
 
 function preload(href: string, as: string, options?: ?PreloadImplOptions) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.preload(href, as, options);
   const ownerDocument = getGlobalDocument();
   if (ownerDocument && href && as) {
@@ -2258,9 +2060,6 @@ function preload(href: string, as: string, options?: ?PreloadImplOptions) {
 }
 
 function preloadModule(href: string, options?: ?PreloadModuleImplOptions) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.preloadModule(href, options);
   const ownerDocument = getGlobalDocument();
   if (ownerDocument && href) {
@@ -2322,9 +2121,6 @@ function preinitStyle(
   precedence: ?string,
   options?: ?PreinitStyleOptions,
 ) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.preinitStyle(href, precedence, options);
 
   const ownerDocument = getGlobalDocument();
@@ -2399,9 +2195,6 @@ function preinitStyle(
 }
 
 function preinitScript(src: string, options?: ?PreinitScriptOptions) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.preinitScript(src, options);
 
   const ownerDocument = getGlobalDocument();
@@ -2458,9 +2251,6 @@ function preinitModuleScript(
   src: string,
   options?: ?PreinitModuleScriptOptions,
 ) {
-  if (!enableFloat) {
-    return;
-  }
   previousDispatcher.preinitModuleScript(src, options);
 
   const ownerDocument = getGlobalDocument();
diff --git a/packages/react-dom-bindings/src/events/DOMPluginEventSystem.js b/packages/react-dom-bindings/src/events/DOMPluginEventSystem.js
index 5bb1fdc91150e..7e7221a6d393f 100644
--- a/packages/react-dom-bindings/src/events/DOMPluginEventSystem.js
+++ b/packages/react-dom-bindings/src/events/DOMPluginEventSystem.js
@@ -52,8 +52,6 @@ import {
   enableLegacyFBSupport,
   enableCreateEventHandleAPI,
   enableScopeAPI,
-  enableFloat,
-  enableFormActions,
 } from 'shared/ReactFeatureFlags';
 import {createEventListenerWrapperWithPriority} from './ReactDOMEventListener';
 import {
@@ -70,6 +68,8 @@ import * as SelectEventPlugin from './plugins/SelectEventPlugin';
 import * as SimpleEventPlugin from './plugins/SimpleEventPlugin';
 import * as FormActionEventPlugin from './plugins/FormActionEventPlugin';
 
+import reportGlobalError from 'shared/reportGlobalError';
+
 type DispatchListener = {
   instance: null | Fiber,
   listener: Function,
@@ -170,17 +170,15 @@ function extractEvents(
       eventSystemFlags,
       targetContainer,
     );
-    if (enableFormActions) {
-      FormActionEventPlugin.extractEvents(
-        dispatchQueue,
-        domEventName,
-        targetInst,
-        nativeEvent,
-        nativeEventTarget,
-        eventSystemFlags,
-        targetContainer,
-      );
-    }
+    FormActionEventPlugin.extractEvents(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget,
+      eventSystemFlags,
+      targetContainer,
+    );
   }
 }
 
@@ -230,9 +228,6 @@ export const nonDelegatedEvents: Set<DOMEventName> = new Set([
   ...mediaEventTypes,
 ]);
 
-let hasError: boolean = false;
-let caughtError: mixed = null;
-
 function executeDispatch(
   event: ReactSyntheticEvent,
   listener: Function,
@@ -242,12 +237,7 @@ function executeDispatch(
   try {
     listener(event);
   } catch (error) {
-    if (!hasError) {
-      hasError = true;
-      caughtError = error;
-    } else {
-      // TODO: Make sure this error gets logged somehow.
-    }
+    reportGlobalError(error);
   }
   event.currentTarget = null;
 }
@@ -289,13 +279,6 @@ export function processDispatchQueue(
     processDispatchQueueItemsInOrder(event, listeners, inCapturePhase);
     //  event system doesn't use pooling.
   }
-  // This would be a good time to rethrow if any of the event handlers threw.
-  if (hasError) {
-    const error = caughtError;
-    hasError = false;
-    caughtError = null;
-    throw error;
-  }
 }
 
 function dispatchEventsForPlugins(
@@ -647,7 +630,7 @@ export function dispatchEventForPluginEventSystem(
             if (
               parentTag === HostComponent ||
               parentTag === HostText ||
-              (enableFloat ? parentTag === HostHoistable : false) ||
+              parentTag === HostHoistable ||
               parentTag === HostSingleton
             ) {
               node = ancestorInst = parentNode;
@@ -705,7 +688,7 @@ export function accumulateSinglePhaseListeners(
     // Handle listeners that are on HostComponents (i.e. <div>)
     if (
       (tag === HostComponent ||
-        (enableFloat ? tag === HostHoistable : false) ||
+        tag === HostHoistable ||
         tag === HostSingleton) &&
       stateNode !== null
     ) {
@@ -819,7 +802,7 @@ export function accumulateTwoPhaseListeners(
     // Handle listeners that are on HostComponents (i.e. <div>)
     if (
       (tag === HostComponent ||
-        (enableFloat ? tag === HostHoistable : false) ||
+        tag === HostHoistable ||
         tag === HostSingleton) &&
       stateNode !== null
     ) {
@@ -922,7 +905,7 @@ function accumulateEnterLeaveListenersForEvent(
     }
     if (
       (tag === HostComponent ||
-        (enableFloat ? tag === HostHoistable : false) ||
+        tag === HostHoistable ||
         tag === HostSingleton) &&
       stateNode !== null
     ) {
diff --git a/packages/react-dom-bindings/src/events/ReactDOMEventReplaying.js b/packages/react-dom-bindings/src/events/ReactDOMEventReplaying.js
index 59c2920778008..5a3e6919cb364 100644
--- a/packages/react-dom-bindings/src/events/ReactDOMEventReplaying.js
+++ b/packages/react-dom-bindings/src/events/ReactDOMEventReplaying.js
@@ -46,7 +46,6 @@ import {
   runWithPriority as attemptHydrationAtPriority,
   getCurrentUpdatePriority,
 } from 'react-reconciler/src/ReactEventPriorities';
-import {enableFormActions} from 'shared/ReactFeatureFlags';
 
 // TODO: Upgrade this definition once we're on a newer version of Flow that
 // has this definition built-in.
@@ -535,72 +534,70 @@ export function retryIfBlockedOn(
     }
   }
 
-  if (enableFormActions) {
-    // Check the document if there are any queued form actions.
-    // If there's no ownerDocument, then this is the document.
-    const root = unblocked.ownerDocument || unblocked;
-    const formReplayingQueue: void | FormReplayingQueue = (root: any)
-      .$$reactFormReplay;
-    if (formReplayingQueue != null) {
-      for (let i = 0; i < formReplayingQueue.length; i += 3) {
-        const form: HTMLFormElement = formReplayingQueue[i];
-        const submitterOrAction:
-          | null
-          | HTMLInputElement
-          | HTMLButtonElement
-          | FormAction = formReplayingQueue[i + 1];
-        const formProps = getFiberCurrentPropsFromNode(form);
-        if (typeof submitterOrAction === 'function') {
-          // This action has already resolved. We're just waiting to dispatch it.
-          if (!formProps) {
-            // This was not part of this React instance. It might have been recently
-            // unblocking us from dispatching our events. So let's make sure we schedule
-            // a retry.
-            scheduleReplayQueueIfNeeded(formReplayingQueue);
-          }
-          continue;
+  // Check the document if there are any queued form actions.
+  // If there's no ownerDocument, then this is the document.
+  const root = unblocked.ownerDocument || unblocked;
+  const formReplayingQueue: void | FormReplayingQueue = (root: any)
+    .$$reactFormReplay;
+  if (formReplayingQueue != null) {
+    for (let i = 0; i < formReplayingQueue.length; i += 3) {
+      const form: HTMLFormElement = formReplayingQueue[i];
+      const submitterOrAction:
+        | null
+        | HTMLInputElement
+        | HTMLButtonElement
+        | FormAction = formReplayingQueue[i + 1];
+      const formProps = getFiberCurrentPropsFromNode(form);
+      if (typeof submitterOrAction === 'function') {
+        // This action has already resolved. We're just waiting to dispatch it.
+        if (!formProps) {
+          // This was not part of this React instance. It might have been recently
+          // unblocking us from dispatching our events. So let's make sure we schedule
+          // a retry.
+          scheduleReplayQueueIfNeeded(formReplayingQueue);
         }
-        let target: Node = form;
-        if (formProps) {
-          // This form belongs to this React instance but the submitter might
-          // not be done yet.
-          let action: null | FormAction = null;
-          const submitter = submitterOrAction;
-          if (submitter && submitter.hasAttribute('formAction')) {
-            // The submitter is the one that is responsible for the action.
-            target = submitter;
-            const submitterProps = getFiberCurrentPropsFromNode(submitter);
-            if (submitterProps) {
-              // The submitter is part of this instance.
-              action = (submitterProps: any).formAction;
-            } else {
-              const blockedOn = findInstanceBlockingTarget(target);
-              if (blockedOn !== null) {
-                // The submitter is not hydrated yet. We'll wait for it.
-                continue;
-              }
-              // The submitter must have been a part of a different React instance.
-              // Except the form isn't. We don't dispatch actions in this scenario.
-            }
-          } else {
-            action = (formProps: any).action;
-          }
-          if (typeof action === 'function') {
-            formReplayingQueue[i + 1] = action;
+        continue;
+      }
+      let target: Node = form;
+      if (formProps) {
+        // This form belongs to this React instance but the submitter might
+        // not be done yet.
+        let action: null | FormAction = null;
+        const submitter = submitterOrAction;
+        if (submitter && submitter.hasAttribute('formAction')) {
+          // The submitter is the one that is responsible for the action.
+          target = submitter;
+          const submitterProps = getFiberCurrentPropsFromNode(submitter);
+          if (submitterProps) {
+            // The submitter is part of this instance.
+            action = (submitterProps: any).formAction;
           } else {
-            // Something went wrong so let's just delete this action.
-            formReplayingQueue.splice(i, 3);
-            i -= 3;
+            const blockedOn = findInstanceBlockingTarget(target);
+            if (blockedOn !== null) {
+              // The submitter is not hydrated yet. We'll wait for it.
+              continue;
+            }
+            // The submitter must have been a part of a different React instance.
+            // Except the form isn't. We don't dispatch actions in this scenario.
           }
-          // Schedule a replay in case this unblocked something.
-          scheduleReplayQueueIfNeeded(formReplayingQueue);
-          continue;
+        } else {
+          action = (formProps: any).action;
         }
-        // Something above this target is still blocked so we can't continue yet.
-        // We're not sure if this target is actually part of this React instance
-        // yet. It could be a different React as a child but at least some parent is.
-        // We must continue for any further queued actions.
+        if (typeof action === 'function') {
+          formReplayingQueue[i + 1] = action;
+        } else {
+          // Something went wrong so let's just delete this action.
+          formReplayingQueue.splice(i, 3);
+          i -= 3;
+        }
+        // Schedule a replay in case this unblocked something.
+        scheduleReplayQueueIfNeeded(formReplayingQueue);
+        continue;
       }
+      // Something above this target is still blocked so we can't continue yet.
+      // We're not sure if this target is actually part of this React instance
+      // yet. It could be a different React as a child but at least some parent is.
+      // We must continue for any further queued actions.
     }
   }
 }
diff --git a/packages/react-dom-bindings/src/events/plugins/ChangeEventPlugin.js b/packages/react-dom-bindings/src/events/plugins/ChangeEventPlugin.js
index ff478e4a6b5d5..fff7d0a1bb8c5 100644
--- a/packages/react-dom-bindings/src/events/plugins/ChangeEventPlugin.js
+++ b/packages/react-dom-bindings/src/events/plugins/ChangeEventPlugin.js
@@ -26,10 +26,7 @@ import {updateValueIfChanged} from '../../client/inputValueTracking';
 import {setDefaultValue} from '../../client/ReactDOMInput';
 import {enqueueStateRestore} from '../ReactDOMControlledComponent';
 
-import {
-  disableInputAttributeSyncing,
-  enableCustomElementPropertySupport,
-} from 'shared/ReactFeatureFlags';
+import {disableInputAttributeSyncing} from 'shared/ReactFeatureFlags';
 import {batchedUpdates} from '../ReactDOMUpdateBatching';
 import {
   processDispatchQueue,
@@ -311,7 +308,6 @@ function extractEvents(
   } else if (shouldUseClickEvent(targetNode)) {
     getTargetInstFunc = getTargetInstForClickEvent;
   } else if (
-    enableCustomElementPropertySupport &&
     targetInst &&
     isCustomElement(targetInst.elementType, targetInst.memoizedProps)
   ) {
diff --git a/packages/react-dom-bindings/src/server/ReactDOMFlightServerHostDispatcher.js b/packages/react-dom-bindings/src/server/ReactDOMFlightServerHostDispatcher.js
index 5cd5dbfb6dbbd..64efccddedefa 100644
--- a/packages/react-dom-bindings/src/server/ReactDOMFlightServerHostDispatcher.js
+++ b/packages/react-dom-bindings/src/server/ReactDOMFlightServerHostDispatcher.js
@@ -16,8 +16,6 @@ import type {
   PreinitModuleScriptOptions,
 } from 'react-dom/src/shared/ReactDOMTypes';
 
-import {enableFloat} from 'shared/ReactFeatureFlags';
-
 import {
   emitHint,
   getHints,
@@ -40,107 +38,99 @@ ReactDOMCurrentDispatcher.current = {
 };
 
 function prefetchDNS(href: string) {
-  if (enableFloat) {
-    if (typeof href === 'string' && href) {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
-        const key = 'D|' + href;
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
-        emitHint(request, 'D', href);
-      } else {
-        previousDispatcher.prefetchDNS(href);
+  if (typeof href === 'string' && href) {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
+      const key = 'D|' + href;
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
       }
+      hints.add(key);
+      emitHint(request, 'D', href);
+    } else {
+      previousDispatcher.prefetchDNS(href);
     }
   }
 }
 
 function preconnect(href: string, crossOrigin?: ?CrossOriginEnum) {
-  if (enableFloat) {
-    if (typeof href === 'string') {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
+  if (typeof href === 'string') {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
 
-        const key = `C|${crossOrigin == null ? 'null' : crossOrigin}|${href}`;
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
-        if (typeof crossOrigin === 'string') {
-          emitHint(request, 'C', [href, crossOrigin]);
-        } else {
-          emitHint(request, 'C', href);
-        }
+      const key = `C|${crossOrigin == null ? 'null' : crossOrigin}|${href}`;
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
+      }
+      hints.add(key);
+      if (typeof crossOrigin === 'string') {
+        emitHint(request, 'C', [href, crossOrigin]);
       } else {
-        previousDispatcher.preconnect(href, crossOrigin);
+        emitHint(request, 'C', href);
       }
+    } else {
+      previousDispatcher.preconnect(href, crossOrigin);
     }
   }
 }
 
 function preload(href: string, as: string, options?: ?PreloadImplOptions) {
-  if (enableFloat) {
-    if (typeof href === 'string') {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
-        let key = 'L';
-        if (as === 'image' && options) {
-          key += getImagePreloadKey(
-            href,
-            options.imageSrcSet,
-            options.imageSizes,
-          );
-        } else {
-          key += `[${as}]${href}`;
-        }
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
+  if (typeof href === 'string') {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
+      let key = 'L';
+      if (as === 'image' && options) {
+        key += getImagePreloadKey(
+          href,
+          options.imageSrcSet,
+          options.imageSizes,
+        );
+      } else {
+        key += `[${as}]${href}`;
+      }
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
+      }
+      hints.add(key);
 
-        const trimmed = trimOptions(options);
-        if (trimmed) {
-          emitHint(request, 'L', [href, as, trimmed]);
-        } else {
-          emitHint(request, 'L', [href, as]);
-        }
+      const trimmed = trimOptions(options);
+      if (trimmed) {
+        emitHint(request, 'L', [href, as, trimmed]);
       } else {
-        previousDispatcher.preload(href, as, options);
+        emitHint(request, 'L', [href, as]);
       }
+    } else {
+      previousDispatcher.preload(href, as, options);
     }
   }
 }
 
 function preloadModule(href: string, options?: ?PreloadModuleImplOptions) {
-  if (enableFloat) {
-    if (typeof href === 'string') {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
-        const key = 'm|' + href;
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
+  if (typeof href === 'string') {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
+      const key = 'm|' + href;
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
+      }
+      hints.add(key);
 
-        const trimmed = trimOptions(options);
-        if (trimmed) {
-          return emitHint(request, 'm', [href, trimmed]);
-        } else {
-          return emitHint(request, 'm', href);
-        }
+      const trimmed = trimOptions(options);
+      if (trimmed) {
+        return emitHint(request, 'm', [href, trimmed]);
       } else {
-        previousDispatcher.preloadModule(href, options);
+        return emitHint(request, 'm', href);
       }
+    } else {
+      previousDispatcher.preloadModule(href, options);
     }
   }
 }
@@ -150,59 +140,55 @@ function preinitStyle(
   precedence: ?string,
   options?: ?PreinitStyleOptions,
 ) {
-  if (enableFloat) {
-    if (typeof href === 'string') {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
-        const key = 'S|' + href;
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
+  if (typeof href === 'string') {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
+      const key = 'S|' + href;
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
+      }
+      hints.add(key);
 
-        const trimmed = trimOptions(options);
-        if (trimmed) {
-          return emitHint(request, 'S', [
-            href,
-            typeof precedence === 'string' ? precedence : 0,
-            trimmed,
-          ]);
-        } else if (typeof precedence === 'string') {
-          return emitHint(request, 'S', [href, precedence]);
-        } else {
-          return emitHint(request, 'S', href);
-        }
+      const trimmed = trimOptions(options);
+      if (trimmed) {
+        return emitHint(request, 'S', [
+          href,
+          typeof precedence === 'string' ? precedence : 0,
+          trimmed,
+        ]);
+      } else if (typeof precedence === 'string') {
+        return emitHint(request, 'S', [href, precedence]);
       } else {
-        previousDispatcher.preinitStyle(href, precedence, options);
+        return emitHint(request, 'S', href);
       }
+    } else {
+      previousDispatcher.preinitStyle(href, precedence, options);
     }
   }
 }
 
 function preinitScript(src: string, options?: ?PreinitScriptOptions) {
-  if (enableFloat) {
-    if (typeof src === 'string') {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
-        const key = 'X|' + src;
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
+  if (typeof src === 'string') {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
+      const key = 'X|' + src;
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
+      }
+      hints.add(key);
 
-        const trimmed = trimOptions(options);
-        if (trimmed) {
-          return emitHint(request, 'X', [src, trimmed]);
-        } else {
-          return emitHint(request, 'X', src);
-        }
+      const trimmed = trimOptions(options);
+      if (trimmed) {
+        return emitHint(request, 'X', [src, trimmed]);
       } else {
-        previousDispatcher.preinitScript(src, options);
+        return emitHint(request, 'X', src);
       }
+    } else {
+      previousDispatcher.preinitScript(src, options);
     }
   }
 }
@@ -211,27 +197,25 @@ function preinitModuleScript(
   src: string,
   options?: ?PreinitModuleScriptOptions,
 ) {
-  if (enableFloat) {
-    if (typeof src === 'string') {
-      const request = resolveRequest();
-      if (request) {
-        const hints = getHints(request);
-        const key = 'M|' + src;
-        if (hints.has(key)) {
-          // duplicate hint
-          return;
-        }
-        hints.add(key);
+  if (typeof src === 'string') {
+    const request = resolveRequest();
+    if (request) {
+      const hints = getHints(request);
+      const key = 'M|' + src;
+      if (hints.has(key)) {
+        // duplicate hint
+        return;
+      }
+      hints.add(key);
 
-        const trimmed = trimOptions(options);
-        if (trimmed) {
-          return emitHint(request, 'M', [src, trimmed]);
-        } else {
-          return emitHint(request, 'M', src);
-        }
+      const trimmed = trimOptions(options);
+      if (trimmed) {
+        return emitHint(request, 'M', [src, trimmed]);
       } else {
-        previousDispatcher.preinitModuleScript(src, options);
+        return emitHint(request, 'M', src);
       }
+    } else {
+      previousDispatcher.preinitModuleScript(src, options);
     }
   }
 }
diff --git a/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js b/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
index 26f12d06b66ab..423e6aba6c839 100644
--- a/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
+++ b/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
@@ -30,11 +30,7 @@ import {Children} from 'react';
 import {
   enableBigIntSupport,
   enableFilterEmptyStringAttributesDOM,
-  enableCustomElementPropertySupport,
-  enableFloat,
-  enableFormActions,
   enableFizzExternalRuntime,
-  enableNewBooleanProps,
 } from 'shared/ReactFeatureFlags';
 
 import type {
@@ -383,11 +379,6 @@ export function createRenderState(
     );
   }
   if (enableFizzExternalRuntime) {
-    if (!enableFloat) {
-      throw new Error(
-        'enableFizzExternalRuntime without enableFloat is not supported. This should never appear in production, since it means you are using a misconfigured React bundle.',
-      );
-    }
     if (externalRuntimeConfig !== undefined) {
       if (typeof externalRuntimeConfig === 'string') {
         externalRuntimeScript = {
@@ -1045,14 +1036,43 @@ function pushAdditionalFormField(
 
 function pushAdditionalFormFields(
   target: Array<Chunk | PrecomputedChunk>,
-  formData: null | FormData,
+  formData: void | null | FormData,
 ) {
-  if (formData !== null) {
+  if (formData != null) {
     // $FlowFixMe[prop-missing]: FormData has forEach.
     formData.forEach(pushAdditionalFormField, target);
   }
 }
 
+function getCustomFormFields(
+  resumableState: ResumableState,
+  formAction: any,
+): null | ReactCustomFormAction {
+  const customAction = formAction.$$FORM_ACTION;
+  if (typeof customAction === 'function') {
+    const prefix = makeFormFieldPrefix(resumableState);
+    try {
+      return formAction.$$FORM_ACTION(prefix);
+    } catch (x) {
+      if (typeof x === 'object' && x !== null && typeof x.then === 'function') {
+        // Rethrow suspense.
+        throw x;
+      }
+      // If we fail to encode the form action for progressive enhancement for some reason,
+      // fallback to trying replaying on the client instead of failing the page. It might
+      // work there.
+      if (__DEV__) {
+        // TODO: Should this be some kind of recoverable error?
+        console.error(
+          'Failed to serialize an action for progressive enhancement:\n%s',
+          x,
+        );
+      }
+    }
+  }
+  return null;
+}
+
 function pushFormActionAttribute(
   target: Array<Chunk | PrecomputedChunk>,
   resumableState: ResumableState,
@@ -1062,9 +1082,9 @@ function pushFormActionAttribute(
   formMethod: any,
   formTarget: any,
   name: any,
-): null | FormData {
+): void | null | FormData {
   let formData = null;
-  if (enableFormActions && typeof formAction === 'function') {
+  if (typeof formAction === 'function') {
     // Function form actions cannot control the form properties
     if (__DEV__) {
       if (name !== null && !didWarnFormActionName) {
@@ -1092,12 +1112,10 @@ function pushFormActionAttribute(
         );
       }
     }
-    const customAction: ReactCustomFormAction = formAction.$$FORM_ACTION;
-    if (typeof customAction === 'function') {
+    const customFields = getCustomFormFields(resumableState, formAction);
+    if (customFields !== null) {
       // This action has a custom progressive enhancement form that can submit the form
       // back to the server if it's invoked before hydration. Such as a Server Action.
-      const prefix = makeFormFieldPrefix(resumableState);
-      const customFields = formAction.$$FORM_ACTION(prefix);
       name = customFields.name;
       formAction = customFields.action || '';
       formEncType = customFields.encType;
@@ -1404,29 +1422,27 @@ function pushAttribute(
       pushStringAttribute(target, 'xml:space', value);
       return;
     case 'inert': {
-      if (enableNewBooleanProps) {
-        if (__DEV__) {
-          if (value === '' && !didWarnForNewBooleanPropsWithEmptyValue[name]) {
-            didWarnForNewBooleanPropsWithEmptyValue[name] = true;
-            console.error(
-              'Received an empty string for a boolean attribute `%s`. ' +
-                'This will treat the attribute as if it were false. ' +
-                'Either pass `false` to silence this warning, or ' +
-                'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
-              name,
-            );
-          }
-        }
-        // Boolean
-        if (value && typeof value !== 'function' && typeof value !== 'symbol') {
-          target.push(
-            attributeSeparator,
-            stringToChunk(name),
-            attributeEmptyString,
+      if (__DEV__) {
+        if (value === '' && !didWarnForNewBooleanPropsWithEmptyValue[name]) {
+          didWarnForNewBooleanPropsWithEmptyValue[name] = true;
+          console.error(
+            'Received an empty string for a boolean attribute `%s`. ' +
+              'This will treat the attribute as if it were false. ' +
+              'Either pass `false` to silence this warning, or ' +
+              'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
+            name,
           );
         }
-        return;
       }
+      // Boolean
+      if (value && typeof value !== 'function' && typeof value !== 'symbol') {
+        target.push(
+          attributeSeparator,
+          stringToChunk(name),
+          attributeEmptyString,
+        );
+      }
+      return;
     }
     // fallthrough for new boolean props without the flag on
     default:
@@ -1860,7 +1876,7 @@ function pushStartForm(
 
   let formData = null;
   let formActionName = null;
-  if (enableFormActions && typeof formAction === 'function') {
+  if (typeof formAction === 'function') {
     // Function form actions cannot control the form properties
     if (__DEV__) {
       if (
@@ -1882,12 +1898,10 @@ function pushStartForm(
         );
       }
     }
-    const customAction: ReactCustomFormAction = formAction.$$FORM_ACTION;
-    if (typeof customAction === 'function') {
+    const customFields = getCustomFormFields(resumableState, formAction);
+    if (customFields !== null) {
       // This action has a custom progressive enhancement form that can submit the form
       // back to the server if it's invoked before hydration. Such as a Server Action.
-      const prefix = makeFormFieldPrefix(resumableState);
-      const customFields = formAction.$$FORM_ACTION(prefix);
       formAction = customFields.action || '';
       formEncType = customFields.encType;
       formMethod = customFields.method;
@@ -2308,44 +2322,40 @@ function pushMeta(
   noscriptTagInScope: boolean,
   isFallback: boolean,
 ): null {
-  if (enableFloat) {
-    if (
-      insertionMode === SVG_MODE ||
-      noscriptTagInScope ||
-      props.itemProp != null
-    ) {
-      return pushSelfClosing(target, props, 'meta');
-    } else {
-      if (textEmbedded) {
-        // This link follows text but we aren't writing a tag. while not as efficient as possible we need
-        // to be safe and assume text will follow by inserting a textSeparator
-        target.push(textSeparator);
-      }
+  if (
+    insertionMode === SVG_MODE ||
+    noscriptTagInScope ||
+    props.itemProp != null
+  ) {
+    return pushSelfClosing(target, props, 'meta');
+  } else {
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
 
-      if (isFallback) {
-        // Hoistable Elements for fallbacks are simply omitted. we don't want to emit them early
-        // because they are likely superceded by primary content and we want to avoid needing to clean
-        // them up when the primary content is ready. They are never hydrated on the client anyway because
-        // boundaries in fallback are awaited or client render, in either case there is never hydration
-        return null;
-      } else if (typeof props.charSet === 'string') {
-        // "charset" Should really be config and not picked up from tags however since this is
-        // the only way to embed the tag today we flush it on a special queue on the Request so it
-        // can go before everything else. Like viewport this means that the tag will escape it's
-        // parent container.
-        return pushSelfClosing(renderState.charsetChunks, props, 'meta');
-      } else if (props.name === 'viewport') {
-        // "viewport" is flushed on the Request so it can go earlier that Float resources that
-        // might be affected by it. This means it can escape the boundary it is rendered within.
-        // This is a pragmatic solution to viewport being incredibly sensitive to document order
-        // without requiring all hoistables to be flushed too early.
-        return pushSelfClosing(renderState.viewportChunks, props, 'meta');
-      } else {
-        return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
-      }
+    if (isFallback) {
+      // Hoistable Elements for fallbacks are simply omitted. we don't want to emit them early
+      // because they are likely superceded by primary content and we want to avoid needing to clean
+      // them up when the primary content is ready. They are never hydrated on the client anyway because
+      // boundaries in fallback are awaited or client render, in either case there is never hydration
+      return null;
+    } else if (typeof props.charSet === 'string') {
+      // "charset" Should really be config and not picked up from tags however since this is
+      // the only way to embed the tag today we flush it on a special queue on the Request so it
+      // can go before everything else. Like viewport this means that the tag will escape it's
+      // parent container.
+      return pushSelfClosing(renderState.charsetChunks, props, 'meta');
+    } else if (props.name === 'viewport') {
+      // "viewport" is flushed on the Request so it can go earlier that Float resources that
+      // might be affected by it. This means it can escape the boundary it is rendered within.
+      // This is a pragmatic solution to viewport being incredibly sensitive to document order
+      // without requiring all hoistables to be flushed too early.
+      return pushSelfClosing(renderState.viewportChunks, props, 'meta');
+    } else {
+      return pushSelfClosing(renderState.hoistableChunks, props, 'meta');
     }
-  } else {
-    return pushSelfClosing(target, props, 'meta');
   }
 }
 
@@ -2360,172 +2370,168 @@ function pushLink(
   noscriptTagInScope: boolean,
   isFallback: boolean,
 ): null {
-  if (enableFloat) {
-    const rel = props.rel;
-    const href = props.href;
-    const precedence = props.precedence;
+  const rel = props.rel;
+  const href = props.href;
+  const precedence = props.precedence;
+  if (
+    insertionMode === SVG_MODE ||
+    noscriptTagInScope ||
+    props.itemProp != null ||
+    typeof rel !== 'string' ||
+    typeof href !== 'string' ||
+    href === ''
+  ) {
+    if (__DEV__) {
+      if (rel === 'stylesheet' && typeof props.precedence === 'string') {
+        if (typeof href !== 'string' || !href) {
+          console.error(
+            'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and expected the `href` prop to be a non-empty string but ecountered %s instead. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop ensure there is a non-empty string `href` prop as well, otherwise remove the `precedence` prop.',
+            getValueDescriptorExpectingObjectForWarning(href),
+          );
+        }
+      }
+    }
+    pushLinkImpl(target, props);
+    return null;
+  }
+
+  if (props.rel === 'stylesheet') {
+    // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
+    const key = getResourceKey(href);
     if (
-      insertionMode === SVG_MODE ||
-      noscriptTagInScope ||
-      props.itemProp != null ||
-      typeof rel !== 'string' ||
-      typeof href !== 'string' ||
-      href === ''
+      typeof precedence !== 'string' ||
+      props.disabled != null ||
+      props.onLoad ||
+      props.onError
     ) {
+      // This stylesheet is either not opted into Resource semantics or has conflicting properties which
+      // disqualify it for such. We can still create a preload resource to help it load faster on the
+      // client
       if (__DEV__) {
-        if (rel === 'stylesheet' && typeof props.precedence === 'string') {
-          if (typeof href !== 'string' || !href) {
+        if (typeof precedence === 'string') {
+          if (props.disabled != null) {
             console.error(
-              'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and expected the `href` prop to be a non-empty string but ecountered %s instead. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop ensure there is a non-empty string `href` prop as well, otherwise remove the `precedence` prop.',
-              getValueDescriptorExpectingObjectForWarning(href),
+              'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and a `disabled` prop. The presence of the `disabled` prop indicates an intent to manage the stylesheet active state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the `disabled` prop, otherwise remove the `precedence` prop.',
+            );
+          } else if (props.onLoad || props.onError) {
+            const propDescription =
+              props.onLoad && props.onError
+                ? '`onLoad` and `onError` props'
+                : props.onLoad
+                ? '`onLoad` prop'
+                : '`onError` prop';
+            console.error(
+              'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and %s. The presence of loading and error handlers indicates an intent to manage the stylesheet loading state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.',
+              propDescription,
+              propDescription,
             );
           }
         }
       }
-      pushLinkImpl(target, props);
-      return null;
-    }
-
-    if (props.rel === 'stylesheet') {
-      // This <link> may hoistable as a Stylesheet Resource, otherwise it will emit in place
-      const key = getResourceKey(href);
-      if (
-        typeof precedence !== 'string' ||
-        props.disabled != null ||
-        props.onLoad ||
-        props.onError
-      ) {
-        // This stylesheet is either not opted into Resource semantics or has conflicting properties which
-        // disqualify it for such. We can still create a preload resource to help it load faster on the
-        // client
-        if (__DEV__) {
-          if (typeof precedence === 'string') {
-            if (props.disabled != null) {
-              console.error(
-                'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and a `disabled` prop. The presence of the `disabled` prop indicates an intent to manage the stylesheet active state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the `disabled` prop, otherwise remove the `precedence` prop.',
-              );
-            } else if (props.onLoad || props.onError) {
-              const propDescription =
-                props.onLoad && props.onError
-                  ? '`onLoad` and `onError` props'
-                  : props.onLoad
-                  ? '`onLoad` prop'
-                  : '`onError` prop';
-              console.error(
-                'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and %s. The presence of loading and error handlers indicates an intent to manage the stylesheet loading state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.',
-                propDescription,
-                propDescription,
-              );
-            }
-          }
-        }
-        return pushLinkImpl(target, props);
-      } else {
-        // This stylesheet refers to a Resource and we create a new one if necessary
-        let styleQueue = renderState.styles.get(precedence);
-        const hasKey = resumableState.styleResources.hasOwnProperty(key);
-        const resourceState = hasKey
-          ? resumableState.styleResources[key]
-          : undefined;
-        if (resourceState !== EXISTS) {
-          // We are going to create this resource now so it is marked as Exists
-          resumableState.styleResources[key] = EXISTS;
-
-          // If this is the first time we've encountered this precedence we need
-          // to create a StyleQueue
-          if (!styleQueue) {
-            styleQueue = {
-              precedence: stringToChunk(escapeTextForBrowser(precedence)),
-              rules: ([]: Array<Chunk | PrecomputedChunk>),
-              hrefs: ([]: Array<Chunk | PrecomputedChunk>),
-              sheets: (new Map(): Map<string, StylesheetResource>),
-            };
-            renderState.styles.set(precedence, styleQueue);
-          }
-
-          const resource: StylesheetResource = {
-            state: PENDING,
-            props: stylesheetPropsFromRawProps(props),
+      return pushLinkImpl(target, props);
+    } else {
+      // This stylesheet refers to a Resource and we create a new one if necessary
+      let styleQueue = renderState.styles.get(precedence);
+      const hasKey = resumableState.styleResources.hasOwnProperty(key);
+      const resourceState = hasKey
+        ? resumableState.styleResources[key]
+        : undefined;
+      if (resourceState !== EXISTS) {
+        // We are going to create this resource now so it is marked as Exists
+        resumableState.styleResources[key] = EXISTS;
+
+        // If this is the first time we've encountered this precedence we need
+        // to create a StyleQueue
+        if (!styleQueue) {
+          styleQueue = {
+            precedence: stringToChunk(escapeTextForBrowser(precedence)),
+            rules: ([]: Array<Chunk | PrecomputedChunk>),
+            hrefs: ([]: Array<Chunk | PrecomputedChunk>),
+            sheets: (new Map(): Map<string, StylesheetResource>),
           };
+          renderState.styles.set(precedence, styleQueue);
+        }
 
-          if (resourceState) {
-            // When resourceState is truty it is a Preload state. We cast it for clarity
-            const preloadState: Preloaded | PreloadedWithCredentials =
-              resourceState;
-            if (preloadState.length === 2) {
-              adoptPreloadCredentials(resource.props, preloadState);
-            }
+        const resource: StylesheetResource = {
+          state: PENDING,
+          props: stylesheetPropsFromRawProps(props),
+        };
 
-            const preloadResource = renderState.preloads.stylesheets.get(key);
-            if (preloadResource && preloadResource.length > 0) {
-              // The Preload for this resource was created in this render pass and has not flushed yet so
-              // we need to clear it to avoid it flushing.
-              preloadResource.length = 0;
-            } else {
-              // Either the preload resource from this render already flushed in this render pass
-              // or the preload flushed in a prior pass (prerender). In either case we need to mark
-              // this resource as already having been preloaded.
-              resource.state = PRELOADED;
-            }
-          } else {
-            // We don't need to check whether a preloadResource exists in the renderState
-            // because if it did exist then the resourceState would also exist and we would
-            // have hit the primary if condition above.
+        if (resourceState) {
+          // When resourceState is truty it is a Preload state. We cast it for clarity
+          const preloadState: Preloaded | PreloadedWithCredentials =
+            resourceState;
+          if (preloadState.length === 2) {
+            adoptPreloadCredentials(resource.props, preloadState);
           }
 
-          // We add the newly created resource to our StyleQueue and if necessary
-          // track the resource with the currently rendering boundary
-          styleQueue.sheets.set(key, resource);
-          if (hoistableState) {
-            hoistableState.stylesheets.add(resource);
+          const preloadResource = renderState.preloads.stylesheets.get(key);
+          if (preloadResource && preloadResource.length > 0) {
+            // The Preload for this resource was created in this render pass and has not flushed yet so
+            // we need to clear it to avoid it flushing.
+            preloadResource.length = 0;
+          } else {
+            // Either the preload resource from this render already flushed in this render pass
+            // or the preload flushed in a prior pass (prerender). In either case we need to mark
+            // this resource as already having been preloaded.
+            resource.state = PRELOADED;
           }
         } else {
-          // We need to track whether this boundary should wait on this resource or not.
-          // Typically this resource should always exist since we either had it or just created
-          // it. However, it's possible when you resume that the style has already been emitted
-          // and then it wouldn't be recreated in the RenderState and there's no need to track
-          // it again since we should've hoisted it to the shell already.
-          if (styleQueue) {
-            const resource = styleQueue.sheets.get(key);
-            if (resource) {
-              if (hoistableState) {
-                hoistableState.stylesheets.add(resource);
-              }
+          // We don't need to check whether a preloadResource exists in the renderState
+          // because if it did exist then the resourceState would also exist and we would
+          // have hit the primary if condition above.
+        }
+
+        // We add the newly created resource to our StyleQueue and if necessary
+        // track the resource with the currently rendering boundary
+        styleQueue.sheets.set(key, resource);
+        if (hoistableState) {
+          hoistableState.stylesheets.add(resource);
+        }
+      } else {
+        // We need to track whether this boundary should wait on this resource or not.
+        // Typically this resource should always exist since we either had it or just created
+        // it. However, it's possible when you resume that the style has already been emitted
+        // and then it wouldn't be recreated in the RenderState and there's no need to track
+        // it again since we should've hoisted it to the shell already.
+        if (styleQueue) {
+          const resource = styleQueue.sheets.get(key);
+          if (resource) {
+            if (hoistableState) {
+              hoistableState.stylesheets.add(resource);
             }
           }
         }
-        if (textEmbedded) {
-          // This link follows text but we aren't writing a tag. while not as efficient as possible we need
-          // to be safe and assume text will follow by inserting a textSeparator
-          target.push(textSeparator);
-        }
-        return null;
       }
-    } else if (props.onLoad || props.onError) {
-      // When using load handlers we cannot hoist and need to emit links in place
-      return pushLinkImpl(target, props);
-    } else {
-      // We can hoist this link so we may need to emit a text separator.
-      // @TODO refactor text separators so we don't have to defensively add
-      // them when we don't end up emitting a tag as a result of pushStartInstance
       if (textEmbedded) {
         // This link follows text but we aren't writing a tag. while not as efficient as possible we need
         // to be safe and assume text will follow by inserting a textSeparator
         target.push(textSeparator);
       }
-
-      if (isFallback) {
-        // Hoistable Elements for fallbacks are simply omitted. we don't want to emit them early
-        // because they are likely superceded by primary content and we want to avoid needing to clean
-        // them up when the primary content is ready. They are never hydrated on the client anyway because
-        // boundaries in fallback are awaited or client render, in either case there is never hydration
-        return null;
-      } else {
-        return pushLinkImpl(renderState.hoistableChunks, props);
-      }
+      return null;
     }
-  } else {
+  } else if (props.onLoad || props.onError) {
+    // When using load handlers we cannot hoist and need to emit links in place
     return pushLinkImpl(target, props);
+  } else {
+    // We can hoist this link so we may need to emit a text separator.
+    // @TODO refactor text separators so we don't have to defensively add
+    // them when we don't end up emitting a tag as a result of pushStartInstance
+    if (textEmbedded) {
+      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+      // to be safe and assume text will follow by inserting a textSeparator
+      target.push(textSeparator);
+    }
+
+    if (isFallback) {
+      // Hoistable Elements for fallbacks are simply omitted. we don't want to emit them early
+      // because they are likely superceded by primary content and we want to avoid needing to clean
+      // them up when the primary content is ready. They are never hydrated on the client anyway because
+      // boundaries in fallback are awaited or client render, in either case there is never hydration
+      return null;
+    } else {
+      return pushLinkImpl(renderState.hoistableChunks, props);
+    }
   }
 }
 
@@ -2598,84 +2604,78 @@ function pushStyle(
       }
     }
   }
-  if (enableFloat) {
-    const precedence = props.precedence;
-    const href = props.href;
+  const precedence = props.precedence;
+  const href = props.href;
 
-    if (
-      insertionMode === SVG_MODE ||
-      noscriptTagInScope ||
-      props.itemProp != null ||
-      typeof precedence !== 'string' ||
-      typeof href !== 'string' ||
-      href === ''
-    ) {
-      // This style tag is not able to be turned into a Style Resource
-      return pushStyleImpl(target, props);
+  if (
+    insertionMode === SVG_MODE ||
+    noscriptTagInScope ||
+    props.itemProp != null ||
+    typeof precedence !== 'string' ||
+    typeof href !== 'string' ||
+    href === ''
+  ) {
+    // This style tag is not able to be turned into a Style Resource
+    return pushStyleImpl(target, props);
+  }
+
+  if (__DEV__) {
+    if (href.includes(' ')) {
+      console.error(
+        'React expected the `href` prop for a <style> tag opting into hoisting semantics using the `precedence` prop to not have any spaces but ecountered spaces instead. using spaces in this prop will cause hydration of this style to fail on the client. The href for the <style> where this ocurred is "%s".',
+        href,
+      );
     }
+  }
+
+  const key = getResourceKey(href);
+  let styleQueue = renderState.styles.get(precedence);
+  const hasKey = resumableState.styleResources.hasOwnProperty(key);
+  const resourceState = hasKey ? resumableState.styleResources[key] : undefined;
+  if (resourceState !== EXISTS) {
+    // We are going to create this resource now so it is marked as Exists
+    resumableState.styleResources[key] = EXISTS;
 
     if (__DEV__) {
-      if (href.includes(' ')) {
+      if (resourceState) {
         console.error(
-          'React expected the `href` prop for a <style> tag opting into hoisting semantics using the `precedence` prop to not have any spaces but ecountered spaces instead. using spaces in this prop will cause hydration of this style to fail on the client. The href for the <style> where this ocurred is "%s".',
+          'React encountered a hoistable style tag for the same href as a preload: "%s". When using a style tag to inline styles you should not also preload it as a stylsheet.',
           href,
         );
       }
     }
 
-    const key = getResourceKey(href);
-    let styleQueue = renderState.styles.get(precedence);
-    const hasKey = resumableState.styleResources.hasOwnProperty(key);
-    const resourceState = hasKey
-      ? resumableState.styleResources[key]
-      : undefined;
-    if (resourceState !== EXISTS) {
-      // We are going to create this resource now so it is marked as Exists
-      resumableState.styleResources[key] = EXISTS;
-
-      if (__DEV__) {
-        if (resourceState) {
-          console.error(
-            'React encountered a hoistable style tag for the same href as a preload: "%s". When using a style tag to inline styles you should not also preload it as a stylsheet.',
-            href,
-          );
-        }
-      }
-
-      if (!styleQueue) {
-        // This is the first time we've encountered this precedence we need
-        // to create a StyleQueue.
-        styleQueue = {
-          precedence: stringToChunk(escapeTextForBrowser(precedence)),
-          rules: ([]: Array<Chunk | PrecomputedChunk>),
-          hrefs: [stringToChunk(escapeTextForBrowser(href))],
-          sheets: (new Map(): Map<string, StylesheetResource>),
-        };
-        renderState.styles.set(precedence, styleQueue);
-      } else {
-        // We have seen this precedence before and need to track this href
-        styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
-      }
-      pushStyleContents(styleQueue.rules, props);
+    if (!styleQueue) {
+      // This is the first time we've encountered this precedence we need
+      // to create a StyleQueue.
+      styleQueue = {
+        precedence: stringToChunk(escapeTextForBrowser(precedence)),
+        rules: ([]: Array<Chunk | PrecomputedChunk>),
+        hrefs: [stringToChunk(escapeTextForBrowser(href))],
+        sheets: (new Map(): Map<string, StylesheetResource>),
+      };
+      renderState.styles.set(precedence, styleQueue);
+    } else {
+      // We have seen this precedence before and need to track this href
+      styleQueue.hrefs.push(stringToChunk(escapeTextForBrowser(href)));
     }
-    if (styleQueue) {
-      // We need to track whether this boundary should wait on this resource or not.
-      // Typically this resource should always exist since we either had it or just created
-      // it. However, it's possible when you resume that the style has already been emitted
-      // and then it wouldn't be recreated in the RenderState and there's no need to track
-      // it again since we should've hoisted it to the shell already.
-      if (hoistableState) {
-        hoistableState.styles.add(styleQueue);
-      }
+    pushStyleContents(styleQueue.rules, props);
+  }
+  if (styleQueue) {
+    // We need to track whether this boundary should wait on this resource or not.
+    // Typically this resource should always exist since we either had it or just created
+    // it. However, it's possible when you resume that the style has already been emitted
+    // and then it wouldn't be recreated in the RenderState and there's no need to track
+    // it again since we should've hoisted it to the shell already.
+    if (hoistableState) {
+      hoistableState.styles.add(styleQueue);
     }
+  }
 
-    if (textEmbedded) {
-      // This link follows text but we aren't writing a tag. while not as efficient as possible we need
-      // to be safe and assume text will follow by inserting a textSeparator
-      target.push(textSeparator);
-    }
-  } else {
-    return pushStartGenericElement(target, props, 'style');
+  if (textEmbedded) {
+    // This link follows text but we aren't writing a tag. while not as efficient as possible we need
+    // to be safe and assume text will follow by inserting a textSeparator
+    target.push(textSeparator);
   }
 }
 
@@ -3032,23 +3032,19 @@ function pushTitle(
     }
   }
 
-  if (enableFloat) {
-    if (
-      insertionMode !== SVG_MODE &&
-      !noscriptTagInScope &&
-      props.itemProp == null
-    ) {
-      if (isFallback) {
-        // Hoistable Elements for fallbacks are simply omitted. we don't want to emit them early
-        // because they are likely superceded by primary content and we want to avoid needing to clean
-        // them up when the primary content is ready. They are never hydrated on the client anyway because
-        // boundaries in fallback are awaited or client render, in either case there is never hydration
-        return null;
-      } else {
-        pushTitleImpl(renderState.hoistableChunks, props);
-      }
+  if (
+    insertionMode !== SVG_MODE &&
+    !noscriptTagInScope &&
+    props.itemProp == null
+  ) {
+    if (isFallback) {
+      // Hoistable Elements for fallbacks are simply omitted. we don't want to emit them early
+      // because they are likely superceded by primary content and we want to avoid needing to clean
+      // them up when the primary content is ready. They are never hydrated on the client anyway because
+      // boundaries in fallback are awaited or client render, in either case there is never hydration
+      return null;
     } else {
-      return pushTitleImpl(target, props);
+      pushTitleImpl(renderState.hoistableChunks, props);
     }
   } else {
     return pushTitleImpl(target, props);
@@ -3103,97 +3099,19 @@ function pushTitleImpl(
   return null;
 }
 
-function pushStartTitle(
-  target: Array<Chunk | PrecomputedChunk>,
-  props: Object,
-): ReactNodeList {
-  target.push(startChunkForTag('title'));
-
-  let children = null;
-  for (const propKey in props) {
-    if (hasOwnProperty.call(props, propKey)) {
-      const propValue = props[propKey];
-      if (propValue == null) {
-        continue;
-      }
-      switch (propKey) {
-        case 'children':
-          children = propValue;
-          break;
-        case 'dangerouslySetInnerHTML':
-          throw new Error(
-            '`dangerouslySetInnerHTML` does not make sense on <title>.',
-          );
-        default:
-          pushAttribute(target, propKey, propValue);
-          break;
-      }
-    }
-  }
-  target.push(endOfStartTag);
-
-  if (__DEV__) {
-    const childForValidation =
-      Array.isArray(children) && children.length < 2
-        ? children[0] || null
-        : children;
-    if (Array.isArray(children) && children.length > 1) {
-      console.error(
-        'A title element received an array with more than 1 element as children. ' +
-          'In browsers title Elements can only have Text Nodes as children. If ' +
-          'the children being rendered output more than a single text node in aggregate the browser ' +
-          'will display markup and comments as text in the title and hydration will likely fail and ' +
-          'fall back to client rendering',
-      );
-    } else if (
-      childForValidation != null &&
-      childForValidation.$$typeof != null
-    ) {
-      console.error(
-        'A title element received a React element for children. ' +
-          'In the browser title Elements can only have Text Nodes as children. If ' +
-          'the children being rendered output more than a single text node in aggregate the browser ' +
-          'will display markup and comments as text in the title and hydration will likely fail and ' +
-          'fall back to client rendering',
-      );
-    } else if (
-      childForValidation != null &&
-      typeof childForValidation !== 'string' &&
-      typeof childForValidation !== 'number' &&
-      ((enableBigIntSupport && typeof childForValidation !== 'bigint') ||
-        !enableBigIntSupport)
-    ) {
-      console.error(
-        'A title element received a value that was not a string or number%s for children. ' +
-          'In the browser title Elements can only have Text Nodes as children. If ' +
-          'the children being rendered output more than a single text node in aggregate the browser ' +
-          'will display markup and comments as text in the title and hydration will likely fail and ' +
-          'fall back to client rendering',
-        enableBigIntSupport ? ' or bigint' : '',
-      );
-    }
-  }
-
-  return children;
-}
-
 function pushStartHead(
   target: Array<Chunk | PrecomputedChunk>,
   props: Object,
   renderState: RenderState,
   insertionMode: InsertionMode,
 ): ReactNodeList {
-  if (enableFloat) {
-    if (insertionMode < HTML_MODE && renderState.headChunks === null) {
-      // This <head> is the Document.head and should be part of the preamble
-      renderState.headChunks = [];
-      return pushStartGenericElement(renderState.headChunks, props, 'head');
-    } else {
-      // This <head> is deep and is likely just an error. we emit it inline though.
-      // Validation should warn that this tag is the the wrong spot.
-      return pushStartGenericElement(target, props, 'head');
-    }
+  if (insertionMode < HTML_MODE && renderState.headChunks === null) {
+    // This <head> is the Document.head and should be part of the preamble
+    renderState.headChunks = [];
+    return pushStartGenericElement(renderState.headChunks, props, 'head');
   } else {
+    // This <head> is deep and is likely just an error. we emit it inline though.
+    // Validation should warn that this tag is the the wrong spot.
     return pushStartGenericElement(target, props, 'head');
   }
 }
@@ -3204,23 +3122,13 @@ function pushStartHtml(
   renderState: RenderState,
   insertionMode: InsertionMode,
 ): ReactNodeList {
-  if (enableFloat) {
-    if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
-      // This <html> is the Document.documentElement and should be part of the preamble
-      renderState.htmlChunks = [DOCTYPE];
-      return pushStartGenericElement(renderState.htmlChunks, props, 'html');
-    } else {
-      // This <html> is deep and is likely just an error. we emit it inline though.
-      // Validation should warn that this tag is the the wrong spot.
-      return pushStartGenericElement(target, props, 'html');
-    }
+  if (insertionMode === ROOT_HTML_MODE && renderState.htmlChunks === null) {
+    // This <html> is the Document.documentElement and should be part of the preamble
+    renderState.htmlChunks = [DOCTYPE];
+    return pushStartGenericElement(renderState.htmlChunks, props, 'html');
   } else {
-    if (insertionMode === ROOT_HTML_MODE) {
-      // If we're rendering the html tag and we're at the root (i.e. not in foreignObject)
-      // then we also emit the DOCTYPE as part of the root content as a convenience for
-      // rendering the whole document.
-      target.push(DOCTYPE);
-    }
+    // This <html> is deep and is likely just an error. we emit it inline though.
+    // Validation should warn that this tag is the the wrong spot.
     return pushStartGenericElement(target, props, 'html');
   }
 }
@@ -3234,80 +3142,75 @@ function pushScript(
   insertionMode: InsertionMode,
   noscriptTagInScope: boolean,
 ): null {
-  if (enableFloat) {
-    const asyncProp = props.async;
-    if (
-      typeof props.src !== 'string' ||
-      !props.src ||
-      !(
-        asyncProp &&
-        typeof asyncProp !== 'function' &&
-        typeof asyncProp !== 'symbol'
-      ) ||
-      props.onLoad ||
-      props.onError ||
-      insertionMode === SVG_MODE ||
-      noscriptTagInScope ||
-      props.itemProp != null
-    ) {
-      // This script will not be a resource, we bailout early and emit it in place.
-      return pushScriptImpl(target, props);
-    }
-
-    const src = props.src;
-    const key = getResourceKey(src);
-    // We can make this <script> into a ScriptResource
+  const asyncProp = props.async;
+  if (
+    typeof props.src !== 'string' ||
+    !props.src ||
+    !(
+      asyncProp &&
+      typeof asyncProp !== 'function' &&
+      typeof asyncProp !== 'symbol'
+    ) ||
+    props.onLoad ||
+    props.onError ||
+    insertionMode === SVG_MODE ||
+    noscriptTagInScope ||
+    props.itemProp != null
+  ) {
+    // This script will not be a resource, we bailout early and emit it in place.
+    return pushScriptImpl(target, props);
+  }
 
-    let resources, preloads;
-    if (props.type === 'module') {
-      resources = resumableState.moduleScriptResources;
-      preloads = renderState.preloads.moduleScripts;
-    } else {
-      resources = resumableState.scriptResources;
-      preloads = renderState.preloads.scripts;
-    }
+  const src = props.src;
+  const key = getResourceKey(src);
+  // We can make this <script> into a ScriptResource
 
-    const hasKey = resources.hasOwnProperty(key);
-    const resourceState = hasKey ? resources[key] : undefined;
-    if (resourceState !== EXISTS) {
-      // We are going to create this resource now so it is marked as Exists
-      resources[key] = EXISTS;
+  let resources, preloads;
+  if (props.type === 'module') {
+    resources = resumableState.moduleScriptResources;
+    preloads = renderState.preloads.moduleScripts;
+  } else {
+    resources = resumableState.scriptResources;
+    preloads = renderState.preloads.scripts;
+  }
 
-      let scriptProps = props;
-      if (resourceState) {
-        // When resourceState is truty it is a Preload state. We cast it for clarity
-        const preloadState: Preloaded | PreloadedWithCredentials =
-          resourceState;
-        if (preloadState.length === 2) {
-          scriptProps = {...props};
-          adoptPreloadCredentials(scriptProps, preloadState);
-        }
+  const hasKey = resources.hasOwnProperty(key);
+  const resourceState = hasKey ? resources[key] : undefined;
+  if (resourceState !== EXISTS) {
+    // We are going to create this resource now so it is marked as Exists
+    resources[key] = EXISTS;
 
-        const preloadResource = preloads.get(key);
-        if (preloadResource) {
-          // the preload resource exists was created in this render. Now that we have
-          // a script resource which will emit earlier than a preload would if it
-          // hasn't already flushed we prevent it from flushing by zeroing the length
-          preloadResource.length = 0;
-        }
+    let scriptProps = props;
+    if (resourceState) {
+      // When resourceState is truty it is a Preload state. We cast it for clarity
+      const preloadState: Preloaded | PreloadedWithCredentials = resourceState;
+      if (preloadState.length === 2) {
+        scriptProps = {...props};
+        adoptPreloadCredentials(scriptProps, preloadState);
       }
 
-      const resource: Resource = [];
-      // Add to the script flushing queue
-      renderState.scripts.add(resource);
-      // encode the tag as Chunks
-      pushScriptImpl(resource, scriptProps);
+      const preloadResource = preloads.get(key);
+      if (preloadResource) {
+        // the preload resource exists was created in this render. Now that we have
+        // a script resource which will emit earlier than a preload would if it
+        // hasn't already flushed we prevent it from flushing by zeroing the length
+        preloadResource.length = 0;
+      }
     }
 
-    if (textEmbedded) {
-      // This script follows text but we aren't writing a tag. while not as efficient as possible we need
-      // to be safe and assume text will follow by inserting a textSeparator
-      target.push(textSeparator);
-    }
-    return null;
-  } else {
-    return pushScriptImpl(target, props);
+    const resource: Resource = [];
+    // Add to the script flushing queue
+    renderState.scripts.add(resource);
+    // encode the tag as Chunks
+    pushScriptImpl(resource, scriptProps);
+  }
+
+  if (textEmbedded) {
+    // This script follows text but we aren't writing a tag. while not as efficient as possible we need
+    // to be safe and assume text will follow by inserting a textSeparator
+    target.push(textSeparator);
   }
+  return null;
 }
 
 function pushScriptImpl(
@@ -3435,11 +3338,9 @@ function pushStartCustomElement(
           // Ignored. These are built-in to React on the client.
           break;
         case 'className':
-          if (enableCustomElementPropertySupport) {
-            // className gets rendered as class on the client, so it should be
-            // rendered as class on the server.
-            attributeName = 'class';
-          }
+          // className gets rendered as class on the client, so it should be
+          // rendered as class on the server.
+          attributeName = 'class';
         // intentional fallthrough
         default:
           if (
@@ -3447,14 +3348,12 @@ function pushStartCustomElement(
             typeof propValue !== 'function' &&
             typeof propValue !== 'symbol'
           ) {
-            if (enableCustomElementPropertySupport) {
-              if (propValue === false) {
-                continue;
-              } else if (propValue === true) {
-                propValue = '';
-              } else if (typeof propValue === 'object') {
-                continue;
-              }
+            if (propValue === false) {
+              continue;
+            } else if (propValue === true) {
+              propValue = '';
+            } else if (typeof propValue === 'object') {
+              continue;
             }
             target.push(
               attributeSeparator,
@@ -3653,16 +3552,14 @@ export function pushStartInstance(
     case 'menuitem':
       return pushStartMenuItem(target, props);
     case 'title':
-      return enableFloat
-        ? pushTitle(
-            target,
-            props,
-            renderState,
-            formatContext.insertionMode,
-            !!(formatContext.tagScope & NOSCRIPT_SCOPE),
-            isFallback,
-          )
-        : pushStartTitle(target, props);
+      return pushTitle(
+        target,
+        props,
+        renderState,
+        formatContext.insertionMode,
+        !!(formatContext.tagScope & NOSCRIPT_SCOPE),
+        isFallback,
+      );
     case 'link':
       return pushLink(
         target,
@@ -3676,17 +3573,15 @@ export function pushStartInstance(
         isFallback,
       );
     case 'script':
-      return enableFloat
-        ? pushScript(
-            target,
-            props,
-            resumableState,
-            renderState,
-            textEmbedded,
-            formatContext.insertionMode,
-            !!(formatContext.tagScope & NOSCRIPT_SCOPE),
-          )
-        : pushStartGenericElement(target, props, type);
+      return pushScript(
+        target,
+        props,
+        resumableState,
+        renderState,
+        textEmbedded,
+        formatContext.insertionMode,
+        !!(formatContext.tagScope & NOSCRIPT_SCOPE),
+      );
     case 'style':
       return pushStyle(
         target,
@@ -3714,15 +3609,13 @@ export function pushStartInstance(
       return pushStartPreformattedElement(target, props, type);
     }
     case 'img': {
-      return enableFloat
-        ? pushImg(
-            target,
-            props,
-            resumableState,
-            renderState,
-            !!(formatContext.tagScope & PICTURE_SCOPE),
-          )
-        : pushSelfClosing(target, props, type);
+      return pushImg(
+        target,
+        props,
+        resumableState,
+        renderState,
+        !!(formatContext.tagScope & PICTURE_SCOPE),
+      );
     }
     // Omitted close tags
     case 'base':
@@ -3795,21 +3688,16 @@ export function pushEndInstance(
   formatContext: FormatContext,
 ): void {
   switch (type) {
-    // When float is on we expect title and script tags to always be pushed in
-    // a unit and never return children. when we end up pushing the end tag we
-    // want to ensure there is no extra closing tag pushed
+    // We expect title and script tags to always be pushed in a unit and never
+    // return children. when we end up pushing the end tag we want to ensure
+    // there is no extra closing tag pushed
     case 'title':
     case 'style':
-    case 'script': {
-      if (!enableFloat) {
-        break;
-      }
-      // Fall through
-    }
-
+    case 'script':
     // Omitted close tags
     // TODO: Instead of repeating this switch we could try to pass a flag from above.
     // That would require returning a tuple. Which might be ok if it gets inlined.
+    // fallthrough
     case 'area':
     case 'base':
     case 'br':
@@ -3834,14 +3722,14 @@ export function pushEndInstance(
     // This is so we can withhold them until the postamble when we know
     // we won't emit any more tags
     case 'body': {
-      if (enableFloat && formatContext.insertionMode <= HTML_HTML_MODE) {
+      if (formatContext.insertionMode <= HTML_HTML_MODE) {
         resumableState.hasBody = true;
         return;
       }
       break;
     }
     case 'html':
-      if (enableFloat && formatContext.insertionMode === ROOT_HTML_MODE) {
+      if (formatContext.insertionMode === ROOT_HTML_MODE) {
         resumableState.hasHtml = true;
         return;
       }
@@ -4245,21 +4133,18 @@ export function writeCompletedBoundaryInstruction(
   id: number,
   hoistableState: HoistableState,
 ): boolean {
-  let requiresStyleInsertion;
-  if (enableFloat) {
-    requiresStyleInsertion = renderState.stylesToHoist;
-    // If necessary stylesheets will be flushed with this instruction.
-    // Any style tags not yet hoisted in the Document will also be hoisted.
-    // We reset this state since after this instruction executes all styles
-    // up to this point will have been hoisted
-    renderState.stylesToHoist = false;
-  }
+  const requiresStyleInsertion = renderState.stylesToHoist;
+  // If necessary stylesheets will be flushed with this instruction.
+  // Any style tags not yet hoisted in the Document will also be hoisted.
+  // We reset this state since after this instruction executes all styles
+  // up to this point will have been hoisted
+  renderState.stylesToHoist = false;
   const scriptFormat =
     !enableFizzExternalRuntime ||
     resumableState.streamingFormat === ScriptStreamingFormat;
   if (scriptFormat) {
     writeChunk(destination, renderState.startInlineScript);
-    if (enableFloat && requiresStyleInsertion) {
+    if (requiresStyleInsertion) {
       if (
         (resumableState.instructions & SentCompleteBoundaryFunction) ===
         NothingSent
@@ -4289,7 +4174,7 @@ export function writeCompletedBoundaryInstruction(
       }
     }
   } else {
-    if (enableFloat && requiresStyleInsertion) {
+    if (requiresStyleInsertion) {
       writeChunk(destination, completeBoundaryWithStylesData1);
     } else {
       writeChunk(destination, completeBoundaryData1);
@@ -4309,7 +4194,7 @@ export function writeCompletedBoundaryInstruction(
   }
   writeChunk(destination, renderState.segmentPrefix);
   writeChunk(destination, idChunk);
-  if (enableFloat && requiresStyleInsertion) {
+  if (requiresStyleInsertion) {
     // Script and data writers must format this differently:
     //  - script writer emits an array literal, whose string elements are
     //    escaped for javascript  e.g. ["A", "B"]
@@ -5359,9 +5244,6 @@ function getImageResourceKey(
 }
 
 function prefetchDNS(href: string) {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5415,9 +5297,6 @@ function prefetchDNS(href: string) {
 }
 
 function preconnect(href: string, crossOrigin: ?CrossOriginEnum) {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5479,9 +5358,6 @@ function preconnect(href: string, crossOrigin: ?CrossOriginEnum) {
 }
 
 function preload(href: string, as: string, options?: ?PreloadImplOptions) {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5683,9 +5559,6 @@ function preloadModule(
   href: string,
   options?: ?PreloadModuleImplOptions,
 ): void {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5760,9 +5633,6 @@ function preinitStyle(
   precedence: ?string,
   options?: ?PreinitStyleOptions,
 ): void {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5848,9 +5718,6 @@ function preinitStyle(
 }
 
 function preinitScript(src: string, options?: ?PreinitScriptOptions): void {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5914,9 +5781,6 @@ function preinitModuleScript(
   src: string,
   options?: ?PreinitModuleScriptOptions,
 ): void {
-  if (!enableFloat) {
-    return;
-  }
   const request = resolveRequest();
   if (!request) {
     // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
@@ -5986,9 +5850,6 @@ function preloadBootstrapScriptOrModule(
   href: string,
   props: PreloadProps,
 ): void {
-  if (!enableFloat) {
-    return;
-  }
   const key = getResourceKey(href);
 
   if (__DEV__) {
diff --git a/packages/react-dom-bindings/src/server/fizz-instruction-set/ReactDOMFizzInstructionSetExternalRuntime.js b/packages/react-dom-bindings/src/server/fizz-instruction-set/ReactDOMFizzInstructionSetExternalRuntime.js
index dc5232c8eeda1..419817b52e1f3 100644
--- a/packages/react-dom-bindings/src/server/fizz-instruction-set/ReactDOMFizzInstructionSetExternalRuntime.js
+++ b/packages/react-dom-bindings/src/server/fizz-instruction-set/ReactDOMFizzInstructionSetExternalRuntime.js
@@ -9,8 +9,6 @@ import {
   listenToFormSubmissionsForReplaying,
 } from './ReactDOMFizzInstructionSetShared';
 
-import {enableFormActions} from 'shared/ReactFeatureFlags';
-
 export {clientRenderBoundary, completeBoundary, completeSegment};
 
 const resourceMap = new Map();
@@ -140,6 +138,4 @@ export function completeBoundaryWithStyles(
   );
 }
 
-if (enableFormActions) {
-  listenToFormSubmissionsForReplaying();
-}
+listenToFormSubmissionsForReplaying();
diff --git a/packages/react-dom-bindings/src/shared/ReactDOMFormActions.js b/packages/react-dom-bindings/src/shared/ReactDOMFormActions.js
index 80d544cd28f44..284eaff1bb6bb 100644
--- a/packages/react-dom-bindings/src/shared/ReactDOMFormActions.js
+++ b/packages/react-dom-bindings/src/shared/ReactDOMFormActions.js
@@ -10,7 +10,7 @@
 import type {Dispatcher} from 'react-reconciler/src/ReactInternalTypes';
 import type {Awaited} from 'shared/ReactTypes';
 
-import {enableAsyncActions, enableFormActions} from 'shared/ReactFeatureFlags';
+import {enableAsyncActions} from 'shared/ReactFeatureFlags';
 import ReactSharedInternals from 'shared/ReactSharedInternals';
 
 const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
@@ -67,7 +67,7 @@ function resolveDispatcher() {
 }
 
 export function useFormStatus(): FormStatus {
-  if (!(enableFormActions && enableAsyncActions)) {
+  if (!enableAsyncActions) {
     throw new Error('Not implemented.');
   } else {
     const dispatcher = resolveDispatcher();
@@ -81,7 +81,7 @@ export function useFormState<S, P>(
   initialState: Awaited<S>,
   permalink?: string,
 ): [Awaited<S>, (P) => void, boolean] {
-  if (!(enableFormActions && enableAsyncActions)) {
+  if (!enableAsyncActions) {
     throw new Error('Not implemented.');
   } else {
     const dispatcher = resolveDispatcher();
diff --git a/packages/react-dom-bindings/src/shared/ReactDOMUnknownPropertyHook.js b/packages/react-dom-bindings/src/shared/ReactDOMUnknownPropertyHook.js
index 29767d8a65ffb..3e49fa637f29d 100644
--- a/packages/react-dom-bindings/src/shared/ReactDOMUnknownPropertyHook.js
+++ b/packages/react-dom-bindings/src/shared/ReactDOMUnknownPropertyHook.js
@@ -9,11 +9,6 @@ import {ATTRIBUTE_NAME_CHAR} from './isAttributeNameSafe';
 import isCustomElement from './isCustomElement';
 import possibleStandardNames from './possibleStandardNames';
 import hasOwnProperty from 'shared/hasOwnProperty';
-import {
-  enableCustomElementPropertySupport,
-  enableFormActions,
-  enableNewBooleanProps,
-} from 'shared/ReactFeatureFlags';
 
 const warnedProperties = {};
 const EVENT_NAME_REGEX = /^on./;
@@ -42,21 +37,18 @@ function validateProperty(tagName, name, value, eventRegistry) {
       return true;
     }
 
-    if (enableFormActions) {
-      // Actions are special because unlike events they can have other value types.
-      if (typeof value === 'function') {
-        if (tagName === 'form' && name === 'action') {
-          return true;
-        }
-        if (tagName === 'input' && name === 'formAction') {
-          return true;
-        }
-        if (tagName === 'button' && name === 'formAction') {
-          return true;
-        }
+    // Actions are special because unlike events they can have other value types.
+    if (typeof value === 'function') {
+      if (tagName === 'form' && name === 'action') {
+        return true;
+      }
+      if (tagName === 'input' && name === 'formAction') {
+        return true;
+      }
+      if (tagName === 'button' && name === 'formAction') {
+        return true;
       }
     }
-
     // We can't rely on the event system being injected on the server.
     if (eventRegistry != null) {
       const {registrationNameDependencies, possibleRegistrationNames} =
@@ -193,9 +185,7 @@ function validateProperty(tagName, name, value, eventRegistry) {
       }
       case 'innerText': // Properties
       case 'textContent':
-        if (enableCustomElementPropertySupport) {
-          return true;
-        }
+        return true;
     }
 
     switch (typeof value) {
@@ -237,18 +227,12 @@ function validateProperty(tagName, name, value, eventRegistry) {
           case 'seamless':
           case 'itemScope':
           case 'capture':
-          case 'download': {
+          case 'download':
+          case 'inert': {
             // Boolean properties can accept boolean values
             return true;
           }
           // fallthrough
-          case 'inert': {
-            if (enableNewBooleanProps) {
-              // Boolean properties can accept boolean values
-              return true;
-            }
-          }
-          // fallthrough for new boolean props without the flag on
           default: {
             const prefix = name.toLowerCase().slice(0, 5);
             if (prefix === 'data-' || prefix === 'aria-') {
@@ -320,15 +304,10 @@ function validateProperty(tagName, name, value, eventRegistry) {
             case 'reversed':
             case 'scoped':
             case 'seamless':
-            case 'itemScope': {
-              break;
-            }
+            case 'itemScope':
             case 'inert': {
-              if (enableNewBooleanProps) {
-                break;
-              }
+              break;
             }
-            // fallthrough for new boolean props without the flag on
             default: {
               return true;
             }
diff --git a/packages/react-dom-bindings/src/shared/possibleStandardNames.js b/packages/react-dom-bindings/src/shared/possibleStandardNames.js
index d2d90877b53d7..6c06b47c64ac7 100644
--- a/packages/react-dom-bindings/src/shared/possibleStandardNames.js
+++ b/packages/react-dom-bindings/src/shared/possibleStandardNames.js
@@ -4,7 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import {enableNewBooleanProps} from 'shared/ReactFeatureFlags';
 
 // When adding attributes to the HTML or SVG allowed attribute list, be sure to
 // also add them to this module to ensure casing and incorrect name
@@ -83,6 +82,7 @@ const possibleStandardNames = {
   id: 'id',
   imagesizes: 'imageSizes',
   imagesrcset: 'imageSrcSet',
+  inert: 'inert',
   innerhtml: 'innerHTML',
   inputmode: 'inputMode',
   integrity: 'integrity',
@@ -503,8 +503,4 @@ const possibleStandardNames = {
   zoomandpan: 'zoomAndPan',
 };
 
-if (enableNewBooleanProps) {
-  possibleStandardNames.inert = 'inert';
-}
-
 export default possibleStandardNames;
diff --git a/packages/react-dom-bindings/src/shared/sanitizeURL.js b/packages/react-dom-bindings/src/shared/sanitizeURL.js
index b3de4657e9158..d1f0e62cbac76 100644
--- a/packages/react-dom-bindings/src/shared/sanitizeURL.js
+++ b/packages/react-dom-bindings/src/shared/sanitizeURL.js
@@ -7,8 +7,6 @@
  * @flow
  */
 
-import {disableJavaScriptURLs} from 'shared/ReactFeatureFlags';
-
 // A javascript: URL can contain leading C0 control or \u0020 SPACE,
 // and any newline or tab are filtered out as if they're not part of the URL.
 // https://url.spec.whatwg.org/#url-parsing
@@ -22,29 +20,14 @@ import {disableJavaScriptURLs} from 'shared/ReactFeatureFlags';
 const isJavaScriptProtocol =
   /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i;
 
-let didWarn = false;
-
 function sanitizeURL<T>(url: T): T | string {
   // We should never have symbols here because they get filtered out elsewhere.
   // eslint-disable-next-line react-internal/safe-string-coercion
-  const stringifiedURL = '' + (url: any);
-  if (disableJavaScriptURLs) {
-    if (isJavaScriptProtocol.test(stringifiedURL)) {
-      // Return a different javascript: url that doesn't cause any side-effects and just
-      // throws if ever visited.
-      // eslint-disable-next-line no-script-url
-      return "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')";
-    }
-  } else if (__DEV__) {
-    if (!didWarn && isJavaScriptProtocol.test(stringifiedURL)) {
-      didWarn = true;
-      console.error(
-        'A future version of React will block javascript: URLs as a security precaution. ' +
-          'Use event handlers instead if you can. If you need to generate unsafe HTML try ' +
-          'using dangerouslySetInnerHTML instead. React was passed %s.',
-        JSON.stringify(stringifiedURL),
-      );
-    }
+  if (isJavaScriptProtocol.test('' + (url: any))) {
+    // Return a different javascript: url that doesn't cause any side-effects and just
+    // throws if ever visited.
+    // eslint-disable-next-line no-script-url
+    return "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')";
   }
   return url;
 }
diff --git a/packages/react-dom/index.classic.fb.js b/packages/react-dom/index.classic.fb.js
index d8814243b690d..5d4cb1e11f822 100644
--- a/packages/react-dom/index.classic.fb.js
+++ b/packages/react-dom/index.classic.fb.js
@@ -20,14 +20,9 @@ Object.assign((Internals: any), {
 
 export {
   createPortal,
-  createRoot,
-  hydrateRoot,
   findDOMNode,
   flushSync,
-  hydrate,
-  render,
   unmountComponentAtNode,
-  unstable_batchedUpdates,
   unstable_createEventHandle,
   unstable_renderSubtreeIntoContainer,
   unstable_runWithPriority, // DO NOT USE: Temporarily exposed to migrate off of Scheduler.runWithPriority.
@@ -42,4 +37,11 @@ export {
   version,
 } from './src/client/ReactDOM';
 
+export {
+  createRoot,
+  hydrateRoot,
+  render,
+  unstable_batchedUpdates,
+} from './src/client/ReactDOMRootFB';
+
 export {Internals as __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED};
diff --git a/packages/react-dom/index.experimental.js b/packages/react-dom/index.experimental.js
index 539dbddb5a89f..0d38031e60b21 100644
--- a/packages/react-dom/index.experimental.js
+++ b/packages/react-dom/index.experimental.js
@@ -12,7 +12,6 @@ export {
   createPortal,
   createRoot,
   hydrateRoot,
-  findDOMNode,
   flushSync,
   unstable_batchedUpdates,
   unstable_runWithPriority, // DO NOT USE: Temporarily exposed to migrate off of Scheduler.runWithPriority.
@@ -26,31 +25,3 @@ export {
   preinitModule,
   version,
 } from './src/client/ReactDOM';
-
-import type {Awaited} from 'shared/ReactTypes';
-import type {FormStatus} from 'react-dom-bindings/src/shared/ReactDOMFormActions';
-import {useFormStatus, useFormState} from './src/client/ReactDOM';
-
-export function experimental_useFormStatus(): FormStatus {
-  if (__DEV__) {
-    console.error(
-      'useFormStatus is now in canary. Remove the experimental_ prefix. ' +
-        'The prefixed alias will be removed in an upcoming release.',
-    );
-  }
-  return useFormStatus();
-}
-
-export function experimental_useFormState<S, P>(
-  action: (Awaited<S>, P) => S,
-  initialState: Awaited<S>,
-  permalink?: string,
-): [Awaited<S>, (P) => void, boolean] {
-  if (__DEV__) {
-    console.error(
-      'useFormState is now in canary. Remove the experimental_ prefix. ' +
-        'The prefixed alias will be removed in an upcoming release.',
-    );
-  }
-  return useFormState(action, initialState, permalink);
-}
diff --git a/packages/react-dom/index.js b/packages/react-dom/index.js
index 4db349ea5bf0d..30ccf0a2eac89 100644
--- a/packages/react-dom/index.js
+++ b/packages/react-dom/index.js
@@ -14,9 +14,7 @@ export {
   createPortal,
   createRoot,
   hydrateRoot,
-  findDOMNode,
   flushSync,
-  hydrate,
   render,
   unmountComponentAtNode,
   unstable_batchedUpdates,
diff --git a/packages/react-dom/index.modern.fb.js b/packages/react-dom/index.modern.fb.js
index 531f4d429b611..0bff591fac7c9 100644
--- a/packages/react-dom/index.modern.fb.js
+++ b/packages/react-dom/index.modern.fb.js
@@ -10,8 +10,6 @@
 export {default as __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED} from './src/ReactDOMSharedInternals';
 export {
   createPortal,
-  createRoot,
-  hydrateRoot,
   flushSync,
   unstable_batchedUpdates,
   unstable_createEventHandle,
@@ -26,3 +24,5 @@ export {
   preinitModule,
   version,
 } from './src/client/ReactDOM';
+
+export {createRoot, hydrateRoot} from './src/client/ReactDOMRootFB';
diff --git a/packages/react-dom/index.stable.js b/packages/react-dom/index.stable.js
index 36f5563fda5da..a817a6b3d9af3 100644
--- a/packages/react-dom/index.stable.js
+++ b/packages/react-dom/index.stable.js
@@ -12,9 +12,7 @@ export {
   createPortal,
   createRoot,
   hydrateRoot,
-  findDOMNode,
   flushSync,
-  hydrate,
   render,
   unmountComponentAtNode,
   unstable_batchedUpdates,
diff --git a/packages/react-dom/npm/server.browser.js b/packages/react-dom/npm/server.browser.js
index 947e981ffd619..4627357ca7460 100644
--- a/packages/react-dom/npm/server.browser.js
+++ b/packages/react-dom/npm/server.browser.js
@@ -12,7 +12,6 @@ if (process.env.NODE_ENV === 'production') {
 exports.version = l.version;
 exports.renderToString = l.renderToString;
 exports.renderToStaticMarkup = l.renderToStaticMarkup;
-exports.renderToNodeStream = l.renderToNodeStream;
 exports.renderToStaticNodeStream = l.renderToStaticNodeStream;
 exports.renderToReadableStream = s.renderToReadableStream;
 if (s.resume) {
diff --git a/packages/react-dom/npm/server.bun.js b/packages/react-dom/npm/server.bun.js
index adbc56adec022..cd45f7d7f1fa7 100644
--- a/packages/react-dom/npm/server.bun.js
+++ b/packages/react-dom/npm/server.bun.js
@@ -15,7 +15,6 @@ exports.renderToReadableStream = b.renderToReadableStream;
 if (b.resume) {
   exports.resume = b.resume;
 }
-exports.renderToNodeStream = b.renderToNodeStream;
 exports.renderToStaticNodeStream = b.renderToStaticNodeStream;
 exports.renderToString = l.renderToString;
 exports.renderToStaticMarkup = l.renderToStaticMarkup;
diff --git a/packages/react-dom/npm/server.edge.js b/packages/react-dom/npm/server.edge.js
index ced0fa7a4e553..c71b3ee805992 100644
--- a/packages/react-dom/npm/server.edge.js
+++ b/packages/react-dom/npm/server.edge.js
@@ -12,7 +12,6 @@ if (process.env.NODE_ENV === 'production') {
 
 exports.version = b.version;
 exports.renderToReadableStream = b.renderToReadableStream;
-exports.renderToNodeStream = b.renderToNodeStream;
 exports.renderToStaticNodeStream = b.renderToStaticNodeStream;
 exports.renderToString = l.renderToString;
 exports.renderToStaticMarkup = l.renderToStaticMarkup;
diff --git a/packages/react-dom/npm/server.node.js b/packages/react-dom/npm/server.node.js
index 6e48652e4103f..9aed61fffb37a 100644
--- a/packages/react-dom/npm/server.node.js
+++ b/packages/react-dom/npm/server.node.js
@@ -12,7 +12,6 @@ if (process.env.NODE_ENV === 'production') {
 exports.version = l.version;
 exports.renderToString = l.renderToString;
 exports.renderToStaticMarkup = l.renderToStaticMarkup;
-exports.renderToNodeStream = l.renderToNodeStream;
 exports.renderToStaticNodeStream = l.renderToStaticNodeStream;
 exports.renderToPipeableStream = s.renderToPipeableStream;
 if (s.resumeToPipeableStream) {
diff --git a/packages/react-dom/package.json b/packages/react-dom/package.json
index 6ef48b292586c..5547c20de65eb 100644
--- a/packages/react-dom/package.json
+++ b/packages/react-dom/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-dom",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "description": "React package for working with the DOM.",
   "main": "index.js",
   "repository": {
@@ -20,7 +20,7 @@
     "scheduler": "^0.23.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0"
+    "react": "^19.0.0"
   },
   "files": [
     "LICENSE",
diff --git a/packages/react-dom/server.browser.js b/packages/react-dom/server.browser.js
index f617e7ec7e382..490bc81504095 100644
--- a/packages/react-dom/server.browser.js
+++ b/packages/react-dom/server.browser.js
@@ -23,12 +23,6 @@ export function renderToStaticMarkup() {
     arguments,
   );
 }
-export function renderToNodeStream() {
-  return require('./src/server/ReactDOMLegacyServerBrowser').renderToNodeStream.apply(
-    this,
-    arguments,
-  );
-}
 export function renderToStaticNodeStream() {
   return require('./src/server/ReactDOMLegacyServerBrowser').renderToStaticNodeStream.apply(
     this,
diff --git a/packages/react-dom/server.bun.js b/packages/react-dom/server.bun.js
index 0776c4a85b0b2..8e868a862159d 100644
--- a/packages/react-dom/server.bun.js
+++ b/packages/react-dom/server.bun.js
@@ -18,13 +18,6 @@ export function renderToReadableStream() {
   );
 }
 
-export function renderToNodeStream() {
-  return require('./src/server/react-dom-server.bun').renderToNodeStream.apply(
-    this,
-    arguments,
-  );
-}
-
 export function renderToStaticNodeStream() {
   return require('./src/server/react-dom-server.bun').renderToStaticNodeStream.apply(
     this,
diff --git a/packages/react-dom/server.edge.js b/packages/react-dom/server.edge.js
index a48e6c7e0a459..d5a0ce6eb46f0 100644
--- a/packages/react-dom/server.edge.js
+++ b/packages/react-dom/server.edge.js
@@ -18,13 +18,6 @@ export function renderToReadableStream() {
   );
 }
 
-export function renderToNodeStream() {
-  return require('./src/server/react-dom-server.edge').renderToNodeStream.apply(
-    this,
-    arguments,
-  );
-}
-
 export function renderToStaticNodeStream() {
   return require('./src/server/react-dom-server.edge').renderToStaticNodeStream.apply(
     this,
diff --git a/packages/react-dom/server.node.js b/packages/react-dom/server.node.js
index d0e403eaf89b6..acdaa234f3c55 100644
--- a/packages/react-dom/server.node.js
+++ b/packages/react-dom/server.node.js
@@ -23,12 +23,6 @@ export function renderToStaticMarkup() {
     arguments,
   );
 }
-export function renderToNodeStream() {
-  return require('./src/server/ReactDOMLegacyServerNode').renderToNodeStream.apply(
-    this,
-    arguments,
-  );
-}
 export function renderToStaticNodeStream() {
   return require('./src/server/ReactDOMLegacyServerNode').renderToStaticNodeStream.apply(
     this,
diff --git a/packages/react-dom/src/ReactDOMSharedInternals.js b/packages/react-dom/src/ReactDOMSharedInternals.js
index 9f721b718b819..6de3648103591 100644
--- a/packages/react-dom/src/ReactDOMSharedInternals.js
+++ b/packages/react-dom/src/ReactDOMSharedInternals.js
@@ -7,6 +7,7 @@
  * @flow
  */
 
+import type {FindDOMNodeType} from './client/ReactDOMLegacy.js';
 import type {HostDispatcher} from './shared/ReactDOMTypes';
 
 type InternalsType = {
@@ -15,6 +16,7 @@ type InternalsType = {
   ReactDOMCurrentDispatcher: {
     current: HostDispatcher,
   },
+  findDOMNode: null | FindDOMNodeType,
 };
 
 function noop() {}
@@ -35,6 +37,7 @@ const Internals: InternalsType = ({
   ReactDOMCurrentDispatcher: {
     current: DefaultDispatcher,
   },
+  findDOMNode: null,
 }: any);
 
 export default Internals;
diff --git a/packages/react-dom/src/__tests__/DOMPropertyOperations-test.js b/packages/react-dom/src/__tests__/DOMPropertyOperations-test.js
index 87885ca07b4a5..1ca571df71cc8 100644
--- a/packages/react-dom/src/__tests__/DOMPropertyOperations-test.js
+++ b/packages/react-dom/src/__tests__/DOMPropertyOperations-test.js
@@ -10,10 +10,7 @@
 'use strict';
 
 // Set by `yarn test-fire`.
-const {
-  enableCustomElementPropertySupport,
-  disableInputAttributeSyncing,
-} = require('shared/ReactFeatureFlags');
+const {disableInputAttributeSyncing} = require('shared/ReactFeatureFlags');
 
 describe('DOMPropertyOperations', () => {
   let React;
@@ -234,7 +231,6 @@ describe('DOMPropertyOperations', () => {
       expect(container.firstChild.hasAttribute('value')).toBe(false);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element custom events lowercase', async () => {
       const oncustomevent = jest.fn();
       function Test() {
@@ -251,7 +247,6 @@ describe('DOMPropertyOperations', () => {
       expect(oncustomevent).toHaveBeenCalledTimes(1);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element custom events uppercase', async () => {
       const oncustomevent = jest.fn();
       function Test() {
@@ -268,7 +263,6 @@ describe('DOMPropertyOperations', () => {
       expect(oncustomevent).toHaveBeenCalledTimes(1);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element custom event with dash in name', async () => {
       const oncustomevent = jest.fn();
       function Test() {
@@ -285,7 +279,6 @@ describe('DOMPropertyOperations', () => {
       expect(oncustomevent).toHaveBeenCalledTimes(1);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element remove event handler', async () => {
       const oncustomevent = jest.fn();
       function Test(props) {
@@ -343,12 +336,8 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.getAttribute('onstring')).toBe('hello');
       expect(customElement.getAttribute('onobj')).toBe('[object Object]');
       expect(customElement.getAttribute('onarray')).toBe('one,two');
-      expect(customElement.getAttribute('ontrue')).toBe(
-        enableCustomElementPropertySupport ? '' : 'true',
-      );
-      expect(customElement.getAttribute('onfalse')).toBe(
-        enableCustomElementPropertySupport ? null : 'false',
-      );
+      expect(customElement.getAttribute('ontrue')).toBe('');
+      expect(customElement.getAttribute('onfalse')).toBe(null);
 
       // Dispatch the corresponding event names to make sure that nothing crashes.
       customElement.dispatchEvent(new Event('string'));
@@ -385,7 +374,6 @@ describe('DOMPropertyOperations', () => {
       expect(syntheticClickEvent.nativeEvent).toBe(nativeClickEvent);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom elements should have working onChange event listeners', async () => {
       let reactChangeEvent = null;
       const eventHandler = jest.fn(event => (reactChangeEvent = event));
@@ -450,7 +438,6 @@ describe('DOMPropertyOperations', () => {
       expect(eventHandler).toHaveBeenCalledTimes(expectedHandlerCallCount);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom elements should have separate onInput and onChange handling', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -476,7 +463,6 @@ describe('DOMPropertyOperations', () => {
       expect(changeEventHandler).toHaveBeenCalledTimes(1);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom elements should be able to remove and re-add custom event listeners', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -758,7 +744,6 @@ describe('DOMPropertyOperations', () => {
       expect(customOnClickHandler).toHaveBeenCalledTimes(0);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('onChange/onInput/onClick on div with various types of children', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -951,7 +936,6 @@ describe('DOMPropertyOperations', () => {
       expect(onClickHandler).toBeCalledTimes(1);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element onChange/onInput/onClick with event target custom element child', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -987,7 +971,6 @@ describe('DOMPropertyOperations', () => {
       expect(onClickHandler).toBeCalledTimes(1);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom elements should allow custom events with capture event listeners', async () => {
       const oncustomeventCapture = jest.fn();
       const oncustomevent = jest.fn();
@@ -1031,7 +1014,6 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.hasChildNodes()).toBe(false);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('innerText should not work on custom elements', async () => {
       const container = document.createElement('div');
       const root = ReactDOMClient.createRoot(container);
@@ -1051,7 +1033,6 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.hasChildNodes()).toBe(false);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('textContent should not work on custom elements', async () => {
       const container = document.createElement('div');
       const root = ReactDOMClient.createRoot(container);
@@ -1071,7 +1052,6 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.hasChildNodes()).toBe(false);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('values should not be converted to booleans when assigning into custom elements', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -1123,7 +1103,6 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.foo).toBe(null);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('boolean props should not be stringified in attributes', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -1143,7 +1122,6 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.getAttribute('foo')).toBe(null);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element custom event handlers assign multiple types', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -1197,7 +1175,6 @@ describe('DOMPropertyOperations', () => {
       expect(customelement.getAttribute('oncustomevent')).toBe(null);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element custom event handlers assign multiple types with setter', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -1257,7 +1234,6 @@ describe('DOMPropertyOperations', () => {
       expect(customelement.getAttribute('oncustomevent')).toBe(null);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('assigning to a custom element property should not remove attributes', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
@@ -1284,7 +1260,6 @@ describe('DOMPropertyOperations', () => {
       expect(customElement.getAttribute('foo')).toBe('one');
     });
 
-    // @gate enableCustomElementPropertySupport
     it('custom element properties should accept functions', async () => {
       const container = document.createElement('div');
       document.body.appendChild(container);
diff --git a/packages/react-dom/src/__tests__/InvalidEventListeners-test.js b/packages/react-dom/src/__tests__/InvalidEventListeners-test.js
index e412256ab2678..d7045d2756ad4 100644
--- a/packages/react-dom/src/__tests__/InvalidEventListeners-test.js
+++ b/packages/react-dom/src/__tests__/InvalidEventListeners-test.js
@@ -51,13 +51,11 @@ describe('InvalidEventListeners', () => {
     }
     window.addEventListener('error', handleWindowError);
     try {
-      await act(() => {
-        node.dispatchEvent(
-          new MouseEvent('click', {
-            bubbles: true,
-          }),
-        );
-      });
+      node.dispatchEvent(
+        new MouseEvent('click', {
+          bubbles: true,
+        }),
+      );
     } finally {
       window.removeEventListener('error', handleWindowError);
     }
diff --git a/packages/react-dom/src/__tests__/ReactBrowserEventEmitter-test.js b/packages/react-dom/src/__tests__/ReactBrowserEventEmitter-test.js
index 9c023f06d9d2a..965c20dbddf53 100644
--- a/packages/react-dom/src/__tests__/ReactBrowserEventEmitter-test.js
+++ b/packages/react-dom/src/__tests__/ReactBrowserEventEmitter-test.js
@@ -195,9 +195,7 @@ describe('ReactBrowserEventEmitter', () => {
     });
     window.addEventListener('error', errorHandler);
     try {
-      await act(() => {
-        CHILD.click();
-      });
+      CHILD.click();
       expect(idCallOrder.length).toBe(3);
       expect(idCallOrder[0]).toBe(CHILD);
       expect(idCallOrder[1]).toBe(PARENT);
diff --git a/packages/react-dom/src/__tests__/ReactComponentLifeCycle-test.js b/packages/react-dom/src/__tests__/ReactComponentLifeCycle-test.js
index 9fc7498c10730..f89e95bcf5dde 100644
--- a/packages/react-dom/src/__tests__/ReactComponentLifeCycle-test.js
+++ b/packages/react-dom/src/__tests__/ReactComponentLifeCycle-test.js
@@ -14,7 +14,7 @@ let act;
 let React;
 let ReactDOM;
 let ReactDOMClient;
-let PropTypes;
+let findDOMNode;
 
 const clone = function (o) {
   return JSON.parse(JSON.stringify(o));
@@ -95,8 +95,9 @@ describe('ReactComponentLifeCycle', () => {
 
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     ReactDOMClient = require('react-dom/client');
-    PropTypes = require('prop-types');
   });
 
   it('should not reuse an instance when it has been unmounted', async () => {
@@ -383,7 +384,7 @@ describe('ReactComponentLifeCycle', () => {
       }
       render() {
         if (this.state.isMounted) {
-          expect(ReactDOM.findDOMNode(this).tagName).toBe('DIV');
+          expect(findDOMNode(this).tagName).toBe('DIV');
         }
         return <div />;
       }
@@ -1111,72 +1112,6 @@ describe('ReactComponentLifeCycle', () => {
     });
   });
 
-  if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-    // @gate !disableLegacyContext
-    it('calls effects on module-pattern component', async () => {
-      const log = [];
-
-      function Parent() {
-        return {
-          render() {
-            expect(typeof this.props).toBe('object');
-            log.push('render');
-            return <Child />;
-          },
-          UNSAFE_componentWillMount() {
-            log.push('will mount');
-          },
-          componentDidMount() {
-            log.push('did mount');
-          },
-          componentDidUpdate() {
-            log.push('did update');
-          },
-          getChildContext() {
-            return {x: 2};
-          },
-        };
-      }
-      Parent.childContextTypes = {
-        x: PropTypes.number,
-      };
-      function Child(props, context) {
-        expect(context.x).toBe(2);
-        return <div />;
-      }
-      Child.contextTypes = {
-        x: PropTypes.number,
-      };
-
-      const root = ReactDOMClient.createRoot(document.createElement('div'));
-      await expect(async () => {
-        await act(() => {
-          root.render(<Parent ref={c => c && log.push('ref')} />);
-        });
-      }).toErrorDev(
-        'Warning: The <Parent /> component appears to be a function component that returns a class instance. ' +
-          'Change Parent to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`Parent.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
-      );
-      await act(() => {
-        root.render(<Parent ref={c => c && log.push('ref')} />);
-      });
-
-      expect(log).toEqual([
-        'will mount',
-        'render',
-        'did mount',
-        'ref',
-
-        'render',
-        'did update',
-        'ref',
-      ]);
-    });
-  }
-
   it('should warn if getDerivedStateFromProps returns undefined', async () => {
     class MyComponent extends React.Component {
       state = {};
diff --git a/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js b/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js
index bf082369e0610..5959cdefccfe3 100644
--- a/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js
+++ b/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js
@@ -211,64 +211,35 @@ describe('ReactCompositeComponent', () => {
     });
   });
 
-  if (require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-    it('should not support module pattern components', async () => {
-      function Child({test}) {
-        return {
-          render() {
-            return <div>{test}</div>;
-          },
-        };
-      }
-
-      const el = document.createElement('div');
-      const root = ReactDOMClient.createRoot(el);
-      expect(() => {
-        expect(() => {
-          ReactDOM.flushSync(() => {
-            root.render(<Child test="test" />);
-          });
-        }).toThrow(
-          'Objects are not valid as a React child (found: object with keys {render}).',
-        );
-      }).toErrorDev(
-        'Warning: The <Child /> component appears to be a function component that returns a class instance. ' +
-          'Change Child to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`Child.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
-      );
-
-      expect(el.textContent).toBe('');
-    });
-  } else {
-    it('should support module pattern components', () => {
-      function Child({test}) {
-        return {
-          render() {
-            return <div>{test}</div>;
-          },
-        };
-      }
+  it('should not support module pattern components', async () => {
+    function Child({test}) {
+      return {
+        render() {
+          return <div>{test}</div>;
+        },
+      };
+    }
 
-      const el = document.createElement('div');
-      const root = ReactDOMClient.createRoot(el);
-      expect(() => {
-        ReactDOM.flushSync(() => {
+    const el = document.createElement('div');
+    const root = ReactDOMClient.createRoot(el);
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
           root.render(<Child test="test" />);
         });
-      }).toErrorDev(
-        'Warning: The <Child /> component appears to be a function component that returns a class instance. ' +
-          'Change Child to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`Child.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
+      }).rejects.toThrow(
+        'Objects are not valid as a React child (found: object with keys {render}).',
       );
+    }).toErrorDev(
+      'Warning: The <Child /> component appears to be a function component that returns a class instance. ' +
+        'Change Child to a class that extends React.Component instead. ' +
+        "If you can't use a class try assigning the prototype on the function as a workaround. " +
+        '`Child.prototype = React.Component.prototype`. ' +
+        "Don't use an arrow function since it cannot be called with `new` by React.",
+    );
 
-      expect(el.textContent).toBe('test');
-    });
-  }
-
+    expect(el.textContent).toBe('');
+  });
   it('should use default values for undefined props', async () => {
     class Component extends React.Component {
       static defaultProps = {prop: 'testKey'};
@@ -526,12 +497,12 @@ describe('ReactCompositeComponent', () => {
       }
     }
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      expect(() => {
-        ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
           root.render(<ClassWithRenderNotExtended />);
         });
-      }).toThrow(TypeError);
+      }).rejects.toThrow(TypeError);
     }).toErrorDev(
       'Warning: The <ClassWithRenderNotExtended /> component appears to have a render method, ' +
         "but doesn't extend React.Component. This is likely to cause errors. " +
@@ -539,11 +510,11 @@ describe('ReactCompositeComponent', () => {
     );
 
     // Test deduplication
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<ClassWithRenderNotExtended />);
       });
-    }).toThrow(TypeError);
+    }).rejects.toThrow(TypeError);
   });
 
   it('should warn about `setState` in render', async () => {
@@ -596,11 +567,11 @@ describe('ReactCompositeComponent', () => {
     expect(ReactCurrentOwner.current).toBe(null);
 
     const root = ReactDOMClient.createRoot(document.createElement('div'));
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(instance);
       });
-    }).toThrow();
+    }).rejects.toThrow();
 
     expect(ReactCurrentOwner.current).toBe(null);
   });
@@ -884,7 +855,7 @@ describe('ReactCompositeComponent', () => {
     );
   });
 
-  it('should only call componentWillUnmount once', () => {
+  it('should only call componentWillUnmount once', async () => {
     let app;
     let count = 0;
 
@@ -919,14 +890,14 @@ describe('ReactCompositeComponent', () => {
     };
 
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<App ref={setRef} stage={1} />);
       });
-      ReactDOM.flushSync(() => {
+      await act(() => {
         root.render(<App ref={setRef} stage={2} />);
       });
-    }).toThrow();
+    }).rejects.toThrow();
     expect(count).toBe(1);
   });
 
@@ -1211,7 +1182,7 @@ describe('ReactCompositeComponent', () => {
     assertLog(['setState callback called']);
   });
 
-  it('should return a meaningful warning when constructor is returned', () => {
+  it('should return a meaningful warning when constructor is returned', async () => {
     class RenderTextInvalidConstructor extends React.Component {
       constructor(props) {
         super(props);
@@ -1224,12 +1195,12 @@ describe('ReactCompositeComponent', () => {
     }
 
     const root = ReactDOMClient.createRoot(document.createElement('div'));
-    expect(() => {
-      expect(() => {
-        ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
           root.render(<RenderTextInvalidConstructor />);
         });
-      }).toThrow();
+      }).rejects.toThrow();
     }).toErrorDev([
       'Warning: No `render` method found on the RenderTextInvalidConstructor instance: ' +
         'did you accidentally return an object from the constructor?',
@@ -1260,16 +1231,16 @@ describe('ReactCompositeComponent', () => {
     );
   });
 
-  it('should return error if render is not defined', () => {
+  it('should return error if render is not defined', async () => {
     class RenderTestUndefinedRender extends React.Component {}
 
     const root = ReactDOMClient.createRoot(document.createElement('div'));
-    expect(() => {
-      expect(() => {
-        ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
           root.render(<RenderTestUndefinedRender />);
         });
-      }).toThrow();
+      }).rejects.toThrow();
     }).toErrorDev([
       'Warning: No `render` method found on the RenderTestUndefinedRender instance: ' +
         'you may have forgotten to define `render`.',
diff --git a/packages/react-dom/src/__tests__/ReactCompositeComponentState-test.js b/packages/react-dom/src/__tests__/ReactCompositeComponentState-test.js
index a1d3d28533fe9..ecb30f0f1d78e 100644
--- a/packages/react-dom/src/__tests__/ReactCompositeComponentState-test.js
+++ b/packages/react-dom/src/__tests__/ReactCompositeComponentState-test.js
@@ -527,72 +527,6 @@ describe('ReactCompositeComponent-state', () => {
     ]);
   });
 
-  if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-    it('should support stateful module pattern components', async () => {
-      function Child() {
-        return {
-          state: {
-            count: 123,
-          },
-          render() {
-            return <div>{`count:${this.state.count}`}</div>;
-          },
-        };
-      }
-
-      const el = document.createElement('div');
-      const root = ReactDOMClient.createRoot(el);
-      expect(() => {
-        ReactDOM.flushSync(() => {
-          root.render(<Child />);
-        });
-      }).toErrorDev(
-        'Warning: The <Child /> component appears to be a function component that returns a class instance. ' +
-          'Change Child to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`Child.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
-      );
-
-      expect(el.textContent).toBe('count:123');
-    });
-
-    it('should support getDerivedStateFromProps for module pattern components', async () => {
-      function Child() {
-        return {
-          state: {
-            count: 1,
-          },
-          render() {
-            return <div>{`count:${this.state.count}`}</div>;
-          },
-        };
-      }
-      Child.getDerivedStateFromProps = (props, prevState) => {
-        return {
-          count: prevState.count + props.incrementBy,
-        };
-      };
-
-      const el = document.createElement('div');
-      const root = ReactDOMClient.createRoot(el);
-      await act(() => {
-        root.render(<Child incrementBy={0} />);
-      });
-
-      expect(el.textContent).toBe('count:1');
-      await act(() => {
-        root.render(<Child incrementBy={2} />);
-      });
-      expect(el.textContent).toBe('count:3');
-
-      await act(() => {
-        root.render(<Child incrementBy={1} />);
-      });
-      expect(el.textContent).toBe('count:4');
-    });
-  }
-
   it('should not support setState in componentWillUnmount', async () => {
     let subscription;
     class A extends React.Component {
diff --git a/packages/react-dom/src/__tests__/ReactDOM-test.js b/packages/react-dom/src/__tests__/ReactDOM-test.js
index 83e3e0229d7b1..2cb0f24e6944a 100644
--- a/packages/react-dom/src/__tests__/ReactDOM-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOM-test.js
@@ -11,6 +11,7 @@
 
 let React;
 let ReactDOM;
+let findDOMNode;
 let ReactDOMClient;
 let ReactDOMServer;
 
@@ -21,6 +22,8 @@ describe('ReactDOM', () => {
     jest.resetModules();
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     ReactDOMClient = require('react-dom/client');
     ReactDOMServer = require('react-dom/server');
 
@@ -166,6 +169,9 @@ describe('ReactDOM', () => {
 
   // @gate !disableLegacyMode
   it('throws in render() if the mount callback in legacy roots is not a function', async () => {
+    spyOnDev(console, 'warn');
+    spyOnDev(console, 'error');
+
     function Foo() {
       this.a = 1;
       this.b = 2;
@@ -180,40 +186,55 @@ describe('ReactDOM', () => {
     }
 
     const myDiv = document.createElement('div');
-    expect(() => {
-      expect(() => {
-        ReactDOM.render(<A />, myDiv, 'no');
-      }).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: no.',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<A />, myDiv, 'no');
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: no',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: no',
+    }).toErrorDev(
+      [
+        'Warning: Expected the last optional `callback` argument to be a function. Instead received: no.',
+        'Warning: Expected the last optional `callback` argument to be a function. Instead received: no.',
+      ],
+      {withoutStack: 2},
     );
 
-    expect(() => {
-      expect(() => {
-        ReactDOM.render(<A />, myDiv, {foo: 'bar'});
-      }).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: [object Object].',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<A />, myDiv, {foo: 'bar'});
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: [object Object]',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: [object Object]',
+    }).toErrorDev(
+      [
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+      ],
+      {withoutStack: 2},
     );
 
-    expect(() => {
-      expect(() => {
-        ReactDOM.render(<A />, myDiv, new Foo());
-      }).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: [object Object].',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<A />, myDiv, new Foo());
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: [object Object]',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: [object Object]',
+    }).toErrorDev(
+      [
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+      ],
+      {withoutStack: 2},
     );
   });
 
@@ -234,42 +255,57 @@ describe('ReactDOM', () => {
 
     const myDiv = document.createElement('div');
     ReactDOM.render(<A />, myDiv);
-    expect(() => {
-      expect(() => {
-        ReactDOM.render(<A />, myDiv, 'no');
-      }).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: no.',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<A />, myDiv, 'no');
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: no',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: no',
+    }).toErrorDev(
+      [
+        'Expected the last optional `callback` argument to be a function. Instead received: no.',
+        'Expected the last optional `callback` argument to be a function. Instead received: no.',
+      ],
+      {withoutStack: 2},
     );
 
     ReactDOM.render(<A />, myDiv); // Re-mount
-    expect(() => {
-      expect(() => {
-        ReactDOM.render(<A />, myDiv, {foo: 'bar'});
-      }).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: [object Object].',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<A />, myDiv, {foo: 'bar'});
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: [object Object]',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: [object Object]',
+    }).toErrorDev(
+      [
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+      ],
+      {withoutStack: 2},
     );
 
     ReactDOM.render(<A />, myDiv); // Re-mount
-    expect(() => {
-      expect(() => {
-        ReactDOM.render(<A />, myDiv, new Foo());
-      }).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: [object Object].',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<A />, myDiv, new Foo());
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: [object Object]',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: [object Object]',
+    }).toErrorDev(
+      [
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+        'Expected the last optional `callback` argument to be a function. Instead received: [object Object].',
+      ],
+      {withoutStack: 2},
     );
   });
 
@@ -461,7 +497,7 @@ describe('ReactDOM', () => {
     });
 
     const App = () => {
-      ReactDOM.findDOMNode(instance);
+      findDOMNode(instance);
       return <div />;
     };
 
diff --git a/packages/react-dom/src/__tests__/ReactDOMAttribute-test.js b/packages/react-dom/src/__tests__/ReactDOMAttribute-test.js
index 402693c407d5c..13fa1cba4993d 100644
--- a/packages/react-dom/src/__tests__/ReactDOMAttribute-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMAttribute-test.js
@@ -12,14 +12,12 @@
 describe('ReactDOM unknown attribute', () => {
   let React;
   let ReactDOMClient;
-  let ReactFeatureFlags;
   let act;
 
   beforeEach(() => {
     jest.resetModules();
     React = require('react');
     ReactDOMClient = require('react-dom/client');
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
     act = require('internal-test-utils').act;
   });
 
@@ -98,15 +96,9 @@ describe('ReactDOM unknown attribute', () => {
         await act(() => {
           root.render(<div inert={true} />);
         });
-      }).toErrorDev(
-        ReactFeatureFlags.enableNewBooleanProps
-          ? []
-          : ['Warning: Received `true` for a non-boolean attribute `inert`.'],
-      );
+      }).toErrorDev([]);
 
-      expect(el.firstChild.getAttribute('inert')).toBe(
-        ReactFeatureFlags.enableNewBooleanProps ? '' : null,
-      );
+      expect(el.firstChild.getAttribute('inert')).toBe(true ? '' : null);
     });
 
     it('warns once for empty strings in new boolean props', async () => {
@@ -117,20 +109,14 @@ describe('ReactDOM unknown attribute', () => {
         await act(() => {
           root.render(<div inert="" />);
         });
-      }).toErrorDev(
-        ReactFeatureFlags.enableNewBooleanProps
-          ? [
-              'Warning: Received an empty string for a boolean attribute `inert`. ' +
-                'This will treat the attribute as if it were false. ' +
-                'Either pass `false` to silence this warning, or ' +
-                'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
-            ]
-          : [],
-      );
-
-      expect(el.firstChild.getAttribute('inert')).toBe(
-        ReactFeatureFlags.enableNewBooleanProps ? null : '',
-      );
+      }).toErrorDev([
+        'Warning: Received an empty string for a boolean attribute `inert`. ' +
+          'This will treat the attribute as if it were false. ' +
+          'Either pass `false` to silence this warning, or ' +
+          'pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.',
+      ]);
+
+      expect(el.firstChild.getAttribute('inert')).toBe(true ? null : '');
 
       // The warning is only printed once.
       await act(() => {
diff --git a/packages/react-dom/src/__tests__/ReactDOMComponent-test.js b/packages/react-dom/src/__tests__/ReactDOMComponent-test.js
index 5c62605af2bc4..5f2c3d14c80e0 100644
--- a/packages/react-dom/src/__tests__/ReactDOMComponent-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMComponent-test.js
@@ -2121,7 +2121,11 @@ describe('ReactDOMComponent', () => {
 
         componentWillUnmount() {
           // Should not throw
-          expect(ReactDOM.findDOMNode(this).nodeName).toBe('SPAN');
+          expect(
+            ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+              this,
+            ).nodeName,
+          ).toBe('SPAN');
         }
       }
 
@@ -3545,15 +3549,11 @@ describe('ReactDOMComponent', () => {
         root.render(<some-custom-element foo={true} />);
       });
       const node = container.firstChild;
-      expect(node.getAttribute('foo')).toBe(
-        ReactFeatureFlags.enableCustomElementPropertySupport ? '' : 'true',
-      );
+      expect(node.getAttribute('foo')).toBe('');
       await act(() => {
         root.render(<some-custom-element foo={false} />);
       });
-      expect(node.getAttribute('foo')).toBe(
-        ReactFeatureFlags.enableCustomElementPropertySupport ? null : 'false',
-      );
+      expect(node.getAttribute('foo')).toBe(null);
       await act(() => {
         root.render(<some-custom-element />);
       });
diff --git a/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReporting-test.js b/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReporting-test.js
index bd80905478bf0..65aa67d342579 100644
--- a/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReporting-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReporting-test.js
@@ -16,16 +16,14 @@ describe('ReactDOMConsoleErrorReporting', () => {
   let NoError;
   let container;
   let windowOnError;
-  let waitForThrow;
+  let Scheduler;
 
   beforeEach(() => {
     jest.resetModules();
     act = require('internal-test-utils').act;
     React = require('react');
     ReactDOMClient = require('react-dom/client');
-
-    const InternalTestUtils = require('internal-test-utils');
-    waitForThrow = InternalTestUtils.waitForThrow;
+    Scheduler = require('scheduler');
 
     ErrorBoundary = class extends React.Component {
       state = {error: null};
@@ -46,6 +44,8 @@ describe('ReactDOMConsoleErrorReporting', () => {
     document.body.appendChild(container);
     windowOnError = jest.fn();
     window.addEventListener('error', windowOnError);
+    spyOnDevAndProd(console, 'error').mockImplementation(() => {});
+    spyOnDevAndProd(console, 'warn').mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -54,11 +54,14 @@ describe('ReactDOMConsoleErrorReporting', () => {
     jest.restoreAllMocks();
   });
 
+  async function fakeAct(cb) {
+    // We don't use act/waitForThrow here because we want to observe how errors are reported for real.
+    await cb();
+    Scheduler.unstable_flushAll();
+  }
+
   describe('ReactDOMClient.createRoot', () => {
     it('logs errors during event handlers', async () => {
-      const originalError = console.error;
-      console.error = jest.fn();
-
       function Foo() {
         return (
           <button
@@ -75,13 +78,11 @@ describe('ReactDOMConsoleErrorReporting', () => {
         root.render(<Foo />);
       });
 
-      await act(() => {
-        container.firstChild.dispatchEvent(
-          new MouseEvent('click', {
-            bubbles: true,
-          }),
-        );
-      });
+      container.firstChild.dispatchEvent(
+        new MouseEvent('click', {
+          bubbles: true,
+        }),
+      );
 
       expect(windowOnError.mock.calls).toEqual([
         [
@@ -95,58 +96,64 @@ describe('ReactDOMConsoleErrorReporting', () => {
         [
           // Reported because we're in a browser click event:
           expect.objectContaining({
-            detail: expect.objectContaining({
-              message: 'Boom',
-            }),
-            type: 'unhandled exception',
+            message: 'Boom',
           }),
         ],
       ]);
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
-      console.error = originalError;
+      console.error.mockReset();
       await act(() => {
         root.render(<NoError />);
       });
       expect(container.textContent).toBe('OK');
       expect(windowOnError.mock.calls).toEqual([]);
+      expect(console.error.mock.calls).toEqual([]);
     });
 
     it('logs render errors without an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         throw Error('Boom');
       }
 
       const root = ReactDOMClient.createRoot(container);
-      await act(async () => {
+      await fakeAct(() => {
         root.render(<Foo />);
-        await waitForThrow('Boom');
       });
 
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
+        expect(windowOnError.mock.calls).toEqual([
+          [
+            expect.objectContaining({
+              message: 'Boom',
+            }),
+          ],
+        ]);
         expect(console.error.mock.calls).toEqual([
           [
-            // Formatting
-            expect.stringContaining('%o'),
             expect.objectContaining({
               message: 'Boom',
             }),
+          ],
+        ]);
+        expect(console.warn.mock.calls).toEqual([
+          [
             // Addendum by React:
-            expect.stringContaining(
-              'The above error occurred in the <Foo> component',
-            ),
+            expect.stringContaining('%s'),
+            expect.stringContaining('An error occurred in the <Foo> component'),
             expect.stringContaining('Foo'),
             expect.stringContaining('Consider adding an error boundary'),
           ],
         ]);
       } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
+        expect(windowOnError.mock.calls).toEqual([
+          [
+            expect.objectContaining({
+              message: 'Boom',
+            }),
+          ],
+        ]);
         expect(console.error.mock.calls).toEqual([
           [
             // Reported by React with no extra message:
@@ -155,6 +162,7 @@ describe('ReactDOMConsoleErrorReporting', () => {
             }),
           ],
         ]);
+        expect(console.warn.mock.calls).toEqual([]);
       }
 
       // Check next render doesn't throw.
@@ -241,24 +249,30 @@ describe('ReactDOMConsoleErrorReporting', () => {
       }
 
       const root = ReactDOMClient.createRoot(container);
-      await act(async () => {
+      await fakeAct(() => {
         root.render(<Foo />);
-        await waitForThrow('Boom');
       });
 
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
+        expect(windowOnError.mock.calls).toEqual([
+          [
+            expect.objectContaining({
+              message: 'Boom',
+            }),
+          ],
+        ]);
         expect(console.error.mock.calls).toEqual([
           [
-            // Formatting
-            expect.stringContaining('%o'),
             expect.objectContaining({
               message: 'Boom',
             }),
+          ],
+        ]);
+        expect(console.warn.mock.calls).toEqual([
+          [
             // Addendum by React:
-            expect.stringContaining(
-              'The above error occurred in the <Foo> component',
-            ),
+            expect.stringContaining('%s'),
+            expect.stringContaining('An error occurred in the <Foo> component'),
             expect.stringContaining('Foo'),
             expect.stringContaining('Consider adding an error boundary'),
           ],
@@ -266,7 +280,13 @@ describe('ReactDOMConsoleErrorReporting', () => {
       } else {
         // The top-level error was caught with try/catch,
         // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
+        expect(windowOnError.mock.calls).toEqual([
+          [
+            expect.objectContaining({
+              message: 'Boom',
+            }),
+          ],
+        ]);
         expect(console.error.mock.calls).toEqual([
           [
             // Reported by React with no extra message:
@@ -275,6 +295,7 @@ describe('ReactDOMConsoleErrorReporting', () => {
             }),
           ],
         ]);
+        expect(console.warn.mock.calls).toEqual([]);
       }
 
       // Check next render doesn't throw.
@@ -364,32 +385,42 @@ describe('ReactDOMConsoleErrorReporting', () => {
       }
 
       const root = ReactDOMClient.createRoot(container);
-      await act(async () => {
+      await fakeAct(() => {
         root.render(<Foo />);
-        await waitForThrow('Boom');
       });
 
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
+        expect(windowOnError.mock.calls).toEqual([
+          [
+            expect.objectContaining({
+              message: 'Boom',
+            }),
+          ],
+        ]);
         expect(console.error.mock.calls).toEqual([
           [
-            // Formatting
-            expect.stringContaining('%o'),
             expect.objectContaining({
               message: 'Boom',
             }),
+          ],
+        ]);
+        expect(console.warn.mock.calls).toEqual([
+          [
             // Addendum by React:
-            expect.stringContaining(
-              'The above error occurred in the <Foo> component',
-            ),
+            expect.stringContaining('%s'),
+            expect.stringContaining('An error occurred in the <Foo> component'),
             expect.stringContaining('Foo'),
             expect.stringContaining('Consider adding an error boundary'),
           ],
         ]);
       } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
+        expect(windowOnError.mock.calls).toEqual([
+          [
+            expect.objectContaining({
+              message: 'Boom',
+            }),
+          ],
+        ]);
         expect(console.error.mock.calls).toEqual([
           [
             // Reported by React with no extra message:
@@ -398,6 +429,7 @@ describe('ReactDOMConsoleErrorReporting', () => {
             }),
           ],
         ]);
+        expect(console.warn.mock.calls).toEqual([]);
       }
 
       // Check next render doesn't throw.
diff --git a/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReportingLegacy-test.js b/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReportingLegacy-test.js
index e75b4b5e29045..02e34f9322f10 100644
--- a/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReportingLegacy-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMConsoleErrorReportingLegacy-test.js
@@ -46,6 +46,8 @@ describe('ReactDOMConsoleErrorReporting', () => {
     document.body.appendChild(container);
     windowOnError = jest.fn();
     window.addEventListener('error', windowOnError);
+    spyOnDevAndProd(console, 'error');
+    spyOnDevAndProd(console, 'warn');
   });
 
   afterEach(() => {
@@ -57,9 +59,6 @@ describe('ReactDOMConsoleErrorReporting', () => {
   describe('ReactDOM.render', () => {
     // @gate !disableLegacyMode
     it('logs errors during event handlers', async () => {
-      const originalError = console.error;
-      console.error = jest.fn();
-
       function Foo() {
         return (
           <button
@@ -75,136 +74,135 @@ describe('ReactDOMConsoleErrorReporting', () => {
         ReactDOM.render(<Foo />, container);
       });
 
-      await act(() => {
-        container.firstChild.dispatchEvent(
-          new MouseEvent('click', {
-            bubbles: true,
+      await expect(async () => {
+        await act(() => {
+          container.firstChild.dispatchEvent(
+            new MouseEvent('click', {
+              bubbles: true,
+            }),
+          );
+        });
+      }).rejects.toThrow(
+        expect.objectContaining({
+          message: 'Boom',
+        }),
+      );
+
+      // Reported because we're in a browser click event:
+      expect(windowOnError.mock.calls).toEqual([
+        [
+          expect.objectContaining({
+            message: 'Boom',
           }),
-        );
-      });
+        ],
+      ]);
+      expect(console.warn).not.toBeCalled();
 
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([
-          [
-            // Reported because we're in a browser click event:
-            expect.objectContaining({
-              message: 'Boom',
-            }),
-          ],
-        ]);
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
           [
-            // Reported because we're in a browser click event:
-            expect.objectContaining({
-              detail: expect.objectContaining({
-                message: 'Boom',
-              }),
-              type: 'unhandled exception',
-            }),
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
           ],
         ]);
       } else {
-        expect(windowOnError.mock.calls).toEqual([
-          [
-            // Reported because we're in a browser click event:
-            expect.objectContaining({
-              message: 'Boom',
-            }),
-          ],
-        ]);
-        expect(console.error.mock.calls).toEqual([
-          [
-            // Reported because we're in a browser click event:
-            expect.objectContaining({
-              detail: expect.objectContaining({
-                message: 'Boom',
-              }),
-              type: 'unhandled exception',
-            }),
-          ],
-        ]);
+        expect(console.error).not.toBeCalled();
       }
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
+      console.warn.mockReset();
       console.error.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.error).not.toBeCalled();
       }
-
-      console.error = originalError;
     });
 
     // @gate !disableLegacyMode
     it('logs render errors without an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         throw Error('Boom');
       }
 
-      expect(() => {
-        ReactDOM.render(<Foo />, container);
-      }).toThrow('Boom');
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<Foo />, container);
+        });
+      }).rejects.toThrow('Boom');
+
+      // Reported because errors without a boundary are reported to window.
+      expect(windowOnError.mock.calls).toEqual([
+        [
+          expect.objectContaining({
+            message: 'Boom',
+          }),
+        ],
+      ]);
 
       if (__DEV__) {
-        expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+        expect(console.warn.mock.calls).toEqual([
           [
             // Formatting
-            expect.stringContaining('%o'),
-            expect.objectContaining({
-              message: 'Boom',
-            }),
+            expect.stringContaining('%s'),
             // Addendum by React:
-            expect.stringContaining(
-              'The above error occurred in the <Foo> component',
-            ),
+            expect.stringContaining('An error occurred in the <Foo> component'),
             expect.stringContaining('Foo'),
             expect.stringContaining('Consider adding an error boundary'),
           ],
         ]);
-      } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
+
         expect(console.error.mock.calls).toEqual([
           [
-            // Reported by React with no extra message:
-            expect.objectContaining({
-              message: 'Boom',
-            }),
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
           ],
         ]);
+      } else {
+        expect(console.warn).not.toBeCalled();
+        expect(console.error).not.toBeCalled();
       }
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
+      console.warn.mockReset();
       console.error.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(console.warn).not.toBeCalled();
+      expect(windowOnError).not.toBeCalled();
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.error).not.toBeCalled();
       }
     });
 
     // @gate !disableLegacyMode
     it('logs render errors with an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         throw Error('Boom');
       }
@@ -218,10 +216,18 @@ describe('ReactDOMConsoleErrorReporting', () => {
         );
       });
 
+      // The top-level error was caught with try/catch,
+      // so we don't see an error event.
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
+
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
           [
             // Formatting
             expect.stringContaining('%o'),
@@ -237,9 +243,6 @@ describe('ReactDOMConsoleErrorReporting', () => {
           ],
         ]);
       } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
         expect(console.error.mock.calls).toEqual([
           [
             // Reported by React with no extra message:
@@ -253,22 +256,28 @@ describe('ReactDOMConsoleErrorReporting', () => {
       // Check next render doesn't throw.
       windowOnError.mockReset();
       console.error.mockReset();
+      console.warn.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.error).not.toBeCalled();
       }
     });
 
     // @gate !disableLegacyMode
     it('logs layout effect errors without an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         React.useLayoutEffect(() => {
           throw Error('Boom');
@@ -276,61 +285,74 @@ describe('ReactDOMConsoleErrorReporting', () => {
         return null;
       }
 
-      expect(() => {
-        ReactDOM.render(<Foo />, container);
-      }).toThrow('Boom');
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<Foo />, container);
+        });
+      }).rejects.toThrow('Boom');
+
+      // Reported because errors without a boundary are reported to window.
+      expect(windowOnError.mock.calls).toEqual([
+        [
+          expect.objectContaining({
+            message: 'Boom',
+          }),
+        ],
+      ]);
 
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
-        expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+        expect(console.warn.mock.calls).toEqual([
           [
             // Formatting
-            expect.stringContaining('%o'),
-            expect.objectContaining({
-              message: 'Boom',
-            }),
+            expect.stringContaining('%s'),
+
             // Addendum by React:
             expect.stringContaining(
-              'The above error occurred in the <Foo> component',
+              'An error occurred in the <Foo> component:',
             ),
             expect.stringContaining('Foo'),
             expect.stringContaining('Consider adding an error boundary'),
           ],
         ]);
-      } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
+
         expect(console.error.mock.calls).toEqual([
           [
-            // Reported by React with no extra message:
-            expect.objectContaining({
-              message: 'Boom',
-            }),
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
           ],
         ]);
+      } else {
+        expect(console.warn).not.toBeCalled();
+        expect(console.error).not.toBeCalled();
       }
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
+      console.warn.mockReset();
       console.error.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(console.warn).not.toBeCalled();
+      expect(windowOnError).not.toBeCalled();
+
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.error).not.toBeCalled();
       }
     });
 
     // @gate !disableLegacyMode
     it('logs layout effect errors with an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         React.useLayoutEffect(() => {
           throw Error('Boom');
@@ -347,10 +369,18 @@ describe('ReactDOMConsoleErrorReporting', () => {
         );
       });
 
+      // The top-level error was caught with try/catch,
+      // so we don't see an error event.
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
+
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
           [
             // Formatting
             expect.stringContaining('%o'),
@@ -366,9 +396,6 @@ describe('ReactDOMConsoleErrorReporting', () => {
           ],
         ]);
       } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
         expect(console.error.mock.calls).toEqual([
           [
             // Reported by React with no extra message:
@@ -381,23 +408,29 @@ describe('ReactDOMConsoleErrorReporting', () => {
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
+      console.warn.mockReset();
       console.error.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.error).not.toBeCalled();
       }
     });
 
     // @gate !disableLegacyMode
     it('logs passive effect errors without an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         React.useEffect(() => {
           throw Error('Boom');
@@ -410,57 +443,66 @@ describe('ReactDOMConsoleErrorReporting', () => {
         await waitForThrow('Boom');
       });
 
+      // The top-level error was caught with try/catch,
+      // so we don't see an error event.
+      expect(windowOnError.mock.calls).toEqual([
+        [
+          expect.objectContaining({
+            message: 'Boom',
+          }),
+        ],
+      ]);
+
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
-        expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+        expect(console.warn.mock.calls).toEqual([
           [
             // Formatting
-            expect.stringContaining('%o'),
-            expect.objectContaining({
-              message: 'Boom',
-            }),
+            expect.stringContaining('%s'),
+
             // Addendum by React:
-            expect.stringContaining(
-              'The above error occurred in the <Foo> component',
-            ),
+            expect.stringContaining('An error occurred in the <Foo> component'),
             expect.stringContaining('Foo'),
             expect.stringContaining('Consider adding an error boundary'),
           ],
         ]);
-      } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
+
         expect(console.error.mock.calls).toEqual([
           [
-            // Reported by React with no extra message:
-            expect.objectContaining({
-              message: 'Boom',
-            }),
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
           ],
         ]);
+      } else {
+        expect(console.warn).not.toBeCalled();
+        expect(console.error).not.toBeCalled();
       }
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
+      console.warn.mockReset();
       console.error.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.error).not.toBeCalled();
       }
     });
 
     // @gate !disableLegacyMode
     it('logs passive effect errors with an error boundary', async () => {
-      spyOnDevAndProd(console, 'error');
-
       function Foo() {
         React.useEffect(() => {
           throw Error('Boom');
@@ -477,10 +519,18 @@ describe('ReactDOMConsoleErrorReporting', () => {
         );
       });
 
+      // The top-level error was caught with try/catch,
+      // so we don't see an error event.
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
+
       if (__DEV__) {
-        expect(windowOnError.mock.calls).toEqual([]);
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
           [
             // Formatting
             expect.stringContaining('%o'),
@@ -496,9 +546,6 @@ describe('ReactDOMConsoleErrorReporting', () => {
           ],
         ]);
       } else {
-        // The top-level error was caught with try/catch,
-        // so in production we don't see an error event.
-        expect(windowOnError.mock.calls).toEqual([]);
         expect(console.error.mock.calls).toEqual([
           [
             // Reported by React with no extra message:
@@ -511,16 +558,24 @@ describe('ReactDOMConsoleErrorReporting', () => {
 
       // Check next render doesn't throw.
       windowOnError.mockReset();
+      console.warn.mockReset();
       console.error.mockReset();
       await act(() => {
         ReactDOM.render(<NoError />, container);
       });
       expect(container.textContent).toBe('OK');
-      expect(windowOnError.mock.calls).toEqual([]);
+      expect(windowOnError).not.toBeCalled();
+      expect(console.warn).not.toBeCalled();
       if (__DEV__) {
         expect(console.error.mock.calls).toEqual([
-          [expect.stringContaining('ReactDOM.render is no longer supported')],
+          [
+            expect.stringContaining(
+              'ReactDOM.render has not been supported since React 18',
+            ),
+          ],
         ]);
+      } else {
+        expect(console.warn).not.toBeCalled();
       }
     });
   });
diff --git a/packages/react-dom/src/__tests__/ReactDOMEventListener-test.js b/packages/react-dom/src/__tests__/ReactDOMEventListener-test.js
index f059d7bd2f560..189bc1d99f423 100644
--- a/packages/react-dom/src/__tests__/ReactDOMEventListener-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMEventListener-test.js
@@ -114,10 +114,18 @@ describe('ReactDOMEventListener', () => {
             this.setState({clicked: true});
           };
           componentDidMount() {
-            expect(ReactDOM.findDOMNode(this)).toBe(container.firstChild);
+            expect(
+              ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+                this,
+              ),
+            ).toBe(container.firstChild);
           }
           componentDidUpdate() {
-            expect(ReactDOM.findDOMNode(this)).toBe(container.firstChild);
+            expect(
+              ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+                this,
+              ),
+            ).toBe(container.firstChild);
           }
           render() {
             if (this.state.clicked) {
diff --git a/packages/react-dom/src/__tests__/ReactDOMFiber-test.js b/packages/react-dom/src/__tests__/ReactDOMFiber-test.js
index 2882cab2e9991..f135bd288d19f 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFiber-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFiber-test.js
@@ -1108,11 +1108,13 @@ describe('ReactDOMFiber', () => {
     // It's an error of type 'NotFoundError' with no message
     container.innerHTML = '<div>MEOW.</div>';
 
-    expect(() => {
-      ReactDOM.flushSync(() => {
-        root.render(<div key="2">baz</div>);
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.flushSync(() => {
+          root.render(<div key="2">baz</div>);
+        });
       });
-    }).toThrow('The node to be removed is not a child of this node');
+    }).rejects.toThrow('The node to be removed is not a child of this node');
   });
 
   it('should not warn when doing an update to a container manually updated outside of React', async () => {
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzForm-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzForm-test.js
index ae56c5eae4dd2..f578748e923d2 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzForm-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzForm-test.js
@@ -23,7 +23,7 @@ let ReactDOMServer;
 let ReactDOMClient;
 let useFormStatus;
 let useOptimistic;
-let useFormState;
+let useActionState;
 
 describe('ReactDOMFizzForm', () => {
   beforeEach(() => {
@@ -32,11 +32,16 @@ describe('ReactDOMFizzForm', () => {
     ReactDOMServer = require('react-dom/server.browser');
     ReactDOMClient = require('react-dom/client');
     useFormStatus = require('react-dom').useFormStatus;
-    useFormState = require('react-dom').useFormState;
     useOptimistic = require('react').useOptimistic;
     act = require('internal-test-utils').act;
     container = document.createElement('div');
     document.body.appendChild(container);
+    if (__VARIANT__) {
+      // Remove after API is deleted.
+      useActionState = require('react-dom').useFormState;
+    } else {
+      useActionState = require('react').useActionState;
+    }
   });
 
   afterEach(() => {
@@ -76,7 +81,6 @@ describe('ReactDOMFizzForm', () => {
     insertNodesAndExecuteScripts(temp, container, null);
   }
 
-  // @gate enableFormActions
   it('should allow passing a function to form action during SSR', async () => {
     const ref = React.createRef();
     let foo;
@@ -103,7 +107,6 @@ describe('ReactDOMFizzForm', () => {
     expect(foo).toBe('bar');
   });
 
-  // @gate enableFormActions
   it('should allow passing a function to an input/button formAction', async () => {
     const inputRef = React.createRef();
     const buttonRef = React.createRef();
@@ -162,7 +165,6 @@ describe('ReactDOMFizzForm', () => {
     expect(rootActionCalled).toBe(false);
   });
 
-  // @gate enableFormActions || !__DEV__
   it('should warn when passing a function action during SSR and string during hydration', async () => {
     function action(formData) {}
     function App({isClient}) {
@@ -180,11 +182,11 @@ describe('ReactDOMFizzForm', () => {
         ReactDOMClient.hydrateRoot(container, <App isClient={true} />);
       });
     }).toErrorDev(
-      'Prop `action` did not match. Server: "function" Client: "action"',
+      "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+      {withoutStack: true},
     );
   });
 
-  // @gate enableFormActions || !__DEV__
   it('should ideally warn when passing a string during SSR and function during hydration', async () => {
     function action(formData) {}
     function App({isClient}) {
@@ -203,7 +205,6 @@ describe('ReactDOMFizzForm', () => {
     });
   });
 
-  // @gate enableFormActions || !__DEV__
   it('should reset form fields after you update away from hydrated function', async () => {
     const formRef = React.createRef();
     const inputRef = React.createRef();
@@ -259,7 +260,6 @@ describe('ReactDOMFizzForm', () => {
     expect(buttonRef.current.hasAttribute('formTarget')).toBe(false);
   });
 
-  // @gate enableFormActions || !__DEV__
   it('should reset form fields after you remove a hydrated function', async () => {
     const formRef = React.createRef();
     const inputRef = React.createRef();
@@ -305,7 +305,6 @@ describe('ReactDOMFizzForm', () => {
     expect(buttonRef.current.hasAttribute('formTarget')).toBe(false);
   });
 
-  // @gate enableFormActions || !__DEV__
   it('should restore the form fields even if they were incorrectly set', async () => {
     const formRef = React.createRef();
     const inputRef = React.createRef();
@@ -346,7 +345,12 @@ describe('ReactDOMFizzForm', () => {
       await act(async () => {
         root = ReactDOMClient.hydrateRoot(container, <App />);
       });
-    }).toErrorDev(['Prop `formTarget` did not match.']);
+    }).toErrorDev(
+      [
+        "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+      ],
+      {withoutStack: true},
+    );
     await act(async () => {
       root.render(<App isUpdate={true} />);
     });
@@ -368,7 +372,6 @@ describe('ReactDOMFizzForm', () => {
     expect(buttonRef.current.hasAttribute('formTarget')).toBe(false);
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   it('useFormStatus is not pending during server render', async () => {
     function App() {
@@ -384,7 +387,6 @@ describe('ReactDOMFizzForm', () => {
     expect(container.textContent).toBe('Pending: false');
   });
 
-  // @gate enableFormActions
   it('should replay a form action after hydration', async () => {
     let foo;
     function action(formData) {
@@ -412,7 +414,6 @@ describe('ReactDOMFizzForm', () => {
     expect(foo).toBe('bar');
   });
 
-  // @gate enableFormActions
   it('should replay input/button formAction', async () => {
     let rootActionCalled = false;
     let savedTitle = null;
@@ -472,15 +473,14 @@ describe('ReactDOMFizzForm', () => {
     expect(container.textContent).toBe('hi');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('useFormState returns initial state', async () => {
+  it('useActionState returns initial state', async () => {
     async function action(state) {
       return state;
     }
 
     function App() {
-      const [state] = useFormState(action, 0);
+      const [state] = useActionState(action, 0);
       return state;
     }
 
@@ -494,7 +494,6 @@ describe('ReactDOMFizzForm', () => {
     expect(container.textContent).toBe('0');
   });
 
-  // @gate enableFormActions
   it('can provide a custom action on the server for actions', async () => {
     const ref = React.createRef();
     let foo;
@@ -546,7 +545,6 @@ describe('ReactDOMFizzForm', () => {
     expect(foo).toBe('bar');
   });
 
-  // @gate enableFormActions
   it('can provide a custom action on buttons the server for actions', async () => {
     const hiddenRef = React.createRef();
     const inputRef = React.createRef();
@@ -626,7 +624,6 @@ describe('ReactDOMFizzForm', () => {
     expect(foo).toBe('bar');
   });
 
-  // @gate enableFormActions
   it('can hydrate hidden fields in the beginning of a form', async () => {
     const hiddenRef = React.createRef();
 
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
index e6ff3e2c22089..1dcc42f5335a5 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
@@ -30,7 +30,7 @@ let SuspenseList;
 let useSyncExternalStore;
 let useSyncExternalStoreWithSelector;
 let use;
-let useFormState;
+let useActionState;
 let PropTypes;
 let textCache;
 let writable;
@@ -47,6 +47,15 @@ let waitForPaint;
 let clientAct;
 let streamingContainer;
 
+function normalizeError(msg) {
+  // Take the first sentence to make it easier to assert on.
+  const idx = msg.indexOf('.');
+  if (idx > -1) {
+    return msg.slice(0, idx + 1);
+  }
+  return msg;
+}
+
 describe('ReactDOMFizzServer', () => {
   beforeEach(() => {
     jest.resetModules();
@@ -89,9 +98,23 @@ describe('ReactDOMFizzServer', () => {
     if (gate(flags => flags.enableSuspenseList)) {
       SuspenseList = React.unstable_SuspenseList;
     }
-    useFormState = ReactDOM.useFormState;
-
     PropTypes = require('prop-types');
+    if (__VARIANT__) {
+      const originalConsoleError = console.error;
+      console.error = (error, ...args) => {
+        if (
+          typeof error !== 'string' ||
+          error.indexOf('ReactDOM.useFormState has been deprecated') === -1
+        ) {
+          originalConsoleError(error, ...args);
+        }
+      };
+
+      // Remove after API is deleted.
+      useActionState = ReactDOM.useFormState;
+    } else {
+      useActionState = React.useActionState;
+    }
 
     const InternalTestUtils = require('internal-test-utils');
     waitForAll = InternalTestUtils.waitForAll;
@@ -2387,29 +2410,18 @@ describe('ReactDOMFizzServer', () => {
 
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log('Log recoverable error: ' + error.message);
+        Scheduler.log(
+          'Log recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
 
-    await expect(async () => {
-      // The first paint switches to client rendering due to mismatch
-      await waitForPaint([
-        'client',
-        'Log recoverable error: Hydration failed because the initial ' +
-          'UI does not match what was rendered on the server.',
-        'Log recoverable error: There was an error while hydrating. ' +
-          'Because the error happened outside of a Suspense boundary, the ' +
-          'entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-        'Warning: Expected server HTML to contain a matching <div> in <div>.\n' +
-          '    in div (at **)\n' +
-          '    in App (at **)',
-      ],
-      {withoutStack: 1},
-    );
+    // The first paint switches to client rendering due to mismatch
+    await waitForPaint([
+      'client',
+      "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+      'Log recoverable error: There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(<div>client</div>);
   });
 
@@ -2470,30 +2482,19 @@ describe('ReactDOMFizzServer', () => {
 
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log('Log recoverable error: ' + error.message);
+        Scheduler.log(
+          'Log recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
 
     // The first paint uses the client due to mismatch forcing client render
-    await expect(async () => {
-      // The first paint switches to client rendering due to mismatch
-      await waitForPaint([
-        'client',
-        'Log recoverable error: Hydration failed because the initial ' +
-          'UI does not match what was rendered on the server.',
-        'Log recoverable error: There was an error while hydrating. ' +
-          'Because the error happened outside of a Suspense boundary, the ' +
-          'entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Warning: An error occurred during hydration. The server HTML was replaced with client content',
-        'Warning: Expected server HTML to contain a matching <div> in <div>.\n' +
-          '    in div (at **)\n' +
-          '    in App (at **)',
-      ],
-      {withoutStack: 1},
-    );
+    // The first paint switches to client rendering due to mismatch
+    await waitForPaint([
+      'client',
+      "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+      'Log recoverable error: There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(<div>client</div>);
   });
 
@@ -2553,24 +2554,17 @@ describe('ReactDOMFizzServer', () => {
       isClient = true;
       ReactDOMClient.hydrateRoot(container, <App />, {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       });
 
       // An error logged but instead of surfacing it to the UI, we switched
       // to client rendering.
-      await expect(async () => {
-        await waitForAll([
-          'Yay!',
-          'Hydration error',
-          'There was an error while hydrating. Because the error happened ' +
-            'outside of a Suspense boundary, the entire root will switch ' +
-            'to client rendering.',
-        ]);
-      }).toErrorDev(
-        'An error occurred during hydration. The server HTML was replaced',
-        {withoutStack: true},
-      );
+      await waitForAll([
+        'Yay!',
+        'Hydration error',
+        'There was an error while hydrating.',
+      ]);
       expect(getVisibleChildren(container)).toEqual(<span>Yay!</span>);
 
       // The node that's inside the boundary that errored during hydration was
@@ -2735,7 +2729,7 @@ describe('ReactDOMFizzServer', () => {
       isClient = true;
       ReactDOMClient.hydrateRoot(container, <App />, {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       });
 
@@ -2744,7 +2738,7 @@ describe('ReactDOMFizzServer', () => {
       await waitForAll([
         'Yay!',
         'Hydration error',
-        'There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+        'There was an error while hydrating this Suspense boundary.',
       ]);
       expect(getVisibleChildren(container)).toEqual(
         <div>
@@ -3190,7 +3184,7 @@ describe('ReactDOMFizzServer', () => {
       isClient = true;
       ReactDOMClient.hydrateRoot(container, <App />, {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       });
 
@@ -3198,8 +3192,7 @@ describe('ReactDOMFizzServer', () => {
       // to client rendering.
       await waitForAll([
         'Hydration error',
-        'There was an error while hydrating this Suspense boundary. Switched ' +
-          'to client rendering.',
+        'There was an error while hydrating this Suspense boundary.',
       ]);
       expect(getVisibleChildren(container)).toEqual(
         <div>
@@ -3259,7 +3252,9 @@ describe('ReactDOMFizzServer', () => {
 
     const root = ReactDOMClient.createRoot(container, {
       onRecoverableError(error) {
-        Scheduler.log('Logged a recoverable error: ' + error.message);
+        Scheduler.log(
+          'Logged a recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
     React.startTransition(() => {
@@ -3335,7 +3330,9 @@ describe('ReactDOMFizzServer', () => {
     isClient = true;
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log('Logged recoverable error: ' + error.message);
+        Scheduler.log(
+          'Logged recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
 
@@ -3345,11 +3342,11 @@ describe('ReactDOMFizzServer', () => {
 
       'Logged recoverable error: Hydration error',
       'Logged recoverable error: There was an error while hydrating this ' +
-        'Suspense boundary. Switched to client rendering.',
+        'Suspense boundary.',
 
       'Logged recoverable error: Hydration error',
       'Logged recoverable error: There was an error while hydrating this ' +
-        'Suspense boundary. Switched to client rendering.',
+        'Suspense boundary.',
     ]);
   });
 
@@ -3576,11 +3573,11 @@ describe('ReactDOMFizzServer', () => {
         onRecoverableError(error, errorInfo) {
           expect(() => {
             expect(error.digest).toBe('a digest');
-            expect(errorInfo.digest).toBe('a digest');
+            expect(errorInfo.digest).toBe(undefined);
           }).toErrorDev(
-            'Warning: You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
-              ' This property is deprecated and will be removed in a future version of React.' +
-              ' To access the digest of an Error look for this property on the Error instance itself.',
+            'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
+              ' This property is no longer provided as part of errorInfo but can be accessed as a property' +
+              ' of the Error instance itself.',
             {withoutStack: true},
           );
         },
@@ -3616,7 +3613,7 @@ describe('ReactDOMFizzServer', () => {
     );
   });
 
-  // bugfix: https://github.com/facebook/react/issues/27286 affecting enableCustomElementPropertySupport flag
+  // bugfix: https://github.com/facebook/react/issues/27286
   it('can render custom elements with children on ther server', async () => {
     await act(() => {
       renderToPipeableStream(
@@ -4391,7 +4388,9 @@ describe('ReactDOMFizzServer', () => {
     const [ClientApp, clientResolve] = makeApp();
     ReactDOMClient.hydrateRoot(container, <ClientApp />, {
       onRecoverableError(error) {
-        Scheduler.log('Logged recoverable error: ' + error.message);
+        Scheduler.log(
+          'Logged recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
     await waitForAll([]);
@@ -4415,7 +4414,7 @@ describe('ReactDOMFizzServer', () => {
     );
   });
 
-  // @gate enableClientRenderFallbackOnTextMismatch
+  // @gate favorSafetyOverHydrationPerf
   it('#24384: Suspending should halt hydration warnings but still emit hydration warnings after unsuspending if mismatches are genuine', async () => {
     const makeApp = () => {
       let resolve, resolved;
@@ -4468,7 +4467,9 @@ describe('ReactDOMFizzServer', () => {
     const [ClientApp, clientResolve] = makeApp();
     ReactDOMClient.hydrateRoot(container, <ClientApp text="replaced" />, {
       onRecoverableError(error) {
-        Scheduler.log('Logged recoverable error: ' + error.message);
+        Scheduler.log(
+          'Logged recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
     await waitForAll([]);
@@ -4483,14 +4484,10 @@ describe('ReactDOMFizzServer', () => {
     // Now that the boundary resolves to it's children the hydration completes and discovers that there is a mismatch requiring
     // client-side rendering.
     await clientResolve();
-    await expect(async () => {
-      await waitForAll([
-        'Logged recoverable error: Text content does not match server-rendered HTML.',
-        'Logged recoverable error: There was an error while hydrating this Suspense boundary. Switched to client rendering.',
-      ]);
-    }).toErrorDev(
-      'Warning: Text content did not match. Server: "initial" Client: "replaced',
-    );
+    await waitForAll([
+      "Logged recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+      'Logged recoverable error: There was an error while hydrating this Suspense boundary.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <p>A</p>
@@ -4501,7 +4498,7 @@ describe('ReactDOMFizzServer', () => {
     await waitForAll([]);
   });
 
-  // @gate enableClientRenderFallbackOnTextMismatch
+  // @gate favorSafetyOverHydrationPerf
   it('only warns once on hydration mismatch while within a suspense boundary', async () => {
     const originalConsoleError = console.error;
     const mockError = jest.fn();
@@ -4537,12 +4534,14 @@ describe('ReactDOMFizzServer', () => {
 
       ReactDOMClient.hydrateRoot(container, <App text="replaced" />, {
         onRecoverableError(error) {
-          Scheduler.log('Logged recoverable error: ' + error.message);
+          Scheduler.log(
+            'Logged recoverable error: ' + normalizeError(error.message),
+          );
         },
       });
       await waitForAll([
-        'Logged recoverable error: Text content does not match server-rendered HTML.',
-        'Logged recoverable error: There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+        "Logged recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+        'Logged recoverable error: There was an error while hydrating this Suspense boundary.',
       ]);
 
       expect(getVisibleChildren(container)).toEqual(
@@ -4554,21 +4553,7 @@ describe('ReactDOMFizzServer', () => {
       );
 
       await waitForAll([]);
-      if (__DEV__) {
-        expect(mockError.mock.calls.length).toBe(1);
-        expect(mockError.mock.calls[0]).toEqual([
-          'Warning: Text content did not match. Server: "%s" Client: "%s"%s',
-          'initial',
-          'replaced',
-          '\n' +
-            '    in h2 (at **)\n' +
-            '    in Suspense (at **)\n' +
-            '    in div (at **)\n' +
-            '    in App (at **)',
-        ]);
-      } else {
-        expect(mockError.mock.calls.length).toBe(0);
-      }
+      expect(mockError.mock.calls.length).toBe(0);
     } finally {
       console.error = originalConsoleError;
     }
@@ -4624,12 +4609,14 @@ describe('ReactDOMFizzServer', () => {
 
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log('Logged recoverable error: ' + error.message);
+        Scheduler.log(
+          'Logged recoverable error: ' + normalizeError(error.message),
+        );
       },
     });
     await waitForAll([
       'Logged recoverable error: uh oh',
-      'Logged recoverable error: There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+      'Logged recoverable error: There was an error while hydrating this Suspense boundary.',
     ]);
 
     expect(getVisibleChildren(container)).toEqual(
@@ -4711,7 +4698,9 @@ describe('ReactDOMFizzServer', () => {
 
       ReactDOMClient.hydrateRoot(container, <App />, {
         onRecoverableError(error) {
-          Scheduler.log('Logged recoverable error: ' + error.message);
+          Scheduler.log(
+            'Logged recoverable error: ' + normalizeError(error.message),
+          );
         },
       });
       await waitForAll([
@@ -4720,7 +4709,7 @@ describe('ReactDOMFizzServer', () => {
         // onRecoverableError because the UI recovered without surfacing the
         // error to the user.
         'Logged recoverable error: first error',
-        'Logged recoverable error: There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+        'Logged recoverable error: There was an error while hydrating this Suspense boundary.',
       ]);
       expect(mockError.mock.calls).toEqual([]);
       mockError.mockClear();
@@ -4828,7 +4817,9 @@ describe('ReactDOMFizzServer', () => {
 
       ReactDOMClient.hydrateRoot(container, <App />, {
         onRecoverableError(error) {
-          Scheduler.log('Logged recoverable error: ' + error.message);
+          Scheduler.log(
+            'Logged recoverable error: ' + normalizeError(error.message),
+          );
         },
       });
       await waitForAll(['suspending']);
@@ -4845,7 +4836,7 @@ describe('ReactDOMFizzServer', () => {
       await waitForAll([
         'throwing: first error',
         'Logged recoverable error: first error',
-        'Logged recoverable error: There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+        'Logged recoverable error: There was an error while hydrating this Suspense boundary.',
       ]);
       expect(getVisibleChildren(container)).toEqual(
         <div>
@@ -4952,14 +4943,16 @@ describe('ReactDOMFizzServer', () => {
 
       ReactDOMClient.hydrateRoot(container, <App />, {
         onRecoverableError(error) {
-          Scheduler.log('Logged recoverable error: ' + error.message);
+          Scheduler.log(
+            'Logged recoverable error: ' + normalizeError(error.message),
+          );
         },
       });
       await waitForAll([
         'throwing: first error',
         'suspending',
         'Logged recoverable error: first error',
-        'Logged recoverable error: There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+        'Logged recoverable error: There was an error while hydrating this Suspense boundary.',
       ]);
       expect(mockError.mock.calls).toEqual([]);
       mockError.mockClear();
@@ -5080,7 +5073,6 @@ describe('ReactDOMFizzServer', () => {
     );
   });
 
-  // @gate enableFloat
   it('can emit the preamble even if the head renders asynchronously', async () => {
     function AsyncNoOutput() {
       readText('nooutput');
@@ -5133,7 +5125,6 @@ describe('ReactDOMFizzServer', () => {
     );
   });
 
-  // @gate enableFloat
   it('holds back body and html closing tags (the postamble) until all pending tasks are completed', async () => {
     const chunks = [];
     writable.on('data', chunk => {
@@ -5734,14 +5725,7 @@ describe('ReactDOMFizzServer', () => {
           ', or object with a novel `toString` method but found an Array with length 2 instead. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert `children` of <title> tags to a single string value which is why Arrays of length greater than 1 are not supported. When using JSX it can be commong to combine text nodes and value nodes. For example: <title>hello {nameOfUser}</title>. While not immediately apparent, `children` in this case is an Array with length 2. If your `children` prop is using this form try rewriting it using a template string: <title>{`hello ${nameOfUser}`}</title>.',
       ]);
 
-      if (gate(flags => flags.enableFloat)) {
-        expect(getVisibleChildren(document.head)).toEqual(<title />);
-      } else {
-        expect(getVisibleChildren(document.head)).toEqual(
-          <title>{'hello1<!-- -->hello2'}</title>,
-        );
-      }
-
+      expect(getVisibleChildren(document.head)).toEqual(<title />);
       const errors = [];
       ReactDOMClient.hydrateRoot(document.head, <App />, {
         onRecoverableError(error) {
@@ -5749,24 +5733,9 @@ describe('ReactDOMFizzServer', () => {
         },
       });
       await waitForAll([]);
-      if (gate(flags => flags.enableFloat)) {
-        expect(errors).toEqual([]);
-        // with float, the title doesn't render on the client or on the server
-        expect(getVisibleChildren(document.head)).toEqual(<title />);
-      } else {
-        expect(errors).toEqual(
-          [
-            gate(flags => flags.enableClientRenderFallbackOnTextMismatch)
-              ? 'Text content does not match server-rendered HTML.'
-              : null,
-            'Hydration failed because the initial UI does not match what was rendered on the server.',
-            'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-          ].filter(Boolean),
-        );
-        expect(getVisibleChildren(document.head)).toEqual(
-          <title>{['hello1', 'hello2']}</title>,
-        );
-      }
+      expect(errors).toEqual([]);
+      // with float, the title doesn't render on the client or on the server
+      expect(getVisibleChildren(document.head)).toEqual(<title />);
     });
 
     it('should warn in dev if you pass a React Component as a child to <title>', async () => {
@@ -5784,37 +5753,20 @@ describe('ReactDOMFizzServer', () => {
         );
       }
 
-      if (gate(flags => flags.enableFloat)) {
-        await expect(async () => {
-          await act(() => {
-            const {pipe} = renderToPipeableStream(<App />);
-            pipe(writable);
-          });
-        }).toErrorDev([
-          'React expects the `children` prop of <title> tags to be a string, number' +
-            gate(flags => (flags.enableBigIntSupport ? ', bigint' : '')) +
-            ', or object with a novel `toString` method but found an object that appears to be a React element which never implements a suitable `toString` method. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value which is why rendering React elements is not supported. If the `children` of <title> is a React Component try moving the <title> tag into that component. If the `children` of <title> is some HTML markup change it to be Text only to be valid HTML.',
-        ]);
-      } else {
-        await expect(async () => {
-          await act(() => {
-            const {pipe} = renderToPipeableStream(<App />);
-            pipe(writable);
-          });
-        }).toErrorDev([
-          'A title element received a React element for children. In the browser title Elements can only have Text Nodes as children. If the children being rendered output more than a single text node in aggregate the browser will display markup and comments as text in the title and hydration will likely fail and fall back to client rendering',
-        ]);
-      }
-
-      if (gate(flags => flags.enableFloat)) {
-        // object titles are toStringed when float is on
-        expect(getVisibleChildren(document.head)).toEqual(
-          <title>{'[object Object]'}</title>,
-        );
-      } else {
-        expect(getVisibleChildren(document.head)).toEqual(<title>hello</title>);
-      }
-
+      await expect(async () => {
+        await act(() => {
+          const {pipe} = renderToPipeableStream(<App />);
+          pipe(writable);
+        });
+      }).toErrorDev([
+        'React expects the `children` prop of <title> tags to be a string, number' +
+          gate(flags => (flags.enableBigIntSupport ? ', bigint' : '')) +
+          ', or object with a novel `toString` method but found an object that appears to be a React element which never implements a suitable `toString` method. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value which is why rendering React elements is not supported. If the `children` of <title> is a React Component try moving the <title> tag into that component. If the `children` of <title> is some HTML markup change it to be Text only to be valid HTML.',
+      ]);
+      // object titles are toStringed when float is on
+      expect(getVisibleChildren(document.head)).toEqual(
+        <title>{'[object Object]'}</title>,
+      );
       const errors = [];
       ReactDOMClient.hydrateRoot(document.head, <App />, {
         onRecoverableError(error) {
@@ -5823,14 +5775,10 @@ describe('ReactDOMFizzServer', () => {
       });
       await waitForAll([]);
       expect(errors).toEqual([]);
-      if (gate(flags => flags.enableFloat)) {
-        // object titles are toStringed when float is on
-        expect(getVisibleChildren(document.head)).toEqual(
-          <title>{'[object Object]'}</title>,
-        );
-      } else {
-        expect(getVisibleChildren(document.head)).toEqual(<title>hello</title>);
-      }
+      // object titles are toStringed when float is on
+      expect(getVisibleChildren(document.head)).toEqual(
+        <title>{'[object Object]'}</title>,
+      );
     });
 
     it('should warn in dev if you pass an object that does not implement toString as a child to <title>', async () => {
@@ -5842,37 +5790,20 @@ describe('ReactDOMFizzServer', () => {
         );
       }
 
-      if (gate(flags => flags.enableFloat)) {
-        await expect(async () => {
-          await act(() => {
-            const {pipe} = renderToPipeableStream(<App />);
-            pipe(writable);
-          });
-        }).toErrorDev([
-          'React expects the `children` prop of <title> tags to be a string, number' +
-            gate(flags => (flags.enableBigIntSupport ? ', bigint' : '')) +
-            ', or object with a novel `toString` method but found an object that does not implement a suitable `toString` method. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value. Using the default `toString` method available on every object is almost certainly an error. Consider whether the `children` of this <title> is an object in error and change it to a string or number value if so. Otherwise implement a `toString` method that React can use to produce a valid <title>.',
-        ]);
-      } else {
-        await expect(async () => {
-          await act(() => {
-            const {pipe} = renderToPipeableStream(<App />);
-            pipe(writable);
-          });
-        }).toErrorDev([
-          'A title element received a React element for children. In the browser title Elements can only have Text Nodes as children. If the children being rendered output more than a single text node in aggregate the browser will display markup and comments as text in the title and hydration will likely fail and fall back to client rendering',
-        ]);
-      }
-
-      if (gate(flags => flags.enableFloat)) {
-        // object titles are toStringed when float is on
-        expect(getVisibleChildren(document.head)).toEqual(
-          <title>{'[object Object]'}</title>,
-        );
-      } else {
-        expect(getVisibleChildren(document.head)).toEqual(<title>hello</title>);
-      }
-
+      await expect(async () => {
+        await act(() => {
+          const {pipe} = renderToPipeableStream(<App />);
+          pipe(writable);
+        });
+      }).toErrorDev([
+        'React expects the `children` prop of <title> tags to be a string, number' +
+          gate(flags => (flags.enableBigIntSupport ? ', bigint' : '')) +
+          ', or object with a novel `toString` method but found an object that does not implement a suitable `toString` method. Browsers treat all child Nodes of <title> tags as Text content and React expects to be able to convert children of <title> tags to a single string value. Using the default `toString` method available on every object is almost certainly an error. Consider whether the `children` of this <title> is an object in error and change it to a string or number value if so. Otherwise implement a `toString` method that React can use to produce a valid <title>.',
+      ]);
+      // object titles are toStringed when float is on
+      expect(getVisibleChildren(document.head)).toEqual(
+        <title>{'[object Object]'}</title>,
+      );
       const errors = [];
       ReactDOMClient.hydrateRoot(document.head, <App />, {
         onRecoverableError(error) {
@@ -5881,14 +5812,10 @@ describe('ReactDOMFizzServer', () => {
       });
       await waitForAll([]);
       expect(errors).toEqual([]);
-      if (gate(flags => flags.enableFloat)) {
-        // object titles are toStringed when float is on
-        expect(getVisibleChildren(document.head)).toEqual(
-          <title>{'[object Object]'}</title>,
-        );
-      } else {
-        expect(getVisibleChildren(document.head)).toEqual(<title>hello</title>);
-      }
+      // object titles are toStringed when float is on
+      expect(getVisibleChildren(document.head)).toEqual(
+        <title>{'[object Object]'}</title>,
+      );
     });
   });
 
@@ -6087,23 +6014,23 @@ describe('ReactDOMFizzServer', () => {
     expect(reportedServerErrors.length).toBe(1);
     expect(reportedServerErrors[0].message).toBe('Oops!');
 
+    const reportedCaughtErrors = [];
     const reportedClientErrors = [];
     ReactDOMClient.hydrateRoot(container, <App />, {
+      onCaughtError(error) {
+        reportedCaughtErrors.push(error);
+      },
       onRecoverableError(error) {
         reportedClientErrors.push(error);
       },
     });
     await waitForAll([]);
     expect(getVisibleChildren(container)).toEqual('Oops!');
-    expect(reportedClientErrors.length).toBe(1);
-    if (__DEV__) {
-      expect(reportedClientErrors[0].message).toBe('Oops!');
-    } else {
-      expect(reportedClientErrors[0].message).toBe(
-        'The server could not finish this Suspense boundary, likely due to ' +
-          'an error during server rendering. Switched to client rendering.',
-      );
-    }
+    // Because this is rethrown on the client, it is not a recoverable error.
+    expect(reportedClientErrors.length).toBe(0);
+    // It is caught by the error boundary.
+    expect(reportedCaughtErrors.length).toBe(1);
+    expect(reportedCaughtErrors[0].message).toBe('Oops!');
   });
 
   it("use a promise that's already been instrumented and resolved", async () => {
@@ -6201,10 +6128,9 @@ describe('ReactDOMFizzServer', () => {
     expect(getVisibleChildren(container)).toEqual('Hi');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('useFormState hydrates without a mismatch', async () => {
-    // This is testing an implementation detail: useFormState emits comment
+  it('useActionState hydrates without a mismatch', async () => {
+    // This is testing an implementation detail: useActionState emits comment
     // nodes into the SSR stream, so this checks that they are handled correctly
     // during hydration.
 
@@ -6214,7 +6140,7 @@ describe('ReactDOMFizzServer', () => {
 
     const childRef = React.createRef(null);
     function Form() {
-      const [state] = useFormState(action, 0);
+      const [state] = useActionState(action, 0);
       const text = `Child: ${state}`;
       return (
         <div id="child" ref={childRef}>
@@ -6255,9 +6181,8 @@ describe('ReactDOMFizzServer', () => {
     expect(childRef.current).toBe(child);
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it("useFormState hydrates without a mismatch if there's a render phase update", async () => {
+  it("useActionState hydrates without a mismatch if there's a render phase update", async () => {
     async function action(state) {
       return state;
     }
@@ -6271,9 +6196,9 @@ describe('ReactDOMFizzServer', () => {
 
       // Because of the render phase update above, this component is evaluated
       // multiple times (even during SSR), but it should only emit a single
-      // marker per useFormState instance.
-      const [formState] = useFormState(action, 0);
-      const text = `${readText('Child')}:${formState}:${localState}`;
+      // marker per useActionState instance.
+      const [actionState] = useActionState(action, 0);
+      const text = `${readText('Child')}:${actionState}:${localState}`;
       return (
         <div id="child" ref={childRef}>
           {text}
@@ -6405,15 +6330,7 @@ describe('ReactDOMFizzServer', () => {
           errors.push(error);
         },
       });
-      await expect(async () => {
-        await waitForAll([]);
-      }).toErrorDev(
-        [
-          'Expected server HTML to contain a matching <span> in <div>',
-          'An error occurred during hydration',
-        ],
-        {withoutStack: 1},
-      );
+      await waitForAll([]);
       expect(errors.length).toEqual(2);
       expect(getVisibleChildren(container)).toEqual(<span />);
     });
@@ -6436,7 +6353,6 @@ describe('ReactDOMFizzServer', () => {
     );
   });
 
-  // @gate enableFloat
   it('warns if script has complex children', async () => {
     function MyScript() {
       return 'bar();';
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js
index ab5f8509260df..f6ac8739f04e8 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzServerBrowser-test.js
@@ -62,15 +62,9 @@ describe('ReactDOMFizzServerBrowser', () => {
       </html>,
     );
     const result = await readResult(stream);
-    if (gate(flags => flags.enableFloat)) {
-      expect(result).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
-      );
-    } else {
-      expect(result).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><body>hello world</body></html>"`,
-      );
-    }
+    expect(result).toMatchInlineSnapshot(
+      `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
+    );
   });
 
   it('should emit bootstrap script src at the end', async () => {
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzServerNode-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzServerNode-test.js
index f7bab722bb386..eb41a627b780e 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzServerNode-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzServerNode-test.js
@@ -73,16 +73,10 @@ describe('ReactDOMFizzServerNode', () => {
     );
     pipe(writable);
     jest.runAllTimers();
-    if (gate(flags => flags.enableFloat)) {
-      // with Float, we emit empty heads if they are elided when rendering <html>
-      expect(output.result).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
-      );
-    } else {
-      expect(output.result).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><body>hello world</body></html>"`,
-      );
-    }
+    // with Float, we emit empty heads if they are elided when rendering <html>
+    expect(output.result).toMatchInlineSnapshot(
+      `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
+    );
   });
 
   it('should emit bootstrap script src at the end', () => {
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js
index 7482c7adaac8c..043c5fc42a923 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzStaticBrowser-test.js
@@ -126,15 +126,9 @@ describe('ReactDOMFizzStaticBrowser', () => {
       </html>,
     );
     const prelude = await readContent(result.prelude);
-    if (gate(flags => flags.enableFloat)) {
-      expect(prelude).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
-      );
-    } else {
-      expect(prelude).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><body>hello world</body></html>"`,
-      );
-    }
+    expect(prelude).toMatchInlineSnapshot(
+      `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
+    );
   });
 
   // @gate experimental
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js
index a049ec4c49222..e0adcfece0781 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzStaticNode-test.js
@@ -63,15 +63,9 @@ describe('ReactDOMFizzStaticNode', () => {
       </html>,
     );
     const prelude = await readContent(result.prelude);
-    if (gate(flags => flags.enableFloat)) {
-      expect(prelude).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
-      );
-    } else {
-      expect(prelude).toMatchInlineSnapshot(
-        `"<!DOCTYPE html><html><body>hello world</body></html>"`,
-      );
-    }
+    expect(prelude).toMatchInlineSnapshot(
+      `"<!DOCTYPE html><html><head></head><body>hello world</body></html>"`,
+    );
   });
 
   // @gate experimental
diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzSuppressHydrationWarning-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzSuppressHydrationWarning-test.js
index 3300297b77ee0..7a584d1797d92 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFizzSuppressHydrationWarning-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFizzSuppressHydrationWarning-test.js
@@ -24,6 +24,15 @@ let hasErrored = false;
 let fatalError = undefined;
 let waitForAll;
 
+function normalizeError(msg) {
+  // Take the first sentence to make it easier to assert on.
+  const idx = msg.indexOf('.');
+  if (idx > -1) {
+    return msg.slice(0, idx + 1);
+  }
+  return msg;
+}
+
 describe('ReactDOMFizzServerHydrationWarning', () => {
   beforeEach(() => {
     jest.resetModules();
@@ -130,7 +139,6 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
       : children;
   }
 
-  // @gate enableClientRenderFallbackOnTextMismatch
   it('suppresses but does not fix text mismatches with suppressHydrationWarning', async () => {
     function App({isClient}) {
       return (
@@ -157,7 +165,7 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
         // Don't miss a hydration error. There should be none.
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     await waitForAll([]);
@@ -170,47 +178,6 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
   });
 
-  // @gate !enableClientRenderFallbackOnTextMismatch
-  it('suppresses and fixes text mismatches with suppressHydrationWarning', async () => {
-    function App({isClient}) {
-      return (
-        <div>
-          <span suppressHydrationWarning={true}>
-            {isClient ? 'Client Text' : 'Server Text'}
-          </span>
-          <span suppressHydrationWarning={true}>{isClient ? 2 : 1}</span>
-        </div>
-      );
-    }
-    await act(() => {
-      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
-        <App isClient={false} />,
-      );
-      pipe(writable);
-    });
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <span>Server Text</span>
-        <span>1</span>
-      </div>,
-    );
-    ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
-      onRecoverableError(error) {
-        // Don't miss a hydration error. There should be none.
-        Scheduler.log(error.message);
-      },
-    });
-    await waitForAll([]);
-    // The text mismatch should be *silently* fixed. Even in production.
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <span>Client Text</span>
-        <span>2</span>
-      </div>,
-    );
-  });
-
-  // @gate enableClientRenderFallbackOnTextMismatch
   it('suppresses but does not fix multiple text node mismatches with suppressHydrationWarning', async () => {
     function App({isClient}) {
       return (
@@ -238,7 +205,7 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     await waitForAll([]);
@@ -252,48 +219,6 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
   });
 
-  // @gate !enableClientRenderFallbackOnTextMismatch
-  it('suppresses and fixes multiple text node mismatches with suppressHydrationWarning', async () => {
-    function App({isClient}) {
-      return (
-        <div>
-          <span suppressHydrationWarning={true}>
-            {isClient ? 'Client1' : 'Server1'}
-            {isClient ? 'Client2' : 'Server2'}
-          </span>
-        </div>
-      );
-    }
-    await act(() => {
-      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
-        <App isClient={false} />,
-      );
-      pipe(writable);
-    });
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <span>
-          {'Server1'}
-          {'Server2'}
-        </span>
-      </div>,
-    );
-    ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
-      onRecoverableError(error) {
-        Scheduler.log(error.message);
-      },
-    });
-    await waitForAll([]);
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <span>
-          {'Client1'}
-          {'Client2'}
-        </span>
-      </div>,
-    );
-  });
-
   it('errors on text-to-element mismatches with suppressHydrationWarning', async () => {
     function App({isClient}) {
       return (
@@ -321,21 +246,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Expected server HTML to contain a matching <span> in <span>',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <span>
@@ -345,7 +262,6 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
   });
 
-  // @gate enableClientRenderFallbackOnTextMismatch
   it('suppresses but does not fix client-only single text node mismatches with suppressHydrationWarning', async () => {
     function App({text}) {
       return (
@@ -367,7 +283,7 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     const root = ReactDOMClient.hydrateRoot(container, <App text="Client" />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     await waitForAll([]);
@@ -386,41 +302,6 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
   });
 
-  // @gate !enableClientRenderFallbackOnTextMismatch
-  it('suppresses and fixes client-only single text node mismatches with suppressHydrationWarning', async () => {
-    function App({isClient}) {
-      return (
-        <div>
-          <span suppressHydrationWarning={true}>
-            {isClient ? 'Client' : null}
-          </span>
-        </div>
-      );
-    }
-    await act(() => {
-      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
-        <App isClient={false} />,
-      );
-      pipe(writable);
-    });
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <span />
-      </div>,
-    );
-    ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
-      onRecoverableError(error) {
-        Scheduler.log(error.message);
-      },
-    });
-    await waitForAll([]);
-    expect(getVisibleChildren(container)).toEqual(
-      <div>
-        <span>{'Client'}</span>
-      </div>,
-    );
-  });
-
   // TODO: This behavior is not consistent with client-only single text node.
 
   it('errors on server-only single text node mismatches with suppressHydrationWarning', async () => {
@@ -446,21 +327,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Did not expect server HTML to contain the text node "Server" in <span>',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <span />
@@ -494,21 +367,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Expected server HTML to contain a matching text node for "Client" in <span>.',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <span>
@@ -545,21 +410,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Did not expect server HTML to contain the text node "Server" in <span>.',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <span>
@@ -594,21 +451,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Expected server HTML to contain a matching text node for "Client" in <span>.',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <span>
@@ -647,7 +496,7 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     await waitForAll([]);
@@ -684,7 +533,7 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     await waitForAll([]);
@@ -717,21 +566,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Expected server HTML to contain a matching <p> in <div>.',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <p>Client and server</p>
@@ -763,21 +604,13 @@ describe('ReactDOMFizzServerHydrationWarning', () => {
     );
     ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await expect(async () => {
-      await waitForAll([
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-      ]);
-    }).toErrorDev(
-      [
-        'Did not expect server HTML to contain a <p> in <div>.',
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
+    ]);
     expect(getVisibleChildren(container)).toEqual(
       <div>
         <p>Client and server</p>
diff --git a/packages/react-dom/src/__tests__/ReactDOMFloat-test.js b/packages/react-dom/src/__tests__/ReactDOMFloat-test.js
index 1e6547daae12a..9ded4826aaf5b 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFloat-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFloat-test.js
@@ -400,7 +400,6 @@ describe('ReactDOMFloat', () => {
     }
   }
 
-  // @gate enableFloat
   it('can render resources before singletons', async () => {
     const root = ReactDOMClient.createRoot(document);
     root.render(
@@ -433,7 +432,6 @@ describe('ReactDOMFloat', () => {
     );
   });
 
-  // @gate enableFloat
   it('can hydrate non Resources in head when Resources are also inserted there', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -499,7 +497,6 @@ describe('ReactDOMFloat', () => {
     );
   });
 
-  // @gate enableFloat || !__DEV__
   it('warns if you render resource-like elements above <head> or <body>', async () => {
     const root = ReactDOMClient.createRoot(document);
 
@@ -631,7 +628,6 @@ describe('ReactDOMFloat', () => {
     );
   });
 
-  // @gate enableFloat
   it('can acquire a resource after releasing it in the same commit', async () => {
     const root = ReactDOMClient.createRoot(container);
     root.render(
@@ -671,7 +667,6 @@ describe('ReactDOMFloat', () => {
     );
   });
 
-  // @gate enableFloat
   it('emits an implicit <head> element to hold resources when none is rendered but an <html> is rendered', async () => {
     const chunks = [];
 
@@ -697,7 +692,6 @@ describe('ReactDOMFloat', () => {
     ]);
   });
 
-  // @gate enableFloat
   it('dedupes if the external runtime is explicitly loaded using preinit', async () => {
     const unstable_externalRuntimeSrc = 'src-of-external-runtime';
     function App() {
@@ -731,7 +725,6 @@ describe('ReactDOMFloat', () => {
     ).toEqual(['<script src="src-of-external-runtime" async=""></script>']);
   });
 
-  // @gate enableFloat
   it('can send style insertion implementation independent of boundary commpletion instruction implementation', async () => {
     await act(() => {
       renderToPipeableStream(
@@ -790,7 +783,6 @@ describe('ReactDOMFloat', () => {
     );
   });
 
-  // @gate enableFloat
   it('can avoid inserting a late stylesheet if it already rendered on the client', async () => {
     await act(() => {
       renderToPipeableStream(
@@ -911,7 +903,6 @@ describe('ReactDOMFloat', () => {
     );
   });
 
-  // @gate enableFloat
   it('can hoist <link rel="stylesheet" .../> and <style /> tags together, respecting order of discovery', async () => {
     const css = `
 body {
@@ -1196,7 +1187,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('client renders a boundary if a style Resource dependency fails to load', async () => {
     function App() {
       return (
@@ -1298,7 +1288,6 @@ body {
     ]);
   });
 
-  // @gate enableFloat
   it('treats stylesheet links with a precedence as a resource', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -1339,7 +1328,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('inserts text separators following text when followed by an element that is converted to a resource and thus removed from the html inline', async () => {
     // If you render many of these as siblings the values get emitted as a single text with no separator sometimes
     // because the link gets elided as a resource
@@ -1386,7 +1374,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('hoists late stylesheets the correct precedence', async () => {
     function PresetPrecedence() {
       ReactDOM.preinit('preset', {as: 'style', precedence: 'preset'});
@@ -1671,7 +1658,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('normalizes stylesheet resource precedence for all boundaries inlined as part of the shell flush', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -1755,7 +1741,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('stylesheet resources are inserted according to precedence order on the client', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -1836,7 +1821,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('inserts preloads in render phase eagerly', async () => {
     function Throw() {
       throw new Error('Uh oh!');
@@ -1878,7 +1862,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('will include child boundary stylesheet resources in the boundary reveal instruction', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -1997,7 +1980,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('will hoist resources of child boundaries emitted as part of a partial boundary to the parent boundary', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -2161,7 +2143,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('encodes attributes consistently whether resources are flushed in shell or in late boundaries', async () => {
     function App() {
       return (
@@ -2305,7 +2286,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('boundary stylesheet resource dependencies hoist to a parent boundary when flushed inline', async () => {
     await act(() => {
       const {pipe} = renderToPipeableStream(
@@ -2428,7 +2408,6 @@ body {
     );
   });
 
-  // @gate enableFloat
   it('always enforces crossOrigin "anonymous" for font preloads', async () => {
     function App() {
       ReactDOM.preload('foo', {as: 'font', type: 'font/woff2'});
@@ -2619,7 +2598,6 @@ body {
     ]);
   });
 
-  // @gate enableFloat
   it('can hydrate resources and components in the head and body even if a browser or 3rd party script injects extra html nodes', async () => {
     // This is a stress test case for hydrating a complex combination of hoistable elements, hoistable resources and host components
     // in an environment that has been manipulated by 3rd party scripts/extensions to modify the <head> and <body>
@@ -4283,6 +4261,91 @@ body {
     );
   });
 
+  it('should handle media on image preload', async () => {
+    function App({isClient}) {
+      ReactDOM.preload('/server', {
+        as: 'image',
+        imageSrcSet: '/server',
+        imageSizes: '100vw',
+        media: 'print and (min-width: 768px)',
+      });
+
+      if (isClient) {
+        ReactDOM.preload('/client', {
+          as: 'image',
+          imageSrcSet: '/client',
+          imageSizes: '100vw',
+          media: 'screen and (max-width: 480px)',
+        });
+      }
+
+      return (
+        <html>
+          <body>hello</body>
+        </html>
+      );
+    }
+
+    await act(() => {
+      renderToPipeableStream(<App />).pipe(writable);
+    });
+    expect(getMeaningfulChildren(document)).toEqual(
+      <html>
+        <head>
+          <link
+            rel="preload"
+            as="image"
+            imagesrcset="/server"
+            imagesizes="100vw"
+            media="print and (min-width: 768px)"
+          />
+        </head>
+        <body>hello</body>
+      </html>,
+    );
+
+    const root = ReactDOMClient.hydrateRoot(document, <App />);
+    await waitForAll([]);
+    expect(getMeaningfulChildren(document)).toEqual(
+      <html>
+        <head>
+          <link
+            rel="preload"
+            as="image"
+            imagesrcset="/server"
+            imagesizes="100vw"
+            media="print and (min-width: 768px)"
+          />
+        </head>
+        <body>hello</body>
+      </html>,
+    );
+
+    root.render(<App isClient={true} />);
+    await waitForAll([]);
+    expect(getMeaningfulChildren(document)).toEqual(
+      <html>
+        <head>
+          <link
+            rel="preload"
+            as="image"
+            imagesrcset="/server"
+            imagesizes="100vw"
+            media="print and (min-width: 768px)"
+          />
+          <link
+            rel="preload"
+            as="image"
+            imagesrcset="/client"
+            imagesizes="100vw"
+            media="screen and (max-width: 480px)"
+          />
+        </head>
+        <body>hello</body>
+      </html>,
+    );
+  });
+
   it('should warn if you preload a stylesheet and then render a style tag with the same href', async () => {
     const style = 'body { color: red; }';
     function App() {
@@ -5195,7 +5258,6 @@ body {
   });
 
   describe('ReactDOM.preload(href, { as: ... })', () => {
-    // @gate enableFloat
     it('creates a preload resource when called', async () => {
       function App() {
         ReactDOM.preload('foo', {as: 'style'});
@@ -5284,7 +5346,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('can seed connection props for stylesheet and script resources', async () => {
       function App() {
         ReactDOM.preload('foo', {
@@ -5326,7 +5387,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('warns if you do not pass in a valid href argument or options argument', async () => {
       function App() {
         ReactDOM.preload();
@@ -5629,7 +5689,6 @@ body {
   });
 
   describe('ReactDOM.preinit(href, { as: ... })', () => {
-    // @gate enableFloat
     it('creates a stylesheet resource when ReactDOM.preinit(..., {as: "style" }) is called', async () => {
       function App() {
         ReactDOM.preinit('foo', {as: 'style'});
@@ -5713,7 +5772,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('creates a stylesheet resource in the ownerDocument when ReactDOM.preinit(..., {as: "style" }) is called outside of render on the client', async () => {
       function App() {
         React.useEffect(() => {
@@ -5739,7 +5797,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('creates a stylesheet resource in the ownerDocument when ReactDOM.preinit(..., {as: "style" }) is called outside of render on the client', async () => {
       // This is testing behavior, but it shows that it is not a good idea to preinit inside a shadowRoot. The point is we are asserting a behavior
       // you would want to avoid in a real app.
@@ -5783,7 +5840,6 @@ body {
       expect(getMeaningfulChildren(shadow)).toEqual(<div>shadow</div>);
     });
 
-    // @gate enableFloat
     it('creates a script resource when ReactDOM.preinit(..., {as: "script" }) is called', async () => {
       function App() {
         ReactDOM.preinit('foo', {as: 'script'});
@@ -5861,7 +5917,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('creates a script resource when ReactDOM.preinit(..., {as: "script" }) is called outside of render on the client', async () => {
       function App() {
         React.useEffect(() => {
@@ -5887,7 +5942,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('warns if you do not pass in a valid href argument or options argument', async () => {
       function App() {
         ReactDOM.preinit();
@@ -6296,7 +6350,6 @@ body {
   });
 
   describe('Stylesheet Resources', () => {
-    // @gate enableFloat
     it('treats link rel stylesheet elements as a stylesheet resource when it includes a precedence when server rendering', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6323,7 +6376,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('treats link rel stylesheet elements as a stylesheet resource when it includes a precedence when client rendering', async () => {
       const root = ReactDOMClient.createRoot(document);
       root.render(
@@ -6349,7 +6401,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('treats link rel stylesheet elements as a stylesheet resource when it includes a precedence when hydrating', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6387,7 +6438,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('hoists stylesheet resources to the correct precedence', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6449,7 +6499,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('retains styles even after the last referring Resource unmounts', async () => {
       // This test is true until a future update where there is some form of garbage collection.
       const root = ReactDOMClient.createRoot(document);
@@ -6482,7 +6531,7 @@ body {
       );
     });
 
-    // @gate enableFloat && enableClientRenderFallbackOnTextMismatch
+    // @gate favorSafetyOverHydrationPerf
     it('retains styles even when a new html, head, and/body mount', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6513,15 +6562,7 @@ body {
           },
         },
       );
-      await expect(async () => {
-        await waitForAll([]);
-      }).toErrorDev(
-        [
-          'Warning: Text content did not match. Server: "server" Client: "client"',
-          'Warning: An error occurred during hydration. The server HTML was replaced with client content in <#document>.',
-        ],
-        {withoutStack: 1},
-      );
+      await waitForAll([]);
       expect(getMeaningfulChildren(document)).toEqual(
         <html>
           <head>
@@ -6534,7 +6575,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('retains styles in head through head remounts', async () => {
       const root = ReactDOMClient.createRoot(document);
       root.render(
@@ -6585,7 +6625,6 @@ body {
         </html>,
       );
     });
-    // @gate enableFloat
     it('can support styles inside portals to a shadowRoot', async () => {
       const shadow = document.body.attachShadow({mode: 'open'});
       const root = ReactDOMClient.createRoot(container);
@@ -6629,7 +6668,6 @@ body {
         <div>shadow</div>,
       ]);
     });
-    // @gate enableFloat
     it('can support styles inside portals to an element in shadowRoots', async () => {
       const template = document.createElement('template');
       template.innerHTML =
@@ -6699,7 +6737,6 @@ body {
       ]);
     });
 
-    // @gate enableFloat
     it('escapes hrefs when selecting matching elements in the document when rendering Resources', async () => {
       function App() {
         ReactDOM.preload('preload', {as: 'style'});
@@ -6767,7 +6804,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('escapes hrefs when selecting matching elements in the document when using preload and preinit', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6830,7 +6866,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('does not create stylesheet resources when inside an <svg> context', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6891,7 +6926,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('does not create stylesheet resources when inside a <noscript> context', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -6933,7 +6967,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('warns if you provide a `precedence` prop with other props that invalidate the creation of a stylesheet resource', async () => {
       await expect(async () => {
         await act(() => {
@@ -7006,7 +7039,6 @@ body {
       ]);
     });
 
-    // @gate enableFloat
     it('will not block displaying a Suspense boundary on a stylesheet with media that does not match', async () => {
       await act(() => {
         renderToPipeableStream(
@@ -7123,7 +7155,6 @@ body {
   });
 
   describe('Style Resource', () => {
-    // @gate enableFloat
     it('treats <style href="..." precedence="..."> elements as a style resource when server rendering', async () => {
       const css = `
 body {
@@ -7153,7 +7184,6 @@ body {
       );
     });
 
-    // @gate enableFloat
     it('can insert style resources as part of a boundary reveal', async () => {
       const cssRed = `
 body {
@@ -7269,7 +7299,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('can emit styles early when a partial boundary flushes', async () => {
       const css = 'body { background-color: red; }';
       await act(() => {
@@ -7601,7 +7630,6 @@ background-color: green;
   });
 
   describe('Script Resources', () => {
-    // @gate enableFloat
     it('treats async scripts without onLoad or onError as Resources', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -7681,7 +7709,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('does not create script resources when inside an <svg> context', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -7742,7 +7769,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('does not create script resources when inside a <noscript> context', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -7786,7 +7812,6 @@ background-color: green;
   });
 
   describe('Hoistables', () => {
-    // @gate enableFloat
     it('can hoist meta tags on the server and hydrate them on the client', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -7840,7 +7865,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('can hoist meta tags on the client', async () => {
       const root = ReactDOMClient.createRoot(container);
       await act(() => {
@@ -7862,7 +7886,6 @@ background-color: green;
       expect(getMeaningfulChildren(document.head)).toEqual(undefined);
     });
 
-    // @gate enableFloat
     it('can hoist link (non-stylesheet) tags on the server and hydrate them on the client', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -7916,7 +7939,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('can hoist link (non-stylesheet) tags on the client', async () => {
       const root = ReactDOMClient.createRoot(container);
       await act(() => {
@@ -7938,7 +7960,6 @@ background-color: green;
       expect(getMeaningfulChildren(document.head)).toEqual(undefined);
     });
 
-    // @gate enableFloat
     it('can hoist title tags on the server and hydrate them on the client', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -7992,7 +8013,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('can hoist title tags on the client', async () => {
       const root = ReactDOMClient.createRoot(container);
       await act(() => {
@@ -8014,7 +8034,6 @@ background-color: green;
       expect(getMeaningfulChildren(document.head)).toEqual(undefined);
     });
 
-    // @gate enableFloat
     it('prioritizes ordering for certain hoistables over others when rendering on the server', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -8054,7 +8073,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('supports rendering hoistables outside of <html> scope', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -8232,7 +8250,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('does not hoist inside an <svg> context', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -8266,7 +8283,6 @@ background-color: green;
       ]);
     });
 
-    // @gate enableFloat
     it('does not hoist inside noscript context', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -8293,7 +8309,7 @@ background-color: green;
       ]);
     });
 
-    // @gate enableFloat && (enableClientRenderFallbackOnTextMismatch || !__DEV__)
+    // @gate favorSafetyOverHydrationPerf
     it('can render a title before a singleton even if that singleton clears its contents', async () => {
       await act(() => {
         const {pipe} = renderToPipeableStream(
@@ -8329,15 +8345,7 @@ background-color: green;
         },
       );
 
-      await expect(async () => {
-        await waitForAll([]);
-      }).toErrorDev(
-        [
-          'Warning: Text content did not match. Server: "server" Client: "client"',
-          'Warning: An error occurred during hydration. The server HTML was replaced with client content in <#document>.',
-        ],
-        {withoutStack: 1},
-      );
+      await waitForAll([]);
       expect(getMeaningfulChildren(document)).toEqual(
         <html>
           <head>
@@ -8350,7 +8358,6 @@ background-color: green;
       );
     });
 
-    // @gate enableFloat
     it('can update title tags', async () => {
       const root = ReactDOMClient.createRoot(container);
       await act(() => {
diff --git a/packages/react-dom/src/__tests__/ReactDOMForm-test.js b/packages/react-dom/src/__tests__/ReactDOMForm-test.js
index 977439b099971..2d7a34aa75cfd 100644
--- a/packages/react-dom/src/__tests__/ReactDOMForm-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMForm-test.js
@@ -41,7 +41,7 @@ describe('ReactDOMForm', () => {
   let startTransition;
   let textCache;
   let useFormStatus;
-  let useFormState;
+  let useActionState;
 
   beforeEach(() => {
     jest.resetModules();
@@ -56,11 +56,26 @@ describe('ReactDOMForm', () => {
     Suspense = React.Suspense;
     startTransition = React.startTransition;
     useFormStatus = ReactDOM.useFormStatus;
-    useFormState = ReactDOM.useFormState;
     container = document.createElement('div');
     document.body.appendChild(container);
 
     textCache = new Map();
+
+    if (__VARIANT__) {
+      const originalConsoleError = console.error;
+      console.error = (error, ...args) => {
+        if (
+          typeof error !== 'string' ||
+          error.indexOf('ReactDOM.useFormState has been deprecated') === -1
+        ) {
+          originalConsoleError(error, ...args);
+        }
+      };
+      // Remove after API is deleted.
+      useActionState = ReactDOM.useFormState;
+    } else {
+      useActionState = React.useActionState;
+    }
   });
 
   function resolveText(text) {
@@ -183,7 +198,6 @@ describe('ReactDOMForm', () => {
     });
   }
 
-  // @gate enableFormActions
   it('should allow passing a function to form action', async () => {
     const ref = React.createRef();
     let foo;
@@ -224,7 +238,6 @@ describe('ReactDOMForm', () => {
     expect(foo).toBe('bar2');
   });
 
-  // @gate enableFormActions
   it('should allow passing a function to an input/button formAction', async () => {
     const inputRef = React.createRef();
     const buttonRef = React.createRef();
@@ -317,7 +330,6 @@ describe('ReactDOMForm', () => {
     expect(rootActionCalled).toBe(false);
   });
 
-  // @gate enableFormActions || !__DEV__
   it('should allow preventing default to block the action', async () => {
     const ref = React.createRef();
     let actionCalled = false;
@@ -340,7 +352,6 @@ describe('ReactDOMForm', () => {
     expect(actionCalled).toBe(false);
   });
 
-  // @gate enableFormActions
   it('should only submit the inner of nested forms', async () => {
     const ref = React.createRef();
     let data;
@@ -377,7 +388,6 @@ describe('ReactDOMForm', () => {
     expect(data).toBe('innerinner');
   });
 
-  // @gate enableFormActions
   it('should only submit once if one root is nested inside the other', async () => {
     const ref = React.createRef();
     let outerCalled = 0;
@@ -421,7 +431,6 @@ describe('ReactDOMForm', () => {
     expect(innerCalled).toBe(1);
   });
 
-  // @gate enableFormActions
   it('should only submit once if a portal is nested inside its own root', async () => {
     const ref = React.createRef();
     let outerCalled = 0;
@@ -465,7 +474,6 @@ describe('ReactDOMForm', () => {
     expect(innerCalled).toBe(1);
   });
 
-  // @gate enableFormActions
   it('can read the clicked button in the formdata event', async () => {
     const inputRef = React.createRef();
     const buttonRef = React.createRef();
@@ -513,7 +521,6 @@ describe('ReactDOMForm', () => {
     expect(buttonRef.current.getAttribute('type')).toBe(null);
   });
 
-  // @gate enableFormActions
   it('excludes the submitter name when the submitter is a function action', async () => {
     const inputRef = React.createRef();
     const buttonRef = React.createRef();
@@ -564,7 +571,6 @@ describe('ReactDOMForm', () => {
     expect(buttonRef.current.getAttribute('type')).toBe(null);
   });
 
-  // @gate enableFormActions || !__DEV__
   it('allows a non-function formaction to override a function one', async () => {
     const ref = React.createRef();
     let actionCalled = false;
@@ -596,7 +602,6 @@ describe('ReactDOMForm', () => {
     expect(actionCalled).toBe(false);
   });
 
-  // @gate enableFormActions || !__DEV__
   it('allows a non-react html formaction to be invoked', async () => {
     let actionCalled = false;
 
@@ -632,7 +637,6 @@ describe('ReactDOMForm', () => {
     expect(actionCalled).toBe(false);
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   it('form actions are transitions', async () => {
     const formRef = React.createRef();
@@ -671,7 +675,6 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('Updated');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   it('multiple form actions', async () => {
     const formRef = React.createRef();
@@ -718,7 +721,6 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('Count: 2');
   });
 
-  // @gate enableFormActions
   it('form actions can be asynchronous', async () => {
     const formRef = React.createRef();
 
@@ -764,7 +766,7 @@ describe('ReactDOMForm', () => {
   });
 
   it('sync errors in form actions can be captured by an error boundary', async () => {
-    if (gate(flags => !(flags.enableFormActions && flags.enableAsyncActions))) {
+    if (gate(flags => !flags.enableAsyncActions)) {
       // TODO: Uncaught JSDOM errors fail the test after the scope has finished
       // so don't work with the `gate` mechanism.
       return;
@@ -810,7 +812,7 @@ describe('ReactDOMForm', () => {
   });
 
   it('async errors in form actions can be captured by an error boundary', async () => {
-    if (gate(flags => !(flags.enableFormActions && flags.enableAsyncActions))) {
+    if (gate(flags => !flags.enableAsyncActions)) {
       // TODO: Uncaught JSDOM errors fail the test after the scope has finished
       // so don't work with the `gate` mechanism.
       return;
@@ -861,7 +863,6 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('Oh no!');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   it('useFormStatus reads the status of a pending form action', async () => {
     const formRef = React.createRef();
@@ -913,7 +914,6 @@ describe('ReactDOMForm', () => {
     assertLog(['Async action finished', 'No pending action']);
   });
 
-  // @gate enableFormActions
   it('should error if submitting a form manually', async () => {
     const ref = React.createRef();
 
@@ -960,9 +960,8 @@ describe('ReactDOMForm', () => {
     );
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState updates state asynchronously and queues multiple actions', async () => {
+  test('useActionState updates state asynchronously and queues multiple actions', async () => {
     let actionCounter = 0;
     async function action(state, type) {
       actionCounter++;
@@ -982,7 +981,7 @@ describe('ReactDOMForm', () => {
 
     let dispatch;
     function App() {
-      const [state, _dispatch, isPending] = useFormState(action, 0);
+      const [state, _dispatch, isPending] = useActionState(action, 0);
       dispatch = _dispatch;
       const pending = isPending ? 'Pending ' : '';
       return <Text text={pending + state} />;
@@ -1021,12 +1020,11 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('2');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState supports inline actions', async () => {
+  test('useActionState supports inline actions', async () => {
     let increment;
     function App({stepSize}) {
-      const [state, dispatch, isPending] = useFormState(async prevState => {
+      const [state, dispatch, isPending] = useActionState(async prevState => {
         return prevState + stepSize;
       }, 0);
       increment = dispatch;
@@ -1054,11 +1052,10 @@ describe('ReactDOMForm', () => {
     assertLog(['Pending 1', '11']);
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState: dispatch throws if called during render', async () => {
+  test('useActionState: dispatch throws if called during render', async () => {
     function App() {
-      const [state, dispatch, isPending] = useFormState(async () => {}, 0);
+      const [state, dispatch, isPending] = useActionState(async () => {}, 0);
       dispatch();
       const pending = isPending ? 'Pending ' : '';
       return <Text text={pending + state} />;
@@ -1071,12 +1068,11 @@ describe('ReactDOMForm', () => {
     });
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   test('queues multiple actions and runs them in order', async () => {
     let action;
     function App() {
-      const [state, dispatch, isPending] = useFormState(
+      const [state, dispatch, isPending] = useActionState(
         async (s, a) => await getText(a),
         'A',
       );
@@ -1104,12 +1100,11 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('D');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState: works if action is sync', async () => {
+  test('useActionState: works if action is sync', async () => {
     let increment;
     function App({stepSize}) {
-      const [state, dispatch, isPending] = useFormState(prevState => {
+      const [state, dispatch, isPending] = useActionState(prevState => {
         return prevState + stepSize;
       }, 0);
       increment = dispatch;
@@ -1137,12 +1132,11 @@ describe('ReactDOMForm', () => {
     assertLog(['Pending 1', '11']);
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState: can mix sync and async actions', async () => {
+  test('useActionState: can mix sync and async actions', async () => {
     let action;
     function App() {
-      const [state, dispatch, isPending] = useFormState((s, a) => a, 'A');
+      const [state, dispatch, isPending] = useActionState((s, a) => a, 'A');
       action = dispatch;
       const pending = isPending ? 'Pending ' : '';
       return <Text text={pending + state} />;
@@ -1166,9 +1160,8 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('E');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState: error handling (sync action)', async () => {
+  test('useActionState: error handling (sync action)', async () => {
     let resetErrorBoundary;
     class ErrorBoundary extends React.Component {
       state = {error: null};
@@ -1186,7 +1179,7 @@ describe('ReactDOMForm', () => {
 
     let action;
     function App() {
-      const [state, dispatch, isPending] = useFormState((s, a) => {
+      const [state, dispatch, isPending] = useActionState((s, a) => {
         if (a.endsWith('!')) {
           throw new Error(a);
         }
@@ -1231,9 +1224,8 @@ describe('ReactDOMForm', () => {
     expect(container.textContent).toBe('B');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  test('useFormState: error handling (async action)', async () => {
+  test('useActionState: error handling (async action)', async () => {
     let resetErrorBoundary;
     class ErrorBoundary extends React.Component {
       state = {error: null};
@@ -1251,7 +1243,7 @@ describe('ReactDOMForm', () => {
 
     let action;
     function App() {
-      const [state, dispatch, isPending] = useFormState(async (s, a) => {
+      const [state, dispatch, isPending] = useActionState(async (s, a) => {
         const text = await getText(a);
         if (text.endsWith('!')) {
           throw new Error(text);
@@ -1295,4 +1287,51 @@ describe('ReactDOMForm', () => {
     assertLog(['B']);
     expect(container.textContent).toBe('B');
   });
+
+  // @gate enableAsyncActions
+  test('useActionState works in StrictMode', async () => {
+    let actionCounter = 0;
+    async function action(state, type) {
+      actionCounter++;
+
+      Scheduler.log(`Async action started [${actionCounter}]`);
+      await getText(`Wait [${actionCounter}]`);
+
+      switch (type) {
+        case 'increment':
+          return state + 1;
+        case 'decrement':
+          return state - 1;
+        default:
+          return state;
+      }
+    }
+
+    let dispatch;
+    function App() {
+      const [state, _dispatch, isPending] = useActionState(action, 0);
+      dispatch = _dispatch;
+      const pending = isPending ? 'Pending ' : '';
+      return <Text text={pending + state} />;
+    }
+
+    const root = ReactDOMClient.createRoot(container);
+    await act(() =>
+      root.render(
+        <React.StrictMode>
+          <App />
+        </React.StrictMode>,
+      ),
+    );
+    assertLog(['0']);
+    expect(container.textContent).toBe('0');
+
+    await act(() => dispatch('increment'));
+    assertLog(['Async action started [1]', 'Pending 0']);
+    expect(container.textContent).toBe('Pending 0');
+
+    await act(() => resolveText('Wait [1]'));
+    assertLog(['1']);
+    expect(container.textContent).toBe('1');
+  });
 });
diff --git a/packages/react-dom/src/__tests__/ReactDOMHydrationDiff-test.js b/packages/react-dom/src/__tests__/ReactDOMHydrationDiff-test.js
index 0eb9cc3fe47d7..b973f85211a0a 100644
--- a/packages/react-dom/src/__tests__/ReactDOMHydrationDiff-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMHydrationDiff-test.js
@@ -17,6 +17,10 @@ let act;
 const util = require('util');
 const realConsoleError = console.error;
 
+function errorHandler() {
+  // forward to console.error but don't fail the tests
+}
+
 describe('ReactDOMServerHydration', () => {
   let container;
 
@@ -27,12 +31,14 @@ describe('ReactDOMServerHydration', () => {
     ReactDOMServer = require('react-dom/server');
     act = React.act;
 
+    window.addEventListener('error', errorHandler);
     console.error = jest.fn();
     container = document.createElement('div');
     document.body.appendChild(container);
   });
 
   afterEach(() => {
+    window.removeEventListener('error', errorHandler);
     document.body.removeChild(container);
     console.error = realConsoleError;
   });
@@ -80,25 +86,51 @@ describe('ReactDOMServerHydration', () => {
           </div>
         );
       }
-      if (gate(flags => flags.enableClientRenderFallbackOnTextMismatch)) {
+      if (gate(flags => flags.favorSafetyOverHydrationPerf)) {
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-          [
-            "Warning: Text content did not match. Server: "server" Client: "client"
-              in main (at **)
-              in div (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Text content does not match server-rendered HTML.]",
-            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-          ]
-        `);
+                  [
+                    "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+                  - A server/client branch \`if (typeof window !== 'undefined')\`.
+                  - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+                  - Date formatting in a user's locale which doesn't match the server.
+                  - External changing data without sending a snapshot of it along with the HTML.
+                  - Invalid HTML tag nesting.
+
+                  It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+                  https://react.dev/link/hydration-mismatch
+
+                    <Mismatch isClient={true}>
+                      <div className="parent">
+                        <main className="child">
+                  +       client
+                  -       server
+                  ]",
+                    "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+                  ]
+              `);
       } else {
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
           [
-            "Warning: Text content did not match. Server: "server" Client: "client"
-              in main (at **)
-              in div (at **)
-              in Mismatch (at **)",
+            "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <main className="child">
+          +       client
+          -       server
+          ",
           ]
         `);
       }
@@ -118,23 +150,49 @@ describe('ReactDOMServerHydration', () => {
       }
 
       /* eslint-disable no-irregular-whitespace */
-      if (gate(flags => flags.enableClientRenderFallbackOnTextMismatch)) {
+      if (gate(flags => flags.favorSafetyOverHydrationPerf)) {
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
           [
-            "Warning: Text content did not match. Server: "This markup contains an nbsp entity:   server text" Client: "This markup contains an nbsp entity:   client text"
-              in div (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Text content does not match server-rendered HTML.]",
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div>
+          +     This markup contains an nbsp entity:   client text
+          -     This markup contains an nbsp entity:   server text
+          ]",
             "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
           ]
         `);
       } else {
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
           [
-            "Warning: Text content did not match. Server: "This markup contains an nbsp entity:   server text" Client: "This markup contains an nbsp entity:   client text"
-              in div (at **)
-              in Mismatch (at **)",
+            "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div>
+          +     This markup contains an nbsp entity:   client text
+          -     This markup contains an nbsp entity:   server text
+          ",
           ]
         `);
       }
@@ -159,10 +217,28 @@ describe('ReactDOMServerHydration', () => {
       }
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
         [
-          "Warning: Prop \`dangerouslySetInnerHTML\` did not match. Server: "<span>server</span>" Client: "<span>client</span>"
-            in main (at **)
-            in div (at **)
-            in Mismatch (at **)",
+          "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <div className="parent">
+              <main
+                className="child"
+                dangerouslySetInnerHTML={{
+        +         __html: "<span>client</span>"
+        -         __html: "<span>server</span>"
+                }}
+              >
+        ",
         ]
       `);
     });
@@ -183,10 +259,27 @@ describe('ReactDOMServerHydration', () => {
       }
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
         [
-          "Warning: Prop \`className\` did not match. Server: "child server" Client: "child client"
-            in main (at **)
-            in div (at **)
-            in Mismatch (at **)",
+          "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <div className="parent">
+              <main
+        +       className="child client"
+        -       className="child server"
+        +       dir="ltr"
+        -       dir="rtl"
+              >
+        ",
         ]
       `);
     });
@@ -206,10 +299,28 @@ describe('ReactDOMServerHydration', () => {
       }
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
         [
-          "Warning: Prop \`tabIndex\` did not match. Server: "null" Client: "1"
-            in main (at **)
-            in div (at **)
-            in Mismatch (at **)",
+          "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <div className="parent">
+              <main
+                className="child"
+        +       tabIndex={1}
+        -       tabIndex={null}
+        +       dir="ltr"
+        -       dir={null}
+              >
+        ",
         ]
       `);
     });
@@ -229,10 +340,28 @@ describe('ReactDOMServerHydration', () => {
       }
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
         [
-          "Warning: Extra attributes from the server: tabindex,dir
-            in main (at **)
-            in div (at **)
-            in Mismatch (at **)",
+          "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <div className="parent">
+              <main
+                className="child"
+        +       tabIndex={null}
+        -       tabIndex="1"
+        +       dir={null}
+        -       dir="rtl"
+              >
+        ",
         ]
       `);
     });
@@ -252,10 +381,28 @@ describe('ReactDOMServerHydration', () => {
       }
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
         [
-          "Warning: Prop \`tabIndex\` did not match. Server: "null" Client: "1"
-            in main (at **)
-            in div (at **)
-            in Mismatch (at **)",
+          "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <div className="parent">
+              <main
+                className="child"
+        +       tabIndex={1}
+        -       tabIndex={null}
+        +       dir={null}
+        -       dir="rtl"
+              >
+        ",
         ]
       `);
     });
@@ -276,10 +423,26 @@ describe('ReactDOMServerHydration', () => {
       }
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
         [
-          "Warning: Prop \`style\` did not match. Server: "opacity:0" Client: "opacity:1"
-            in main (at **)
-            in div (at **)
-            in Mismatch (at **)",
+          "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <div className="parent">
+              <main
+                className="child"
+        +       style={{opacity:1}}
+        -       style={{opacity:"0"}}
+              >
+        ",
         ]
       `);
     });
@@ -297,16 +460,26 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <main> in <div>.
-                in main (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <main className="only">
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -321,16 +494,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <header> in <div>.
-                in header (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <header className="1">
+          -     <main className="2">
+                ...
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -345,16 +530,29 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <main> in <div>.
-                in main (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <header>
+          +     <main className="2">
+          -     <footer className="3">
+                ...
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -369,16 +567,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <footer> in <div>.
-                in footer (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <header>
+                <main>
+          +     <footer className="3">
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
     });
 
@@ -388,23 +598,49 @@ describe('ReactDOMServerHydration', () => {
         function Mismatch({isClient}) {
           return <div className="parent">{isClient && 'only'}</div>;
         }
-        if (gate(flags => flags.enableClientRenderFallbackOnTextMismatch)) {
+        if (gate(flags => flags.favorSafetyOverHydrationPerf)) {
           expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
             [
-              "Warning: Text content did not match. Server: "" Client: "only"
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Text content does not match server-rendered HTML.]",
+              "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+            - A server/client branch \`if (typeof window !== 'undefined')\`.
+            - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+            - Date formatting in a user's locale which doesn't match the server.
+            - External changing data without sending a snapshot of it along with the HTML.
+            - Invalid HTML tag nesting.
+
+            It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+            https://react.dev/link/hydration-mismatch
+
+              <Mismatch isClient={true}>
+                <div className="parent">
+            +     only
+            -     
+            ]",
               "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
             ]
           `);
         } else {
           expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
             [
-              "Warning: Text content did not match. Server: "" Client: "only"
-                in div (at **)
-                in Mismatch (at **)",
+              "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:
+
+            - A server/client branch \`if (typeof window !== 'undefined')\`.
+            - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+            - Date formatting in a user's locale which doesn't match the server.
+            - External changing data without sending a snapshot of it along with the HTML.
+            - Invalid HTML tag nesting.
+
+            It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+            https://react.dev/link/hydration-mismatch
+
+              <Mismatch isClient={true}>
+                <div className="parent">
+            +     only
+            -     
+            ",
             ]
           `);
         }
@@ -422,15 +658,29 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching text node for "second" in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <header>
+          +     second
+          -     <footer className="3">
+                ...
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -445,15 +695,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching text node for "first" in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     first
+          -     <main className="2">
+                ...
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -468,15 +731,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching text node for "third" in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <header>
+                <main>
+          +     third
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
     });
   });
@@ -493,15 +769,26 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain a <main> in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     <main className="only">
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -517,12 +804,24 @@ describe('ReactDOMServerHydration', () => {
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
           [
-            "Warning: Expected server HTML to contain a matching <main> in <div>.
-              in main (at **)
-              in div (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <main className="2">
+          -     <header className="1">
+                ...
+          ]",
             "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
           ]
         `);
@@ -540,16 +839,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <footer> in <div>.
-                in footer (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <header>
+          +     <footer className="3">
+          -     <main className="2">
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -564,15 +875,26 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain a <footer> in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     <footer className="3">
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
     });
 
@@ -583,15 +905,26 @@ describe('ReactDOMServerHydration', () => {
           return <div className="parent">{!isClient && 'only'}</div>;
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain the text node "only" in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     only
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -607,12 +940,24 @@ describe('ReactDOMServerHydration', () => {
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
           [
-            "Warning: Expected server HTML to contain a matching <main> in <div>.
-              in main (at **)
-              in div (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <main className="2">
+          -     first
+                ...
+          ]",
             "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
           ]
         `);
@@ -630,16 +975,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <footer> in <div>.
-                in footer (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <header>
+          +     <footer className="3">
+          -     second
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -654,15 +1011,26 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain the text node "third" in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     third
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
     });
   });
@@ -686,14 +1054,27 @@ describe('ReactDOMServerHydration', () => {
             </div>
           );
         }
-        // TODO: This message doesn't seem to have any useful details.
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <Suspense fallback={<p>}>
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -710,15 +1091,26 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain a <main> in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     <Suspense>
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -737,12 +1129,26 @@ describe('ReactDOMServerHydration', () => {
         }
         // TODO: This message doesn't seem to have any useful details.
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <Suspense fallback={<p>}>
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -765,15 +1171,26 @@ describe('ReactDOMServerHydration', () => {
         // unhydrated tail nodes and this template is the first match. When we add special case handling for client
         // rendered suspense boundaries this test will likely change again
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain a <template> in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     <Suspense>
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -790,16 +1207,30 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <main> in <div>.
-                in main (at **)
-                in Suspense (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating this Suspense boundary. Switched to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <Suspense fallback={<p>}>
+                  <header>
+          +       <main className="second">
+          -       <footer className="3">
+                  ...
+          ]",
+            "Caught [There was an error while hydrating this Suspense boundary. Switched to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -816,16 +1247,29 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Expected server HTML to contain a matching <footer> in <div>.
-                in footer (at **)
-                in Suspense (at **)
-                in div (at **)
-                in Mismatch (at **)",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating this Suspense boundary. Switched to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+                <Suspense fallback={<p>}>
+                  <header>
+          +       <footer className="3">
+          -       <main className="second">
+          ]",
+            "Caught [There was an error while hydrating this Suspense boundary. Switched to client rendering.]",
+          ]
+        `);
       });
 
       // @gate __DEV__
@@ -899,12 +1343,23 @@ describe('ReactDOMServerHydration', () => {
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
           [
-            "Warning: Expected server HTML to contain a matching <header> in <div>.
-              in header (at **)
-              in div (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          +     <header className="1">
+                ...
+          ]",
             "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
           ]
         `);
@@ -926,15 +1381,28 @@ describe('ReactDOMServerHydration', () => {
           );
         }
         expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-            [
-              "Warning: Did not expect server HTML to contain a <header> in <div>.
-                in div (at **)
-                in Mismatch (at **)",
-              "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-              "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-              "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-            ]
-          `);
+          [
+            "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+          - A server/client branch \`if (typeof window !== 'undefined')\`.
+          - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+          - Date formatting in a user's locale which doesn't match the server.
+          - External changing data without sending a snapshot of it along with the HTML.
+          - Invalid HTML tag nesting.
+
+          It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+          https://react.dev/link/hydration-mismatch
+
+            <Mismatch isClient={true}>
+              <div className="parent">
+          -     <header className="1">
+          -     <main className="2">
+          -     <footer className="3">
+          ]",
+            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+          ]
+        `);
       });
     });
   });
@@ -975,18 +1443,31 @@ describe('ReactDOMServerHydration', () => {
       }
 
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-          [
-            "Warning: Expected server HTML to contain a matching <footer> in <div>.
-              in footer (at **)
-              in Panel (at **)
-              in div (at **)
-              in ProfileSettings (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-          ]
-        `);
+        [
+          "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <ProfileSettings>
+              <div className="parent">
+                <input>
+                <Panel type="profile">
+                  <header>
+                  <main>
+        +         <footer className="3">
+        ]",
+          "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+        ]
+      `);
     });
 
     // @gate __DEV__
@@ -1024,16 +1505,27 @@ describe('ReactDOMServerHydration', () => {
       }
 
       expect(testMismatch(Mismatch)).toMatchInlineSnapshot(`
-          [
-            "Warning: Did not expect server HTML to contain a <footer> in <div>.
-              in div (at **)
-              in ProfileSettings (at **)
-              in Mismatch (at **)",
-            "Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.",
-            "Caught [Hydration failed because the initial UI does not match what was rendered on the server.]",
-            "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
-          ]
-        `);
+        [
+          "Caught [Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:
+
+        - A server/client branch \`if (typeof window !== 'undefined')\`.
+        - Variable input such as \`Date.now()\` or \`Math.random()\` which changes each time it's called.
+        - Date formatting in a user's locale which doesn't match the server.
+        - External changing data without sending a snapshot of it along with the HTML.
+        - Invalid HTML tag nesting.
+
+        It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.
+
+        https://react.dev/link/hydration-mismatch
+
+          <Mismatch isClient={true}>
+            <ProfileSettings>
+              <div className="parent">
+        -       <footer className="3">
+        ]",
+          "Caught [There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.]",
+        ]
+      `);
     });
   });
 });
diff --git a/packages/react-dom/src/__tests__/ReactDOMLegacyFiber-test.js b/packages/react-dom/src/__tests__/ReactDOMLegacyFiber-test.js
index c2dbc38580e3f..9725d5fe0fbdc 100644
--- a/packages/react-dom/src/__tests__/ReactDOMLegacyFiber-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMLegacyFiber-test.js
@@ -12,11 +12,12 @@
 const React = require('react');
 const ReactDOM = require('react-dom');
 const PropTypes = require('prop-types');
-
+let act;
 describe('ReactDOMLegacyFiber', () => {
   let container;
 
   beforeEach(() => {
+    act = require('internal-test-utils').act;
     container = document.createElement('div');
     document.body.appendChild(container);
   });
@@ -110,7 +111,10 @@ describe('ReactDOMLegacyFiber', () => {
       container,
     );
 
-    const textNode = ReactDOM.findDOMNode(instance);
+    const textNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+        instance,
+      );
     expect(textNode).toBe(container.firstChild);
     expect(textNode.nodeType).toBe(3);
     expect(textNode.nodeValue).toBe('foo');
@@ -129,7 +133,10 @@ describe('ReactDOMLegacyFiber', () => {
 
     expect(container.childNodes.length).toBe(2);
 
-    const firstNode = ReactDOM.findDOMNode(instance);
+    const firstNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+        instance,
+      );
     expect(firstNode).toBe(container.firstChild);
     expect(firstNode.tagName).toBe('DIV');
   });
@@ -158,7 +165,10 @@ describe('ReactDOMLegacyFiber', () => {
 
     expect(container.childNodes.length).toBe(2);
 
-    const firstNode = ReactDOM.findDOMNode(instance);
+    const firstNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+        instance,
+      );
     expect(firstNode).toBe(container.firstChild);
     expect(firstNode.tagName).toBe('DIV');
   });
@@ -182,7 +192,10 @@ describe('ReactDOMLegacyFiber', () => {
 
     expect(container.childNodes.length).toBe(2);
 
-    const firstNode = ReactDOM.findDOMNode(instance);
+    const firstNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+        instance,
+      );
     expect(firstNode).toBe(container.firstChild);
     expect(firstNode.tagName).toBe('DIV');
   });
@@ -656,18 +669,20 @@ describe('ReactDOMLegacyFiber', () => {
   });
 
   // @gate !disableLegacyMode
-  it('should unwind namespaces on uncaught errors', () => {
+  it('should unwind namespaces on uncaught errors', async () => {
     function BrokenRender() {
       throw new Error('Hello');
     }
 
-    expect(() => {
-      assertNamespacesMatch(
-        <svg {...expectSVG}>
-          <BrokenRender />
-        </svg>,
-      );
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        assertNamespacesMatch(
+          <svg {...expectSVG}>
+            <BrokenRender />
+          </svg>,
+        );
+      });
+    }).rejects.toThrow('Hello');
     assertNamespacesMatch(<div {...expectHTML} />);
   });
 
@@ -875,13 +890,19 @@ describe('ReactDOMLegacyFiber', () => {
     }
 
     const myNodeA = ReactDOM.render(<MyNode />, container);
-    const a = ReactDOM.findDOMNode(myNodeA);
+    const a =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+        myNodeA,
+      );
     expect(a.tagName).toBe('DIV');
 
     const myNodeB = ReactDOM.render(<MyNode flag={true} />, container);
     expect(myNodeA === myNodeB).toBe(true);
 
-    const b = ReactDOM.findDOMNode(myNodeB);
+    const b =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode(
+        myNodeB,
+      );
     expect(b.tagName).toBe('SPAN');
   });
 
@@ -1193,10 +1214,10 @@ describe('ReactDOMLegacyFiber', () => {
     if (__DEV__) {
       expect(console.error).toHaveBeenCalledTimes(2);
       expect(console.error.mock.calls[0][0]).toMatch(
-        'ReactDOM.render is no longer supported in React 18',
+        'ReactDOM.render has not been supported since React 18',
       );
       expect(console.error.mock.calls[1][0]).toMatch(
-        'ReactDOM.render is no longer supported in React 18',
+        'ReactDOM.render has not been supported since React 18',
       );
     }
   });
@@ -1222,7 +1243,7 @@ describe('ReactDOMLegacyFiber', () => {
   });
 
   // @gate !disableLegacyMode
-  it('should warn when replacing a container which was manually updated outside of React', () => {
+  it('should warn when replacing a container which was manually updated outside of React', async () => {
     // when not messing with the DOM outside of React
     ReactDOM.render(<div key="1">foo</div>, container);
     ReactDOM.render(<div key="1">bar</div>, container);
@@ -1232,18 +1253,20 @@ describe('ReactDOMLegacyFiber', () => {
     // It's an error of type 'NotFoundError' with no message
     container.innerHTML = '<div>MEOW.</div>';
 
-    expect(() => {
-      expect(() =>
-        ReactDOM.render(<div key="2">baz</div>, container),
-      ).toErrorDev(
-        '' +
-          'It looks like the React-rendered content of this container was ' +
-          'removed without using React. This is not supported and will ' +
-          'cause errors. Instead, call ReactDOM.unmountComponentAtNode ' +
-          'to empty a container.',
-        {withoutStack: true},
-      );
-    }).toThrowError();
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.render(<div key="2">baz</div>, container);
+        });
+      }).rejects.toThrow('The node to be removed is not a child of this node.');
+    }).toErrorDev(
+      '' +
+        'It looks like the React-rendered content of this container was ' +
+        'removed without using React. This is not supported and will ' +
+        'cause errors. Instead, call ReactDOM.unmountComponentAtNode ' +
+        'to empty a container.',
+      {withoutStack: true},
+    );
   });
 
   // @gate !disableLegacyMode
diff --git a/packages/react-dom/src/__tests__/ReactDOMLegacyFloat-test.js b/packages/react-dom/src/__tests__/ReactDOMLegacyFloat-test.js
index 94876e41641f9..52c9746abdb4f 100644
--- a/packages/react-dom/src/__tests__/ReactDOMLegacyFloat-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMLegacyFloat-test.js
@@ -22,7 +22,6 @@ describe('ReactDOMFloat', () => {
   });
 
   // fixes #27177
-  // @gate enableFloat
   it('does not hoist above the <html> tag', async () => {
     const result = ReactDOMFizzServer.renderToString(
       <html>
diff --git a/packages/react-dom/src/__tests__/ReactDOMOption-test.js b/packages/react-dom/src/__tests__/ReactDOMOption-test.js
index 873aad71d21d3..8743c5993ddbe 100644
--- a/packages/react-dom/src/__tests__/ReactDOMOption-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMOption-test.js
@@ -237,7 +237,7 @@ describe('ReactDOMOption', () => {
     expect(node.selectedIndex).toEqual(2);
   });
 
-  it('generates a warning and hydration error when an invalid nested tag is used as a child', async () => {
+  it('generates a hydration error when an invalid nested tag is used as a child', async () => {
     const ref = React.createRef();
     const children = (
       <select readOnly={true} value="bar">
@@ -266,14 +266,7 @@ describe('ReactDOMOption', () => {
           onRecoverableError: () => {},
         });
       });
-    }).toErrorDev(
-      [
-        'Warning: Text content did not match. Server: "FooBaz" Client: "Foo"',
-        'Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>',
-        'Warning: In HTML, <div> cannot be a child of <option>',
-      ],
-      {withoutStack: 1},
-    );
+    }).toErrorDev(['Warning: In HTML, <div> cannot be a child of <option>']);
     option = container.firstChild.firstChild;
 
     expect(option.textContent).toBe('BarFooBaz');
diff --git a/packages/react-dom/src/__tests__/ReactDOMRoot-test.js b/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
index fdf048049d167..cdfb267006b1e 100644
--- a/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
@@ -47,6 +47,7 @@ describe('ReactDOMRoot', () => {
     expect(container.textContent).toEqual('Hi');
   });
 
+  // @gate !classic || !__DEV__
   it('warns if you import createRoot from react-dom', async () => {
     expect(() => ReactDOM.createRoot(container)).toErrorDev(
       'You are importing createRoot from "react-dom" which is not supported. ' +
@@ -57,6 +58,7 @@ describe('ReactDOMRoot', () => {
     );
   });
 
+  // @gate !classic || !__DEV__
   it('warns if you import hydrateRoot from react-dom', async () => {
     expect(() => ReactDOM.hydrateRoot(container, null)).toErrorDev(
       'You are importing hydrateRoot from "react-dom" which is not supported. ' +
@@ -171,7 +173,8 @@ describe('ReactDOMRoot', () => {
       </div>,
     );
     await expect(async () => await waitForAll([])).toErrorDev(
-      'Extra attributes',
+      "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+      {withoutStack: true},
     );
   });
 
@@ -222,21 +225,8 @@ describe('ReactDOMRoot', () => {
   });
 
   it('warns if creating a root on the document.body', async () => {
-    if (gate(flags => flags.enableFloat)) {
-      // we no longer expect an error for this if float is enabled
-      ReactDOMClient.createRoot(document.body);
-    } else {
-      expect(() => {
-        ReactDOMClient.createRoot(document.body);
-      }).toErrorDev(
-        'createRoot(): Creating roots directly with document.body is ' +
-          'discouraged, since its children are often manipulated by third-party ' +
-          'scripts and browser extensions. This may lead to subtle ' +
-          'reconciliation issues. Try using a container element created ' +
-          'for your app.',
-        {withoutStack: true},
-      );
-    }
+    // we no longer expect an error for this if float is enabled
+    ReactDOMClient.createRoot(document.body);
   });
 
   it('warns if updating a root that has had its contents removed', async () => {
@@ -245,21 +235,9 @@ describe('ReactDOMRoot', () => {
     await waitForAll([]);
     container.innerHTML = '';
 
-    if (gate(flags => flags.enableFloat)) {
-      // When either of these flags are on this validation is turned off so we
-      // expect there to be no warnings
-      root.render(<div>Hi</div>);
-    } else {
-      expect(() => {
-        root.render(<div>Hi</div>);
-      }).toErrorDev(
-        'It looks like the React-rendered content of the ' +
-          'root container was removed without using React. This is not ' +
-          'supported and will cause errors. Instead, call ' +
-          "root.unmount() to empty a root's container.",
-        {withoutStack: true},
-      );
-    }
+    // When either of these flags are on this validation is turned off so we
+    // expect there to be no warnings
+    root.render(<div>Hi</div>);
   });
 
   it('should render different components in same root', async () => {
@@ -343,9 +321,11 @@ describe('ReactDOMRoot', () => {
     });
     container.innerHTML = '';
 
-    expect(() => {
-      root.unmount();
-    }).toThrow('The node to be removed is not a child of this node.');
+    await expect(async () => {
+      await act(() => {
+        root.unmount();
+      });
+    }).rejects.toThrow('The node to be removed is not a child of this node.');
   });
 
   it('opts-in to concurrent default updates', async () => {
diff --git a/packages/react-dom/src/__tests__/ReactDOMSelect-test.js b/packages/react-dom/src/__tests__/ReactDOMSelect-test.js
index 0bc230bcb90d0..eac858697f572 100644
--- a/packages/react-dom/src/__tests__/ReactDOMSelect-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMSelect-test.js
@@ -1448,7 +1448,13 @@ describe('ReactDOMSelect', () => {
               </select>,
             );
           }),
-        ).rejects.toThrowError(new TypeError('prod message'));
+        ).rejects.toThrowError(
+          // eslint-disable-next-line no-undef
+          new AggregateError([
+            new TypeError('prod message'),
+            new TypeError('prod message'),
+          ]),
+        );
       }).toErrorDev([
         'The provided `value` attribute is an unsupported type TemporalLike.' +
           ' This value must be coerced to a string before using it here.',
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationAttributes-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationAttributes-test.js
index 1613ef66994ef..5d798e3f58df3 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationAttributes-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationAttributes-test.js
@@ -699,13 +699,8 @@ describe('ReactDOMServerIntegration', () => {
 
     itRenders('className for custom elements', async render => {
       const e = await render(<custom-element className="test" />, 0);
-      if (ReactFeatureFlags.enableCustomElementPropertySupport) {
-        expect(e.getAttribute('className')).toBe(null);
-        expect(e.getAttribute('class')).toBe('test');
-      } else {
-        expect(e.getAttribute('className')).toBe('test');
-        expect(e.getAttribute('class')).toBe(null);
-      }
+      expect(e.getAttribute('className')).toBe(null);
+      expect(e.getAttribute('class')).toBe('test');
     });
 
     itRenders('htmlFor property on is elements', async render => {
@@ -738,53 +733,33 @@ describe('ReactDOMServerIntegration', () => {
 
     itRenders('unknown boolean `true` attributes as strings', async render => {
       const e = await render(<custom-element foo={true} />);
-      if (ReactFeatureFlags.enableCustomElementPropertySupport) {
-        expect(e.getAttribute('foo')).toBe('');
-      } else {
-        expect(e.getAttribute('foo')).toBe('true');
-      }
+      expect(e.getAttribute('foo')).toBe('');
     });
 
     itRenders('unknown boolean `false` attributes as strings', async render => {
       const e = await render(<custom-element foo={false} />);
-      if (ReactFeatureFlags.enableCustomElementPropertySupport) {
-        expect(e.getAttribute('foo')).toBe(null);
-      } else {
-        expect(e.getAttribute('foo')).toBe('false');
-      }
+      expect(e.getAttribute('foo')).toBe(null);
     });
 
     itRenders('new boolean `true` attributes', async render => {
-      const element = await render(
-        <div inert={true} />,
-        ReactFeatureFlags.enableNewBooleanProps ? 0 : 1,
-      );
+      const element = await render(<div inert={true} />, 0);
 
-      expect(element.getAttribute('inert')).toBe(
-        ReactFeatureFlags.enableNewBooleanProps ? '' : null,
-      );
+      expect(element.getAttribute('inert')).toBe('');
     });
 
     itRenders('new boolean `""` attributes', async render => {
       const element = await render(
         <div inert="" />,
-        ReactFeatureFlags.enableNewBooleanProps
-          ? // Warns since this used to render `inert=""` like `inert={true}`
-            // but now renders it like `inert={false}`.
-            1
-          : 0,
+        // Warns since this used to render `inert=""` like `inert={true}`
+        // but now renders it like `inert={false}`.
+        1,
       );
 
-      expect(element.getAttribute('inert')).toBe(
-        ReactFeatureFlags.enableNewBooleanProps ? null : '',
-      );
+      expect(element.getAttribute('inert')).toBe(null);
     });
 
     itRenders('new boolean `false` attributes', async render => {
-      const element = await render(
-        <div inert={false} />,
-        ReactFeatureFlags.enableNewBooleanProps ? 0 : 1,
-      );
+      const element = await render(<div inert={false} />, 0);
 
       expect(element.getAttribute('inert')).toBe(null);
     });
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationElements-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationElements-test.js
index d7dc81d2d4ef8..f492aebb455db 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationElements-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationElements-test.js
@@ -18,7 +18,6 @@ let React;
 let ReactDOM;
 let ReactDOMClient;
 let ReactDOMServer;
-let ReactFeatureFlags;
 
 function initModules() {
   jest.resetModules();
@@ -26,7 +25,6 @@ function initModules() {
   ReactDOM = require('react-dom');
   ReactDOMClient = require('react-dom/client');
   ReactDOMServer = require('react-dom/server');
-  ReactFeatureFlags = require('shared/ReactFeatureFlags');
 
   // Make them available to the helpers.
   return {
@@ -629,23 +627,9 @@ describe('ReactDOMServerIntegration', () => {
         checkFooDiv(await render(<ClassComponent />));
       });
 
-      if (require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-        itThrowsWhenRendering(
-          'factory components',
-          async render => {
-            const FactoryComponent = () => {
-              return {
-                render: function () {
-                  return <div>foo</div>;
-                },
-              };
-            };
-            await render(<FactoryComponent />, 1);
-          },
-          'Objects are not valid as a React child (found: object with keys {render})',
-        );
-      } else {
-        itRenders('factory components', async render => {
+      itThrowsWhenRendering(
+        'factory components',
+        async render => {
           const FactoryComponent = () => {
             return {
               render: function () {
@@ -653,9 +637,10 @@ describe('ReactDOMServerIntegration', () => {
               },
             };
           };
-          checkFooDiv(await render(<FactoryComponent />, 1));
-        });
-      }
+          await render(<FactoryComponent />, 1);
+        },
+        'Objects are not valid as a React child (found: object with keys {render})',
+      );
     });
 
     describe('component hierarchies', function () {
@@ -843,16 +828,15 @@ describe('ReactDOMServerIntegration', () => {
           if (
             render === serverRender ||
             render === streamRender ||
-            (render === clientRenderOnServerString &&
-              ReactFeatureFlags.enableClientRenderFallbackOnTextMismatch)
+            render === clientRenderOnServerString
           ) {
             expect(e.childNodes.length).toBe(1);
-            // Everything becomes LF when parsed from server HTML or hydrated if enableClientRenderFallbackOnTextMismatch is on.
+            // Everything becomes LF when parsed from server HTML or hydrated.
             // Null character is ignored.
             expectNode(e.childNodes[0], TEXT_NODE_TYPE, 'foo\nbar\nbaz\nqux');
           } else {
             expect(e.childNodes.length).toBe(1);
-            // Client rendering (or hydration without enableClientRenderFallbackOnTextMismatch) uses JS value with CR.
+            // Client rendering uses JS value with CR.
             // Null character stays.
 
             expectNode(
@@ -876,19 +860,18 @@ describe('ReactDOMServerIntegration', () => {
           if (
             render === serverRender ||
             render === streamRender ||
-            (render === clientRenderOnServerString &&
-              ReactFeatureFlags.enableClientRenderFallbackOnTextMismatch)
+            render === clientRenderOnServerString
           ) {
             // We have three nodes because there is a comment between them.
             expect(e.childNodes.length).toBe(3);
-            // Everything becomes LF when parsed from server HTML or hydrated if enableClientRenderFallbackOnTextMismatch is on.
+            // Everything becomes LF when parsed from server HTML or hydrated.
             // Null character is ignored.
             expectNode(e.childNodes[0], TEXT_NODE_TYPE, 'foo\nbar');
             expectNode(e.childNodes[2], TEXT_NODE_TYPE, '\nbaz\nqux');
           } else if (render === clientRenderOnServerString) {
             // We have three nodes because there is a comment between them.
             expect(e.childNodes.length).toBe(3);
-            // Hydration without enableClientRenderFallbackOnTextMismatch uses JS value with CR and null character.
+            // Hydration uses JS value with CR and null character.
 
             expectNode(e.childNodes[0], TEXT_NODE_TYPE, 'foo\rbar');
             expectNode(e.childNodes[2], TEXT_NODE_TYPE, '\r\nbaz\nqux\u0000');
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationLegacyContextDisabled-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationLegacyContextDisabled-test.internal.js
index e2af97951ea48..40ae0b682231b 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationLegacyContextDisabled-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationLegacyContextDisabled-test.internal.js
@@ -105,7 +105,7 @@ describe('ReactDOMServerIntegrationLegacyContextDisabled', () => {
           <RegularFn />
         </span>
       </LegacyProvider>,
-      render === clientRenderOnBadMarkup ? 5 : 3,
+      render === clientRenderOnBadMarkup ? 4 : 3,
     );
     expect(e.textContent).toBe('{}undefinedundefined');
     expect(lifecycleContextLog).toEqual([]);
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationNewContext-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationNewContext-test.js
index 58af90bce30e9..df4deff9e23d4 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationNewContext-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationNewContext-test.js
@@ -338,24 +338,12 @@ describe('ReactDOMServerIntegration', () => {
         </LoggedInUser.Provider>
       );
 
-      let streamAmy;
-      let streamBob;
-      expect(() => {
-        streamAmy = ReactDOMServer.renderToNodeStream(
-          AppWithUser('Amy'),
-        ).setEncoding('utf8');
-      }).toErrorDev(
-        'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-        {withoutStack: true},
-      );
-      expect(() => {
-        streamBob = ReactDOMServer.renderToNodeStream(
-          AppWithUser('Bob'),
-        ).setEncoding('utf8');
-      }).toErrorDev(
-        'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-        {withoutStack: true},
-      );
+      const streamAmy = ReactDOMServer.renderToStaticNodeStream(
+        AppWithUser('Amy'),
+      ).setEncoding('utf8');
+      const streamBob = ReactDOMServer.renderToStaticNodeStream(
+        AppWithUser('Bob'),
+      ).setEncoding('utf8');
 
       // Testing by filling the buffer using internal _read() with a small
       // number of bytes to avoid a test case which needs to align to a
@@ -390,14 +378,9 @@ describe('ReactDOMServerIntegration', () => {
       const streamCount = 34;
 
       for (let i = 0; i < streamCount; i++) {
-        expect(() => {
-          streams[i] = ReactDOMServer.renderToNodeStream(
-            NthRender(i % 2 === 0 ? 'Expected to be recreated' : i),
-          ).setEncoding('utf8');
-        }).toErrorDev(
-          'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-          {withoutStack: true},
-        );
+        streams[i] = ReactDOMServer.renderToStaticNodeStream(
+          NthRender(i % 2 === 0 ? 'Expected to be recreated' : i),
+        ).setEncoding('utf8');
       }
 
       // Testing by filling the buffer using internal _read() with a small
@@ -414,14 +397,9 @@ describe('ReactDOMServerIntegration', () => {
 
       // Recreate those same streams.
       for (let i = 0; i < streamCount; i += 2) {
-        expect(() => {
-          streams[i] = ReactDOMServer.renderToNodeStream(
-            NthRender(i),
-          ).setEncoding('utf8');
-        }).toErrorDev(
-          'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-          {withoutStack: true},
-        );
+        streams[i] = ReactDOMServer.renderToStaticNodeStream(
+          NthRender(i),
+        ).setEncoding('utf8');
       }
 
       // Read a bit from all streams again.
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationReconnecting-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationReconnecting-test.js
index 3eae27486a097..a58f7f8529f98 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationReconnecting-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationReconnecting-test.js
@@ -12,7 +12,6 @@
 const ReactDOMServerIntegrationUtils = require('./utils/ReactDOMServerIntegrationTestUtils');
 
 let React;
-let ReactDOM;
 let ReactDOMClient;
 let ReactDOMServer;
 
@@ -453,75 +452,3 @@ describe('ReactDOMServerIntegration', () => {
       ));
   });
 });
-
-describe('ReactDOMServerIntegration (legacy)', () => {
-  function initModules() {
-    // Reset warning cache.
-    jest.resetModules();
-
-    React = require('react');
-    ReactDOM = require('react-dom');
-    ReactDOMServer = require('react-dom/server');
-
-    // Make them available to the helpers.
-    return {
-      ReactDOM,
-      ReactDOMServer,
-    };
-  }
-
-  const {resetModules, expectMarkupMatch} =
-    ReactDOMServerIntegrationUtils(initModules);
-
-  beforeEach(() => {
-    resetModules();
-  });
-
-  // @gate !disableLegacyMode
-  it('legacy mode can explicitly ignore errors reconnecting different element types of children', () =>
-    expectMarkupMatch(
-      <div>
-        <div />
-      </div>,
-      <div suppressHydrationWarning={true}>
-        <span />
-      </div>,
-    ));
-
-  // @gate !disableLegacyMode
-  it('legacy mode can explicitly ignore reconnecting more children', () =>
-    expectMarkupMatch(
-      <div>
-        <div />
-      </div>,
-      <div suppressHydrationWarning={true}>
-        <div />
-        <div />
-      </div>,
-    ));
-
-  // @gate !disableLegacyMode
-  it('legacy mode can explicitly ignore reconnecting fewer children', () =>
-    expectMarkupMatch(
-      <div>
-        <div />
-        <div />
-      </div>,
-      <div suppressHydrationWarning={true}>
-        <div />
-      </div>,
-    ));
-
-  // @gate !disableLegacyMode
-  it('legacy mode can explicitly ignore reconnecting reordered children', () =>
-    expectMarkupMatch(
-      <div suppressHydrationWarning={true}>
-        <div />
-        <span />
-      </div>,
-      <div suppressHydrationWarning={true}>
-        <span />
-        <div />
-      </div>,
-    ));
-});
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationSelect-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationSelect-test.js
index 8114092a42b0d..9b20b1edcd216 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationSelect-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationSelect-test.js
@@ -254,7 +254,6 @@ describe('ReactDOMServerIntegrationSelect', () => {
           <option value="first">First</option>
           <option value="true">True</option>
         </select>,
-        1,
       );
       expect(e.firstChild.selected).toBe(false);
       expect(e.lastChild.selected).toBe(true);
@@ -269,7 +268,6 @@ describe('ReactDOMServerIntegrationSelect', () => {
           <option value="first">First</option>
           <option value="undefined">Undefined</option>
         </select>,
-        1,
       );
       expect(e.firstChild.selected).toBe(true);
       expect(e.lastChild.selected).toBe(false);
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationUntrustedURL-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationUntrustedURL-test.js
index 73d511985527c..dfdb9ffd23757 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationUntrustedURL-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationUntrustedURL-test.js
@@ -23,176 +23,6 @@ const EXPECTED_SAFE_URL =
   "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')";
 
 describe('ReactDOMServerIntegration - Untrusted URLs', () => {
-  // The `itRenders` helpers don't work with the gate pragma, so we have to do
-  // this instead.
-  if (gate(flags => flags.disableJavaScriptURLs)) {
-    it("empty test so Jest doesn't complain", () => {});
-    return;
-  }
-
-  function initModules() {
-    jest.resetModules();
-    React = require('react');
-    ReactDOMClient = require('react-dom/client');
-    ReactDOMServer = require('react-dom/server');
-    act = require('internal-test-utils').act;
-
-    // Make them available to the helpers.
-    return {
-      ReactDOMClient,
-      ReactDOMServer,
-    };
-  }
-
-  const {resetModules, itRenders} = ReactDOMServerIntegrationUtils(initModules);
-
-  beforeEach(() => {
-    resetModules();
-  });
-
-  itRenders('a http link with the word javascript in it', async render => {
-    const e = await render(
-      <a href="http://javascript:0/thisisfine">Click me</a>,
-    );
-    expect(e.tagName).toBe('A');
-    expect(e.href).toBe('http://javascript:0/thisisfine');
-  });
-
-  itRenders('a javascript protocol href', async render => {
-    // Only the first one warns. The second warning is deduped.
-    const e = await render(
-      <div>
-        <a href="javascript:notfine">p0wned</a>
-        <a href="javascript:notfineagain">p0wned again</a>
-      </div>,
-      1,
-    );
-    expect(e.firstChild.href).toBe('javascript:notfine');
-    expect(e.lastChild.href).toBe('javascript:notfineagain');
-  });
-
-  itRenders('a javascript protocol with leading spaces', async render => {
-    const e = await render(
-      <a href={'  \t \u0000\u001F\u0003javascript\n: notfine'}>p0wned</a>,
-      1,
-    );
-    // We use an approximate comparison here because JSDOM might not parse
-    // \u0000 in HTML properly.
-    expect(e.href).toContain('notfine');
-  });
-
-  itRenders(
-    'a javascript protocol with intermediate new lines and mixed casing',
-    async render => {
-      const e = await render(
-        <a href={'\t\r\n Jav\rasCr\r\niP\t\n\rt\n:notfine'}>p0wned</a>,
-        1,
-      );
-      expect(e.href).toBe('javascript:notfine');
-    },
-  );
-
-  itRenders('a javascript protocol area href', async render => {
-    const e = await render(
-      <map>
-        <area href="javascript:notfine" />
-      </map>,
-      1,
-    );
-    expect(e.firstChild.href).toBe('javascript:notfine');
-  });
-
-  itRenders('a javascript protocol form action', async render => {
-    const e = await render(<form action="javascript:notfine">p0wned</form>, 1);
-    expect(e.action).toBe('javascript:notfine');
-  });
-
-  itRenders('a javascript protocol input formAction', async render => {
-    const e = await render(
-      <input type="submit" formAction="javascript:notfine" />,
-      1,
-    );
-    expect(e.getAttribute('formAction')).toBe('javascript:notfine');
-  });
-
-  itRenders('a javascript protocol button formAction', async render => {
-    const e = await render(
-      <button formAction="javascript:notfine">p0wned</button>,
-      1,
-    );
-    expect(e.getAttribute('formAction')).toBe('javascript:notfine');
-  });
-
-  itRenders('a javascript protocol iframe src', async render => {
-    const e = await render(<iframe src="javascript:notfine" />, 1);
-    expect(e.src).toBe('javascript:notfine');
-  });
-
-  itRenders('a javascript protocol frame src', async render => {
-    const e = await render(
-      <html>
-        <head />
-        <frameset>
-          <frame src="javascript:notfine" />
-        </frameset>
-      </html>,
-      1,
-    );
-    expect(e.lastChild.firstChild.src).toBe('javascript:notfine');
-  });
-
-  itRenders('a javascript protocol in an SVG link', async render => {
-    const e = await render(
-      <svg>
-        <a href="javascript:notfine" />
-      </svg>,
-      1,
-    );
-    expect(e.firstChild.getAttribute('href')).toBe('javascript:notfine');
-  });
-
-  itRenders(
-    'a javascript protocol in an SVG link with a namespace',
-    async render => {
-      const e = await render(
-        <svg>
-          <a xlinkHref="javascript:notfine" />
-        </svg>,
-        1,
-      );
-      expect(
-        e.firstChild.getAttributeNS('http://www.w3.org/1999/xlink', 'href'),
-      ).toBe('javascript:notfine');
-    },
-  );
-
-  it('rejects a javascript protocol href if it is added during an update', async () => {
-    const container = document.createElement('div');
-    const root = ReactDOMClient.createRoot(container);
-    await act(async () => {
-      root.render(<a href="thisisfine">click me</a>);
-    });
-    await expect(async () => {
-      await act(() => {
-        root.render(<a href="javascript:notfine">click me</a>);
-      });
-    }).toErrorDev(
-      'Warning: A future version of React will block javascript: URLs as a security precaution. ' +
-        'Use event handlers instead if you can. If you need to generate unsafe HTML try using ' +
-        'dangerouslySetInnerHTML instead. React was passed "javascript:notfine".\n' +
-        '    in a (at **)',
-    );
-  });
-});
-
-describe('ReactDOMServerIntegration - Untrusted URLs - disableJavaScriptURLs', () => {
-  // The `itRenders` helpers don't work with the gate pragma, so we have to do
-  // this instead.
-  if (gate(flags => !flags.disableJavaScriptURLs)) {
-    it("empty test so Jest doesn't complain", () => {});
-    return;
-  }
-
   function initModules() {
     jest.resetModules();
 
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js
index 9ee8ee5a8130e..1ab7f81e4eaa2 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js
@@ -27,13 +27,13 @@ let waitFor;
 let waitForPaint;
 let assertLog;
 
-function normalizeCodeLocInfo(strOrErr) {
-  if (strOrErr && strOrErr.replace) {
-    return strOrErr.replace(/\n +(?:at|in) ([\S]+)[^\n]*/g, function (m, name) {
-      return '\n    in ' + name + ' (at **)';
-    });
+function normalizeError(msg) {
+  // Take the first sentence to make it easier to assert on.
+  const idx = msg.indexOf('.');
+  if (idx > -1) {
+    return msg.slice(0, idx + 1);
   }
-  return strOrErr;
+  return msg;
 }
 
 function dispatchMouseEvent(to, from) {
@@ -151,113 +151,704 @@ describe('ReactDOMServerPartialHydration', () => {
       if (suspend) {
         throw promise;
       } else {
-        return 'Hello';
+        return 'Hello';
+      }
+    }
+
+    function App() {
+      return (
+        <div>
+          <Suspense fallback="Loading...">
+            <span ref={ref}>
+              <Child />
+            </span>
+          </Suspense>
+        </div>
+      );
+    }
+
+    // First we render the final HTML. With the streaming renderer
+    // this may have suspense points on the server but here we want
+    // to test the completed HTML. Don't suspend on the server.
+    suspend = false;
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+
+    const container = document.createElement('div');
+    container.innerHTML = finalHTML;
+
+    const span = container.getElementsByTagName('span')[0];
+
+    // On the client we don't have all data yet but we want to start
+    // hydrating anyway.
+    suspend = true;
+    ReactDOMClient.hydrateRoot(container, <App />);
+    await waitForAll([]);
+
+    expect(ref.current).toBe(null);
+
+    // Resolving the promise should continue hydration
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([]);
+
+    // We should now have hydrated with a ref on the existing span.
+    expect(ref.current).toBe(span);
+  });
+
+  it('can hydrate siblings of a suspended component without errors', async () => {
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => (resolve = resolvePromise));
+    function Child() {
+      if (suspend) {
+        throw promise;
+      } else {
+        return 'Hello';
+      }
+    }
+
+    function App() {
+      return (
+        <Suspense fallback="Loading...">
+          <Child />
+          <Suspense fallback="Loading...">
+            <div>Hello</div>
+          </Suspense>
+        </Suspense>
+      );
+    }
+
+    // First we render the final HTML. With the streaming renderer
+    // this may have suspense points on the server but here we want
+    // to test the completed HTML. Don't suspend on the server.
+    suspend = false;
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+
+    const container = document.createElement('div');
+    container.innerHTML = finalHTML;
+    expect(container.textContent).toBe('HelloHello');
+
+    // On the client we don't have all data yet but we want to start
+    // hydrating anyway.
+    suspend = true;
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll([]);
+
+    // Expect the server-generated HTML to stay intact.
+    expect(container.textContent).toBe('HelloHello');
+
+    // Resolving the promise should continue hydration
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([]);
+    // Hydration should not change anything.
+    expect(container.textContent).toBe('HelloHello');
+  });
+
+  it('falls back to client rendering boundary on mismatch', async () => {
+    let client = false;
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
+    function Child() {
+      if (suspend) {
+        Scheduler.log('Suspend');
+        throw promise;
+      } else {
+        Scheduler.log('Hello');
+        return 'Hello';
+      }
+    }
+    function Component({shouldMismatch}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return <article>Mismatch</article>;
+      }
+      return <div>Component</div>;
+    }
+    function App() {
+      return (
+        <Suspense fallback="Loading...">
+          <Child />
+          <Component />
+          <Component />
+          <Component />
+          <Component shouldMismatch={true} />
+        </Suspense>
+      );
+    }
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+    const container = document.createElement('section');
+    container.innerHTML = finalHTML;
+    assertLog(['Hello', 'Component', 'Component', 'Component', 'Component']);
+
+    expect(container.innerHTML).toBe(
+      '<!--$-->Hello<div>Component</div><div>Component</div><div>Component</div><div>Component</div><!--/$-->',
+    );
+
+    suspend = true;
+    client = true;
+
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll(['Suspend']);
+    jest.runAllTimers();
+
+    // Unchanged
+    expect(container.innerHTML).toBe(
+      '<!--$-->Hello<div>Component</div><div>Component</div><div>Component</div><div>Component</div><!--/$-->',
+    );
+
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([
+      // first pass, mismatches at end
+      'Hello',
+      'Component',
+      'Component',
+      'Component',
+      'Component',
+
+      // second pass as client render
+      'Hello',
+      'Component',
+      'Component',
+      'Component',
+      'Component',
+      // Hydration mismatch is logged
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+
+    // Client rendered - suspense comment nodes removed
+    expect(container.innerHTML).toBe(
+      'Hello<div>Component</div><div>Component</div><div>Component</div><article>Mismatch</article>',
+    );
+  });
+
+  it('does not show a fallback if mismatch is after suspending', async () => {
+    let client = false;
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
+    function Child() {
+      if (suspend) {
+        Scheduler.log('Suspend');
+        throw promise;
+      } else {
+        Scheduler.log('Hello');
+        return 'Hello';
+      }
+    }
+    function Component({shouldMismatch}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return <article>Mismatch</article>;
+      }
+      return <div>Component</div>;
+    }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
+    function App() {
+      return (
+        <Suspense fallback={<Fallback />}>
+          <Child />
+          <Component shouldMismatch={true} />
+        </Suspense>
+      );
+    }
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+    const container = document.createElement('section');
+    container.innerHTML = finalHTML;
+    assertLog(['Hello', 'Component']);
+
+    expect(container.innerHTML).toBe(
+      '<!--$-->Hello<div>Component</div><!--/$-->',
+    );
+
+    suspend = true;
+    client = true;
+
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll(['Suspend']);
+    jest.runAllTimers();
+
+    // !! Unchanged, continue showing server content while suspended.
+    expect(container.innerHTML).toBe(
+      '<!--$-->Hello<div>Component</div><!--/$-->',
+    );
+
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([
+      // first pass, mismatches at end
+      'Hello',
+      'Component',
+      'Hello',
+      'Component',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
+
+    // Client rendered - suspense comment nodes removed.
+    expect(container.innerHTML).toBe('Hello<article>Mismatch</article>');
+  });
+
+  it('does not show a fallback if mismatch is child of suspended component', async () => {
+    let client = false;
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
+    function Child({children}) {
+      if (suspend) {
+        Scheduler.log('Suspend');
+        throw promise;
+      } else {
+        Scheduler.log('Hello');
+        return <div>{children}</div>;
+      }
+    }
+    function Component({shouldMismatch}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return <article>Mismatch</article>;
+      }
+      return <div>Component</div>;
+    }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
+    function App() {
+      return (
+        <Suspense fallback={<Fallback />}>
+          <Child>
+            <Component shouldMismatch={true} />
+          </Child>
+        </Suspense>
+      );
+    }
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+    const container = document.createElement('section');
+    container.innerHTML = finalHTML;
+    assertLog(['Hello', 'Component']);
+
+    expect(container.innerHTML).toBe(
+      '<!--$--><div><div>Component</div></div><!--/$-->',
+    );
+
+    suspend = true;
+    client = true;
+
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll(['Suspend']);
+    jest.runAllTimers();
+
+    // !! Unchanged, continue showing server content while suspended.
+    expect(container.innerHTML).toBe(
+      '<!--$--><div><div>Component</div></div><!--/$-->',
+    );
+
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([
+      // first pass, mismatches at end
+      'Hello',
+      'Component',
+      'Hello',
+      'Component',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
+
+    // Client rendered - suspense comment nodes removed
+    expect(container.innerHTML).toBe('<div><article>Mismatch</article></div>');
+  });
+
+  it('does not show a fallback if mismatch is parent and first child suspends', async () => {
+    let client = false;
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
+    function Child({children}) {
+      if (suspend) {
+        Scheduler.log('Suspend');
+        throw promise;
+      } else {
+        Scheduler.log('Hello');
+        return <div>{children}</div>;
+      }
+    }
+    function Component({shouldMismatch, children}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return (
+          <div>
+            {children}
+            <article>Mismatch</article>
+          </div>
+        );
+      }
+      return (
+        <div>
+          {children}
+          <div>Component</div>
+        </div>
+      );
+    }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
+    function App() {
+      return (
+        <Suspense fallback={<Fallback />}>
+          <Component shouldMismatch={true}>
+            <Child />
+          </Component>
+        </Suspense>
+      );
+    }
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+    const container = document.createElement('section');
+    container.innerHTML = finalHTML;
+    assertLog(['Component', 'Hello']);
+
+    expect(container.innerHTML).toBe(
+      '<!--$--><div><div></div><div>Component</div></div><!--/$-->',
+    );
+
+    suspend = true;
+    client = true;
+
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll(['Component', 'Suspend']);
+    jest.runAllTimers();
+
+    // !! Unchanged, continue showing server content while suspended.
+    expect(container.innerHTML).toBe(
+      '<!--$--><div><div></div><div>Component</div></div><!--/$-->',
+    );
+
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([
+      // first pass, mismatches at end
+      'Component',
+      'Hello',
+      'Component',
+      'Hello',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
+
+    // Client rendered - suspense comment nodes removed
+    expect(container.innerHTML).toBe(
+      '<div><div></div><article>Mismatch</article></div>',
+    );
+  });
+
+  it('does show a fallback if mismatch is parent and second child suspends', async () => {
+    let client = false;
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
+    function Child({children}) {
+      if (suspend) {
+        Scheduler.log('Suspend');
+        throw promise;
+      } else {
+        Scheduler.log('Hello');
+        return <div>{children}</div>;
+      }
+    }
+    function Component({shouldMismatch, children}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return (
+          <div>
+            <article>Mismatch</article>
+            {children}
+          </div>
+        );
+      }
+      return (
+        <div>
+          <div>Component</div>
+          {children}
+        </div>
+      );
+    }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
+    function App() {
+      return (
+        <Suspense fallback={<Fallback />}>
+          <Component shouldMismatch={true}>
+            <Child />
+          </Component>
+        </Suspense>
+      );
+    }
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+    const container = document.createElement('section');
+    container.innerHTML = finalHTML;
+    assertLog(['Component', 'Hello']);
+
+    expect(container.innerHTML).toBe(
+      '<!--$--><div><div>Component</div><div></div></div><!--/$-->',
+    );
+
+    suspend = true;
+    client = true;
+
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll([
+      'Component',
+      'Component',
+      'Suspend',
+      'Fallback',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
+
+    // !! Client switches to suspense fallback.
+    expect(container.innerHTML).toBe('Loading...');
+
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll(['Component', 'Hello']);
+    jest.runAllTimers();
+
+    // Client rendered - suspense comment nodes removed
+    expect(container.innerHTML).toBe(
+      '<div><article>Mismatch</article><div></div></div>',
+    );
+  });
+
+  it('does show a fallback if mismatch is in parent element only', async () => {
+    let client = false;
+    let suspend = false;
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
+    function Child({children}) {
+      if (suspend) {
+        Scheduler.log('Suspend');
+        throw promise;
+      } else {
+        Scheduler.log('Hello');
+        return <div>{children}</div>;
       }
     }
-
+    function Component({shouldMismatch, children}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return <article>{children}</article>;
+      }
+      return <div>{children}</div>;
+    }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
     function App() {
       return (
-        <div>
-          <Suspense fallback="Loading...">
-            <span ref={ref}>
-              <Child />
-            </span>
-          </Suspense>
-        </div>
+        <Suspense fallback={<Fallback />}>
+          <Component shouldMismatch={true}>
+            <Child />
+          </Component>
+        </Suspense>
       );
     }
-
-    // First we render the final HTML. With the streaming renderer
-    // this may have suspense points on the server but here we want
-    // to test the completed HTML. Don't suspend on the server.
-    suspend = false;
     const finalHTML = ReactDOMServer.renderToString(<App />);
-
-    const container = document.createElement('div');
+    const container = document.createElement('section');
     container.innerHTML = finalHTML;
+    assertLog(['Component', 'Hello']);
 
-    const span = container.getElementsByTagName('span')[0];
+    expect(container.innerHTML).toBe('<!--$--><div><div></div></div><!--/$-->');
 
-    // On the client we don't have all data yet but we want to start
-    // hydrating anyway.
     suspend = true;
-    ReactDOMClient.hydrateRoot(container, <App />);
-    await waitForAll([]);
+    client = true;
 
-    expect(ref.current).toBe(null);
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll([
+      'Component',
+      'Component',
+      'Suspend',
+      'Fallback',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
+
+    // !! Client switches to suspense fallback.
+    expect(container.innerHTML).toBe('Loading...');
 
-    // Resolving the promise should continue hydration
     suspend = false;
     resolve();
     await promise;
-    await waitForAll([]);
+    await waitForAll(['Component', 'Hello']);
+    jest.runAllTimers();
 
-    // We should now have hydrated with a ref on the existing span.
-    expect(ref.current).toBe(span);
+    // Client rendered - suspense comment nodes removed
+    expect(container.innerHTML).toBe('<article><div></div></article>');
   });
 
-  it('can hydrate siblings of a suspended component without errors', async () => {
+  it('does show a fallback if mismatch is before suspending', async () => {
+    let client = false;
     let suspend = false;
     let resolve;
-    const promise = new Promise(resolvePromise => (resolve = resolvePromise));
+    const promise = new Promise(resolvePromise => {
+      resolve = () => {
+        suspend = false;
+        resolvePromise();
+      };
+    });
     function Child() {
       if (suspend) {
+        Scheduler.log('Suspend');
         throw promise;
       } else {
+        Scheduler.log('Hello');
         return 'Hello';
       }
     }
-
+    function Component({shouldMismatch}) {
+      Scheduler.log('Component');
+      if (shouldMismatch && client) {
+        return <article>Mismatch</article>;
+      }
+      return <div>Component</div>;
+    }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
     function App() {
       return (
-        <Suspense fallback="Loading...">
+        <Suspense fallback={<Fallback />}>
+          <Component shouldMismatch={true} />
           <Child />
-          <Suspense fallback="Loading...">
-            <div>Hello</div>
-          </Suspense>
         </Suspense>
       );
     }
-
-    // First we render the final HTML. With the streaming renderer
-    // this may have suspense points on the server but here we want
-    // to test the completed HTML. Don't suspend on the server.
-    suspend = false;
     const finalHTML = ReactDOMServer.renderToString(<App />);
-
-    const container = document.createElement('div');
+    const container = document.createElement('section');
     container.innerHTML = finalHTML;
-    expect(container.textContent).toBe('HelloHello');
+    assertLog(['Component', 'Hello']);
+
+    expect(container.innerHTML).toBe(
+      '<!--$--><div>Component</div>Hello<!--/$-->',
+    );
 
-    // On the client we don't have all data yet but we want to start
-    // hydrating anyway.
     suspend = true;
+    client = true;
+
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
-    await waitForAll([]);
+    await waitForAll([
+      'Component',
+      'Component',
+      'Suspend',
+      'Fallback',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
 
-    // Expect the server-generated HTML to stay intact.
-    expect(container.textContent).toBe('HelloHello');
+    // !! Client switches to suspense fallback.
+    expect(container.innerHTML).toBe('Loading...');
 
-    // Resolving the promise should continue hydration
     suspend = false;
     resolve();
     await promise;
-    await waitForAll([]);
-    // Hydration should not change anything.
-    expect(container.textContent).toBe('HelloHello');
+    await waitForAll([
+      // first pass, mismatches at end
+      'Component',
+      'Hello',
+    ]);
+    jest.runAllTimers();
+
+    // Client rendered - suspense comment nodes removed
+    expect(container.innerHTML).toBe('<article>Mismatch</article>Hello');
   });
 
-  it('falls back to client rendering boundary on mismatch', async () => {
-    // We can't use the toErrorDev helper here because this is async.
-    const originalConsoleError = console.error;
-    const mockError = jest.fn();
-    console.error = (...args) => {
-      mockError(...args.map(normalizeCodeLocInfo));
-    };
+  it('does show a fallback if mismatch is before suspending in a child', async () => {
     let client = false;
     let suspend = false;
     let resolve;
@@ -283,87 +874,64 @@ describe('ReactDOMServerPartialHydration', () => {
       }
       return <div>Component</div>;
     }
+    function Fallback() {
+      Scheduler.log('Fallback');
+      return 'Loading...';
+    }
     function App() {
       return (
-        <Suspense fallback="Loading...">
-          <Child />
-          <Component />
-          <Component />
-          <Component />
+        <Suspense fallback={<Fallback />}>
           <Component shouldMismatch={true} />
+          <div>
+            <Child />
+          </div>
         </Suspense>
       );
     }
-    try {
-      const finalHTML = ReactDOMServer.renderToString(<App />);
-      const container = document.createElement('section');
-      container.innerHTML = finalHTML;
-      assertLog(['Hello', 'Component', 'Component', 'Component', 'Component']);
+    const finalHTML = ReactDOMServer.renderToString(<App />);
+    const container = document.createElement('section');
+    container.innerHTML = finalHTML;
+    assertLog(['Component', 'Hello']);
 
-      expect(container.innerHTML).toBe(
-        '<!--$-->Hello<div>Component</div><div>Component</div><div>Component</div><div>Component</div><!--/$-->',
-      );
+    expect(container.innerHTML).toBe(
+      '<!--$--><div>Component</div><div>Hello</div><!--/$-->',
+    );
 
-      suspend = true;
-      client = true;
+    suspend = true;
+    client = true;
 
-      ReactDOMClient.hydrateRoot(container, <App />, {
-        onRecoverableError(error) {
-          Scheduler.log(error.message);
-        },
-      });
-      await waitForAll(['Suspend']);
-      jest.runAllTimers();
+    ReactDOMClient.hydrateRoot(container, <App />, {
+      onRecoverableError(error) {
+        Scheduler.log(normalizeError(error.message));
+      },
+    });
+    await waitForAll([
+      'Component',
+      'Component',
+      'Suspend',
+      'Fallback',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+    jest.runAllTimers();
 
-      // Unchanged
-      expect(container.innerHTML).toBe(
-        '<!--$-->Hello<div>Component</div><div>Component</div><div>Component</div><div>Component</div><!--/$-->',
-      );
+    // !! Client switches to suspense fallback.
+    expect(container.innerHTML).toBe('Loading...');
 
-      suspend = false;
-      resolve();
-      await promise;
-      await waitForAll([
-        // first pass, mismatches at end
-        'Hello',
-        'Component',
-        'Component',
-        'Component',
-        'Component',
-
-        // second pass as client render
-        'Hello',
-        'Component',
-        'Component',
-        'Component',
-        'Component',
-
-        // Hydration mismatch is logged
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
-        'There was an error while hydrating this Suspense boundary. Switched to client rendering.',
-      ]);
+    suspend = false;
+    resolve();
+    await promise;
+    await waitForAll([
+      // first pass, mismatches at end
+      'Component',
+      'Hello',
+    ]);
+    jest.runAllTimers();
 
-      // Client rendered - suspense comment nodes removed
-      expect(container.innerHTML).toBe(
-        'Hello<div>Component</div><div>Component</div><div>Component</div><article>Mismatch</article>',
-      );
-
-      if (__DEV__) {
-        const lastCall = mockError.mock.calls[mockError.mock.calls.length - 1];
-        expect(lastCall).toEqual([
-          'Warning: Expected server HTML to contain a matching <%s> in <%s>.%s',
-          'article',
-          'section',
-          '\n' +
-            '    in article (at **)\n' +
-            '    in Component (at **)\n' +
-            '    in Suspense (at **)\n' +
-            '    in App (at **)',
-        ]);
-      }
-    } finally {
-      console.error = originalConsoleError;
-    }
+    // Client rendered - suspense comment nodes removed.
+    expect(container.innerHTML).toBe(
+      '<article>Mismatch</article><div>Hello</div>',
+    );
   });
 
   it('calls the hydration callbacks after hydration or deletion', async () => {
@@ -426,7 +994,7 @@ describe('ReactDOMServerPartialHydration', () => {
         deleted.push(node);
       },
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     await waitForAll([]);
@@ -521,15 +1089,13 @@ describe('ReactDOMServerPartialHydration', () => {
     expect(container.innerHTML).toContain('<span>B</span>');
     expect(ref.current).toBe(null);
 
-    await expect(async () => {
-      await act(() => {
-        ReactDOMClient.hydrateRoot(container, <App hasB={false} />, {
-          onRecoverableError(error) {
-            Scheduler.log(error.message);
-          },
-        });
+    await act(() => {
+      ReactDOMClient.hydrateRoot(container, <App hasB={false} />, {
+        onRecoverableError(error) {
+          Scheduler.log(normalizeError(error.message));
+        },
       });
-    }).toErrorDev('Did not expect server HTML to contain a <span> in <div>');
+    });
 
     expect(container.innerHTML).toContain('<span>A</span>');
     expect(container.innerHTML).not.toContain('<span>B</span>');
@@ -537,21 +1103,13 @@ describe('ReactDOMServerPartialHydration', () => {
     assertLog([
       'Server rendered',
       'Client rendered',
-      'Hydration failed because the initial UI does not match what was rendered on the server.',
-      'There was an error while hydrating this Suspense boundary. ' +
-        'Switched to client rendering.',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
     ]);
     expect(ref.current).not.toBe(span);
   });
 
   it('recovers with client render when server rendered additional nodes at suspense root after unsuspending', async () => {
-    // We can't use the toErrorDev helper here because this is async.
-    const originalConsoleError = console.error;
-    const mockError = jest.fn();
-    console.error = (...args) => {
-      mockError(...args.map(normalizeCodeLocInfo));
-    };
-
     const ref = React.createRef();
     let shouldSuspend = false;
     let resolve;
@@ -579,44 +1137,38 @@ describe('ReactDOMServerPartialHydration', () => {
         </div>
       );
     }
-    try {
-      const finalHTML = ReactDOMServer.renderToString(<App hasB={true} />);
+    const finalHTML = ReactDOMServer.renderToString(<App hasB={true} />);
 
-      const container = document.createElement('div');
-      container.innerHTML = finalHTML;
+    const container = document.createElement('div');
+    container.innerHTML = finalHTML;
 
-      const span = container.getElementsByTagName('span')[0];
+    const span = container.getElementsByTagName('span')[0];
 
-      expect(container.innerHTML).toContain('<span>A</span>');
-      expect(container.innerHTML).toContain('<span>B</span>');
-      expect(ref.current).toBe(null);
+    expect(container.innerHTML).toContain('<span>A</span>');
+    expect(container.innerHTML).toContain('<span>B</span>');
+    expect(ref.current).toBe(null);
 
-      shouldSuspend = true;
-      await act(() => {
-        ReactDOMClient.hydrateRoot(container, <App hasB={false} />);
+    shouldSuspend = true;
+    await act(() => {
+      ReactDOMClient.hydrateRoot(container, <App hasB={false} />, {
+        onRecoverableError(error) {
+          Scheduler.log(normalizeError(error.message));
+        },
       });
+    });
 
-      await act(() => {
-        resolve();
-      });
+    await act(() => {
+      resolve();
+    });
 
-      expect(container.innerHTML).toContain('<span>A</span>');
-      expect(container.innerHTML).not.toContain('<span>B</span>');
-      expect(ref.current).not.toBe(span);
-      if (__DEV__) {
-        expect(mockError).toHaveBeenCalledWith(
-          'Warning: Did not expect server HTML to contain a <%s> in <%s>.%s',
-          'span',
-          'div',
-          '\n' +
-            '    in Suspense (at **)\n' +
-            '    in div (at **)\n' +
-            '    in App (at **)',
-        );
-      }
-    } finally {
-      console.error = originalConsoleError;
-    }
+    assertLog([
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
+    ]);
+
+    expect(container.innerHTML).toContain('<span>A</span>');
+    expect(container.innerHTML).not.toContain('<span>B</span>');
+    expect(ref.current).not.toBe(span);
   });
 
   it('recovers with client render when server rendered additional nodes deep inside suspense root', async () => {
@@ -646,18 +1198,16 @@ describe('ReactDOMServerPartialHydration', () => {
     expect(container.innerHTML).toContain('<span>B</span>');
     expect(ref.current).toBe(null);
 
-    await expect(async () => {
-      await act(() => {
-        ReactDOMClient.hydrateRoot(container, <App hasB={false} />, {
-          onRecoverableError(error) {
-            Scheduler.log(error.message);
-          },
-        });
+    await act(() => {
+      ReactDOMClient.hydrateRoot(container, <App hasB={false} />, {
+        onRecoverableError(error) {
+          Scheduler.log(normalizeError(error.message));
+        },
       });
-    }).toErrorDev('Did not expect server HTML to contain a <span> in <div>');
+    });
     assertLog([
-      'Hydration failed because the initial UI does not match what was rendered on the server.',
-      'There was an error while hydrating this Suspense boundary. Switched to client rendering.',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating this Suspense boundary.',
     ]);
 
     expect(container.innerHTML).toContain('<span>A</span>');
@@ -718,75 +1268,6 @@ describe('ReactDOMServerPartialHydration', () => {
     expect(deleted.length).toBe(1);
   });
 
-  // @gate !disableLegacyMode
-  it('warns and replaces the boundary content in legacy mode', async () => {
-    let suspend = false;
-    let resolve;
-    const promise = new Promise(resolvePromise => (resolve = resolvePromise));
-    const ref = React.createRef();
-
-    function Child() {
-      if (suspend) {
-        throw promise;
-      } else {
-        return 'Hello';
-      }
-    }
-
-    function App() {
-      return (
-        <div>
-          <Suspense fallback="Loading...">
-            <span ref={ref}>
-              <Child />
-            </span>
-          </Suspense>
-        </div>
-      );
-    }
-
-    // Don't suspend on the server.
-    suspend = false;
-    const finalHTML = ReactDOMServer.renderToString(<App />);
-
-    const container = document.createElement('div');
-    container.innerHTML = finalHTML;
-
-    const span = container.getElementsByTagName('span')[0];
-
-    // On the client we try to hydrate.
-    suspend = true;
-    await expect(async () => {
-      await act(() => {
-        ReactDOM.hydrate(<App />, container);
-      });
-    }).toErrorDev(
-      'Warning: Cannot hydrate Suspense in legacy mode. Switch from ' +
-        'ReactDOM.hydrate(element, container) to ' +
-        'ReactDOMClient.hydrateRoot(container, <App />)' +
-        '.render(element) or remove the Suspense components from the server ' +
-        'rendered components.' +
-        '\n    in Suspense (at **)' +
-        '\n    in div (at **)' +
-        '\n    in App (at **)',
-    );
-
-    // We're now in loading state.
-    expect(container.textContent).toBe('Loading...');
-
-    const span2 = container.getElementsByTagName('span')[0];
-    // This is a new node.
-    expect(span).not.toBe(span2);
-    expect(ref.current).toBe(null);
-
-    // Resolving the promise should render the final content.
-    suspend = false;
-    await act(() => resolve());
-
-    // We should now have hydrated with a ref on the existing span.
-    expect(container.textContent).toBe('Hello');
-  });
-
   it('can insert siblings before the dehydrated boundary', async () => {
     let suspend = false;
     const promise = new Promise(() => {});
@@ -1085,7 +1566,7 @@ describe('ReactDOMServerPartialHydration', () => {
       <App text="Hello" className="hello" />,
       {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       },
     );
@@ -1163,7 +1644,7 @@ describe('ReactDOMServerPartialHydration', () => {
       <App text="Hello" className="hello" />,
       {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       },
     );
@@ -1239,7 +1720,7 @@ describe('ReactDOMServerPartialHydration', () => {
       <App text="Hello" className="hello" />,
       {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       },
     );
@@ -1547,7 +2028,7 @@ describe('ReactDOMServerPartialHydration', () => {
       </Context.Provider>,
       {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       },
     );
@@ -1622,22 +2103,18 @@ describe('ReactDOMServerPartialHydration', () => {
     suspend = false;
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     if (__DEV__) {
       await waitForAll([
         'The server did not finish this Suspense boundary: The server used' +
-          ' "renderToString" which does not support Suspense. If you intended' +
-          ' for this Suspense boundary to render the fallback content on the' +
-          ' server consider throwing an Error somewhere within the Suspense boundary.' +
-          ' If you intended to have the server wait for the suspended component' +
-          ' please switch to "renderToPipeableStream" which supports Suspense on the server',
+          ' "renderToString" which does not support Suspense.',
       ]);
     } else {
       await waitForAll([
         'The server could not finish this Suspense boundary, likely due to ' +
-          'an error during server rendering. Switched to client rendering.',
+          'an error during server rendering.',
       ]);
     }
     jest.runAllTimers();
@@ -1695,22 +2172,18 @@ describe('ReactDOMServerPartialHydration', () => {
     suspend = false;
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     if (__DEV__) {
       await waitForAll([
         'The server did not finish this Suspense boundary: The server used' +
-          ' "renderToString" which does not support Suspense. If you intended' +
-          ' for this Suspense boundary to render the fallback content on the' +
-          ' server consider throwing an Error somewhere within the Suspense boundary.' +
-          ' If you intended to have the server wait for the suspended component' +
-          ' please switch to "renderToPipeableStream" which supports Suspense on the server',
+          ' "renderToString" which does not support Suspense.',
       ]);
     } else {
       await waitForAll([
         'The server could not finish this Suspense boundary, likely due to ' +
-          'an error during server rendering. Switched to client rendering.',
+          'an error during server rendering.',
       ]);
     }
     // This will have exceeded the suspended time so we should timeout.
@@ -1773,22 +2246,18 @@ describe('ReactDOMServerPartialHydration', () => {
     suspend = false;
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     if (__DEV__) {
       await waitForAll([
         'The server did not finish this Suspense boundary: The server used' +
-          ' "renderToString" which does not support Suspense. If you intended' +
-          ' for this Suspense boundary to render the fallback content on the' +
-          ' server consider throwing an Error somewhere within the Suspense boundary.' +
-          ' If you intended to have the server wait for the suspended component' +
-          ' please switch to "renderToPipeableStream" which supports Suspense on the server',
+          ' "renderToString" which does not support Suspense.',
       ]);
     } else {
       await waitForAll([
         'The server could not finish this Suspense boundary, likely due to ' +
-          'an error during server rendering. Switched to client rendering.',
+          'an error during server rendering.',
       ]);
     }
     // This will have exceeded the suspended time so we should timeout.
@@ -2095,7 +2564,7 @@ describe('ReactDOMServerPartialHydration', () => {
 
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
 
@@ -2103,16 +2572,12 @@ describe('ReactDOMServerPartialHydration', () => {
     if (__DEV__) {
       await waitForAll([
         'The server did not finish this Suspense boundary: The server used' +
-          ' "renderToString" which does not support Suspense. If you intended' +
-          ' for this Suspense boundary to render the fallback content on the' +
-          ' server consider throwing an Error somewhere within the Suspense boundary.' +
-          ' If you intended to have the server wait for the suspended component' +
-          ' please switch to "renderToPipeableStream" which supports Suspense on the server',
+          ' "renderToString" which does not support Suspense.',
       ]);
     } else {
       await waitForAll([
         'The server could not finish this Suspense boundary, likely due to ' +
-          'an error during server rendering. Switched to client rendering.',
+          'an error during server rendering.',
       ]);
     }
 
@@ -2171,22 +2636,18 @@ describe('ReactDOMServerPartialHydration', () => {
     suspend = false;
     ReactDOMClient.hydrateRoot(container, <App />, {
       onRecoverableError(error) {
-        Scheduler.log(error.message);
+        Scheduler.log(normalizeError(error.message));
       },
     });
     if (__DEV__) {
       await waitForAll([
         'The server did not finish this Suspense boundary: The server used' +
-          ' "renderToString" which does not support Suspense. If you intended' +
-          ' for this Suspense boundary to render the fallback content on the' +
-          ' server consider throwing an Error somewhere within the Suspense boundary.' +
-          ' If you intended to have the server wait for the suspended component' +
-          ' please switch to "renderToPipeableStream" which supports Suspense on the server',
+          ' "renderToString" which does not support Suspense.',
       ]);
     } else {
       await waitForAll([
         'The server could not finish this Suspense boundary, likely due to ' +
-          'an error during server rendering. Switched to client rendering.',
+          'an error during server rendering.',
       ]);
     }
     jest.runAllTimers();
@@ -2287,7 +2748,7 @@ describe('ReactDOMServerPartialHydration', () => {
       </ClassName.Provider>,
       {
         onRecoverableError(error) {
-          Scheduler.log(error.message);
+          Scheduler.log(normalizeError(error.message));
         },
       },
     );
@@ -3321,27 +3782,18 @@ describe('ReactDOMServerPartialHydration', () => {
     document.body.appendChild(container);
     container.innerHTML = finalHTML;
 
-    await expect(async () => {
-      await act(() => {
-        ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
-          onRecoverableError(error) {
-            Scheduler.log('Log recoverable error: ' + error.message);
-          },
-        });
+    await act(() => {
+      ReactDOMClient.hydrateRoot(container, <App isClient={true} />, {
+        onRecoverableError(error) {
+          Scheduler.log(
+            'Log recoverable error: ' + normalizeError(error.message),
+          );
+        },
       });
-    }).toErrorDev(
-      [
-        'Warning: An error occurred during hydration. ' +
-          'The server HTML was replaced with client content in <div>.',
-        'Warning: Expected server HTML to contain a matching <span> in <div>.\n' +
-          '    in span (at **)\n' +
-          '    in App (at **)',
-      ],
-      {withoutStack: 1},
-    );
+    });
     assertLog([
-      'Log recoverable error: Hydration failed because the initial UI does not match what was rendered on the server.',
-      'Log recoverable error: There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
+      "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+      'Log recoverable error: There was an error while hydrating.',
     ]);
 
     // We show fallback state when mismatch happens at root
@@ -3359,7 +3811,7 @@ describe('ReactDOMServerPartialHydration', () => {
     );
   });
 
-  // @gate enableClientRenderFallbackOnTextMismatch
+  // @gate favorSafetyOverHydrationPerf
   it("falls back to client rendering when there's a text mismatch (direct text child)", async () => {
     function DirectTextChild({text}) {
       return <div>{text}</div>;
@@ -3368,30 +3820,20 @@ describe('ReactDOMServerPartialHydration', () => {
     container.innerHTML = ReactDOMServer.renderToString(
       <DirectTextChild text="good" />,
     );
-    await expect(async () => {
-      await act(() => {
-        ReactDOMClient.hydrateRoot(container, <DirectTextChild text="bad" />, {
-          onRecoverableError(error) {
-            Scheduler.log(error.message);
-          },
-        });
+    await act(() => {
+      ReactDOMClient.hydrateRoot(container, <DirectTextChild text="bad" />, {
+        onRecoverableError(error) {
+          Scheduler.log(normalizeError(error.message));
+        },
       });
-    }).toErrorDev(
-      [
-        'Text content did not match. Server: "good" Client: "bad"',
-        'An error occurred during hydration. The server HTML was replaced with ' +
-          'client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    });
     assertLog([
-      'Text content does not match server-rendered HTML.',
-      'There was an error while hydrating. Because the error happened outside ' +
-        'of a Suspense boundary, the entire root will switch to client rendering.',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
     ]);
   });
 
-  // @gate enableClientRenderFallbackOnTextMismatch
+  // @gate favorSafetyOverHydrationPerf
   it("falls back to client rendering when there's a text mismatch (text child with siblings)", async () => {
     function Sibling() {
       return 'Sibling';
@@ -3409,30 +3851,20 @@ describe('ReactDOMServerPartialHydration', () => {
     container2.innerHTML = ReactDOMServer.renderToString(
       <TextChildWithSibling text="good" />,
     );
-    await expect(async () => {
-      await act(() => {
-        ReactDOMClient.hydrateRoot(
-          container2,
-          <TextChildWithSibling text="bad" />,
-          {
-            onRecoverableError(error) {
-              Scheduler.log(error.message);
-            },
+    await act(() => {
+      ReactDOMClient.hydrateRoot(
+        container2,
+        <TextChildWithSibling text="bad" />,
+        {
+          onRecoverableError(error) {
+            Scheduler.log(normalizeError(error.message));
           },
-        );
-      });
-    }).toErrorDev(
-      [
-        'Text content did not match. Server: "good" Client: "bad"',
-        'An error occurred during hydration. The server HTML was replaced with ' +
-          'client content in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+        },
+      );
+    });
     assertLog([
-      'Text content does not match server-rendered HTML.',
-      'There was an error while hydrating. Because the error happened outside ' +
-        'of a Suspense boundary, the entire root will switch to client rendering.',
+      "Hydration failed because the server rendered HTML didn't match the client.",
+      'There was an error while hydrating.',
     ]);
   });
 });
diff --git a/packages/react-dom/src/__tests__/ReactDOMSingletonComponents-test.js b/packages/react-dom/src/__tests__/ReactDOMSingletonComponents-test.js
index 307f848a16cce..157d9aa9056ea 100644
--- a/packages/react-dom/src/__tests__/ReactDOMSingletonComponents-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMSingletonComponents-test.js
@@ -24,6 +24,15 @@ let hasErrored = false;
 let fatalError = undefined;
 let waitForAll;
 
+function normalizeError(msg) {
+  // Take the first sentence to make it easier to assert on.
+  const idx = msg.indexOf('.');
+  if (idx > -1) {
+    return msg.slice(0, idx + 1);
+  }
+  return msg;
+}
+
 describe('ReactDOM HostSingleton', () => {
   beforeEach(() => {
     jest.resetModules();
@@ -123,7 +132,6 @@ describe('ReactDOM HostSingleton', () => {
       : children;
   }
 
-  // @gate enableFloat
   it('warns if you render the same singleton twice at the same time', async () => {
     const root = ReactDOMClient.createRoot(document);
     root.render(
@@ -208,7 +216,6 @@ describe('ReactDOM HostSingleton', () => {
     );
   });
 
-  // @gate enableFloat
   it('renders into html, head, and body persistently so the node identities never change and extraneous styles are retained', async () => {
     // Server render some html that will get replaced with a client render
     await actIntoEmptyDocument(() => {
@@ -456,7 +463,7 @@ describe('ReactDOM HostSingleton', () => {
       {
         onRecoverableError(error, errorInfo) {
           hydrationErrors.push([
-            error.message,
+            normalizeError(error.message),
             errorInfo.componentStack
               ? errorInfo.componentStack.split('\n')[1].trim()
               : null,
@@ -464,27 +471,13 @@ describe('ReactDOM HostSingleton', () => {
         },
       },
     );
-    await expect(async () => {
-      await waitForAll([]);
-    }).toErrorDev(
-      [
-        `Warning: Expected server HTML to contain a matching <div> in <body>.
-    in div (at **)
-    in body (at **)
-    in html (at **)`,
-        `Warning: An error occurred during hydration. The server HTML was replaced with client content in <#document>.`,
-      ],
-      {withoutStack: 1},
-    );
+    await waitForAll([]);
     expect(hydrationErrors).toEqual([
       [
-        'Hydration failed because the initial UI does not match what was rendered on the server.',
+        "Hydration failed because the server rendered HTML didn't match the client.",
         'at div',
       ],
-      [
-        'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-        null,
-      ],
+      ['There was an error while hydrating.', null],
     ]);
     expect(persistentElements).toEqual([
       document.documentElement,
@@ -548,7 +541,12 @@ describe('ReactDOM HostSingleton', () => {
       },
     );
     expect(hydrationErrors).toEqual([]);
-    await waitForAll([]);
+    await expect(async () => {
+      await waitForAll([]);
+    }).toErrorDev(
+      "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+      {withoutStack: true},
+    );
     expect(persistentElements).toEqual([
       document.documentElement,
       document.head,
@@ -806,7 +804,6 @@ describe('ReactDOM HostSingleton', () => {
     );
   });
 
-  // @gate enableFloat
   it('clears persistent body when it is the container', async () => {
     await actIntoEmptyDocument(() => {
       const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
diff --git a/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js b/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js
index 089e6329e068b..12916166ecf0a 100644
--- a/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js
@@ -11,6 +11,7 @@
 
 let React;
 let ReactDOM;
+let findDOMNode;
 let ReactDOMClient;
 let Suspense;
 let Scheduler;
@@ -24,6 +25,8 @@ describe('ReactDOMSuspensePlaceholder', () => {
     jest.resetModules();
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     ReactDOMClient = require('react-dom/client');
     Scheduler = require('scheduler');
     act = require('internal-test-utils').act;
@@ -232,11 +235,11 @@ describe('ReactDOMSuspensePlaceholder', () => {
     class Child extends React.Component {
       componentDidMount() {
         log.push('cDM ' + this.props.id);
-        ReactDOM.findDOMNode(this);
+        findDOMNode(this);
       }
       componentDidUpdate() {
         log.push('cDU ' + this.props.id);
-        ReactDOM.findDOMNode(this);
+        findDOMNode(this);
       }
       render() {
         return 'child';
@@ -291,12 +294,12 @@ describe('ReactDOMSuspensePlaceholder', () => {
     class Child extends React.Component {
       componentDidMount() {
         log.push('cDM');
-        ReactDOM.findDOMNode(this);
+        findDOMNode(this);
       }
 
       componentDidUpdate() {
         log.push('cDU');
-        ReactDOM.findDOMNode(this);
+        findDOMNode(this);
       }
 
       render() {
diff --git a/packages/react-dom/src/__tests__/ReactEmptyComponent-test.js b/packages/react-dom/src/__tests__/ReactEmptyComponent-test.js
index 9316ad4392f61..d5274f964c2b5 100644
--- a/packages/react-dom/src/__tests__/ReactEmptyComponent-test.js
+++ b/packages/react-dom/src/__tests__/ReactEmptyComponent-test.js
@@ -11,6 +11,7 @@
 
 let React;
 let ReactDOM;
+let findDOMNode;
 let ReactDOMClient;
 let TogglingComponent;
 let act;
@@ -25,6 +26,8 @@ describe('ReactEmptyComponent', () => {
 
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     ReactDOMClient = require('react-dom/client');
     Scheduler = require('scheduler');
     const InternalTestUtils = require('internal-test-utils');
@@ -37,12 +40,12 @@ describe('ReactEmptyComponent', () => {
       state = {component: this.props.firstComponent};
 
       componentDidMount() {
-        Scheduler.log('mount ' + ReactDOM.findDOMNode(this)?.nodeName);
+        Scheduler.log('mount ' + findDOMNode(this)?.nodeName);
         this.setState({component: this.props.secondComponent});
       }
 
       componentDidUpdate() {
-        Scheduler.log('update ' + ReactDOM.findDOMNode(this)?.nodeName);
+        Scheduler.log('update ' + findDOMNode(this)?.nodeName);
       }
 
       render() {
@@ -244,13 +247,13 @@ describe('ReactEmptyComponent', () => {
         componentDidMount() {
           // Make sure the DOM node resolves properly even if we're replacing a
           // `null` component
-          expect(ReactDOM.findDOMNode(this)).not.toBe(null);
+          expect(findDOMNode(this)).not.toBe(null);
         }
 
         componentWillUnmount() {
           // Even though we're getting replaced by `null`, we haven't been
           // replaced yet!
-          expect(ReactDOM.findDOMNode(this)).not.toBe(null);
+          expect(findDOMNode(this)).not.toBe(null);
         }
       }
 
diff --git a/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js b/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js
index e0176d80ddd84..ffa923de3de58 100644
--- a/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js
@@ -643,7 +643,7 @@ describe('ReactErrorBoundaries', () => {
       root.render(<BrokenComponentWillUnmount />);
     });
     await expect(async () => {
-      root.unmount();
+      await act(() => root.unmount());
     }).rejects.toThrow('Hello');
   });
 
@@ -879,56 +879,6 @@ describe('ReactErrorBoundaries', () => {
     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');
   });
 
-  // @gate !disableModulePatternComponents
-  it('renders an error state if module-style context provider throws in componentWillMount', async () => {
-    function BrokenComponentWillMountWithContext() {
-      return {
-        getChildContext() {
-          return {foo: 42};
-        },
-        render() {
-          return <div>{this.props.children}</div>;
-        },
-        UNSAFE_componentWillMount() {
-          throw new Error('Hello');
-        },
-      };
-    }
-    BrokenComponentWillMountWithContext.childContextTypes = {
-      foo: PropTypes.number,
-    };
-
-    const container = document.createElement('div');
-    const root = ReactDOMClient.createRoot(container);
-
-    await expect(async () => {
-      await act(() => {
-        root.render(
-          <ErrorBoundary>
-            <BrokenComponentWillMountWithContext />
-          </ErrorBoundary>,
-        );
-      });
-    }).toErrorDev([
-      'Warning: The <BrokenComponentWillMountWithContext /> component appears to be a function component that ' +
-        'returns a class instance. ' +
-        'Change BrokenComponentWillMountWithContext to a class that extends React.Component instead. ' +
-        "If you can't use a class try assigning the prototype on the function as a workaround. " +
-        '`BrokenComponentWillMountWithContext.prototype = React.Component.prototype`. ' +
-        "Don't use an arrow function since it cannot be called with `new` by React.",
-      ...gate(flags =>
-        flags.disableLegacyContext
-          ? [
-              'Warning: BrokenComponentWillMountWithContext uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.',
-              'Warning: BrokenComponentWillMountWithContext uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.',
-            ]
-          : [],
-      ),
-    ]);
-
-    expect(container.firstChild.textContent).toBe('Caught an error: Hello.');
-  });
-
   it('mounts the error message if mounting fails', async () => {
     function renderError(error) {
       return <ErrorMessage message={error.message} />;
@@ -2470,7 +2420,7 @@ describe('ReactErrorBoundaries', () => {
     ]);
   });
 
-  it('passes first error when two errors happen in commit', async () => {
+  it('passes an aggregate error when two errors happen in commit', async () => {
     const errors = [];
     let caughtError;
     class Parent extends React.Component {
@@ -2501,15 +2451,14 @@ describe('ReactErrorBoundaries', () => {
         root.render(<Parent />);
       });
     } catch (e) {
-      if (e.message !== 'parent sad' && e.message !== 'child sad') {
-        throw e;
-      }
       caughtError = e;
     }
 
     expect(errors).toEqual(['child sad', 'parent sad']);
-    // Error should be the first thrown
-    expect(caughtError.message).toBe('child sad');
+    expect(caughtError.errors).toEqual([
+      expect.objectContaining({message: 'child sad'}),
+      expect.objectContaining({message: 'parent sad'}),
+    ]);
   });
 
   it('propagates uncaught error inside unbatched initial mount', async () => {
@@ -2561,15 +2510,14 @@ describe('ReactErrorBoundaries', () => {
         root.render(<Parent value={2} />);
       });
     } catch (e) {
-      if (e.message !== 'parent sad' && e.message !== 'child sad') {
-        throw e;
-      }
       caughtError = e;
     }
 
     expect(errors).toEqual(['child sad', 'parent sad']);
-    // Error should be the first thrown
-    expect(caughtError.message).toBe('child sad');
+    expect(caughtError.errors).toEqual([
+      expect.objectContaining({message: 'child sad'}),
+      expect.objectContaining({message: 'parent sad'}),
+    ]);
   });
 
   it('should warn if an error boundary with only componentDidCatch does not update state', async () => {
diff --git a/packages/react-dom/src/__tests__/ReactErrorLoggingRecovery-test.js b/packages/react-dom/src/__tests__/ReactErrorLoggingRecovery-test.js
index 388ac58f3bb2e..d2392b9503153 100644
--- a/packages/react-dom/src/__tests__/ReactErrorLoggingRecovery-test.js
+++ b/packages/react-dom/src/__tests__/ReactErrorLoggingRecovery-test.js
@@ -18,7 +18,7 @@ if (global.window) {
 // The issue only reproduced when React was loaded before JSDOM.
 const React = require('react');
 const ReactDOMClient = require('react-dom/client');
-const act = require('internal-test-utils').act;
+const Scheduler = require('scheduler');
 
 // Initialize JSDOM separately.
 // We don't use our normal JSDOM setup because we want to load React first.
@@ -39,6 +39,12 @@ class Bad extends React.Component {
   }
 }
 
+async function fakeAct(cb) {
+  // We don't use act/waitForThrow here because we want to observe how errors are reported for real.
+  await cb();
+  Scheduler.unstable_flushAll();
+}
+
 describe('ReactErrorLoggingRecovery', () => {
   const originalConsoleError = console.error;
 
@@ -55,20 +61,18 @@ describe('ReactErrorLoggingRecovery', () => {
   it('should recover from errors in console.error', async function () {
     const div = document.createElement('div');
     const root = ReactDOMClient.createRoot(div);
-    await expect(async () => {
-      await act(() => {
-        root.render(<Bad />);
-      });
-      await act(() => {
-        root.render(<Bad />);
-      });
-    }).rejects.toThrow('no');
+    await fakeAct(() => {
+      root.render(<Bad />);
+    });
+    await fakeAct(() => {
+      root.render(<Bad />);
+    });
+
+    expect(() => jest.runAllTimers()).toThrow('');
 
-    await expect(async () => {
-      await act(() => {
-        root.render(<span>Hello</span>);
-      });
-    }).rejects.toThrow('Buggy console.error');
+    await fakeAct(() => {
+      root.render(<span>Hello</span>);
+    });
     expect(div.firstChild.textContent).toBe('Hello');
   });
 });
diff --git a/packages/react-dom/src/__tests__/ReactLegacyCompositeComponent-test.js b/packages/react-dom/src/__tests__/ReactLegacyCompositeComponent-test.js
index 974403acc4197..1f62d9ab20d97 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyCompositeComponent-test.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyCompositeComponent-test.js
@@ -11,6 +11,7 @@
 
 let React;
 let ReactDOM;
+let findDOMNode;
 let ReactDOMClient;
 let PropTypes;
 let act;
@@ -20,6 +21,8 @@ describe('ReactLegacyCompositeComponent', () => {
     jest.resetModules();
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     ReactDOMClient = require('react-dom/client');
     PropTypes = require('prop-types');
     act = require('internal-test-utils').act;
@@ -115,7 +118,7 @@ describe('ReactLegacyCompositeComponent', () => {
     await act(() => {
       root.render(<Parent ref={current => (component = current)} />);
     });
-    expect(ReactDOM.findDOMNode(component).innerHTML).toBe('bar');
+    expect(findDOMNode(component).innerHTML).toBe('bar');
   });
 
   // @gate !disableLegacyContext
@@ -661,14 +664,14 @@ describe('ReactLegacyCompositeComponent', () => {
 
     const container = document.createElement('div');
     const comp = ReactDOM.render(<Component flipped={false} />, container);
-    expect(ReactDOM.findDOMNode(comp.static0Ref.current).textContent).toBe('A');
-    expect(ReactDOM.findDOMNode(comp.static1Ref.current).textContent).toBe('B');
+    expect(findDOMNode(comp.static0Ref.current).textContent).toBe('A');
+    expect(findDOMNode(comp.static1Ref.current).textContent).toBe('B');
 
     // When flipping the order, the refs should update even though the actual
     // contents do not
     ReactDOM.render(<Component flipped={true} />, container);
-    expect(ReactDOM.findDOMNode(comp.static0Ref.current).textContent).toBe('B');
-    expect(ReactDOM.findDOMNode(comp.static1Ref.current).textContent).toBe('A');
+    expect(findDOMNode(comp.static0Ref.current).textContent).toBe('B');
+    expect(findDOMNode(comp.static1Ref.current).textContent).toBe('A');
   });
 
   // @gate !disableLegacyMode
@@ -678,12 +681,12 @@ describe('ReactLegacyCompositeComponent', () => {
 
     class Component extends React.Component {
       componentDidMount() {
-        a = ReactDOM.findDOMNode(this);
+        a = findDOMNode(this);
         expect(a).not.toBe(null);
       }
 
       componentWillUnmount() {
-        b = ReactDOM.findDOMNode(this);
+        b = findDOMNode(this);
         expect(b).not.toBe(null);
       }
 
diff --git a/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js b/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js
index b73e25f2e168c..7c68b275c232b 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js
@@ -97,11 +97,11 @@ describe('ReactLegacyContextDisabled', () => {
         );
       });
     }).toErrorDev([
-      'LegacyProvider uses the legacy childContextTypes API which is no longer supported. ' +
+      'LegacyProvider uses the legacy childContextTypes API which was removed in React 19. ' +
         'Use React.createContext() instead.',
-      'LegacyClsConsumer uses the legacy contextTypes API which is no longer supported. ' +
+      'LegacyClsConsumer uses the legacy contextTypes API which was removed in React 19. ' +
         'Use React.createContext() with static contextType instead.',
-      'LegacyFnConsumer uses the legacy contextTypes API which is no longer supported. ' +
+      'LegacyFnConsumer uses the legacy contextTypes API which was removed in React 19. ' +
         'Use React.createContext() with React.useContext() instead.',
     ]);
     expect(container.textContent).toBe('{}undefinedundefined');
@@ -137,11 +137,11 @@ describe('ReactLegacyContextDisabled', () => {
         container,
       );
     }).toErrorDev([
-      'LegacyProvider uses the legacy childContextTypes API which is no longer supported. ' +
+      'LegacyProvider uses the legacy childContextTypes API which was removed in React 19. ' +
         'Use React.createContext() instead.',
-      'LegacyClsConsumer uses the legacy contextTypes API which is no longer supported. ' +
+      'LegacyClsConsumer uses the legacy contextTypes API which was removed in React 19. ' +
         'Use React.createContext() with static contextType instead.',
-      'LegacyFnConsumer uses the legacy contextTypes API which is no longer supported. ' +
+      'LegacyFnConsumer uses the legacy contextTypes API which was removed in React 19. ' +
         'Use React.createContext() with React.useContext() instead.',
     ]);
     expect(text).toBe('<span>{}<!-- -->undefined<!-- -->undefined</span>');
diff --git a/packages/react-dom/src/__tests__/ReactLegacyErrorBoundaries-test.internal.js b/packages/react-dom/src/__tests__/ReactLegacyErrorBoundaries-test.internal.js
index e5a2c52ad3ea2..b0b223dd43bee 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyErrorBoundaries-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyErrorBoundaries-test.internal.js
@@ -12,6 +12,7 @@
 let PropTypes;
 let React;
 let ReactDOM;
+let act;
 
 // TODO: Refactor this test once componentDidCatch setState is deprecated.
 describe('ReactLegacyErrorBoundaries', () => {
@@ -40,6 +41,7 @@ describe('ReactLegacyErrorBoundaries', () => {
     PropTypes = require('prop-types');
     ReactDOM = require('react-dom');
     React = require('react');
+    act = require('internal-test-utils').act;
 
     log = [];
 
@@ -586,63 +588,79 @@ describe('ReactLegacyErrorBoundaries', () => {
   });
 
   // @gate !disableLegacyMode
-  it('does not swallow exceptions on mounting without boundaries', () => {
+  it('does not swallow exceptions on mounting without boundaries', async () => {
     let container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<BrokenRender />, container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenRender />, container);
+      });
+    }).rejects.toThrow('Hello');
 
     container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<BrokenComponentWillMount />, container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenComponentWillMount />, container);
+      });
+    }).rejects.toThrow('Hello');
 
     container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<BrokenComponentDidMount />, container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenComponentDidMount />, container);
+      });
+    }).rejects.toThrow('Hello');
   });
 
   // @gate !disableLegacyMode
-  it('does not swallow exceptions on updating without boundaries', () => {
+  it('does not swallow exceptions on updating without boundaries', async () => {
     let container = document.createElement('div');
     ReactDOM.render(<BrokenComponentWillUpdate />, container);
-    expect(() => {
-      ReactDOM.render(<BrokenComponentWillUpdate />, container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenComponentWillUpdate />, container);
+      });
+    }).rejects.toThrow('Hello');
 
     container = document.createElement('div');
     ReactDOM.render(<BrokenComponentWillReceiveProps />, container);
-    expect(() => {
-      ReactDOM.render(<BrokenComponentWillReceiveProps />, container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenComponentWillReceiveProps />, container);
+      });
+    }).rejects.toThrow('Hello');
 
     container = document.createElement('div');
     ReactDOM.render(<BrokenComponentDidUpdate />, container);
-    expect(() => {
-      ReactDOM.render(<BrokenComponentDidUpdate />, container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenComponentDidUpdate />, container);
+      });
+    }).rejects.toThrow('Hello');
   });
 
   // @gate !disableLegacyMode
-  it('does not swallow exceptions on unmounting without boundaries', () => {
+  it('does not swallow exceptions on unmounting without boundaries', async () => {
     const container = document.createElement('div');
     ReactDOM.render(<BrokenComponentWillUnmount />, container);
-    expect(() => {
-      ReactDOM.unmountComponentAtNode(container);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.unmountComponentAtNode(container);
+      });
+    }).rejects.toThrow('Hello');
   });
 
   // @gate !disableLegacyMode
-  it('prevents errors from leaking into other roots', () => {
+  it('prevents errors from leaking into other roots', async () => {
     const container1 = document.createElement('div');
     const container2 = document.createElement('div');
     const container3 = document.createElement('div');
 
     ReactDOM.render(<span>Before 1</span>, container1);
-    expect(() => {
-      ReactDOM.render(<BrokenRender />, container2);
-    }).toThrow('Hello');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<BrokenRender />, container2);
+      });
+    }).rejects.toThrow('Hello');
     ReactDOM.render(
       <ErrorBoundary>
         <BrokenRender />
@@ -684,7 +702,7 @@ describe('ReactLegacyErrorBoundaries', () => {
     if (__DEV__) {
       expect(console.error).toHaveBeenCalledTimes(2);
       expect(console.error.mock.calls[0][0]).toContain(
-        'ReactDOM.render is no longer supported',
+        'ReactDOM.render has not been supported since React 18',
       );
       expect(console.error.mock.calls[1][2]).toContain(
         'The above error occurred in the <BrokenRender> component:',
@@ -831,54 +849,6 @@ describe('ReactLegacyErrorBoundaries', () => {
     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');
   });
 
-  if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-    // @gate !disableLegacyMode
-    it('renders an error state if module-style context provider throws in componentWillMount', () => {
-      function BrokenComponentWillMountWithContext() {
-        return {
-          getChildContext() {
-            return {foo: 42};
-          },
-          render() {
-            return <div>{this.props.children}</div>;
-          },
-          UNSAFE_componentWillMount() {
-            throw new Error('Hello');
-          },
-        };
-      }
-      BrokenComponentWillMountWithContext.childContextTypes = {
-        foo: PropTypes.number,
-      };
-
-      const container = document.createElement('div');
-      expect(() =>
-        ReactDOM.render(
-          <ErrorBoundary>
-            <BrokenComponentWillMountWithContext />
-          </ErrorBoundary>,
-          container,
-        ),
-      ).toErrorDev([
-        'Warning: The <BrokenComponentWillMountWithContext /> component appears to be a function component that ' +
-          'returns a class instance. ' +
-          'Change BrokenComponentWillMountWithContext to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`BrokenComponentWillMountWithContext.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
-        ...gate(flags =>
-          flags.disableLegacyContext
-            ? [
-                'Warning: BrokenComponentWillMountWithContext uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.',
-                'Warning: BrokenComponentWillMountWithContext uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.',
-              ]
-            : [],
-        ),
-      ]);
-      expect(container.firstChild.textContent).toBe('Caught an error: Hello.');
-    });
-  }
-
   // @gate !disableLegacyMode
   it('mounts the error message if mounting fails', () => {
     function renderError(error) {
@@ -2124,39 +2094,41 @@ describe('ReactLegacyErrorBoundaries', () => {
   });
 
   // @gate !disableLegacyMode
-  it('discards a bad root if the root component fails', () => {
+  it('discards a bad root if the root component fails', async () => {
     const X = null;
     const Y = undefined;
-    let err1;
-    let err2;
-
-    try {
-      const container = document.createElement('div');
-      expect(() => ReactDOM.render(<X />, container)).toErrorDev(
-        'React.createElement: type is invalid -- expected a string ' +
-          '(for built-in components) or a class/function ' +
-          '(for composite components) but got: null.',
-      );
-    } catch (err) {
-      err1 = err;
-    }
-    try {
-      const container = document.createElement('div');
-      expect(() => ReactDOM.render(<Y />, container)).toErrorDev(
-        'React.createElement: type is invalid -- expected a string ' +
-          '(for built-in components) or a class/function ' +
-          '(for composite components) but got: undefined.',
-      );
-    } catch (err) {
-      err2 = err;
-    }
 
-    expect(err1.message).toMatch(/got: null/);
-    expect(err2.message).toMatch(/got: undefined/);
+    await expect(async () => {
+      await expect(async () => {
+        const container = document.createElement('div');
+        await act(() => {
+          ReactDOM.render(<X />, container);
+        });
+      }).rejects.toThrow('got: null');
+    }).toErrorDev(
+      'Warning: React.jsx: type is invalid -- expected a string ' +
+        '(for built-in components) or a class/function ' +
+        '(for composite components) but got: null.',
+      {withoutStack: 1},
+    );
+
+    await expect(async () => {
+      await expect(async () => {
+        const container = document.createElement('div');
+        await act(() => {
+          ReactDOM.render(<Y />, container);
+        });
+      }).rejects.toThrow('got: undefined');
+    }).toErrorDev(
+      'Warning: React.jsx: type is invalid -- expected a string ' +
+        '(for built-in components) or a class/function ' +
+        '(for composite components) but got: undefined.',
+      {withoutStack: 1},
+    );
   });
 
   // @gate !disableLegacyMode
-  it('renders empty output if error boundary does not handle the error', () => {
+  it('renders empty output if error boundary does not handle the error', async () => {
     const container = document.createElement('div');
     expect(() => {
       ReactDOM.render(
@@ -2191,9 +2163,8 @@ describe('ReactLegacyErrorBoundaries', () => {
   });
 
   // @gate !disableLegacyMode
-  it('passes first error when two errors happen in commit', () => {
+  it('passes first error when two errors happen in commit', async () => {
     const errors = [];
-    let caughtError;
     class Parent extends React.Component {
       render() {
         return <Child />;
@@ -2214,39 +2185,42 @@ describe('ReactLegacyErrorBoundaries', () => {
     }
 
     const container = document.createElement('div');
-    try {
-      // Here, we test the behavior where there is no error boundary and we
-      // delegate to the host root.
-      ReactDOM.render(<Parent />, container);
-    } catch (e) {
-      if (e.message !== 'parent sad' && e.message !== 'child sad') {
-        throw e;
-      }
-      caughtError = e;
-    }
+    await expect(async () => {
+      await act(() => {
+        // Here, we test the behavior where there is no error boundary and we
+        // delegate to the host root.
+        ReactDOM.render(<Parent />, container);
+      });
+    }).rejects.toThrow(
+      expect.objectContaining({
+        errors: [
+          expect.objectContaining({message: 'child sad'}),
+          expect.objectContaining({message: 'parent sad'}),
+        ],
+      }),
+    );
 
     expect(errors).toEqual(['child sad', 'parent sad']);
-    // Error should be the first thrown
-    expect(caughtError.message).toBe('child sad');
   });
 
   // @gate !disableLegacyMode
-  it('propagates uncaught error inside unbatched initial mount', () => {
+  it('propagates uncaught error inside unbatched initial mount', async () => {
     function Foo() {
       throw new Error('foo error');
     }
     const container = document.createElement('div');
-    expect(() => {
-      ReactDOM.unstable_batchedUpdates(() => {
-        ReactDOM.render(<Foo />, container);
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.unstable_batchedUpdates(() => {
+          ReactDOM.render(<Foo />, container);
+        });
       });
-    }).toThrow('foo error');
+    }).rejects.toThrow('foo error');
   });
 
   // @gate !disableLegacyMode
-  it('handles errors that occur in before-mutation commit hook', () => {
+  it('handles errors that occur in before-mutation commit hook', async () => {
     const errors = [];
-    let caughtError;
     class Parent extends React.Component {
       getSnapshotBeforeUpdate() {
         errors.push('parent sad');
@@ -2269,18 +2243,24 @@ describe('ReactLegacyErrorBoundaries', () => {
     }
 
     const container = document.createElement('div');
-    ReactDOM.render(<Parent value={1} />, container);
-    try {
-      ReactDOM.render(<Parent value={2} />, container);
-    } catch (e) {
-      if (e.message !== 'parent sad' && e.message !== 'child sad') {
-        throw e;
-      }
-      caughtError = e;
-    }
+    await act(() => {
+      ReactDOM.render(<Parent value={1} />, container);
+    });
+
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<Parent value={2} />, container);
+      });
+    }).rejects.toThrow(
+      expect.objectContaining({
+        errors: [
+          expect.objectContaining({message: 'child sad'}),
+          expect.objectContaining({message: 'parent sad'}),
+        ],
+      }),
+    );
 
     expect(errors).toEqual(['child sad', 'parent sad']);
     // Error should be the first thrown
-    expect(caughtError.message).toBe('child sad');
   });
 });
diff --git a/packages/react-dom/src/__tests__/ReactLegacyMount-test.js b/packages/react-dom/src/__tests__/ReactLegacyMount-test.js
index 52a5458697d48..bd0f3442bc4cb 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyMount-test.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyMount-test.js
@@ -13,10 +13,7 @@ const {COMMENT_NODE} = require('react-dom-bindings/src/client/HTMLNodeType');
 
 let React;
 let ReactDOM;
-let ReactDOMServer;
-let Scheduler;
 let ReactDOMClient;
-let assertLog;
 let waitForAll;
 
 describe('ReactMount', () => {
@@ -26,11 +23,8 @@ describe('ReactMount', () => {
     React = require('react');
     ReactDOM = require('react-dom');
     ReactDOMClient = require('react-dom/client');
-    ReactDOMServer = require('react-dom/server');
-    Scheduler = require('scheduler');
 
     const InternalTestUtils = require('internal-test-utils');
-    assertLog = InternalTestUtils.assertLog;
     waitForAll = InternalTestUtils.waitForAll;
   });
 
@@ -138,25 +132,6 @@ describe('ReactMount', () => {
     expect(instance1 === instance2).toBe(true);
   });
 
-  // @gate !disableLegacyMode
-  it('does not warn if mounting into left padded rendered markup', () => {
-    const container = document.createElement('container');
-    container.innerHTML = ReactDOMServer.renderToString(<div />) + ' ';
-
-    // This should probably ideally warn but we ignore extra markup at the root.
-    ReactDOM.hydrate(<div />, container);
-  });
-
-  // @gate !disableLegacyMode
-  it('should warn if mounting into right padded rendered markup', () => {
-    const container = document.createElement('container');
-    container.innerHTML = ' ' + ReactDOMServer.renderToString(<div />);
-
-    expect(() => ReactDOM.hydrate(<div />, container)).toErrorDev(
-      'Did not expect server HTML to contain the text node " " in <container>.',
-    );
-  });
-
   // @gate !disableLegacyMode
   it('should not warn if mounting into non-empty node', () => {
     const container = document.createElement('container');
@@ -174,25 +149,6 @@ describe('ReactMount', () => {
     ReactDOM.render(<div />, iFrame.contentDocument.body);
   });
 
-  // @gate !disableLegacyMode
-  it('should account for escaping on a checksum mismatch', () => {
-    const div = document.createElement('div');
-    const markup = ReactDOMServer.renderToString(
-      <div>This markup contains an nbsp entity: &nbsp; server text</div>,
-    );
-    div.innerHTML = markup;
-
-    expect(() =>
-      ReactDOM.hydrate(
-        <div>This markup contains an nbsp entity: &nbsp; client text</div>,
-        div,
-      ),
-    ).toErrorDev(
-      'Server: "This markup contains an nbsp entity:   server text" ' +
-        'Client: "This markup contains an nbsp entity:   client text"',
-    );
-  });
-
   // @gate !disableLegacyMode
   it('should warn if render removes React-rendered children', () => {
     const container = document.createElement('container');
@@ -292,7 +248,7 @@ describe('ReactMount', () => {
     expect(calls).toBe(5);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('initial mount of legacy root is sync inside batchedUpdates, as if it were wrapped in flushSync', () => {
     const container1 = document.createElement('div');
     const container2 = document.createElement('div');
@@ -413,17 +369,6 @@ describe('ReactMount', () => {
     expect(container.textContent).toEqual('Bye');
   });
 
-  // @gate !disableLegacyMode
-  it('callback passed to legacy hydrate() API', () => {
-    const container = document.createElement('div');
-    container.innerHTML = '<div>Hi</div>';
-    ReactDOM.hydrate(<div>Hi</div>, container, () => {
-      Scheduler.log('callback');
-    });
-    expect(container.textContent).toEqual('Hi');
-    assertLog(['callback']);
-  });
-
   // @gate !disableLegacyMode
   it('warns when unmounting with legacy API (no previous content)', async () => {
     const container = document.createElement('div');
diff --git a/packages/react-dom/src/__tests__/ReactLegacyRootWarnings-test.js b/packages/react-dom/src/__tests__/ReactLegacyRootWarnings-test.js
index c686a67d43d15..1eef3d140e325 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyRootWarnings-test.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyRootWarnings-test.js
@@ -22,22 +22,7 @@ describe('ReactDOMRoot', () => {
     if (__DEV__) {
       expect(console.error).toHaveBeenCalledTimes(1);
       expect(console.error.mock.calls[0][0]).toContain(
-        'ReactDOM.render is no longer supported',
-      );
-    }
-  });
-
-  // @gate !disableLegacyMode
-  test('deprecation warning for ReactDOM.hydrate', () => {
-    spyOnDev(console, 'error');
-
-    container.innerHTML = 'Hi';
-    ReactDOM.hydrate('Hi', container);
-    expect(container.textContent).toEqual('Hi');
-    if (__DEV__) {
-      expect(console.error).toHaveBeenCalledTimes(1);
-      expect(console.error.mock.calls[0][0]).toContain(
-        'ReactDOM.hydrate is no longer supported',
+        'ReactDOM.render has not been supported since React 18',
       );
     }
   });
diff --git a/packages/react-dom/src/__tests__/ReactLegacyUpdates-test.js b/packages/react-dom/src/__tests__/ReactLegacyUpdates-test.js
index a989b17127783..942191372a3c0 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyUpdates-test.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyUpdates-test.js
@@ -11,6 +11,7 @@
 
 let React;
 let ReactDOM;
+let findDOMNode;
 let act;
 let Scheduler;
 let assertLog;
@@ -22,6 +23,8 @@ describe('ReactLegacyUpdates', () => {
     jest.resetModules();
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     act = require('internal-test-utils').act;
     Scheduler = require('scheduler');
 
@@ -29,7 +32,7 @@ describe('ReactLegacyUpdates', () => {
     assertLog = InternalTestUtils.assertLog;
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should batch state when updating state twice', () => {
     let updateCount = 0;
 
@@ -60,7 +63,7 @@ describe('ReactLegacyUpdates', () => {
     expect(updateCount).toBe(1);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should batch state when updating two different state keys', () => {
     let updateCount = 0;
 
@@ -94,7 +97,7 @@ describe('ReactLegacyUpdates', () => {
     expect(updateCount).toBe(1);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should batch state and props together', () => {
     let updateCount = 0;
 
@@ -128,7 +131,7 @@ describe('ReactLegacyUpdates', () => {
     expect(updateCount).toBe(1);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should batch parent/child state updates together', () => {
     let parentUpdateCount = 0;
 
@@ -184,7 +187,7 @@ describe('ReactLegacyUpdates', () => {
     expect(childUpdateCount).toBe(1);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should batch child/parent state updates together', () => {
     let parentUpdateCount = 0;
 
@@ -242,7 +245,7 @@ describe('ReactLegacyUpdates', () => {
     expect(childUpdateCount).toBe(1);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should support chained state updates', () => {
     let updateCount = 0;
 
@@ -283,7 +286,7 @@ describe('ReactLegacyUpdates', () => {
     expect(updateCount).toBe(2);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should batch forceUpdate together', () => {
     let shouldUpdateCount = 0;
     let updateCount = 0;
@@ -545,7 +548,7 @@ describe('ReactLegacyUpdates', () => {
     );
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('should queue mount-ready handlers across different roots', () => {
     // We'll define two components A and B, then update both of them. When A's
     // componentDidUpdate handlers is called, B's DOM should already have been
@@ -561,7 +564,7 @@ describe('ReactLegacyUpdates', () => {
       state = {x: 0};
 
       componentDidUpdate() {
-        expect(ReactDOM.findDOMNode(b).textContent).toBe('B1');
+        expect(findDOMNode(b).textContent).toBe('B1');
         aUpdated = true;
       }
 
@@ -699,7 +702,7 @@ describe('ReactLegacyUpdates', () => {
               depth={this.props.depth + 1}
               count={this.props.count}
             />,
-            ReactDOM.findDOMNode(this),
+            findDOMNode(this),
           );
         }
       }
@@ -770,10 +773,10 @@ describe('ReactLegacyUpdates', () => {
     const x = ReactDOM.render(<X />, container);
     container = document.createElement('div');
     const y = ReactDOM.render(<Y />, container);
-    expect(ReactDOM.findDOMNode(x).textContent).toBe('0');
+    expect(findDOMNode(x).textContent).toBe('0');
 
     y.forceUpdate();
-    expect(ReactDOM.findDOMNode(x).textContent).toBe('1');
+    expect(findDOMNode(x).textContent).toBe('1');
   });
 
   // @gate !disableLegacyMode
@@ -816,7 +819,7 @@ describe('ReactLegacyUpdates', () => {
     });
 
     expect(a.state.x).toBe(1);
-    expect(ReactDOM.findDOMNode(a).textContent).toBe('A1');
+    expect(findDOMNode(a).textContent).toBe('A1');
   });
 
   // @gate !disableLegacyMode
@@ -846,7 +849,7 @@ describe('ReactLegacyUpdates', () => {
     expect(callbackCount).toBe(1);
   });
 
-  // @gate !disableLegacyMode
+  // @gate !disableLegacyMode && classic
   it('does not call render after a component as been deleted', () => {
     let renderCount = 0;
     let componentB = null;
@@ -886,7 +889,7 @@ describe('ReactLegacyUpdates', () => {
   });
 
   // @gate !disableLegacyMode
-  it('throws in setState if the update callback is not a function', () => {
+  it('throws in setState if the update callback is not a function', async () => {
     function Foo() {
       this.a = 1;
       this.b = 2;
@@ -903,37 +906,52 @@ describe('ReactLegacyUpdates', () => {
     let container = document.createElement('div');
     let component = ReactDOM.render(<A />, container);
 
-    expect(() => {
-      expect(() => component.setState({}, 'no')).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: no.',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          component.setState({}, 'no');
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: no',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: no',
+    }).toErrorDev(
+      'Expected the last optional `callback` argument to be ' +
+        'a function. Instead received: no.',
+      {withoutStack: 1},
     );
+
     container = document.createElement('div');
     component = ReactDOM.render(<A />, container);
-    expect(() => {
-      expect(() => component.setState({}, {foo: 'bar'})).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: [object Object].',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          component.setState({}, {foo: 'bar'});
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: [object Object]',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: [object Object]',
+    }).toErrorDev(
+      'Expected the last optional `callback` argument to be ' +
+        'a function. Instead received: [object Object].',
+      {withoutStack: 1},
     );
     // Make sure the warning is deduplicated and doesn't fire again
     container = document.createElement('div');
     component = ReactDOM.render(<A />, container);
-    expect(() => component.setState({}, new Foo())).toThrowError(
+    await expect(async () => {
+      await act(() => {
+        component.setState({}, new Foo());
+      });
+    }).rejects.toThrowError(
       'Invalid argument passed as callback. Expected a function. Instead ' +
         'received: [object Object]',
     );
   });
 
   // @gate !disableLegacyMode
-  it('throws in forceUpdate if the update callback is not a function', () => {
+  it('throws in forceUpdate if the update callback is not a function', async () => {
     function Foo() {
       this.a = 1;
       this.b = 2;
@@ -950,30 +968,44 @@ describe('ReactLegacyUpdates', () => {
     let container = document.createElement('div');
     let component = ReactDOM.render(<A />, container);
 
-    expect(() => {
-      expect(() => component.forceUpdate('no')).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: no.',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          component.forceUpdate('no');
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: no',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: no',
+    }).toErrorDev(
+      'Expected the last optional `callback` argument to be ' +
+        'a function. Instead received: no.',
+      {withoutStack: 1},
     );
     container = document.createElement('div');
     component = ReactDOM.render(<A />, container);
-    expect(() => {
-      expect(() => component.forceUpdate({foo: 'bar'})).toErrorDev(
-        'Expected the last optional `callback` argument to be ' +
-          'a function. Instead received: [object Object].',
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => {
+          component.forceUpdate({foo: 'bar'});
+        });
+      }).rejects.toThrowError(
+        'Invalid argument passed as callback. Expected a function. Instead ' +
+          'received: [object Object]',
       );
-    }).toThrowError(
-      'Invalid argument passed as callback. Expected a function. Instead ' +
-        'received: [object Object]',
+    }).toErrorDev(
+      'Expected the last optional `callback` argument to be ' +
+        'a function. Instead received: [object Object].',
+      {withoutStack: 1},
     );
     // Make sure the warning is deduplicated and doesn't fire again
     container = document.createElement('div');
     component = ReactDOM.render(<A />, container);
-    expect(() => component.forceUpdate(new Foo())).toThrowError(
+    await expect(async () => {
+      await act(() => {
+        component.forceUpdate(new Foo());
+      });
+    }).rejects.toThrowError(
       'Invalid argument passed as callback. Expected a function. Instead ' +
         'received: [object Object]',
     );
@@ -1377,7 +1409,7 @@ describe('ReactLegacyUpdates', () => {
   });
 
   // @gate !disableLegacyMode
-  it('resets the update counter for unrelated updates', () => {
+  it('resets the update counter for unrelated updates', async () => {
     const container = document.createElement('div');
     const ref = React.createRef();
 
@@ -1397,9 +1429,11 @@ describe('ReactLegacyUpdates', () => {
     }
 
     let limit = 55;
-    expect(() => {
-      ReactDOM.render(<EventuallyTerminating ref={ref} />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<EventuallyTerminating ref={ref} />, container);
+      });
+    }).rejects.toThrow('Maximum');
 
     // Verify that we don't go over the limit if these updates are unrelated.
     limit -= 10;
@@ -1411,14 +1445,16 @@ describe('ReactLegacyUpdates', () => {
     expect(container.textContent).toBe(limit.toString());
 
     limit += 10;
-    expect(() => {
-      ref.current.setState({step: 0});
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ref.current.setState({step: 0});
+      });
+    }).rejects.toThrow('Maximum');
     expect(ref.current).toBe(null);
   });
 
   // @gate !disableLegacyMode
-  it('does not fall into an infinite update loop', () => {
+  it('does not fall into an infinite update loop', async () => {
     class NonTerminating extends React.Component {
       state = {step: 0};
       componentDidMount() {
@@ -1438,13 +1474,15 @@ describe('ReactLegacyUpdates', () => {
     }
 
     const container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<NonTerminating />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<NonTerminating />, container);
+      });
+    }).rejects.toThrow('Maximum');
   });
 
   // @gate !disableLegacyMode
-  it('does not fall into an infinite update loop with useLayoutEffect', () => {
+  it('does not fall into an infinite update loop with useLayoutEffect', async () => {
     function NonTerminating() {
       const [step, setStep] = React.useState(0);
       React.useLayoutEffect(() => {
@@ -1454,13 +1492,15 @@ describe('ReactLegacyUpdates', () => {
     }
 
     const container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<NonTerminating />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<NonTerminating />, container);
+      });
+    }).rejects.toThrow('Maximum');
   });
 
   // @gate !disableLegacyMode
-  it('can recover after falling into an infinite update loop', () => {
+  it('can recover after falling into an infinite update loop', async () => {
     class NonTerminating extends React.Component {
       state = {step: 0};
       componentDidMount() {
@@ -1485,23 +1525,27 @@ describe('ReactLegacyUpdates', () => {
     }
 
     const container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<NonTerminating />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<NonTerminating />, container);
+      });
+    }).rejects.toThrow('Maximum');
 
     ReactDOM.render(<Terminating />, container);
     expect(container.textContent).toBe('1');
 
-    expect(() => {
-      ReactDOM.render(<NonTerminating />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<NonTerminating />, container);
+      });
+    }).rejects.toThrow('Maximum');
 
     ReactDOM.render(<Terminating />, container);
     expect(container.textContent).toBe('1');
   });
 
   // @gate !disableLegacyMode
-  it('does not fall into mutually recursive infinite update loop with same container', () => {
+  it('does not fall into mutually recursive infinite update loop with same container', async () => {
     // Note: this test would fail if there were two or more different roots.
 
     class A extends React.Component {
@@ -1523,13 +1567,15 @@ describe('ReactLegacyUpdates', () => {
     }
 
     const container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<A />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<A />, container);
+      });
+    }).rejects.toThrow('Maximum');
   });
 
   // @gate !disableLegacyMode
-  it('does not fall into an infinite error loop', () => {
+  it('does not fall into an infinite error loop', async () => {
     function BadRender() {
       throw new Error('error');
     }
@@ -1557,9 +1603,11 @@ describe('ReactLegacyUpdates', () => {
     }
 
     const container = document.createElement('div');
-    expect(() => {
-      ReactDOM.render(<NonTerminating />, container);
-    }).toThrow('Maximum');
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.render(<NonTerminating />, container);
+      });
+    }).rejects.toThrow('Maximum');
   });
 
   // @gate !disableLegacyMode
diff --git a/packages/react-dom/src/__tests__/ReactRenderDocument-test.js b/packages/react-dom/src/__tests__/ReactRenderDocument-test.js
index f901312677fad..4d2d67a7e284c 100644
--- a/packages/react-dom/src/__tests__/ReactRenderDocument-test.js
+++ b/packages/react-dom/src/__tests__/ReactRenderDocument-test.js
@@ -28,6 +28,15 @@ function getTestDocument(markup) {
   return doc;
 }
 
+function normalizeError(msg) {
+  // Take the first sentence to make it easier to assert on.
+  const idx = msg.indexOf('.');
+  if (idx > -1) {
+    return msg.slice(0, idx + 1);
+  }
+  return msg;
+}
+
 describe('rendering React components at document', () => {
   beforeEach(() => {
     jest.resetModules();
@@ -187,25 +196,19 @@ describe('rendering React components at document', () => {
       const container = document.createElement('div');
       container.textContent = 'potato';
 
-      expect(() => {
-        ReactDOM.flushSync(() => {
-          ReactDOMClient.hydrateRoot(container, <div>parsnip</div>, {
-            onRecoverableError: error => {
-              Scheduler.log('Log recoverable error: ' + error.message);
-            },
-          });
+      ReactDOM.flushSync(() => {
+        ReactDOMClient.hydrateRoot(container, <div>parsnip</div>, {
+          onRecoverableError: error => {
+            Scheduler.log(
+              'Log recoverable error: ' + normalizeError(error.message),
+            );
+          },
         });
-      }).toErrorDev(
-        [
-          'Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-          'Expected server HTML to contain a matching <div> in <div>.',
-        ],
-        {withoutStack: 1},
-      );
+      });
 
       assertLog([
-        'Log recoverable error: Hydration failed because the initial UI does not match what was rendered on the server.',
-        'Log recoverable error: There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
+        "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+        'Log recoverable error: There was an error while hydrating.',
       ]);
 
       // This creates an unfortunate double text case.
@@ -217,31 +220,25 @@ describe('rendering React components at document', () => {
       const wrapper = document.createElement('div');
       wrapper.textContent = 'potato';
       container.appendChild(wrapper);
-      expect(() => {
-        ReactDOM.flushSync(() => {
-          ReactDOMClient.hydrateRoot(
-            container,
-            <div>
-              <div>parsnip</div>
-            </div>,
-            {
-              onRecoverableError: error => {
-                Scheduler.log('Log recoverable error: ' + error.message);
-              },
+      ReactDOM.flushSync(() => {
+        ReactDOMClient.hydrateRoot(
+          container,
+          <div>
+            <div>parsnip</div>
+          </div>,
+          {
+            onRecoverableError: error => {
+              Scheduler.log(
+                'Log recoverable error: ' + normalizeError(error.message),
+              );
             },
-          );
-        });
-      }).toErrorDev(
-        [
-          'Warning: An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-          'Expected server HTML to contain a matching <div> in <div>.',
-        ],
-        {withoutStack: 1},
-      );
+          },
+        );
+      });
 
       assertLog([
-        'Log recoverable error: Hydration failed because the initial UI does not match what was rendered on the server.',
-        'Log recoverable error: There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
+        "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+        'Log recoverable error: There was an error while hydrating.',
       ]);
       expect(container.textContent).toBe('parsnip');
     });
@@ -265,8 +262,8 @@ describe('rendering React components at document', () => {
       );
       const testDocument = getTestDocument(markup);
 
-      const enableClientRenderFallbackOnTextMismatch = gate(
-        flags => flags.enableClientRenderFallbackOnTextMismatch,
+      const favorSafetyOverHydrationPerf = gate(
+        flags => flags.favorSafetyOverHydrationPerf,
       );
       expect(() => {
         ReactDOM.flushSync(() => {
@@ -275,32 +272,33 @@ describe('rendering React components at document', () => {
             <Component text="Hello world" />,
             {
               onRecoverableError: error => {
-                Scheduler.log('Log recoverable error: ' + error.message);
+                Scheduler.log(
+                  'Log recoverable error: ' + normalizeError(error.message),
+                );
               },
             },
           );
         });
       }).toErrorDev(
-        enableClientRenderFallbackOnTextMismatch
-          ? [
-              'Warning: An error occurred during hydration. The server HTML was replaced with client content in <#document>.',
-              'Warning: Text content did not match.',
-            ]
-          : ['Warning: Text content did not match.'],
-        {
-          withoutStack: enableClientRenderFallbackOnTextMismatch ? 1 : 0,
-        },
+        favorSafetyOverHydrationPerf
+          ? []
+          : [
+              "Warning: A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+            ],
+        {withoutStack: true},
       );
 
       assertLog(
-        enableClientRenderFallbackOnTextMismatch
+        favorSafetyOverHydrationPerf
           ? [
-              'Log recoverable error: Text content does not match server-rendered HTML.',
-              'Log recoverable error: There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
+              "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+              'Log recoverable error: There was an error while hydrating.',
             ]
           : [],
       );
-      expect(testDocument.body.innerHTML).toBe('Hello world');
+      expect(testDocument.body.innerHTML).toBe(
+        favorSafetyOverHydrationPerf ? 'Hello world' : 'Goodbye world',
+      );
     });
 
     it('should render w/ no markup to full document', async () => {
@@ -319,76 +317,25 @@ describe('rendering React components at document', () => {
         }
       }
 
-      if (gate(flags => flags.enableFloat)) {
-        // with float the title no longer is a hydration mismatch so we get an error on the body mismatch
-        expect(() => {
-          ReactDOM.flushSync(() => {
-            ReactDOMClient.hydrateRoot(
-              testDocument,
-              <Component text="Hello world" />,
-              {
-                onRecoverableError: error => {
-                  Scheduler.log('Log recoverable error: ' + error.message);
-                },
-              },
-            );
-          });
-        }).toErrorDev(
-          [
-            'Warning: An error occurred during hydration. The server HTML was replaced with client content in <#document>.',
-            'Expected server HTML to contain a matching text node for "Hello world" in <body>',
-          ],
-          {withoutStack: 1},
-        );
-        assertLog([
-          'Log recoverable error: Hydration failed because the initial UI does not match what was rendered on the server.',
-          'Log recoverable error: There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-        ]);
-      } else {
-        // getTestDocument() has an extra <meta> that we didn't render.
-        expect(() => {
-          ReactDOM.flushSync(() => {
-            ReactDOMClient.hydrateRoot(
-              testDocument,
-              <Component text="Hello world" />,
-              {
-                onRecoverableError: error => {
-                  Scheduler.log('Log recoverable error: ' + error.message);
-                },
-              },
-            );
-          });
-        }).toErrorDev(
-          [
-            'Warning: An error occurred during hydration. The server HTML was replaced with client content in <#document>.',
-            'Warning: Text content did not match. Server: "test doc" Client: "Hello World"',
-          ],
-          {withoutStack: 1},
+      // with float the title no longer is a hydration mismatch so we get an error on the body mismatch
+      ReactDOM.flushSync(() => {
+        ReactDOMClient.hydrateRoot(
+          testDocument,
+          <Component text="Hello world" />,
+          {
+            onRecoverableError: error => {
+              Scheduler.log(
+                'Log recoverable error: ' + normalizeError(error.message),
+              );
+            },
+          },
         );
-        assertLog([
-          'Log recoverable error: Text content does not match server-rendered HTML.',
-          'Log recoverable error: There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
-        ]);
-      }
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-    });
-
-    // @gate !disableLegacyMode
-    it('supports findDOMNode on full-page components in legacy mode', () => {
-      const tree = (
-        <html>
-          <head>
-            <title>Hello World</title>
-          </head>
-          <body>Hello world</body>
-        </html>
-      );
-
-      const markup = ReactDOMServer.renderToString(tree);
-      const testDocument = getTestDocument(markup);
-      const component = ReactDOM.hydrate(tree, testDocument);
+      });
+      assertLog([
+        "Log recoverable error: Hydration failed because the server rendered HTML didn't match the client.",
+        'Log recoverable error: There was an error while hydrating.',
+      ]);
       expect(testDocument.body.innerHTML).toBe('Hello world');
-      expect(ReactDOM.findDOMNode(component).tagName).toBe('HTML');
     });
   });
 });
diff --git a/packages/react-dom/src/__tests__/ReactServerRendering-test.js b/packages/react-dom/src/__tests__/ReactServerRendering-test.js
index 07654a9f13c0a..efacdb8be9a4e 100644
--- a/packages/react-dom/src/__tests__/ReactServerRendering-test.js
+++ b/packages/react-dom/src/__tests__/ReactServerRendering-test.js
@@ -578,39 +578,6 @@ describe('ReactDOMServer', () => {
     });
   });
 
-  describe('renderToNodeStream', () => {
-    it('should generate simple markup', () => {
-      const SuccessfulElement = React.createElement(() => <img />);
-      let response;
-      expect(() => {
-        response = ReactDOMServer.renderToNodeStream(SuccessfulElement);
-      }).toErrorDev(
-        'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-        {withoutStack: true},
-      );
-      expect(response.read().toString()).toMatch(new RegExp('<img' + '/>'));
-    });
-
-    it('should handle errors correctly', () => {
-      const FailingElement = React.createElement(() => {
-        throw new Error('An Error');
-      });
-      let response;
-      expect(() => {
-        response = ReactDOMServer.renderToNodeStream(FailingElement);
-      }).toErrorDev(
-        'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-        {withoutStack: true},
-      );
-      return new Promise(resolve => {
-        response.once('error', () => {
-          resolve();
-        });
-        expect(response.read()).toBeNull();
-      });
-    });
-  });
-
   describe('renderToStaticNodeStream', () => {
     it('should generate simple markup', () => {
       const SuccessfulElement = React.createElement(() => <img />);
@@ -632,7 +599,7 @@ describe('ReactDOMServer', () => {
       });
     });
 
-    it('should refer users to new apis when using suspense', async () => {
+    it('should omit text and suspense placeholders', async () => {
       let resolve = null;
       const promise = new Promise(res => {
         resolve = () => {
@@ -648,23 +615,15 @@ describe('ReactDOMServer', () => {
         throw promise;
       }
 
-      let response;
-      expect(() => {
-        response = ReactDOMServer.renderToNodeStream(
-          <div>
-            <React.Suspense fallback={'fallback'}>
-              <Suspender />
-            </React.Suspense>
-          </div>,
-        );
-      }).toErrorDev(
-        'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-        {withoutStack: true},
+      const response = ReactDOMServer.renderToStaticNodeStream(
+        <div>
+          <React.Suspense fallback={'fallback'}>
+            <Suspender />
+          </React.Suspense>
+        </div>,
       );
       await resolve();
-      expect(response.read().toString()).toEqual(
-        '<div><!--$-->resolved<!-- --><!--/$--></div>',
-      );
+      expect(response.read().toString()).toEqual('<div>resolved</div>');
     });
   });
 
@@ -1126,7 +1085,6 @@ describe('ReactDOMServer', () => {
       expect(output).toBe(`<my-custom-element foo="5"></my-custom-element>`);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('Object properties should not be server rendered for custom elements', () => {
       const output = ReactDOMServer.renderToString(
         <my-custom-element foo={{foo: 'bar'}} />,
@@ -1134,7 +1092,6 @@ describe('ReactDOMServer', () => {
       expect(output).toBe(`<my-custom-element></my-custom-element>`);
     });
 
-    // @gate enableCustomElementPropertySupport
     it('Array properties should not be server rendered for custom elements', () => {
       const output = ReactDOMServer.renderToString(
         <my-custom-element foo={['foo', 'bar']} />,
diff --git a/packages/react-dom/src/__tests__/ReactServerRenderingBrowser-test.js b/packages/react-dom/src/__tests__/ReactServerRenderingBrowser-test.js
index e99bc4904d1e4..bfcb32f4f82cf 100644
--- a/packages/react-dom/src/__tests__/ReactServerRenderingBrowser-test.js
+++ b/packages/react-dom/src/__tests__/ReactServerRenderingBrowser-test.js
@@ -45,17 +45,4 @@ describe('ReactServerRenderingBrowser', () => {
       ReactDOMServer.renderToStaticMarkup(<Greeting />),
     );
   });
-
-  it('throws meaningfully for server-only APIs', () => {
-    expect(() => ReactDOMServerBrowser.renderToNodeStream(<div />)).toThrow(
-      'ReactDOMServer.renderToNodeStream(): The streaming API is not available ' +
-        'in the browser. Use ReactDOMServer.renderToString() instead.',
-    );
-    expect(() =>
-      ReactDOMServerBrowser.renderToStaticNodeStream(<div />),
-    ).toThrow(
-      'ReactDOMServer.renderToStaticNodeStream(): The streaming API is not available ' +
-        'in the browser. Use ReactDOMServer.renderToStaticMarkup() instead.',
-    );
-  });
 });
diff --git a/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js b/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js
index 872ef03f38ea6..dcba42d0afbcc 100644
--- a/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js
+++ b/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js
@@ -123,8 +123,8 @@ describe('ReactDOMServerHydration', () => {
       // Now simulate a situation where the app is not idempotent. React should
       // warn but do the right thing.
       element.innerHTML = lastMarkup;
-      const enableClientRenderFallbackOnTextMismatch = gate(
-        flags => flags.enableClientRenderFallbackOnTextMismatch,
+      const favorSafetyOverHydrationPerf = gate(
+        flags => flags.favorSafetyOverHydrationPerf,
       );
       await expect(async () => {
         root = await act(() => {
@@ -142,17 +142,20 @@ describe('ReactDOMServerHydration', () => {
           );
         });
       }).toErrorDev(
-        enableClientRenderFallbackOnTextMismatch
-          ? [
-              'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-              'Text content did not match. Server: "x" Client: "y"',
-            ]
-          : ['Text content did not match. Server: "x" Client: "y"'],
-        {withoutStack: enableClientRenderFallbackOnTextMismatch ? 1 : 0},
+        favorSafetyOverHydrationPerf
+          ? []
+          : [
+              " A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+            ],
+        {withoutStack: true},
       );
       expect(mountCount).toEqual(4);
       expect(element.innerHTML.length > 0).toBe(true);
-      expect(element.innerHTML).not.toEqual(lastMarkup);
+      if (favorSafetyOverHydrationPerf) {
+        expect(element.innerHTML).not.toEqual(lastMarkup);
+      } else {
+        expect(element.innerHTML).toEqual(lastMarkup);
+      }
 
       // Ensure the events system works after markup mismatch.
       expect(numClicks).toEqual(1);
@@ -218,8 +221,8 @@ describe('ReactDOMServerHydration', () => {
     const onFocusAfterHydration = jest.fn();
     element.firstChild.focus = onFocusBeforeHydration;
 
-    const enableClientRenderFallbackOnTextMismatch = gate(
-      flags => flags.enableClientRenderFallbackOnTextMismatch,
+    const favorSafetyOverHydrationPerf = gate(
+      flags => flags.favorSafetyOverHydrationPerf,
     );
     await expect(async () => {
       await act(() => {
@@ -232,15 +235,12 @@ describe('ReactDOMServerHydration', () => {
         );
       });
     }).toErrorDev(
-      enableClientRenderFallbackOnTextMismatch
-        ? [
-            'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-            'Warning: Text content did not match. Server: "server" Client: "client"',
-          ]
+      favorSafetyOverHydrationPerf
+        ? []
         : [
-            'Warning: Text content did not match. Server: "server" Client: "client"',
+            "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
           ],
-      {withoutStack: enableClientRenderFallbackOnTextMismatch ? 1 : 0},
+      {withoutStack: true},
     );
 
     expect(onFocusBeforeHydration).not.toHaveBeenCalled();
@@ -265,9 +265,8 @@ describe('ReactDOMServerHydration', () => {
         );
       });
     }).toErrorDev(
-      'Warning: Prop `style` did not match. Server: ' +
-        '"text-decoration:none;color:black;height:10px" Client: ' +
-        '"text-decoration:none;color:white;height:10px"',
+      "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+      {withoutStack: true},
     );
   });
 
@@ -314,9 +313,8 @@ describe('ReactDOMServerHydration', () => {
         );
       });
     }).toErrorDev(
-      'Warning: Prop `style` did not match. Server: ' +
-        '"text-decoration: none; color: black; height: 10px;" Client: ' +
-        '"text-decoration:none;color:black;height:10px"',
+      "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
+      {withoutStack: true},
     );
   });
 
@@ -505,74 +503,6 @@ describe('ReactDOMServerHydration', () => {
     await act(() => root.render(<div />));
   });
 
-  // @gate !disableLegacyMode
-  it('Suspense + hydration in legacy mode', () => {
-    const element = document.createElement('div');
-    element.innerHTML = '<div><div>Hello World</div></div>';
-    const div = element.firstChild.firstChild;
-    const ref = React.createRef();
-    expect(() =>
-      ReactDOM.hydrate(
-        <div>
-          <React.Suspense fallback={null}>
-            <div ref={ref}>Hello World</div>
-          </React.Suspense>
-        </div>,
-        element,
-      ),
-    ).toErrorDev(
-      'Warning: Did not expect server HTML to contain a <div> in <div>.',
-    );
-
-    // The content should've been client rendered and replaced the
-    // existing div.
-    expect(ref.current).not.toBe(div);
-    // The HTML should be the same though.
-    expect(element.innerHTML).toBe('<div><div>Hello World</div></div>');
-  });
-
-  // @gate !disableLegacyMode
-  it('Suspense + hydration in legacy mode (at root)', () => {
-    const element = document.createElement('div');
-    element.innerHTML = '<div>Hello World</div>';
-    const div = element.firstChild;
-    const ref = React.createRef();
-    ReactDOM.hydrate(
-      <React.Suspense fallback={null}>
-        <div ref={ref}>Hello World</div>
-      </React.Suspense>,
-      element,
-    );
-
-    // The content should've been client rendered.
-    expect(ref.current).not.toBe(div);
-    // Unfortunately, since we don't delete the tail at the root, a duplicate will remain.
-    expect(element.innerHTML).toBe(
-      '<div>Hello World</div><div>Hello World</div>',
-    );
-  });
-
-  // @gate !disableLegacyMode
-  it('Suspense + hydration in legacy mode with no fallback', () => {
-    const element = document.createElement('div');
-    element.innerHTML = '<div>Hello World</div>';
-    const div = element.firstChild;
-    const ref = React.createRef();
-    ReactDOM.hydrate(
-      <React.Suspense>
-        <div ref={ref}>Hello World</div>
-      </React.Suspense>,
-      element,
-    );
-
-    // The content should've been client rendered.
-    expect(ref.current).not.toBe(div);
-    // Unfortunately, since we don't delete the tail at the root, a duplicate will remain.
-    expect(element.innerHTML).toBe(
-      '<div>Hello World</div><div>Hello World</div>',
-    );
-  });
-
   // regression test for https://github.com/facebook/react/issues/17170
   it('should not warn if dangerouslySetInnerHtml=undefined', async () => {
     const domElement = document.createElement('div');
@@ -598,8 +528,8 @@ describe('ReactDOMServerHydration', () => {
     );
     domElement.innerHTML = markup;
 
-    const enableClientRenderFallbackOnTextMismatch = gate(
-      flags => flags.enableClientRenderFallbackOnTextMismatch,
+    const favorSafetyOverHydrationPerf = gate(
+      flags => flags.favorSafetyOverHydrationPerf,
     );
     await expect(async () => {
       await act(() => {
@@ -611,19 +541,20 @@ describe('ReactDOMServerHydration', () => {
           {onRecoverableError: error => {}},
         );
       });
-
-      expect(domElement.innerHTML).not.toEqual(markup);
     }).toErrorDev(
-      enableClientRenderFallbackOnTextMismatch
-        ? [
-            'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-            'Warning: Text content did not match. Server: "server" Client: "client"',
-          ]
+      favorSafetyOverHydrationPerf
+        ? []
         : [
-            'Warning: Text content did not match. Server: "server" Client: "client"',
+            " A tree hydrated but some attributes of the server rendered HTML didn't match the client properties.",
           ],
-      {withoutStack: enableClientRenderFallbackOnTextMismatch ? 1 : 0},
+      {withoutStack: true},
     );
+
+    if (favorSafetyOverHydrationPerf) {
+      expect(domElement.innerHTML).not.toEqual(markup);
+    } else {
+      expect(domElement.innerHTML).toEqual(markup);
+    }
   });
 
   it('should warn if innerHTML mismatches with dangerouslySetInnerHTML=undefined on the client', async () => {
@@ -633,23 +564,15 @@ describe('ReactDOMServerHydration', () => {
     );
     domElement.innerHTML = markup;
 
-    await expect(async () => {
-      await act(() => {
-        ReactDOMClient.hydrateRoot(
-          domElement,
-          <div dangerouslySetInnerHTML={undefined} />,
-          {onRecoverableError: error => {}},
-        );
-      });
+    await act(() => {
+      ReactDOMClient.hydrateRoot(
+        domElement,
+        <div dangerouslySetInnerHTML={undefined} />,
+        {onRecoverableError: error => {}},
+      );
+    });
 
-      expect(domElement.innerHTML).not.toEqual(markup);
-    }).toErrorDev(
-      [
-        'An error occurred during hydration. The server HTML was replaced with client content in <div>.',
-        'Warning: Did not expect server HTML to contain a <p> in <div>.',
-      ],
-      {withoutStack: 1},
-    );
+    expect(domElement.innerHTML).not.toEqual(markup);
   });
 
   it('should warn when hydrating read-only properties', async () => {
@@ -670,23 +593,16 @@ describe('ReactDOMServerHydration', () => {
       const jsx = React.createElement('my-custom-element', props);
       const element = document.createElement('div');
       element.innerHTML = ReactDOMServer.renderToString(jsx);
-      if (gate(flags => flags.enableCustomElementPropertySupport)) {
-        await expect(async () => {
-          await act(() => {
-            ReactDOMClient.hydrateRoot(element, jsx);
-          });
-        }).toErrorDev(
-          `Warning: Assignment to read-only property will result in a no-op: \`${readOnlyProperty}\``,
-        );
-      } else {
+      await expect(async () => {
         await act(() => {
           ReactDOMClient.hydrateRoot(element, jsx);
         });
-      }
+      }).toErrorDev(
+        `Warning: Assignment to read-only property will result in a no-op: \`${readOnlyProperty}\``,
+      );
     }
   });
 
-  // @gate enableCustomElementPropertySupport
   it('should not re-assign properties on hydration', async () => {
     const container = document.createElement('div');
     document.body.appendChild(container);
@@ -817,7 +733,6 @@ describe('ReactDOMServerHydration', () => {
     }
   });
 
-  // @gate enableFormActions
   it('allows rendering extra hidden inputs in a form', async () => {
     const element = document.createElement('div');
     element.innerHTML =
@@ -854,7 +769,6 @@ describe('ReactDOMServerHydration', () => {
     expect(c.current.value).toBe('C');
   });
 
-  // @gate enableFormActions
   it('allows rendering extra hidden inputs immediately before a text instance', async () => {
     const element = document.createElement('div');
     element.innerHTML =
diff --git a/packages/react-dom/src/__tests__/ReactTestUtils-test.js b/packages/react-dom/src/__tests__/ReactTestUtils-test.js
index 2fa0ea75a36e8..e3ed7c71a6883 100644
--- a/packages/react-dom/src/__tests__/ReactTestUtils-test.js
+++ b/packages/react-dom/src/__tests__/ReactTestUtils-test.js
@@ -31,6 +31,7 @@ describe('ReactTestUtils', () => {
     expect(Object.keys(ReactTestUtils.Simulate).sort()).toMatchSnapshot();
   });
 
+  // @gate !disableDOMTestUtils
   it('gives Jest mocks a passthrough implementation with mockComponent()', async () => {
     class MockedComponent extends React.Component {
       render() {
@@ -60,6 +61,7 @@ describe('ReactTestUtils', () => {
     expect(container.textContent).toBe('Hello');
   });
 
+  // @gate !disableDOMTestUtils
   it('can scryRenderedComponentsWithType', async () => {
     class Child extends React.Component {
       render() {
@@ -88,6 +90,7 @@ describe('ReactTestUtils', () => {
     expect(scryResults.length).toBe(1);
   });
 
+  // @gate !disableDOMTestUtils
   it('can scryRenderedDOMComponentsWithClass with TextComponent', async () => {
     class Wrapper extends React.Component {
       render() {
@@ -112,6 +115,7 @@ describe('ReactTestUtils', () => {
     expect(scryResults.length).toBe(0);
   });
 
+  // @gate !disableDOMTestUtils
   it('can scryRenderedDOMComponentsWithClass with className contains \\n', async () => {
     class Wrapper extends React.Component {
       render() {
@@ -136,6 +140,7 @@ describe('ReactTestUtils', () => {
     expect(scryResults.length).toBe(1);
   });
 
+  // @gate !disableDOMTestUtils
   it('can scryRenderedDOMComponentsWithClass with multiple classes', async () => {
     class Wrapper extends React.Component {
       render() {
@@ -187,6 +192,7 @@ describe('ReactTestUtils', () => {
     expect(scryResults5.length).toBe(0);
   });
 
+  // @gate !disableDOMTestUtils
   it('traverses children in the correct order', async () => {
     class Wrapper extends React.Component {
       render() {
@@ -225,6 +231,7 @@ describe('ReactTestUtils', () => {
     expect(log).toEqual(['orangepurple', 'orange', 'purple']);
   });
 
+  // @gate !disableDOMTestUtils
   it('should support injected wrapper components as DOM components', async () => {
     const injectedDOMComponents = [
       'button',
@@ -291,6 +298,7 @@ describe('ReactTestUtils', () => {
     expect(ReactTestUtils.isDOMComponent(component.bodyRef.current)).toBe(true);
   });
 
+  // @gate !disableDOMTestUtils
   it('can scry with stateless components involved', async () => {
     const Function = () => (
       <div>
@@ -320,6 +328,7 @@ describe('ReactTestUtils', () => {
     expect(hrs.length).toBe(2);
   });
 
+  // @gate !disableDOMTestUtils
   it('provides a clear error when passing invalid objects to scry', () => {
     // This is probably too relaxed but it's existing behavior.
     ReactTestUtils.findAllInRenderedTree(null, 'span');
@@ -377,6 +386,7 @@ describe('ReactTestUtils', () => {
   });
 
   describe('Simulate', () => {
+    // @gate !disableDOMTestUtils
     it('should change the value of an input field', async () => {
       const obj = {
         handler: function (e) {
@@ -399,6 +409,7 @@ describe('ReactTestUtils', () => {
       );
     });
 
+    // @gate !disableDOMTestUtils
     it('should change the value of an input field in a component', async () => {
       class SomeComponent extends React.Component {
         inputRef = React.createRef();
@@ -442,6 +453,7 @@ describe('ReactTestUtils', () => {
       );
     });
 
+    // @gate !disableDOMTestUtils
     it('should not warn when used with extra properties', async () => {
       const CLIENT_X = 100;
 
@@ -468,6 +480,7 @@ describe('ReactTestUtils', () => {
       });
     });
 
+    // @gate !disableDOMTestUtils
     it('should set the type of the event', async () => {
       let event;
       const stub = jest.fn().mockImplementation(e => {
@@ -488,6 +501,7 @@ describe('ReactTestUtils', () => {
       expect(event.nativeEvent.type).toBe('keydown');
     });
 
+    // @gate !disableDOMTestUtils
     it('should work with renderIntoDocument', async () => {
       const onChange = jest.fn();
 
@@ -520,6 +534,7 @@ describe('ReactTestUtils', () => {
       );
     });
 
+    // @gate !disableDOMTestUtils
     it('should have mouse enter simulated by test utils', async () => {
       const idCallOrder = [];
       const recordID = function (id) {
@@ -560,8 +575,17 @@ describe('ReactTestUtils', () => {
       });
       expect(idCallOrder).toEqual([CHILD]);
     });
+
+    // @gate disableDOMTestUtils
+    it('throws', async () => {
+      expect(ReactTestUtils.Simulate.click).toThrow(
+        '`Simulate` was removed from `react-dom/test-utils`. ' +
+          'See https://react.dev/warnings/react-dom-test-utils for more info.',
+      );
+    });
   });
 
+  // @gate !disableDOMTestUtils
   it('should call setState callback with no arguments', async () => {
     let mockArgs;
     class Component extends React.Component {
@@ -573,14 +597,12 @@ describe('ReactTestUtils', () => {
       }
     }
 
-    const container = document.createElement('div');
-    const root = ReactDOMClient.createRoot(container);
-    await act(() => {
-      root.render(<Component />);
-    });
+    ReactTestUtils.renderIntoDocument(<Component />);
 
     expect(mockArgs.length).toEqual(0);
   });
+
+  // @gate !disableDOMTestUtils
   it('should find rendered component with type in document', async () => {
     class MyComponent extends React.Component {
       render() {
@@ -602,4 +624,26 @@ describe('ReactTestUtils', () => {
 
     expect(renderedComponentType).toBe(instance);
   });
+
+  // @gate disableDOMTestUtils
+  it('throws on every removed function', async () => {
+    expect(ReactTestUtils.isDOMComponent).toThrow(
+      '`isDOMComponent` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  });
+
+  // @gate __DEV__
+  it('warns when using `act`', () => {
+    expect(() => {
+      ReactTestUtils.act(() => {});
+    }).toErrorDev(
+      [
+        '`ReactDOMTestUtils.act` is deprecated in favor of `React.act`. ' +
+          'Import `act` from `react` instead of `react-dom/test-utils`. ' +
+          'See https://react.dev/warnings/react-dom-test-utils for more info.',
+      ],
+      {withoutStack: true},
+    );
+  });
 });
diff --git a/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js b/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js
index 9f24801907ba1..c76b59ba6e40c 100644
--- a/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js
+++ b/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js
@@ -9,7 +9,6 @@
 
 let React;
 let ReactDOMClient;
-let ReactTestUtils;
 let Scheduler;
 let act;
 let container;
@@ -27,7 +26,7 @@ function sleep(period) {
   });
 }
 
-describe('ReactTestUtils.act()', () => {
+describe('React.act()', () => {
   afterEach(() => {
     jest.restoreAllMocks();
   });
@@ -84,9 +83,8 @@ function runActTests(render, unmount, rerender) {
       jest.resetModules();
       React = require('react');
       ReactDOMClient = require('react-dom/client');
-      ReactTestUtils = require('react-dom/test-utils');
       Scheduler = require('scheduler');
-      act = ReactTestUtils.act;
+      act = React.act;
 
       const InternalTestUtils = require('internal-test-utils');
       assertLog = InternalTestUtils.assertLog;
diff --git a/packages/react-dom/src/__tests__/ReactUpdates-test.js b/packages/react-dom/src/__tests__/ReactUpdates-test.js
index fb0c73fd25ba0..d4acfaa9b35f8 100644
--- a/packages/react-dom/src/__tests__/ReactUpdates-test.js
+++ b/packages/react-dom/src/__tests__/ReactUpdates-test.js
@@ -11,6 +11,7 @@
 
 let React;
 let ReactDOM;
+let findDOMNode;
 let ReactDOMClient;
 let act;
 let Scheduler;
@@ -23,6 +24,8 @@ describe('ReactUpdates', () => {
     jest.resetModules();
     React = require('react');
     ReactDOM = require('react-dom');
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
     ReactDOMClient = require('react-dom/client');
     act = require('internal-test-utils').act;
     Scheduler = require('scheduler');
@@ -659,7 +662,7 @@ describe('ReactUpdates', () => {
         a = this;
       }
       componentDidUpdate() {
-        expect(ReactDOM.findDOMNode(b).textContent).toBe('B1');
+        expect(findDOMNode(b).textContent).toBe('B1');
         aUpdated = true;
       }
 
@@ -801,7 +804,7 @@ describe('ReactUpdates', () => {
       componentDidMount() {
         instances.push(this);
         if (this.props.depth < this.props.count) {
-          const root = ReactDOMClient.createRoot(ReactDOM.findDOMNode(this));
+          const root = ReactDOMClient.createRoot(findDOMNode(this));
           root.render(
             <MockComponent
               depth={this.props.depth + 1}
@@ -889,12 +892,12 @@ describe('ReactUpdates', () => {
       root.render(<Y ref={current => (y = current)} />);
     });
 
-    expect(ReactDOM.findDOMNode(x).textContent).toBe('0');
+    expect(findDOMNode(x).textContent).toBe('0');
 
     await act(() => {
       y.forceUpdate();
     });
-    expect(ReactDOM.findDOMNode(x).textContent).toBe('1');
+    expect(findDOMNode(x).textContent).toBe('1');
   });
 
   it('should queue updates from during mount', async () => {
@@ -1542,11 +1545,11 @@ describe('ReactUpdates', () => {
 
     let limit = 55;
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<EventuallyTerminating ref={ref} />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
 
     // Verify that we don't go over the limit if these updates are unrelated.
     limit -= 10;
@@ -1566,15 +1569,15 @@ describe('ReactUpdates', () => {
     expect(container.textContent).toBe(limit.toString());
 
     limit += 10;
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         ref.current.setState({step: 0});
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
     expect(ref.current).toBe(null);
   });
 
-  it('does not fall into an infinite update loop', () => {
+  it('does not fall into an infinite update loop', async () => {
     class NonTerminating extends React.Component {
       state = {step: 0};
 
@@ -1599,14 +1602,14 @@ describe('ReactUpdates', () => {
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
 
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<NonTerminating />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
   });
 
-  it('does not fall into an infinite update loop with useLayoutEffect', () => {
+  it('does not fall into an infinite update loop with useLayoutEffect', async () => {
     function NonTerminating() {
       const [step, setStep] = React.useState(0);
       React.useLayoutEffect(() => {
@@ -1617,11 +1620,11 @@ describe('ReactUpdates', () => {
 
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<NonTerminating />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
   });
 
   it('can recover after falling into an infinite update loop', async () => {
@@ -1650,29 +1653,29 @@ describe('ReactUpdates', () => {
 
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<NonTerminating />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
 
     await act(() => {
       root.render(<Terminating />);
     });
     expect(container.textContent).toBe('1');
 
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<NonTerminating />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
     await act(() => {
       root.render(<Terminating />);
     });
     expect(container.textContent).toBe('1');
   });
 
-  it('does not fall into mutually recursive infinite update loop with same container', () => {
+  it('does not fall into mutually recursive infinite update loop with same container', async () => {
     // Note: this test would fail if there were two or more different roots.
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
@@ -1694,14 +1697,14 @@ describe('ReactUpdates', () => {
       }
     }
 
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<A />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
   });
 
-  it('does not fall into an infinite error loop', () => {
+  it('does not fall into an infinite error loop', async () => {
     function BadRender() {
       throw new Error('error');
     }
@@ -1730,11 +1733,11 @@ describe('ReactUpdates', () => {
 
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      ReactDOM.flushSync(() => {
+    await expect(async () => {
+      await act(() => {
         root.render(<NonTerminating />);
       });
-    }).toThrow('Maximum');
+    }).rejects.toThrow('Maximum');
   });
 
   it('can schedule ridiculously many updates within the same batch without triggering a maximum update error', async () => {
@@ -1775,7 +1778,7 @@ describe('ReactUpdates', () => {
     expect(subscribers.length).toBe(limit);
   });
 
-  it("does not infinite loop if there's a synchronous render phase update on another component", () => {
+  it("does not infinite loop if there's a synchronous render phase update on another component", async () => {
     if (gate(flags => !flags.enableInfiniteRenderLoopDetection)) {
       return;
     }
@@ -1795,10 +1798,10 @@ describe('ReactUpdates', () => {
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
 
-    expect(() => {
-      expect(() => ReactDOM.flushSync(() => root.render(<App />))).toThrow(
-        'Maximum update depth exceeded',
-      );
+    await expect(async () => {
+      await expect(async () => {
+        await act(() => ReactDOM.flushSync(() => root.render(<App />)));
+      }).rejects.toThrow('Maximum update depth exceeded');
     }).toErrorDev(
       'Warning: Cannot update a component (`App`) while rendering a different component (`Child`)',
     );
@@ -1926,7 +1929,7 @@ describe('ReactUpdates', () => {
     });
   }
 
-  it('prevents infinite update loop triggered by synchronous updates in useEffect', () => {
+  it('prevents infinite update loop triggered by synchronous updates in useEffect', async () => {
     // Ignore flushSync warning
     spyOnDev(console, 'error').mockImplementation(() => {});
 
@@ -1950,10 +1953,12 @@ describe('ReactUpdates', () => {
 
     const container = document.createElement('div');
     const root = ReactDOMClient.createRoot(container);
-    expect(() => {
-      ReactDOM.flushSync(() => {
-        root.render(<NonTerminating />);
+    await expect(async () => {
+      await act(() => {
+        ReactDOM.flushSync(() => {
+          root.render(<NonTerminating />);
+        });
       });
-    }).toThrow('Maximum update depth exceeded');
+    }).rejects.toThrow('Maximum update depth exceeded');
   });
 });
diff --git a/packages/react-dom/src/__tests__/findDOMNode-test.js b/packages/react-dom/src/__tests__/findDOMNode-test.js
index a67316a97b003..6dfcae82d4cfa 100644
--- a/packages/react-dom/src/__tests__/findDOMNode-test.js
+++ b/packages/react-dom/src/__tests__/findDOMNode-test.js
@@ -11,11 +11,13 @@
 
 const React = require('react');
 const ReactDOM = require('react-dom');
+const findDOMNode =
+  ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
 const StrictMode = React.StrictMode;
 
 describe('findDOMNode', () => {
   it('findDOMNode should return null if passed null', () => {
-    expect(ReactDOM.findDOMNode(null)).toBe(null);
+    expect(findDOMNode(null)).toBe(null);
   });
 
   // @gate !disableLegacyMode
@@ -32,8 +34,8 @@ describe('findDOMNode', () => {
 
     const container = document.createElement('div');
     const myNode = ReactDOM.render(<MyNode />, container);
-    const myDiv = ReactDOM.findDOMNode(myNode);
-    const mySameDiv = ReactDOM.findDOMNode(myDiv);
+    const myDiv = findDOMNode(myNode);
+    const mySameDiv = findDOMNode(myDiv);
     expect(myDiv.tagName).toBe('DIV');
     expect(mySameDiv).toBe(myDiv);
   });
@@ -55,19 +57,19 @@ describe('findDOMNode', () => {
     const container = document.createElement('div');
 
     const myNodeA = ReactDOM.render(<MyNode />, container);
-    const a = ReactDOM.findDOMNode(myNodeA);
+    const a = findDOMNode(myNodeA);
     expect(a).toBe(null);
 
     const myNodeB = ReactDOM.render(<MyNode flag={true} />, container);
     expect(myNodeA === myNodeB).toBe(true);
 
-    const b = ReactDOM.findDOMNode(myNodeB);
+    const b = findDOMNode(myNodeB);
     expect(b.tagName).toBe('SPAN');
   });
 
   it('findDOMNode should reject random objects', () => {
     expect(function () {
-      ReactDOM.findDOMNode({foo: 'bar'});
+      findDOMNode({foo: 'bar'});
     }).toThrowError('Argument appears to not be a ReactComponent. Keys: foo');
   });
 
@@ -83,7 +85,7 @@ describe('findDOMNode', () => {
     const inst = ReactDOM.render(<Foo />, container);
     ReactDOM.unmountComponentAtNode(container);
 
-    expect(() => ReactDOM.findDOMNode(inst)).toThrowError(
+    expect(() => findDOMNode(inst)).toThrowError(
       'Unable to find node on an unmounted component.',
     );
   });
@@ -92,7 +94,7 @@ describe('findDOMNode', () => {
   it('findDOMNode should not throw an error when called within a component that is not mounted', () => {
     class Bar extends React.Component {
       UNSAFE_componentWillMount() {
-        expect(ReactDOM.findDOMNode(this)).toBeNull();
+        expect(findDOMNode(this)).toBeNull();
       }
 
       render() {
@@ -127,7 +129,7 @@ describe('findDOMNode', () => {
     );
 
     let match;
-    expect(() => (match = ReactDOM.findDOMNode(parent))).toErrorDev([
+    expect(() => (match = findDOMNode(parent))).toErrorDev([
       'Warning: findDOMNode is deprecated in StrictMode. ' +
         'findDOMNode was passed an instance of ContainsStrictModeChild which renders StrictMode children. ' +
         'Instead, add a ref directly to the element you want to reference. ' +
@@ -160,7 +162,7 @@ describe('findDOMNode', () => {
     );
 
     let match;
-    expect(() => (match = ReactDOM.findDOMNode(parent))).toErrorDev([
+    expect(() => (match = findDOMNode(parent))).toErrorDev([
       'Warning: findDOMNode is deprecated in StrictMode. ' +
         'findDOMNode was passed an instance of IsInStrictMode which is inside StrictMode. ' +
         'Instead, add a ref directly to the element you want to reference. ' +
diff --git a/packages/react-dom/src/__tests__/react-dom-server-rendering-stub-test.js b/packages/react-dom/src/__tests__/react-dom-server-rendering-stub-test.js
index 0f6b4efa34800..28c4cb536d77d 100644
--- a/packages/react-dom/src/__tests__/react-dom-server-rendering-stub-test.js
+++ b/packages/react-dom/src/__tests__/react-dom-server-rendering-stub-test.js
@@ -30,6 +30,9 @@ describe('react-dom-server-rendering-stub', () => {
     expect(ReactDOM.createRoot).toBe(undefined);
     expect(ReactDOM.hydrateRoot).toBe(undefined);
     expect(ReactDOM.findDOMNode).toBe(undefined);
+    expect(
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode,
+    ).toBe(null);
     expect(ReactDOM.hydrate).toBe(undefined);
     expect(ReactDOM.render).toBe(undefined);
     expect(ReactDOM.unmountComponentAtNode).toBe(undefined);
@@ -38,7 +41,6 @@ describe('react-dom-server-rendering-stub', () => {
     expect(ReactDOM.unstable_runWithPriority).toBe(undefined);
   });
 
-  // @gate enableFloat
   it('provides preload, preloadModule, preinit, and preinitModule exports', async () => {
     function App() {
       ReactDOM.preload('foo', {as: 'style'});
@@ -83,7 +85,6 @@ describe('react-dom-server-rendering-stub', () => {
     expect(x).toBe(false);
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   it('exports useFormStatus', async () => {
     function App() {
diff --git a/packages/react-dom/src/__tests__/refs-test.js b/packages/react-dom/src/__tests__/refs-test.js
index f43ada19e004f..4a638ef17c566 100644
--- a/packages/react-dom/src/__tests__/refs-test.js
+++ b/packages/react-dom/src/__tests__/refs-test.js
@@ -11,7 +11,6 @@
 
 let React = require('react');
 let ReactDOMClient = require('react-dom/client');
-let ReactFeatureFlags = require('shared/ReactFeatureFlags');
 let act = require('internal-test-utils').act;
 
 // This is testing if string refs are deleted from `instance.refs`
@@ -24,7 +23,6 @@ describe('reactiverefs', () => {
     jest.resetModules();
     React = require('react');
     ReactDOMClient = require('react-dom/client');
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
     act = require('internal-test-utils').act;
   });
 
@@ -195,38 +193,6 @@ describe('reactiverefs', () => {
   });
 });
 
-if (!ReactFeatureFlags.disableModulePatternComponents) {
-  describe('factory components', () => {
-    it('Should correctly get the ref', async () => {
-      function Comp() {
-        return {
-          elemRef: React.createRef(),
-          render() {
-            return <div ref={this.elemRef} />;
-          },
-        };
-      }
-
-      let inst;
-      await expect(async () => {
-        const container = document.createElement('div');
-        const root = ReactDOMClient.createRoot(container);
-
-        await act(() => {
-          root.render(<Comp ref={current => (inst = current)} />);
-        });
-      }).toErrorDev(
-        'Warning: The <Comp /> component appears to be a function component that returns a class instance. ' +
-          'Change Comp to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`Comp.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
-      );
-      expect(inst.elemRef.current.tagName).toBe('DIV');
-    });
-  });
-}
-
 /**
  * Tests that when a ref hops around children, we can track that correctly.
  */
@@ -236,7 +202,6 @@ describe('ref swapping', () => {
     jest.resetModules();
     React = require('react');
     ReactDOMClient = require('react-dom/client');
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
     act = require('internal-test-utils').act;
 
     RefHopsAround = class extends React.Component {
diff --git a/packages/react-dom/src/__tests__/renderSubtreeIntoContainer-test.js b/packages/react-dom/src/__tests__/renderSubtreeIntoContainer-test.js
index 3b90ba569e05b..4f93cd3ac89ef 100644
--- a/packages/react-dom/src/__tests__/renderSubtreeIntoContainer-test.js
+++ b/packages/react-dom/src/__tests__/renderSubtreeIntoContainer-test.js
@@ -54,7 +54,7 @@ describe('renderSubtreeIntoContainer', () => {
             renderSubtreeIntoContainer(this, <Component />, portal);
           }.bind(this),
         ).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
     }
@@ -107,7 +107,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Component />, portal);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
 
@@ -115,7 +115,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Component />, portal);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
     }
@@ -172,7 +172,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Component />, portal);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
 
@@ -180,7 +180,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Component />, portal);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
     }
@@ -211,7 +211,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <div>hello</div>, portal);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
     }
@@ -250,7 +250,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Child />, portal);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
     }
@@ -290,7 +290,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Middle />, portal1);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
       static childContextTypes = {
@@ -306,7 +306,7 @@ describe('renderSubtreeIntoContainer', () => {
         expect(() => {
           renderSubtreeIntoContainer(this, <Child />, portal2);
         }).toErrorDev(
-          'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported',
+          'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported since React 18',
         );
       }
     }
diff --git a/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js b/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
index e9c4479b028fb..dce37947dfb5d 100644
--- a/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
+++ b/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
@@ -17,10 +17,12 @@ module.exports = function (initModules) {
   let ReactDOMClient;
   let ReactDOMServer;
   let act;
+  let ReactFeatureFlags;
 
   function resetModules() {
     ({ReactDOM, ReactDOMClient, ReactDOMServer} = initModules());
     act = require('internal-test-utils').act;
+    ReactFeatureFlags = require('shared/ReactFeatureFlags');
   }
 
   function shouldUseDocument(reactElement) {
@@ -52,15 +54,20 @@ module.exports = function (initModules) {
   async function asyncReactDOMRender(reactElement, domElement, forceHydrate) {
     if (forceHydrate) {
       await act(() => {
-        if (ReactDOMClient) {
-          ReactDOMClient.hydrateRoot(domElement, reactElement, {
-            onRecoverableError: () => {
-              // TODO: assert on recoverable error count.
-            },
-          });
-        } else {
-          ReactDOM.hydrate(reactElement, domElement);
-        }
+        ReactDOMClient.hydrateRoot(domElement, reactElement, {
+          onRecoverableError(e) {
+            if (
+              e.message.startsWith(
+                'There was an error while hydrating. Because the error happened outside of a Suspense boundary, the entire root will switch to client rendering.',
+              )
+            ) {
+              // We ignore this extra error because it shouldn't really need to be there if
+              // a hydration mismatch is the cause of it.
+            } else {
+              console.error(e);
+            }
+          },
+        });
       });
     } else {
       await act(() => {
@@ -94,11 +101,7 @@ module.exports = function (initModules) {
       for (let i = 0; i < console.error.mock.calls.length; i++) {
         const args = console.error.mock.calls[i];
         const [format, ...rest] = args;
-        if (
-          !shouldIgnoreConsoleError(format, rest, {
-            TODO_ignoreHydrationErrors: true,
-          })
-        ) {
+        if (!shouldIgnoreConsoleError(format, rest)) {
           filteredWarnings.push(args);
         }
       }
@@ -271,8 +274,10 @@ module.exports = function (initModules) {
     const cleanTextContent =
       (cleanContainer.lastChild && cleanContainer.lastChild.textContent) || '';
 
-    // The only guarantee is that text content has been patched up if needed.
-    expect(hydratedTextContent).toBe(cleanTextContent);
+    if (ReactFeatureFlags.favorSafetyOverHydrationPerf) {
+      // The only guarantee is that text content has been patched up if needed.
+      expect(hydratedTextContent).toBe(cleanTextContent);
+    }
 
     // Abort any further expects. All bets are off at this point.
     throw new BadMarkupExpected();
diff --git a/packages/react-dom/src/client/ReactDOM.js b/packages/react-dom/src/client/ReactDOM.js
index 78fffeb41cb34..99d2b62f2f845 100644
--- a/packages/react-dom/src/client/ReactDOM.js
+++ b/packages/react-dom/src/client/ReactDOM.js
@@ -21,7 +21,6 @@ import type {
 import {
   findDOMNode,
   render,
-  hydrate,
   unstable_renderSubtreeIntoContainer,
   unmountComponentAtNode,
 } from './ReactDOMLegacy';
@@ -33,7 +32,6 @@ import {
 import {createEventHandle} from 'react-dom-bindings/src/client/ReactDOMEventHandle';
 
 import {
-  batchedUpdates,
   flushSync as flushSyncWithoutWarningIfAlreadyRendering,
   isAlreadyRendering,
   injectIntoDevTools,
@@ -165,14 +163,23 @@ function flushSync<R>(fn: (() => R) | void): R | void {
   return flushSyncWithoutWarningIfAlreadyRendering(fn);
 }
 
+// Expose findDOMNode on internals
+Internals.findDOMNode = findDOMNode;
+
+function unstable_batchedUpdates<A, R>(fn: (a: A) => R, a: A): R {
+  // batchedUpdates was a legacy mode feature that is a no-op outside of
+  // legacy mode. In 19, we made it an actual no-op, but we're keeping it
+  // for now since there may be libraries that still include it.
+  return fn(a);
+}
+
 export {
   createPortal,
-  batchedUpdates as unstable_batchedUpdates,
+  unstable_batchedUpdates,
   flushSync,
   ReactVersion as version,
   // Disabled behind disableLegacyReactDOMAPIs
   findDOMNode,
-  hydrate,
   render,
   unmountComponentAtNode,
   // exposeConcurrentModeAPIs
@@ -195,7 +202,7 @@ Internals.Events = [
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates,
+  unstable_batchedUpdates,
 ];
 
 const foundDevTools = injectIntoDevTools({
diff --git a/packages/react-dom/src/client/ReactDOMLegacy.js b/packages/react-dom/src/client/ReactDOMLegacy.js
index ed0c6baae2fae..46220501a5e1e 100644
--- a/packages/react-dom/src/client/ReactDOMLegacy.js
+++ b/packages/react-dom/src/client/ReactDOMLegacy.js
@@ -39,6 +39,8 @@ import {
   getPublicRootInstance,
   findHostInstance,
   findHostInstanceWithWarning,
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
 } from 'react-reconciler/src/ReactFiberReconciler';
 import {LegacyRoot} from 'react-reconciler/src/ReactRootTags';
 import getComponentNameFromType from 'shared/getComponentNameFromType';
@@ -124,6 +126,8 @@ function legacyCreateRootFromDOMContainer(
       false, // isStrictMode
       false, // concurrentUpdatesByDefaultOverride,
       '', // identifierPrefix
+      defaultOnUncaughtError,
+      defaultOnCaughtError,
       noopOnRecoverableError,
       // TODO(luna) Support hydration later
       null,
@@ -158,7 +162,9 @@ function legacyCreateRootFromDOMContainer(
       false, // isStrictMode
       false, // concurrentUpdatesByDefaultOverride,
       '', // identifierPrefix
-      noopOnRecoverableError, // onRecoverableError
+      defaultOnUncaughtError,
+      defaultOnCaughtError,
+      noopOnRecoverableError,
       null, // transitionCallbacks
     );
     container._reactRootContainer = root;
@@ -228,6 +234,8 @@ function legacyRenderSubtreeIntoContainer(
   return getPublicRootInstance(root);
 }
 
+export type FindDOMNodeType = typeof findDOMNode;
+
 export function findDOMNode(
   componentOrElement: Element | ?React$Component<any, any>,
 ): null | Element | Text {
@@ -260,54 +268,6 @@ export function findDOMNode(
   return findHostInstance(componentOrElement);
 }
 
-export function hydrate(
-  element: React$Node,
-  container: Container,
-  callback: ?Function,
-): React$Component<any, any> | PublicInstance | null {
-  if (disableLegacyMode) {
-    if (__DEV__) {
-      console.error(
-        'ReactDOM.hydrate is no longer supported in React 18. Use hydrateRoot instead',
-      );
-    }
-    throw new Error('ReactDOM: Unsupported Legacy Mode API.');
-  }
-  if (__DEV__) {
-    console.error(
-      'ReactDOM.hydrate is no longer supported in React 18. Use hydrateRoot ' +
-        'instead. Until you switch to the new API, your app will behave as ' +
-        "if it's running React 17. Learn " +
-        'more: https://react.dev/link/switch-to-createroot',
-    );
-  }
-
-  if (!isValidContainerLegacy(container)) {
-    throw new Error('Target container is not a DOM element.');
-  }
-
-  if (__DEV__) {
-    const isModernRoot =
-      isContainerMarkedAsRoot(container) &&
-      container._reactRootContainer === undefined;
-    if (isModernRoot) {
-      console.error(
-        'You are calling ReactDOM.hydrate() on a container that was previously ' +
-          'passed to ReactDOMClient.createRoot(). This is not supported. ' +
-          'Did you mean to call hydrateRoot(container, element)?',
-      );
-    }
-  }
-  // TODO: throw or warn if we couldn't hydrate?
-  return legacyRenderSubtreeIntoContainer(
-    null,
-    element,
-    container,
-    true,
-    callback,
-  );
-}
-
 export function render(
   element: React$Element<any>,
   container: Container,
@@ -316,14 +276,14 @@ export function render(
   if (disableLegacyMode) {
     if (__DEV__) {
       console.error(
-        'ReactDOM.render is no longer supported in React 18. Use createRoot instead.',
+        'ReactDOM.render was removed in React 19. Use createRoot instead.',
       );
     }
     throw new Error('ReactDOM: Unsupported Legacy Mode API.');
   }
   if (__DEV__) {
     console.error(
-      'ReactDOM.render is no longer supported in React 18. Use createRoot ' +
+      'ReactDOM.render has not been supported since React 18. Use createRoot ' +
         'instead. Until you switch to the new API, your app will behave as ' +
         "if it's running React 17. Learn " +
         'more: https://react.dev/link/switch-to-createroot',
@@ -364,15 +324,15 @@ export function unstable_renderSubtreeIntoContainer(
   if (disableLegacyMode) {
     if (__DEV__) {
       console.error(
-        'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported in React 18. Consider using a portal instead.',
+        'ReactDOM.unstable_renderSubtreeIntoContainer() was removed in React 19. Consider using a portal instead.',
       );
     }
     throw new Error('ReactDOM: Unsupported Legacy Mode API.');
   }
   if (__DEV__) {
     console.error(
-      'ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported ' +
-        'in React 18. Consider using a portal instead. Until you switch to ' +
+      'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported ' +
+        'since React 18. Consider using a portal instead. Until you switch to ' +
         "the createRoot API, your app will behave as if it's running React " +
         '17. Learn more: https://react.dev/link/switch-to-createroot',
     );
@@ -396,6 +356,14 @@ export function unstable_renderSubtreeIntoContainer(
 }
 
 export function unmountComponentAtNode(container: Container): boolean {
+  if (disableLegacyMode) {
+    if (__DEV__) {
+      console.error(
+        'unmountComponentAtNode was removed in React 19. Use root.unmount() instead.',
+      );
+    }
+    throw new Error('ReactDOM: Unsupported Legacy Mode API.');
+  }
   if (!isValidContainerLegacy(container)) {
     throw new Error('Target container is not a DOM element.');
   }
diff --git a/packages/react-dom/src/client/ReactDOMRoot.js b/packages/react-dom/src/client/ReactDOMRoot.js
index 563fd6be1fc0c..21b08b784e6bb 100644
--- a/packages/react-dom/src/client/ReactDOMRoot.js
+++ b/packages/react-dom/src/client/ReactDOMRoot.js
@@ -19,7 +19,6 @@ import {
   allowConcurrentByDefault,
   disableCommentsAsDOMContainers,
   enableAsyncActions,
-  enableFormActions,
 } from 'shared/ReactFeatureFlags';
 
 export type RootType = {
@@ -33,7 +32,21 @@ export type CreateRootOptions = {
   unstable_concurrentUpdatesByDefault?: boolean,
   unstable_transitionCallbacks?: TransitionTracingCallbacks,
   identifierPrefix?: string,
-  onRecoverableError?: (error: mixed) => void,
+  onUncaughtError?: (
+    error: mixed,
+    errorInfo: {+componentStack?: ?string},
+  ) => void,
+  onCaughtError?: (
+    error: mixed,
+    errorInfo: {
+      +componentStack?: ?string,
+      +errorBoundary?: ?React$Component<any, any>,
+    },
+  ) => void,
+  onRecoverableError?: (
+    error: mixed,
+    errorInfo: {+digest?: ?string, +componentStack?: ?string},
+  ) => void,
 };
 
 export type HydrateRootOptions = {
@@ -45,7 +58,21 @@ export type HydrateRootOptions = {
   unstable_concurrentUpdatesByDefault?: boolean,
   unstable_transitionCallbacks?: TransitionTracingCallbacks,
   identifierPrefix?: string,
-  onRecoverableError?: (error: mixed) => void,
+  onUncaughtError?: (
+    error: mixed,
+    errorInfo: {+componentStack?: ?string},
+  ) => void,
+  onCaughtError?: (
+    error: mixed,
+    errorInfo: {
+      +componentStack?: ?string,
+      +errorBoundary?: ?React$Component<any, any>,
+    },
+  ) => void,
+  onRecoverableError?: (
+    error: mixed,
+    errorInfo: {+digest?: ?string, +componentStack?: ?string},
+  ) => void,
   formState?: ReactFormState<any, any> | null,
 };
 
@@ -68,21 +95,12 @@ import {
   updateContainer,
   flushSync,
   isAlreadyRendering,
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
+  defaultOnRecoverableError,
 } from 'react-reconciler/src/ReactFiberReconciler';
 import {ConcurrentRoot} from 'react-reconciler/src/ReactRootTags';
 
-/* global reportError */
-const defaultOnRecoverableError =
-  typeof reportError === 'function'
-    ? // In modern browsers, reportError will dispatch an error event,
-      // emulating an uncaught JavaScript error.
-      reportError
-    : (error: mixed) => {
-        // In older browsers and test environments, fallback to console.error.
-        // eslint-disable-next-line react-internal/no-production-logging
-        console['error'](error);
-      };
-
 // $FlowFixMe[missing-this-annot]
 function ReactDOMRoot(internalRoot: FiberRoot) {
   this._internalRoot = internalRoot;
@@ -163,6 +181,8 @@ export function createRoot(
   let isStrictMode = false;
   let concurrentUpdatesByDefaultOverride = false;
   let identifierPrefix = '';
+  let onUncaughtError = defaultOnUncaughtError;
+  let onCaughtError = defaultOnCaughtError;
   let onRecoverableError = defaultOnRecoverableError;
   let transitionCallbacks = null;
 
@@ -200,6 +220,12 @@ export function createRoot(
     if (options.identifierPrefix !== undefined) {
       identifierPrefix = options.identifierPrefix;
     }
+    if (options.onUncaughtError !== undefined) {
+      onUncaughtError = options.onUncaughtError;
+    }
+    if (options.onCaughtError !== undefined) {
+      onCaughtError = options.onCaughtError;
+    }
     if (options.onRecoverableError !== undefined) {
       onRecoverableError = options.onRecoverableError;
     }
@@ -215,6 +241,8 @@ export function createRoot(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
+    onUncaughtError,
+    onCaughtError,
     onRecoverableError,
     transitionCallbacks,
   );
@@ -269,6 +297,8 @@ export function hydrateRoot(
   let isStrictMode = false;
   let concurrentUpdatesByDefaultOverride = false;
   let identifierPrefix = '';
+  let onUncaughtError = defaultOnUncaughtError;
+  let onCaughtError = defaultOnCaughtError;
   let onRecoverableError = defaultOnRecoverableError;
   let transitionCallbacks = null;
   let formState = null;
@@ -285,13 +315,19 @@ export function hydrateRoot(
     if (options.identifierPrefix !== undefined) {
       identifierPrefix = options.identifierPrefix;
     }
+    if (options.onUncaughtError !== undefined) {
+      onUncaughtError = options.onUncaughtError;
+    }
+    if (options.onCaughtError !== undefined) {
+      onCaughtError = options.onCaughtError;
+    }
     if (options.onRecoverableError !== undefined) {
       onRecoverableError = options.onRecoverableError;
     }
     if (options.unstable_transitionCallbacks !== undefined) {
       transitionCallbacks = options.unstable_transitionCallbacks;
     }
-    if (enableAsyncActions && enableFormActions) {
+    if (enableAsyncActions) {
       if (options.formState !== undefined) {
         formState = options.formState;
       }
@@ -307,6 +343,8 @@ export function hydrateRoot(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
+    onUncaughtError,
+    onCaughtError,
     onRecoverableError,
     transitionCallbacks,
     formState,
diff --git a/packages/react-dom/src/client/ReactDOMRootFB.js b/packages/react-dom/src/client/ReactDOMRootFB.js
new file mode 100644
index 0000000000000..138f781e6caa7
--- /dev/null
+++ b/packages/react-dom/src/client/ReactDOMRootFB.js
@@ -0,0 +1,421 @@
+/**
+ * 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.
+ *
+ * @flow
+ */
+
+import type {ReactNodeList} from 'shared/ReactTypes';
+
+import type {
+  RootType,
+  CreateRootOptions,
+  HydrateRootOptions,
+} from './ReactDOMRoot';
+
+import type {FiberRoot} from 'react-reconciler/src/ReactInternalTypes';
+
+import type {
+  Container,
+  PublicInstance,
+} from 'react-dom-bindings/src/client/ReactFiberConfigDOM';
+
+import {
+  createRoot as createRootImpl,
+  hydrateRoot as hydrateRootImpl,
+} from './ReactDOMRoot';
+
+import {disableLegacyMode} from 'shared/ReactFeatureFlags';
+import {clearContainer} from 'react-dom-bindings/src/client/ReactFiberConfigDOM';
+import {
+  getInstanceFromNode,
+  isContainerMarkedAsRoot,
+  markContainerAsRoot,
+} from 'react-dom-bindings/src/client/ReactDOMComponentTree';
+import {listenToAllSupportedEvents} from 'react-dom-bindings/src/events/DOMPluginEventSystem';
+import {isValidContainerLegacy} from './ReactDOMRoot';
+import {
+  DOCUMENT_NODE,
+  COMMENT_NODE,
+} from 'react-dom-bindings/src/client/HTMLNodeType';
+
+import {
+  batchedUpdates,
+  createContainer,
+  createHydrationContainer,
+  findHostInstanceWithNoPortals,
+  updateContainer,
+  flushSync,
+  getPublicRootInstance,
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
+} from 'react-reconciler/src/ReactFiberReconciler';
+import {LegacyRoot} from 'react-reconciler/src/ReactRootTags';
+import {has as hasInstance} from 'shared/ReactInstanceMap';
+
+import assign from 'shared/assign';
+
+// Provided by www
+const ReactFiberErrorDialogWWW = require('ReactFiberErrorDialog');
+
+if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== 'function') {
+  throw new Error(
+    'Expected ReactFiberErrorDialog.showErrorDialog to be a function.',
+  );
+}
+
+function wwwOnUncaughtError(
+  error: mixed,
+  errorInfo: {+componentStack?: ?string},
+): void {
+  const componentStack =
+    errorInfo.componentStack != null ? errorInfo.componentStack : '';
+  const logError = ReactFiberErrorDialogWWW.showErrorDialog({
+    errorBoundary: null,
+    error,
+    componentStack,
+  });
+
+  // Allow injected showErrorDialog() to prevent default console.error logging.
+  // This enables renderers like ReactNative to better manage redbox behavior.
+  if (logError === false) {
+    return;
+  }
+
+  defaultOnUncaughtError(error, errorInfo);
+}
+
+function wwwOnCaughtError(
+  error: mixed,
+  errorInfo: {
+    +componentStack?: ?string,
+    +errorBoundary?: ?React$Component<any, any>,
+  },
+): void {
+  const errorBoundary = errorInfo.errorBoundary;
+  const componentStack =
+    errorInfo.componentStack != null ? errorInfo.componentStack : '';
+  const logError = ReactFiberErrorDialogWWW.showErrorDialog({
+    errorBoundary,
+    error,
+    componentStack,
+  });
+
+  // Allow injected showErrorDialog() to prevent default console.error logging.
+  // This enables renderers like ReactNative to better manage redbox behavior.
+  if (logError === false) {
+    return;
+  }
+
+  defaultOnCaughtError(error, errorInfo);
+}
+
+export function createRoot(
+  container: Element | Document | DocumentFragment,
+  options?: CreateRootOptions,
+): RootType {
+  return createRootImpl(
+    container,
+    assign(
+      ({
+        onUncaughtError: wwwOnUncaughtError,
+        onCaughtError: wwwOnCaughtError,
+      }: any),
+      options,
+    ),
+  );
+}
+
+export function hydrateRoot(
+  container: Document | Element,
+  initialChildren: ReactNodeList,
+  options?: HydrateRootOptions,
+): RootType {
+  return hydrateRootImpl(
+    container,
+    initialChildren,
+    assign(
+      ({
+        onUncaughtError: wwwOnUncaughtError,
+        onCaughtError: wwwOnCaughtError,
+      }: any),
+      options,
+    ),
+  );
+}
+
+let topLevelUpdateWarnings;
+
+if (__DEV__) {
+  topLevelUpdateWarnings = (container: Container) => {
+    if (container._reactRootContainer && container.nodeType !== COMMENT_NODE) {
+      const hostInstance = findHostInstanceWithNoPortals(
+        container._reactRootContainer.current,
+      );
+      if (hostInstance) {
+        if (hostInstance.parentNode !== container) {
+          console.error(
+            'It looks like the React-rendered content of this ' +
+              'container was removed without using React. This is not ' +
+              'supported and will cause errors. Instead, call ' +
+              'ReactDOM.unmountComponentAtNode to empty a container.',
+          );
+        }
+      }
+    }
+
+    const isRootRenderedBySomeReact = !!container._reactRootContainer;
+    const rootEl = getReactRootElementInContainer(container);
+    const hasNonRootReactChild = !!(rootEl && getInstanceFromNode(rootEl));
+
+    if (hasNonRootReactChild && !isRootRenderedBySomeReact) {
+      console.error(
+        'Replacing React-rendered children with a new root ' +
+          'component. If you intended to update the children of this node, ' +
+          'you should instead have the existing children update their state ' +
+          'and render the new components instead of calling ReactDOM.render.',
+      );
+    }
+  };
+}
+
+function getReactRootElementInContainer(container: any) {
+  if (!container) {
+    return null;
+  }
+
+  if (container.nodeType === DOCUMENT_NODE) {
+    return container.documentElement;
+  } else {
+    return container.firstChild;
+  }
+}
+
+function noopOnRecoverableError() {
+  // This isn't reachable because onRecoverableError isn't called in the
+  // legacy API.
+}
+
+function legacyCreateRootFromDOMContainer(
+  container: Container,
+  initialChildren: ReactNodeList,
+  parentComponent: ?React$Component<any, any>,
+  callback: ?Function,
+  isHydrationContainer: boolean,
+): FiberRoot {
+  if (isHydrationContainer) {
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root: FiberRoot = createHydrationContainer(
+      initialChildren,
+      callback,
+      container,
+      LegacyRoot,
+      null, // hydrationCallbacks
+      false, // isStrictMode
+      false, // concurrentUpdatesByDefaultOverride,
+      '', // identifierPrefix
+      wwwOnUncaughtError,
+      wwwOnCaughtError,
+      noopOnRecoverableError,
+      // TODO(luna) Support hydration later
+      null,
+      null,
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+
+    const rootContainerElement =
+      container.nodeType === COMMENT_NODE ? container.parentNode : container;
+    // $FlowFixMe[incompatible-call]
+    listenToAllSupportedEvents(rootContainerElement);
+
+    flushSync();
+    return root;
+  } else {
+    // First clear any existing content.
+    clearContainer(container);
+
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+
+    const root = createContainer(
+      container,
+      LegacyRoot,
+      null, // hydrationCallbacks
+      false, // isStrictMode
+      false, // concurrentUpdatesByDefaultOverride,
+      '', // identifierPrefix
+      wwwOnUncaughtError,
+      wwwOnCaughtError,
+      noopOnRecoverableError,
+      null, // transitionCallbacks
+    );
+    container._reactRootContainer = root;
+    markContainerAsRoot(root.current, container);
+
+    const rootContainerElement =
+      container.nodeType === COMMENT_NODE ? container.parentNode : container;
+    // $FlowFixMe[incompatible-call]
+    listenToAllSupportedEvents(rootContainerElement);
+
+    // Initial mount should not be batched.
+    flushSync(() => {
+      updateContainer(initialChildren, root, parentComponent, callback);
+    });
+
+    return root;
+  }
+}
+
+function warnOnInvalidCallback(callback: mixed): void {
+  if (__DEV__) {
+    if (callback !== null && typeof callback !== 'function') {
+      console.error(
+        'Expected the last optional `callback` argument to be a ' +
+          'function. Instead received: %s.',
+        callback,
+      );
+    }
+  }
+}
+
+function legacyRenderSubtreeIntoContainer(
+  parentComponent: ?React$Component<any, any>,
+  children: ReactNodeList,
+  container: Container,
+  forceHydrate: boolean,
+  callback: ?Function,
+): React$Component<any, any> | PublicInstance | null {
+  if (__DEV__) {
+    topLevelUpdateWarnings(container);
+    warnOnInvalidCallback(callback === undefined ? null : callback);
+  }
+
+  const maybeRoot = container._reactRootContainer;
+  let root: FiberRoot;
+  if (!maybeRoot) {
+    // Initial mount
+    root = legacyCreateRootFromDOMContainer(
+      container,
+      children,
+      parentComponent,
+      callback,
+      forceHydrate,
+    );
+  } else {
+    root = maybeRoot;
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+      callback = function () {
+        const instance = getPublicRootInstance(root);
+        originalCallback.call(instance);
+      };
+    }
+    // Update
+    updateContainer(children, root, parentComponent, callback);
+  }
+  return getPublicRootInstance(root);
+}
+
+export function render(
+  element: React$Element<any>,
+  container: Container,
+  callback: ?Function,
+): React$Component<any, any> | PublicInstance | null {
+  if (disableLegacyMode) {
+    if (__DEV__) {
+      console.error(
+        'ReactDOM.render was removed in React 19. Use createRoot instead.',
+      );
+    }
+    throw new Error('ReactDOM: Unsupported Legacy Mode API.');
+  }
+  if (__DEV__) {
+    console.error(
+      'ReactDOM.render has not been supported since React 18. Use createRoot ' +
+        'instead. Until you switch to the new API, your app will behave as ' +
+        "if it's running React 17. Learn " +
+        'more: https://react.dev/link/switch-to-createroot',
+    );
+  }
+
+  if (!isValidContainerLegacy(container)) {
+    throw new Error('Target container is not a DOM element.');
+  }
+
+  if (__DEV__) {
+    const isModernRoot =
+      isContainerMarkedAsRoot(container) &&
+      container._reactRootContainer === undefined;
+    if (isModernRoot) {
+      console.error(
+        'You are calling ReactDOM.render() on a container that was previously ' +
+          'passed to ReactDOMClient.createRoot(). This is not supported. ' +
+          'Did you mean to call root.render(element)?',
+      );
+    }
+  }
+  return legacyRenderSubtreeIntoContainer(
+    null,
+    element,
+    container,
+    false,
+    callback,
+  );
+}
+
+export function unstable_renderSubtreeIntoContainer(
+  parentComponent: React$Component<any, any>,
+  element: React$Element<any>,
+  containerNode: Container,
+  callback: ?Function,
+): React$Component<any, any> | PublicInstance | null {
+  if (disableLegacyMode) {
+    if (__DEV__) {
+      console.error(
+        'ReactDOM.unstable_renderSubtreeIntoContainer() was removed in React 19. Consider using a portal instead.',
+      );
+    }
+    throw new Error('ReactDOM: Unsupported Legacy Mode API.');
+  }
+  if (__DEV__) {
+    console.error(
+      'ReactDOM.unstable_renderSubtreeIntoContainer() has not been supported ' +
+        'since React 18. Consider using a portal instead. Until you switch to ' +
+        "the createRoot API, your app will behave as if it's running React " +
+        '17. Learn more: https://react.dev/link/switch-to-createroot',
+    );
+  }
+
+  if (!isValidContainerLegacy(containerNode)) {
+    throw new Error('Target container is not a DOM element.');
+  }
+
+  if (parentComponent == null || !hasInstance(parentComponent)) {
+    throw new Error('parentComponent must be a valid React Component');
+  }
+
+  return legacyRenderSubtreeIntoContainer(
+    parentComponent,
+    element,
+    containerNode,
+    false,
+    callback,
+  );
+}
+
+export {batchedUpdates as unstable_batchedUpdates};
diff --git a/packages/react-dom/src/client/__mocks__/ReactFiberErrorDialog.js b/packages/react-dom/src/client/__mocks__/ReactFiberErrorDialog.js
new file mode 100644
index 0000000000000..94b0e9ab67ba1
--- /dev/null
+++ b/packages/react-dom/src/client/__mocks__/ReactFiberErrorDialog.js
@@ -0,0 +1,12 @@
+/**
+ * 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.
+ *
+ * @flow
+ */
+
+export function showErrorDialog(): boolean {
+  return true;
+}
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerBun.js b/packages/react-dom/src/server/ReactDOMFizzServerBun.js
index ffe29f22ed7de..bc0206cdc8057 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerBun.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerBun.js
@@ -146,13 +146,6 @@ function renderToReadableStream(
   });
 }
 
-function renderToNodeStream() {
-  throw new Error(
-    'ReactDOMServer.renderToNodeStream(): The Node Stream API is not available ' +
-      'in Bun. Use ReactDOMServer.renderToReadableStream() instead.',
-  );
-}
-
 function renderToStaticNodeStream() {
   throw new Error(
     'ReactDOMServer.renderToStaticNodeStream(): The Node Stream API is not available ' +
@@ -162,7 +155,6 @@ function renderToStaticNodeStream() {
 
 export {
   renderToReadableStream,
-  renderToNodeStream,
   renderToStaticNodeStream,
   ReactVersion as version,
 };
diff --git a/packages/react-dom/src/server/ReactDOMLegacyServerBrowser.js b/packages/react-dom/src/server/ReactDOMLegacyServerBrowser.js
index b424bef497ba6..01fdbd8d50b62 100644
--- a/packages/react-dom/src/server/ReactDOMLegacyServerBrowser.js
+++ b/packages/react-dom/src/server/ReactDOMLegacyServerBrowser.js
@@ -39,13 +39,6 @@ function renderToStaticMarkup(
   );
 }
 
-function renderToNodeStream() {
-  throw new Error(
-    'ReactDOMServer.renderToNodeStream(): The streaming API is not available ' +
-      'in the browser. Use ReactDOMServer.renderToString() instead.',
-  );
-}
-
 function renderToStaticNodeStream() {
   throw new Error(
     'ReactDOMServer.renderToStaticNodeStream(): The streaming API is not available ' +
@@ -56,7 +49,6 @@ function renderToStaticNodeStream() {
 export {
   renderToString,
   renderToStaticMarkup,
-  renderToNodeStream,
   renderToStaticNodeStream,
   version,
 };
diff --git a/packages/react-dom/src/server/ReactDOMLegacyServerNode.js b/packages/react-dom/src/server/ReactDOMLegacyServerNode.js
index 5c56afb7e03e8..07765e2b74333 100644
--- a/packages/react-dom/src/server/ReactDOMLegacyServerNode.js
+++ b/packages/react-dom/src/server/ReactDOMLegacyServerNode.js
@@ -10,10 +10,7 @@
 import type {ReactNodeList} from 'shared/ReactTypes';
 
 import {version, renderToStringImpl} from './ReactDOMLegacyServerImpl';
-import {
-  renderToNodeStream,
-  renderToStaticNodeStream,
-} from './ReactDOMLegacyServerNodeStream';
+import {renderToStaticNodeStream} from './ReactDOMLegacyServerNodeStream';
 
 type ServerOptions = {
   identifierPrefix?: string,
@@ -46,7 +43,6 @@ function renderToStaticMarkup(
 export {
   renderToString,
   renderToStaticMarkup,
-  renderToNodeStream,
   renderToStaticNodeStream,
   version,
 };
diff --git a/packages/react-dom/src/server/ReactDOMLegacyServerNodeStream.js b/packages/react-dom/src/server/ReactDOMLegacyServerNodeStream.js
index 8df44d8004261..d34c0563a81a6 100644
--- a/packages/react-dom/src/server/ReactDOMLegacyServerNodeStream.js
+++ b/packages/react-dom/src/server/ReactDOMLegacyServerNodeStream.js
@@ -59,10 +59,9 @@ function onError() {
   // Non-fatal errors are ignored.
 }
 
-function renderToNodeStreamImpl(
+function renderToStaticNodeStream(
   children: ReactNodeList,
-  options: void | ServerOptions,
-  generateStaticMarkup: boolean,
+  options?: ServerOptions,
 ): Readable {
   function onAllReady() {
     // We wait until everything has loaded before starting to write.
@@ -78,7 +77,7 @@ function renderToNodeStreamImpl(
   const request = createRequest(
     children,
     resumableState,
-    createRenderState(resumableState, false),
+    createRenderState(resumableState, true),
     createRootFormatContext(),
     Infinity,
     onError,
@@ -92,23 +91,4 @@ function renderToNodeStreamImpl(
   return destination;
 }
 
-function renderToNodeStream(
-  children: ReactNodeList,
-  options?: ServerOptions,
-): Readable {
-  if (__DEV__) {
-    console.error(
-      'renderToNodeStream is deprecated. Use renderToPipeableStream instead.',
-    );
-  }
-  return renderToNodeStreamImpl(children, options, false);
-}
-
-function renderToStaticNodeStream(
-  children: ReactNodeList,
-  options?: ServerOptions,
-): Readable {
-  return renderToNodeStreamImpl(children, options, true);
-}
-
-export {renderToNodeStream, renderToStaticNodeStream};
+export {renderToStaticNodeStream};
diff --git a/packages/react-dom/src/server/react-dom-server.bun.stable.js b/packages/react-dom/src/server/react-dom-server.bun.stable.js
index b5c1fd02d3638..74f933dcfeb96 100644
--- a/packages/react-dom/src/server/react-dom-server.bun.stable.js
+++ b/packages/react-dom/src/server/react-dom-server.bun.stable.js
@@ -9,7 +9,6 @@
 
 export {
   renderToReadableStream,
-  renderToNodeStream,
   renderToStaticNodeStream,
   version,
 } from './ReactDOMFizzServerBun.js';
diff --git a/packages/react-dom/src/shared/ReactDOMFloat.js b/packages/react-dom/src/shared/ReactDOMFloat.js
index 2effe174416be..4aa364af318c7 100644
--- a/packages/react-dom/src/shared/ReactDOMFloat.js
+++ b/packages/react-dom/src/shared/ReactDOMFloat.js
@@ -139,6 +139,7 @@ export function preload(href: string, options: PreloadOptions) {
           : undefined,
       imageSizes:
         typeof options.imageSizes === 'string' ? options.imageSizes : undefined,
+      media: typeof options.media === 'string' ? options.media : undefined,
     });
   }
   // We don't error because preload needs to be resilient to being called in a variety of scopes
diff --git a/packages/react-dom/src/shared/ReactDOMTypes.js b/packages/react-dom/src/shared/ReactDOMTypes.js
index 7578e182ae7c8..0e6d76c6e919a 100644
--- a/packages/react-dom/src/shared/ReactDOMTypes.js
+++ b/packages/react-dom/src/shared/ReactDOMTypes.js
@@ -16,6 +16,7 @@ export type PreloadOptions = {
   crossOrigin?: string,
   integrity?: string,
   type?: string,
+  media?: string,
   nonce?: string,
   fetchPriority?: FetchPriorityEnum,
   imageSrcSet?: string,
diff --git a/packages/react-dom/src/test-utils/ReactTestUtils.js b/packages/react-dom/src/test-utils/ReactTestUtils.js
index 8a4f2eb9ba7cd..1b4125c819e61 100644
--- a/packages/react-dom/src/test-utils/ReactTestUtils.js
+++ b/packages/react-dom/src/test-utils/ReactTestUtils.js
@@ -21,7 +21,7 @@ import {
 } from 'react-reconciler/src/ReactWorkTags';
 import {SyntheticEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
 import {ELEMENT_NODE} from 'react-dom-bindings/src/client/HTMLNodeType';
-import {enableFloat} from 'shared/ReactFeatureFlags';
+import {disableDOMTestUtils} from 'shared/ReactFeatureFlags';
 import assign from 'shared/assign';
 import isArray from 'shared/isArray';
 
@@ -35,9 +35,18 @@ const getFiberCurrentPropsFromNode = EventInternals[2];
 const enqueueStateRestore = EventInternals[3];
 const restoreStateIfNeeded = EventInternals[4];
 
-// TODO: Add a warning if this API is accessed with advice to switch to
-// importing directly from the React package instead.
-const act = React.act;
+let didWarnAboutUsingAct = false;
+function act(callback) {
+  if (didWarnAboutUsingAct === false) {
+    didWarnAboutUsingAct = true;
+    console.error(
+      '`ReactDOMTestUtils.act` is deprecated in favor of `React.act`. ' +
+        'Import `act` from `react` instead of `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+  return React.act(callback);
+}
 
 function Event(suffix) {}
 
@@ -63,7 +72,7 @@ function findAllInRenderedFiberTreeInternal(fiber, test) {
       node.tag === HostText ||
       node.tag === ClassComponent ||
       node.tag === FunctionComponent ||
-      (enableFloat ? node.tag === HostHoistable : false) ||
+      node.tag === HostHoistable ||
       node.tag === HostSingleton
     ) {
       const publicInst = node.stateNode;
@@ -127,6 +136,13 @@ function validateClassInstance(inst, methodName) {
  * @lends ReactTestUtils
  */
 function renderIntoDocument(element) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`renderIntoDocument` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   const div = document.createElement('div');
   // None of our tests actually require attaching the container to the
   // DOM, and doing so creates a mess that we rely on test isolation to
@@ -137,22 +153,57 @@ function renderIntoDocument(element) {
 }
 
 function isElement(element) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`isElement` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   return React.isValidElement(element);
 }
 
 function isElementOfType(inst, convenienceConstructor) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`isElementOfType` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   return React.isValidElement(inst) && inst.type === convenienceConstructor;
 }
 
 function isDOMComponent(inst) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`isDOMComponent` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
 }
 
 function isDOMComponentElement(inst) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`isDOMComponentElement` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   return !!(inst && React.isValidElement(inst) && !!inst.tagName);
 }
 
 function isCompositeComponent(inst) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`isCompositeComponent` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   if (isDOMComponent(inst)) {
     // Accessing inst.setState warns; just return false as that'll be what
     // this returns when we have DOM nodes as refs directly
@@ -166,6 +217,13 @@ function isCompositeComponent(inst) {
 }
 
 function isCompositeComponentWithType(inst, type) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`isCompositeComponentWithType` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   if (!isCompositeComponent(inst)) {
     return false;
   }
@@ -175,6 +233,13 @@ function isCompositeComponentWithType(inst, type) {
 }
 
 function findAllInRenderedTree(inst, test) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`findAllInRenderedTree` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(inst, 'findAllInRenderedTree');
   if (!inst) {
     return [];
@@ -189,6 +254,13 @@ function findAllInRenderedTree(inst, test) {
  * @return {array} an array of all the matches.
  */
 function scryRenderedDOMComponentsWithClass(root, classNames) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`scryRenderedDOMComponentsWithClass` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
   return findAllInRenderedTree(root, function (inst) {
     if (isDOMComponent(inst)) {
@@ -224,6 +296,13 @@ function scryRenderedDOMComponentsWithClass(root, classNames) {
  * @return {!ReactDOMComponent} The one match.
  */
 function findRenderedDOMComponentWithClass(root, className) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`findRenderedDOMComponentWithClass` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(root, 'findRenderedDOMComponentWithClass');
   const all = scryRenderedDOMComponentsWithClass(root, className);
   if (all.length !== 1) {
@@ -244,6 +323,13 @@ function findRenderedDOMComponentWithClass(root, className) {
  * @return {array} an array of all the matches.
  */
 function scryRenderedDOMComponentsWithTag(root, tagName) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`scryRenderedDOMComponentsWithTag` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
   return findAllInRenderedTree(root, function (inst) {
     return (
@@ -260,6 +346,13 @@ function scryRenderedDOMComponentsWithTag(root, tagName) {
  * @return {!ReactDOMComponent} The one match.
  */
 function findRenderedDOMComponentWithTag(root, tagName) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`findRenderedDOMComponentWithTag` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(root, 'findRenderedDOMComponentWithTag');
   const all = scryRenderedDOMComponentsWithTag(root, tagName);
   if (all.length !== 1) {
@@ -279,6 +372,13 @@ function findRenderedDOMComponentWithTag(root, tagName) {
  * @return {array} an array of all the matches.
  */
 function scryRenderedComponentsWithType(root, componentType) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`scryRenderedComponentsWithType` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(root, 'scryRenderedComponentsWithType');
   return findAllInRenderedTree(root, function (inst) {
     return isCompositeComponentWithType(inst, componentType);
@@ -292,6 +392,13 @@ function scryRenderedComponentsWithType(root, componentType) {
  * @return {!ReactComponent} The one match.
  */
 function findRenderedComponentWithType(root, componentType) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`findRenderedComponentWithType` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   validateClassInstance(root, 'findRenderedComponentWithType');
   const all = scryRenderedComponentsWithType(root, componentType);
   if (all.length !== 1) {
@@ -320,6 +427,13 @@ function findRenderedComponentWithType(root, componentType) {
  * @return {object} the ReactTestUtils object (for chaining)
  */
 function mockComponent(module, mockTagName) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`mockComponent` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   if (__DEV__) {
     if (!hasWarnedAboutDeprecatedMockComponent) {
       hasWarnedAboutDeprecatedMockComponent = true;
@@ -341,6 +455,13 @@ function mockComponent(module, mockTagName) {
 }
 
 function nativeTouchData(x, y) {
+  if (disableDOMTestUtils) {
+    throw new Error(
+      '`nativeTouchData` was removed from `react-dom/test-utils`. ' +
+        'See https://react.dev/warnings/react-dom-test-utils for more info.',
+    );
+  }
+
   return {
     touches: [{pageX: x, pageY: y}],
   };
@@ -579,6 +700,13 @@ const directDispatchEventTypes = new Set([
  */
 function makeSimulator(eventType) {
   return function (domNode, eventData) {
+    if (disableDOMTestUtils) {
+      throw new Error(
+        '`Simulate` was removed from `react-dom/test-utils`. ' +
+          'See https://react.dev/warnings/react-dom-test-utils for more info.',
+      );
+    }
+
     if (React.isValidElement(domNode)) {
       throw new Error(
         'TestUtils.Simulate expected a DOM node as the first argument but received ' +
diff --git a/packages/react-dom/unstable_testing.classic.fb.js b/packages/react-dom/unstable_testing.classic.fb.js
index 6dd68f3669dc3..9958b22cc3277 100644
--- a/packages/react-dom/unstable_testing.classic.fb.js
+++ b/packages/react-dom/unstable_testing.classic.fb.js
@@ -11,7 +11,6 @@ export {
   createPortal,
   findDOMNode,
   flushSync,
-  hydrate,
   render,
   unmountComponentAtNode,
   unstable_batchedUpdates,
diff --git a/packages/react-dom/unstable_testing.experimental.js b/packages/react-dom/unstable_testing.experimental.js
index a7b01b449639c..2cbd3557cca93 100644
--- a/packages/react-dom/unstable_testing.experimental.js
+++ b/packages/react-dom/unstable_testing.experimental.js
@@ -9,7 +9,6 @@
 
 export {
   createPortal,
-  findDOMNode,
   flushSync,
   unstable_batchedUpdates,
   useFormStatus,
diff --git a/packages/react-dom/unstable_testing.js b/packages/react-dom/unstable_testing.js
index 9729a427e4aa6..1e973748c7cb8 100644
--- a/packages/react-dom/unstable_testing.js
+++ b/packages/react-dom/unstable_testing.js
@@ -9,9 +9,7 @@
 
 export {
   createPortal,
-  findDOMNode,
   flushSync,
-  hydrate,
   render,
   unmountComponentAtNode,
   unstable_batchedUpdates,
diff --git a/packages/react-dom/unstable_testing.stable.js b/packages/react-dom/unstable_testing.stable.js
index 453e8b4fdece7..0b47d34c0acb0 100644
--- a/packages/react-dom/unstable_testing.stable.js
+++ b/packages/react-dom/unstable_testing.stable.js
@@ -9,9 +9,7 @@
 
 export {
   createPortal,
-  findDOMNode,
   flushSync,
-  hydrate,
   render,
   unmountComponentAtNode,
   unstable_batchedUpdates,
diff --git a/packages/react-is/package.json b/packages/react-is/package.json
index da7194b7ad525..07360a88e614f 100644
--- a/packages/react-is/package.json
+++ b/packages/react-is/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-is",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "description": "Brand checking of React Elements.",
   "main": "index.js",
   "sideEffects": false,
diff --git a/packages/react-native-renderer/src/ReactFabric.js b/packages/react-native-renderer/src/ReactFabric.js
index 3c2eff2dbc9bb..6cdb179093b12 100644
--- a/packages/react-native-renderer/src/ReactFabric.js
+++ b/packages/react-native-renderer/src/ReactFabric.js
@@ -20,6 +20,9 @@ import {
   updateContainer,
   injectIntoDevTools,
   getPublicRootInstance,
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
+  defaultOnRecoverableError,
 } from 'react-reconciler/src/ReactFiberReconciler';
 
 import {createPortal as createPortalImpl} from 'react-reconciler/src/ReactPortal';
@@ -43,11 +46,58 @@ import {
 } from './ReactNativePublicCompat';
 import {getPublicInstanceFromInternalInstanceHandle} from './ReactFiberConfigFabric';
 
-// $FlowFixMe[missing-local-annot]
-function onRecoverableError(error) {
-  // TODO: Expose onRecoverableError option to userspace
-  // eslint-disable-next-line react-internal/no-production-logging, react-internal/warning-args
-  console.error(error);
+// Module provided by RN:
+import {ReactFiberErrorDialog} from 'react-native/Libraries/ReactPrivate/ReactNativePrivateInterface';
+
+if (typeof ReactFiberErrorDialog.showErrorDialog !== 'function') {
+  throw new Error(
+    'Expected ReactFiberErrorDialog.showErrorDialog to be a function.',
+  );
+}
+
+function nativeOnUncaughtError(
+  error: mixed,
+  errorInfo: {+componentStack?: ?string},
+): void {
+  const componentStack =
+    errorInfo.componentStack != null ? errorInfo.componentStack : '';
+  const logError = ReactFiberErrorDialog.showErrorDialog({
+    errorBoundary: null,
+    error,
+    componentStack,
+  });
+
+  // Allow injected showErrorDialog() to prevent default console.error logging.
+  // This enables renderers like ReactNative to better manage redbox behavior.
+  if (logError === false) {
+    return;
+  }
+
+  defaultOnUncaughtError(error, errorInfo);
+}
+function nativeOnCaughtError(
+  error: mixed,
+  errorInfo: {
+    +componentStack?: ?string,
+    +errorBoundary?: ?React$Component<any, any>,
+  },
+): void {
+  const errorBoundary = errorInfo.errorBoundary;
+  const componentStack =
+    errorInfo.componentStack != null ? errorInfo.componentStack : '';
+  const logError = ReactFiberErrorDialog.showErrorDialog({
+    errorBoundary,
+    error,
+    componentStack,
+  });
+
+  // Allow injected showErrorDialog() to prevent default console.error logging.
+  // This enables renderers like ReactNative to better manage redbox behavior.
+  if (logError === false) {
+    return;
+  }
+
+  defaultOnCaughtError(error, errorInfo);
 }
 
 function render(
@@ -68,7 +118,9 @@ function render(
       false,
       null,
       '',
-      onRecoverableError,
+      nativeOnUncaughtError,
+      nativeOnCaughtError,
+      defaultOnRecoverableError,
       null,
     );
     roots.set(containerTag, root);
diff --git a/packages/react-native-renderer/src/ReactNativeRenderer.js b/packages/react-native-renderer/src/ReactNativeRenderer.js
index d8eb76bc23a36..5409eb3df4f98 100644
--- a/packages/react-native-renderer/src/ReactNativeRenderer.js
+++ b/packages/react-native-renderer/src/ReactNativeRenderer.js
@@ -20,6 +20,9 @@ import {
   updateContainer,
   injectIntoDevTools,
   getPublicRootInstance,
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
+  defaultOnRecoverableError,
 } from 'react-reconciler/src/ReactFiberReconciler';
 // TODO: direct imports like some-package/src/* are bad. Fix me.
 import {getStackByFiberInDevAndProd} from 'react-reconciler/src/ReactFiberComponentStack';
@@ -47,11 +50,58 @@ import {
   isChildPublicInstance,
 } from './ReactNativePublicCompat';
 
-// $FlowFixMe[missing-local-annot]
-function onRecoverableError(error) {
-  // TODO: Expose onRecoverableError option to userspace
-  // eslint-disable-next-line react-internal/no-production-logging, react-internal/warning-args
-  console.error(error);
+// Module provided by RN:
+import {ReactFiberErrorDialog} from 'react-native/Libraries/ReactPrivate/ReactNativePrivateInterface';
+
+if (typeof ReactFiberErrorDialog.showErrorDialog !== 'function') {
+  throw new Error(
+    'Expected ReactFiberErrorDialog.showErrorDialog to be a function.',
+  );
+}
+
+function nativeOnUncaughtError(
+  error: mixed,
+  errorInfo: {+componentStack?: ?string},
+): void {
+  const componentStack =
+    errorInfo.componentStack != null ? errorInfo.componentStack : '';
+  const logError = ReactFiberErrorDialog.showErrorDialog({
+    errorBoundary: null,
+    error,
+    componentStack,
+  });
+
+  // Allow injected showErrorDialog() to prevent default console.error logging.
+  // This enables renderers like ReactNative to better manage redbox behavior.
+  if (logError === false) {
+    return;
+  }
+
+  defaultOnUncaughtError(error, errorInfo);
+}
+function nativeOnCaughtError(
+  error: mixed,
+  errorInfo: {
+    +componentStack?: ?string,
+    +errorBoundary?: ?React$Component<any, any>,
+  },
+): void {
+  const errorBoundary = errorInfo.errorBoundary;
+  const componentStack =
+    errorInfo.componentStack != null ? errorInfo.componentStack : '';
+  const logError = ReactFiberErrorDialog.showErrorDialog({
+    errorBoundary,
+    error,
+    componentStack,
+  });
+
+  // Allow injected showErrorDialog() to prevent default console.error logging.
+  // This enables renderers like ReactNative to better manage redbox behavior.
+  if (logError === false) {
+    return;
+  }
+
+  defaultOnCaughtError(error, errorInfo);
 }
 
 function render(
@@ -71,7 +121,9 @@ function render(
       false,
       null,
       '',
-      onRecoverableError,
+      nativeOnUncaughtError,
+      nativeOnCaughtError,
+      defaultOnRecoverableError,
       null,
     );
     roots.set(containerTag, root);
diff --git a/packages/react-native-renderer/src/ReactNativeTypes.js b/packages/react-native-renderer/src/ReactNativeTypes.js
index f02b921b6ce7a..0b44ef7f81e39 100644
--- a/packages/react-native-renderer/src/ReactNativeTypes.js
+++ b/packages/react-native-renderer/src/ReactNativeTypes.js
@@ -125,7 +125,7 @@ export type NativeMethods = $ReadOnly<{|
 |}>;
 
 // This validates that INativeMethods and NativeMethods stay in sync using Flow!
-declare var ensureNativeMethodsAreSynced: NativeMethods;
+declare const ensureNativeMethodsAreSynced: NativeMethods;
 (ensureNativeMethodsAreSynced: INativeMethods);
 
 export type HostComponent<T> = AbstractComponent<T, $ReadOnly<NativeMethods>>;
diff --git a/packages/react-native-renderer/src/__tests__/ReactNativeEvents-test.internal.js b/packages/react-native-renderer/src/__tests__/ReactNativeEvents-test.internal.js
index 56a1d6fb7c1a9..f210de5f8c456 100644
--- a/packages/react-native-renderer/src/__tests__/ReactNativeEvents-test.internal.js
+++ b/packages/react-native-renderer/src/__tests__/ReactNativeEvents-test.internal.js
@@ -13,6 +13,7 @@
 let PropTypes;
 let RCTEventEmitter;
 let React;
+let act;
 let ReactNative;
 let ResponderEventPlugin;
 let UIManager;
@@ -67,6 +68,7 @@ beforeEach(() => {
   RCTEventEmitter =
     require('react-native/Libraries/ReactPrivate/ReactNativePrivateInterface').RCTEventEmitter;
   React = require('react');
+  act = require('internal-test-utils').act;
   ReactNative = require('react-native-renderer');
   ResponderEventPlugin =
     require('react-native-renderer/src/legacy-events/ResponderEventPlugin').default;
@@ -77,7 +79,7 @@ beforeEach(() => {
       .ReactNativeViewConfigRegistry.register;
 });
 
-it('fails to register the same event name with different types', () => {
+it('fails to register the same event name with different types', async () => {
   const InvalidEvents = createReactNativeComponentClass('InvalidEvents', () => {
     if (!__DEV__) {
       // Simulate a registration error in prod.
@@ -109,15 +111,15 @@ it('fails to register the same event name with different types', () => {
 
   // The first time this renders,
   // we attempt to register the view config and fail.
-  expect(() => ReactNative.render(<InvalidEvents />, 1)).toThrow(
-    'Event cannot be both direct and bubbling: topChange',
-  );
+  await expect(
+    async () => await act(() => ReactNative.render(<InvalidEvents />, 1)),
+  ).rejects.toThrow('Event cannot be both direct and bubbling: topChange');
 
   // Continue to re-register the config and
   // fail so that we don't mask the above failure.
-  expect(() => ReactNative.render(<InvalidEvents />, 1)).toThrow(
-    'Event cannot be both direct and bubbling: topChange',
-  );
+  await expect(
+    async () => await act(() => ReactNative.render(<InvalidEvents />, 1)),
+  ).rejects.toThrow('Event cannot be both direct and bubbling: topChange');
 });
 
 it('fails if unknown/unsupported event types are dispatched', () => {
diff --git a/packages/react-native-renderer/src/__tests__/ReactNativeMount-test.internal.js b/packages/react-native-renderer/src/__tests__/ReactNativeMount-test.internal.js
index 11b3f66e99620..06604f2d062f9 100644
--- a/packages/react-native-renderer/src/__tests__/ReactNativeMount-test.internal.js
+++ b/packages/react-native-renderer/src/__tests__/ReactNativeMount-test.internal.js
@@ -17,6 +17,7 @@ let createReactNativeComponentClass;
 let UIManager;
 let TextInputState;
 let ReactNativePrivateInterface;
+let act;
 
 const DISPATCH_COMMAND_REQUIRES_HOST_COMPONENT =
   "Warning: dispatchCommand was called with a ref that isn't a " +
@@ -31,6 +32,7 @@ describe('ReactNative', () => {
     jest.resetModules();
 
     React = require('react');
+    act = require('internal-test-utils').act;
     StrictMode = React.StrictMode;
     ReactNative = require('react-native-renderer');
     ReactNativePrivateInterface = require('react-native/Libraries/ReactPrivate/ReactNativePrivateInterface');
@@ -476,7 +478,7 @@ describe('ReactNative', () => {
     );
   });
 
-  it('should throw for text not inside of a <Text> ancestor', () => {
+  it('should throw for text not inside of a <Text> ancestor', async () => {
     const ScrollView = createReactNativeComponentClass('RCTScrollView', () => ({
       validAttributes: {},
       uiViewClassName: 'RCTScrollView',
@@ -490,18 +492,24 @@ describe('ReactNative', () => {
       uiViewClassName: 'RCTView',
     }));
 
-    expect(() => ReactNative.render(<View>this should warn</View>, 11)).toThrow(
+    await expect(async () => {
+      await act(() => ReactNative.render(<View>this should warn</View>, 11));
+    }).rejects.toThrow(
       'Text strings must be rendered within a <Text> component.',
     );
 
-    expect(() =>
-      ReactNative.render(
-        <Text>
-          <ScrollView>hi hello hi</ScrollView>
-        </Text>,
-        11,
-      ),
-    ).toThrow('Text strings must be rendered within a <Text> component.');
+    await expect(async () => {
+      await act(() =>
+        ReactNative.render(
+          <Text>
+            <ScrollView>hi hello hi</ScrollView>
+          </Text>,
+          11,
+        ),
+      );
+    }).rejects.toThrow(
+      'Text strings must be rendered within a <Text> component.',
+    );
   });
 
   it('should not throw for text inside of an indirect <Text> ancestor', () => {
diff --git a/packages/react-noop-renderer/src/createReactNoop.js b/packages/react-noop-renderer/src/createReactNoop.js
index 0470672f4b5f3..af4612f00ddee 100644
--- a/packages/react-noop-renderer/src/createReactNoop.js
+++ b/packages/react-noop-renderer/src/createReactNoop.js
@@ -974,6 +974,8 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
           null,
           false,
           '',
+          NoopRenderer.defaultOnUncaughtError,
+          NoopRenderer.defaultOnCaughtError,
           onRecoverableError,
           null,
         );
@@ -996,6 +998,8 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
         null,
         false,
         '',
+        NoopRenderer.defaultOnUncaughtError,
+        NoopRenderer.defaultOnCaughtError,
         onRecoverableError,
         options && options.unstable_transitionCallbacks
           ? options.unstable_transitionCallbacks
@@ -1028,6 +1032,8 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
         null,
         false,
         '',
+        NoopRenderer.defaultOnUncaughtError,
+        NoopRenderer.defaultOnCaughtError,
         onRecoverableError,
         null,
       );
diff --git a/packages/react-reconciler/package.json b/packages/react-reconciler/package.json
index 4f78d314d3463..27422543681c7 100644
--- a/packages/react-reconciler/package.json
+++ b/packages/react-reconciler/package.json
@@ -26,7 +26,7 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0"
+    "react": "^19.0.0"
   },
   "dependencies": {
     "scheduler": "^0.23.0"
diff --git a/packages/react-reconciler/src/ReactFiber.js b/packages/react-reconciler/src/ReactFiber.js
index 786761ebb4daa..ce909b802530a 100644
--- a/packages/react-reconciler/src/ReactFiber.js
+++ b/packages/react-reconciler/src/ReactFiber.js
@@ -36,7 +36,6 @@ import {
   allowConcurrentByDefault,
   enableTransitionTracing,
   enableDebugTracing,
-  enableFloat,
   enableDO_NOT_USE_disableStrictPassiveEffect,
   enableRenderableContext,
 } from 'shared/ReactFeatureFlags';
@@ -508,14 +507,14 @@ export function createFiberFromTypeAndProps(
       }
     }
   } else if (typeof type === 'string') {
-    if (enableFloat && supportsResources && supportsSingletons) {
+    if (supportsResources && supportsSingletons) {
       const hostContext = getHostContext();
       fiberTag = isHostHoistableType(type, pendingProps, hostContext)
         ? HostHoistable
         : isHostSingletonType(type)
         ? HostSingleton
         : HostComponent;
-    } else if (enableFloat && supportsResources) {
+    } else if (supportsResources) {
       const hostContext = getHostContext();
       fiberTag = isHostHoistableType(type, pendingProps, hostContext)
         ? HostHoistable
@@ -850,12 +849,6 @@ export function createFiberFromText(
   return fiber;
 }
 
-export function createFiberFromHostInstanceForDeletion(): Fiber {
-  const fiber = createFiber(HostComponent, null, null, NoMode);
-  fiber.elementType = 'DELETED';
-  return fiber;
-}
-
 export function createFiberFromDehydratedFragment(
   dehydratedNode: SuspenseInstance,
 ): Fiber {
diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.js b/packages/react-reconciler/src/ReactFiberBeginWork.js
index 7bf979f03e6a0..f6dce003e842f 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.js
@@ -95,7 +95,6 @@ import ReactSharedInternals from 'shared/ReactSharedInternals';
 import {
   debugRenderPhaseSideEffectsForStrictMode,
   disableLegacyContext,
-  disableModulePatternComponents,
   enableProfilerCommitHooks,
   enableProfilerTimer,
   enableScopeAPI,
@@ -105,8 +104,6 @@ import {
   enableTransitionTracing,
   enableLegacyHidden,
   enableCPUSuspense,
-  enableFloat,
-  enableFormActions,
   enableAsyncActions,
   enablePostpone,
   enableRenderableContext,
@@ -143,7 +140,6 @@ import {
 import {
   NoLane,
   NoLanes,
-  SyncLane,
   OffscreenLane,
   DefaultHydrationLane,
   SomeRetryLane,
@@ -239,7 +235,6 @@ import {
   queueHydrationError,
 } from './ReactFiberHydrationContext';
 import {
-  adoptClassInstance,
   constructClassInstance,
   mountClassInstance,
   resumeMountClassInstance,
@@ -269,7 +264,10 @@ import {
   createCapturedValueAtFiber,
   type CapturedValue,
 } from './ReactCapturedValue';
-import {createClassErrorUpdate} from './ReactFiberThrow';
+import {
+  createClassErrorUpdate,
+  initializeClassErrorUpdate,
+} from './ReactFiberThrow';
 import is from 'shared/objectIs';
 import {
   getForksAtLevel,
@@ -1182,10 +1180,18 @@ function updateClassComponent(
         const lane = pickArbitraryLane(renderLanes);
         workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
         // Schedule the error boundary to re-render using updated state
-        const update = createClassErrorUpdate(
+        const root: FiberRoot | null = getWorkInProgressRoot();
+        if (root === null) {
+          throw new Error(
+            'Expected a work-in-progress root. This is a bug in React. Please file an issue.',
+          );
+        }
+        const update = createClassErrorUpdate(lane);
+        initializeClassErrorUpdate(
+          update,
+          root,
           workInProgress,
           createCapturedValueAtFiber(error, workInProgress),
-          lane,
         );
         enqueueCapturedUpdate(workInProgress, update);
         break;
@@ -1544,7 +1550,7 @@ function updateHostComponent(
     workInProgress.flags |= ContentReset;
   }
 
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     const memoizedState = workInProgress.memoizedState;
     if (memoizedState !== null) {
       // This fiber has been upgraded to a stateful component. The only way
@@ -1912,88 +1918,27 @@ function mountIndeterminateComponent(
     }
   }
 
-  if (
-    // Run these checks in production only if the flag is off.
-    // Eventually we'll delete this branch altogether.
-    !disableModulePatternComponents &&
-    typeof value === 'object' &&
-    value !== null &&
-    typeof value.render === 'function' &&
-    value.$$typeof === undefined
-  ) {
-    if (__DEV__) {
-      const componentName = getComponentNameFromType(Component) || 'Unknown';
-      if (!didWarnAboutModulePatternComponent[componentName]) {
-        console.error(
-          'The <%s /> component appears to be a function component that returns a class instance. ' +
-            'Change %s to a class that extends React.Component instead. ' +
-            "If you can't use a class try assigning the prototype on the function as a workaround. " +
-            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
-            'cannot be called with `new` by React.',
-          componentName,
-          componentName,
-          componentName,
-        );
-        didWarnAboutModulePatternComponent[componentName] = true;
-      }
-    }
-
-    // Proceed under the assumption that this is a class instance
-    workInProgress.tag = ClassComponent;
-
-    // Throw out any hooks that were used.
-    workInProgress.memoizedState = null;
-    workInProgress.updateQueue = null;
-
-    // Push context providers early to prevent context stack mismatches.
-    // During mounting we don't know the child context yet as the instance doesn't exist.
-    // We will invalidate the child context in finishClassComponent() right after rendering.
-    let hasContext = false;
-    if (isLegacyContextProvider(Component)) {
-      hasContext = true;
-      pushLegacyContextProvider(workInProgress);
-    } else {
-      hasContext = false;
-    }
-
-    workInProgress.memoizedState =
-      value.state !== null && value.state !== undefined ? value.state : null;
-
-    initializeUpdateQueue(workInProgress);
-
-    adoptClassInstance(workInProgress, value);
-    mountClassInstance(workInProgress, Component, props, renderLanes);
-    return finishClassComponent(
-      null,
-      workInProgress,
-      Component,
-      true,
-      hasContext,
-      renderLanes,
-    );
-  } else {
-    // Proceed under the assumption that this is a function component
-    workInProgress.tag = FunctionComponent;
-    if (__DEV__) {
-      if (disableLegacyContext && Component.contextTypes) {
-        console.error(
-          '%s uses the legacy contextTypes API which is no longer supported. ' +
-            'Use React.createContext() with React.useContext() instead.',
-          getComponentNameFromType(Component) || 'Unknown',
-        );
-      }
+  // Proceed under the assumption that this is a function component
+  workInProgress.tag = FunctionComponent;
+  if (__DEV__) {
+    if (disableLegacyContext && Component.contextTypes) {
+      console.error(
+        '%s uses the legacy contextTypes API which was removed in React 19. ' +
+          'Use React.createContext() with React.useContext() instead.',
+        getComponentNameFromType(Component) || 'Unknown',
+      );
     }
+  }
 
-    if (getIsHydrating() && hasId) {
-      pushMaterializedTreeId(workInProgress);
-    }
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  }
 
-    reconcileChildren(null, workInProgress, value, renderLanes);
-    if (__DEV__) {
-      validateFunctionComponentInDev(workInProgress, Component);
-    }
-    return workInProgress.child;
+  reconcileChildren(null, workInProgress, value, renderLanes);
+  if (__DEV__) {
+    validateFunctionComponentInDev(workInProgress, Component);
   }
+  return workInProgress.child;
 }
 
 function validateFunctionComponentInDev(workInProgress: Fiber, Component: any) {
@@ -2745,18 +2690,7 @@ function mountDehydratedSuspenseComponent(
 ): null | Fiber {
   // During the first pass, we'll bail out and not drill into the children.
   // Instead, we'll leave the content in place and try to hydrate it later.
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    if (__DEV__) {
-      console.error(
-        'Cannot hydrate Suspense in legacy mode. Switch from ' +
-          'ReactDOM.hydrate(element, container) to ' +
-          'ReactDOMClient.hydrateRoot(container, <App />)' +
-          '.render(element) or remove the Suspense components from ' +
-          'the server rendered components.',
-      );
-    }
-    workInProgress.lanes = laneToLanes(SyncLane);
-  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+  if (isSuspenseInstanceFallback(suspenseInstance)) {
     // This is a client-only boundary. Since we won't get any content from the server
     // for this, we need to schedule that at a higher priority based on when it would
     // have timed out. In theory we could render it in this pass but it would have the
@@ -2796,15 +2730,6 @@ function updateDehydratedSuspenseComponent(
     // but after we've already committed once.
     warnIfHydrating();
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null,
-      );
-    }
-
     if (isSuspenseInstanceFallback(suspenseInstance)) {
       // This boundary is in a permanent fallback state. In this case, we'll never
       // get an update and we'll never be able to hydrate the final content. Let's just try the
@@ -4089,7 +4014,7 @@ function beginWork(
     case HostRoot:
       return updateHostRoot(current, workInProgress, renderLanes);
     case HostHoistable:
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         return updateHostHoistable(current, workInProgress, renderLanes);
       }
     // Fall through
diff --git a/packages/react-reconciler/src/ReactFiberClassComponent.js b/packages/react-reconciler/src/ReactFiberClassComponent.js
index f6a095de44146..b64f9f9e626c8 100644
--- a/packages/react-reconciler/src/ReactFiberClassComponent.js
+++ b/packages/react-reconciler/src/ReactFiberClassComponent.js
@@ -413,14 +413,14 @@ function checkClassInstance(workInProgress: Fiber, ctor: any, newProps: any) {
     if (disableLegacyContext) {
       if (ctor.childContextTypes) {
         console.error(
-          '%s uses the legacy childContextTypes API which is no longer supported. ' +
+          '%s uses the legacy childContextTypes API which was removed in React 19. ' +
             'Use React.createContext() instead.',
           name,
         );
       }
       if (ctor.contextTypes) {
         console.error(
-          '%s uses the legacy contextTypes API which is no longer supported. ' +
+          '%s uses the legacy contextTypes API which was removed in React 19. ' +
             'Use React.createContext() with static contextType instead.',
           name,
         );
@@ -1230,7 +1230,6 @@ function updateClassInstance(
 }
 
 export {
-  adoptClassInstance,
   constructClassInstance,
   mountClassInstance,
   resumeMountClassInstance,
diff --git a/packages/react-reconciler/src/ReactFiberCommitWork.js b/packages/react-reconciler/src/ReactFiberCommitWork.js
index 65b8c713c4eee..7b88509b65d65 100644
--- a/packages/react-reconciler/src/ReactFiberCommitWork.js
+++ b/packages/react-reconciler/src/ReactFiberCommitWork.js
@@ -40,7 +40,7 @@ import type {
 } from './ReactFiberTracingMarkerComponent';
 
 import {
-  alwaysThrottleDisappearingFallbacks,
+  alwaysThrottleRetries,
   enableCreateEventHandleAPI,
   enableProfilerTimer,
   enableProfilerCommitHooks,
@@ -52,7 +52,6 @@ import {
   enableCache,
   enableTransitionTracing,
   enableUseEffectEventHook,
-  enableFloat,
   enableLegacyHidden,
   disableStringRefs,
 } from 'shared/ReactFeatureFlags';
@@ -1105,7 +1104,7 @@ function commitLayoutEffectOnFiber(
       break;
     }
     case HostHoistable: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         recursivelyTraverseLayoutEffects(
           finishedRoot,
           finishedWork,
@@ -1509,9 +1508,7 @@ function hideOrUnhideAllChildren(finishedWork: Fiber, isHidden: boolean) {
     while (true) {
       if (
         node.tag === HostComponent ||
-        (enableFloat && supportsResources
-          ? node.tag === HostHoistable
-          : false) ||
+        (supportsResources ? node.tag === HostHoistable : false) ||
         (supportsSingletons ? node.tag === HostSingleton : false)
       ) {
         if (hostSubtreeRoot === null) {
@@ -1733,7 +1730,7 @@ function isHostParent(fiber: Fiber): boolean {
   return (
     fiber.tag === HostComponent ||
     fiber.tag === HostRoot ||
-    (enableFloat && supportsResources ? fiber.tag === HostHoistable : false) ||
+    (supportsResources ? fiber.tag === HostHoistable : false) ||
     (supportsSingletons ? fiber.tag === HostSingleton : false) ||
     fiber.tag === HostPortal
   );
@@ -2011,7 +2008,7 @@ function commitDeletionEffectsOnFiber(
   // that don't modify the stack.
   switch (deletedFiber.tag) {
     case HostHoistable: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         if (!offscreenSubtreeWasHidden) {
           safelyDetachRef(deletedFiber, nearestMountedAncestor);
         }
@@ -2604,7 +2601,7 @@ function commitMutationEffectsOnFiber(
       return;
     }
     case HostHoistable: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         // We cast because we always set the root at the React root and so it cannot be
         // null while we are processing mutation effects
         const hoistableRoot: HoistableRoot = (currentHoistableRoot: any);
@@ -2800,7 +2797,7 @@ function commitMutationEffectsOnFiber(
       return;
     }
     case HostRoot: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         prepareToCommitHoistables();
 
         const previousHoistableRoot = currentHoistableRoot;
@@ -2845,7 +2842,7 @@ function commitMutationEffectsOnFiber(
       return;
     }
     case HostPortal: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         const previousHoistableRoot = currentHoistableRoot;
         currentHoistableRoot = getHoistableRoot(
           finishedWork.stateNode.containerInfo,
@@ -2896,7 +2893,7 @@ function commitMutationEffectsOnFiber(
           current !== null &&
           (current.memoizedState: SuspenseState | null) !== null;
 
-        if (alwaysThrottleDisappearingFallbacks) {
+        if (alwaysThrottleRetries) {
           if (isShowingFallback !== wasShowingFallback) {
             // A fallback is either appearing or disappearing.
             markCommitTimeOfFallback();
@@ -4114,7 +4111,7 @@ function accumulateSuspenseyCommitOnFiber(fiber: Fiber) {
     }
     case HostRoot:
     case HostPortal: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         const previousHoistableRoot = currentHoistableRoot;
         const container: Container = fiber.stateNode.containerInfo;
         currentHoistableRoot = getHoistableRoot(container);
diff --git a/packages/react-reconciler/src/ReactFiberCompleteWork.js b/packages/react-reconciler/src/ReactFiberCompleteWork.js
index e15192e2854a2..89044182672ad 100644
--- a/packages/react-reconciler/src/ReactFiberCompleteWork.js
+++ b/packages/react-reconciler/src/ReactFiberCompleteWork.js
@@ -38,7 +38,6 @@ import {
   enableProfilerTimer,
   enableCache,
   enableTransitionTracing,
-  enableFloat,
   enableRenderableContext,
   passChildrenWhenCloningPersistedNodes,
 } from 'shared/ReactFeatureFlags';
@@ -145,6 +144,7 @@ import {
   resetHydrationState,
   getIsHydrating,
   upgradeHydrationErrorsToRecoverable,
+  emitPendingHydrationWarnings,
 } from './ReactFiberHydrationContext';
 import {
   renderHasNotSuspendedYet,
@@ -894,6 +894,7 @@ function completeDehydratedSuspenseBoundary(
       }
       return false;
     } else {
+      emitPendingHydrationWarnings();
       // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
       // state since we're now exiting out of it. popHydrationState doesn't do that for us.
       resetHydrationState();
@@ -1010,6 +1011,7 @@ function completeWork(
         // that weren't hydrated.
         const wasHydrated = popHydrationState(workInProgress);
         if (wasHydrated) {
+          emitPendingHydrationWarnings();
           // If we hydrated, then we'll need to schedule an update for
           // the commit side-effects on the root.
           markUpdate(workInProgress);
@@ -1051,7 +1053,7 @@ function completeWork(
       return null;
     }
     case HostHoistable: {
-      if (enableFloat && supportsResources) {
+      if (supportsResources) {
         // The branching here is more complicated than you might expect because
         // a HostHoistable sometimes corresponds to a Resource and sometimes
         // corresponds to an Instance. It can also switch during an update.
@@ -1307,9 +1309,7 @@ function completeWork(
         const currentHostContext = getHostContext();
         const wasHydrated = popHydrationState(workInProgress);
         if (wasHydrated) {
-          if (prepareToHydrateHostTextInstance(workInProgress)) {
-            markUpdate(workInProgress);
-          }
+          prepareToHydrateHostTextInstance(workInProgress);
         } else {
           workInProgress.stateNode = createTextInstance(
             newText,
diff --git a/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js b/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js
index 2413e6d986ac7..3707f99f488fb 100644
--- a/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js
+++ b/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js
@@ -43,20 +43,8 @@ export const commitHydratedSuspenseInstance = shim;
 export const clearSuspenseBoundary = shim;
 export const clearSuspenseBoundaryFromContainer = shim;
 export const shouldDeleteUnhydratedTailInstances = shim;
-export const didNotMatchHydratedContainerTextInstance = shim;
-export const didNotMatchHydratedTextInstance = shim;
-export const didNotHydrateInstanceWithinContainer = shim;
-export const didNotHydrateInstanceWithinSuspenseInstance = shim;
-export const didNotHydrateInstance = shim;
-export const didNotFindHydratableInstanceWithinContainer = shim;
-export const didNotFindHydratableTextInstanceWithinContainer = shim;
-export const didNotFindHydratableSuspenseInstanceWithinContainer = shim;
-export const didNotFindHydratableInstanceWithinSuspenseInstance = shim;
-export const didNotFindHydratableTextInstanceWithinSuspenseInstance = shim;
-export const didNotFindHydratableSuspenseInstanceWithinSuspenseInstance = shim;
-export const didNotFindHydratableInstance = shim;
-export const didNotFindHydratableTextInstance = shim;
-export const didNotFindHydratableSuspenseInstance = shim;
-export const errorHydratingContainer = shim;
+export const diffHydratedPropsForDevWarnings = shim;
+export const diffHydratedTextForDevWarnings = shim;
+export const describeHydratableInstanceForDevWarnings = shim;
 export const validateHydratableInstance = shim;
 export const validateHydratableTextInstance = shim;
diff --git a/packages/react-reconciler/src/ReactFiberDevToolsHook.js b/packages/react-reconciler/src/ReactFiberDevToolsHook.js
index abf56e90fabc2..dead0fda4691c 100644
--- a/packages/react-reconciler/src/ReactFiberDevToolsHook.js
+++ b/packages/react-reconciler/src/ReactFiberDevToolsHook.js
@@ -41,7 +41,7 @@ import {
 import {setSuppressWarning} from 'shared/consoleWithStackDev';
 import {disableLogs, reenableLogs} from 'shared/ConsolePatchingDev';
 
-declare var __REACT_DEVTOOLS_GLOBAL_HOOK__: Object | void;
+declare const __REACT_DEVTOOLS_GLOBAL_HOOK__: Object | void;
 
 let rendererID = null;
 let injectedHook = null;
diff --git a/packages/react-reconciler/src/ReactFiberErrorDialog.js b/packages/react-reconciler/src/ReactFiberErrorDialog.js
deleted file mode 100644
index 7baf2f96516fa..0000000000000
--- a/packages/react-reconciler/src/ReactFiberErrorDialog.js
+++ /dev/null
@@ -1,22 +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.
- *
- * @flow
- */
-
-import type {Fiber} from './ReactInternalTypes';
-import type {CapturedValue} from './ReactCapturedValue';
-
-// This module is forked in different environments.
-// By default, return `true` to log errors to the console.
-// Forks can return `false` if this isn't desirable.
-
-export function showErrorDialog(
-  boundary: Fiber,
-  errorInfo: CapturedValue<mixed>,
-): boolean {
-  return true;
-}
diff --git a/packages/react-reconciler/src/ReactFiberErrorLogger.js b/packages/react-reconciler/src/ReactFiberErrorLogger.js
index 14a1ebb352f89..775ca9b20aa92 100644
--- a/packages/react-reconciler/src/ReactFiberErrorLogger.js
+++ b/packages/react-reconciler/src/ReactFiberErrorLogger.js
@@ -7,68 +7,152 @@
  * @flow
  */
 
-import type {Fiber} from './ReactInternalTypes';
+import type {Fiber, FiberRoot} from './ReactInternalTypes';
 import type {CapturedValue} from './ReactCapturedValue';
 
-import {showErrorDialog} from './ReactFiberErrorDialog';
 import getComponentNameFromFiber from 'react-reconciler/src/getComponentNameFromFiber';
-import {HostRoot} from 'react-reconciler/src/ReactWorkTags';
 
-export function logCapturedError(
-  boundary: Fiber,
+import {ClassComponent} from './ReactWorkTags';
+
+import reportGlobalError from 'shared/reportGlobalError';
+
+import ReactSharedInternals from 'shared/ReactSharedInternals';
+const {ReactCurrentActQueue} = ReactSharedInternals;
+
+// Side-channel since I'm not sure we want to make this part of the public API
+let componentName: null | string = null;
+let errorBoundaryName: null | string = null;
+
+export function defaultOnUncaughtError(
+  error: mixed,
+  errorInfo: {+componentStack?: ?string},
+): void {
+  // Overriding this can silence these warnings e.g. for tests.
+  // See https://github.com/facebook/react/pull/13384
+
+  // For uncaught root errors we report them as uncaught to the browser's
+  // onerror callback. This won't have component stacks and the error addendum.
+  // So we add those into a separate console.warn.
+  reportGlobalError(error);
+  if (__DEV__) {
+    const componentStack =
+      errorInfo.componentStack != null ? errorInfo.componentStack : '';
+
+    const componentNameMessage = componentName
+      ? `An error occurred in the <${componentName}> component:`
+      : 'An error occurred in one of your React components:';
+
+    console['warn'](
+      '%s\n%s\n\n%s',
+      componentNameMessage,
+      componentStack || '',
+      'Consider adding an error boundary to your tree to customize error handling behavior.\n' +
+        'Visit https://react.dev/link/error-boundaries to learn more about error boundaries.',
+    );
+  }
+}
+
+export function defaultOnCaughtError(
+  error: mixed,
+  errorInfo: {
+    +componentStack?: ?string,
+    +errorBoundary?: ?React$Component<any, any>,
+  },
+): void {
+  // Overriding this can silence these warnings e.g. for tests.
+  // See https://github.com/facebook/react/pull/13384
+
+  // Caught by error boundary
+  if (__DEV__) {
+    const componentStack =
+      errorInfo.componentStack != null ? errorInfo.componentStack : '';
+
+    const componentNameMessage = componentName
+      ? `The above error occurred in the <${componentName}> component:`
+      : 'The above error occurred in one of your React components:';
+
+    // In development, we provide our own message which includes the component stack
+    // in addition to the error.
+    // Don't transform to our wrapper
+    console['error'](
+      '%o\n\n%s\n%s\n\n%s',
+      error,
+      componentNameMessage,
+      componentStack,
+      `React will try to recreate this component tree from scratch ` +
+        `using the error boundary you provided, ${
+          errorBoundaryName || 'Anonymous'
+        }.`,
+    );
+  } else {
+    // In production, we print the error directly.
+    // This will include the message, the JS stack, and anything the browser wants to show.
+    // We pass the error object instead of custom message so that the browser displays the error natively.
+    console['error'](error); // Don't transform to our wrapper
+  }
+}
+
+export function defaultOnRecoverableError(
+  error: mixed,
+  errorInfo: {+digest?: ?string, +componentStack?: ?string},
+) {
+  reportGlobalError(error);
+}
+
+export function logUncaughtError(
+  root: FiberRoot,
   errorInfo: CapturedValue<mixed>,
 ): void {
   try {
-    const logError = showErrorDialog(boundary, errorInfo);
-
-    // Allow injected showErrorDialog() to prevent default console.error logging.
-    // This enables renderers like ReactNative to better manage redbox behavior.
-    if (logError === false) {
+    if (__DEV__) {
+      componentName = errorInfo.source
+        ? getComponentNameFromFiber(errorInfo.source)
+        : null;
+      errorBoundaryName = null;
+    }
+    const error = (errorInfo.value: any);
+    if (__DEV__ && ReactCurrentActQueue.current !== null) {
+      // For uncaught errors inside act, we track them on the act and then
+      // rethrow them into the test.
+      ReactCurrentActQueue.thrownErrors.push(error);
       return;
     }
+    const onUncaughtError = root.onUncaughtError;
+    onUncaughtError(error, {
+      componentStack: errorInfo.stack,
+    });
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(() => {
+      throw e;
+    });
+  }
+}
 
-    const error = (errorInfo.value: any);
+export function logCaughtError(
+  root: FiberRoot,
+  boundary: Fiber,
+  errorInfo: CapturedValue<mixed>,
+): void {
+  try {
     if (__DEV__) {
-      const source = errorInfo.source;
-      const stack = errorInfo.stack;
-      const componentStack = stack !== null ? stack : '';
-      // TODO: There's no longer a way to silence these warnings e.g. for tests.
-      // See https://github.com/facebook/react/pull/13384
-
-      const componentName = source ? getComponentNameFromFiber(source) : null;
-      const componentNameMessage = componentName
-        ? `The above error occurred in the <${componentName}> component:`
-        : 'The above error occurred in one of your React components:';
-
-      let errorBoundaryMessage;
-      if (boundary.tag === HostRoot) {
-        errorBoundaryMessage =
-          'Consider adding an error boundary to your tree to customize error handling behavior.\n' +
-          'Visit https://react.dev/link/error-boundaries to learn more about error boundaries.';
-      } else {
-        const errorBoundaryName =
-          getComponentNameFromFiber(boundary) || 'Anonymous';
-        errorBoundaryMessage =
-          `React will try to recreate this component tree from scratch ` +
-          `using the error boundary you provided, ${errorBoundaryName}.`;
-      }
-
-      // In development, we provide our own message which includes the component stack
-      // in addition to the error.
-      console['error'](
-        // Don't transform to our wrapper
-        '%o\n\n%s\n%s\n\n%s',
-        error,
-        componentNameMessage,
-        componentStack,
-        errorBoundaryMessage,
-      );
-    } else {
-      // In production, we print the error directly.
-      // This will include the message, the JS stack, and anything the browser wants to show.
-      // We pass the error object instead of custom message so that the browser displays the error natively.
-      console['error'](error); // Don't transform to our wrapper
+      componentName = errorInfo.source
+        ? getComponentNameFromFiber(errorInfo.source)
+        : null;
+      errorBoundaryName = getComponentNameFromFiber(boundary);
     }
+    const error = (errorInfo.value: any);
+    const onCaughtError = root.onCaughtError;
+    onCaughtError(error, {
+      componentStack: errorInfo.stack,
+      errorBoundary:
+        boundary.tag === ClassComponent
+          ? boundary.stateNode // This should always be the case as long as we only have class boundaries
+          : null,
+    });
   } catch (e) {
     // This method must not throw, or React internal state will get messed up.
     // If console.error is overridden, or logCapturedError() shows a dialog that throws,
diff --git a/packages/react-reconciler/src/ReactFiberHooks.js b/packages/react-reconciler/src/ReactFiberHooks.js
index ecb707608ebc4..127656768cf30 100644
--- a/packages/react-reconciler/src/ReactFiberHooks.js
+++ b/packages/react-reconciler/src/ReactFiberHooks.js
@@ -41,7 +41,6 @@ import {
   enableLegacyCache,
   debugRenderPhaseSideEffectsForStrictMode,
   enableAsyncActions,
-  enableFormActions,
   enableUseDeferredValueInitialArg,
 } from 'shared/ReactFeatureFlags';
 import {
@@ -179,10 +178,12 @@ let didWarnAboutMismatchedHooksForComponent;
 let didWarnUncachedGetSnapshot: void | true;
 let didWarnAboutUseWrappedInTryCatch;
 let didWarnAboutAsyncClientComponent;
+let didWarnAboutUseFormState;
 if (__DEV__) {
   didWarnAboutMismatchedHooksForComponent = new Set<string | null>();
   didWarnAboutUseWrappedInTryCatch = new Set<string | null>();
   didWarnAboutAsyncClientComponent = new Set<string | null>();
+  didWarnAboutUseFormState = new Set<string | null>();
 }
 
 export type Hook = {
@@ -387,6 +388,21 @@ function warnOnHookMismatchInDev(currentHookName: HookType): void {
   }
 }
 
+function warnOnUseFormStateInDev(): void {
+  if (__DEV__) {
+    const componentName = getComponentNameFromFiber(currentlyRenderingFiber);
+    if (!didWarnAboutUseFormState.has(componentName)) {
+      didWarnAboutUseFormState.add(componentName);
+
+      console.error(
+        'ReactDOM.useFormState has been deprecated and replaced by ' +
+          'React.useActionState. Please update %s to use React.useActionState.',
+        componentName,
+      );
+    }
+  }
+}
+
 function warnIfAsyncClientComponent(Component: Function) {
   if (__DEV__) {
     // This dev-only check only works for detecting native async functions,
@@ -811,7 +827,7 @@ export function renderTransitionAwareHostComponentWithHooks(
   workInProgress: Fiber,
   lanes: Lanes,
 ): TransitionStatus {
-  if (!(enableFormActions && enableAsyncActions)) {
+  if (!enableAsyncActions) {
     throw new Error('Not implemented.');
   }
   return renderWithHooks(
@@ -825,7 +841,7 @@ export function renderTransitionAwareHostComponentWithHooks(
 }
 
 export function TransitionAwareHostComponent(): TransitionStatus {
-  if (!(enableFormActions && enableAsyncActions)) {
+  if (!enableAsyncActions) {
     throw new Error('Not implemented.');
   }
   const dispatcher = ReactCurrentDispatcher.current;
@@ -1890,9 +1906,9 @@ function rerenderOptimistic<S, A>(
   return [passthrough, dispatch];
 }
 
-// useFormState actions run sequentially, because each action receives the
+// useActionState actions run sequentially, because each action receives the
 // previous state as an argument. We store pending actions on a queue.
-type FormStateActionQueue<S, P> = {
+type ActionStateQueue<S, P> = {
   // This is the most recent state returned from an action. It's updated as
   // soon as the action finishes running.
   state: Awaited<S>,
@@ -1903,18 +1919,18 @@ type FormStateActionQueue<S, P> = {
   action: (Awaited<S>, P) => S,
   // This is a circular linked list of pending action payloads. It incudes the
   // action that is currently running.
-  pending: FormStateActionQueueNode<P> | null,
+  pending: ActionStateQueueNode<P> | null,
 };
 
-type FormStateActionQueueNode<P> = {
+type ActionStateQueueNode<P> = {
   payload: P,
   // This is never null because it's part of a circular linked list.
-  next: FormStateActionQueueNode<P>,
+  next: ActionStateQueueNode<P>,
 };
 
-function dispatchFormState<S, P>(
+function dispatchActionState<S, P>(
   fiber: Fiber,
-  actionQueue: FormStateActionQueue<S, P>,
+  actionQueue: ActionStateQueue<S, P>,
   setPendingState: boolean => void,
   setState: Dispatch<S | Awaited<S>>,
   payload: P,
@@ -1926,13 +1942,13 @@ function dispatchFormState<S, P>(
   if (last === null) {
     // There are no pending actions; this is the first one. We can run
     // it immediately.
-    const newLast: FormStateActionQueueNode<P> = {
+    const newLast: ActionStateQueueNode<P> = {
       payload,
       next: (null: any), // circular
     };
     newLast.next = actionQueue.pending = newLast;
 
-    runFormStateAction(
+    runActionStateAction(
       actionQueue,
       (setPendingState: any),
       (setState: any),
@@ -1941,7 +1957,7 @@ function dispatchFormState<S, P>(
   } else {
     // There's already an action running. Add to the queue.
     const first = last.next;
-    const newLast: FormStateActionQueueNode<P> = {
+    const newLast: ActionStateQueueNode<P> = {
       payload,
       next: first,
     };
@@ -1949,8 +1965,8 @@ function dispatchFormState<S, P>(
   }
 }
 
-function runFormStateAction<S, P>(
-  actionQueue: FormStateActionQueue<S, P>,
+function runActionStateAction<S, P>(
+  actionQueue: ActionStateQueue<S, P>,
   setPendingState: boolean => void,
   setState: Dispatch<S | Awaited<S>>,
   payload: P,
@@ -1988,14 +2004,14 @@ function runFormStateAction<S, P>(
       thenable.then(
         (nextState: Awaited<S>) => {
           actionQueue.state = nextState;
-          finishRunningFormStateAction(
+          finishRunningActionStateAction(
             actionQueue,
             (setPendingState: any),
             (setState: any),
           );
         },
         () =>
-          finishRunningFormStateAction(
+          finishRunningActionStateAction(
             actionQueue,
             (setPendingState: any),
             (setState: any),
@@ -2008,14 +2024,14 @@ function runFormStateAction<S, P>(
 
       const nextState = ((returnValue: any): Awaited<S>);
       actionQueue.state = nextState;
-      finishRunningFormStateAction(
+      finishRunningActionStateAction(
         actionQueue,
         (setPendingState: any),
         (setState: any),
       );
     }
   } catch (error) {
-    // This is a trick to get the `useFormState` hook to rethrow the error.
+    // This is a trick to get the `useActionState` hook to rethrow the error.
     // When it unwraps the thenable with the `use` algorithm, the error
     // will be thrown.
     const rejectedThenable: S = ({
@@ -2025,7 +2041,7 @@ function runFormStateAction<S, P>(
       // $FlowFixMe: Not sure why this doesn't work
     }: RejectedThenable<Awaited<S>>);
     setState(rejectedThenable);
-    finishRunningFormStateAction(
+    finishRunningActionStateAction(
       actionQueue,
       (setPendingState: any),
       (setState: any),
@@ -2049,8 +2065,8 @@ function runFormStateAction<S, P>(
   }
 }
 
-function finishRunningFormStateAction<S, P>(
-  actionQueue: FormStateActionQueue<S, P>,
+function finishRunningActionStateAction<S, P>(
+  actionQueue: ActionStateQueue<S, P>,
   setPendingState: Dispatch<S | Awaited<S>>,
   setState: Dispatch<S | Awaited<S>>,
 ) {
@@ -2068,7 +2084,7 @@ function finishRunningFormStateAction<S, P>(
       last.next = next;
 
       // Run the next action.
-      runFormStateAction(
+      runActionStateAction(
         actionQueue,
         (setPendingState: any),
         (setState: any),
@@ -2078,11 +2094,11 @@ function finishRunningFormStateAction<S, P>(
   }
 }
 
-function formStateReducer<S>(oldState: S, newState: S): S {
+function actionStateReducer<S>(oldState: S, newState: S): S {
   return newState;
 }
 
-function mountFormState<S, P>(
+function mountActionState<S, P>(
   action: (Awaited<S>, P) => S,
   initialStateProp: Awaited<S>,
   permalink?: string,
@@ -2114,7 +2130,7 @@ function mountFormState<S, P>(
     pending: null,
     lanes: NoLanes,
     dispatch: (null: any),
-    lastRenderedReducer: formStateReducer,
+    lastRenderedReducer: actionStateReducer,
     lastRenderedState: initialState,
   };
   stateHook.queue = stateQueue;
@@ -2143,14 +2159,14 @@ function mountFormState<S, P>(
   // but different because the actions are run sequentially, and they run in
   // an event instead of during render.
   const actionQueueHook = mountWorkInProgressHook();
-  const actionQueue: FormStateActionQueue<S, P> = {
+  const actionQueue: ActionStateQueue<S, P> = {
     state: initialState,
     dispatch: (null: any), // circular
     action,
     pending: null,
   };
   actionQueueHook.queue = actionQueue;
-  const dispatch = (dispatchFormState: any).bind(
+  const dispatch = (dispatchActionState: any).bind(
     null,
     currentlyRenderingFiber,
     actionQueue,
@@ -2167,14 +2183,14 @@ function mountFormState<S, P>(
   return [initialState, dispatch, false];
 }
 
-function updateFormState<S, P>(
+function updateActionState<S, P>(
   action: (Awaited<S>, P) => S,
   initialState: Awaited<S>,
   permalink?: string,
 ): [Awaited<S>, (P) => void, boolean] {
   const stateHook = updateWorkInProgressHook();
   const currentStateHook = ((currentHook: any): Hook);
-  return updateFormStateImpl(
+  return updateActionStateImpl(
     stateHook,
     currentStateHook,
     action,
@@ -2183,7 +2199,7 @@ function updateFormState<S, P>(
   );
 }
 
-function updateFormStateImpl<S, P>(
+function updateActionStateImpl<S, P>(
   stateHook: Hook,
   currentStateHook: Hook,
   action: (Awaited<S>, P) => S,
@@ -2193,7 +2209,7 @@ function updateFormStateImpl<S, P>(
   const [actionResult] = updateReducerImpl<S | Thenable<S>, S | Thenable<S>>(
     stateHook,
     currentStateHook,
-    formStateReducer,
+    actionStateReducer,
   );
 
   const [isPending] = updateState(false);
@@ -2217,7 +2233,7 @@ function updateFormStateImpl<S, P>(
     currentlyRenderingFiber.flags |= PassiveEffect;
     pushEffect(
       HookHasEffect | HookPassive,
-      formStateActionEffect.bind(null, actionQueue, action),
+      actionStateActionEffect.bind(null, actionQueue, action),
       createEffectInstance(),
       null,
     );
@@ -2226,19 +2242,19 @@ function updateFormStateImpl<S, P>(
   return [state, dispatch, isPending];
 }
 
-function formStateActionEffect<S, P>(
-  actionQueue: FormStateActionQueue<S, P>,
+function actionStateActionEffect<S, P>(
+  actionQueue: ActionStateQueue<S, P>,
   action: (Awaited<S>, P) => S,
 ): void {
   actionQueue.action = action;
 }
 
-function rerenderFormState<S, P>(
+function rerenderActionState<S, P>(
   action: (Awaited<S>, P) => S,
   initialState: Awaited<S>,
   permalink?: string,
 ): [Awaited<S>, (P) => void, boolean] {
-  // Unlike useState, useFormState doesn't support render phase updates.
+  // Unlike useState, useActionState doesn't support render phase updates.
   // Also unlike useState, we need to replay all pending updates again in case
   // the passthrough value changed.
   //
@@ -2250,7 +2266,7 @@ function rerenderFormState<S, P>(
 
   if (currentStateHook !== null) {
     // This is an update. Process the update queue.
-    return updateFormStateImpl(
+    return updateActionStateImpl(
       stateHook,
       currentStateHook,
       action,
@@ -2259,6 +2275,8 @@ function rerenderFormState<S, P>(
     );
   }
 
+  updateWorkInProgressHook(); // State
+
   // This is a mount. No updates to process.
   const state: Awaited<S> = stateHook.memoizedState;
 
@@ -2962,11 +2980,6 @@ export function startHostTransition<F>(
   callback: F => mixed,
   formData: F,
 ): void {
-  if (!enableFormActions) {
-    // Not implemented.
-    return;
-  }
-
   if (!enableAsyncActions) {
     // Form actions are enabled, but async actions are not. Call the function,
     // but don't handle any pending or error states.
@@ -3087,7 +3100,7 @@ function rerenderTransition(): [
 }
 
 function useHostTransitionStatus(): TransitionStatus {
-  if (!(enableFormActions && enableAsyncActions)) {
+  if (!enableAsyncActions) {
     throw new Error('Not implemented.');
   }
   const status: TransitionStatus | null = readContext(HostTransitionContext);
@@ -3510,10 +3523,11 @@ if (enableUseMemoCacheHook) {
 if (enableUseEffectEventHook) {
   (ContextOnlyDispatcher: Dispatcher).useEffectEvent = throwInvalidHookError;
 }
-if (enableFormActions && enableAsyncActions) {
+if (enableAsyncActions) {
   (ContextOnlyDispatcher: Dispatcher).useHostTransitionStatus =
     throwInvalidHookError;
   (ContextOnlyDispatcher: Dispatcher).useFormState = throwInvalidHookError;
+  (ContextOnlyDispatcher: Dispatcher).useActionState = throwInvalidHookError;
 }
 if (enableAsyncActions) {
   (ContextOnlyDispatcher: Dispatcher).useOptimistic = throwInvalidHookError;
@@ -3548,10 +3562,11 @@ if (enableUseMemoCacheHook) {
 if (enableUseEffectEventHook) {
   (HooksDispatcherOnMount: Dispatcher).useEffectEvent = mountEvent;
 }
-if (enableFormActions && enableAsyncActions) {
+if (enableAsyncActions) {
   (HooksDispatcherOnMount: Dispatcher).useHostTransitionStatus =
     useHostTransitionStatus;
-  (HooksDispatcherOnMount: Dispatcher).useFormState = mountFormState;
+  (HooksDispatcherOnMount: Dispatcher).useFormState = mountActionState;
+  (HooksDispatcherOnMount: Dispatcher).useActionState = mountActionState;
 }
 if (enableAsyncActions) {
   (HooksDispatcherOnMount: Dispatcher).useOptimistic = mountOptimistic;
@@ -3586,10 +3601,11 @@ if (enableUseMemoCacheHook) {
 if (enableUseEffectEventHook) {
   (HooksDispatcherOnUpdate: Dispatcher).useEffectEvent = updateEvent;
 }
-if (enableFormActions && enableAsyncActions) {
+if (enableAsyncActions) {
   (HooksDispatcherOnUpdate: Dispatcher).useHostTransitionStatus =
     useHostTransitionStatus;
-  (HooksDispatcherOnUpdate: Dispatcher).useFormState = updateFormState;
+  (HooksDispatcherOnUpdate: Dispatcher).useFormState = updateActionState;
+  (HooksDispatcherOnUpdate: Dispatcher).useActionState = updateActionState;
 }
 if (enableAsyncActions) {
   (HooksDispatcherOnUpdate: Dispatcher).useOptimistic = updateOptimistic;
@@ -3624,10 +3640,11 @@ if (enableUseMemoCacheHook) {
 if (enableUseEffectEventHook) {
   (HooksDispatcherOnRerender: Dispatcher).useEffectEvent = updateEvent;
 }
-if (enableFormActions && enableAsyncActions) {
+if (enableAsyncActions) {
   (HooksDispatcherOnRerender: Dispatcher).useHostTransitionStatus =
     useHostTransitionStatus;
-  (HooksDispatcherOnRerender: Dispatcher).useFormState = rerenderFormState;
+  (HooksDispatcherOnRerender: Dispatcher).useFormState = rerenderActionState;
+  (HooksDispatcherOnRerender: Dispatcher).useActionState = rerenderActionState;
 }
 if (enableAsyncActions) {
   (HooksDispatcherOnRerender: Dispatcher).useOptimistic = rerenderOptimistic;
@@ -3809,7 +3826,7 @@ if (__DEV__) {
         return mountEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (HooksDispatcherOnMountInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (HooksDispatcherOnMountInDEV: Dispatcher).useFormState =
@@ -3820,7 +3837,17 @@ if (__DEV__) {
       ): [Awaited<S>, (P) => void, boolean] {
         currentHookNameInDev = 'useFormState';
         mountHookTypesDev();
-        return mountFormState(action, initialState, permalink);
+        return mountActionState(action, initialState, permalink);
+      };
+    (HooksDispatcherOnMountInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        mountHookTypesDev();
+        return mountActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
@@ -3979,7 +4006,7 @@ if (__DEV__) {
         return mountEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (HooksDispatcherOnMountWithHookTypesInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (HooksDispatcherOnMountWithHookTypesInDEV: Dispatcher).useFormState =
@@ -3990,7 +4017,18 @@ if (__DEV__) {
       ): [Awaited<S>, (P) => void, boolean] {
         currentHookNameInDev = 'useFormState';
         updateHookTypesDev();
-        return mountFormState(action, initialState, permalink);
+        warnOnUseFormStateInDev();
+        return mountActionState(action, initialState, permalink);
+      };
+    (HooksDispatcherOnMountWithHookTypesInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        updateHookTypesDev();
+        return mountActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
@@ -4151,7 +4189,7 @@ if (__DEV__) {
         return updateEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (HooksDispatcherOnUpdateInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (HooksDispatcherOnUpdateInDEV: Dispatcher).useFormState =
@@ -4162,7 +4200,18 @@ if (__DEV__) {
       ): [Awaited<S>, (P) => void, boolean] {
         currentHookNameInDev = 'useFormState';
         updateHookTypesDev();
-        return updateFormState(action, initialState, permalink);
+        warnOnUseFormStateInDev();
+        return updateActionState(action, initialState, permalink);
+      };
+    (HooksDispatcherOnUpdateInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        updateHookTypesDev();
+        return updateActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
@@ -4323,7 +4372,7 @@ if (__DEV__) {
         return updateEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (HooksDispatcherOnRerenderInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (HooksDispatcherOnRerenderInDEV: Dispatcher).useFormState =
@@ -4334,7 +4383,18 @@ if (__DEV__) {
       ): [Awaited<S>, (P) => void, boolean] {
         currentHookNameInDev = 'useFormState';
         updateHookTypesDev();
-        return rerenderFormState(action, initialState, permalink);
+        warnOnUseFormStateInDev();
+        return rerenderActionState(action, initialState, permalink);
+      };
+    (HooksDispatcherOnRerenderInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        updateHookTypesDev();
+        return rerenderActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
@@ -4516,7 +4576,7 @@ if (__DEV__) {
         return mountEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (InvalidNestedHooksDispatcherOnMountInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (InvalidNestedHooksDispatcherOnMountInDEV: Dispatcher).useFormState =
@@ -4528,7 +4588,18 @@ if (__DEV__) {
         currentHookNameInDev = 'useFormState';
         warnInvalidHookAccess();
         mountHookTypesDev();
-        return mountFormState(action, initialState, permalink);
+        return mountActionState(action, initialState, permalink);
+      };
+    (InvalidNestedHooksDispatcherOnMountInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
@@ -4714,7 +4785,7 @@ if (__DEV__) {
         return updateEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (InvalidNestedHooksDispatcherOnUpdateInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (InvalidNestedHooksDispatcherOnUpdateInDEV: Dispatcher).useFormState =
@@ -4726,7 +4797,18 @@ if (__DEV__) {
         currentHookNameInDev = 'useFormState';
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateFormState(action, initialState, permalink);
+        return updateActionState(action, initialState, permalink);
+      };
+    (InvalidNestedHooksDispatcherOnUpdateInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
@@ -4912,7 +4994,7 @@ if (__DEV__) {
         return updateEvent(callback);
       };
   }
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     (InvalidNestedHooksDispatcherOnRerenderInDEV: Dispatcher).useHostTransitionStatus =
       useHostTransitionStatus;
     (InvalidNestedHooksDispatcherOnRerenderInDEV: Dispatcher).useFormState =
@@ -4924,7 +5006,18 @@ if (__DEV__) {
         currentHookNameInDev = 'useFormState';
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return rerenderFormState(action, initialState, permalink);
+        return rerenderActionState(action, initialState, permalink);
+      };
+    (InvalidNestedHooksDispatcherOnRerenderInDEV: Dispatcher).useActionState =
+      function useActionState<S, P>(
+        action: (Awaited<S>, P) => S,
+        initialState: Awaited<S>,
+        permalink?: string,
+      ): [Awaited<S>, (P) => void, boolean] {
+        currentHookNameInDev = 'useActionState';
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderActionState(action, initialState, permalink);
       };
   }
   if (enableAsyncActions) {
diff --git a/packages/react-reconciler/src/ReactFiberHostContext.js b/packages/react-reconciler/src/ReactFiberHostContext.js
index 0b64be766a95b..f930799f56387 100644
--- a/packages/react-reconciler/src/ReactFiberHostContext.js
+++ b/packages/react-reconciler/src/ReactFiberHostContext.js
@@ -24,7 +24,7 @@ import {
 } from './ReactFiberConfig';
 import {createCursor, push, pop} from './ReactFiberStack';
 import {REACT_CONTEXT_TYPE} from 'shared/ReactSymbols';
-import {enableAsyncActions, enableFormActions} from 'shared/ReactFeatureFlags';
+import {enableAsyncActions} from 'shared/ReactFeatureFlags';
 
 const contextStackCursor: StackCursor<HostContext | null> = createCursor(null);
 const contextFiberStackCursor: StackCursor<Fiber | null> = createCursor(null);
@@ -110,7 +110,7 @@ function getHostContext(): HostContext {
 }
 
 function pushHostContext(fiber: Fiber): void {
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     const stateHook: Hook | null = fiber.memoizedState;
     if (stateHook !== null) {
       // Only provide context if this fiber has been upgraded by a host
@@ -139,7 +139,7 @@ function popHostContext(fiber: Fiber): void {
     pop(contextFiberStackCursor, fiber);
   }
 
-  if (enableFormActions && enableAsyncActions) {
+  if (enableAsyncActions) {
     if (hostTransitionProviderCursor.current === fiber) {
       // Do not pop unless this Fiber provided the current context. This is mostly
       // a performance optimization, but conveniently it also prevents a potential
diff --git a/packages/react-reconciler/src/ReactFiberHotReloading.js b/packages/react-reconciler/src/ReactFiberHotReloading.js
index 090f1311b4453..6f58d5608b8cf 100644
--- a/packages/react-reconciler/src/ReactFiberHotReloading.js
+++ b/packages/react-reconciler/src/ReactFiberHotReloading.js
@@ -14,7 +14,6 @@ import type {Fiber, FiberRoot} from './ReactInternalTypes';
 import type {Instance} from './ReactFiberConfig';
 import type {ReactNodeList} from 'shared/ReactTypes';
 
-import {enableFloat} from 'shared/ReactFeatureFlags';
 import {
   flushSync,
   scheduleUpdateOnFiber,
@@ -468,7 +467,7 @@ function findChildHostInstancesForFiberShallowly(
     while (true) {
       if (
         node.tag === HostComponent ||
-        (enableFloat ? node.tag === HostHoistable : false) ||
+        node.tag === HostHoistable ||
         (supportsSingletons ? node.tag === HostSingleton : false)
       ) {
         // We got a match.
diff --git a/packages/react-reconciler/src/ReactFiberHydrationContext.js b/packages/react-reconciler/src/ReactFiberHydrationContext.js
index 90d87e13d7b33..e3fe81641ced6 100644
--- a/packages/react-reconciler/src/ReactFiberHydrationContext.js
+++ b/packages/react-reconciler/src/ReactFiberHydrationContext.js
@@ -8,7 +8,6 @@
  */
 
 import type {Fiber} from './ReactInternalTypes';
-import {NoMode, ConcurrentMode} from './ReactTypeOfMode';
 import type {
   Instance,
   TextInstance,
@@ -20,27 +19,17 @@ import type {
 import type {SuspenseState} from './ReactFiberSuspenseComponent';
 import type {TreeContext} from './ReactFiberTreeContext';
 import type {CapturedValue} from './ReactCapturedValue';
+import type {HydrationDiffNode} from './ReactFiberHydrationDiffs';
 
 import {
   HostComponent,
   HostSingleton,
-  HostText,
   HostRoot,
   SuspenseComponent,
 } from './ReactWorkTags';
-import {
-  ChildDeletion,
-  Placement,
-  Hydrating,
-  NoFlags,
-  DidCapture,
-} from './ReactFiberFlags';
-import {enableClientRenderFallbackOnTextMismatch} from 'shared/ReactFeatureFlags';
+import {favorSafetyOverHydrationPerf} from 'shared/ReactFeatureFlags';
 
-import {
-  createFiberFromHostInstanceForDeletion,
-  createFiberFromDehydratedFragment,
-} from './ReactFiber';
+import {createFiberFromDehydratedFragment} from './ReactFiber';
 import {
   shouldSetTextContent,
   supportsHydration,
@@ -50,24 +39,13 @@ import {
   getFirstHydratableChildWithinContainer,
   getFirstHydratableChildWithinSuspenseInstance,
   hydrateInstance,
+  diffHydratedPropsForDevWarnings,
+  describeHydratableInstanceForDevWarnings,
   hydrateTextInstance,
+  diffHydratedTextForDevWarnings,
   hydrateSuspenseInstance,
   getNextHydratableInstanceAfterSuspenseInstance,
   shouldDeleteUnhydratedTailInstances,
-  didNotMatchHydratedContainerTextInstance,
-  didNotMatchHydratedTextInstance,
-  didNotHydrateInstanceWithinContainer,
-  didNotHydrateInstanceWithinSuspenseInstance,
-  didNotHydrateInstance,
-  didNotFindHydratableInstanceWithinContainer,
-  didNotFindHydratableTextInstanceWithinContainer,
-  didNotFindHydratableSuspenseInstanceWithinContainer,
-  didNotFindHydratableInstanceWithinSuspenseInstance,
-  didNotFindHydratableTextInstanceWithinSuspenseInstance,
-  didNotFindHydratableSuspenseInstanceWithinSuspenseInstance,
-  didNotFindHydratableInstance,
-  didNotFindHydratableTextInstance,
-  didNotFindHydratableSuspenseInstance,
   resolveSingletonInstance,
   canHydrateInstance,
   canHydrateTextInstance,
@@ -84,6 +62,7 @@ import {
 } from './ReactFiberTreeContext';
 import {queueRecoverableErrors} from './ReactFiberWorkLoop';
 import {getRootHostContainer, getHostContext} from './ReactFiberHostContext';
+import {describeDiff} from './ReactFiberHydrationDiffs';
 
 // The deepest Fiber on the stack involved in a hydration context.
 // This may have been an insertion or a hydration.
@@ -95,11 +74,64 @@ let isHydrating: boolean = false;
 // due to earlier mismatches or a suspended fiber.
 let didSuspendOrErrorDEV: boolean = false;
 
+// Hydration differences found that haven't yet been logged.
+let hydrationDiffRootDEV: null | HydrationDiffNode = null;
+
 // Hydration errors that were thrown inside this boundary
 let hydrationErrors: Array<CapturedValue<mixed>> | null = null;
 
 let rootOrSingletonContext = false;
 
+// Builds a common ancestor tree from the root down for collecting diffs.
+function buildHydrationDiffNode(
+  fiber: Fiber,
+  distanceFromLeaf: number,
+): HydrationDiffNode {
+  if (fiber.return === null) {
+    // We're at the root.
+    if (hydrationDiffRootDEV === null) {
+      hydrationDiffRootDEV = {
+        fiber: fiber,
+        children: [],
+        serverProps: undefined,
+        serverTail: [],
+        distanceFromLeaf: distanceFromLeaf,
+      };
+    } else if (hydrationDiffRootDEV.fiber !== fiber) {
+      throw new Error(
+        'Saw multiple hydration diff roots in a pass. This is a bug in React.',
+      );
+    } else if (hydrationDiffRootDEV.distanceFromLeaf > distanceFromLeaf) {
+      hydrationDiffRootDEV.distanceFromLeaf = distanceFromLeaf;
+    }
+    return hydrationDiffRootDEV;
+  }
+  const siblings = buildHydrationDiffNode(
+    fiber.return,
+    distanceFromLeaf + 1,
+  ).children;
+  // The same node may already exist in the parent. Since we currently always render depth first
+  // and rerender if we suspend or terminate early, if a shared ancestor was added we should still
+  // be inside of that shared ancestor which means it was the last one to be added. If this changes
+  // we may have to scan the whole set.
+  if (siblings.length > 0 && siblings[siblings.length - 1].fiber === fiber) {
+    const existing = siblings[siblings.length - 1];
+    if (existing.distanceFromLeaf > distanceFromLeaf) {
+      existing.distanceFromLeaf = distanceFromLeaf;
+    }
+    return existing;
+  }
+  const newNode: HydrationDiffNode = {
+    fiber: fiber,
+    children: [],
+    serverProps: undefined,
+    serverTail: [],
+    distanceFromLeaf: distanceFromLeaf,
+  };
+  siblings.push(newNode);
+  return newNode;
+}
+
 function warnIfHydrating() {
   if (__DEV__) {
     if (isHydrating) {
@@ -128,6 +160,7 @@ function enterHydrationState(fiber: Fiber): boolean {
   isHydrating = true;
   hydrationErrors = null;
   didSuspendOrErrorDEV = false;
+  hydrationDiffRootDEV = null;
   rootOrSingletonContext = true;
   return true;
 }
@@ -146,6 +179,7 @@ function reenterHydrationStateFromDehydratedSuspenseInstance(
   isHydrating = true;
   hydrationErrors = null;
   didSuspendOrErrorDEV = false;
+  hydrationDiffRootDEV = null;
   rootOrSingletonContext = false;
   if (treeContext !== null) {
     restoreSuspendedTreeContext(fiber, treeContext);
@@ -153,63 +187,10 @@ function reenterHydrationStateFromDehydratedSuspenseInstance(
   return true;
 }
 
-function warnUnhydratedInstance(
-  returnFiber: Fiber,
-  instance: HydratableInstance,
-) {
-  if (__DEV__) {
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        didNotHydrateInstanceWithinContainer(
-          returnFiber.stateNode.containerInfo,
-          instance,
-        );
-        break;
-      }
-      case HostSingleton:
-      case HostComponent: {
-        const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-        didNotHydrateInstance(
-          returnFiber.type,
-          returnFiber.memoizedProps,
-          returnFiber.stateNode,
-          instance,
-          // TODO: Delete this argument when we remove the legacy root API.
-          isConcurrentMode,
-        );
-        break;
-      }
-      case SuspenseComponent: {
-        const suspenseState: SuspenseState = returnFiber.memoizedState;
-        if (suspenseState.dehydrated !== null)
-          didNotHydrateInstanceWithinSuspenseInstance(
-            suspenseState.dehydrated,
-            instance,
-          );
-        break;
-      }
-    }
-  }
-}
-
-function deleteHydratableInstance(
-  returnFiber: Fiber,
-  instance: HydratableInstance,
+function warnNonHydratedInstance(
+  fiber: Fiber,
+  rejectedCandidate: null | HydratableInstance,
 ) {
-  const childToDelete = createFiberFromHostInstanceForDeletion();
-  childToDelete.stateNode = instance;
-  childToDelete.return = returnFiber;
-
-  const deletions = returnFiber.deletions;
-  if (deletions === null) {
-    returnFiber.deletions = [childToDelete];
-    returnFiber.flags |= ChildDeletion;
-  } else {
-    deletions.push(childToDelete);
-  }
-}
-
-function warnNonHydratedInstance(returnFiber: Fiber, fiber: Fiber) {
   if (__DEV__) {
     if (didSuspendOrErrorDEV) {
       // Inside a boundary that already suspended. We're currently rendering the
@@ -218,123 +199,23 @@ function warnNonHydratedInstance(returnFiber: Fiber, fiber: Fiber) {
       return;
     }
 
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        const parentContainer = returnFiber.stateNode.containerInfo;
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent:
-            const type = fiber.type;
-            const props = fiber.pendingProps;
-            didNotFindHydratableInstanceWithinContainer(
-              parentContainer,
-              type,
-              props,
-            );
-            break;
-          case HostText:
-            const text = fiber.pendingProps;
-            didNotFindHydratableTextInstanceWithinContainer(
-              parentContainer,
-              text,
-            );
-            break;
-          case SuspenseComponent:
-            didNotFindHydratableSuspenseInstanceWithinContainer(
-              parentContainer,
-            );
-            break;
-        }
-        break;
-      }
-      case HostSingleton:
-      case HostComponent: {
-        const parentType = returnFiber.type;
-        const parentProps = returnFiber.memoizedProps;
-        const parentInstance = returnFiber.stateNode;
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent: {
-            const type = fiber.type;
-            const props = fiber.pendingProps;
-            const isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
-            didNotFindHydratableInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              type,
-              props,
-              // TODO: Delete this argument when we remove the legacy root API.
-              isConcurrentMode,
-            );
-            break;
-          }
-          case HostText: {
-            const text = fiber.pendingProps;
-            const isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
-            didNotFindHydratableTextInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              text,
-              // TODO: Delete this argument when we remove the legacy root API.
-              isConcurrentMode,
-            );
-            break;
-          }
-          case SuspenseComponent: {
-            didNotFindHydratableSuspenseInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-            );
-            break;
-          }
-        }
-        break;
-      }
-      case SuspenseComponent: {
-        const suspenseState: SuspenseState = returnFiber.memoizedState;
-        const parentInstance = suspenseState.dehydrated;
-        if (parentInstance !== null)
-          switch (fiber.tag) {
-            case HostSingleton:
-            case HostComponent:
-              const type = fiber.type;
-              const props = fiber.pendingProps;
-              didNotFindHydratableInstanceWithinSuspenseInstance(
-                parentInstance,
-                type,
-                props,
-              );
-              break;
-            case HostText:
-              const text = fiber.pendingProps;
-              didNotFindHydratableTextInstanceWithinSuspenseInstance(
-                parentInstance,
-                text,
-              );
-              break;
-            case SuspenseComponent:
-              didNotFindHydratableSuspenseInstanceWithinSuspenseInstance(
-                parentInstance,
-              );
-              break;
-          }
-        break;
-      }
-      default:
-        return;
+    // Add this fiber to the diff tree.
+    const diffNode = buildHydrationDiffNode(fiber, 0);
+    // We use null as a signal that there was no node to match.
+    diffNode.serverProps = null;
+    if (rejectedCandidate !== null) {
+      const description =
+        describeHydratableInstanceForDevWarnings(rejectedCandidate);
+      diffNode.serverTail.push(description);
     }
   }
 }
-function insertNonHydratedInstance(returnFiber: Fiber, fiber: Fiber) {
-  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-}
 
-function tryHydrateInstance(fiber: Fiber, nextInstance: any) {
+function tryHydrateInstance(
+  fiber: Fiber,
+  nextInstance: any,
+  hostContext: HostContext,
+) {
   // fiber is a HostComponent Fiber
   const instance = canHydrateInstance(
     nextInstance,
@@ -344,6 +225,22 @@ function tryHydrateInstance(fiber: Fiber, nextInstance: any) {
   );
   if (instance !== null) {
     fiber.stateNode = (instance: Instance);
+
+    if (__DEV__) {
+      if (!didSuspendOrErrorDEV) {
+        const differences = diffHydratedPropsForDevWarnings(
+          instance,
+          fiber.type,
+          fiber.pendingProps,
+          hostContext,
+        );
+        if (differences !== null) {
+          const diffNode = buildHydrationDiffNode(fiber, 0);
+          diffNode.serverProps = differences;
+        }
+      }
+    }
+
     hydrationParentFiber = fiber;
     nextHydratableInstance = getFirstHydratableChild(instance);
     rootOrSingletonContext = false;
@@ -400,17 +297,30 @@ function tryHydrateSuspense(fiber: Fiber, nextInstance: any) {
   return false;
 }
 
-function shouldClientRenderOnMismatch(fiber: Fiber) {
-  return (
-    (fiber.mode & ConcurrentMode) !== NoMode &&
-    (fiber.flags & DidCapture) === NoFlags
-  );
-}
-
 function throwOnHydrationMismatch(fiber: Fiber) {
+  let diff = '';
+  if (__DEV__) {
+    // Consume the diff root for this mismatch.
+    // Any other errors will get their own diffs.
+    const diffRoot = hydrationDiffRootDEV;
+    if (diffRoot !== null) {
+      hydrationDiffRootDEV = null;
+      diff = describeDiff(diffRoot);
+    }
+  }
   throw new Error(
-    'Hydration failed because the initial UI does not match what was ' +
-      'rendered on the server.',
+    "Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:\n" +
+      '\n' +
+      "- A server/client branch `if (typeof window !== 'undefined')`.\n" +
+      "- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n" +
+      "- Date formatting in a user's locale which doesn't match the server.\n" +
+      '- External changing data without sending a snapshot of it along with the HTML.\n' +
+      '- Invalid HTML tag nesting.\n' +
+      '\n' +
+      'It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n' +
+      '\n' +
+      'https://react.dev/link/hydration-mismatch' +
+      diff,
   );
 }
 
@@ -428,6 +338,22 @@ function claimHydratableSingleton(fiber: Fiber): void {
       currentHostContext,
       false,
     ));
+
+    if (__DEV__) {
+      if (!didSuspendOrErrorDEV) {
+        const differences = diffHydratedPropsForDevWarnings(
+          instance,
+          fiber.type,
+          fiber.pendingProps,
+          currentHostContext,
+        );
+        if (differences !== null) {
+          const diffNode = buildHydrationDiffNode(fiber, 0);
+          diffNode.serverProps = differences;
+        }
+      }
+    }
+
     hydrationParentFiber = fiber;
     rootOrSingletonContext = true;
     nextHydratableInstance = getFirstHydratableChild(instance);
@@ -447,60 +373,15 @@ function tryToClaimNextHydratableInstance(fiber: Fiber): void {
     currentHostContext,
   );
 
-  const initialInstance = nextHydratableInstance;
   const nextInstance = nextHydratableInstance;
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      if (shouldKeepWarning) {
-        warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      }
-      throwOnHydrationMismatch(fiber);
-    }
-    // Nothing to hydrate. Make it an insertion.
-    insertNonHydratedInstance((hydrationParentFiber: any), fiber);
-    if (shouldKeepWarning) {
-      warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-    }
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
-  const firstAttemptedInstance = nextInstance;
-  if (!tryHydrateInstance(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      if (shouldKeepWarning) {
-        warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      }
-      throwOnHydrationMismatch(fiber);
-    }
-    // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    const prevHydrationParentFiber: Fiber = (hydrationParentFiber: any);
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateInstance(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance((hydrationParentFiber: any), fiber);
-      if (shouldKeepWarning) {
-        warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      }
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    }
-    // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
+  if (
+    !nextInstance ||
+    !tryHydrateInstance(fiber, nextInstance, currentHostContext)
+  ) {
     if (shouldKeepWarning) {
-      warnUnhydratedInstance(prevHydrationParentFiber, firstAttemptedInstance);
+      warnNonHydratedInstance(fiber, nextInstance);
     }
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+    throwOnHydrationMismatch(fiber);
   }
 }
 
@@ -515,63 +396,12 @@ function tryToClaimNextHydratableTextInstance(fiber: Fiber): void {
   const currentHostContext = getHostContext();
   shouldKeepWarning = validateHydratableTextInstance(text, currentHostContext);
 
-  const initialInstance = nextHydratableInstance;
   const nextInstance = nextHydratableInstance;
-  if (!nextInstance) {
-    // We exclude non hydrabable text because we know there are no matching hydratables.
-    // We either throw or insert depending on the render mode.
-    if (shouldClientRenderOnMismatch(fiber)) {
-      if (shouldKeepWarning) {
-        warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      }
-      throwOnHydrationMismatch(fiber);
-    }
-    // Nothing to hydrate. Make it an insertion.
-    insertNonHydratedInstance((hydrationParentFiber: any), fiber);
+  if (!nextInstance || !tryHydrateText(fiber, nextInstance)) {
     if (shouldKeepWarning) {
-      warnNonHydratedInstance((hydrationParentFiber: any), fiber);
+      warnNonHydratedInstance(fiber, nextInstance);
     }
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
-  const firstAttemptedInstance = nextInstance;
-  if (!tryHydrateText(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      if (shouldKeepWarning) {
-        warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      }
-      throwOnHydrationMismatch(fiber);
-    }
-    // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    const prevHydrationParentFiber: Fiber = (hydrationParentFiber: any);
-
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateText(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance((hydrationParentFiber: any), fiber);
-      if (shouldKeepWarning) {
-        warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      }
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    }
-    // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-    if (shouldKeepWarning) {
-      warnUnhydratedInstance(prevHydrationParentFiber, firstAttemptedInstance);
-    }
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+    throwOnHydrationMismatch(fiber);
   }
 }
 
@@ -579,51 +409,10 @@ function tryToClaimNextHydratableSuspenseInstance(fiber: Fiber): void {
   if (!isHydrating) {
     return;
   }
-  const initialInstance = nextHydratableInstance;
   const nextInstance = nextHydratableInstance;
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      throwOnHydrationMismatch(fiber);
-    }
-    // Nothing to hydrate. Make it an insertion.
-    insertNonHydratedInstance((hydrationParentFiber: any), fiber);
-    warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
-  const firstAttemptedInstance = nextInstance;
-  if (!tryHydrateSuspense(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      throwOnHydrationMismatch(fiber);
-    }
-    // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    const prevHydrationParentFiber: Fiber = (hydrationParentFiber: any);
-
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateSuspense(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance((hydrationParentFiber: any), fiber);
-      warnNonHydratedInstance((hydrationParentFiber: any), fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    }
-    // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-    warnUnhydratedInstance(prevHydrationParentFiber, firstAttemptedInstance);
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  if (!nextInstance || !tryHydrateSuspense(fiber, nextInstance)) {
+    warnNonHydratedInstance(fiber, nextInstance);
+    throwOnHydrationMismatch(fiber);
   }
 }
 
@@ -650,7 +439,7 @@ export function tryToClaimNextHydratableFormMarkerInstance(
   }
   // Should have found a marker instance. Throw an error to trigger client
   // rendering. We don't bother to check if we're in a concurrent root because
-  // useFormState is a new API, so backwards compat is not an issue.
+  // useActionState is a new API, so backwards compat is not an issue.
   throwOnHydrationMismatch(fiber);
   return false;
 }
@@ -667,18 +456,19 @@ function prepareToHydrateHostInstance(
   }
 
   const instance: Instance = fiber.stateNode;
-  const shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  hydrateInstance(
+  const didHydrate = hydrateInstance(
     instance,
     fiber.type,
     fiber.memoizedProps,
     hostContext,
     fiber,
-    shouldWarnIfMismatchDev,
   );
+  if (!didHydrate && favorSafetyOverHydrationPerf) {
+    throwOnHydrationMismatch(fiber);
+  }
 }
 
-function prepareToHydrateHostTextInstance(fiber: Fiber): boolean {
+function prepareToHydrateHostTextInstance(fiber: Fiber): void {
   if (!supportsHydration) {
     throw new Error(
       'Expected prepareToHydrateHostTextInstance() to never be called. ' +
@@ -689,65 +479,59 @@ function prepareToHydrateHostTextInstance(fiber: Fiber): boolean {
   const textInstance: TextInstance = fiber.stateNode;
   const textContent: string = fiber.memoizedProps;
   const shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  const shouldUpdate = hydrateTextInstance(
-    textInstance,
-    textContent,
-    fiber,
-    shouldWarnIfMismatchDev,
-  );
-  if (shouldUpdate) {
-    // We assume that prepareToHydrateHostTextInstance is called in a context where the
-    // hydration parent is the parent host component of this host text.
-    const returnFiber = hydrationParentFiber;
-    if (returnFiber !== null) {
-      switch (returnFiber.tag) {
-        case HostRoot: {
-          const parentContainer = returnFiber.stateNode.containerInfo;
-          const isConcurrentMode =
-            (returnFiber.mode & ConcurrentMode) !== NoMode;
-          didNotMatchHydratedContainerTextInstance(
-            parentContainer,
-            textInstance,
-            textContent,
-            // TODO: Delete this argument when we remove the legacy root API.
-            isConcurrentMode,
-            shouldWarnIfMismatchDev,
-          );
-          if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
-            // In concurrent mode we never update the mismatched text,
-            // even if the error was ignored.
-            return false;
+  let parentProps = null;
+  // We assume that prepareToHydrateHostTextInstance is called in a context where the
+  // hydration parent is the parent host component of this host text.
+  const returnFiber = hydrationParentFiber;
+  if (returnFiber !== null) {
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        if (__DEV__) {
+          if (shouldWarnIfMismatchDev) {
+            const difference = diffHydratedTextForDevWarnings(
+              textInstance,
+              textContent,
+              parentProps,
+            );
+            if (difference !== null) {
+              const diffNode = buildHydrationDiffNode(fiber, 0);
+              diffNode.serverProps = difference;
+            }
           }
-          break;
         }
-        case HostSingleton:
-        case HostComponent: {
-          const parentType = returnFiber.type;
-          const parentProps = returnFiber.memoizedProps;
-          const parentInstance = returnFiber.stateNode;
-          const isConcurrentMode =
-            (returnFiber.mode & ConcurrentMode) !== NoMode;
-          didNotMatchHydratedTextInstance(
-            parentType,
-            parentProps,
-            parentInstance,
-            textInstance,
-            textContent,
-            // TODO: Delete this argument when we remove the legacy root API.
-            isConcurrentMode,
-            shouldWarnIfMismatchDev,
-          );
-          if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
-            // In concurrent mode we never update the mismatched text,
-            // even if the error was ignored.
-            return false;
+        break;
+      }
+      case HostSingleton:
+      case HostComponent: {
+        parentProps = returnFiber.memoizedProps;
+        if (__DEV__) {
+          if (shouldWarnIfMismatchDev) {
+            const difference = diffHydratedTextForDevWarnings(
+              textInstance,
+              textContent,
+              parentProps,
+            );
+            if (difference !== null) {
+              const diffNode = buildHydrationDiffNode(fiber, 0);
+              diffNode.serverProps = difference;
+            }
           }
-          break;
         }
+        break;
       }
     }
+    // TODO: What if it's a SuspenseInstance?
+  }
+
+  const didHydrate = hydrateTextInstance(
+    textInstance,
+    textContent,
+    fiber,
+    parentProps,
+  );
+  if (!didHydrate && favorSafetyOverHydrationPerf) {
+    throwOnHydrationMismatch(fiber);
   }
-  return shouldUpdate;
 }
 
 function prepareToHydrateHostSuspenseInstance(fiber: Fiber): void {
@@ -861,18 +645,10 @@ function popHydrationState(fiber: Fiber): boolean {
     }
   }
   if (shouldClear) {
-    let nextInstance = nextHydratableInstance;
+    const nextInstance = nextHydratableInstance;
     if (nextInstance) {
-      if (shouldClientRenderOnMismatch(fiber)) {
-        warnIfUnhydratedTailNodes(fiber);
-        throwOnHydrationMismatch(fiber);
-      } else {
-        while (nextInstance) {
-          warnUnhydratedInstance(fiber, nextInstance);
-          deleteHydratableInstance(fiber, nextInstance);
-          nextInstance = getNextHydratableSibling(nextInstance);
-        }
-      }
+      warnIfUnhydratedTailNodes(fiber);
+      throwOnHydrationMismatch(fiber);
     }
   }
   popToNextHostParent(fiber);
@@ -887,10 +663,21 @@ function popHydrationState(fiber: Fiber): boolean {
 }
 
 function warnIfUnhydratedTailNodes(fiber: Fiber) {
-  let nextInstance = nextHydratableInstance;
-  while (nextInstance) {
-    warnUnhydratedInstance(fiber, nextInstance);
-    nextInstance = getNextHydratableSibling(nextInstance);
+  if (__DEV__) {
+    let nextInstance = nextHydratableInstance;
+    while (nextInstance) {
+      const diffNode = buildHydrationDiffNode(fiber, 0);
+      const description =
+        describeHydratableInstanceForDevWarnings(nextInstance);
+      diffNode.serverTail.push(description);
+      if (description.type === 'Suspense') {
+        const suspenseInstance: SuspenseInstance = (nextInstance: any);
+        nextInstance =
+          getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+      } else {
+        nextInstance = getNextHydratableSibling(nextInstance);
+      }
+    }
   }
 }
 
@@ -927,6 +714,34 @@ export function queueHydrationError(error: CapturedValue<mixed>): void {
   }
 }
 
+export function emitPendingHydrationWarnings() {
+  if (__DEV__) {
+    // If we haven't yet thrown any hydration errors by the time we reach the end we've successfully
+    // hydrated, however, we might still have DEV-only mismatches that we log now.
+    const diffRoot = hydrationDiffRootDEV;
+    if (diffRoot !== null) {
+      hydrationDiffRootDEV = null;
+      const diff = describeDiff(diffRoot);
+      console.error(
+        "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. " +
+          'This can happen if a SSR-ed Client Component used:\n' +
+          '\n' +
+          "- A server/client branch `if (typeof window !== 'undefined')`.\n" +
+          "- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n" +
+          "- Date formatting in a user's locale which doesn't match the server.\n" +
+          '- External changing data without sending a snapshot of it along with the HTML.\n' +
+          '- Invalid HTML tag nesting.\n' +
+          '\n' +
+          'It can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n' +
+          '\n' +
+          '%s%s',
+        'https://react.dev/link/hydration-mismatch',
+        diff,
+      );
+    }
+  }
+}
+
 export {
   warnIfHydrating,
   enterHydrationState,
diff --git a/packages/react-reconciler/src/ReactFiberHydrationDiffs.js b/packages/react-reconciler/src/ReactFiberHydrationDiffs.js
new file mode 100644
index 0000000000000..812d9d046a533
--- /dev/null
+++ b/packages/react-reconciler/src/ReactFiberHydrationDiffs.js
@@ -0,0 +1,643 @@
+/**
+ * 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.
+ *
+ * @flow
+ */
+
+import type {Fiber} from './ReactInternalTypes';
+
+import {
+  HostComponent,
+  HostHoistable,
+  HostSingleton,
+  LazyComponent,
+  SuspenseComponent,
+  SuspenseListComponent,
+  FunctionComponent,
+  IndeterminateComponent,
+  ForwardRef,
+  SimpleMemoComponent,
+  ClassComponent,
+  HostText,
+} from './ReactWorkTags';
+
+import {REACT_ELEMENT_TYPE} from 'shared/ReactSymbols';
+import assign from 'shared/assign';
+import getComponentNameFromType from 'shared/getComponentNameFromType';
+
+import isArray from 'shared/isArray';
+
+export type HydrationDiffNode = {
+  fiber: Fiber,
+  children: Array<HydrationDiffNode>,
+  serverProps: void | null | $ReadOnly<{[propName: string]: mixed}> | string, // null means no matching server node
+  serverTail: Array<
+    | $ReadOnly<{type: string, props: $ReadOnly<{[propName: string]: mixed}>}>
+    | string,
+  >,
+  distanceFromLeaf: number,
+};
+
+const maxRowLength = 120;
+const idealDepth = 15;
+
+function findNotableNode(
+  node: HydrationDiffNode,
+  indent: number,
+): HydrationDiffNode {
+  if (
+    node.serverProps === undefined &&
+    node.serverTail.length === 0 &&
+    node.children.length === 1 &&
+    node.distanceFromLeaf > 3 &&
+    node.distanceFromLeaf > idealDepth - indent
+  ) {
+    // This is not an interesting node for contextual purposes so we can skip it.
+    const child = node.children[0];
+    return findNotableNode(child, indent);
+  }
+  return node;
+}
+
+function indentation(indent: number): string {
+  return '  ' + '  '.repeat(indent);
+}
+
+function added(indent: number): string {
+  return '+ ' + '  '.repeat(indent);
+}
+
+function removed(indent: number): string {
+  return '- ' + '  '.repeat(indent);
+}
+
+function describeFiberType(fiber: Fiber): null | string {
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      return fiber.type;
+    case LazyComponent:
+      return 'Lazy';
+    case SuspenseComponent:
+      return 'Suspense';
+    case SuspenseListComponent:
+      return 'SuspenseList';
+    case FunctionComponent:
+    case IndeterminateComponent:
+    case SimpleMemoComponent:
+      const fn = fiber.type;
+      return fn.displayName || fn.name || null;
+    case ForwardRef:
+      const render = fiber.type.render;
+      return render.displayName || render.name || null;
+    case ClassComponent:
+      const ctr = fiber.type;
+      return ctr.displayName || ctr.name || null;
+    default:
+      // Skip
+      return null;
+  }
+}
+
+const needsEscaping = /["'&<>\n\t]/;
+
+function describeTextNode(content: string, maxLength: number): string {
+  if (needsEscaping.test(content)) {
+    const encoded = JSON.stringify(content);
+    if (encoded.length > maxLength - 2) {
+      if (maxLength < 8) {
+        return '{"..."}';
+      }
+      return '{' + encoded.slice(0, maxLength - 7) + '..."}';
+    }
+    return '{' + encoded + '}';
+  } else {
+    if (content.length > maxLength) {
+      if (maxLength < 5) {
+        return '{"..."}';
+      }
+      return content.slice(0, maxLength - 3) + '...';
+    }
+    return content;
+  }
+}
+
+function describeTextDiff(
+  clientText: string,
+  serverProps: mixed,
+  indent: number,
+): string {
+  const maxLength = maxRowLength - indent * 2;
+  if (serverProps === null) {
+    return added(indent) + describeTextNode(clientText, maxLength) + '\n';
+  } else if (typeof serverProps === 'string') {
+    let serverText: string = serverProps;
+    let firstDiff = 0;
+    for (
+      ;
+      firstDiff < serverText.length && firstDiff < clientText.length;
+      firstDiff++
+    ) {
+      if (
+        serverText.charCodeAt(firstDiff) !== clientText.charCodeAt(firstDiff)
+      ) {
+        break;
+      }
+    }
+    if (firstDiff > maxLength - 8 && firstDiff > 10) {
+      // The first difference between the two strings would be cut off, so cut off in
+      // the beginning instead.
+      clientText = '...' + clientText.slice(firstDiff - 8);
+      serverText = '...' + serverText.slice(firstDiff - 8);
+    }
+    return (
+      added(indent) +
+      describeTextNode(clientText, maxLength) +
+      '\n' +
+      removed(indent) +
+      describeTextNode(serverText, maxLength) +
+      '\n'
+    );
+  } else {
+    return indentation(indent) + describeTextNode(clientText, maxLength) + '\n';
+  }
+}
+
+function objectName(object: mixed): string {
+  // $FlowFixMe[method-unbinding]
+  const name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
+}
+
+function describeValue(value: mixed, maxLength: number): string {
+  switch (typeof value) {
+    case 'string': {
+      const encoded = JSON.stringify(value);
+      if (encoded.length > maxLength) {
+        if (maxLength < 5) {
+          return '"..."';
+        }
+        return encoded.slice(0, maxLength - 4) + '..."';
+      }
+      return encoded;
+    }
+    case 'object': {
+      if (value === null) {
+        return 'null';
+      }
+      if (isArray(value)) {
+        return '[...]';
+      }
+      if ((value: any).$$typeof === REACT_ELEMENT_TYPE) {
+        const type = getComponentNameFromType((value: any).type);
+        return type ? '<' + type + '>' : '<...>';
+      }
+      const name = objectName(value);
+      if (name === 'Object') {
+        let properties = '';
+        maxLength -= 2;
+        for (let propName in value) {
+          if (!value.hasOwnProperty(propName)) {
+            continue;
+          }
+          const jsonPropName = JSON.stringify(propName);
+          if (jsonPropName !== '"' + propName + '"') {
+            propName = jsonPropName;
+          }
+          maxLength -= propName.length - 2;
+          const propValue = describeValue(
+            value[propName],
+            maxLength < 15 ? maxLength : 15,
+          );
+          maxLength -= propValue.length;
+          if (maxLength < 0) {
+            properties += properties === '' ? '...' : ', ...';
+            break;
+          }
+          properties +=
+            (properties === '' ? '' : ',') + propName + ':' + propValue;
+        }
+        return '{' + properties + '}';
+      }
+      return name;
+    }
+    case 'function': {
+      const name = (value: any).displayName || value.name;
+      return name ? 'function ' + name : 'function';
+    }
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
+  }
+}
+
+function describePropValue(value: mixed, maxLength: number): string {
+  if (typeof value === 'string' && !needsEscaping.test(value)) {
+    if (value.length > maxLength - 2) {
+      if (maxLength < 5) {
+        return '"..."';
+      }
+      return '"' + value.slice(0, maxLength - 5) + '..."';
+    }
+    return '"' + value + '"';
+  }
+  return '{' + describeValue(value, maxLength - 2) + '}';
+}
+
+function describeCollapsedElement(
+  type: string,
+  props: {[propName: string]: mixed},
+  indent: number,
+): string {
+  // This function tries to fit the props into a single line for non-essential elements.
+  // We also ignore children because we're not going deeper.
+
+  let maxLength = maxRowLength - indent * 2 - type.length - 2;
+
+  let content = '';
+
+  for (const propName in props) {
+    if (!props.hasOwnProperty(propName)) {
+      continue;
+    }
+    if (propName === 'children') {
+      // Ignored.
+      continue;
+    }
+    const propValue = describePropValue(props[propName], 15);
+    maxLength -= propName.length + propValue.length + 2;
+    if (maxLength < 0) {
+      content += ' ...';
+      break;
+    }
+    content += ' ' + propName + '=' + propValue;
+  }
+
+  return indentation(indent) + '<' + type + content + '>\n';
+}
+
+function describeExpandedElement(
+  type: string,
+  props: {+[propName: string]: mixed},
+  rowPrefix: string,
+): string {
+  // This function tries to fit the props into a single line for non-essential elements.
+  // We also ignore children because we're not going deeper.
+
+  let remainingRowLength = maxRowLength - rowPrefix.length - type.length;
+
+  // We add the properties to a set so we can choose later whether we'll put it on one
+  // line or multiple lines.
+
+  const properties = [];
+
+  for (const propName in props) {
+    if (!props.hasOwnProperty(propName)) {
+      continue;
+    }
+    if (propName === 'children') {
+      // Ignored.
+      continue;
+    }
+    const maxLength = maxRowLength - rowPrefix.length - propName.length - 1;
+    const propValue = describePropValue(props[propName], maxLength);
+    remainingRowLength -= propName.length + propValue.length + 2;
+    properties.push(propName + '=' + propValue);
+  }
+
+  if (properties.length === 0) {
+    return rowPrefix + '<' + type + '>\n';
+  } else if (remainingRowLength > 0) {
+    // We can fit all on one row.
+    return rowPrefix + '<' + type + ' ' + properties.join(' ') + '>\n';
+  } else {
+    // Split into one row per property:
+    return (
+      rowPrefix +
+      '<' +
+      type +
+      '\n' +
+      rowPrefix +
+      '  ' +
+      properties.join('\n' + rowPrefix + '  ') +
+      '\n' +
+      rowPrefix +
+      '>\n'
+    );
+  }
+}
+
+function describePropertiesDiff(
+  clientObject: {+[propName: string]: mixed},
+  serverObject: {+[propName: string]: mixed},
+  indent: number,
+): string {
+  let properties = '';
+  const remainingServerProperties = assign({}, serverObject);
+  for (const propName in clientObject) {
+    if (!clientObject.hasOwnProperty(propName)) {
+      continue;
+    }
+    delete remainingServerProperties[propName];
+    const maxLength = maxRowLength - indent * 2 - propName.length - 2;
+    const clientValue = clientObject[propName];
+    const clientPropValue = describeValue(clientValue, maxLength);
+    if (serverObject.hasOwnProperty(propName)) {
+      const serverValue = serverObject[propName];
+      const serverPropValue = describeValue(serverValue, maxLength);
+      properties += added(indent) + propName + ': ' + clientPropValue + '\n';
+      properties += removed(indent) + propName + ': ' + serverPropValue + '\n';
+    } else {
+      properties += added(indent) + propName + ': ' + clientPropValue + '\n';
+    }
+  }
+  for (const propName in remainingServerProperties) {
+    if (!remainingServerProperties.hasOwnProperty(propName)) {
+      continue;
+    }
+    const maxLength = maxRowLength - indent * 2 - propName.length - 2;
+    const serverValue = remainingServerProperties[propName];
+    const serverPropValue = describeValue(serverValue, maxLength);
+    properties += removed(indent) + propName + ': ' + serverPropValue + '\n';
+  }
+  return properties;
+}
+
+function describeElementDiff(
+  type: string,
+  clientProps: {+[propName: string]: mixed},
+  serverProps: {+[propName: string]: mixed},
+  indent: number,
+): string {
+  let content = '';
+
+  // Maps any previously unmatched lower case server prop name to its full prop name
+  const serverPropNames: Map<string, string> = new Map();
+
+  for (const propName in serverProps) {
+    if (!serverProps.hasOwnProperty(propName)) {
+      continue;
+    }
+    serverPropNames.set(propName.toLowerCase(), propName);
+  }
+
+  if (serverPropNames.size === 1 && serverPropNames.has('children')) {
+    content += describeExpandedElement(type, clientProps, indentation(indent));
+  } else {
+    for (const propName in clientProps) {
+      if (!clientProps.hasOwnProperty(propName)) {
+        continue;
+      }
+      if (propName === 'children') {
+        // Handled below.
+        continue;
+      }
+      const maxLength = maxRowLength - (indent + 1) * 2 - propName.length - 1;
+      const serverPropName = serverPropNames.get(propName.toLowerCase());
+      if (serverPropName !== undefined) {
+        serverPropNames.delete(propName.toLowerCase());
+        // There's a diff here.
+        const clientValue = clientProps[propName];
+        const serverValue = serverProps[serverPropName];
+        const clientPropValue = describePropValue(clientValue, maxLength);
+        const serverPropValue = describePropValue(serverValue, maxLength);
+        if (
+          typeof clientValue === 'object' &&
+          clientValue !== null &&
+          typeof serverValue === 'object' &&
+          serverValue !== null &&
+          objectName(clientValue) === 'Object' &&
+          objectName(serverValue) === 'Object' &&
+          // Only do the diff if the object has a lot of keys or was shortened.
+          (Object.keys(clientValue).length > 2 ||
+            Object.keys(serverValue).length > 2 ||
+            clientPropValue.indexOf('...') > -1 ||
+            serverPropValue.indexOf('...') > -1)
+        ) {
+          // We're comparing two plain objects. We can diff the nested objects instead.
+          content +=
+            indentation(indent + 1) +
+            propName +
+            '={{\n' +
+            describePropertiesDiff(clientValue, serverValue, indent + 2) +
+            indentation(indent + 1) +
+            '}}\n';
+        } else {
+          content +=
+            added(indent + 1) + propName + '=' + clientPropValue + '\n';
+          content +=
+            removed(indent + 1) + propName + '=' + serverPropValue + '\n';
+        }
+      } else {
+        // Considered equal.
+        content +=
+          indentation(indent + 1) +
+          propName +
+          '=' +
+          describePropValue(clientProps[propName], maxLength) +
+          '\n';
+      }
+    }
+
+    serverPropNames.forEach(propName => {
+      if (propName === 'children') {
+        // Handled below.
+        return;
+      }
+      const maxLength = maxRowLength - (indent + 1) * 2 - propName.length - 1;
+      content +=
+        removed(indent + 1) +
+        propName +
+        '=' +
+        describePropValue(serverProps[propName], maxLength) +
+        '\n';
+    });
+
+    if (content === '') {
+      // No properties
+      content = indentation(indent) + '<' + type + '>\n';
+    } else {
+      // Had properties
+      content =
+        indentation(indent) +
+        '<' +
+        type +
+        '\n' +
+        content +
+        indentation(indent) +
+        '>\n';
+    }
+  }
+
+  const serverChildren = serverProps.children;
+  const clientChildren = clientProps.children;
+  if (
+    typeof serverChildren === 'string' ||
+    typeof serverChildren === 'number' ||
+    typeof serverChildren === 'bigint'
+  ) {
+    // There's a diff of the children.
+    // $FlowFixMe[unsafe-addition]
+    const serverText = '' + serverChildren;
+    let clientText = '';
+    if (
+      typeof clientChildren === 'string' ||
+      typeof clientChildren === 'number' ||
+      typeof clientChildren === 'bigint'
+    ) {
+      // $FlowFixMe[unsafe-addition]
+      clientText = '' + clientChildren;
+    }
+    content += describeTextDiff(clientText, serverText, indent + 1);
+  } else if (
+    typeof clientChildren === 'string' ||
+    typeof clientChildren === 'number' ||
+    typeof clientChildren === 'bigint'
+  ) {
+    // The client has children but it's not considered a difference from the server.
+    // $FlowFixMe[unsafe-addition]
+    content += describeTextDiff('' + clientChildren, undefined, indent + 1);
+  }
+  return content;
+}
+
+function describeSiblingFiber(fiber: Fiber, indent: number): string {
+  const type = describeFiberType(fiber);
+  if (type === null) {
+    // Skip this type of fiber. We currently treat this as a fragment
+    // so it's just part of the parent's children.
+    let flatContent = '';
+    let childFiber = fiber.child;
+    while (childFiber) {
+      flatContent += describeSiblingFiber(childFiber, indent);
+      childFiber = childFiber.sibling;
+    }
+    return flatContent;
+  }
+  return indentation(indent) + '<' + type + '>' + '\n';
+}
+
+function describeNode(node: HydrationDiffNode, indent: number): string {
+  const skipToNode = findNotableNode(node, indent);
+  if (
+    skipToNode !== node &&
+    (node.children.length !== 1 || node.children[0] !== skipToNode)
+  ) {
+    return indentation(indent) + '...\n' + describeNode(skipToNode, indent + 1);
+  }
+
+  // Prefix with any server components for context
+  let parentContent = '';
+  const debugInfo = node.fiber._debugInfo;
+  if (debugInfo) {
+    for (let i = 0; i < debugInfo.length; i++) {
+      const serverComponentName = debugInfo[i].name;
+      if (typeof serverComponentName === 'string') {
+        parentContent +=
+          indentation(indent) + '<' + serverComponentName + '>' + '\n';
+        indent++;
+      }
+    }
+  }
+
+  // Self
+  let selfContent = '';
+
+  // We use the pending props since we might be generating a diff before the complete phase
+  // when something throws.
+  const clientProps = node.fiber.pendingProps;
+
+  if (node.fiber.tag === HostText) {
+    // Text Node
+    selfContent = describeTextDiff(clientProps, node.serverProps, indent);
+  } else {
+    const type = describeFiberType(node.fiber);
+    if (type !== null) {
+      // Element Node
+      if (node.serverProps === undefined) {
+        // Just a reference node for context.
+        selfContent = describeCollapsedElement(type, clientProps, indent);
+        indent++;
+      } else if (node.serverProps === null) {
+        selfContent = describeExpandedElement(type, clientProps, added(indent));
+        // If this was an insertion we won't step down further. Any tail
+        // are considered siblings so we don't indent.
+        // TODO: Model this a little better.
+      } else if (typeof node.serverProps === 'string') {
+        if (__DEV__) {
+          console.error(
+            'Should not have matched a non HostText fiber to a Text node. This is a bug in React.',
+          );
+        }
+      } else {
+        selfContent = describeElementDiff(
+          type,
+          clientProps,
+          node.serverProps,
+          indent,
+        );
+        indent++;
+      }
+    }
+  }
+
+  // Compute children
+  let childContent = '';
+  let childFiber = node.fiber.child;
+  let diffIdx = 0;
+  while (childFiber && diffIdx < node.children.length) {
+    const childNode = node.children[diffIdx];
+    if (childNode.fiber === childFiber) {
+      // This was a match in the diff.
+      childContent += describeNode(childNode, indent);
+      diffIdx++;
+    } else {
+      // This is an unrelated previous sibling.
+      childContent += describeSiblingFiber(childFiber, indent);
+    }
+    childFiber = childFiber.sibling;
+  }
+
+  if (childFiber && node.children.length > 0) {
+    // If we had any further siblings after the last mismatch, we can't be sure if it's
+    // actually a valid match since it might not have found a match. So we exclude next
+    // siblings to avoid confusion.
+    childContent += indentation(indent) + '...' + '\n';
+  }
+
+  // Deleted tail nodes
+  const serverTail = node.serverTail;
+  for (let i = 0; i < serverTail.length; i++) {
+    const tailNode = serverTail[i];
+    if (typeof tailNode === 'string') {
+      // Removed text node
+      childContent +=
+        removed(indent) +
+        describeTextNode(tailNode, maxRowLength - indent * 2) +
+        '\n';
+    } else {
+      // Removed element
+      childContent += describeExpandedElement(
+        tailNode.type,
+        tailNode.props,
+        removed(indent),
+      );
+    }
+  }
+
+  return parentContent + selfContent + childContent;
+}
+
+export function describeDiff(rootNode: HydrationDiffNode): string {
+  try {
+    return '\n\n' + describeNode(rootNode, 0);
+  } catch (x) {
+    return '';
+  }
+}
diff --git a/packages/react-reconciler/src/ReactFiberNewContext.js b/packages/react-reconciler/src/ReactFiberNewContext.js
index cb9ada3dee9b8..c19e056b0a3cd 100644
--- a/packages/react-reconciler/src/ReactFiberNewContext.js
+++ b/packages/react-reconciler/src/ReactFiberNewContext.js
@@ -44,7 +44,6 @@ import {createUpdate, ForceUpdate} from './ReactFiberClassUpdateQueue';
 import {markWorkInProgressReceivedUpdate} from './ReactFiberBeginWork';
 import {
   enableLazyContextPropagation,
-  enableFormActions,
   enableAsyncActions,
   enableRenderableContext,
 } from 'shared/ReactFeatureFlags';
@@ -582,11 +581,7 @@ function propagateParentContextChanges(
           }
         }
       }
-    } else if (
-      enableFormActions &&
-      enableAsyncActions &&
-      parent === getHostTransitionProvider()
-    ) {
+    } else if (enableAsyncActions && parent === getHostTransitionProvider()) {
       // During a host transition, a host component can act like a context
       // provider. E.g. in React DOM, this would be a <form />.
       const currentParent = parent.alternate;
diff --git a/packages/react-reconciler/src/ReactFiberReconciler.js b/packages/react-reconciler/src/ReactFiberReconciler.js
index 8bee380ce0370..6cd30c78ae901 100644
--- a/packages/react-reconciler/src/ReactFiberReconciler.js
+++ b/packages/react-reconciler/src/ReactFiberReconciler.js
@@ -111,6 +111,11 @@ export {
   observeVisibleRects,
 } from './ReactTestSelectors';
 export {startHostTransition} from './ReactFiberHooks';
+export {
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
+  defaultOnRecoverableError,
+} from './ReactFiberErrorLogger';
 
 type OpaqueRoot = FiberRoot;
 
@@ -249,7 +254,21 @@ export function createContainer(
   isStrictMode: boolean,
   concurrentUpdatesByDefaultOverride: null | boolean,
   identifierPrefix: string,
-  onRecoverableError: (error: mixed) => void,
+  onUncaughtError: (
+    error: mixed,
+    errorInfo: {+componentStack?: ?string},
+  ) => void,
+  onCaughtError: (
+    error: mixed,
+    errorInfo: {
+      +componentStack?: ?string,
+      +errorBoundary?: ?React$Component<any, any>,
+    },
+  ) => void,
+  onRecoverableError: (
+    error: mixed,
+    errorInfo: {+digest?: ?string, +componentStack?: ?string},
+  ) => void,
   transitionCallbacks: null | TransitionTracingCallbacks,
 ): OpaqueRoot {
   const hydrate = false;
@@ -263,6 +282,8 @@ export function createContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
+    onUncaughtError,
+    onCaughtError,
     onRecoverableError,
     transitionCallbacks,
     null,
@@ -279,7 +300,21 @@ export function createHydrationContainer(
   isStrictMode: boolean,
   concurrentUpdatesByDefaultOverride: null | boolean,
   identifierPrefix: string,
-  onRecoverableError: (error: mixed) => void,
+  onUncaughtError: (
+    error: mixed,
+    errorInfo: {+componentStack?: ?string},
+  ) => void,
+  onCaughtError: (
+    error: mixed,
+    errorInfo: {
+      +componentStack?: ?string,
+      +errorBoundary?: ?React$Component<any, any>,
+    },
+  ) => void,
+  onRecoverableError: (
+    error: mixed,
+    errorInfo: {+digest?: ?string, +componentStack?: ?string},
+  ) => void,
   transitionCallbacks: null | TransitionTracingCallbacks,
   formState: ReactFormState<any, any> | null,
 ): OpaqueRoot {
@@ -293,6 +328,8 @@ export function createHydrationContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
+    onUncaughtError,
+    onCaughtError,
     onRecoverableError,
     transitionCallbacks,
     formState,
diff --git a/packages/react-reconciler/src/ReactFiberRoot.js b/packages/react-reconciler/src/ReactFiberRoot.js
index 210561595aac4..1db2e6bda4b49 100644
--- a/packages/react-reconciler/src/ReactFiberRoot.js
+++ b/packages/react-reconciler/src/ReactFiberRoot.js
@@ -51,6 +51,8 @@ function FiberRootNode(
   tag,
   hydrate: any,
   identifierPrefix: any,
+  onUncaughtError: any,
+  onCaughtError: any,
   onRecoverableError: any,
   formState: ReactFormState<any, any> | null,
 ) {
@@ -83,6 +85,8 @@ function FiberRootNode(
   this.hiddenUpdates = createLaneMap(null);
 
   this.identifierPrefix = identifierPrefix;
+  this.onUncaughtError = onUncaughtError;
+  this.onCaughtError = onCaughtError;
   this.onRecoverableError = onRecoverableError;
 
   if (enableCache) {
@@ -143,7 +147,21 @@ export function createFiberRoot(
   // them through the root constructor. Perhaps we should put them all into a
   // single type, like a DynamicHostConfig that is defined by the renderer.
   identifierPrefix: string,
-  onRecoverableError: null | ((error: mixed) => void),
+  onUncaughtError: (
+    error: mixed,
+    errorInfo: {+componentStack?: ?string},
+  ) => void,
+  onCaughtError: (
+    error: mixed,
+    errorInfo: {
+      +componentStack?: ?string,
+      +errorBoundary?: ?React$Component<any, any>,
+    },
+  ) => void,
+  onRecoverableError: (
+    error: mixed,
+    errorInfo: {+digest?: ?string, +componentStack?: ?string},
+  ) => void,
   transitionCallbacks: null | TransitionTracingCallbacks,
   formState: ReactFormState<any, any> | null,
 ): FiberRoot {
@@ -153,6 +171,8 @@ export function createFiberRoot(
     tag,
     hydrate,
     identifierPrefix,
+    onUncaughtError,
+    onCaughtError,
     onRecoverableError,
     formState,
   ): any);
diff --git a/packages/react-reconciler/src/ReactFiberRootScheduler.js b/packages/react-reconciler/src/ReactFiberRootScheduler.js
index da45a9278006e..d03131ce1751a 100644
--- a/packages/react-reconciler/src/ReactFiberRootScheduler.js
+++ b/packages/react-reconciler/src/ReactFiberRootScheduler.js
@@ -166,7 +166,6 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy: boolean) {
 
   // There may or may not be synchronous work scheduled. Let's check.
   let didPerformSomeWork;
-  let errors: Array<mixed> | null = null;
   isFlushingWork = true;
   do {
     didPerformSomeWork = false;
@@ -184,48 +183,14 @@ function flushSyncWorkAcrossRoots_impl(onlyLegacy: boolean) {
         );
         if (includesSyncLane(nextLanes)) {
           // This root has pending sync work. Flush it now.
-          try {
-            didPerformSomeWork = true;
-            performSyncWorkOnRoot(root, nextLanes);
-          } catch (error) {
-            // Collect errors so we can rethrow them at the end
-            if (errors === null) {
-              errors = [error];
-            } else {
-              errors.push(error);
-            }
-          }
+          didPerformSomeWork = true;
+          performSyncWorkOnRoot(root, nextLanes);
         }
       }
       root = root.next;
     }
   } while (didPerformSomeWork);
   isFlushingWork = false;
-
-  // If any errors were thrown, rethrow them right before exiting.
-  // TODO: Consider returning these to the caller, to allow them to decide
-  // how/when to rethrow.
-  if (errors !== null) {
-    if (errors.length > 1) {
-      if (typeof AggregateError === 'function') {
-        // eslint-disable-next-line no-undef
-        throw new AggregateError(errors);
-      } else {
-        for (let i = 1; i < errors.length; i++) {
-          scheduleImmediateTask(throwError.bind(null, errors[i]));
-        }
-        const firstError = errors[0];
-        throw firstError;
-      }
-    } else {
-      const error = errors[0];
-      throw error;
-    }
-  }
-}
-
-function throwError(error: mixed) {
-  throw error;
 }
 
 function processRootScheduleInMicrotask() {
diff --git a/packages/react-reconciler/src/ReactFiberThrow.js b/packages/react-reconciler/src/ReactFiberThrow.js
index 7633e1c676713..ce18234fd37ca 100644
--- a/packages/react-reconciler/src/ReactFiberThrow.js
+++ b/packages/react-reconciler/src/ReactFiberThrow.js
@@ -59,7 +59,6 @@ import {
 import {
   renderDidError,
   renderDidSuspendDelayIfPossible,
-  onUncaughtError,
   markLegacyErrorBoundaryAsFailed,
   isAlreadyFailedLegacyErrorBoundary,
   attachPingListener,
@@ -67,7 +66,7 @@ import {
   renderDidSuspend,
 } from './ReactFiberWorkLoop';
 import {propagateParentContextChangesToDeferredTree} from './ReactFiberNewContext';
-import {logCapturedError} from './ReactFiberErrorLogger';
+import {logUncaughtError, logCaughtError} from './ReactFiberErrorLogger';
 import {logComponentSuspended} from './DebugTracing';
 import {isDevToolsPresent} from './ReactFiberDevToolsHook';
 import {
@@ -86,7 +85,7 @@ import {noopSuspenseyCommitThenable} from './ReactFiberThenable';
 import {REACT_POSTPONE_TYPE} from 'shared/ReactSymbols';
 
 function createRootErrorUpdate(
-  fiber: Fiber,
+  root: FiberRoot,
   errorInfo: CapturedValue<mixed>,
   lane: Lane,
 ): Update<mixed> {
@@ -96,21 +95,24 @@ function createRootErrorUpdate(
   // Caution: React DevTools currently depends on this property
   // being called "element".
   update.payload = {element: null};
-  const error = errorInfo.value;
   update.callback = () => {
-    onUncaughtError(error);
-    logCapturedError(fiber, errorInfo);
+    logUncaughtError(root, errorInfo);
   };
   return update;
 }
 
-function createClassErrorUpdate(
-  fiber: Fiber,
-  errorInfo: CapturedValue<mixed>,
-  lane: Lane,
-): Update<mixed> {
+function createClassErrorUpdate(lane: Lane): Update<mixed> {
   const update = createUpdate(lane);
   update.tag = CaptureUpdate;
+  return update;
+}
+
+function initializeClassErrorUpdate(
+  update: Update<mixed>,
+  root: FiberRoot,
+  fiber: Fiber,
+  errorInfo: CapturedValue<mixed>,
+): void {
   const getDerivedStateFromError = fiber.type.getDerivedStateFromError;
   if (typeof getDerivedStateFromError === 'function') {
     const error = errorInfo.value;
@@ -121,7 +123,7 @@ function createClassErrorUpdate(
       if (__DEV__) {
         markFailedErrorBoundaryForHotReloading(fiber);
       }
-      logCapturedError(fiber, errorInfo);
+      logCaughtError(root, fiber, errorInfo);
     };
   }
 
@@ -132,7 +134,7 @@ function createClassErrorUpdate(
       if (__DEV__) {
         markFailedErrorBoundaryForHotReloading(fiber);
       }
-      logCapturedError(fiber, errorInfo);
+      logCaughtError(root, fiber, errorInfo);
       if (typeof getDerivedStateFromError !== 'function') {
         // To preserve the preexisting retry behavior of error boundaries,
         // we keep track of which ones already failed during this batch.
@@ -162,7 +164,6 @@ function createClassErrorUpdate(
       }
     };
   }
-  return update;
 }
 
 function resetSuspendedComponent(sourceFiber: Fiber, rootRenderLanes: Lanes) {
@@ -564,7 +565,11 @@ function throwException(
         workInProgress.flags |= ShouldCapture;
         const lane = pickArbitraryLane(rootRenderLanes);
         workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
-        const update = createRootErrorUpdate(workInProgress, errorInfo, lane);
+        const update = createRootErrorUpdate(
+          workInProgress.stateNode,
+          errorInfo,
+          lane,
+        );
         enqueueCapturedUpdate(workInProgress, update);
         return false;
       }
@@ -584,11 +589,8 @@ function throwException(
           const lane = pickArbitraryLane(rootRenderLanes);
           workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
           // Schedule the error boundary to re-render using updated state
-          const update = createClassErrorUpdate(
-            workInProgress,
-            errorInfo,
-            lane,
-          );
+          const update = createClassErrorUpdate(lane);
+          initializeClassErrorUpdate(update, root, workInProgress, errorInfo);
           enqueueCapturedUpdate(workInProgress, update);
           return false;
         }
@@ -603,4 +605,9 @@ function throwException(
   return false;
 }
 
-export {throwException, createRootErrorUpdate, createClassErrorUpdate};
+export {
+  throwException,
+  createRootErrorUpdate,
+  createClassErrorUpdate,
+  initializeClassErrorUpdate,
+};
diff --git a/packages/react-reconciler/src/ReactFiberTreeReflection.js b/packages/react-reconciler/src/ReactFiberTreeReflection.js
index c5c5944efda6b..ba13faf68ca24 100644
--- a/packages/react-reconciler/src/ReactFiberTreeReflection.js
+++ b/packages/react-reconciler/src/ReactFiberTreeReflection.js
@@ -25,7 +25,6 @@ import {
   SuspenseComponent,
 } from './ReactWorkTags';
 import {NoFlags, Placement, Hydrating} from './ReactFiberFlags';
-import {enableFloat} from 'shared/ReactFeatureFlags';
 
 const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
 
@@ -280,7 +279,7 @@ function findCurrentHostFiberImpl(node: Fiber): Fiber | null {
   const tag = node.tag;
   if (
     tag === HostComponent ||
-    (enableFloat ? tag === HostHoistable : false) ||
+    tag === HostHoistable ||
     tag === HostSingleton ||
     tag === HostText
   ) {
@@ -311,7 +310,7 @@ function findCurrentHostFiberWithNoPortalsImpl(node: Fiber): Fiber | null {
   const tag = node.tag;
   if (
     tag === HostComponent ||
-    (enableFloat ? tag === HostHoistable : false) ||
+    tag === HostHoistable ||
     tag === HostSingleton ||
     tag === HostText
   ) {
diff --git a/packages/react-reconciler/src/ReactFiberWorkLoop.js b/packages/react-reconciler/src/ReactFiberWorkLoop.js
index 152b0b460b2f4..f9b18aff86485 100644
--- a/packages/react-reconciler/src/ReactFiberWorkLoop.js
+++ b/packages/react-reconciler/src/ReactFiberWorkLoop.js
@@ -39,6 +39,7 @@ import {
   disableLegacyContext,
   alwaysThrottleRetries,
   enableInfiniteRenderLoopDetection,
+  disableLegacyMode,
 } from 'shared/ReactFeatureFlags';
 import ReactSharedInternals from 'shared/ReactSharedInternals';
 import is from 'shared/objectIs';
@@ -70,10 +71,10 @@ import {
   noTimeout,
   afterActiveInstanceBlur,
   getCurrentEventPriority,
-  errorHydratingContainer,
   startSuspendingCommit,
   waitForCommitToBeReady,
   preloadInstance,
+  supportsHydration,
 } from './ReactFiberConfig';
 
 import {createWorkInProgress, resetWorkInProgress} from './ReactFiber';
@@ -174,6 +175,7 @@ import {
   throwException,
   createRootErrorUpdate,
   createClassErrorUpdate,
+  initializeClassErrorUpdate,
 } from './ReactFiberThrow';
 import {
   commitBeforeMutationEffects,
@@ -274,6 +276,7 @@ import {
 } from './ReactFiberRootScheduler';
 import {getMaskedContext, getUnmaskedContext} from './ReactFiberContext';
 import {peekEntangledActionLane} from './ReactFiberAsyncAction';
+import {logUncaughtError} from './ReactFiberErrorLogger';
 
 const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
 
@@ -345,8 +348,6 @@ export let entangledRenderLanes: Lanes = NoLanes;
 
 // Whether to root completed, errored, suspended, etc.
 let workInProgressRootExitStatus: RootExitStatus = RootInProgress;
-// A fatal error, if one is thrown
-let workInProgressRootFatalError: mixed = null;
 // The work left over by components that were visited during this render. Only
 // includes unprocessed updates, not work in bailed out children.
 let workInProgressRootSkippedLanes: Lanes = NoLanes;
@@ -561,8 +562,6 @@ export function getRenderTargetTime(): number {
   return workInProgressRootRenderTargetTime;
 }
 
-let hasUncaughtError = false;
-let firstUncaughtError = null;
 let legacyErrorBoundariesThatAlreadyFailed: Set<mixed> | null = null;
 
 let rootDoesHavePassiveEffects: boolean = false;
@@ -971,11 +970,9 @@ export function performConcurrentWorkOnRoot(
           }
         }
         if (exitStatus === RootFatalErrored) {
-          const fatalError = workInProgressRootFatalError;
           prepareFreshStack(root, NoLanes);
           markRootSuspended(root, lanes, NoLane);
-          ensureRootIsScheduled(root);
-          throw fatalError;
+          break;
         }
 
         // We now have a consistent tree. The next step is either to commit it,
@@ -1003,7 +1000,7 @@ function recoverFromConcurrentError(
   // Before rendering again, save the errors from the previous attempt.
   const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
 
-  const wasRootDehydrated = isRootDehydrated(root);
+  const wasRootDehydrated = supportsHydration && isRootDehydrated(root);
   if (wasRootDehydrated) {
     // The shell failed to hydrate. Set a flag to force a client rendering
     // during the next attempt. To do this, we call prepareFreshStack now
@@ -1018,9 +1015,6 @@ function recoverFromConcurrentError(
     // Something to consider for a future refactor.
     const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
     rootWorkInProgress.flags |= ForceClientRender;
-    if (__DEV__) {
-      errorHydratingContainer(root.containerInfo);
-    }
   }
 
   const exitStatus = renderRootSync(root, errorRetryLanes);
@@ -1106,7 +1100,14 @@ function finishConcurrentRender(
       // Commit the placeholder.
       break;
     }
-    case RootErrored:
+    case RootErrored: {
+      // This render errored. Ignore any recoverable errors because we weren't actually
+      // able to recover. Instead, whatever the final errors were is the ones we log.
+      // This ensures that we only log the actual client side error if it's just a plain
+      // error thrown from a component on the server and the client.
+      workInProgressRootRecoverableErrors = null;
+      break;
+    }
     case RootSuspended:
     case RootCompleted: {
       break;
@@ -1388,11 +1389,10 @@ export function performSyncWorkOnRoot(root: FiberRoot, lanes: Lanes): null {
   }
 
   if (exitStatus === RootFatalErrored) {
-    const fatalError = workInProgressRootFatalError;
     prepareFreshStack(root, NoLanes);
     markRootSuspended(root, lanes, NoLane);
     ensureRootIsScheduled(root);
-    throw fatalError;
+    return null;
   }
 
   if (exitStatus === RootDidNotComplete) {
@@ -1457,21 +1457,27 @@ export function deferredUpdates<A>(fn: () => A): A {
 }
 
 export function batchedUpdates<A, R>(fn: A => R, a: A): R {
-  const prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  try {
+  if (disableLegacyMode) {
+    // batchedUpdates is a no-op now, but there's still some internal react-dom
+    // code calling it, that we can't remove until we remove legacy mode.
     return fn(a);
-  } finally {
-    executionContext = prevExecutionContext;
-    // If there were legacy sync updates, flush them at the end of the outer
-    // most batchedUpdates-like method.
-    if (
-      executionContext === NoContext &&
-      // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !(__DEV__ && ReactCurrentActQueue.isBatchingLegacy)
-    ) {
-      resetRenderTimer();
-      flushSyncWorkOnLegacyRootsOnly();
+  } else {
+    const prevExecutionContext = executionContext;
+    executionContext |= BatchedContext;
+    try {
+      return fn(a);
+    } finally {
+      executionContext = prevExecutionContext;
+      // If there were legacy sync updates, flush them at the end of the outer
+      // most batchedUpdates-like method.
+      if (
+        executionContext === NoContext &&
+        // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+        !(__DEV__ && ReactCurrentActQueue.isBatchingLegacy)
+      ) {
+        resetRenderTimer();
+        flushSyncWorkOnLegacyRootsOnly();
+      }
     }
   }
 }
@@ -1622,7 +1628,6 @@ function prepareFreshStack(root: FiberRoot, lanes: Lanes): Fiber {
   workInProgressThrownValue = null;
   workInProgressRootDidAttachPingListener = false;
   workInProgressRootExitStatus = RootInProgress;
-  workInProgressRootFatalError = null;
   workInProgressRootSkippedLanes = NoLanes;
   workInProgressRootInterleavedUpdatedLanes = NoLanes;
   workInProgressRootRenderPhaseUpdatedLanes = NoLanes;
@@ -1735,7 +1740,10 @@ function handleThrow(root: FiberRoot, thrownValue: any): void {
   if (erroredWork === null) {
     // This is a fatal error
     workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue;
+    logUncaughtError(
+      root,
+      createCapturedValueAtFiber(thrownValue, root.current),
+    );
     return;
   }
 
@@ -2513,7 +2521,7 @@ function throwAndUnwindWorkLoop(
       workInProgressRootRenderLanes,
     );
     if (didFatal) {
-      panicOnRootError(thrownValue);
+      panicOnRootError(root, thrownValue);
       return;
     }
   } catch (error) {
@@ -2525,7 +2533,7 @@ function throwAndUnwindWorkLoop(
       workInProgress = returnFiber;
       throw error;
     } else {
-      panicOnRootError(thrownValue);
+      panicOnRootError(root, thrownValue);
       return;
     }
   }
@@ -2547,13 +2555,13 @@ function throwAndUnwindWorkLoop(
   }
 }
 
-function panicOnRootError(error: mixed) {
+function panicOnRootError(root: FiberRoot, error: mixed) {
   // There's no ancestor that can handle this exception. This should never
   // happen because the root is supposed to capture all errors that weren't
   // caught by an error boundary. This is a fatal error, or panic condition,
   // because we've run out of ways to recover.
   workInProgressRootExitStatus = RootFatalErrored;
-  workInProgressRootFatalError = error;
+  logUncaughtError(root, createCapturedValueAtFiber(error, root.current));
   // Set `workInProgress` to null. This represents advancing to the next
   // sibling, or the parent if there are no siblings. But since the root
   // has no siblings nor a parent, we set it to null. Usually this is
@@ -3021,21 +3029,11 @@ function commitRootImpl(
     const onRecoverableError = root.onRecoverableError;
     for (let i = 0; i < recoverableErrors.length; i++) {
       const recoverableError = recoverableErrors[i];
-      const errorInfo = makeErrorInfo(
-        recoverableError.digest,
-        recoverableError.stack,
-      );
+      const errorInfo = makeErrorInfo(recoverableError.stack);
       onRecoverableError(recoverableError.value, errorInfo);
     }
   }
 
-  if (hasUncaughtError) {
-    hasUncaughtError = false;
-    const error = firstUncaughtError;
-    firstUncaughtError = null;
-    throw error;
-  }
-
   // If the passive effects are the result of a discrete render, flush them
   // synchronously at the end of the current task so that the result is
   // immediately observable. Otherwise, we assume that they are not
@@ -3129,28 +3127,35 @@ function commitRootImpl(
   return null;
 }
 
-function makeErrorInfo(digest: ?string, componentStack: ?string) {
+function makeErrorInfo(componentStack: ?string) {
   if (__DEV__) {
     const errorInfo = {
       componentStack,
-      digest,
     };
-    Object.defineProperty(errorInfo, 'digest', {
-      configurable: false,
-      enumerable: true,
-      get() {
-        console.error(
-          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
-            ' This property is deprecated and will be removed in a future version of React.' +
-            ' To access the digest of an Error look for this property on the Error instance itself.',
-        );
-        return digest;
+    return new Proxy(errorInfo, {
+      get(target, prop, receiver) {
+        if (prop === 'digest') {
+          console.error(
+            'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
+              ' This property is no longer provided as part of errorInfo but can be accessed as a property' +
+              ' of the Error instance itself.',
+          );
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      has(target, prop) {
+        if (prop === 'digest') {
+          console.error(
+            'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
+              ' This property is no longer provided as part of errorInfo but can be accessed as a property' +
+              ' of the Error instance itself.',
+          );
+        }
+        return Reflect.has(target, prop);
       },
     });
-    return errorInfo;
   } else {
     return {
-      digest,
       componentStack,
     };
   }
@@ -3355,21 +3360,17 @@ export function markLegacyErrorBoundaryAsFailed(instance: mixed) {
   }
 }
 
-function prepareToThrowUncaughtError(error: mixed) {
-  if (!hasUncaughtError) {
-    hasUncaughtError = true;
-    firstUncaughtError = error;
-  }
-}
-export const onUncaughtError = prepareToThrowUncaughtError;
-
 function captureCommitPhaseErrorOnRoot(
   rootFiber: Fiber,
   sourceFiber: Fiber,
   error: mixed,
 ) {
   const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
-  const update = createRootErrorUpdate(rootFiber, errorInfo, (SyncLane: Lane));
+  const update = createRootErrorUpdate(
+    rootFiber.stateNode,
+    errorInfo,
+    (SyncLane: Lane),
+  );
   const root = enqueueUpdate(rootFiber, update, (SyncLane: Lane));
   if (root !== null) {
     markRootUpdated(root, SyncLane);
@@ -3406,13 +3407,10 @@ export function captureCommitPhaseError(
           !isAlreadyFailedLegacyErrorBoundary(instance))
       ) {
         const errorInfo = createCapturedValueAtFiber(error, sourceFiber);
-        const update = createClassErrorUpdate(
-          fiber,
-          errorInfo,
-          (SyncLane: Lane),
-        );
+        const update = createClassErrorUpdate((SyncLane: Lane));
         const root = enqueueUpdate(fiber, update, (SyncLane: Lane));
         if (root !== null) {
+          initializeClassErrorUpdate(update, root, fiber, errorInfo);
           markRootUpdated(root, SyncLane);
           ensureRootIsScheduled(root);
         }
diff --git a/packages/react-reconciler/src/ReactInternalTypes.js b/packages/react-reconciler/src/ReactInternalTypes.js
index 8d3e99b986cfb..10b65fb39280f 100644
--- a/packages/react-reconciler/src/ReactInternalTypes.js
+++ b/packages/react-reconciler/src/ReactInternalTypes.js
@@ -56,7 +56,8 @@ export type HookType =
   | 'useId'
   | 'useCacheRefresh'
   | 'useOptimistic'
-  | 'useFormState';
+  | 'useFormState'
+  | 'useActionState';
 
 export type ContextDependency<T> = {
   context: ReactContext<T>,
@@ -259,9 +260,20 @@ type BaseFiberRootProperties = {
   // a reference to.
   identifierPrefix: string,
 
+  onUncaughtError: (
+    error: mixed,
+    errorInfo: {+componentStack?: ?string},
+  ) => void,
+  onCaughtError: (
+    error: mixed,
+    errorInfo: {
+      +componentStack?: ?string,
+      +errorBoundary?: ?React$Component<any, any>,
+    },
+  ) => void,
   onRecoverableError: (
     error: mixed,
-    errorInfo: {digest?: ?string, componentStack?: ?string},
+    errorInfo: {+digest?: ?string, +componentStack?: ?string},
   ) => void,
 
   formState: ReactFormState<any, any> | null,
@@ -414,6 +426,11 @@ export type Dispatcher = {
     initialState: Awaited<S>,
     permalink?: string,
   ) => [Awaited<S>, (P) => void, boolean],
+  useActionState?: <S, P>(
+    action: (Awaited<S>, P) => S,
+    initialState: Awaited<S>,
+    permalink?: string,
+  ) => [Awaited<S>, (P) => void, boolean],
 };
 
 export type CacheDispatcher = {
diff --git a/packages/react-reconciler/src/__tests__/ErrorBoundaryReconciliation-test.internal.js b/packages/react-reconciler/src/__tests__/ErrorBoundaryReconciliation-test.internal.js
index 449174a961fd6..b577bd1bc074e 100644
--- a/packages/react-reconciler/src/__tests__/ErrorBoundaryReconciliation-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ErrorBoundaryReconciliation-test.internal.js
@@ -46,45 +46,40 @@ describe('ErrorBoundaryReconciliation', () => {
       fail ? <InvalidType /> : <span prop="BrokenRender" />;
   });
 
-  [true, false].forEach(isConcurrent => {
-    async function sharedTest(ErrorBoundary, fallbackTagName) {
-      let renderer;
+  async function sharedTest(ErrorBoundary, fallbackTagName) {
+    let renderer;
 
+    await act(() => {
+      renderer = ReactTestRenderer.create(
+        <ErrorBoundary fallbackTagName={fallbackTagName}>
+          <BrokenRender fail={false} />
+        </ErrorBoundary>,
+        {unstable_isConcurrent: true},
+      );
+    });
+    expect(renderer).toMatchRenderedOutput(<span prop="BrokenRender" />);
+    await expect(async () => {
       await act(() => {
-        renderer = ReactTestRenderer.create(
+        renderer.update(
           <ErrorBoundary fallbackTagName={fallbackTagName}>
-            <BrokenRender fail={false} />
+            <BrokenRender fail={true} />
           </ErrorBoundary>,
-          {unstable_isConcurrent: isConcurrent},
         );
       });
-      expect(renderer).toMatchRenderedOutput(<span prop="BrokenRender" />);
-
-      await expect(async () => {
-        await act(() => {
-          renderer.update(
-            <ErrorBoundary fallbackTagName={fallbackTagName}>
-              <BrokenRender fail={true} />
-            </ErrorBoundary>,
-          );
-        });
-      }).toErrorDev(isConcurrent ? ['invalid', 'invalid'] : ['invalid']);
-      const Fallback = fallbackTagName;
-      expect(renderer).toMatchRenderedOutput(<Fallback prop="ErrorBoundary" />);
-    }
+    }).toErrorDev(['invalid', 'invalid']);
+    const Fallback = fallbackTagName;
+    expect(renderer).toMatchRenderedOutput(<Fallback prop="ErrorBoundary" />);
+  }
 
-    describe(isConcurrent ? 'concurrent' : 'sync', () => {
-      it('componentDidCatch can recover by rendering an element of the same type', () =>
-        sharedTest(DidCatchErrorBoundary, 'span'));
+  it('componentDidCatch can recover by rendering an element of the same type', () =>
+    sharedTest(DidCatchErrorBoundary, 'span'));
 
-      it('componentDidCatch can recover by rendering an element of a different type', () =>
-        sharedTest(DidCatchErrorBoundary, 'div'));
+  it('componentDidCatch can recover by rendering an element of a different type', () =>
+    sharedTest(DidCatchErrorBoundary, 'div'));
 
-      it('getDerivedStateFromError can recover by rendering an element of the same type', () =>
-        sharedTest(GetDerivedErrorBoundary, 'span'));
+  it('getDerivedStateFromError can recover by rendering an element of the same type', () =>
+    sharedTest(GetDerivedErrorBoundary, 'span'));
 
-      it('getDerivedStateFromError can recover by rendering an element of a different type', () =>
-        sharedTest(GetDerivedErrorBoundary, 'div'));
-    });
-  });
+  it('getDerivedStateFromError can recover by rendering an element of a different type', () =>
+    sharedTest(GetDerivedErrorBoundary, 'div'));
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactConfigurableErrorLogging-test.js b/packages/react-reconciler/src/__tests__/ReactConfigurableErrorLogging-test.js
new file mode 100644
index 0000000000000..4cdde5ce64636
--- /dev/null
+++ b/packages/react-reconciler/src/__tests__/ReactConfigurableErrorLogging-test.js
@@ -0,0 +1,229 @@
+/**
+ * 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';
+
+let React;
+let ReactDOMClient;
+let Scheduler;
+let container;
+let act;
+
+async function fakeAct(cb) {
+  // We don't use act/waitForThrow here because we want to observe how errors are reported for real.
+  await cb();
+  Scheduler.unstable_flushAll();
+}
+
+describe('ReactConfigurableErrorLogging', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    React = require('react');
+    ReactDOMClient = require('react-dom/client');
+    Scheduler = require('scheduler');
+    container = document.createElement('div');
+    if (__DEV__) {
+      act = React.act;
+    }
+  });
+
+  it('should log errors that occur during the begin phase', async () => {
+    class ErrorThrowingComponent extends React.Component {
+      constructor(props) {
+        super(props);
+        throw new Error('constructor error');
+      }
+      render() {
+        return <div />;
+      }
+    }
+    const uncaughtErrors = [];
+    const caughtErrors = [];
+    const root = ReactDOMClient.createRoot(container, {
+      onUncaughtError(error, errorInfo) {
+        uncaughtErrors.push(error, errorInfo);
+      },
+      onCaughtError(error, errorInfo) {
+        caughtErrors.push(error, errorInfo);
+      },
+    });
+    await fakeAct(() => {
+      root.render(
+        <div>
+          <span>
+            <ErrorThrowingComponent />
+          </span>
+        </div>,
+      );
+    });
+
+    expect(uncaughtErrors).toEqual([
+      expect.objectContaining({
+        message: 'constructor error',
+      }),
+      expect.objectContaining({
+        componentStack: expect.stringMatching(
+          new RegExp(
+            '\\s+(in|at) ErrorThrowingComponent (.*)\n' +
+              '\\s+(in|at) span(.*)\n' +
+              '\\s+(in|at) div(.*)',
+          ),
+        ),
+      }),
+    ]);
+    expect(caughtErrors).toEqual([]);
+  });
+
+  it('should log errors that occur during the commit phase', async () => {
+    class ErrorThrowingComponent extends React.Component {
+      componentDidMount() {
+        throw new Error('componentDidMount error');
+      }
+      render() {
+        return <div />;
+      }
+    }
+    const uncaughtErrors = [];
+    const caughtErrors = [];
+    const root = ReactDOMClient.createRoot(container, {
+      onUncaughtError(error, errorInfo) {
+        uncaughtErrors.push(error, errorInfo);
+      },
+      onCaughtError(error, errorInfo) {
+        caughtErrors.push(error, errorInfo);
+      },
+    });
+    await fakeAct(() => {
+      root.render(
+        <div>
+          <span>
+            <ErrorThrowingComponent />
+          </span>
+        </div>,
+      );
+    });
+
+    expect(uncaughtErrors).toEqual([
+      expect.objectContaining({
+        message: 'componentDidMount error',
+      }),
+      expect.objectContaining({
+        componentStack: expect.stringMatching(
+          new RegExp(
+            '\\s+(in|at) ErrorThrowingComponent (.*)\n' +
+              '\\s+(in|at) span(.*)\n' +
+              '\\s+(in|at) div(.*)',
+          ),
+        ),
+      }),
+    ]);
+    expect(caughtErrors).toEqual([]);
+  });
+
+  it('should ignore errors thrown in log method to prevent cycle', async () => {
+    class ErrorBoundary extends React.Component {
+      state = {error: null};
+      componentDidCatch(error) {
+        this.setState({error});
+      }
+      render() {
+        return this.state.error ? null : this.props.children;
+      }
+    }
+    class ErrorThrowingComponent extends React.Component {
+      render() {
+        throw new Error('render error');
+      }
+    }
+
+    const uncaughtErrors = [];
+    const caughtErrors = [];
+    const root = ReactDOMClient.createRoot(container, {
+      onUncaughtError(error, errorInfo) {
+        uncaughtErrors.push(error, errorInfo);
+      },
+      onCaughtError(error, errorInfo) {
+        caughtErrors.push(error, errorInfo);
+        throw new Error('onCaughtError error');
+      },
+    });
+
+    const ref = React.createRef();
+
+    await fakeAct(() => {
+      root.render(
+        <div>
+          <ErrorBoundary ref={ref}>
+            <span>
+              <ErrorThrowingComponent />
+            </span>
+          </ErrorBoundary>
+        </div>,
+      );
+    });
+
+    expect(uncaughtErrors).toEqual([]);
+    expect(caughtErrors).toEqual([
+      expect.objectContaining({
+        message: 'render error',
+      }),
+      expect.objectContaining({
+        componentStack: expect.stringMatching(
+          new RegExp(
+            '\\s+(in|at) ErrorThrowingComponent (.*)\n' +
+              '\\s+(in|at) span(.*)\n' +
+              '\\s+(in|at) ErrorBoundary(.*)\n' +
+              '\\s+(in|at) div(.*)',
+          ),
+        ),
+        errorBoundary: ref.current,
+      }),
+    ]);
+
+    // The error thrown in caughtError should be rethrown with a clean stack
+    expect(() => {
+      jest.runAllTimers();
+    }).toThrow('onCaughtError error');
+  });
+
+  it('does not log errors when inside real act', async () => {
+    function ErrorThrowingComponent() {
+      throw new Error('render error');
+    }
+    const uncaughtErrors = [];
+    const caughtErrors = [];
+    const root = ReactDOMClient.createRoot(container, {
+      onUncaughtError(error, errorInfo) {
+        uncaughtErrors.push(error, errorInfo);
+      },
+      onCaughtError(error, errorInfo) {
+        caughtErrors.push(error, errorInfo);
+      },
+    });
+
+    if (__DEV__) {
+      global.IS_REACT_ACT_ENVIRONMENT = true;
+
+      await expect(async () => {
+        await act(() => {
+          root.render(
+            <div>
+              <span>
+                <ErrorThrowingComponent />
+              </span>
+            </div>,
+          );
+        });
+      }).rejects.toThrow('render error');
+    }
+
+    expect(uncaughtErrors).toEqual([]);
+    expect(caughtErrors).toEqual([]);
+  });
+});
diff --git a/packages/react-reconciler/src/__tests__/ReactFiberHostContext-test.internal.js b/packages/react-reconciler/src/__tests__/ReactFiberHostContext-test.internal.js
index 0711fb3adb3d0..0a38182ecbe54 100644
--- a/packages/react-reconciler/src/__tests__/ReactFiberHostContext-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactFiberHostContext-test.internal.js
@@ -93,7 +93,11 @@ describe('ReactFiberHostContext', () => {
       ConcurrentRoot,
       null,
       false,
+      null,
       '',
+      () => {},
+      () => {},
+      () => {},
       null,
     );
     act(() => {
diff --git a/packages/react-reconciler/src/__tests__/ReactFlushSync-test.js b/packages/react-reconciler/src/__tests__/ReactFlushSync-test.js
index ab487922ca56d..3f8c62a42d1c9 100644
--- a/packages/react-reconciler/src/__tests__/ReactFlushSync-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactFlushSync-test.js
@@ -326,10 +326,12 @@ describe('ReactFlushSync', () => {
 
     let error;
     try {
-      ReactDOM.flushSync(() => {
-        root1.render(<Throws error={aahh} />);
-        root2.render(<Throws error={nooo} />);
-        root3.render(<Text text="aww" />);
+      await act(() => {
+        ReactDOM.flushSync(() => {
+          root1.render(<Throws error={aahh} />);
+          root2.render(<Throws error={nooo} />);
+          root3.render(<Text text="aww" />);
+        });
       });
     } catch (e) {
       error = e;
diff --git a/packages/react-reconciler/src/__tests__/ReactFlushSyncNoAggregateError-test.js b/packages/react-reconciler/src/__tests__/ReactFlushSyncNoAggregateError-test.js
index a5da4dbcc261e..d971521efe6d8 100644
--- a/packages/react-reconciler/src/__tests__/ReactFlushSyncNoAggregateError-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactFlushSyncNoAggregateError-test.js
@@ -119,10 +119,12 @@ describe('ReactFlushSync (AggregateError not available)', () => {
     overrideQueueMicrotask = true;
     let error;
     try {
-      ReactDOM.flushSync(() => {
-        root1.render(<Throws error={aahh} />);
-        root2.render(<Throws error={nooo} />);
-        root3.render(<Text text="aww" />);
+      await act(() => {
+        ReactDOM.flushSync(() => {
+          root1.render(<Throws error={aahh} />);
+          root2.render(<Throws error={nooo} />);
+          root3.render(<Text text="aww" />);
+        });
       });
     } catch (e) {
       error = e;
@@ -140,6 +142,6 @@ describe('ReactFlushSync (AggregateError not available)', () => {
     // AggregateError is not available, React throws the first error, then
     // throws the remaining errors in separate tasks.
     expect(error).toBe(aahh);
-    expect(flushFakeMicrotasks).toThrow(nooo);
+    await flushFakeMicrotasks();
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js b/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
index ce0a45be89f54..b63a8b23476e4 100644
--- a/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
@@ -1308,16 +1308,6 @@ describe('ReactHooks', () => {
       return <div />;
     });
 
-    function Factory() {
-      return {
-        state: {},
-        render() {
-          renderCount++;
-          return <div />;
-        },
-      };
-    }
-
     let renderer;
     await act(() => {
       renderer = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
@@ -1410,46 +1400,6 @@ describe('ReactHooks', () => {
     });
     expect(renderCount).toBe(__DEV__ ? 2 : 1);
 
-    if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-      renderCount = 0;
-      await expect(async () => {
-        await act(() => {
-          renderer.update(<Factory />);
-        });
-      }).toErrorDev(
-        'Warning: The <Factory /> component appears to be a function component that returns a class instance. ' +
-          'Change Factory to a class that extends React.Component instead. ' +
-          "If you can't use a class try assigning the prototype on the function as a workaround. " +
-          '`Factory.prototype = React.Component.prototype`. ' +
-          "Don't use an arrow function since it cannot be called with `new` by React.",
-      );
-      expect(renderCount).toBe(1);
-      renderCount = 0;
-      await act(() => {
-        renderer.update(<Factory />);
-      });
-      expect(renderCount).toBe(1);
-
-      renderCount = 0;
-      await act(() => {
-        renderer.update(
-          <StrictMode>
-            <Factory />
-          </StrictMode>,
-        );
-      });
-      expect(renderCount).toBe(__DEV__ ? 2 : 1); // Treated like a class
-      renderCount = 0;
-      await act(() => {
-        renderer.update(
-          <StrictMode>
-            <Factory />
-          </StrictMode>,
-        );
-      });
-      expect(renderCount).toBe(__DEV__ ? 2 : 1); // Treated like a class
-    }
-
     renderCount = 0;
     await act(() => {
       renderer.update(<HasHooks />);
@@ -1899,7 +1849,7 @@ describe('ReactHooks', () => {
     }).rejects.toThrow('Hello');
 
     if (__DEV__) {
-      expect(console.error).toHaveBeenCalledTimes(2);
+      expect(console.error).toHaveBeenCalledTimes(1);
       expect(console.error.mock.calls[0][0]).toContain(
         'Warning: Cannot update a component (`%s`) while rendering ' +
           'a different component (`%s`).',
diff --git a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js
index df720e207a777..04e7be86c61cf 100644
--- a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js
@@ -227,44 +227,6 @@ describe('ReactHooksWithNoopRenderer', () => {
     await waitForAll([10]);
   });
 
-  // @gate !disableModulePatternComponents
-  it('throws inside module-style components', async () => {
-    function Counter() {
-      return {
-        render() {
-          const [count] = useState(0);
-          return <Text text={this.props.label + ': ' + count} />;
-        },
-      };
-    }
-    ReactNoop.render(<Counter />);
-    await expect(
-      async () =>
-        await waitForThrow(
-          'Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen ' +
-            'for one of the following reasons:\n' +
-            '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' +
-            '2. You might be breaking the Rules of Hooks\n' +
-            '3. You might have more than one copy of React in the same app\n' +
-            'See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.',
-        ),
-    ).toErrorDev(
-      'Warning: The <Counter /> component appears to be a function component that returns a class instance. ' +
-        'Change Counter to a class that extends React.Component instead. ' +
-        "If you can't use a class try assigning the prototype on the function as a workaround. " +
-        '`Counter.prototype = React.Component.prototype`. ' +
-        "Don't use an arrow function since it cannot be called with `new` by React.",
-    );
-
-    // Confirm that a subsequent hook works properly.
-    function GoodCounter(props) {
-      const [count] = useState(props.initialCount);
-      return <Text text={count} />;
-    }
-    ReactNoop.render(<GoodCounter initialCount={10} />);
-    await waitForAll([10]);
-  });
-
   it('throws when called outside the render phase', async () => {
     expect(() => {
       expect(() => useState(0)).toThrow(
@@ -2077,14 +2039,15 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      await act(async () => {
-        ReactNoop.render(<Counter count={0} />, () =>
-          Scheduler.log('Sync effect'),
-        );
-        await waitFor(['Count: 0', 'Sync effect']);
-        expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
-        expect(() => ReactNoop.flushPassiveEffects()).toThrow('Oops');
-      });
+      await expect(async () => {
+        await act(async () => {
+          ReactNoop.render(<Counter count={0} />, () =>
+            Scheduler.log('Sync effect'),
+          );
+          await waitFor(['Count: 0', 'Sync effect']);
+          expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
+        });
+      }).rejects.toThrow('Oops');
 
       assertLog([
         'Mount A [0]',
@@ -2107,7 +2070,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         useEffect(() => {
           if (props.count === 1) {
             Scheduler.log('Oops!');
-            throw new Error('Oops!');
+            throw new Error('Oops error!');
           }
           Scheduler.log(`Mount B [${props.count}]`);
           return () => {
@@ -2126,22 +2089,27 @@ describe('ReactHooksWithNoopRenderer', () => {
         assertLog(['Mount A [0]', 'Mount B [0]']);
       });
 
-      await act(async () => {
-        // This update will trigger an error
-        ReactNoop.render(<Counter count={1} />, () =>
-          Scheduler.log('Sync effect'),
-        );
-        await waitFor(['Count: 1', 'Sync effect']);
-        expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
-        expect(() => ReactNoop.flushPassiveEffects()).toThrow('Oops');
-        assertLog(['Unmount A [0]', 'Unmount B [0]', 'Mount A [1]', 'Oops!']);
-        expect(ReactNoop).toMatchRenderedOutput(null);
-      });
-      assertLog([
-        // Clean up effect A runs passively on unmount.
-        // There's no effect B to clean-up, because it never mounted.
-        'Unmount A [1]',
-      ]);
+      await expect(async () => {
+        await act(async () => {
+          // This update will trigger an error
+          ReactNoop.render(<Counter count={1} />, () =>
+            Scheduler.log('Sync effect'),
+          );
+          await waitFor(['Count: 1', 'Sync effect']);
+          expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
+          ReactNoop.flushPassiveEffects();
+          assertLog([
+            'Unmount A [0]',
+            'Unmount B [0]',
+            'Mount A [1]',
+            'Oops!',
+            // Clean up effect A runs passively on unmount.
+            // There's no effect B to clean-up, because it never mounted.
+            'Unmount A [1]',
+          ]);
+          expect(ReactNoop).toMatchRenderedOutput(null);
+        });
+      }).rejects.toThrow('Oops error!');
     });
 
     it('handles errors in destroy on update', async () => {
@@ -2151,7 +2119,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           return () => {
             Scheduler.log('Oops!');
             if (props.count === 0) {
-              throw new Error('Oops!');
+              throw new Error('Oops error!');
             }
           };
         });
@@ -2174,26 +2142,34 @@ describe('ReactHooksWithNoopRenderer', () => {
         assertLog(['Mount A [0]', 'Mount B [0]']);
       });
 
-      await act(async () => {
-        // This update will trigger an error during passive effect unmount
-        ReactNoop.render(<Counter count={1} />, () =>
-          Scheduler.log('Sync effect'),
-        );
-        await waitFor(['Count: 1', 'Sync effect']);
-        expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
-        expect(() => ReactNoop.flushPassiveEffects()).toThrow('Oops');
+      await expect(async () => {
+        await act(async () => {
+          // This update will trigger an error during passive effect unmount
+          ReactNoop.render(<Counter count={1} />, () =>
+            Scheduler.log('Sync effect'),
+          );
+          await waitFor(['Count: 1', 'Sync effect']);
+          expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
+          ReactNoop.flushPassiveEffects();
 
-        // This branch enables a feature flag that flushes all passive destroys in a
-        // separate pass before flushing any passive creates.
-        // A result of this two-pass flush is that an error thrown from unmount does
-        // not block the subsequent create functions from being run.
-        assertLog(['Oops!', 'Unmount B [0]', 'Mount A [1]', 'Mount B [1]']);
-      });
+          // This branch enables a feature flag that flushes all passive destroys in a
+          // separate pass before flushing any passive creates.
+          // A result of this two-pass flush is that an error thrown from unmount does
+          // not block the subsequent create functions from being run.
+          assertLog([
+            'Oops!',
+            'Unmount B [0]',
+            'Mount A [1]',
+            'Mount B [1]',
+            // <Counter> gets unmounted because an error is thrown above.
+            // The remaining destroy functions are run later on unmount, since they're passive.
+            // In this case, one of them throws again (because of how the test is written).
+            'Oops!',
+            'Unmount B [1]',
+          ]);
+        });
+      }).rejects.toThrow('Oops error!');
 
-      // <Counter> gets unmounted because an error is thrown above.
-      // The remaining destroy functions are run later on unmount, since they're passive.
-      // In this case, one of them throws again (because of how the test is written).
-      assertLog(['Oops!', 'Unmount B [1]']);
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
@@ -3805,7 +3781,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           await waitForThrow(
             'Rendered more hooks than during the previous render.',
           );
-          assertLog([]);
+          assertLog(['Unmount A']);
         }).toErrorDev([
           'Warning: React has detected a change in the order of Hooks called by App. ' +
             'This will lead to bugs and errors if not fixed. For more information, ' +
diff --git a/packages/react-reconciler/src/__tests__/ReactIncremental-test.js b/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
index 13f904bf9d014..4beb0a12dabb2 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
@@ -1864,48 +1864,6 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  // @gate !disableModulePatternComponents
-  // @gate !disableLegacyContext
-  it('does not leak own context into context provider (factory components)', async () => {
-    function Recurse(props, context) {
-      return {
-        getChildContext() {
-          return {n: (context.n || 3) - 1};
-        },
-        render() {
-          Scheduler.log('Recurse ' + JSON.stringify(context));
-          if (context.n === 0) {
-            return null;
-          }
-          return <Recurse />;
-        },
-      };
-    }
-    Recurse.contextTypes = {
-      n: PropTypes.number,
-    };
-    Recurse.childContextTypes = {
-      n: PropTypes.number,
-    };
-
-    ReactNoop.render(<Recurse />);
-    await expect(
-      async () =>
-        await waitForAll([
-          'Recurse {}',
-          'Recurse {"n":2}',
-          'Recurse {"n":1}',
-          'Recurse {"n":0}',
-        ]),
-    ).toErrorDev([
-      'Warning: The <Recurse /> component appears to be a function component that returns a class instance. ' +
-        'Change Recurse to a class that extends React.Component instead. ' +
-        "If you can't use a class try assigning the prototype on the function as a workaround. " +
-        '`Recurse.prototype = React.Component.prototype`. ' +
-        "Don't use an arrow function since it cannot be called with `new` by React.",
-    ]);
-  });
-
   // @gate www
   // @gate !disableLegacyContext
   it('provides context when reusing work', async () => {
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
index 763a2fc9ca204..c6e342871b198 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
@@ -387,7 +387,7 @@ describe('ReactIncrementalErrorHandling', () => {
     // The work loop unwound to the nearest error boundary. React will try
     // to render one more time, synchronously. Flush just one unit of work to
     // demonstrate that this render is synchronous.
-    expect(() => Scheduler.unstable_flushNumberOfYields(1)).toThrow('oops');
+    Scheduler.unstable_flushNumberOfYields(1);
     assertLog(['Parent', 'BadRender', 'commit']);
     expect(ReactNoop).toMatchRenderedOutput(null);
   });
@@ -425,10 +425,8 @@ describe('ReactIncrementalErrorHandling', () => {
     // Expire the render midway through
     Scheduler.unstable_advanceTime(10000);
 
-    expect(() => {
-      Scheduler.unstable_flushExpired();
-      ReactNoop.flushSync();
-    }).toThrow('Oops');
+    Scheduler.unstable_flushExpired();
+    ReactNoop.flushSync();
 
     assertLog([
       // The render expired, but we shouldn't throw out the partial work.
@@ -769,15 +767,14 @@ describe('ReactIncrementalErrorHandling', () => {
       throw new Error('Hello');
     }
 
-    expect(() => {
-      ReactNoop.flushSync(() => {
-        ReactNoop.render(
-          <RethrowErrorBoundary>
-            <BrokenRender />
-          </RethrowErrorBoundary>,
-        );
-      });
-    }).toThrow('Hello');
+    ReactNoop.flushSync(() => {
+      ReactNoop.render(
+        <RethrowErrorBoundary>
+          <BrokenRender />
+        </RethrowErrorBoundary>,
+      );
+    });
+
     assertLog([
       'RethrowErrorBoundary render',
       'BrokenRender',
@@ -809,18 +806,17 @@ describe('ReactIncrementalErrorHandling', () => {
       throw new Error('Hello');
     }
 
-    expect(() => {
-      ReactNoop.flushSync(() => {
-        ReactNoop.render(
-          <RethrowErrorBoundary>Before the storm.</RethrowErrorBoundary>,
-        );
-        ReactNoop.render(
-          <RethrowErrorBoundary>
-            <BrokenRender />
-          </RethrowErrorBoundary>,
-        );
-      });
-    }).toThrow('Hello');
+    ReactNoop.flushSync(() => {
+      ReactNoop.render(
+        <RethrowErrorBoundary>Before the storm.</RethrowErrorBoundary>,
+      );
+      ReactNoop.render(
+        <RethrowErrorBoundary>
+          <BrokenRender />
+        </RethrowErrorBoundary>,
+      );
+    });
+
     assertLog([
       'RethrowErrorBoundary render',
       'BrokenRender',
@@ -1120,14 +1116,15 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(ReactNoop.getChildrenAsJSX('e')).toEqual(null);
 
     ReactNoop.renderToRootWithID(<BrokenRender label="a" />, 'a');
+    await waitForThrow('a');
+
     ReactNoop.renderToRootWithID(<span prop="b:6" />, 'b');
     ReactNoop.renderToRootWithID(<BrokenRender label="c" />, 'c');
+    await waitForThrow('c');
+
     ReactNoop.renderToRootWithID(<span prop="d:6" />, 'd');
     ReactNoop.renderToRootWithID(<BrokenRender label="e" />, 'e');
     ReactNoop.renderToRootWithID(<span prop="f:6" />, 'f');
-
-    await waitForThrow('a');
-    await waitForThrow('c');
     await waitForThrow('e');
 
     await waitForAll([]);
@@ -1369,8 +1366,10 @@ describe('ReactIncrementalErrorHandling', () => {
 
     let aggregateError;
     try {
-      ReactNoop.flushSync(() => {
-        inst.setState({fail: true});
+      await act(() => {
+        ReactNoop.flushSync(() => {
+          inst.setState({fail: true});
+        });
       });
     } catch (e) {
       aggregateError = e;
@@ -1387,9 +1386,10 @@ describe('ReactIncrementalErrorHandling', () => {
 
     // React threw both errors as a single AggregateError
     const errors = aggregateError.errors;
-    expect(errors.length).toBe(2);
+    expect(errors.length).toBe(3);
     expect(errors[0].message).toBe('Hello.');
     expect(errors[1].message).toBe('One does not simply unmount me.');
+    expect(errors[2].message).toBe('One does not simply unmount me.');
   });
 
   it('does not interrupt unmounting if detaching a ref throws', async () => {
@@ -1754,45 +1754,6 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  // @gate !disableModulePatternComponents
-  it('handles error thrown inside getDerivedStateFromProps of a module-style context provider', async () => {
-    function Provider() {
-      return {
-        getChildContext() {
-          return {foo: 'bar'};
-        },
-        render() {
-          return 'Hi';
-        },
-      };
-    }
-    Provider.childContextTypes = {
-      x: () => {},
-    };
-    Provider.getDerivedStateFromProps = () => {
-      throw new Error('Oops!');
-    };
-
-    ReactNoop.render(<Provider />);
-    await expect(async () => {
-      await waitForThrow('Oops!');
-    }).toErrorDev([
-      'Warning: The <Provider /> component appears to be a function component that returns a class instance. ' +
-        'Change Provider to a class that extends React.Component instead. ' +
-        "If you can't use a class try assigning the prototype on the function as a workaround. " +
-        '`Provider.prototype = React.Component.prototype`. ' +
-        "Don't use an arrow function since it cannot be called with `new` by React.",
-      ...gate(flags =>
-        flags.disableLegacyContext
-          ? [
-              'Warning: Provider uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.',
-              'Warning: Provider uses the legacy childContextTypes API which is no longer supported. Use React.createContext() instead.',
-            ]
-          : [],
-      ),
-    ]);
-  });
-
   it('uncaught errors should be discarded if the render is aborted', async () => {
     const root = ReactNoop.createRoot();
 
@@ -1878,6 +1839,7 @@ describe('ReactIncrementalErrorHandling', () => {
     // accident) a render phase triggered from userspace.
 
     spyOnDev(console, 'error').mockImplementation(() => {});
+    spyOnDev(console, 'warn').mockImplementation(() => {});
 
     let numberOfThrows = 0;
 
@@ -1916,12 +1878,13 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(numberOfThrows < 100).toBe(true);
 
     if (__DEV__) {
-      expect(console.error).toHaveBeenCalledTimes(2);
+      expect(console.error).toHaveBeenCalledTimes(1);
       expect(console.error.mock.calls[0][0]).toContain(
         'Cannot update a component (`%s`) while rendering a different component',
       );
-      expect(console.error.mock.calls[1][2]).toContain(
-        'The above error occurred in the <App> component',
+      expect(console.warn).toHaveBeenCalledTimes(1);
+      expect(console.warn.mock.calls[0][1]).toContain(
+        'An error occurred in the <App> component',
       );
     }
   });
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js
index 82edcf2db4503..d4c7949580c97 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js
@@ -14,7 +14,13 @@ let React;
 let ReactNoop;
 let Scheduler;
 let waitForAll;
-let waitForThrow;
+let uncaughtExceptionMock;
+
+async function fakeAct(cb) {
+  // We don't use act/waitForThrow here because we want to observe how errors are reported for real.
+  await cb();
+  Scheduler.unstable_flushAll();
+}
 
 describe('ReactIncrementalErrorLogging', () => {
   beforeEach(() => {
@@ -25,20 +31,28 @@ describe('ReactIncrementalErrorLogging', () => {
 
     const InternalTestUtils = require('internal-test-utils');
     waitForAll = InternalTestUtils.waitForAll;
-    waitForThrow = InternalTestUtils.waitForThrow;
   });
 
   // Note: in this test file we won't be using toErrorDev() matchers
   // because they filter out precisely the messages we want to test for.
+  let oldConsoleWarn;
   let oldConsoleError;
   beforeEach(() => {
+    oldConsoleWarn = console.warn;
     oldConsoleError = console.error;
+    console.warn = jest.fn();
     console.error = jest.fn();
+    uncaughtExceptionMock = jest.fn();
+    process.on('uncaughtException', uncaughtExceptionMock);
   });
 
   afterEach(() => {
+    console.warn = oldConsoleWarn;
     console.error = oldConsoleError;
+    process.off('uncaughtException', uncaughtExceptionMock);
+    oldConsoleWarn = null;
     oldConsoleError = null;
+    uncaughtExceptionMock = null;
   });
 
   it('should log errors that occur during the begin phase', async () => {
@@ -51,23 +65,27 @@ describe('ReactIncrementalErrorLogging', () => {
         return <div />;
       }
     }
-    ReactNoop.render(
-      <div>
-        <span>
-          <ErrorThrowingComponent />
-        </span>
-      </div>,
+    await fakeAct(() => {
+      ReactNoop.render(
+        <div>
+          <span>
+            <ErrorThrowingComponent />
+          </span>
+        </div>,
+      );
+    });
+    expect(uncaughtExceptionMock).toHaveBeenCalledTimes(1);
+    expect(uncaughtExceptionMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'constructor error',
+      }),
     );
-    await waitForThrow('constructor error');
-    expect(console.error).toHaveBeenCalledTimes(1);
     if (__DEV__) {
-      expect(console.error).toHaveBeenCalledWith(
-        expect.stringContaining('%o'),
-        expect.objectContaining({
-          message: 'constructor error',
-        }),
+      expect(console.warn).toHaveBeenCalledTimes(1);
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining('%s'),
         expect.stringContaining(
-          'The above error occurred in the <ErrorThrowingComponent> component:',
+          'An error occurred in the <ErrorThrowingComponent> component:',
         ),
         expect.stringMatching(
           new RegExp(
@@ -81,12 +99,6 @@ describe('ReactIncrementalErrorLogging', () => {
             'to customize error handling behavior.',
         ),
       );
-    } else {
-      expect(console.error).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'constructor error',
-        }),
-      );
     }
   });
 
@@ -99,23 +111,27 @@ describe('ReactIncrementalErrorLogging', () => {
         return <div />;
       }
     }
-    ReactNoop.render(
-      <div>
-        <span>
-          <ErrorThrowingComponent />
-        </span>
-      </div>,
+    await fakeAct(() => {
+      ReactNoop.render(
+        <div>
+          <span>
+            <ErrorThrowingComponent />
+          </span>
+        </div>,
+      );
+    });
+    expect(uncaughtExceptionMock).toHaveBeenCalledTimes(1);
+    expect(uncaughtExceptionMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'componentDidMount error',
+      }),
     );
-    await waitForThrow('componentDidMount error');
-    expect(console.error).toHaveBeenCalledTimes(1);
     if (__DEV__) {
-      expect(console.error).toHaveBeenCalledWith(
-        expect.stringContaining('%o'),
-        expect.objectContaining({
-          message: 'componentDidMount error',
-        }),
+      expect(console.warn).toHaveBeenCalledTimes(1);
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining('%s'),
         expect.stringContaining(
-          'The above error occurred in the <ErrorThrowingComponent> component:',
+          'An error occurred in the <ErrorThrowingComponent> component:',
         ),
         expect.stringMatching(
           new RegExp(
@@ -129,12 +145,6 @@ describe('ReactIncrementalErrorLogging', () => {
             'to customize error handling behavior.',
         ),
       );
-    } else {
-      expect(console.error).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'componentDidMount error',
-        }),
-      );
     }
   });
 
@@ -145,19 +155,32 @@ describe('ReactIncrementalErrorLogging', () => {
       logCapturedErrorCalls.push(error);
       throw new Error('logCapturedError error');
     });
+
+    class ErrorBoundary extends React.Component {
+      state = {error: null};
+      componentDidCatch(error) {
+        this.setState({error});
+      }
+      render() {
+        return this.state.error ? null : this.props.children;
+      }
+    }
     class ErrorThrowingComponent extends React.Component {
       render() {
         throw new Error('render error');
       }
     }
-    ReactNoop.render(
-      <div>
-        <span>
-          <ErrorThrowingComponent />
-        </span>
-      </div>,
-    );
-    await waitForThrow('render error');
+    await fakeAct(() => {
+      ReactNoop.render(
+        <div>
+          <ErrorBoundary>
+            <span>
+              <ErrorThrowingComponent />
+            </span>
+          </ErrorBoundary>
+        </div>,
+      );
+    });
     expect(logCapturedErrorCalls.length).toBe(1);
     if (__DEV__) {
       expect(console.error).toHaveBeenCalledWith(
@@ -172,12 +195,13 @@ describe('ReactIncrementalErrorLogging', () => {
           new RegExp(
             '\\s+(in|at) ErrorThrowingComponent (.*)\n' +
               '\\s+(in|at) span(.*)\n' +
+              '\\s+(in|at) ErrorBoundary(.*)\n' +
               '\\s+(in|at) div(.*)',
           ),
         ),
         expect.stringContaining(
-          'Consider adding an error boundary to your tree ' +
-            'to customize error handling behavior.',
+          'React will try to recreate this component tree from scratch ' +
+            'using the error boundary you provided, ErrorBoundary.',
         ),
       );
     } else {
diff --git a/packages/react-reconciler/src/__tests__/ReactLazy-test.internal.js b/packages/react-reconciler/src/__tests__/ReactLazy-test.internal.js
index 1eca54518b5a7..4091c064aac8b 100644
--- a/packages/react-reconciler/src/__tests__/ReactLazy-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactLazy-test.internal.js
@@ -121,11 +121,15 @@ describe('ReactLazy', () => {
       },
     }));
 
-    const root = ReactTestRenderer.create(
-      <Suspense fallback={<Text text="Loading..." />}>
-        <LazyText text="Hi" />
-      </Suspense>,
-    );
+    let root;
+    await act(() => {
+      root = ReactTestRenderer.create(
+        <Suspense fallback={<Text text="Loading..." />}>
+          <LazyText text="Hi" />
+        </Suspense>,
+        {unstable_isConcurrent: true},
+      );
+    });
 
     assertLog(['Hi']);
     expect(root).toMatchRenderedOutput('Hi');
@@ -150,13 +154,17 @@ describe('ReactLazy', () => {
       }
     }
 
-    const root = ReactTestRenderer.create(
-      <ErrorBoundary>
-        <Suspense fallback={<Text text="Loading..." />}>
-          <LazyText text="Hi" />
-        </Suspense>
-      </ErrorBoundary>,
-    );
+    let root;
+    await act(() => {
+      root = ReactTestRenderer.create(
+        <ErrorBoundary>
+          <Suspense fallback={<Text text="Loading..." />}>
+            <LazyText text="Hi" />
+          </Suspense>
+        </ErrorBoundary>,
+        {unstable_isConcurrent: true},
+      );
+    });
     assertLog([]);
     expect(root).toMatchRenderedOutput('Error: oh no');
   });
@@ -222,7 +230,7 @@ describe('ReactLazy', () => {
     assertLog(['Loading...']);
     expect(root).not.toMatchRenderedOutput('Hi');
     if (__DEV__) {
-      expect(console.error).toHaveBeenCalledTimes(3);
+      expect(console.error).toHaveBeenCalledTimes(2);
       expect(console.error.mock.calls[0][0]).toContain(
         'Expected the result of a dynamic import() call',
       );
@@ -627,11 +635,15 @@ describe('ReactLazy', () => {
 
     const LazyClass = lazy(() => fakeImport(C));
 
-    const root = ReactTestRenderer.create(
-      <Suspense fallback={<Text text="Loading..." />}>
-        <LazyClass num={1} />
-      </Suspense>,
-    );
+    let root;
+    await act(() => {
+      root = ReactTestRenderer.create(
+        <Suspense fallback={<Text text="Loading..." />}>
+          <LazyClass num={1} />
+        </Suspense>,
+        {unstable_isConcurrent: true},
+      );
+    });
 
     assertLog(['Loading...']);
     await waitForAll([]);
@@ -641,20 +653,24 @@ describe('ReactLazy', () => {
 
     assertLog([]);
 
-    root.update(
-      <Suspense fallback={<Text text="Loading..." />}>
-        <LazyClass num={2} />
-      </Suspense>,
-    );
+    await act(() => {
+      root.update(
+        <Suspense fallback={<Text text="Loading..." />}>
+          <LazyClass num={2} />
+        </Suspense>,
+      );
+    });
 
     assertLog(['UNSAFE_componentWillMount: A', 'A2']);
     expect(root).toMatchRenderedOutput('A2');
 
-    root.update(
-      <Suspense fallback={<Text text="Loading..." />}>
-        <LazyClass num={3} />
-      </Suspense>,
-    );
+    await act(() => {
+      root.update(
+        <Suspense fallback={<Text text="Loading..." />}>
+          <LazyClass num={3} />
+        </Suspense>,
+      );
+    });
     assertLog([
       'UNSAFE_componentWillReceiveProps: A -> A',
       'UNSAFE_componentWillUpdate: A -> A',
@@ -1234,7 +1250,7 @@ describe('ReactLazy', () => {
     expect(componentStackMessage).toContain('in ResolvedText');
   });
 
-  it('should error with a component stack containing Lazy if unresolved', () => {
+  it('should error with a component stack containing Lazy if unresolved', async () => {
     let componentStackMessage;
 
     const LazyText = lazy(() => ({
@@ -1258,13 +1274,16 @@ describe('ReactLazy', () => {
       }
     }
 
-    ReactTestRenderer.create(
-      <ErrorBoundary>
-        <Suspense fallback={<Text text="Loading..." />}>
-          <LazyText text="Hi" />
-        </Suspense>
-      </ErrorBoundary>,
-    );
+    await act(() => {
+      ReactTestRenderer.create(
+        <ErrorBoundary>
+          <Suspense fallback={<Text text="Loading..." />}>
+            <LazyText text="Hi" />
+          </Suspense>
+        </ErrorBoundary>,
+        {unstable_isConcurrent: true},
+      );
+    });
 
     assertLog([]);
 
@@ -1362,79 +1381,6 @@ describe('ReactLazy', () => {
     expect(root).toMatchRenderedOutput('ba');
   });
 
-  it('mount and reorder lazy types (legacy mode)', async () => {
-    class Child extends React.Component {
-      componentDidMount() {
-        Scheduler.log('Did mount: ' + this.props.label);
-      }
-      componentDidUpdate() {
-        Scheduler.log('Did update: ' + this.props.label);
-      }
-      render() {
-        return <Text text={this.props.label} />;
-      }
-    }
-
-    function ChildA({lowerCase}) {
-      return <Child label={lowerCase ? 'a' : 'A'} />;
-    }
-
-    function ChildB({lowerCase}) {
-      return <Child label={lowerCase ? 'b' : 'B'} />;
-    }
-
-    const LazyChildA = lazy(() => {
-      Scheduler.log('Init A');
-      return fakeImport(ChildA);
-    });
-    const LazyChildB = lazy(() => {
-      Scheduler.log('Init B');
-      return fakeImport(ChildB);
-    });
-    const LazyChildA2 = lazy(() => {
-      Scheduler.log('Init A2');
-      return fakeImport(ChildA);
-    });
-    const LazyChildB2 = lazy(() => {
-      Scheduler.log('Init B2');
-      return fakeImport(ChildB);
-    });
-
-    function Parent({swap}) {
-      return (
-        <Suspense fallback={<Text text="Outer..." />}>
-          <Suspense fallback={<Text text="Loading..." />}>
-            {swap
-              ? [
-                  <LazyChildB2 key="B" lowerCase={true} />,
-                  <LazyChildA2 key="A" lowerCase={true} />,
-                ]
-              : [<LazyChildA key="A" />, <LazyChildB key="B" />]}
-          </Suspense>
-        </Suspense>
-      );
-    }
-
-    const root = ReactTestRenderer.create(<Parent swap={false} />, {
-      unstable_isConcurrent: false,
-    });
-
-    assertLog(['Init A', 'Init B', 'Loading...']);
-    expect(root).not.toMatchRenderedOutput('AB');
-
-    await resolveFakeImport(ChildA);
-    await resolveFakeImport(ChildB);
-
-    await waitForAll(['A', 'B', 'Did mount: A', 'Did mount: B']);
-    expect(root).toMatchRenderedOutput('AB');
-
-    // Swap the position of A and B
-    root.update(<Parent swap={true} />);
-    assertLog(['Init B2', 'Loading...']);
-    await waitForAll(['Init A2', 'b', 'a', 'Did update: b', 'Did update: a']);
-    expect(root).toMatchRenderedOutput('ba');
-  });
-
   it('mount and reorder lazy elements', async () => {
     class Child extends React.Component {
       componentDidMount() {
@@ -1504,72 +1450,149 @@ describe('ReactLazy', () => {
     expect(root).toMatchRenderedOutput('ba');
   });
 
-  it('mount and reorder lazy elements (legacy mode)', async () => {
-    class Child extends React.Component {
-      componentDidMount() {
-        Scheduler.log('Did mount: ' + this.props.label);
-      }
-      componentDidUpdate() {
-        Scheduler.log('Did update: ' + this.props.label);
+  describe('legacy mode', () => {
+    // @gate !disableLegacyMode
+    it('mount and reorder lazy elements (legacy mode)', async () => {
+      class Child extends React.Component {
+        componentDidMount() {
+          Scheduler.log('Did mount: ' + this.props.label);
+        }
+        componentDidUpdate() {
+          Scheduler.log('Did update: ' + this.props.label);
+        }
+        render() {
+          return <Text text={this.props.label} />;
+        }
       }
-      render() {
-        return <Text text={this.props.label} />;
+
+      const ChildA = <Child key="A" label="A" />;
+      const lazyChildA = lazy(() => {
+        Scheduler.log('Init A');
+        return fakeImport(ChildA);
+      });
+      const ChildB = <Child key="B" label="B" />;
+      const lazyChildB = lazy(() => {
+        Scheduler.log('Init B');
+        return fakeImport(ChildB);
+      });
+      const ChildA2 = <Child key="A" label="a" />;
+      const lazyChildA2 = lazy(() => {
+        Scheduler.log('Init A2');
+        return fakeImport(ChildA2);
+      });
+      const ChildB2 = <Child key="B" label="b" />;
+      const lazyChildB2 = lazy(() => {
+        Scheduler.log('Init B2');
+        return fakeImport(ChildB2);
+      });
+
+      function Parent({swap}) {
+        return (
+          <Suspense fallback={<Text text="Loading..." />}>
+            {swap ? [lazyChildB2, lazyChildA2] : [lazyChildA, lazyChildB]}
+          </Suspense>
+        );
       }
-    }
 
-    const ChildA = <Child key="A" label="A" />;
-    const lazyChildA = lazy(() => {
-      Scheduler.log('Init A');
-      return fakeImport(ChildA);
-    });
-    const ChildB = <Child key="B" label="B" />;
-    const lazyChildB = lazy(() => {
-      Scheduler.log('Init B');
-      return fakeImport(ChildB);
-    });
-    const ChildA2 = <Child key="A" label="a" />;
-    const lazyChildA2 = lazy(() => {
-      Scheduler.log('Init A2');
-      return fakeImport(ChildA2);
-    });
-    const ChildB2 = <Child key="B" label="b" />;
-    const lazyChildB2 = lazy(() => {
-      Scheduler.log('Init B2');
-      return fakeImport(ChildB2);
-    });
+      const root = ReactTestRenderer.create(<Parent swap={false} />, {
+        unstable_isConcurrent: false,
+      });
 
-    function Parent({swap}) {
-      return (
-        <Suspense fallback={<Text text="Loading..." />}>
-          {swap ? [lazyChildB2, lazyChildA2] : [lazyChildA, lazyChildB]}
-        </Suspense>
-      );
-    }
+      assertLog(['Init A', 'Loading...']);
+      expect(root).not.toMatchRenderedOutput('AB');
 
-    const root = ReactTestRenderer.create(<Parent swap={false} />, {
-      unstable_isConcurrent: false,
+      await resolveFakeImport(ChildA);
+      // We need to flush to trigger the B to load.
+      await waitForAll(['Init B']);
+      await resolveFakeImport(ChildB);
+
+      await waitForAll(['A', 'B', 'Did mount: A', 'Did mount: B']);
+      expect(root).toMatchRenderedOutput('AB');
+
+      // Swap the position of A and B
+      root.update(<Parent swap={true} />);
+      assertLog(['Init B2', 'Loading...']);
+      await resolveFakeImport(ChildB2);
+      // We need to flush to trigger the second one to load.
+      await waitForAll(['Init A2']);
+      await resolveFakeImport(ChildA2);
+
+      await waitForAll(['b', 'a', 'Did update: b', 'Did update: a']);
+      expect(root).toMatchRenderedOutput('ba');
     });
 
-    assertLog(['Init A', 'Loading...']);
-    expect(root).not.toMatchRenderedOutput('AB');
+    // @gate !disableLegacyMode
+    it('mount and reorder lazy types (legacy mode)', async () => {
+      class Child extends React.Component {
+        componentDidMount() {
+          Scheduler.log('Did mount: ' + this.props.label);
+        }
+        componentDidUpdate() {
+          Scheduler.log('Did update: ' + this.props.label);
+        }
+        render() {
+          return <Text text={this.props.label} />;
+        }
+      }
 
-    await resolveFakeImport(ChildA);
-    // We need to flush to trigger the B to load.
-    await waitForAll(['Init B']);
-    await resolveFakeImport(ChildB);
+      function ChildA({lowerCase}) {
+        return <Child label={lowerCase ? 'a' : 'A'} />;
+      }
 
-    await waitForAll(['A', 'B', 'Did mount: A', 'Did mount: B']);
-    expect(root).toMatchRenderedOutput('AB');
+      function ChildB({lowerCase}) {
+        return <Child label={lowerCase ? 'b' : 'B'} />;
+      }
 
-    // Swap the position of A and B
-    root.update(<Parent swap={true} />);
-    assertLog(['Init B2', 'Loading...']);
-    await resolveFakeImport(ChildB2);
-    // We need to flush to trigger the second one to load.
-    await waitForAll(['Init A2']);
-    await resolveFakeImport(ChildA2);
+      const LazyChildA = lazy(() => {
+        Scheduler.log('Init A');
+        return fakeImport(ChildA);
+      });
+      const LazyChildB = lazy(() => {
+        Scheduler.log('Init B');
+        return fakeImport(ChildB);
+      });
+      const LazyChildA2 = lazy(() => {
+        Scheduler.log('Init A2');
+        return fakeImport(ChildA);
+      });
+      const LazyChildB2 = lazy(() => {
+        Scheduler.log('Init B2');
+        return fakeImport(ChildB);
+      });
 
-    await waitForAll(['b', 'a', 'Did update: b', 'Did update: a']);
-    expect(root).toMatchRenderedOutput('ba');
+      function Parent({swap}) {
+        return (
+          <Suspense fallback={<Text text="Outer..." />}>
+            <Suspense fallback={<Text text="Loading..." />}>
+              {swap
+                ? [
+                    <LazyChildB2 key="B" lowerCase={true} />,
+                    <LazyChildA2 key="A" lowerCase={true} />,
+                  ]
+                : [<LazyChildA key="A" />, <LazyChildB key="B" />]}
+            </Suspense>
+          </Suspense>
+        );
+      }
+
+      const root = ReactTestRenderer.create(<Parent swap={false} />, {
+        unstable_isConcurrent: false,
+      });
+
+      assertLog(['Init A', 'Init B', 'Loading...']);
+      expect(root).not.toMatchRenderedOutput('AB');
+
+      await resolveFakeImport(ChildA);
+      await resolveFakeImport(ChildB);
+
+      await waitForAll(['A', 'B', 'Did mount: A', 'Did mount: B']);
+      expect(root).toMatchRenderedOutput('AB');
+
+      // Swap the position of A and B
+      root.update(<Parent swap={true} />);
+      assertLog(['Init B2', 'Loading...']);
+      await waitForAll(['Init A2', 'b', 'a', 'Did update: b', 'Did update: a']);
+      expect(root).toMatchRenderedOutput('ba');
+    });
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js b/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js
index 8f4664a5325a3..14c58cb0d6581 100644
--- a/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js
@@ -289,6 +289,57 @@ describe('ReactSuspense', () => {
     expect(container.textContent).toEqual('AB');
   });
 
+  it('pushes out siblings that render faster than throttle', async () => {
+    function Foo() {
+      Scheduler.log('Foo');
+      return (
+        <Suspense fallback={<Text text="Loading..." />}>
+          <AsyncText text="A" ms={290} />
+          <Suspense fallback={<Text text="Loading more..." />}>
+            <AsyncText text="B" ms={30} />
+          </Suspense>
+        </Suspense>
+      );
+    }
+
+    setTimeout(async () => {
+      // TODO: this is dumb, but AsyncText isn't timer based after the act changes.
+      // Pretend that this is the start of the sibling suspending.
+      // In a real test, the timer would start when we render B.
+      setTimeout(async () => {
+        resolveText('B');
+      }, 30);
+
+      resolveText('A');
+    }, 290);
+
+    // Render an empty shell
+    const root = ReactDOMClient.createRoot(container);
+    root.render(<Foo />);
+    await waitForAll(['Foo', 'Suspend! [A]', 'Loading...']);
+    expect(container.textContent).toEqual('Loading...');
+
+    // Now resolve A
+    jest.advanceTimersByTime(290);
+    await waitFor(['A']);
+    expect(container.textContent).toEqual('Loading...');
+
+    // B starts loading. Parent boundary is in throttle.
+    // Still shows parent loading under throttle
+    jest.advanceTimersByTime(10);
+    await waitForAll(['Suspend! [B]', 'Loading more...']);
+    expect(container.textContent).toEqual('Loading...');
+
+    // !! B could have finished before the throttle, but we show a fallback.
+    // !! Pushing out the 30ms fetch for B to 300ms.
+    jest.advanceTimersByTime(300);
+    await waitFor(['B']);
+    expect(container.textContent).toEqual('ALoading more...');
+
+    await act(() => {});
+    expect(container.textContent).toEqual('AB');
+  });
+
   it('does not throttle fallback committing for too long', async () => {
     function Foo() {
       Scheduler.log('Foo');
diff --git a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js
index f52c33887c257..2d75f2bda18b0 100644
--- a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js
@@ -887,9 +887,11 @@ describe('ReactSuspenseWithNoopRenderer', () => {
   });
 
   // @gate enableLegacyCache
-  it('in legacy mode, errors when an update suspends without a Suspense boundary during a sync update', () => {
+  it('in legacy mode, errors when an update suspends without a Suspense boundary during a sync update', async () => {
     const root = ReactNoop.createLegacyRoot();
-    expect(() => root.render(<AsyncText text="Async" />)).toThrow(
+    await expect(async () => {
+      await act(() => root.render(<AsyncText text="Async" />));
+    }).rejects.toThrow(
       'A component suspended while responding to synchronous input.',
     );
   });
diff --git a/packages/react-reconciler/src/__tests__/StrictEffectsMode-test.js b/packages/react-reconciler/src/__tests__/StrictEffectsMode-test.js
index c1354c47e5a30..f673bf01c2cc0 100644
--- a/packages/react-reconciler/src/__tests__/StrictEffectsMode-test.js
+++ b/packages/react-reconciler/src/__tests__/StrictEffectsMode-test.js
@@ -772,4 +772,177 @@ describe('StrictEffectsMode', () => {
       'useEffect unmount',
     ]);
   });
+
+  // @gate __DEV__
+  it('should double invoke effects after a re-suspend', async () => {
+    // Not using Scheduler.log because it silences double render logs.
+    let log = [];
+    let shouldSuspend = true;
+    let resolve;
+    const suspensePromise = new Promise(_resolve => {
+      resolve = _resolve;
+    });
+    function Fallback() {
+      log.push('Fallback');
+      return 'Loading';
+    }
+
+    function Parent({prop}) {
+      log.push('Parent rendered');
+
+      React.useEffect(() => {
+        log.push('Parent create');
+        return () => {
+          log.push('Parent destroy');
+        };
+      }, []);
+
+      React.useEffect(() => {
+        log.push('Parent dep create');
+        return () => {
+          log.push('Parent dep destroy');
+        };
+      }, [prop]);
+
+      return (
+        <React.Suspense fallback={<Fallback />}>
+          <Child prop={prop} />
+        </React.Suspense>
+      );
+    }
+
+    function Child({prop}) {
+      const [count, forceUpdate] = React.useState(0);
+      const ref = React.useRef(null);
+      log.push('Child rendered');
+      React.useEffect(() => {
+        log.push('Child create');
+        return () => {
+          log.push('Child destroy');
+          ref.current = true;
+        };
+      }, []);
+      const key = `${prop}-${count}`;
+      React.useEffect(() => {
+        log.push('Child dep create');
+        if (ref.current === true) {
+          ref.current = false;
+          forceUpdate(c => c + 1);
+          log.push('-----------------------after setState');
+          return;
+        }
+
+        return () => {
+          log.push('Child dep destroy');
+        };
+      }, [key]);
+
+      if (shouldSuspend) {
+        log.push('Child suspended');
+        throw suspensePromise;
+      }
+      return null;
+    }
+
+    // Initial mount
+    shouldSuspend = false;
+    await act(() => {
+      ReactNoop.render(
+        <React.StrictMode>
+          <Parent />
+        </React.StrictMode>,
+      );
+    });
+
+    // Now re-suspend
+    shouldSuspend = true;
+    log = [];
+    await act(() => {
+      ReactNoop.render(
+        <React.StrictMode>
+          <Parent />
+        </React.StrictMode>,
+      );
+    });
+
+    // while suspended, update
+    log.push('-----------------------after update');
+    await act(() => {
+      ReactNoop.render(
+        <React.StrictMode>
+          <Parent prop={'bar'} />
+        </React.StrictMode>,
+      );
+    });
+
+    // Now resolve and commit
+    log.push('-----------------------after suspense');
+
+    await act(() => {
+      resolve();
+      shouldSuspend = false;
+    });
+
+    if (gate(flags => flags.useModernStrictMode)) {
+      expect(log).toEqual([
+        'Parent rendered',
+        'Parent rendered',
+        'Child rendered',
+        'Child suspended',
+        'Fallback',
+        'Fallback',
+        '-----------------------after update',
+        'Parent rendered',
+        'Parent rendered',
+        'Child rendered',
+        'Child suspended',
+        'Fallback',
+        'Fallback',
+        'Parent dep destroy',
+        'Parent dep create',
+        '-----------------------after suspense',
+        'Child rendered',
+        'Child rendered',
+        // !!! Committed, destroy and create effect.
+        // !!! The other effect is not destroyed and created
+        // !!! because the dep didn't change
+        'Child dep destroy',
+        'Child dep create',
+
+        // Double invoke both effects
+        'Child destroy',
+        'Child dep destroy',
+        'Child create',
+        'Child dep create',
+        // Fires setState
+        '-----------------------after setState',
+        'Child rendered',
+        'Child rendered',
+        'Child dep create',
+      ]);
+    } else {
+      expect(log).toEqual([
+        'Parent rendered',
+        'Parent rendered',
+        'Child rendered',
+        'Child suspended',
+        'Fallback',
+        'Fallback',
+        '-----------------------after update',
+        'Parent rendered',
+        'Parent rendered',
+        'Child rendered',
+        'Child suspended',
+        'Fallback',
+        'Fallback',
+        'Parent dep destroy',
+        'Parent dep create',
+        '-----------------------after suspense',
+        'Child rendered',
+        'Child rendered',
+        'Child dep destroy',
+        'Child dep create',
+      ]);
+    }
+  });
 });
diff --git a/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js b/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js
index c2c6fd21e5987..492b1a4a8906f 100644
--- a/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js
+++ b/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js
@@ -23,7 +23,7 @@
 // So `$$$config` looks like a global variable, but it's
 // really an argument to a top-level wrapping function.
 
-declare var $$$config: any;
+declare const $$$config: any;
 export opaque type Type = mixed; // eslint-disable-line no-undef
 export opaque type Props = mixed; // eslint-disable-line no-undef
 export opaque type Container = mixed; // eslint-disable-line no-undef
@@ -164,34 +164,12 @@ export const clearSuspenseBoundaryFromContainer =
   $$$config.clearSuspenseBoundaryFromContainer;
 export const shouldDeleteUnhydratedTailInstances =
   $$$config.shouldDeleteUnhydratedTailInstances;
-export const didNotMatchHydratedContainerTextInstance =
-  $$$config.didNotMatchHydratedContainerTextInstance;
-export const didNotMatchHydratedTextInstance =
-  $$$config.didNotMatchHydratedTextInstance;
-export const didNotHydrateInstanceWithinContainer =
-  $$$config.didNotHydrateInstanceWithinContainer;
-export const didNotHydrateInstanceWithinSuspenseInstance =
-  $$$config.didNotHydrateInstanceWithinSuspenseInstance;
-export const didNotHydrateInstance = $$$config.didNotHydrateInstance;
-export const didNotFindHydratableInstanceWithinContainer =
-  $$$config.didNotFindHydratableInstanceWithinContainer;
-export const didNotFindHydratableTextInstanceWithinContainer =
-  $$$config.didNotFindHydratableTextInstanceWithinContainer;
-export const didNotFindHydratableSuspenseInstanceWithinContainer =
-  $$$config.didNotFindHydratableSuspenseInstanceWithinContainer;
-export const didNotFindHydratableInstanceWithinSuspenseInstance =
-  $$$config.didNotFindHydratableInstanceWithinSuspenseInstance;
-export const didNotFindHydratableTextInstanceWithinSuspenseInstance =
-  $$$config.didNotFindHydratableTextInstanceWithinSuspenseInstance;
-export const didNotFindHydratableSuspenseInstanceWithinSuspenseInstance =
-  $$$config.didNotFindHydratableSuspenseInstanceWithinSuspenseInstance;
-export const didNotFindHydratableInstance =
-  $$$config.didNotFindHydratableInstance;
-export const didNotFindHydratableTextInstance =
-  $$$config.didNotFindHydratableTextInstance;
-export const didNotFindHydratableSuspenseInstance =
-  $$$config.didNotFindHydratableSuspenseInstance;
-export const errorHydratingContainer = $$$config.errorHydratingContainer;
+export const diffHydratedPropsForDevWarnings =
+  $$$config.diffHydratedPropsForDevWarnings;
+export const diffHydratedTextForDevWarnings =
+  $$$config.diffHydratedTextForDevWarnings;
+export const describeHydratableInstanceForDevWarnings =
+  $$$config.describeHydratableInstanceForDevWarnings;
 export const validateHydratableInstance = $$$config.validateHydratableInstance;
 export const validateHydratableTextInstance =
   $$$config.validateHydratableTextInstance;
diff --git a/packages/react-reconciler/src/forks/ReactFiberErrorDialog.native.js b/packages/react-reconciler/src/forks/ReactFiberErrorDialog.native.js
deleted file mode 100644
index 9883128cc2623..0000000000000
--- a/packages/react-reconciler/src/forks/ReactFiberErrorDialog.native.js
+++ /dev/null
@@ -1,37 +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.
- *
- * @flow
- */
-
-import type {Fiber} from '../ReactFiber';
-import type {CapturedValue} from '../ReactCapturedValue';
-
-import {ClassComponent} from '../ReactWorkTags';
-
-// Module provided by RN:
-import {ReactFiberErrorDialog as RNImpl} from 'react-native/Libraries/ReactPrivate/ReactNativePrivateInterface';
-
-if (typeof RNImpl.showErrorDialog !== 'function') {
-  throw new Error(
-    'Expected ReactFiberErrorDialog.showErrorDialog to be a function.',
-  );
-}
-
-export function showErrorDialog(
-  boundary: Fiber,
-  errorInfo: CapturedValue<mixed>,
-): boolean {
-  const capturedError = {
-    componentStack: errorInfo.stack !== null ? errorInfo.stack : '',
-    error: errorInfo.value,
-    errorBoundary:
-      boundary !== null && boundary.tag === ClassComponent
-        ? boundary.stateNode
-        : null,
-  };
-  return RNImpl.showErrorDialog(capturedError);
-}
diff --git a/packages/react-reconciler/src/forks/ReactFiberErrorDialog.www.js b/packages/react-reconciler/src/forks/ReactFiberErrorDialog.www.js
deleted file mode 100644
index 0f7eaef803f38..0000000000000
--- a/packages/react-reconciler/src/forks/ReactFiberErrorDialog.www.js
+++ /dev/null
@@ -1,37 +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.
- *
- * @flow
- */
-
-import type {Fiber} from '../ReactFiber';
-import type {CapturedValue} from '../ReactCapturedValue';
-
-import {ClassComponent} from '../ReactWorkTags';
-
-// Provided by www
-const ReactFiberErrorDialogWWW = require('ReactFiberErrorDialog');
-
-if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== 'function') {
-  throw new Error(
-    'Expected ReactFiberErrorDialog.showErrorDialog to be a function.',
-  );
-}
-
-export function showErrorDialog(
-  boundary: Fiber,
-  errorInfo: CapturedValue<mixed>,
-): boolean {
-  const capturedError = {
-    componentStack: errorInfo.stack !== null ? errorInfo.stack : '',
-    error: errorInfo.value,
-    errorBoundary:
-      boundary !== null && boundary.tag === ClassComponent
-        ? boundary.stateNode
-        : null,
-  };
-  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
-}
diff --git a/packages/react-refresh/src/ReactFreshBabelPlugin.js b/packages/react-refresh/src/ReactFreshBabelPlugin.js
index fa8ba43f16062..9592a994399e5 100644
--- a/packages/react-refresh/src/ReactFreshBabelPlugin.js
+++ b/packages/react-refresh/src/ReactFreshBabelPlugin.js
@@ -244,6 +244,8 @@ export default function (babel, opts = {}) {
       case 'React.useFormStatus':
       case 'useFormState':
       case 'React.useFormState':
+      case 'useActionState':
+      case 'React.useActionState':
       case 'useOptimistic':
       case 'React.useOptimistic':
         return true;
diff --git a/packages/react-refresh/src/__tests__/ReactFresh-test.js b/packages/react-refresh/src/__tests__/ReactFresh-test.js
index 2f0def9063190..13ded584199e4 100644
--- a/packages/react-refresh/src/__tests__/ReactFresh-test.js
+++ b/packages/react-refresh/src/__tests__/ReactFresh-test.js
@@ -71,7 +71,15 @@ describe('ReactFresh', () => {
     return Component;
   }
 
-  function patch(version) {
+  async function patch(version) {
+    const Component = version();
+    await act(() => {
+      ReactFreshRuntime.performReactRefresh();
+    });
+    return Component;
+  }
+
+  function patchSync(version) {
     const Component = version();
     ReactFreshRuntime.performReactRefresh();
     return Component;
@@ -124,7 +132,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const HelloV2 = patch(() => {
+      const HelloV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -217,7 +225,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const OuterV2 = patch(() => {
+      const OuterV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -348,7 +356,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Patch to change the color.
-      const ParentV2 = patch(() => {
+      const ParentV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -435,7 +443,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello({color}) {
           const [val, setVal] = React.useState(0);
           return (
@@ -489,7 +497,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update of just the rendering function.
-      patch(() => {
+      await patch(() => {
         function Hello({color}) {
           const [val, setVal] = React.useState(0);
           return (
@@ -543,7 +551,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const OuterV2 = patch(() => {
+      const OuterV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -632,7 +640,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const OuterV2 = patch(() => {
+      const OuterV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -719,7 +727,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update of just the rendering function.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -768,7 +776,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const OuterV2 = patch(() => {
+      const OuterV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -880,7 +888,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const AppV2 = patch(() => {
+      const AppV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1003,7 +1011,7 @@ describe('ReactFresh', () => {
       expect(container.textContent).toBe('Loading');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1033,7 +1041,7 @@ describe('ReactFresh', () => {
       expect(el.style.color).toBe('red');
 
       // Test another reload.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1087,7 +1095,7 @@ describe('ReactFresh', () => {
       expect(container.textContent).toBe('Loading');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function renderHello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1118,7 +1126,7 @@ describe('ReactFresh', () => {
       expect(el.style.color).toBe('red');
 
       // Test another reload.
-      patch(() => {
+      await patch(() => {
         function renderHello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1173,7 +1181,7 @@ describe('ReactFresh', () => {
       expect(container.textContent).toBe('Loading');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function renderHello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1204,7 +1212,7 @@ describe('ReactFresh', () => {
       expect(el.style.color).toBe('red');
 
       // Test another reload.
-      patch(() => {
+      await patch(() => {
         function renderHello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1259,7 +1267,7 @@ describe('ReactFresh', () => {
       expect(container.textContent).toBe('Loading');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function renderHello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1290,7 +1298,7 @@ describe('ReactFresh', () => {
       expect(el.style.color).toBe('red');
 
       // Test another reload.
-      patch(() => {
+      await patch(() => {
         function renderHello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1358,7 +1366,7 @@ describe('ReactFresh', () => {
       expect(primaryChild.style.display).toBe('');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello({children}) {
           const [val, setVal] = React.useState(0);
           return (
@@ -1404,7 +1412,7 @@ describe('ReactFresh', () => {
       expect(fallbackChild.style.display).toBe('');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello({children}) {
           const [val, setVal] = React.useState(0);
           return (
@@ -1436,7 +1444,7 @@ describe('ReactFresh', () => {
       expect(primaryChild.style.display).toBe('');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello({children}) {
           const [val, setVal] = React.useState(0);
           return (
@@ -1492,7 +1500,7 @@ describe('ReactFresh', () => {
       expect(appRenders).toBe(1);
 
       // Perform a hot update for Hello only.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1552,7 +1560,7 @@ describe('ReactFresh', () => {
       expect(container.textContent).toBe('XXXXXXXXXX');
       helloRenders = 0;
 
-      patch(() => {
+      await patch(() => {
         function Hello({children}) {
           helloRenders++;
           return <div>O{children}O</div>;
@@ -1619,7 +1627,7 @@ describe('ReactFresh', () => {
       expect(el2.textContent).toBe('1');
 
       // Perform a hot update for both inner components.
-      patch(() => {
+      await patch(() => {
         function Hello1() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1681,7 +1689,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const HelloV2 = patch(() => {
+      const HelloV2 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1702,7 +1710,7 @@ describe('ReactFresh', () => {
       expect(el.style.color).toBe('red');
 
       // Perform a hot update.
-      const HelloV3 = patch(() => {
+      const HelloV3 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1743,7 +1751,7 @@ describe('ReactFresh', () => {
       expect(newEl.style.color).toBe('yellow');
 
       // Verify we can patch again while preserving the signature.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1763,7 +1771,7 @@ describe('ReactFresh', () => {
       expect(newEl.style.color).toBe('purple');
 
       // Check removing the signature also causes a remount.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -1940,7 +1948,7 @@ describe('ReactFresh', () => {
   }, 10000);
 
   async function runRemountingStressTest(tree) {
-    patch(() => {
+    await patch(() => {
       function Hello({children}) {
         return <section data-color="blue">{children}</section>;
       }
@@ -1961,7 +1969,7 @@ describe('ReactFresh', () => {
     });
 
     // Patch color without changing the signature.
-    patch(() => {
+    await patch(() => {
       function Hello({children}) {
         return <section data-color="red">{children}</section>;
       }
@@ -1980,7 +1988,7 @@ describe('ReactFresh', () => {
     });
 
     // Patch color *and* change the signature.
-    patch(() => {
+    await patch(() => {
       function Hello({children}) {
         return <section data-color="orange">{children}</section>;
       }
@@ -1999,7 +2007,7 @@ describe('ReactFresh', () => {
     });
 
     // Now patch color but *don't* change the signature.
-    patch(() => {
+    await patch(() => {
       function Hello({children}) {
         return <section data-color="black">{children}</section>;
       }
@@ -2229,7 +2237,7 @@ describe('ReactFresh', () => {
     expect(el.textContent).toBe('1');
 
     // Perform a hot update that doesn't remount.
-    patch(() => {
+    await patch(() => {
       function Hello() {
         const [val, setVal] = React.useState(0);
         return (
@@ -2250,7 +2258,7 @@ describe('ReactFresh', () => {
     expect(el.style.color).toBe('red');
 
     // Perform a hot update that remounts.
-    patch(() => {
+    await patch(() => {
       function Hello() {
         const [val, setVal] = React.useState(0);
         return (
@@ -2279,7 +2287,7 @@ describe('ReactFresh', () => {
     expect(newEl.style.color).toBe('yellow');
 
     // Verify we can patch again while preserving the signature.
-    patch(() => {
+    await patch(() => {
       function Hello() {
         const [val, setVal] = React.useState(0);
         return (
@@ -2299,7 +2307,7 @@ describe('ReactFresh', () => {
     expect(newEl.style.color).toBe('purple');
 
     // Check removing the signature also causes a remount.
-    patch(() => {
+    await patch(() => {
       function Hello() {
         const [val, setVal] = React.useState(0);
         return (
@@ -2356,7 +2364,7 @@ describe('ReactFresh', () => {
       expect(useEffectWithEmptyArrayCalls).toBe(1); // useEffect didn't re-run
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           const tranformed = React.useMemo(() => val * 10, [val]);
@@ -2413,7 +2421,7 @@ describe('ReactFresh', () => {
       expect(el.style.color).toBe('blue');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const source = React.useMemo(() => ({value: 20}), []);
           const [state, setState] = React.useState({value: null});
@@ -2468,7 +2476,7 @@ describe('ReactFresh', () => {
     expect(el.firstChild).toBe(null); // Offscreen content not flushed yet.
 
     // Perform a hot update.
-    patch(() => {
+    patchSync(() => {
       function Hello() {
         React.useLayoutEffect(() => {
           Scheduler.log('Hello#layout');
@@ -2507,7 +2515,7 @@ describe('ReactFresh', () => {
     expect(el.firstChild.style.color).toBe('red');
 
     // Hot reload while we're offscreen.
-    patch(() => {
+    patchSync(() => {
       function Hello() {
         React.useLayoutEffect(() => {
           Scheduler.log('Hello#layout');
@@ -2575,7 +2583,7 @@ describe('ReactFresh', () => {
       const secondP = firstP.nextSibling.nextSibling;
 
       // Perform a hot update that fails.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           throw new Error('No');
         }
@@ -2587,7 +2595,7 @@ describe('ReactFresh', () => {
       expect(container.firstChild.nextSibling.nextSibling).toBe(secondP);
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Fixed!</h1>;
         }
@@ -2601,7 +2609,7 @@ describe('ReactFresh', () => {
 
       // Verify next hot reload doesn't remount anything.
       const helloNode = container.firstChild.nextSibling;
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Nice.</h1>;
         }
@@ -2653,7 +2661,7 @@ describe('ReactFresh', () => {
       const secondP = firstP.nextSibling.nextSibling;
 
       // Perform a hot update that fails.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           throw new Error('No');
         }
@@ -2665,7 +2673,7 @@ describe('ReactFresh', () => {
       expect(container.firstChild.nextSibling.nextSibling).toBe(secondP);
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Fixed!</h1>;
         }
@@ -2679,7 +2687,7 @@ describe('ReactFresh', () => {
 
       // Verify next hot reload doesn't remount anything.
       const helloNode = container.firstChild.nextSibling;
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Nice.</h1>;
         }
@@ -2735,7 +2743,7 @@ describe('ReactFresh', () => {
 
       // Perform a hot update that fails.
       let crash;
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [x, setX] = React.useState('');
           React.useEffect(() => {
@@ -2761,7 +2769,7 @@ describe('ReactFresh', () => {
       expect(container.firstChild.nextSibling.nextSibling).toBe(secondP);
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [x] = React.useState('');
           React.useEffect(() => {}, []); // Removes the bad effect code.
@@ -2778,7 +2786,7 @@ describe('ReactFresh', () => {
 
       // Verify next hot reload doesn't remount anything.
       const helloNode = container.firstChild.nextSibling;
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [x] = React.useState('');
           React.useEffect(() => {}, []);
@@ -2808,18 +2816,18 @@ describe('ReactFresh', () => {
       expect(container.innerHTML).toBe('');
 
       // A bad retry
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('Not yet');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('Not yet');
+      }).rejects.toThrow('Not yet');
       expect(container.innerHTML).toBe('');
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Fixed!</h1>;
         }
@@ -2829,25 +2837,25 @@ describe('ReactFresh', () => {
       expect(container.innerHTML).toBe('<h1>Fixed!</h1>');
 
       // Ensure we can keep failing and recovering later.
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('No 2');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('No 2');
+      }).rejects.toThrow('No 2');
       expect(container.innerHTML).toBe('');
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('Not yet 2');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('Not yet 2');
+      }).rejects.toThrow('Not yet 2');
       expect(container.innerHTML).toBe('');
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Fixed 2!</h1>;
         }
@@ -2859,14 +2867,14 @@ describe('ReactFresh', () => {
       await act(() => {
         root.unmount();
       });
-      patch(() => {
+      await patch(() => {
         function Hello() {
           throw new Error('Ignored');
         }
         $RefreshReg$(Hello, 'Hello');
       });
       expect(container.innerHTML).toBe('');
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Ignored</h1>;
         }
@@ -2896,7 +2904,7 @@ describe('ReactFresh', () => {
       });
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Fixed!</h1>;
         }
@@ -2921,29 +2929,29 @@ describe('ReactFresh', () => {
 
       // Perform a hot update that fails.
       // This removes the root.
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('No');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('No');
+      }).rejects.toThrow('No');
       expect(container.innerHTML).toBe('');
 
       // A bad retry
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('Not yet');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('Not yet');
+      }).rejects.toThrow('Not yet');
       expect(container.innerHTML).toBe('');
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Fixed!</h1>;
         }
@@ -2954,7 +2962,7 @@ describe('ReactFresh', () => {
 
       // Verify next hot reload doesn't remount anything.
       const helloNode = container.firstChild;
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Nice.</h1>;
         }
@@ -2964,18 +2972,18 @@ describe('ReactFresh', () => {
       expect(helloNode.textContent).toBe('Nice.');
 
       // Break again.
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('Oops');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('Oops');
+      }).rejects.toThrow('Oops');
       expect(container.innerHTML).toBe('');
 
       // Perform a hot update that fixes the error.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>At last.</h1>;
         }
@@ -2989,7 +2997,7 @@ describe('ReactFresh', () => {
         root.unmount();
       });
       expect(container.innerHTML).toBe('');
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Never mind me!</h1>;
         }
@@ -3010,14 +3018,14 @@ describe('ReactFresh', () => {
       expect(container.innerHTML).toBe('<h1>Hi</h1>');
 
       // Break again.
-      expect(() => {
-        patch(() => {
+      await expect(async () => {
+        await patch(() => {
           function Hello() {
             throw new Error('Oops');
           }
           $RefreshReg$(Hello, 'Hello');
         });
-      }).toThrow('Oops');
+      }).rejects.toThrow('Oops');
       expect(container.innerHTML).toBe('');
 
       // Check we don't attempt to reverse an intentional unmount, even after an error.
@@ -3025,7 +3033,7 @@ describe('ReactFresh', () => {
         root.unmount();
       });
       expect(container.innerHTML).toBe('');
-      patch(() => {
+      await patch(() => {
         function Hello() {
           return <h1>Never mind me!</h1>;
         }
@@ -3139,7 +3147,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      const HelloV2 = patch(() => {
+      const HelloV2 = await patch(() => {
         class Hello extends React.Component {
           state = {count: 0};
           handleClick = () => {
@@ -3176,7 +3184,7 @@ describe('ReactFresh', () => {
       expect(newEl.style.color).toBe('red');
       expect(newEl.textContent).toBe('1');
 
-      const HelloV3 = patch(() => {
+      const HelloV3 = await patch(() => {
         class Hello extends React.Component {
           state = {count: 0};
           handleClick = () => {
@@ -3235,7 +3243,7 @@ describe('ReactFresh', () => {
       );
       expect(testRef.current.getColor()).toBe('green');
 
-      patch(() => {
+      await patch(() => {
         class Hello extends React.Component {
           getColor() {
             return 'orange';
@@ -3248,7 +3256,7 @@ describe('ReactFresh', () => {
       });
       expect(testRef.current.getColor()).toBe('orange');
 
-      patch(() => {
+      await patch(() => {
         const Hello = React.forwardRef((props, ref) => {
           React.useImperativeHandle(ref, () => ({
             getColor() {
@@ -3261,7 +3269,7 @@ describe('ReactFresh', () => {
       });
       expect(testRef.current.getColor()).toBe('pink');
 
-      patch(() => {
+      await patch(() => {
         const Hello = React.forwardRef((props, ref) => {
           React.useImperativeHandle(ref, () => ({
             getColor() {
@@ -3274,7 +3282,7 @@ describe('ReactFresh', () => {
       });
       expect(testRef.current.getColor()).toBe('yellow');
 
-      patch(() => {
+      await patch(() => {
         const Hello = React.forwardRef((props, ref) => {
           React.useImperativeHandle(ref, () => ({
             getColor() {
@@ -3314,7 +3322,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update that turns it into a class.
-      const HelloV2 = patch(() => {
+      const HelloV2 = await patch(() => {
         class Hello extends React.Component {
           state = {count: 0};
           handleClick = () => {
@@ -3352,7 +3360,7 @@ describe('ReactFresh', () => {
       expect(newEl.textContent).toBe('1');
 
       // Now convert it back to a function.
-      const HelloV3 = patch(() => {
+      const HelloV3 = await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -3383,7 +3391,7 @@ describe('ReactFresh', () => {
       expect(finalEl.textContent).toBe('1');
 
       // Now that it's a function, verify edits keep state.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
@@ -3872,7 +3880,7 @@ describe('ReactFresh', () => {
       expect(el.textContent).toBe('1');
 
       // Perform a hot update.
-      patch(() => {
+      await patch(() => {
         function Hello() {
           const [val, setVal] = React.useState(0);
           return (
diff --git a/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js b/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js
index ed8c56072a217..c1e5f308b2202 100644
--- a/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js
+++ b/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js
@@ -1639,54 +1639,6 @@ describe('ReactFreshIntegration', () => {
       }
     });
 
-    if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-      it('remounts deprecated factory components', async () => {
-        if (__DEV__) {
-          await expect(async () => {
-            await render(`
-              function Parent() {
-                return {
-                  render() {
-                    return <Child prop="A" />;
-                  }
-                };
-              };
-
-              function Child({prop}) {
-                return <h1>{prop}1</h1>;
-              };
-
-              export default Parent;
-            `);
-          }).toErrorDev(
-            'The <Parent /> component appears to be a function component ' +
-              'that returns a class instance.',
-          );
-          const el = container.firstChild;
-          expect(el.textContent).toBe('A1');
-          await patch(`
-            function Parent() {
-              return {
-                render() {
-                  return <Child prop="B" />;
-                }
-              };
-            };
-
-            function Child({prop}) {
-              return <h1>{prop}2</h1>;
-            };
-
-            export default Parent;
-          `);
-          // Like classes, factory components always remount.
-          expect(container.firstChild).not.toBe(el);
-          const newEl = container.firstChild;
-          expect(newEl.textContent).toBe('B2');
-        }
-      });
-    }
-
     describe('with inline requires', () => {
       beforeEach(() => {
         global.FakeModuleSystem = {};
diff --git a/packages/react-server-dom-esm/package.json b/packages/react-server-dom-esm/package.json
index 5073ccc53edce..39fbff3a0270e 100644
--- a/packages/react-server-dom-esm/package.json
+++ b/packages/react-server-dom-esm/package.json
@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-esm",
   "description": "React Server Components bindings for DOM using ESM. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "keywords": [
     "react"
   ],
@@ -47,8 +47,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
   },
   "dependencies": {
     "acorn-loose": "^8.3.0"
diff --git a/packages/react-server-dom-esm/src/ReactFlightDOMClientBrowser.js b/packages/react-server-dom-esm/src/ReactFlightDOMClientBrowser.js
index eabe0546913f0..dbc4430ec1d8f 100644
--- a/packages/react-server-dom-esm/src/ReactFlightDOMClientBrowser.js
+++ b/packages/react-server-dom-esm/src/ReactFlightDOMClientBrowser.js
@@ -26,11 +26,18 @@ import {
   createServerReference,
 } from 'react-client/src/ReactFlightReplyClient';
 
+import type {TemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export {createTemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export type {TemporaryReferenceSet};
+
 type CallServerCallback = <A, T>(string, args: A) => Promise<T>;
 
 export type Options = {
   moduleBaseURL?: string,
   callServer?: CallServerCallback,
+  temporaryReferences?: TemporaryReferenceSet,
 };
 
 function createResponseFromOptions(options: void | Options) {
@@ -40,6 +47,9 @@ function createResponseFromOptions(options: void | Options) {
     options && options.callServer ? options.callServer : undefined,
     undefined, // encodeFormAction
     undefined, // nonce
+    options && options.temporaryReferences
+      ? options.temporaryReferences
+      : undefined,
   );
 }
 
@@ -97,11 +107,20 @@ function createFromFetch<T>(
 
 function encodeReply(
   value: ReactServerValue,
+  options?: {temporaryReferences?: TemporaryReferenceSet},
 ): Promise<
   string | URLSearchParams | FormData,
 > /* We don't use URLSearchParams yet but maybe */ {
   return new Promise((resolve, reject) => {
-    processReply(value, '', resolve, reject);
+    processReply(
+      value,
+      '',
+      options && options.temporaryReferences
+        ? options.temporaryReferences
+        : undefined,
+      resolve,
+      reject,
+    );
   });
 }
 
diff --git a/packages/react-server-dom-esm/src/ReactFlightDOMClientNode.js b/packages/react-server-dom-esm/src/ReactFlightDOMClientNode.js
index 71bbcbd577397..97a9ec0a08476 100644
--- a/packages/react-server-dom-esm/src/ReactFlightDOMClientNode.js
+++ b/packages/react-server-dom-esm/src/ReactFlightDOMClientNode.js
@@ -60,6 +60,7 @@ function createFromNodeStream<T>(
     noServerCall,
     options ? options.encodeFormAction : undefined,
     options && typeof options.nonce === 'string' ? options.nonce : undefined,
+    undefined, // TODO: If encodeReply is supported, this should support temporaryReferences
   );
   stream.on('data', chunk => {
     processBinaryChunk(response, chunk);
diff --git a/packages/react-server-dom-turbopack/package.json b/packages/react-server-dom-turbopack/package.json
index 60a908b8efd39..fd489c6c23fc7 100644
--- a/packages/react-server-dom-turbopack/package.json
+++ b/packages/react-server-dom-turbopack/package.json
@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-turbopack",
   "description": "React Server Components bindings for DOM using Turbopack. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "keywords": [
     "react"
   ],
@@ -79,8 +79,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
   },
   "dependencies": {
     "acorn-loose": "^8.3.0",
diff --git a/packages/react-server-dom-turbopack/src/ReactFlightDOMClientBrowser.js b/packages/react-server-dom-turbopack/src/ReactFlightDOMClientBrowser.js
index 108040653114d..2f5a554b5ac4a 100644
--- a/packages/react-server-dom-turbopack/src/ReactFlightDOMClientBrowser.js
+++ b/packages/react-server-dom-turbopack/src/ReactFlightDOMClientBrowser.js
@@ -26,10 +26,17 @@ import {
   createServerReference,
 } from 'react-client/src/ReactFlightReplyClient';
 
+import type {TemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export {createTemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export type {TemporaryReferenceSet};
+
 type CallServerCallback = <A, T>(string, args: A) => Promise<T>;
 
 export type Options = {
   callServer?: CallServerCallback,
+  temporaryReferences?: TemporaryReferenceSet,
 };
 
 function createResponseFromOptions(options: void | Options) {
@@ -39,6 +46,9 @@ function createResponseFromOptions(options: void | Options) {
     options && options.callServer ? options.callServer : undefined,
     undefined, // encodeFormAction
     undefined, // nonce
+    options && options.temporaryReferences
+      ? options.temporaryReferences
+      : undefined,
   );
 }
 
@@ -96,11 +106,20 @@ function createFromFetch<T>(
 
 function encodeReply(
   value: ReactServerValue,
+  options?: {temporaryReferences?: TemporaryReferenceSet},
 ): Promise<
   string | URLSearchParams | FormData,
 > /* We don't use URLSearchParams yet but maybe */ {
   return new Promise((resolve, reject) => {
-    processReply(value, '', resolve, reject);
+    processReply(
+      value,
+      '',
+      options && options.temporaryReferences
+        ? options.temporaryReferences
+        : undefined,
+      resolve,
+      reject,
+    );
   });
 }
 
diff --git a/packages/react-server-dom-turbopack/src/ReactFlightDOMClientEdge.js b/packages/react-server-dom-turbopack/src/ReactFlightDOMClientEdge.js
index 5e379d3baa2f5..57ed079c5af2a 100644
--- a/packages/react-server-dom-turbopack/src/ReactFlightDOMClientEdge.js
+++ b/packages/react-server-dom-turbopack/src/ReactFlightDOMClientEdge.js
@@ -36,6 +36,12 @@ import {
   createServerReference as createServerReferenceImpl,
 } from 'react-client/src/ReactFlightReplyClient';
 
+import type {TemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export {createTemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export type {TemporaryReferenceSet};
+
 function noServerCall() {
   throw new Error(
     'Server Functions cannot be called during initial render. ' +
@@ -60,6 +66,7 @@ export type Options = {
   ssrManifest: SSRManifest,
   nonce?: string,
   encodeFormAction?: EncodeFormActionCallback,
+  temporaryReferences?: TemporaryReferenceSet,
 };
 
 function createResponseFromOptions(options: Options) {
@@ -69,6 +76,9 @@ function createResponseFromOptions(options: Options) {
     noServerCall,
     options.encodeFormAction,
     typeof options.nonce === 'string' ? options.nonce : undefined,
+    options && options.temporaryReferences
+      ? options.temporaryReferences
+      : undefined,
   );
 }
 
@@ -126,11 +136,20 @@ function createFromFetch<T>(
 
 function encodeReply(
   value: ReactServerValue,
+  options?: {temporaryReferences?: TemporaryReferenceSet},
 ): Promise<
   string | URLSearchParams | FormData,
 > /* We don't use URLSearchParams yet but maybe */ {
   return new Promise((resolve, reject) => {
-    processReply(value, '', resolve, reject);
+    processReply(
+      value,
+      '',
+      options && options.temporaryReferences
+        ? options.temporaryReferences
+        : undefined,
+      resolve,
+      reject,
+    );
   });
 }
 
diff --git a/packages/react-server-dom-turbopack/src/ReactFlightDOMClientNode.js b/packages/react-server-dom-turbopack/src/ReactFlightDOMClientNode.js
index 180f595dd9a08..b34958424c1cb 100644
--- a/packages/react-server-dom-turbopack/src/ReactFlightDOMClientNode.js
+++ b/packages/react-server-dom-turbopack/src/ReactFlightDOMClientNode.js
@@ -69,6 +69,7 @@ function createFromNodeStream<T>(
     noServerCall,
     options ? options.encodeFormAction : undefined,
     options && typeof options.nonce === 'string' ? options.nonce : undefined,
+    undefined, // TODO: If encodeReply is supported, this should support temporaryReferences
   );
   stream.on('data', chunk => {
     processBinaryChunk(response, chunk);
diff --git a/packages/react-server-dom-turbopack/src/__tests__/ReactFlightTurbopackDOMForm-test.js b/packages/react-server-dom-turbopack/src/__tests__/ReactFlightTurbopackDOMForm-test.js
index 3f63222d0ae2d..e7da697fad8e9 100644
--- a/packages/react-server-dom-turbopack/src/__tests__/ReactFlightTurbopackDOMForm-test.js
+++ b/packages/react-server-dom-turbopack/src/__tests__/ReactFlightTurbopackDOMForm-test.js
@@ -111,7 +111,6 @@ describe('ReactFlightDOMForm', () => {
     insertNodesAndExecuteScripts(temp, container, null);
   }
 
-  // @gate enableFormActions
   it('can submit a passed server action without hydrating it', async () => {
     let foo = null;
 
diff --git a/packages/react-server-dom-webpack/package.json b/packages/react-server-dom-webpack/package.json
index d7418ee1cbfa0..8516b3e2e1166 100644
--- a/packages/react-server-dom-webpack/package.json
+++ b/packages/react-server-dom-webpack/package.json
@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-webpack",
   "description": "React Server Components bindings for DOM using Webpack. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "keywords": [
     "react"
   ],
@@ -79,8 +79,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "webpack": "^5.59.0"
   },
   "dependencies": {
diff --git a/packages/react-server-dom-webpack/src/ReactFlightDOMClientBrowser.js b/packages/react-server-dom-webpack/src/ReactFlightDOMClientBrowser.js
index 108040653114d..2f5a554b5ac4a 100644
--- a/packages/react-server-dom-webpack/src/ReactFlightDOMClientBrowser.js
+++ b/packages/react-server-dom-webpack/src/ReactFlightDOMClientBrowser.js
@@ -26,10 +26,17 @@ import {
   createServerReference,
 } from 'react-client/src/ReactFlightReplyClient';
 
+import type {TemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export {createTemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export type {TemporaryReferenceSet};
+
 type CallServerCallback = <A, T>(string, args: A) => Promise<T>;
 
 export type Options = {
   callServer?: CallServerCallback,
+  temporaryReferences?: TemporaryReferenceSet,
 };
 
 function createResponseFromOptions(options: void | Options) {
@@ -39,6 +46,9 @@ function createResponseFromOptions(options: void | Options) {
     options && options.callServer ? options.callServer : undefined,
     undefined, // encodeFormAction
     undefined, // nonce
+    options && options.temporaryReferences
+      ? options.temporaryReferences
+      : undefined,
   );
 }
 
@@ -96,11 +106,20 @@ function createFromFetch<T>(
 
 function encodeReply(
   value: ReactServerValue,
+  options?: {temporaryReferences?: TemporaryReferenceSet},
 ): Promise<
   string | URLSearchParams | FormData,
 > /* We don't use URLSearchParams yet but maybe */ {
   return new Promise((resolve, reject) => {
-    processReply(value, '', resolve, reject);
+    processReply(
+      value,
+      '',
+      options && options.temporaryReferences
+        ? options.temporaryReferences
+        : undefined,
+      resolve,
+      reject,
+    );
   });
 }
 
diff --git a/packages/react-server-dom-webpack/src/ReactFlightDOMClientEdge.js b/packages/react-server-dom-webpack/src/ReactFlightDOMClientEdge.js
index 5e379d3baa2f5..57ed079c5af2a 100644
--- a/packages/react-server-dom-webpack/src/ReactFlightDOMClientEdge.js
+++ b/packages/react-server-dom-webpack/src/ReactFlightDOMClientEdge.js
@@ -36,6 +36,12 @@ import {
   createServerReference as createServerReferenceImpl,
 } from 'react-client/src/ReactFlightReplyClient';
 
+import type {TemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export {createTemporaryReferenceSet} from 'react-client/src/ReactFlightTemporaryReferences';
+
+export type {TemporaryReferenceSet};
+
 function noServerCall() {
   throw new Error(
     'Server Functions cannot be called during initial render. ' +
@@ -60,6 +66,7 @@ export type Options = {
   ssrManifest: SSRManifest,
   nonce?: string,
   encodeFormAction?: EncodeFormActionCallback,
+  temporaryReferences?: TemporaryReferenceSet,
 };
 
 function createResponseFromOptions(options: Options) {
@@ -69,6 +76,9 @@ function createResponseFromOptions(options: Options) {
     noServerCall,
     options.encodeFormAction,
     typeof options.nonce === 'string' ? options.nonce : undefined,
+    options && options.temporaryReferences
+      ? options.temporaryReferences
+      : undefined,
   );
 }
 
@@ -126,11 +136,20 @@ function createFromFetch<T>(
 
 function encodeReply(
   value: ReactServerValue,
+  options?: {temporaryReferences?: TemporaryReferenceSet},
 ): Promise<
   string | URLSearchParams | FormData,
 > /* We don't use URLSearchParams yet but maybe */ {
   return new Promise((resolve, reject) => {
-    processReply(value, '', resolve, reject);
+    processReply(
+      value,
+      '',
+      options && options.temporaryReferences
+        ? options.temporaryReferences
+        : undefined,
+      resolve,
+      reject,
+    );
   });
 }
 
diff --git a/packages/react-server-dom-webpack/src/ReactFlightDOMClientNode.js b/packages/react-server-dom-webpack/src/ReactFlightDOMClientNode.js
index 180f595dd9a08..b34958424c1cb 100644
--- a/packages/react-server-dom-webpack/src/ReactFlightDOMClientNode.js
+++ b/packages/react-server-dom-webpack/src/ReactFlightDOMClientNode.js
@@ -69,6 +69,7 @@ function createFromNodeStream<T>(
     noServerCall,
     options ? options.encodeFormAction : undefined,
     options && typeof options.nonce === 'string' ? options.nonce : undefined,
+    undefined, // TODO: If encodeReply is supported, this should support temporaryReferences
   );
   stream.on('data', chunk => {
     processBinaryChunk(response, chunk);
diff --git a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMForm-test.js b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMForm-test.js
index 4ac9663237af6..e90a361806816 100644
--- a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMForm-test.js
+++ b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMForm-test.js
@@ -31,7 +31,7 @@ let ReactDOMServer;
 let ReactServerDOMServer;
 let ReactServerDOMClient;
 let ReactDOMClient;
-let useFormState;
+let useActionState;
 let act;
 
 describe('ReactFlightDOMForm', () => {
@@ -55,7 +55,13 @@ describe('ReactFlightDOMForm', () => {
     ReactDOMServer = require('react-dom/server.edge');
     ReactDOMClient = require('react-dom/client');
     act = React.act;
-    useFormState = require('react-dom').useFormState;
+
+    if (__VARIANT__) {
+      // Remove after API is deleted.
+      useActionState = require('react-dom').useFormState;
+    } else {
+      useActionState = require('react').useActionState;
+    }
     container = document.createElement('div');
     document.body.appendChild(container);
   });
@@ -127,7 +133,6 @@ describe('ReactFlightDOMForm', () => {
     insertNodesAndExecuteScripts(temp, container, null);
   }
 
-  // @gate enableFormActions
   it('can submit a passed server action without hydrating it', async () => {
     let foo = null;
 
@@ -162,7 +167,6 @@ describe('ReactFlightDOMForm', () => {
     expect(foo).toBe('bar');
   });
 
-  // @gate enableFormActions
   it('can submit an imported server action without hydrating it', async () => {
     let foo = null;
 
@@ -195,7 +199,6 @@ describe('ReactFlightDOMForm', () => {
     expect(foo).toBe('bar');
   });
 
-  // @gate enableFormActions
   it('can submit a complex closure server action without hydrating it', async () => {
     let foo = null;
 
@@ -230,7 +233,6 @@ describe('ReactFlightDOMForm', () => {
     expect(foo).toBe('barobject');
   });
 
-  // @gate enableFormActions
   it('can submit a multiple complex closure server action without hydrating it', async () => {
     let foo = null;
 
@@ -271,7 +273,6 @@ describe('ReactFlightDOMForm', () => {
     expect(foo).toBe('barc');
   });
 
-  // @gate enableFormActions
   it('can bind an imported server action on the client without hydrating it', async () => {
     let foo = null;
 
@@ -303,7 +304,6 @@ describe('ReactFlightDOMForm', () => {
     expect(foo).toBe('barobject');
   });
 
-  // @gate enableFormActions
   it('can bind a server action on the client without hydrating it', async () => {
     let foo = null;
 
@@ -344,9 +344,8 @@ describe('ReactFlightDOMForm', () => {
     expect(foo).toBe('barobject');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it("useFormState's dispatch binds the initial state to the provided action", async () => {
+  it("useActionState's dispatch binds the initial state to the provided action", async () => {
     const serverAction = serverExports(
       async function action(prevState, formData) {
         return {
@@ -358,7 +357,7 @@ describe('ReactFlightDOMForm', () => {
 
     const initialState = {count: 1};
     function Client({action}) {
-      const [state, dispatch, isPending] = useFormState(action, initialState);
+      const [state, dispatch, isPending] = useActionState(action, initialState);
       return (
         <form action={dispatch}>
           <span>{isPending ? 'Pending...' : ''}</span>
@@ -393,9 +392,8 @@ describe('ReactFlightDOMForm', () => {
     expect(await returnValue).toEqual({count: 6});
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('useFormState can reuse state during MPA form submission', async () => {
+  it('useActionState can reuse state during MPA form submission', async () => {
     const serverAction = serverExports(
       async function action(prevState, formData) {
         return prevState + 1;
@@ -403,7 +401,7 @@ describe('ReactFlightDOMForm', () => {
     );
 
     function Form({action}) {
-      const [count, dispatch, isPending] = useFormState(action, 1);
+      const [count, dispatch, isPending] = useActionState(action, 1);
       return (
         <form action={dispatch}>
           {isPending ? 'Pending...' : ''}
@@ -483,10 +481,9 @@ describe('ReactFlightDOMForm', () => {
     }
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
   it(
-    'useFormState preserves state if arity is the same, but different ' +
+    'useActionState preserves state if arity is the same, but different ' +
       'arguments are bound (i.e. inline closure)',
     async () => {
       const serverAction = serverExports(
@@ -496,7 +493,7 @@ describe('ReactFlightDOMForm', () => {
       );
 
       function Form({action}) {
-        const [count, dispatch, isPending] = useFormState(action, 1);
+        const [count, dispatch, isPending] = useActionState(action, 1);
         return (
           <form action={dispatch}>
             {isPending ? 'Pending...' : ''}
@@ -603,9 +600,8 @@ describe('ReactFlightDOMForm', () => {
     },
   );
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('useFormState does not reuse state if action signatures are different', async () => {
+  it('useActionState does not reuse state if action signatures are different', async () => {
     // This is the same as the previous test, except instead of using bind to
     // configure the server action (i.e. a closure), it swaps the action.
     const increaseBy1 = serverExports(
@@ -621,7 +617,7 @@ describe('ReactFlightDOMForm', () => {
     );
 
     function Form({action}) {
-      const [count, dispatch, isPending] = useFormState(action, 1);
+      const [count, dispatch, isPending] = useActionState(action, 1);
       return (
         <form action={dispatch}>
           {isPending ? 'Pending...' : ''}
@@ -691,9 +687,8 @@ describe('ReactFlightDOMForm', () => {
     expect(container.textContent).toBe('111');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('when permalink is provided, useFormState compares that instead of the keypath', async () => {
+  it('when permalink is provided, useActionState compares that instead of the keypath', async () => {
     const serverAction = serverExports(
       async function action(prevState, formData) {
         return prevState + 1;
@@ -701,7 +696,7 @@ describe('ReactFlightDOMForm', () => {
     );
 
     function Form({action, permalink}) {
-      const [count, dispatch, isPending] = useFormState(action, 1, permalink);
+      const [count, dispatch, isPending] = useActionState(action, 1, permalink);
       return (
         <form action={dispatch}>
           {isPending ? 'Pending...' : ''}
@@ -798,16 +793,15 @@ describe('ReactFlightDOMForm', () => {
     expect(container.textContent).toBe('1');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('useFormState can change the action URL with the `permalink` argument', async () => {
+  it('useActionState can change the action URL with the `permalink` argument', async () => {
     const serverAction = serverExports(function action(prevState) {
       return {state: prevState.count + 1};
     });
 
     const initialState = {count: 1};
     function Client({action}) {
-      const [state, dispatch, isPending] = useFormState(
+      const [state, dispatch, isPending] = useActionState(
         action,
         initialState,
         '/permalink',
@@ -844,9 +838,8 @@ describe('ReactFlightDOMForm', () => {
     expect(form.action).toBe('http://localhost/permalink');
   });
 
-  // @gate enableFormActions
   // @gate enableAsyncActions
-  it('useFormState `permalink` is coerced to string', async () => {
+  it('useActionState `permalink` is coerced to string', async () => {
     const serverAction = serverExports(function action(prevState) {
       return {state: prevState.count + 1};
     });
@@ -861,7 +854,7 @@ describe('ReactFlightDOMForm', () => {
 
     const initialState = {count: 1};
     function Client({action}) {
-      const [state, dispatch, isPending] = useFormState(
+      const [state, dispatch, isPending] = useActionState(
         action,
         initialState,
         permalink,
@@ -897,4 +890,76 @@ describe('ReactFlightDOMForm', () => {
 
     expect(form.action).toBe('http://localhost/permalink');
   });
+
+  // @gate enableAsyncActions
+  it('useActionState can return JSX state during MPA form submission', async () => {
+    const serverAction = serverExports(
+      async function action(prevState, formData) {
+        return <div>error message</div>;
+      },
+    );
+
+    function Form({action}) {
+      const [errorMsg, dispatch] = useActionState(action, null);
+      return <form action={dispatch}>{errorMsg}</form>;
+    }
+
+    const FormRef = await clientExports(Form);
+
+    const rscStream = ReactServerDOMServer.renderToReadableStream(
+      <FormRef action={serverAction} />,
+      webpackMap,
+    );
+    const response = ReactServerDOMClient.createFromReadableStream(rscStream, {
+      ssrManifest: {
+        moduleMap: null,
+        moduleLoading: null,
+      },
+    });
+    const ssrStream = await ReactDOMServer.renderToReadableStream(response);
+    await readIntoContainer(ssrStream);
+
+    const form1 = container.getElementsByTagName('form')[0];
+    expect(form1.textContent).toBe('');
+
+    async function submitTheForm() {
+      const form = container.getElementsByTagName('form')[0];
+      const {formState} = await submit(form);
+
+      // Simulate an MPA form submission by resetting the container and
+      // rendering again.
+      container.innerHTML = '';
+
+      const postbackRscStream = ReactServerDOMServer.renderToReadableStream(
+        <FormRef action={serverAction} />,
+        webpackMap,
+      );
+      const postbackResponse = ReactServerDOMClient.createFromReadableStream(
+        postbackRscStream,
+        {
+          ssrManifest: {
+            moduleMap: null,
+            moduleLoading: null,
+          },
+        },
+      );
+      const postbackSsrStream = await ReactDOMServer.renderToReadableStream(
+        postbackResponse,
+        {formState: formState},
+      );
+      await readIntoContainer(postbackSsrStream);
+    }
+
+    await expect(submitTheForm).toErrorDev(
+      'Warning: Failed to serialize an action for progressive enhancement:\n' +
+        'Error: React Element cannot be passed to Server Functions from the Client without a temporary reference set. Pass a TemporaryReferenceSet to the options.\n' +
+        '  [<div/>]\n' +
+        '   ^^^^^^',
+    );
+
+    // The error message was returned as JSX.
+    const form2 = container.getElementsByTagName('form')[0];
+    expect(form2.textContent).toBe('error message');
+    expect(form2.firstChild.tagName).toBe('DIV');
+  });
 });
diff --git a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMReply-test.js b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMReply-test.js
index 1162d1d0fe738..938937dba2afb 100644
--- a/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMReply-test.js
+++ b/packages/react-server-dom-webpack/src/__tests__/ReactFlightDOMReply-test.js
@@ -17,6 +17,7 @@ global.TextDecoder = require('util').TextDecoder;
 
 // let serverExports;
 let webpackServerMap;
+let React;
 let ReactServerDOMServer;
 let ReactServerDOMClient;
 
@@ -31,6 +32,7 @@ describe('ReactFlightDOMReply', () => {
     const WebpackMock = require('./utils/WebpackMock');
     // serverExports = WebpackMock.serverExports;
     webpackServerMap = WebpackMock.webpackServerMap;
+    React = require('react');
     ReactServerDOMServer = require('react-server-dom-webpack/server.browser');
     jest.resetModules();
     ReactServerDOMClient = require('react-server-dom-webpack/client');
@@ -241,4 +243,107 @@ describe('ReactFlightDOMReply', () => {
     }
     expect(error.message).toBe('Connection closed.');
   });
+
+  it('resolves a promise and includes its value', async () => {
+    let resolve;
+    const promise = new Promise(r => (resolve = r));
+    const bodyPromise = ReactServerDOMClient.encodeReply({promise: promise});
+    resolve('Hi');
+    const result = await ReactServerDOMServer.decodeReply(await bodyPromise);
+    expect(await result.promise).toBe('Hi');
+  });
+
+  it('resolves a React.lazy and includes its value', async () => {
+    let resolve;
+    const lazy = React.lazy(() => new Promise(r => (resolve = r)));
+    const bodyPromise = ReactServerDOMClient.encodeReply({lazy: lazy});
+    resolve({default: 'Hi'});
+    const result = await ReactServerDOMServer.decodeReply(await bodyPromise);
+    expect(result.lazy).toBe('Hi');
+  });
+
+  it('resolves a proxy throwing a promise inside React.lazy', async () => {
+    let resolve1;
+    let resolve2;
+    const lazy = React.lazy(() => new Promise(r => (resolve1 = r)));
+    const promise = new Promise(r => (resolve2 = r));
+    const bodyPromise1 = ReactServerDOMClient.encodeReply({lazy: lazy});
+    const target = {value: ''};
+    let loaded = false;
+    const proxy = new Proxy(target, {
+      get(targetObj, prop, receiver) {
+        if (prop === 'value') {
+          if (!loaded) {
+            throw promise;
+          }
+          return 'Hello';
+        }
+        return targetObj[prop];
+      },
+    });
+    await resolve1({default: proxy});
+
+    // Encode it again so that we have an already initialized lazy
+    // This is now already resolved but the proxy inside isn't. This ensures
+    // we trigger the retry code path.
+    const bodyPromise2 = ReactServerDOMClient.encodeReply({lazy: lazy});
+
+    // Then resolve the inner thrown promise.
+    loaded = true;
+    await resolve2('Hello');
+
+    const result1 = await ReactServerDOMServer.decodeReply(await bodyPromise1);
+    expect(await result1.lazy.value).toBe('Hello');
+    const result2 = await ReactServerDOMServer.decodeReply(await bodyPromise2);
+    expect(await result2.lazy.value).toBe('Hello');
+  });
+
+  it('errors when called with JSX by default', async () => {
+    let error;
+    try {
+      await ReactServerDOMClient.encodeReply(<div />);
+    } catch (x) {
+      error = x;
+    }
+    expect(error).toEqual(
+      expect.objectContaining({
+        message: __DEV__
+          ? expect.stringContaining(
+              'React Element cannot be passed to Server Functions from the Client without a temporary reference set.',
+            )
+          : expect.stringContaining(''),
+      }),
+    );
+  });
+
+  it('can pass JSX through a round trip using temporary references', async () => {
+    function Component() {
+      return <div />;
+    }
+
+    const children = <Component />;
+
+    const temporaryReferences =
+      ReactServerDOMClient.createTemporaryReferenceSet();
+    const body = await ReactServerDOMClient.encodeReply(
+      {children},
+      {
+        temporaryReferences,
+      },
+    );
+    const serverPayload = await ReactServerDOMServer.decodeReply(
+      body,
+      webpackServerMap,
+    );
+    const stream = ReactServerDOMServer.renderToReadableStream(serverPayload);
+    const response = await ReactServerDOMClient.createFromReadableStream(
+      stream,
+      {
+        temporaryReferences,
+      },
+    );
+
+    // This should've been the same reference that we already saw.
+    expect(response.children).toBe(children);
+  });
 });
diff --git a/packages/react-server/src/ReactFizzClassComponent.js b/packages/react-server/src/ReactFizzClassComponent.js
index 27eef61884ad2..4a10d3db562cd 100644
--- a/packages/react-server/src/ReactFizzClassComponent.js
+++ b/packages/react-server/src/ReactFizzClassComponent.js
@@ -371,14 +371,14 @@ function checkClassInstance(instance: any, ctor: any, newProps: any) {
     if (disableLegacyContext) {
       if (ctor.childContextTypes) {
         console.error(
-          '%s uses the legacy childContextTypes API which is no longer supported. ' +
+          '%s uses the legacy childContextTypes API which was removed in React 19. ' +
             'Use React.createContext() instead.',
           name,
         );
       }
       if (ctor.contextTypes) {
         console.error(
-          '%s uses the legacy contextTypes API which is no longer supported. ' +
+          '%s uses the legacy contextTypes API which was removed in React 19. ' +
             'Use React.createContext() with static contextType instead.',
           name,
         );
diff --git a/packages/react-server/src/ReactFizzHooks.js b/packages/react-server/src/ReactFizzHooks.js
index efcb05bcba941..5caff3ca14751 100644
--- a/packages/react-server/src/ReactFizzHooks.js
+++ b/packages/react-server/src/ReactFizzHooks.js
@@ -35,7 +35,6 @@ import {
   enableUseEffectEventHook,
   enableUseMemoCacheHook,
   enableAsyncActions,
-  enableFormActions,
   enableUseDeferredValueInitialArg,
 } from 'shared/ReactFeatureFlags';
 import is from 'shared/objectIs';
@@ -79,11 +78,11 @@ let didScheduleRenderPhaseUpdate: boolean = false;
 let localIdCounter: number = 0;
 // Chunks that should be pushed to the stream once the component
 // finishes rendering.
-// Counts the number of useFormState calls in this component
-let formStateCounter: number = 0;
-// The index of the useFormState hook that matches the one passed in at the
+// Counts the number of useActionState calls in this component
+let actionStateCounter: number = 0;
+// The index of the useActionState hook that matches the one passed in at the
 // root during an MPA navigation, if any.
-let formStateMatchingIndex: number = -1;
+let actionStateMatchingIndex: number = -1;
 // Counts the number of use(thenable) calls in this component
 let thenableIndexCounter: number = 0;
 let thenableState: ThenableState | null = null;
@@ -224,8 +223,8 @@ export function prepareToUseHooks(
   // workInProgressHook = null;
 
   localIdCounter = 0;
-  formStateCounter = 0;
-  formStateMatchingIndex = -1;
+  actionStateCounter = 0;
+  actionStateMatchingIndex = -1;
   thenableIndexCounter = 0;
   thenableState = prevThenableState;
 }
@@ -246,8 +245,8 @@ export function finishHooks(
     // restarting until no more updates are scheduled.
     didScheduleRenderPhaseUpdate = false;
     localIdCounter = 0;
-    formStateCounter = 0;
-    formStateMatchingIndex = -1;
+    actionStateCounter = 0;
+    actionStateMatchingIndex = -1;
     thenableIndexCounter = 0;
     numberOfReRenders += 1;
 
@@ -275,17 +274,17 @@ export function checkDidRenderIdHook(): boolean {
   return didRenderIdHook;
 }
 
-export function getFormStateCount(): number {
+export function getActionStateCount(): number {
   // This should be called immediately after every finishHooks call.
   // Conceptually, it's part of the return value of finishHooks; it's only a
   // separate function to avoid using an array tuple.
-  return formStateCounter;
+  return actionStateCounter;
 }
-export function getFormStateMatchingIndex(): number {
+export function getActionStateMatchingIndex(): number {
   // This should be called immediately after every finishHooks call.
   // Conceptually, it's part of the return value of finishHooks; it's only a
   // separate function to avoid using an array tuple.
-  return formStateMatchingIndex;
+  return actionStateMatchingIndex;
 }
 
 // Reset the internal hooks state if an error occurs while rendering a component
@@ -592,7 +591,7 @@ function useOptimistic<S, A>(
   return [passthrough, unsupportedSetOptimisticState];
 }
 
-function createPostbackFormStateKey(
+function createPostbackActionStateKey(
   permalink: string | void,
   componentKeyPath: KeyNode | null,
   hookIndex: number,
@@ -611,17 +610,17 @@ function createPostbackFormStateKey(
   }
 }
 
-function useFormState<S, P>(
+function useActionState<S, P>(
   action: (Awaited<S>, P) => S,
   initialState: Awaited<S>,
   permalink?: string,
 ): [Awaited<S>, (P) => void, boolean] {
   resolveCurrentlyRenderingComponent();
 
-  // Count the number of useFormState hooks per component. We also use this to
-  // track the position of this useFormState hook relative to the other ones in
+  // Count the number of useActionState hooks per component. We also use this to
+  // track the position of this useActionState hook relative to the other ones in
   // this component, so we can generate a unique key for each one.
-  const formStateHookIndex = formStateCounter++;
+  const actionStateHookIndex = actionStateCounter++;
   const request: Request = (currentlyRenderingRequest: any);
 
   // $FlowIgnore[prop-missing]
@@ -630,7 +629,7 @@ function useFormState<S, P>(
     // This is a server action. These have additional features to enable
     // MPA-style form submissions with progressive enhancement.
 
-    // TODO: If the same permalink is passed to multiple useFormStates, and
+    // TODO: If the same permalink is passed to multiple useActionStates, and
     // they all have the same action signature, Fizz will pass the postback
     // state to all of them. We should probably only pass it to the first one,
     // and/or warn.
@@ -641,30 +640,33 @@ function useFormState<S, P>(
 
     // Determine the current form state. If we received state during an MPA form
     // submission, then we will reuse that, if the action identity matches.
-    // Otherwise we'll use the initial state argument. We will emit a comment
+    // Otherwise, we'll use the initial state argument. We will emit a comment
     // marker into the stream that indicates whether the state was reused.
     let state = initialState;
     const componentKeyPath = (currentlyRenderingKeyPath: any);
-    const postbackFormState = getFormState(request);
+    const postbackActionState = getFormState(request);
     // $FlowIgnore[prop-missing]
     const isSignatureEqual = action.$$IS_SIGNATURE_EQUAL;
-    if (postbackFormState !== null && typeof isSignatureEqual === 'function') {
-      const postbackKey = postbackFormState[1];
-      const postbackReferenceId = postbackFormState[2];
-      const postbackBoundArity = postbackFormState[3];
+    if (
+      postbackActionState !== null &&
+      typeof isSignatureEqual === 'function'
+    ) {
+      const postbackKey = postbackActionState[1];
+      const postbackReferenceId = postbackActionState[2];
+      const postbackBoundArity = postbackActionState[3];
       if (
         isSignatureEqual.call(action, postbackReferenceId, postbackBoundArity)
       ) {
-        nextPostbackStateKey = createPostbackFormStateKey(
+        nextPostbackStateKey = createPostbackActionStateKey(
           permalink,
           componentKeyPath,
-          formStateHookIndex,
+          actionStateHookIndex,
         );
         if (postbackKey === nextPostbackStateKey) {
           // This was a match
-          formStateMatchingIndex = formStateHookIndex;
+          actionStateMatchingIndex = actionStateHookIndex;
           // Reuse the state that was submitted by the form.
-          state = postbackFormState[0];
+          state = postbackActionState[0];
         }
       }
     }
@@ -696,10 +698,10 @@ function useFormState<S, P>(
         const formData = metadata.data;
         if (formData) {
           if (nextPostbackStateKey === null) {
-            nextPostbackStateKey = createPostbackFormStateKey(
+            nextPostbackStateKey = createPostbackActionStateKey(
               permalink,
               componentKeyPath,
-              formStateHookIndex,
+              actionStateHookIndex,
             );
           }
           formData.append('$ACTION_KEY', nextPostbackStateKey);
@@ -814,12 +816,13 @@ if (enableUseEffectEventHook) {
 if (enableUseMemoCacheHook) {
   HooksDispatcher.useMemoCache = useMemoCache;
 }
-if (enableFormActions && enableAsyncActions) {
+if (enableAsyncActions) {
   HooksDispatcher.useHostTransitionStatus = useHostTransitionStatus;
 }
 if (enableAsyncActions) {
   HooksDispatcher.useOptimistic = useOptimistic;
-  HooksDispatcher.useFormState = useFormState;
+  HooksDispatcher.useFormState = useActionState;
+  HooksDispatcher.useActionState = useActionState;
 }
 
 export let currentResumableState: null | ResumableState = (null: any);
diff --git a/packages/react-server/src/ReactFizzServer.js b/packages/react-server/src/ReactFizzServer.js
index 7085a54a4c52b..f49fca69b6485 100644
--- a/packages/react-server/src/ReactFizzServer.js
+++ b/packages/react-server/src/ReactFizzServer.js
@@ -106,8 +106,8 @@ import {
   setCurrentResumableState,
   getThenableStateAfterSuspending,
   unwrapThenable,
-  getFormStateCount,
-  getFormStateMatchingIndex,
+  getActionStateCount,
+  getActionStateMatchingIndex,
 } from './ReactFizzHooks';
 import {DefaultCacheDispatcher} from './ReactFizzCache';
 import {getStackByComponentStackNode} from './ReactFizzComponentStack';
@@ -137,11 +137,9 @@ import {
 import ReactSharedInternals from 'shared/ReactSharedInternals';
 import {
   disableLegacyContext,
-  disableModulePatternComponents,
   enableBigIntSupport,
   enableScopeAPI,
   enableSuspenseAvoidThisFallbackFizz,
-  enableFloat,
   enableCache,
   enablePostpone,
   enableRenderableContext,
@@ -1441,8 +1439,8 @@ function renderIndeterminateComponent(
     legacyContext,
   );
   const hasId = checkDidRenderIdHook();
-  const formStateCount = getFormStateCount();
-  const formStateMatchingIndex = getFormStateMatchingIndex();
+  const actionStateCount = getActionStateCount();
+  const actionStateMatchingIndex = getActionStateMatchingIndex();
 
   if (__DEV__) {
     // Support for module components is deprecated and is removed behind a flag.
@@ -1470,58 +1468,28 @@ function renderIndeterminateComponent(
     }
   }
 
-  if (
-    // Run these checks in production only if the flag is off.
-    // Eventually we'll delete this branch altogether.
-    !disableModulePatternComponents &&
-    typeof value === 'object' &&
-    value !== null &&
-    typeof value.render === 'function' &&
-    value.$$typeof === undefined
-  ) {
-    if (__DEV__) {
-      const componentName = getComponentNameFromType(Component) || 'Unknown';
-      if (!didWarnAboutModulePatternComponent[componentName]) {
-        console.error(
-          'The <%s /> component appears to be a function component that returns a class instance. ' +
-            'Change %s to a class that extends React.Component instead. ' +
-            "If you can't use a class try assigning the prototype on the function as a workaround. " +
-            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
-            'cannot be called with `new` by React.',
-          componentName,
-          componentName,
-          componentName,
-        );
-        didWarnAboutModulePatternComponent[componentName] = true;
-      }
-    }
-
-    mountClassInstance(value, Component, props, legacyContext);
-    finishClassComponent(request, task, keyPath, value, Component, props);
-  } else {
-    // Proceed under the assumption that this is a function component
-    if (__DEV__) {
-      if (disableLegacyContext && Component.contextTypes) {
-        console.error(
-          '%s uses the legacy contextTypes API which is no longer supported. ' +
-            'Use React.createContext() with React.useContext() instead.',
-          getComponentNameFromType(Component) || 'Unknown',
-        );
-      }
-    }
-    if (__DEV__) {
-      validateFunctionComponentInDev(Component);
+  // Proceed under the assumption that this is a function component
+  if (__DEV__) {
+    if (disableLegacyContext && Component.contextTypes) {
+      console.error(
+        '%s uses the legacy contextTypes API which was removed in React 19. ' +
+          'Use React.createContext() with React.useContext() instead.',
+        getComponentNameFromType(Component) || 'Unknown',
+      );
     }
-    finishFunctionComponent(
-      request,
-      task,
-      keyPath,
-      value,
-      hasId,
-      formStateCount,
-      formStateMatchingIndex,
-    );
   }
+  if (__DEV__) {
+    validateFunctionComponentInDev(Component);
+  }
+  finishFunctionComponent(
+    request,
+    task,
+    keyPath,
+    value,
+    hasId,
+    actionStateCount,
+    actionStateMatchingIndex,
+  );
   task.componentStack = previousComponentStack;
 }
 
@@ -1531,22 +1499,22 @@ function finishFunctionComponent(
   keyPath: KeyNode,
   children: ReactNodeList,
   hasId: boolean,
-  formStateCount: number,
-  formStateMatchingIndex: number,
+  actionStateCount: number,
+  actionStateMatchingIndex: number,
 ) {
-  let didEmitFormStateMarkers = false;
-  if (formStateCount !== 0 && request.formState !== null) {
-    // For each useFormState hook, emit a marker that indicates whether we
+  let didEmitActionStateMarkers = false;
+  if (actionStateCount !== 0 && request.formState !== null) {
+    // For each useActionState hook, emit a marker that indicates whether we
     // rendered using the form state passed at the root. We only emit these
     // markers if form state is passed at the root.
     const segment = task.blockedSegment;
     if (segment === null) {
       // Implies we're in reumable mode.
     } else {
-      didEmitFormStateMarkers = true;
+      didEmitActionStateMarkers = true;
       const target = segment.chunks;
-      for (let i = 0; i < formStateCount; i++) {
-        if (i === formStateMatchingIndex) {
+      for (let i = 0; i < actionStateCount; i++) {
+        if (i === actionStateMatchingIndex) {
           pushFormStateMarkerIsMatching(target);
         } else {
           pushFormStateMarkerIsNotMatching(target);
@@ -1570,8 +1538,8 @@ function finishFunctionComponent(
     // Like the other contexts, this does not need to be in a finally block
     // because renderNode takes care of unwinding the stack.
     task.treeContext = prevTreeContext;
-  } else if (didEmitFormStateMarkers) {
-    // If there were formState hooks, we must use the non-destructive path
+  } else if (didEmitActionStateMarkers) {
+    // If there were useActionState hooks, we must use the non-destructive path
     // because this component is not a pure indirection; we emitted markers
     // to the stream.
     renderNode(request, task, children, -1);
@@ -1691,16 +1659,16 @@ function renderForwardRef(
     ref,
   );
   const hasId = checkDidRenderIdHook();
-  const formStateCount = getFormStateCount();
-  const formStateMatchingIndex = getFormStateMatchingIndex();
+  const actionStateCount = getActionStateCount();
+  const actionStateMatchingIndex = getActionStateMatchingIndex();
   finishFunctionComponent(
     request,
     task,
     keyPath,
     children,
     hasId,
-    formStateCount,
-    formStateMatchingIndex,
+    actionStateCount,
+    actionStateMatchingIndex,
   );
   task.componentStack = previousComponentStack;
 }
@@ -3820,12 +3788,8 @@ function flushSegment(
     const id = boundary.rootSegmentID;
     writeStartPendingSuspenseBoundary(destination, request.renderState, id);
 
-    // We are going to flush the fallback so we need to hoist the fallback
-    // state to the parent boundary
-    if (enableFloat) {
-      if (hoistableState) {
-        hoistHoistables(hoistableState, boundary.fallbackState);
-      }
+    if (hoistableState) {
+      hoistHoistables(hoistableState, boundary.fallbackState);
     }
     // Flush the fallback.
     flushSubtree(request, destination, segment, hoistableState);
@@ -3859,10 +3823,8 @@ function flushSegment(
 
     return writeEndPendingSuspenseBoundary(destination, request.renderState);
   } else {
-    if (enableFloat) {
-      if (hoistableState) {
-        hoistHoistables(hoistableState, boundary.contentState);
-      }
+    if (hoistableState) {
+      hoistHoistables(hoistableState, boundary.contentState);
     }
     // We can inline this boundary's content as a complete boundary.
     writeStartCompletedSuspenseBoundary(destination, request.renderState);
@@ -3927,14 +3889,11 @@ function flushCompletedBoundary(
   }
   completedSegments.length = 0;
 
-  if (enableFloat) {
-    writeHoistablesForBoundary(
-      destination,
-      boundary.contentState,
-      request.renderState,
-    );
-  }
-
+  writeHoistablesForBoundary(
+    destination,
+    boundary.contentState,
+    request.renderState,
+  );
   return writeCompletedBoundaryInstruction(
     destination,
     request.resumableState,
@@ -3965,15 +3924,11 @@ function flushPartialBoundary(
   }
   completedSegments.splice(0, i);
 
-  if (enableFloat) {
-    return writeHoistablesForBoundary(
-      destination,
-      boundary.contentState,
-      request.renderState,
-    );
-  } else {
-    return true;
-  }
+  return writeHoistablesForBoundary(
+    destination,
+    boundary.contentState,
+    request.renderState,
+  );
 }
 
 function flushPartiallyCompletedSegment(
@@ -4035,10 +3990,7 @@ function flushCompletedQueues(
         // We postponed the root, so we write nothing.
         return;
       } else if (request.pendingRootTasks === 0) {
-        if (enableFloat) {
-          flushPreamble(request, destination, completedRootSegment);
-        }
-
+        flushPreamble(request, destination, completedRootSegment);
         flushSegment(request, destination, completedRootSegment, null);
         request.completedRootSegment = null;
         writeCompletedRoot(destination, request.renderState);
@@ -4047,10 +3999,7 @@ function flushCompletedQueues(
         return;
       }
     }
-    if (enableFloat) {
-      writeHoistables(destination, request.resumableState, request.renderState);
-    }
-
+    writeHoistables(destination, request.resumableState, request.renderState);
     // We emit client rendering instructions for already emitted boundaries first.
     // This is so that we can signal to the client to start client rendering them as
     // soon as possible.
@@ -4126,12 +4075,10 @@ function flushCompletedQueues(
       // either they have pending task or they're complete.
     ) {
       request.flushScheduled = false;
-      if (enableFloat) {
-        // 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);
-        }
+      // 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);
       }
       completeWriting(destination);
       flushBuffered(destination);
diff --git a/packages/react-server/src/ReactFlightReplyServer.js b/packages/react-server/src/ReactFlightReplyServer.js
index 291da7870760e..98d9c0fe046e6 100644
--- a/packages/react-server/src/ReactFlightReplyServer.js
+++ b/packages/react-server/src/ReactFlightReplyServer.js
@@ -24,6 +24,8 @@ import {
   requireModule,
 } from 'react-client/src/ReactFlightClientConfig';
 
+import {createTemporaryReference} from './ReactFlightServerTemporaryReferences';
+
 export type JSONValue =
   | number
   | null
@@ -394,10 +396,6 @@ function parseModelString(
         const chunk = getChunk(response, id);
         return chunk;
       }
-      case 'S': {
-        // Symbol
-        return Symbol.for(value.slice(2));
-      }
       case 'F': {
         // Server Reference
         const id = parseInt(value.slice(2), 16);
@@ -413,6 +411,10 @@ function parseModelString(
           key,
         );
       }
+      case 'T': {
+        // Temporary Reference
+        return createTemporaryReference(value.slice(2));
+      }
       case 'Q': {
         // Map
         const id = parseInt(value.slice(2), 16);
diff --git a/packages/react-server/src/ReactFlightServer.js b/packages/react-server/src/ReactFlightServer.js
index 02533c7ca305b..d253db44c4a15 100644
--- a/packages/react-server/src/ReactFlightServer.js
+++ b/packages/react-server/src/ReactFlightServer.js
@@ -59,6 +59,7 @@ import type {
   ReactAsyncInfo,
 } from 'shared/ReactTypes';
 import type {LazyComponent} from 'react/src/ReactLazy';
+import type {TemporaryReference} from './ReactFlightServerTemporaryReferences';
 
 import {
   resolveClientReferenceMetadata,
@@ -73,6 +74,11 @@ import {
   initAsyncDebugInfo,
 } from './ReactFlightServerConfig';
 
+import {
+  isTemporaryReference,
+  resolveTemporaryReferenceID,
+} from './ReactFlightServerTemporaryReferences';
+
 import {
   HooksDispatcher,
   prepareToUseHooksForRequest,
@@ -788,7 +794,7 @@ function renderElement(
     }
   }
   if (typeof type === 'function') {
-    if (isClientReference(type)) {
+    if (isClientReference(type) || isTemporaryReference(type)) {
       // This is a reference to a Client Component.
       return renderClientElement(task, type, key, props);
     }
@@ -949,6 +955,10 @@ function serializeServerReferenceID(id: number): string {
   return '$F' + id.toString(16);
 }
 
+function serializeTemporaryReferenceID(id: string): string {
+  return '$T' + id;
+}
+
 function serializeSymbolReference(name: string): string {
   return '$S' + name;
 }
@@ -1085,6 +1095,14 @@ function serializeServerReference(
   return serializeServerReferenceID(metadataId);
 }
 
+function serializeTemporaryReference(
+  request: Request,
+  temporaryReference: TemporaryReference<any>,
+): string {
+  const id = resolveTemporaryReferenceID(temporaryReference);
+  return serializeTemporaryReferenceID(id);
+}
+
 function serializeLargeTextString(request: Request, text: string): string {
   request.pendingChunks += 2;
   const textId = request.nextChunkId++;
@@ -1635,6 +1653,9 @@ function renderModelDestructive(
     if (isServerReference(value)) {
       return serializeServerReference(request, (value: any));
     }
+    if (isTemporaryReference(value)) {
+      return serializeTemporaryReference(request, (value: any));
+    }
 
     if (enableTaint) {
       const tainted = TaintRegistryObjects.get(value);
@@ -2103,6 +2124,9 @@ function renderConsoleValue(
         (value: any),
       );
     }
+    if (isTemporaryReference(value)) {
+      return serializeTemporaryReference(request, (value: any));
+    }
 
     // Serialize the body of the function as an eval so it can be printed.
     // $FlowFixMe[method-unbinding]
diff --git a/packages/react-server/src/ReactFlightServerConfigBundlerCustom.js b/packages/react-server/src/ReactFlightServerConfigBundlerCustom.js
index e11c154d05f32..00578a4da2459 100644
--- a/packages/react-server/src/ReactFlightServerConfigBundlerCustom.js
+++ b/packages/react-server/src/ReactFlightServerConfigBundlerCustom.js
@@ -7,7 +7,7 @@
  * @flow
  */
 
-declare var $$$config: any;
+declare const $$$config: any;
 
 export opaque type ClientManifest = mixed;
 export opaque type ClientReference<T> = mixed; // eslint-disable-line no-unused-vars
diff --git a/packages/react-server/src/ReactFlightServerTemporaryReferences.js b/packages/react-server/src/ReactFlightServerTemporaryReferences.js
new file mode 100644
index 0000000000000..c133f9030431d
--- /dev/null
+++ b/packages/react-server/src/ReactFlightServerTemporaryReferences.js
@@ -0,0 +1,99 @@
+/**
+ * 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.
+ *
+ * @flow
+ */
+
+const TEMPORARY_REFERENCE_TAG = Symbol.for('react.temporary.reference');
+
+// eslint-disable-next-line no-unused-vars
+export opaque type TemporaryReference<T> = {
+  $$typeof: symbol,
+  $$id: string,
+};
+
+export function isTemporaryReference(reference: Object): boolean {
+  return reference.$$typeof === TEMPORARY_REFERENCE_TAG;
+}
+
+export function resolveTemporaryReferenceID<T>(
+  temporaryReference: TemporaryReference<T>,
+): string {
+  return temporaryReference.$$id;
+}
+
+const proxyHandlers = {
+  get: function (
+    target: Function,
+    name: string | symbol,
+    receiver: Proxy<Function>,
+  ) {
+    switch (name) {
+      // These names are read by the Flight runtime if you end up using the exports object.
+      case '$$typeof':
+        // These names are a little too common. We should probably have a way to
+        // have the Flight runtime extract the inner target instead.
+        return target.$$typeof;
+      case '$$id':
+        return target.$$id;
+      case '$$async':
+        return target.$$async;
+      case 'name':
+        return undefined;
+      case 'displayName':
+        return undefined;
+      // We need to special case this because createElement reads it if we pass this
+      // reference.
+      case 'defaultProps':
+        return undefined;
+      // Avoid this attempting to be serialized.
+      case 'toJSON':
+        return undefined;
+      case Symbol.toPrimitive:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toPrimitive];
+      case Symbol.toStringTag:
+        // $FlowFixMe[prop-missing]
+        return Object.prototype[Symbol.toStringTag];
+      case 'Provider':
+        throw new Error(
+          `Cannot render a Client Context Provider on the Server. ` +
+            `Instead, you can export a Client Component wrapper ` +
+            `that itself renders a Client Context Provider.`,
+        );
+    }
+    throw new Error(
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      `Cannot access ${String(name)} on the server. ` +
+        'You cannot dot into a temporary client reference from a server component. ' +
+        'You can only pass the value through to the client.',
+    );
+  },
+  set: function () {
+    throw new Error(
+      'Cannot assign to a temporary client reference from a server module.',
+    );
+  },
+};
+
+export function createTemporaryReference<T>(id: string): TemporaryReference<T> {
+  const reference: TemporaryReference<any> = Object.defineProperties(
+    (function () {
+      throw new Error(
+        // eslint-disable-next-line react-internal/safe-string-coercion
+        `Attempted to call a temporary Client Reference from the server but it is on the client. ` +
+          `It's not possible to invoke a client function from the server, it can ` +
+          `only be rendered as a Component or passed to props of a Client Component.`,
+      );
+    }: any),
+    {
+      $$typeof: {value: TEMPORARY_REFERENCE_TAG},
+      $$id: {value: id},
+    },
+  );
+
+  return new Proxy(reference, proxyHandlers);
+}
diff --git a/packages/react-server/src/createFastHashJS.js b/packages/react-server/src/createFastHashJS.js
index a72c75a88ff9d..063f15a7ccd4e 100644
--- a/packages/react-server/src/createFastHashJS.js
+++ b/packages/react-server/src/createFastHashJS.js
@@ -10,7 +10,7 @@
 // A pure JS implementation of a string hashing function. We do not use it for
 // security or obfuscation purposes, only to create compact hashes. So we
 // prioritize speed over collision avoidance. For example, we use this to hash
-// the component key path used by useFormState for MPA-style submissions.
+// the component key path used by useActionState for MPA-style submissions.
 //
 // In environments where built-in hashing functions are available, we prefer
 // those instead. Like Node's crypto module, or Bun.hash. Unfortunately this
diff --git a/packages/react-server/src/forks/ReactFizzConfig.custom.js b/packages/react-server/src/forks/ReactFizzConfig.custom.js
index cf1e05a54165d..495a74fb18656 100644
--- a/packages/react-server/src/forks/ReactFizzConfig.custom.js
+++ b/packages/react-server/src/forks/ReactFizzConfig.custom.js
@@ -26,7 +26,7 @@
 import type {Request} from 'react-server/src/ReactFizzServer';
 import type {TransitionStatus} from 'react-reconciler/src/ReactFiberConfig';
 
-declare var $$$config: any;
+declare const $$$config: any;
 export opaque type Destination = mixed; // eslint-disable-line no-undef
 export opaque type RenderState = mixed;
 export opaque type HoistableState = mixed;
diff --git a/packages/react-server/src/forks/ReactServerStreamConfig.custom.js b/packages/react-server/src/forks/ReactServerStreamConfig.custom.js
index e372e8903f856..22cd6551c0b28 100644
--- a/packages/react-server/src/forks/ReactServerStreamConfig.custom.js
+++ b/packages/react-server/src/forks/ReactServerStreamConfig.custom.js
@@ -23,7 +23,7 @@
 // So `$$$config` looks like a global variable, but it's
 // really an argument to a top-level wrapping function.
 
-declare var $$$config: any;
+declare const $$$config: any;
 export opaque type Destination = mixed; // eslint-disable-line no-undef
 
 export opaque type PrecomputedChunk = mixed; // eslint-disable-line no-undef
diff --git a/packages/react-test-renderer/__tests__/shallow-test.js b/packages/react-test-renderer/__tests__/shallow-test.js
new file mode 100644
index 0000000000000..9ee3e428bcb96
--- /dev/null
+++ b/packages/react-test-renderer/__tests__/shallow-test.js
@@ -0,0 +1,22 @@
+/**
+ * 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';
+
+describe('shallow', () => {
+  it('throws an error on init', () => {
+    const ReactShallowRenderer = require('../shallow.js').default;
+    expect(() => {
+      // eslint-disable-next-line no-new
+      new ReactShallowRenderer();
+    }).toThrow(
+      'react-test-renderer/shallow has been removed. See https://react.dev/warnings/react-test-renderer.'
+    );
+  });
+});
diff --git a/packages/react-test-renderer/npm/shallow.js b/packages/react-test-renderer/npm/shallow.js
index 8c558b509a3c6..d964174eabd48 100644
--- a/packages/react-test-renderer/npm/shallow.js
+++ b/packages/react-test-renderer/npm/shallow.js
@@ -1,3 +1,9 @@
 'use strict';
 
-module.exports = require('react-shallow-renderer');
+function ReactShallowRenderer() {
+  throw new Error(
+    'react-test-renderer/shallow has been removed. See https://react.dev/warnings/react-test-renderer.'
+  );
+}
+
+module.exports = ReactShallowRenderer;
diff --git a/packages/react-test-renderer/package.json b/packages/react-test-renderer/package.json
index 80861018ee8fa..ed32ffef0c950 100644
--- a/packages/react-test-renderer/package.json
+++ b/packages/react-test-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-test-renderer",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "description": "React package for snapshot testing.",
   "main": "index.js",
   "repository": {
@@ -20,11 +20,10 @@
   "homepage": "https://react.dev/",
   "dependencies": {
     "react-is": "^18.2.0",
-    "react-shallow-renderer": "^16.15.0",
     "scheduler": "^0.23.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0"
+    "react": "^19.0.0"
   },
   "files": [
     "LICENSE",
diff --git a/packages/react-test-renderer/shallow.js b/packages/react-test-renderer/shallow.js
index f4e93d121e5c7..3e4ba25d83d72 100644
--- a/packages/react-test-renderer/shallow.js
+++ b/packages/react-test-renderer/shallow.js
@@ -7,4 +7,5 @@
  * @flow
  */
 
-export {default} from 'react-shallow-renderer';
+import ReactShallowRenderer from './npm/shallow.js';
+export default ReactShallowRenderer;
diff --git a/packages/react-test-renderer/src/ReactTestRenderer.js b/packages/react-test-renderer/src/ReactTestRenderer.js
index 57b6f4d8b4f47..7368eada24ad5 100644
--- a/packages/react-test-renderer/src/ReactTestRenderer.js
+++ b/packages/react-test-renderer/src/ReactTestRenderer.js
@@ -23,6 +23,9 @@ import {
   flushSync,
   injectIntoDevTools,
   batchedUpdates,
+  defaultOnUncaughtError,
+  defaultOnCaughtError,
+  defaultOnRecoverableError,
 } from 'react-reconciler/src/ReactFiberReconciler';
 import {findCurrentFiberUsingSlowPath} from 'react-reconciler/src/ReactFiberTreeReflection';
 import {
@@ -55,6 +58,7 @@ import {ConcurrentRoot, LegacyRoot} from 'react-reconciler/src/ReactRootTags';
 import {
   allowConcurrentByDefault,
   enableReactTestRendererWarning,
+  disableLegacyMode,
 } from 'shared/ReactFeatureFlags';
 
 const act = React.act;
@@ -453,13 +457,6 @@ function propsMatch(props: Object, filter: Object): boolean {
   return true;
 }
 
-// $FlowFixMe[missing-local-annot]
-function onRecoverableError(error) {
-  // TODO: Expose onRecoverableError option to userspace
-  // eslint-disable-next-line react-internal/no-production-logging, react-internal/warning-args
-  console.error(error);
-}
-
 function create(
   element: React$Element<any>,
   options: TestRendererOptions,
@@ -474,7 +471,10 @@ function create(
   unstable_flushSync: typeof flushSync,
 } {
   if (__DEV__) {
-    if (enableReactTestRendererWarning === true) {
+    if (
+      enableReactTestRendererWarning === true &&
+      global.IS_REACT_NATIVE_TEST_ENVIRONMENT !== true
+    ) {
       console.warn(
         'react-test-renderer is deprecated. See https://react.dev/warnings/react-test-renderer',
       );
@@ -482,7 +482,10 @@ function create(
   }
 
   let createNodeMock = defaultTestOptions.createNodeMock;
-  let isConcurrent = false;
+  const isConcurrentOnly =
+    disableLegacyMode === true &&
+    global.IS_REACT_NATIVE_TEST_ENVIRONMENT !== true;
+  let isConcurrent = isConcurrentOnly;
   let isStrictMode = false;
   let concurrentUpdatesByDefault = null;
   if (typeof options === 'object' && options !== null) {
@@ -490,8 +493,8 @@ function create(
       // $FlowFixMe[incompatible-type] found when upgrading Flow
       createNodeMock = options.createNodeMock;
     }
-    if (options.unstable_isConcurrent === true) {
-      isConcurrent = true;
+    if (isConcurrentOnly === false) {
+      isConcurrent = options.unstable_isConcurrent;
     }
     if (options.unstable_strictMode === true) {
       isStrictMode = true;
@@ -515,7 +518,9 @@ function create(
     isStrictMode,
     concurrentUpdatesByDefault,
     '',
-    onRecoverableError,
+    defaultOnUncaughtError,
+    defaultOnCaughtError,
+    defaultOnRecoverableError,
     null,
   );
 
diff --git a/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.internal.js b/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.internal.js
index 139cbfc17e323..4cd173d06f348 100644
--- a/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.internal.js
+++ b/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.internal.js
@@ -14,14 +14,19 @@ const ReactFeatureFlags = require('shared/ReactFeatureFlags');
 const React = require('react');
 const ReactTestRenderer = require('react-test-renderer');
 const {format: prettyFormat} = require('pretty-format');
+const InternalTestUtils = require('internal-test-utils');
+const waitForAll = InternalTestUtils.waitForAll;
+const act = InternalTestUtils.act;
+const Reconciler = require('react-reconciler/src/ReactFiberReconciler');
+const {
+  ConcurrentRoot,
+  LegacyRoot,
+} = require('react-reconciler/src/ReactRootTags');
 
 // Isolate noop renderer
 jest.resetModules();
 const ReactNoop = require('react-noop-renderer');
 
-const InternalTestUtils = require('internal-test-utils');
-const waitForAll = InternalTestUtils.waitForAll;
-
 // Kind of hacky, but we nullify all the instances to test the tree structure
 // with jasmine's deep equality function, and test the instances separate. We
 // also delete children props because testing them is more annoying and not
@@ -65,11 +70,75 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('renders a simple component', () => {
+  // @gate __DEV__
+  it('should not warn if enableReactTestRendererWarning is enabled but the RN global is set', () => {
+    global.IS_REACT_NATIVE_TEST_ENVIRONMENT = true;
+    ReactFeatureFlags.enableReactTestRendererWarning = true;
+    expect(() => {
+      ReactTestRenderer.create(<div />);
+    }).not.toWarnDev(
+      'Warning: react-test-renderer is deprecated. See https://react.dev/warnings/react-test-renderer',
+      {withoutStack: true},
+    );
+  });
+
+  describe('root tags', () => {
+    let createContainerSpy;
+    beforeEach(() => {
+      global.IS_REACT_NATIVE_TEST_ENVIRONMENT = false;
+      createContainerSpy = jest.spyOn(Reconciler, 'createContainer');
+    });
+
+    function expectTag(tag) {
+      expect(createContainerSpy).toHaveBeenCalledWith(
+        expect.anything(),
+        tag,
+        null,
+        expect.anything(),
+        null,
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        null,
+      );
+    }
+
+    // @gate disableLegacyMode
+    it('should render using concurrent root if disableLegacyMode', () => {
+      ReactTestRenderer.create(<div />);
+      expectTag(ConcurrentRoot);
+    });
+
+    // @gate !disableLegacyMode
+    it('should default to legacy root if not disableLegacyMode', () => {
+      ReactTestRenderer.create(<div />);
+      expectTag(LegacyRoot);
+    });
+
+    it('should allow unstable_isConcurrent if not disableLegacyMode', async () => {
+      ReactTestRenderer.create(<div />, {
+        unstable_isConcurrent: true,
+      });
+      ReactTestRenderer.create(<div />);
+      expectTag(ConcurrentRoot);
+    });
+
+    it('should render legacy root when RN test environment', async () => {
+      global.IS_REACT_NATIVE_TEST_ENVIRONMENT = true;
+      ReactTestRenderer.create(<div />);
+      expectTag(LegacyRoot);
+    });
+  });
+
+  it('renders a simple component', async () => {
     function Link() {
       return <a role="link" />;
     }
-    const renderer = ReactTestRenderer.create(<Link />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Link />);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'a',
       props: {role: 'link'},
@@ -77,19 +146,25 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('renders a top-level empty component', () => {
+  it('renders a top-level empty component', async () => {
     function Empty() {
       return null;
     }
-    const renderer = ReactTestRenderer.create(<Empty />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Empty />);
+    });
     expect(renderer.toJSON()).toEqual(null);
   });
 
-  it('exposes a type flag', () => {
+  it('exposes a type flag', async () => {
     function Link() {
       return <a role="link" />;
     }
-    const renderer = ReactTestRenderer.create(<Link />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Link />);
+    });
     const object = renderer.toJSON();
     expect(object.$$typeof).toBe(Symbol.for('react.test.json'));
 
@@ -101,7 +176,7 @@ describe('ReactTestRenderer', () => {
     }
   });
 
-  it('can render a composite component', () => {
+  it('can render a composite component', async () => {
     class Component extends React.Component {
       render() {
         return (
@@ -116,7 +191,10 @@ describe('ReactTestRenderer', () => {
       return <moo />;
     };
 
-    const renderer = ReactTestRenderer.create(<Component />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Component />);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {className: 'purple'},
@@ -124,7 +202,7 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('renders some basics with an update', () => {
+  it('renders some basics with an update', async () => {
     let renders = 0;
 
     class Component extends React.Component {
@@ -156,7 +234,10 @@ describe('ReactTestRenderer', () => {
       return null;
     };
 
-    const renderer = ReactTestRenderer.create(<Component />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Component />);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {className: 'purple'},
@@ -165,7 +246,7 @@ describe('ReactTestRenderer', () => {
     expect(renders).toBe(6);
   });
 
-  it('exposes the instance', () => {
+  it('exposes the instance', async () => {
     class Mouse extends React.Component {
       constructor() {
         super();
@@ -178,7 +259,10 @@ describe('ReactTestRenderer', () => {
         return <div>{this.state.mouse}</div>;
       }
     }
-    const renderer = ReactTestRenderer.create(<Mouse />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Mouse />);
+    });
 
     expect(renderer.toJSON()).toEqual({
       type: 'div',
@@ -187,7 +271,9 @@ describe('ReactTestRenderer', () => {
     });
 
     const mouse = renderer.getInstance();
-    mouse.handleMoose();
+    await act(() => {
+      mouse.handleMoose();
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: ['moose'],
@@ -195,15 +281,20 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('updates types', () => {
-    const renderer = ReactTestRenderer.create(<div>mouse</div>);
+  it('updates types', async () => {
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<div>mouse</div>);
+    });
+
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {},
       children: ['mouse'],
     });
-
-    renderer.update(<span>mice</span>);
+    await act(() => {
+      renderer.update(<span>mice</span>);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'span',
       props: {},
@@ -211,14 +302,18 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('updates children', () => {
-    const renderer = ReactTestRenderer.create(
-      <div>
-        <span key="a">A</span>
-        <span key="b">B</span>
-        <span key="c">C</span>
-      </div>,
-    );
+  it('updates children', async () => {
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(
+        <div>
+          <span key="a">A</span>
+          <span key="b">B</span>
+          <span key="c">C</span>
+        </div>,
+      );
+    });
+
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {},
@@ -229,13 +324,15 @@ describe('ReactTestRenderer', () => {
       ],
     });
 
-    renderer.update(
-      <div>
-        <span key="d">D</span>
-        <span key="c">C</span>
-        <span key="b">B</span>
-      </div>,
-    );
+    await act(() => {
+      renderer.update(
+        <div>
+          <span key="d">D</span>
+          <span key="c">C</span>
+          <span key="b">B</span>
+        </div>,
+      );
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {},
@@ -247,7 +344,7 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('does the full lifecycle', () => {
+  it('does the full lifecycle', async () => {
     const log = [];
     class Log extends React.Component {
       render() {
@@ -262,9 +359,16 @@ describe('ReactTestRenderer', () => {
       }
     }
 
-    const renderer = ReactTestRenderer.create(<Log key="foo" name="Foo" />);
-    renderer.update(<Log key="bar" name="Bar" />);
-    renderer.unmount();
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Log key="foo" name="Foo" />);
+    });
+    await act(() => {
+      renderer.update(<Log key="bar" name="Bar" />);
+    });
+    await act(() => {
+      renderer.unmount();
+    });
 
     expect(log).toEqual([
       'render Foo',
@@ -276,14 +380,16 @@ describe('ReactTestRenderer', () => {
     ]);
   });
 
-  it('gives a ref to native components', () => {
+  it('gives a ref to native components', async () => {
     const log = [];
-    ReactTestRenderer.create(<div ref={r => log.push(r)} />);
+    await act(() => {
+      ReactTestRenderer.create(<div ref={r => log.push(r)} />);
+    });
     expect(log).toEqual([null]);
   });
 
   // @gate !enableRefAsProp || !__DEV__
-  it('warns correctly for refs on SFCs', () => {
+  it('warns correctly for refs on SFCs', async () => {
     function Bar() {
       return <div>Hello, world</div>;
     }
@@ -299,8 +405,14 @@ describe('ReactTestRenderer', () => {
         return <div ref={this.bazRef} />;
       }
     }
-    ReactTestRenderer.create(<Baz />);
-    expect(() => ReactTestRenderer.create(<Foo />)).toErrorDev(
+    await act(() => {
+      ReactTestRenderer.create(<Baz />);
+    });
+    await expect(async () => {
+      await act(() => {
+        ReactTestRenderer.create(<Foo />);
+      });
+    }).toErrorDev(
       'Warning: Function components cannot be given refs. Attempts ' +
         'to access this ref will fail. ' +
         'Did you mean to use React.forwardRef()?\n' +
@@ -309,7 +421,7 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('allows an optional createNodeMock function', () => {
+  it('allows an optional createNodeMock function', async () => {
     const mockDivInstance = {appendChild: () => {}};
     const mockInputInstance = {focus: () => {}};
     const mockListItemInstance = {click: () => {}};
@@ -338,27 +450,41 @@ describe('ReactTestRenderer', () => {
           return {};
       }
     }
-    ReactTestRenderer.create(<div ref={r => log.push(r)} />, {createNodeMock});
-    ReactTestRenderer.create(<input ref={r => log.push(r)} />, {
-      createNodeMock,
+    await act(() => {
+      ReactTestRenderer.create(<div ref={r => log.push(r)} />, {
+        createNodeMock,
+      });
+    });
+    await act(() => {
+      ReactTestRenderer.create(<input ref={r => log.push(r)} />, {
+        createNodeMock,
+      });
+    });
+    await act(() => {
+      ReactTestRenderer.create(
+        <div>
+          <span>
+            <ul>
+              <li ref={r => log.push(r)} />
+            </ul>
+            <ul>
+              <li ref={r => log.push(r)} />
+              <li ref={r => log.push(r)} />
+            </ul>
+          </span>
+        </div>,
+        {createNodeMock, foobar: true},
+      );
+    });
+    await act(() => {
+      ReactTestRenderer.create(<Foo />, {createNodeMock});
+    });
+    await act(() => {
+      ReactTestRenderer.create(<div ref={r => log.push(r)} />);
+    });
+    await act(() => {
+      ReactTestRenderer.create(<div ref={r => log.push(r)} />, {});
     });
-    ReactTestRenderer.create(
-      <div>
-        <span>
-          <ul>
-            <li ref={r => log.push(r)} />
-          </ul>
-          <ul>
-            <li ref={r => log.push(r)} />
-            <li ref={r => log.push(r)} />
-          </ul>
-        </span>
-      </div>,
-      {createNodeMock, foobar: true},
-    );
-    ReactTestRenderer.create(<Foo />, {createNodeMock});
-    ReactTestRenderer.create(<div ref={r => log.push(r)} />);
-    ReactTestRenderer.create(<div ref={r => log.push(r)} />, {});
     expect(log).toEqual([
       mockDivInstance,
       mockInputInstance,
@@ -383,7 +509,7 @@ describe('ReactTestRenderer', () => {
     expect(() => inst.unmount()).not.toThrow();
   });
 
-  it('supports unmounting inner instances', () => {
+  it('supports unmounting inner instances', async () => {
     let count = 0;
     class Foo extends React.Component {
       componentWillUnmount() {
@@ -393,19 +519,24 @@ describe('ReactTestRenderer', () => {
         return <div />;
       }
     }
-    const inst = ReactTestRenderer.create(
-      <div>
-        <Foo />
-      </div>,
-      {
-        createNodeMock: () => 'foo',
-      },
-    );
-    expect(() => inst.unmount()).not.toThrow();
+    let inst;
+    await act(() => {
+      inst = ReactTestRenderer.create(
+        <div>
+          <Foo />
+        </div>,
+        {
+          createNodeMock: () => 'foo',
+        },
+      );
+    });
+    await act(() => {
+      inst.unmount();
+    });
     expect(count).toEqual(1);
   });
 
-  it('supports updates when using refs', () => {
+  it('supports updates when using refs', async () => {
     const log = [];
     const createNodeMock = element => {
       log.push(element.type);
@@ -420,14 +551,19 @@ describe('ReactTestRenderer', () => {
         );
       }
     }
-    const inst = ReactTestRenderer.create(<Foo useDiv={true} />, {
-      createNodeMock,
+    let inst;
+    await act(() => {
+      inst = ReactTestRenderer.create(<Foo useDiv={true} />, {
+        createNodeMock,
+      });
+    });
+    await act(() => {
+      inst.update(<Foo useDiv={false} />);
     });
-    inst.update(<Foo useDiv={false} />);
     expect(log).toEqual(['div', 'span']);
   });
 
-  it('supports error boundaries', () => {
+  it('supports error boundaries', async () => {
     const log = [];
     class Angry extends React.Component {
       render() {
@@ -476,13 +612,20 @@ describe('ReactTestRenderer', () => {
       }
     }
 
-    const renderer = ReactTestRenderer.create(<Boundary />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Boundary />, {
+        unstable_isConcurrent: true,
+      });
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       props: {},
       children: ['Happy Birthday!'],
     });
     expect(log).toEqual([
+      'Boundary render',
+      'Angry render',
       'Boundary render',
       'Angry render',
       'Boundary componentDidMount',
@@ -491,42 +634,53 @@ describe('ReactTestRenderer', () => {
     ]);
   });
 
-  it('can update text nodes', () => {
+  it('can update text nodes', async () => {
     class Component extends React.Component {
       render() {
         return <div>{this.props.children}</div>;
       }
     }
 
-    const renderer = ReactTestRenderer.create(<Component>Hi</Component>);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Component>Hi</Component>);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: ['Hi'],
       props: {},
     });
-    renderer.update(<Component>{['Hi', 'Bye']}</Component>);
+    await act(() => {
+      renderer.update(<Component>{['Hi', 'Bye']}</Component>);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: ['Hi', 'Bye'],
       props: {},
     });
-    renderer.update(<Component>Bye</Component>);
+    await act(() => {
+      renderer.update(<Component>Bye</Component>);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: ['Bye'],
       props: {},
     });
-    renderer.update(<Component>{42}</Component>);
+    await act(() => {
+      renderer.update(<Component>{42}</Component>);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: ['42'],
       props: {},
     });
-    renderer.update(
-      <Component>
-        <div />
-      </Component>,
-    );
+    await act(() => {
+      renderer.update(
+        <Component>
+          <div />
+        </Component>,
+      );
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: [
@@ -540,10 +694,13 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('toTree() renders simple components returning host components', () => {
+  it('toTree() renders simple components returning host components', async () => {
     const Qoo = () => <span className="Qoo">Hello World!</span>;
 
-    const renderer = ReactTestRenderer.create(<Qoo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Qoo />);
+    });
     const tree = renderer.toTree();
 
     cleanNodeOrArray(tree);
@@ -565,13 +722,16 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('toTree() handles nested Fragments', () => {
+  it('toTree() handles nested Fragments', async () => {
     const Foo = () => (
       <>
         <>foo</>
       </>
     );
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />);
+    });
     const tree = renderer.toTree();
 
     cleanNodeOrArray(tree);
@@ -587,14 +747,17 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('toTree() handles null rendering components', () => {
+  it('toTree() handles null rendering components', async () => {
     class Foo extends React.Component {
       render() {
         return null;
       }
     }
 
-    const renderer = ReactTestRenderer.create(<Foo />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Foo />);
+    });
     const tree = renderer.toTree();
 
     expect(tree.instance).toBeInstanceOf(Foo);
@@ -610,15 +773,18 @@ describe('ReactTestRenderer', () => {
     });
   });
 
-  it('toTree() handles simple components that return arrays', () => {
+  it('toTree() handles simple components that return arrays', async () => {
     const Foo = ({children}) => children;
 
-    const renderer = ReactTestRenderer.create(
-      <Foo>
-        <div>One</div>
-        <div>Two</div>
-      </Foo>,
-    );
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(
+        <Foo>
+          <div>One</div>
+          <div>Two</div>
+        </Foo>,
+      );
+    });
 
     const tree = renderer.toTree();
 
@@ -650,25 +816,28 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('toTree() handles complicated tree of arrays', () => {
+  it('toTree() handles complicated tree of arrays', async () => {
     class Foo extends React.Component {
       render() {
         return this.props.children;
       }
     }
 
-    const renderer = ReactTestRenderer.create(
-      <div>
-        <Foo>
-          <div>One</div>
-          <div>Two</div>
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(
+        <div>
           <Foo>
-            <div>Three</div>
+            <div>One</div>
+            <div>Two</div>
+            <Foo>
+              <div>Three</div>
+            </Foo>
           </Foo>
-        </Foo>
-        <div>Four</div>
-      </div>,
-    );
+          <div>Four</div>
+        </div>,
+      );
+    });
 
     const tree = renderer.toTree();
 
@@ -728,19 +897,22 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('toTree() handles complicated tree of fragments', () => {
-    const renderer = ReactTestRenderer.create(
-      <>
+  it('toTree() handles complicated tree of fragments', async () => {
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(
         <>
-          <div>One</div>
-          <div>Two</div>
           <>
-            <div>Three</div>
+            <div>One</div>
+            <div>Two</div>
+            <>
+              <div>Three</div>
+            </>
           </>
-        </>
-        <div>Four</div>
-      </>,
-    );
+          <div>Four</div>
+        </>,
+      );
+    });
 
     const tree = renderer.toTree();
 
@@ -780,18 +952,22 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('root instance and createNodeMock ref return the same value', () => {
+  it('root instance and createNodeMock ref return the same value', async () => {
     const createNodeMock = ref => ({node: ref});
     let refInst = null;
-    const renderer = ReactTestRenderer.create(
-      <div ref={ref => (refInst = ref)} />,
-      {createNodeMock},
-    );
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(
+        <div ref={ref => (refInst = ref)} />,
+        {createNodeMock},
+      );
+    });
+
     const root = renderer.getInstance();
     expect(root).toEqual(refInst);
   });
 
-  it('toTree() renders complicated trees of composites and hosts', () => {
+  it('toTree() renders complicated trees of composites and hosts', async () => {
     // SFC returning host. no children props.
     const Qoo = () => <span className="Qoo">Hello World!</span>;
 
@@ -822,7 +998,11 @@ describe('ReactTestRenderer', () => {
       }
     }
 
-    const renderer = ReactTestRenderer.create(<Bam />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<Bam />);
+    });
+
     const tree = renderer.toTree();
 
     // we test for the presence of instances before nulling them out
@@ -881,30 +1061,45 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('can update text nodes when rendered as root', () => {
-    const renderer = ReactTestRenderer.create(['Hello', 'world']);
+  it('can update text nodes when rendered as root', async () => {
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(['Hello', 'world']);
+    });
     expect(renderer.toJSON()).toEqual(['Hello', 'world']);
-    renderer.update(42);
+    await act(() => {
+      renderer.update(42);
+    });
     expect(renderer.toJSON()).toEqual('42');
-    renderer.update([42, 'world']);
+    await act(() => {
+      renderer.update([42, 'world']);
+    });
     expect(renderer.toJSON()).toEqual(['42', 'world']);
   });
 
-  it('can render and update root fragments', () => {
+  it('can render and update root fragments', async () => {
     const Component = props => props.children;
 
-    const renderer = ReactTestRenderer.create([
-      <Component key="a">Hi</Component>,
-      <Component key="b">Bye</Component>,
-    ]);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create([
+        <Component key="a">Hi</Component>,
+        <Component key="b">Bye</Component>,
+      ]);
+    });
+
     expect(renderer.toJSON()).toEqual(['Hi', 'Bye']);
-    renderer.update(<div />);
+    await act(() => {
+      renderer.update(<div />);
+    });
     expect(renderer.toJSON()).toEqual({
       type: 'div',
       children: null,
       props: {},
     });
-    renderer.update([<div key="a">goodbye</div>, 'world']);
+    await act(() => {
+      renderer.update([<div key="a">goodbye</div>, 'world']);
+    });
     expect(renderer.toJSON()).toEqual([
       {
         type: 'div',
@@ -915,7 +1110,7 @@ describe('ReactTestRenderer', () => {
     ]);
   });
 
-  it('supports context providers and consumers', () => {
+  it('supports context providers and consumers', async () => {
     const {Consumer, Provider} = React.createContext('a');
 
     function Child(props) {
@@ -930,7 +1125,10 @@ describe('ReactTestRenderer', () => {
       );
     }
 
-    const renderer = ReactTestRenderer.create(<App />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<App />);
+    });
     const child = renderer.root.findByType(Child);
     expect(child.children).toEqual(['b']);
     expect(prettyFormat(renderer.toTree())).toEqual(
@@ -952,7 +1150,7 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('supports modes', () => {
+  it('supports modes', async () => {
     function Child(props) {
       return props.value;
     }
@@ -965,7 +1163,10 @@ describe('ReactTestRenderer', () => {
       );
     }
 
-    const renderer = ReactTestRenderer.create(<App value="a" />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<App value="a" />);
+    });
     const child = renderer.root.findByType(Child);
     expect(child.children).toEqual(['a']);
     expect(prettyFormat(renderer.toTree())).toEqual(
@@ -989,7 +1190,7 @@ describe('ReactTestRenderer', () => {
     );
   });
 
-  it('supports forwardRef', () => {
+  it('supports forwardRef', async () => {
     const InnerRefed = React.forwardRef((props, ref) => (
       <div>
         <span ref={ref} />
@@ -1007,7 +1208,10 @@ describe('ReactTestRenderer', () => {
       }
     }
 
-    const renderer = ReactTestRenderer.create(<App />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<App />);
+    });
     const tree = renderer.toTree();
     cleanNodeOrArray(tree);
 
@@ -1052,12 +1256,17 @@ describe('ReactTestRenderer', () => {
     );
     ReactNoop.render(<App />);
     await waitForAll([]);
-    ReactTestRenderer.create(<App />);
+    await act(() => {
+      ReactTestRenderer.create(<App />);
+    });
   });
 
-  it('calling findByType() with an invalid component will fall back to "Unknown" for component name', () => {
+  it('calling findByType() with an invalid component will fall back to "Unknown" for component name', async () => {
     const App = () => null;
-    const renderer = ReactTestRenderer.create(<App />);
+    let renderer;
+    await act(() => {
+      renderer = ReactTestRenderer.create(<App />);
+    });
     const NonComponent = {};
 
     expect(() => {
diff --git a/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.js b/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.js
index 0118fa53f3ad3..d3bbd294e37c3 100644
--- a/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.js
+++ b/packages/react-test-renderer/src/__tests__/ReactTestRenderer-test.js
@@ -13,7 +13,7 @@ let ReactDOM;
 let React;
 let ReactCache;
 let ReactTestRenderer;
-let waitForAll;
+let act;
 
 describe('ReactTestRenderer', () => {
   beforeEach(() => {
@@ -26,32 +26,57 @@ describe('ReactTestRenderer', () => {
     ReactCache = require('react-cache');
     ReactTestRenderer = require('react-test-renderer');
     const InternalTestUtils = require('internal-test-utils');
-    waitForAll = InternalTestUtils.waitForAll;
+    act = InternalTestUtils.act;
   });
 
-  it('should warn if used to render a ReactDOM portal', () => {
+  it('should warn if used to render a ReactDOM portal', async () => {
     const container = document.createElement('div');
-    expect(() => {
-      let error;
-      try {
+    let error;
+
+    await expect(async () => {
+      await act(() => {
         ReactTestRenderer.create(ReactDOM.createPortal('foo', container));
-      } catch (e) {
-        error = e;
-      }
-      // After the update throws, a subsequent render is scheduled to
-      // unmount the whole tree. This update also causes an error, so React
-      // throws an AggregateError.
-      const errors = error.errors;
-      expect(errors.length).toBe(2);
-      expect(errors[0].message.includes('indexOf is not a function')).toBe(
-        true,
-      );
-      expect(errors[1].message.includes('indexOf is not a function')).toBe(
-        true,
-      );
+      }).catch(e => (error = e));
     }).toErrorDev('An invalid container has been provided.', {
       withoutStack: true,
     });
+
+    // After the update throws, a subsequent render is scheduled to
+    // unmount the whole tree. This update also causes an error, so React
+    // throws an AggregateError.
+    const errors = error.errors;
+    expect(errors.length).toBe(2);
+    expect(errors[0].message.includes('indexOf is not a function')).toBe(true);
+    expect(errors[1].message.includes('indexOf is not a function')).toBe(true);
+  });
+
+  test('find element by prop with suspended content', async () => {
+    const neverResolve = new Promise(() => {});
+
+    function TestComp({foo}) {
+      if (foo === 'one') {
+        throw neverResolve;
+      } else {
+        return null;
+      }
+    }
+
+    const tree = await act(() =>
+      ReactTestRenderer.create(
+        <div>
+          <React.Suspense fallback={null}>
+            <TestComp foo="one" />
+          </React.Suspense>
+          <TestComp foo="two" />
+        </div>,
+      ),
+    );
+
+    expect(
+      tree.root.find(item => {
+        return item.props.foo === 'two';
+      }),
+    ).toBeDefined();
   });
 
   describe('timed out Suspense hidden subtrees should not be observable via toJSON', () => {
@@ -84,16 +109,23 @@ describe('ReactTestRenderer', () => {
         );
       };
 
-      const root = ReactTestRenderer.create(<App text="initial" />);
-      PendingResources.initial('initial');
-      await waitForAll([]);
+      let root;
+      await act(() => {
+        root = ReactTestRenderer.create(<App text="initial" />);
+      });
+      await act(() => {
+        PendingResources.initial('initial');
+      });
       expect(root.toJSON()).toEqual('initial');
 
-      root.update(<App text="dynamic" />);
+      await act(() => {
+        root.update(<App text="dynamic" />);
+      });
       expect(root.toJSON()).toEqual('fallback');
 
-      PendingResources.dynamic('dynamic');
-      await waitForAll([]);
+      await act(() => {
+        PendingResources.dynamic('dynamic');
+      });
       expect(root.toJSON()).toEqual('dynamic');
     });
 
@@ -108,16 +140,23 @@ describe('ReactTestRenderer', () => {
         );
       };
 
-      const root = ReactTestRenderer.create(<App text="initial" />);
-      PendingResources.initial('initial');
-      await waitForAll([]);
+      let root;
+      await act(() => {
+        root = ReactTestRenderer.create(<App text="initial" />);
+      });
+      await act(() => {
+        PendingResources.initial('initial');
+      });
       expect(root.toJSON().children).toEqual(['initial']);
 
-      root.update(<App text="dynamic" />);
+      await act(() => {
+        root.update(<App text="dynamic" />);
+      });
       expect(root.toJSON().children).toEqual(['fallback']);
 
-      PendingResources.dynamic('dynamic');
-      await waitForAll([]);
+      await act(() => {
+        PendingResources.dynamic('dynamic');
+      });
       expect(root.toJSON().children).toEqual(['dynamic']);
     });
   });
diff --git a/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js b/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js
index 2306a895b785c..ef27de6d0fe2f 100644
--- a/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js
+++ b/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js
@@ -16,6 +16,7 @@ describe('ReactTestRenderer.act()', () => {
 
     const InternalTestUtils = require('internal-test-utils');
     assertLog = InternalTestUtils.assertLog;
+    global.IS_REACT_ACT_ENVIRONMENT = true;
   });
 
   // @gate __DEV__
@@ -91,7 +92,10 @@ describe('ReactTestRenderer.act()', () => {
         });
         return step;
       }
-      const root = ReactTestRenderer.create(null);
+      let root;
+      await act(() => {
+        root = ReactTestRenderer.create(null);
+      });
       await act(async () => {
         root.update(<App />);
       });
diff --git a/packages/react-test-renderer/src/__tests__/ReactTestRendererTraversal-test.js b/packages/react-test-renderer/src/__tests__/ReactTestRendererTraversal-test.js
index d61f0a7c9075a..b4f79d2c55f19 100644
--- a/packages/react-test-renderer/src/__tests__/ReactTestRendererTraversal-test.js
+++ b/packages/react-test-renderer/src/__tests__/ReactTestRendererTraversal-test.js
@@ -13,6 +13,7 @@
 const React = require('react');
 let ReactTestRenderer;
 let Context;
+let act;
 
 const RCTView = 'RCTView';
 const View = props => <RCTView {...props} />;
@@ -21,6 +22,7 @@ describe('ReactTestRendererTraversal', () => {
   beforeEach(() => {
     jest.resetModules();
     ReactTestRenderer = require('react-test-renderer');
+    act = require('internal-test-utils').act;
     Context = React.createContext(null);
   });
 
@@ -68,8 +70,11 @@ describe('ReactTestRendererTraversal', () => {
     <View {...props} ref={ref} />
   ));
 
-  it('initializes', () => {
-    const render = ReactTestRenderer.create(<Example />);
+  it('initializes', async () => {
+    let render;
+    await act(() => {
+      render = ReactTestRenderer.create(<Example />);
+    });
     const hasFooProp = node => node.props.hasOwnProperty('foo');
 
     // assert .props, .type and .parent attributes
@@ -80,8 +85,12 @@ describe('ReactTestRendererTraversal', () => {
     expect(foo.children[0].parent).toBe(foo);
   });
 
-  it('searches via .find() / .findAll()', () => {
-    const render = ReactTestRenderer.create(<Example />);
+  it('searches via .find() / .findAll()', async () => {
+    let render;
+    await act(() => {
+      render = ReactTestRenderer.create(<Example />);
+    });
+
     const hasFooProp = node => node.props.hasOwnProperty('foo');
     const hasBarProp = node => node.props.hasOwnProperty('bar');
     const hasBazProp = node => node.props.hasOwnProperty('baz');
@@ -135,8 +144,11 @@ describe('ReactTestRendererTraversal', () => {
     expect(itself.findAll(hasBazProp)).toHaveLength(2);
   });
 
-  it('searches via .findByType() / .findAllByType()', () => {
-    const render = ReactTestRenderer.create(<Example />);
+  it('searches via .findByType() / .findAllByType()', async () => {
+    let render;
+    await act(() => {
+      render = ReactTestRenderer.create(<Example />);
+    });
 
     expect(() => render.root.findByType(ExampleFn)).not.toThrow(); // 1 match
     expect(() => render.root.findByType(View)).not.toThrow(); // 1 match
@@ -159,8 +171,11 @@ describe('ReactTestRendererTraversal', () => {
     expect(fn[0].findAllByType(View)).toHaveLength(1);
   });
 
-  it('searches via .findByProps() / .findAllByProps()', () => {
-    const render = ReactTestRenderer.create(<Example />);
+  it('searches via .findByProps() / .findAllByProps()', async () => {
+    let render;
+    await act(() => {
+      render = ReactTestRenderer.create(<Example />);
+    });
     const foo = 'foo';
     const bar = 'bar';
     const baz = 'baz';
@@ -182,8 +197,11 @@ describe('ReactTestRendererTraversal', () => {
     expect(render.root.findAllByProps({qux})).toHaveLength(3);
   });
 
-  it('skips special nodes', () => {
-    const render = ReactTestRenderer.create(<Example />);
+  it('skips special nodes', async () => {
+    let render;
+    await act(() => {
+      render = ReactTestRenderer.create(<Example />);
+    });
     expect(render.root.findAllByType(React.Fragment)).toHaveLength(0);
     expect(render.root.findAllByType(Context.Consumer)).toHaveLength(0);
     expect(render.root.findAllByType(Context.Provider)).toHaveLength(0);
@@ -200,47 +218,62 @@ describe('ReactTestRendererTraversal', () => {
     expect(nestedViews[2].parent).toBe(expectedParent);
   });
 
-  it('can have special nodes as roots', () => {
+  it('can have special nodes as roots', async () => {
     const FR = React.forwardRef((props, ref) => <section {...props} />);
-    expect(
-      ReactTestRenderer.create(
+
+    let render1;
+    await act(() => {
+      render1 = ReactTestRenderer.create(
         <FR>
           <div />
           <div />
         </FR>,
-      ).root.findAllByType('div').length,
-    ).toBe(2);
-    expect(
-      ReactTestRenderer.create(
+      );
+    });
+    expect(render1.root.findAllByType('div').length).toBe(2);
+
+    let render2;
+    await act(() => {
+      render2 = ReactTestRenderer.create(
         <>
           <div />
           <div />
         </>,
-      ).root.findAllByType('div').length,
-    ).toBe(2);
-    expect(
-      ReactTestRenderer.create(
+      );
+    });
+    expect(render2.root.findAllByType('div').length).toBe(2);
+
+    let render3;
+    await act(() => {
+      render3 = ReactTestRenderer.create(
         <React.Fragment key="foo">
           <div />
           <div />
         </React.Fragment>,
-      ).root.findAllByType('div').length,
-    ).toBe(2);
-    expect(
-      ReactTestRenderer.create(
+      );
+    });
+    expect(render3.root.findAllByType('div').length).toBe(2);
+
+    let render4;
+    await act(() => {
+      render4 = ReactTestRenderer.create(
         <React.StrictMode>
           <div />
           <div />
         </React.StrictMode>,
-      ).root.findAllByType('div').length,
-    ).toBe(2);
-    expect(
-      ReactTestRenderer.create(
+      );
+    });
+    expect(render4.root.findAllByType('div').length).toBe(2);
+
+    let render5;
+    await act(() => {
+      render5 = ReactTestRenderer.create(
         <Context.Provider value={null}>
           <div />
           <div />
         </Context.Provider>,
-      ).root.findAllByType('div').length,
-    ).toBe(2);
+      );
+    });
+    expect(render5.root.findAllByType('div').length).toBe(2);
   });
 });
diff --git a/packages/react/index.classic.fb.js b/packages/react/index.classic.fb.js
index b51f0ee3bc0dd..c8a3a6012a27a 100644
--- a/packages/react/index.classic.fb.js
+++ b/packages/react/index.classic.fb.js
@@ -56,6 +56,7 @@ export {
   useState,
   useSyncExternalStore,
   useTransition,
+  useActionState,
   version,
 } from './src/ReactClient';
 export {jsx, jsxs, jsxDEV} from './src/jsx/ReactJSX';
diff --git a/packages/react/index.experimental.js b/packages/react/index.experimental.js
index 23280b774fa00..1adaed959e512 100644
--- a/packages/react/index.experimental.js
+++ b/packages/react/index.experimental.js
@@ -54,6 +54,7 @@ export {
   useState,
   useSyncExternalStore,
   useTransition,
+  useActionState,
   version,
 } from './src/ReactClient';
 
diff --git a/packages/react/index.js b/packages/react/index.js
index 387dbb5f4e79d..2f267f6eeb0c0 100644
--- a/packages/react/index.js
+++ b/packages/react/index.js
@@ -77,5 +77,6 @@ export {
   useRef,
   useState,
   useTransition,
+  useActionState,
   version,
 } from './src/ReactClient';
diff --git a/packages/react/index.modern.fb.js b/packages/react/index.modern.fb.js
index 4f73dded7f7eb..d5d9a10f4ca93 100644
--- a/packages/react/index.modern.fb.js
+++ b/packages/react/index.modern.fb.js
@@ -55,6 +55,7 @@ export {
   useState,
   useSyncExternalStore,
   useTransition,
+  useActionState,
   version,
 } from './src/ReactClient';
 export {jsx, jsxs, jsxDEV} from './src/jsx/ReactJSX';
diff --git a/packages/react/index.stable.js b/packages/react/index.stable.js
index 274c08fec435f..5e356cf698987 100644
--- a/packages/react/index.stable.js
+++ b/packages/react/index.stable.js
@@ -45,5 +45,6 @@ export {
   useState,
   useSyncExternalStore,
   useTransition,
+  useActionState,
   version,
 } from './src/ReactClient';
diff --git a/packages/react/package.json b/packages/react/package.json
index 76ca54e5127d1..f93bb209349f9 100644
--- a/packages/react/package.json
+++ b/packages/react/package.json
@@ -4,7 +4,7 @@
   "keywords": [
     "react"
   ],
-  "version": "18.2.0",
+  "version": "19.0.0",
   "homepage": "https://react.dev/",
   "bugs": "https://github.com/facebook/react/issues",
   "license": "MIT",
diff --git a/packages/react/src/ReactAct.js b/packages/react/src/ReactAct.js
index e28ecef8ad7df..269c0b2de2eda 100644
--- a/packages/react/src/ReactAct.js
+++ b/packages/react/src/ReactAct.js
@@ -19,6 +19,14 @@ let actScopeDepth = 0;
 // We only warn the first time you neglect to await an async `act` scope.
 let didWarnNoAwaitAct = false;
 
+function aggregateErrors(errors: Array<mixed>): mixed {
+  if (errors.length > 1 && typeof AggregateError === 'function') {
+    // eslint-disable-next-line no-undef
+    return new AggregateError(errors);
+  }
+  return errors[0];
+}
+
 export function act<T>(callback: () => T | Thenable<T>): Thenable<T> {
   if (__DEV__) {
     // When ReactCurrentActQueue.current is not null, it signals to React that
@@ -71,9 +79,14 @@ export function act<T>(callback: () => T | Thenable<T>): Thenable<T> {
       // one used to track `act` scopes. Why, you may be wondering? Because
       // that's how it worked before version 18. Yes, it's confusing! We should
       // delete legacy mode!!
+      ReactCurrentActQueue.thrownErrors.push(error);
+    }
+    if (ReactCurrentActQueue.thrownErrors.length > 0) {
       ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
       popActScope(prevActQueue, prevActScopeDepth);
-      throw error;
+      const thrownError = aggregateErrors(ReactCurrentActQueue.thrownErrors);
+      ReactCurrentActQueue.thrownErrors.length = 0;
+      throw thrownError;
     }
 
     if (
@@ -123,7 +136,14 @@ export function act<T>(callback: () => T | Thenable<T>): Thenable<T> {
                   // `thenable` might not be a real promise, and `flushActQueue`
                   // might throw, so we need to wrap `flushActQueue` in a
                   // try/catch.
-                  reject(error);
+                  ReactCurrentActQueue.thrownErrors.push(error);
+                }
+                if (ReactCurrentActQueue.thrownErrors.length > 0) {
+                  const thrownError = aggregateErrors(
+                    ReactCurrentActQueue.thrownErrors,
+                  );
+                  ReactCurrentActQueue.thrownErrors.length = 0;
+                  reject(thrownError);
                 }
               } else {
                 resolve(returnValue);
@@ -131,7 +151,15 @@ export function act<T>(callback: () => T | Thenable<T>): Thenable<T> {
             },
             error => {
               popActScope(prevActQueue, prevActScopeDepth);
-              reject(error);
+              if (ReactCurrentActQueue.thrownErrors.length > 0) {
+                const thrownError = aggregateErrors(
+                  ReactCurrentActQueue.thrownErrors,
+                );
+                ReactCurrentActQueue.thrownErrors.length = 0;
+                reject(thrownError);
+              } else {
+                reject(error);
+              }
             },
           );
         },
@@ -183,6 +211,13 @@ export function act<T>(callback: () => T | Thenable<T>): Thenable<T> {
         // to be awaited, regardless of whether the callback is sync or async.
         ReactCurrentActQueue.current = null;
       }
+
+      if (ReactCurrentActQueue.thrownErrors.length > 0) {
+        const thrownError = aggregateErrors(ReactCurrentActQueue.thrownErrors);
+        ReactCurrentActQueue.thrownErrors.length = 0;
+        throw thrownError;
+      }
+
       return {
         then(resolve: T => mixed, reject: mixed => mixed) {
           didAwaitActCall = true;
@@ -239,15 +274,20 @@ function recursivelyFlushAsyncActWork<T>(
           queueMacrotask(() =>
             recursivelyFlushAsyncActWork(returnValue, resolve, reject),
           );
+          return;
         } catch (error) {
           // Leave remaining tasks on the queue if something throws.
-          reject(error);
+          ReactCurrentActQueue.thrownErrors.push(error);
         }
       } else {
         // The queue is empty. We can finish.
         ReactCurrentActQueue.current = null;
-        resolve(returnValue);
       }
+    }
+    if (ReactCurrentActQueue.thrownErrors.length > 0) {
+      const thrownError = aggregateErrors(ReactCurrentActQueue.thrownErrors);
+      ReactCurrentActQueue.thrownErrors.length = 0;
+      reject(thrownError);
     } else {
       resolve(returnValue);
     }
@@ -287,7 +327,7 @@ function flushActQueue(queue: Array<RendererTask>) {
       } catch (error) {
         // If something throws, leave the remaining callbacks on the queue.
         queue.splice(0, i + 1);
-        throw error;
+        ReactCurrentActQueue.thrownErrors.push(error);
       } finally {
         isFlushing = false;
       }
diff --git a/packages/react/src/ReactClient.js b/packages/react/src/ReactClient.js
index 9e5af26381fdc..83bcdcc8226a2 100644
--- a/packages/react/src/ReactClient.js
+++ b/packages/react/src/ReactClient.js
@@ -59,6 +59,7 @@ import {
   use,
   useMemoCache,
   useOptimistic,
+  useActionState,
 } from './ReactHooks';
 import ReactSharedInternals from './ReactSharedInternalsClient';
 import {startTransition} from './ReactStartTransition';
@@ -93,6 +94,7 @@ export {
   useLayoutEffect,
   useMemo,
   useOptimistic,
+  useActionState,
   useSyncExternalStore,
   useReducer,
   useRef,
diff --git a/packages/react/src/ReactCurrentActQueue.js b/packages/react/src/ReactCurrentActQueue.js
index f8b118f19d840..ee1dff7180250 100644
--- a/packages/react/src/ReactCurrentActQueue.js
+++ b/packages/react/src/ReactCurrentActQueue.js
@@ -20,6 +20,9 @@ const ReactCurrentActQueue = {
   // Determines whether we should yield to microtasks to unwrap already resolved
   // promises without suspending.
   didUsePromise: false,
+
+  // Track first uncaught error within this act
+  thrownErrors: ([]: Array<mixed>),
 };
 
 export default ReactCurrentActQueue;
diff --git a/packages/react/src/ReactHooks.js b/packages/react/src/ReactHooks.js
index 60fc20062d597..fada4c9c8c0ad 100644
--- a/packages/react/src/ReactHooks.js
+++ b/packages/react/src/ReactHooks.js
@@ -12,11 +12,13 @@ import type {
   ReactContext,
   StartTransitionOptions,
   Usable,
+  Awaited,
 } from 'shared/ReactTypes';
 import {REACT_CONSUMER_TYPE} from 'shared/ReactSymbols';
 
 import ReactCurrentDispatcher from './ReactCurrentDispatcher';
 import ReactCurrentCache from './ReactCurrentCache';
+import {enableAsyncActions} from 'shared/ReactFeatureFlags';
 
 type BasicStateAction<S> = (S => S) | S;
 type Dispatch<A> = A => void;
@@ -227,3 +229,17 @@ export function useOptimistic<S, A>(
   // $FlowFixMe[not-a-function] This is unstable, thus optional
   return dispatcher.useOptimistic(passthrough, reducer);
 }
+
+export function useActionState<S, P>(
+  action: (Awaited<S>, P) => S,
+  initialState: Awaited<S>,
+  permalink?: string,
+): [Awaited<S>, (P) => void, boolean] {
+  if (!enableAsyncActions) {
+    throw new Error('Not implemented.');
+  } else {
+    const dispatcher = resolveDispatcher();
+    // $FlowFixMe[not-a-function] This is unstable, thus optional
+    return dispatcher.useActionState(action, initialState, permalink);
+  }
+}
diff --git a/packages/react/src/ReactServer.experimental.js b/packages/react/src/ReactServer.experimental.js
index ccc6de20eca34..fb90fd18e7b73 100644
--- a/packages/react/src/ReactServer.experimental.js
+++ b/packages/react/src/ReactServer.experimental.js
@@ -34,6 +34,7 @@ import {
   useCallback,
   useDebugValue,
   useMemo,
+  useActionState,
   getCacheSignal,
   getCacheForType,
 } from './ReactHooks';
@@ -84,5 +85,6 @@ export {
   useCallback,
   useDebugValue,
   useMemo,
+  useActionState,
   version,
 };
diff --git a/packages/react/src/ReactServer.js b/packages/react/src/ReactServer.js
index cc7e2c1847e5a..0c5eacbba23d0 100644
--- a/packages/react/src/ReactServer.js
+++ b/packages/react/src/ReactServer.js
@@ -27,7 +27,14 @@ import {
   isValidElement,
 } from './jsx/ReactJSXElement';
 import {createRef} from './ReactCreateRef';
-import {use, useId, useCallback, useDebugValue, useMemo} from './ReactHooks';
+import {
+  use,
+  useId,
+  useCallback,
+  useDebugValue,
+  useMemo,
+  useActionState,
+} from './ReactHooks';
 import {forwardRef} from './ReactForwardRef';
 import {lazy} from './ReactLazy';
 import {memo} from './ReactMemo';
@@ -63,5 +70,6 @@ export {
   useCallback,
   useDebugValue,
   useMemo,
+  useActionState,
   version,
 };
diff --git a/packages/react/src/ReactStartTransition.js b/packages/react/src/ReactStartTransition.js
index ebdc0d7718a66..968cc6d812cf9 100644
--- a/packages/react/src/ReactStartTransition.js
+++ b/packages/react/src/ReactStartTransition.js
@@ -15,6 +15,8 @@ import {
   enableTransitionTracing,
 } from 'shared/ReactFeatureFlags';
 
+import reportGlobalError from 'shared/reportGlobalError';
+
 export function startTransition(
   scope: () => void,
   options?: StartTransitionOptions,
@@ -51,10 +53,10 @@ export function startTransition(
         typeof returnValue.then === 'function'
       ) {
         callbacks.forEach(callback => callback(currentTransition, returnValue));
-        returnValue.then(noop, onError);
+        returnValue.then(noop, reportGlobalError);
       }
     } catch (error) {
-      onError(error);
+      reportGlobalError(error);
     } finally {
       warnAboutTransitionSubscriptions(prevTransition, currentTransition);
       ReactCurrentBatchConfig.transition = prevTransition;
@@ -91,16 +93,3 @@ function warnAboutTransitionSubscriptions(
 }
 
 function noop() {}
-
-// Use reportError, if it exists. Otherwise console.error. This is the same as
-// the default for onRecoverableError.
-const onError =
-  typeof reportError === 'function'
-    ? // In modern browsers, reportError will dispatch an error event,
-      // emulating an uncaught JavaScript error.
-      reportError
-    : (error: mixed) => {
-        // In older browsers and test environments, fallback to console.error.
-        // eslint-disable-next-line react-internal/no-production-logging
-        console['error'](error);
-      };
diff --git a/packages/react/src/__tests__/ReactCoffeeScriptClass-test.coffee b/packages/react/src/__tests__/ReactCoffeeScriptClass-test.coffee
index 0cc201ea06341..f29f38a128b34 100644
--- a/packages/react/src/__tests__/ReactCoffeeScriptClass-test.coffee
+++ b/packages/react/src/__tests__/ReactCoffeeScriptClass-test.coffee
@@ -9,7 +9,6 @@ PropTypes = null
 React = null
 ReactDOM = null
 ReactDOMClient = null
-act = null
 
 featureFlags = require 'shared/ReactFeatureFlags'
 
@@ -49,16 +48,25 @@ describe 'ReactCoffeeScriptClass', ->
 
   it 'throws if no render function is defined', ->
     class Foo extends React.Component
+    caughtErrors = []
+    errorHandler = (event) ->
+      event.preventDefault()
+      caughtErrors.push(event.error)
+    window.addEventListener 'error', errorHandler;
     expect(->
-      expect(->
-        ReactDOM.flushSync ->
-          root.render React.createElement(Foo)
-      ).toThrow()
+      ReactDOM.flushSync ->
+        root.render React.createElement(Foo)
     ).toErrorDev([
       # A failed component renders twice in DEV in concurrent mode
       'No `render` method found on the Foo instance',
       'No `render` method found on the Foo instance',
     ])
+    window.removeEventListener 'error', errorHandler;
+    expect(caughtErrors).toEqual([
+      expect.objectContaining(
+        message: expect.stringContaining('is not a function')
+      )
+    ])
 
   it 'renders a simple stateless component with prop', ->
     class Foo extends React.Component
@@ -554,10 +562,4 @@ describe 'ReactCoffeeScriptClass', ->
       ]);
       expect(ref.current.refs.inner.getName()).toBe 'foo'
 
-  it 'supports drilling through to the DOM using findDOMNode', ->
-    ref = React.createRef()
-    test React.createElement(InnerComponent, name: 'foo', ref: ref), 'DIV', 'foo'
-    node = ReactDOM.findDOMNode(ref.current)
-    expect(node).toBe container.firstChild
-
   undefined
diff --git a/packages/react/src/__tests__/ReactCreateElement-test.js b/packages/react/src/__tests__/ReactCreateElement-test.js
index fbc3f6a50c96a..cf372a33e35f0 100644
--- a/packages/react/src/__tests__/ReactCreateElement-test.js
+++ b/packages/react/src/__tests__/ReactCreateElement-test.js
@@ -181,7 +181,7 @@ describe('ReactCreateElement', () => {
     expect(element.type).toBe(ComponentClass);
     if (gate(flags => flags.enableRefAsProp)) {
       expect(() => expect(element.ref).toBe(ref)).toErrorDev(
-        'Accessing element.ref is no longer supported',
+        'Accessing element.ref was removed in React 19',
         {withoutStack: true},
       );
       const expectation = {foo: '56', ref};
diff --git a/packages/react/src/__tests__/ReactES6Class-test.js b/packages/react/src/__tests__/ReactES6Class-test.js
index 326576e525b83..de9eab6399f9c 100644
--- a/packages/react/src/__tests__/ReactES6Class-test.js
+++ b/packages/react/src/__tests__/ReactES6Class-test.js
@@ -60,14 +60,29 @@ describe('ReactES6Class', () => {
 
   it('throws if no render function is defined', () => {
     class Foo extends React.Component {}
-    expect(() => {
-      expect(() => ReactDOM.flushSync(() => root.render(<Foo />))).toThrow();
-    }).toErrorDev([
-      // A failed component renders twice in DEV in concurrent mode
-      'Warning: No `render` method found on the Foo instance: ' +
-        'you may have forgotten to define `render`.',
-      'Warning: No `render` method found on the Foo instance: ' +
-        'you may have forgotten to define `render`.',
+    const caughtErrors = [];
+    function errorHandler(event) {
+      event.preventDefault();
+      caughtErrors.push(event.error);
+    }
+    window.addEventListener('error', errorHandler);
+    try {
+      expect(() => {
+        ReactDOM.flushSync(() => root.render(<Foo />));
+      }).toErrorDev([
+        // A failed component renders twice in DEV in concurrent mode
+        'Warning: No `render` method found on the Foo instance: ' +
+          'you may have forgotten to define `render`.',
+        'Warning: No `render` method found on the Foo instance: ' +
+          'you may have forgotten to define `render`.',
+      ]);
+    } finally {
+      window.removeEventListener('error', errorHandler);
+    }
+    expect(caughtErrors).toEqual([
+      expect.objectContaining({
+        message: expect.stringContaining('is not a function'),
+      }),
     ]);
   });
 
@@ -592,11 +607,4 @@ describe('ReactES6Class', () => {
       expect(ref.current.refs.inner.getName()).toBe('foo');
     });
   }
-
-  it('supports drilling through to the DOM using findDOMNode', () => {
-    const ref = React.createRef();
-    test(<Inner name="foo" ref={ref} />, 'DIV', 'foo');
-    const node = ReactDOM.findDOMNode(ref.current);
-    expect(node).toBe(container.firstChild);
-  });
 });
diff --git a/packages/react/src/__tests__/ReactElementClone-test.js b/packages/react/src/__tests__/ReactElementClone-test.js
index aec18a3e0fcb9..f16423ee60256 100644
--- a/packages/react/src/__tests__/ReactElementClone-test.js
+++ b/packages/react/src/__tests__/ReactElementClone-test.js
@@ -361,7 +361,7 @@ describe('ReactElementClone', () => {
     if (gate(flags => flags.enableRefAsProp)) {
       expect(clone.props.ref).toBe('34');
       expect(() => expect(clone.ref).toBe('34')).toErrorDev(
-        'Accessing element.ref is no longer supported',
+        'Accessing element.ref was removed in React 19',
         {withoutStack: true},
       );
       expect(clone.props).toEqual({foo: 'ef', ref: '34'});
diff --git a/packages/react/src/__tests__/ReactJSXRuntime-test.js b/packages/react/src/__tests__/ReactJSXRuntime-test.js
index 3f1042435523a..db488e1684001 100644
--- a/packages/react/src/__tests__/ReactJSXRuntime-test.js
+++ b/packages/react/src/__tests__/ReactJSXRuntime-test.js
@@ -15,6 +15,7 @@ let ReactDOMClient;
 let JSXRuntime;
 let JSXDEVRuntime;
 let act;
+let findDOMNode;
 
 // NOTE: Prefer to call the JSXRuntime directly in these tests so we can be
 // certain that we are testing the runtime behavior, as opposed to the Babel
@@ -29,6 +30,8 @@ describe('ReactJSXRuntime', () => {
     ReactDOM = require('react-dom');
     ReactDOMClient = require('react-dom/client');
     act = require('internal-test-utils').act;
+    findDOMNode =
+      ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.findDOMNode;
   });
 
   it('allows static methods to be called using the type property', () => {
@@ -130,9 +133,9 @@ describe('ReactJSXRuntime', () => {
 
     const outer = container.firstChild;
     if (__DEV__) {
-      expect(ReactDOM.findDOMNode(outer).className).toBe('moo');
+      expect(findDOMNode(outer).className).toBe('moo');
     } else {
-      expect(ReactDOM.findDOMNode(outer).className).toBe('quack');
+      expect(findDOMNode(outer).className).toBe('quack');
     }
   });
 
diff --git a/packages/react/src/__tests__/ReactJSXTransformIntegration-test.js b/packages/react/src/__tests__/ReactJSXTransformIntegration-test.js
index 19d3458804f84..22480f1a7ef63 100644
--- a/packages/react/src/__tests__/ReactJSXTransformIntegration-test.js
+++ b/packages/react/src/__tests__/ReactJSXTransformIntegration-test.js
@@ -126,7 +126,7 @@ describe('ReactJSXTransformIntegration', () => {
     expect(element.type).toBe(Component);
     if (gate(flags => flags.enableRefAsProp)) {
       expect(() => expect(element.ref).toBe(ref)).toErrorDev(
-        'Accessing element.ref is no longer supported',
+        'Accessing element.ref was removed in React 19',
         {withoutStack: true},
       );
       const expectation = {foo: '56', ref};
diff --git a/packages/react/src/__tests__/ReactProfilerDevToolsIntegration-test.internal.js b/packages/react/src/__tests__/ReactProfilerDevToolsIntegration-test.internal.js
index 2f28d2b60d43b..ba29cbbe461f8 100644
--- a/packages/react/src/__tests__/ReactProfilerDevToolsIntegration-test.internal.js
+++ b/packages/react/src/__tests__/ReactProfilerDevToolsIntegration-test.internal.js
@@ -19,6 +19,7 @@ describe('ReactProfiler DevTools integration', () => {
   let hook;
   let waitForAll;
   let waitFor;
+  let act;
 
   beforeEach(() => {
     global.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
@@ -39,6 +40,7 @@ describe('ReactProfiler DevTools integration', () => {
     const InternalTestUtils = require('internal-test-utils');
     waitForAll = InternalTestUtils.waitForAll;
     waitFor = InternalTestUtils.waitFor;
+    act = InternalTestUtils.act;
 
     AdvanceTime = class extends React.Component {
       static defaultProps = {
@@ -56,7 +58,7 @@ describe('ReactProfiler DevTools integration', () => {
     };
   });
 
-  it('should auto-Profile all fibers if the DevTools hook is detected', () => {
+  it('should auto-Profile all fibers if the DevTools hook is detected', async () => {
     const App = ({multiplier}) => {
       Scheduler.unstable_advanceTime(2);
       return (
@@ -71,7 +73,12 @@ describe('ReactProfiler DevTools integration', () => {
     };
 
     const onRender = jest.fn(() => {});
-    const rendered = ReactTestRenderer.create(<App multiplier={1} />);
+    let rendered;
+    await act(() => {
+      rendered = ReactTestRenderer.create(<App multiplier={1} />, {
+        unstable_isConcurrent: true,
+      });
+    });
 
     expect(hook.onCommitFiberRoot).toHaveBeenCalledTimes(1);
 
@@ -90,7 +97,9 @@ describe('ReactProfiler DevTools integration', () => {
       12,
     );
 
-    rendered.update(<App multiplier={2} />);
+    await act(() => {
+      rendered.update(<App multiplier={2} />);
+    });
 
     // Measure observable timing using the Profiler component.
     // The time spent in App (above the Profiler) won't be included in the durations,
@@ -107,14 +116,18 @@ describe('ReactProfiler DevTools integration', () => {
     );
   });
 
-  it('should reset the fiber stack correctly after an error when profiling host roots', () => {
+  it('should reset the fiber stack correctly after an error when profiling host roots', async () => {
     Scheduler.unstable_advanceTime(20);
 
-    const rendered = ReactTestRenderer.create(
-      <div>
-        <AdvanceTime byAmount={2} />
-      </div>,
-    );
+    let rendered;
+    await act(() => {
+      rendered = ReactTestRenderer.create(
+        <div>
+          <AdvanceTime byAmount={2} />
+        </div>,
+        {unstable_isConcurrent: true},
+      );
+    });
 
     Scheduler.unstable_advanceTime(20);
 
@@ -122,22 +135,26 @@ describe('ReactProfiler DevTools integration', () => {
       throw new Error('Oops!');
     }
 
-    expect(() => {
-      rendered.update(
-        <Throws>
-          <AdvanceTime byAmount={3} />
-        </Throws>,
-      );
-    }).toThrow('Oops!');
+    await expect(async () => {
+      await act(() => {
+        rendered.update(
+          <Throws>
+            <AdvanceTime byAmount={3} />
+          </Throws>,
+        );
+      });
+    }).rejects.toThrow('Oops!');
 
     Scheduler.unstable_advanceTime(20);
 
-    // But this should render correctly, if the profiler's fiber stack has been reset.
-    rendered.update(
-      <div>
-        <AdvanceTime byAmount={7} />
-      </div>,
-    );
+    await act(() => {
+      // But this should render correctly, if the profiler's fiber stack has been reset.
+      rendered.update(
+        <div>
+          <AdvanceTime byAmount={7} />
+        </div>,
+      );
+    });
 
     // Measure unobservable timing required by the DevTools profiler.
     // At this point, the base time should include only the most recent (not failed) render.
@@ -154,7 +171,10 @@ describe('ReactProfiler DevTools integration', () => {
       return text;
     }
 
-    const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
+    let root;
+    await act(() => {
+      root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
+    });
 
     // Commit something
     root.update(<Text text="A" />);
diff --git a/packages/react/src/__tests__/ReactTypeScriptClass-test.ts b/packages/react/src/__tests__/ReactTypeScriptClass-test.ts
index fd2e8c7ee0ecc..fa59b6ce644e5 100644
--- a/packages/react/src/__tests__/ReactTypeScriptClass-test.ts
+++ b/packages/react/src/__tests__/ReactTypeScriptClass-test.ts
@@ -327,17 +327,27 @@ describe('ReactTypeScriptClass', function() {
   });
 
   it('throws if no render function is defined', function() {
-    expect(() => {
-      expect(() =>
+    class Foo extends React.Component {}
+    const caughtErrors = [];
+    function errorHandler(event) {
+      event.preventDefault();
+      caughtErrors.push(event.error);
+    }
+    window.addEventListener('error', errorHandler);
+    try {
+      expect(() => {
         ReactDOM.flushSync(() => root.render(React.createElement(Empty)))
-      ).toThrow();
-    }).toErrorDev([
-      // A failed component renders twice in DEV in concurrent mode
-      'Warning: No `render` method found on the Empty instance: ' +
-        'you may have forgotten to define `render`.',
-      'Warning: No `render` method found on the Empty instance: ' +
-        'you may have forgotten to define `render`.',
-    ]);
+      }).toErrorDev([
+        // A failed component renders twice in DEV in concurrent mode
+        'Warning: No `render` method found on the Empty instance: ' +
+          'you may have forgotten to define `render`.',
+        'Warning: No `render` method found on the Empty instance: ' +
+          'you may have forgotten to define `render`.',
+      ]);
+    } finally {
+      window.removeEventListener('error', errorHandler);
+    }
+    expect(caughtErrors.length).toBe(1);
   });
 
   it('renders a simple stateless component with prop', function() {
@@ -699,11 +709,4 @@ describe('ReactTypeScriptClass', function() {
       expect(ref.current.refs.inner.getName()).toBe('foo');
     });
   }
-
-  it('supports drilling through to the DOM using findDOMNode', function() {
-    const ref = React.createRef();
-    test(React.createElement(Inner, {name: 'foo', ref: ref}), 'DIV', 'foo');
-    const node = ReactDOM.findDOMNode(ref.current);
-    expect(node).toBe(container.firstChild);
-  });
 });
diff --git a/packages/react/src/jsx/ReactJSXElement.js b/packages/react/src/jsx/ReactJSXElement.js
index b716e0bc08f7c..3a0027c2b6a32 100644
--- a/packages/react/src/jsx/ReactJSXElement.js
+++ b/packages/react/src/jsx/ReactJSXElement.js
@@ -141,7 +141,7 @@ function elementRefGetterWithDeprecationWarning() {
     if (!didWarnAboutElementRef[componentName]) {
       didWarnAboutElementRef[componentName] = true;
       console.error(
-        'Accessing element.ref is no longer supported. ref is now a ' +
+        'Accessing element.ref was removed in React 19. ref is now a ' +
           'regular prop. It will be removed from the JSX Element ' +
           'type in a future release.',
       );
diff --git a/packages/scheduler/src/forks/SchedulerNative.js b/packages/scheduler/src/forks/SchedulerNative.js
index a7370d92a650b..3832cbc69753e 100644
--- a/packages/scheduler/src/forks/SchedulerNative.js
+++ b/packages/scheduler/src/forks/SchedulerNative.js
@@ -32,7 +32,7 @@ type NativeSchedulerType = {
   unstable_now: () => DOMHighResTimeStamp,
 };
 
-declare var nativeRuntimeScheduler: void | NativeSchedulerType;
+declare const nativeRuntimeScheduler: void | NativeSchedulerType;
 
 export const unstable_UserBlockingPriority: PriorityLevel =
   typeof nativeRuntimeScheduler !== 'undefined'
diff --git a/packages/shared/ReactFeatureFlags.js b/packages/shared/ReactFeatureFlags.js
index 2b34cf3cbee38..4d4fc361f4879 100644
--- a/packages/shared/ReactFeatureFlags.js
+++ b/packages/shared/ReactFeatureFlags.js
@@ -30,8 +30,7 @@ export const enableComponentStackLocations = true;
 // -----------------------------------------------------------------------------
 
 // TODO: Finish rolling out in www
-export const enableClientRenderFallbackOnTextMismatch = true;
-export const enableFormActions = true;
+export const favorSafetyOverHydrationPerf = true;
 export const enableAsyncActions = true;
 
 // Need to remove didTimeout argument from Scheduler before landing
@@ -100,8 +99,6 @@ export const enableSuspenseAvoidThisFallbackFizz = false;
 
 export const enableCPUSuspense = __EXPERIMENTAL__;
 
-export const enableFloat = true;
-
 // Enables unstable_useMemoCache hook, intended as a compilation target for
 // auto-memoization.
 export const enableUseMemoCacheHook = __EXPERIMENTAL__;
@@ -113,16 +110,12 @@ export const enableUseEffectEventHook = __EXPERIMENTAL__;
 // (handled with an MutationObserver) instead of inline-scripts
 export const enableFizzExternalRuntime = true;
 
-export const alwaysThrottleDisappearingFallbacks = true;
-
 export const alwaysThrottleRetries = true;
 
 export const passChildrenWhenCloningPersistedNodes = false;
 
 export const enableUseDeferredValueInitialArg = __EXPERIMENTAL__;
 
-export const enableRenderableContext = false;
-
 export const enableServerComponentLogs = __EXPERIMENTAL__;
 
 /**
@@ -143,10 +136,6 @@ const __NEXT_MAJOR__ = __EXPERIMENTAL__;
 // Removes legacy style context
 export const disableLegacyContext = __NEXT_MAJOR__;
 
-// Not ready to break experimental yet.
-// Disable javascript: URL strings in href for XSS protection.
-export const disableJavaScriptURLs = __NEXT_MAJOR__;
-
 // Not ready to break experimental yet.
 // Modern <StrictMode /> behaviour aligns more with what components
 // components will encounter in production, especially when used With <Offscreen />.
@@ -157,12 +146,6 @@ export const useModernStrictMode = __NEXT_MAJOR__;
 // Remove IE and MsApp specific workarounds for innerHTML
 export const disableIEWorkarounds = __NEXT_MAJOR__;
 
-// Changes the behavior for rendering custom elements in both server rendering
-// and client rendering, mostly to allow JSX attributes to apply to the custom
-// element's object properties instead of only HTML attributes.
-// https://github.com/facebook/react/issues/11347
-export const enableCustomElementPropertySupport = __NEXT_MAJOR__;
-
 // Filter certain DOM attributes (e.g. src, href) if their values are empty
 // strings. This prevents e.g. <img src=""> from making an unnecessary HTTP
 // request for certain browsers.
@@ -190,22 +173,18 @@ export const enableInfiniteRenderLoopDetection = true;
 export const enableRefAsProp = __NEXT_MAJOR__;
 export const disableStringRefs = __NEXT_MAJOR__;
 
-// Not ready to break experimental yet.
-// Needs more internal cleanup
 // Warn on any usage of ReactTestRenderer
-export const enableReactTestRendererWarning = false;
+export const enableReactTestRendererWarning = __NEXT_MAJOR__;
 
 // Disables legacy mode
 // This allows us to land breaking changes to remove legacy mode APIs in experimental builds
 // before removing them in stable in the next Major
 export const disableLegacyMode = __NEXT_MAJOR__;
 
-// HTML boolean attributes need a special PropertyInfoRecord.
-// Between support of these attributes in browsers and React supporting them as
-// boolean props library users can use them as `<div someBooleanAttribute="" />`.
-// However, once React considers them as boolean props an empty string will
-// result in false property i.e. break existing usage.
-export const enableNewBooleanProps = __NEXT_MAJOR__;
+export const disableDOMTestUtils = __NEXT_MAJOR__;
+
+// Make <Context> equivalent to <Context.Provider> instead of <Context.Consumer>
+export const enableRenderableContext = __NEXT_MAJOR__;
 
 // -----------------------------------------------------------------------------
 // Chopping Block
@@ -214,8 +193,6 @@ export const enableNewBooleanProps = __NEXT_MAJOR__;
 // when we plan to enable them.
 // -----------------------------------------------------------------------------
 
-export const disableModulePatternComponents = __NEXT_MAJOR__;
-
 export const enableUseRefAccessWarning = false;
 
 // Enables time slicing for updates that aren't wrapped in startTransition.
diff --git a/packages/shared/ReactVersion.js b/packages/shared/ReactVersion.js
index d0a14cfff7806..13dd40e747e0d 100644
--- a/packages/shared/ReactVersion.js
+++ b/packages/shared/ReactVersion.js
@@ -7,10 +7,9 @@
 
 // TODO: this is special because it gets imported during build.
 //
-// TODO: 18.0.0 has not been released to NPM;
 // It exists as a placeholder so that DevTools can support work tag changes between releases.
 // When we next publish a release, update the matching TODO in backend/renderer.js
 // TODO: This module is used both by the release scripts and to expose a version
 // at runtime. We should instead inject the version number as part of the build
 // process, and use the ReactVersions.js module as the single source of truth.
-export default '18.2.0';
+export default '19.0.0';
diff --git a/packages/shared/forks/ReactFeatureFlags.native-fb-dynamic.js b/packages/shared/forks/ReactFeatureFlags.native-fb-dynamic.js
index 38943de13d524..be82df80b8217 100644
--- a/packages/shared/forks/ReactFeatureFlags.native-fb-dynamic.js
+++ b/packages/shared/forks/ReactFeatureFlags.native-fb-dynamic.js
@@ -7,9 +7,6 @@
  * @flow strict
  */
 
-import typeof * as ExportsType from './ReactFeatureFlags.native-fb-dynamic';
-import typeof * as DynamicFlagsType from 'ReactNativeInternalFeatureFlags';
-
 // In xplat, these flags are controlled by GKs. Because most GKs have some
 // population running in either mode, we should run our tests that way, too,
 //
@@ -18,12 +15,12 @@ import typeof * as DynamicFlagsType from 'ReactNativeInternalFeatureFlags';
 //
 // TODO: __VARIANT__ isn't supported for React Native flags yet. You can set the
 // flag here but it won't be set to `true` in any of our test runs. Need to
-// update the test configuration.
+// add a test configuration for React Native.
 
-export const alwaysThrottleDisappearingFallbacks = __VARIANT__;
 export const alwaysThrottleRetries = __VARIANT__;
 export const consoleManagedByDevToolsDuringStrictMode = __VARIANT__;
 export const enableAsyncActions = __VARIANT__;
+export const enableBigIntSupport = __VARIANT__;
 export const enableComponentStackLocations = __VARIANT__;
 export const enableDeferRootSchedulingToMicrotask = __VARIANT__;
 export const enableInfiniteRenderLoopDetection = __VARIANT__;
@@ -32,6 +29,3 @@ export const enableUnifiedSyncLane = __VARIANT__;
 export const enableUseRefAccessWarning = __VARIANT__;
 export const passChildrenWhenCloningPersistedNodes = __VARIANT__;
 export const useModernStrictMode = __VARIANT__;
-
-// Flow magic to verify the exports of this file match the original version.
-((((null: any): ExportsType): DynamicFlagsType): ExportsType);
diff --git a/packages/shared/forks/ReactFeatureFlags.native-fb.js b/packages/shared/forks/ReactFeatureFlags.native-fb.js
index 64753fba3f96f..13e8d00c5b3b3 100644
--- a/packages/shared/forks/ReactFeatureFlags.native-fb.js
+++ b/packages/shared/forks/ReactFeatureFlags.native-fb.js
@@ -9,19 +9,20 @@
 
 import typeof * as FeatureFlagsType from 'shared/ReactFeatureFlags';
 import typeof * as ExportsType from './ReactFeatureFlags.native-fb';
+import typeof * as DynamicExportsType from './ReactFeatureFlags.native-fb-dynamic';
 
-// NOTE: There are no flags, currently. Uncomment the stuff below if we add one.
-// Re-export dynamic flags from the internal module. Intentionally using *
-// because this import is compiled to a `require` call.
-import * as dynamicFlags from 'ReactNativeInternalFeatureFlags';
+// Re-export dynamic flags from the internal module.
+// Intentionally using * because this import is compiled to a `require` call.
+import * as dynamicFlagsUntyped from 'ReactNativeInternalFeatureFlags';
+const dynamicFlags: DynamicExportsType = (dynamicFlagsUntyped: any);
 
 // We destructure each value before re-exporting to avoid a dynamic look-up on
 // the exports object every time a flag is read.
 export const {
-  alwaysThrottleDisappearingFallbacks,
   alwaysThrottleRetries,
   consoleManagedByDevToolsDuringStrictMode,
   enableAsyncActions,
+  enableBigIntSupport,
   enableComponentStackLocations,
   enableDeferRootSchedulingToMicrotask,
   enableInfiniteRenderLoopDetection,
@@ -33,7 +34,6 @@ export const {
 } = dynamicFlags;
 
 // The rest of the flags are static for better dead code elimination.
-export const disableModulePatternComponents = true;
 export const enableDebugTracing = false;
 export const enableAsyncDebugInfo = false;
 export const enableSchedulingProfiler = __PROFILE__;
@@ -45,12 +45,10 @@ export const enableCache = true;
 export const enableLegacyCache = false;
 export const enableCacheElement = true;
 export const enableFetchInstrumentation = false;
-export const enableFormActions = true; // Doesn't affect Native
 export const enableBinaryFlight = true;
 export const enableTaint = true;
 export const enablePostpone = false;
 export const debugRenderPhaseSideEffectsForStrictMode = __DEV__;
-export const disableJavaScriptURLs = true;
 export const disableCommentsAsDOMContainers = true;
 export const disableInputAttributeSyncing = false;
 export const disableIEWorkarounds = true;
@@ -65,7 +63,7 @@ export const enableSuspenseAvoidThisFallbackFizz = false;
 export const enableCPUSuspense = true;
 export const enableUseMemoCacheHook = true;
 export const enableUseEffectEventHook = false;
-export const enableClientRenderFallbackOnTextMismatch = true;
+export const favorSafetyOverHydrationPerf = true;
 export const enableLegacyFBSupport = false;
 export const enableFilterEmptyStringAttributesDOM = true;
 export const enableGetInspectorDataForInstanceInProduction = true;
@@ -80,13 +78,9 @@ export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const forceConcurrentByDefaultForTesting = false;
 export const allowConcurrentByDefault = false;
-export const enableCustomElementPropertySupport = true;
-export const enableNewBooleanProps = true;
 
 export const enableTransitionTracing = false;
 
-export const enableFloat = true;
-
 export const enableDO_NOT_USE_disableStrictPassiveEffect = false;
 export const enableFizzExternalRuntime = true;
 
@@ -103,8 +97,7 @@ export const disableStringRefs = false;
 
 export const enableReactTestRendererWarning = false;
 export const disableLegacyMode = false;
-
-export const enableBigIntSupport = false;
+export const disableDOMTestUtils = false;
 
 // Flow magic to verify the exports of this file match the original version.
 ((((null: any): ExportsType): FeatureFlagsType): ExportsType);
diff --git a/packages/shared/forks/ReactFeatureFlags.native-oss.js b/packages/shared/forks/ReactFeatureFlags.native-oss.js
index 4dd502dc0d46b..904f165c214cb 100644
--- a/packages/shared/forks/ReactFeatureFlags.native-oss.js
+++ b/packages/shared/forks/ReactFeatureFlags.native-oss.js
@@ -10,100 +10,104 @@
 import typeof * as FeatureFlagsType from 'shared/ReactFeatureFlags';
 import typeof * as ExportsType from './ReactFeatureFlags.native-oss';
 
+// TODO: Align these flags with canary and delete this file once RN ships from Canary.
+
 // -----------------------------------------------------------------------------
-// Ready for next major.
+// TODO for next React Native major.
 //
-// Alias __NEXT_MAJOR__ to false for easier skimming.
+// Alias __TODO_NEXT_RN_MAJOR__ to false for easier skimming.
 // -----------------------------------------------------------------------------
-const __NEXT_MAJOR__ = false;
+const __TODO_NEXT_RN_MAJOR__ = false;
+export const enableRefAsProp = __TODO_NEXT_RN_MAJOR__;
+export const disableStringRefs = __TODO_NEXT_RN_MAJOR__;
+export const disableLegacyMode = __TODO_NEXT_RN_MAJOR__;
+export const disableDOMTestUtils = __TODO_NEXT_RN_MAJOR__;
+export const enableBigIntSupport = __TODO_NEXT_RN_MAJOR__;
+export const useModernStrictMode = __TODO_NEXT_RN_MAJOR__;
+export const enableReactTestRendererWarning = __TODO_NEXT_RN_MAJOR__;
+export const enableAsyncActions = __TODO_NEXT_RN_MAJOR__;
+export const consoleManagedByDevToolsDuringStrictMode = __TODO_NEXT_RN_MAJOR__;
+export const enableDeferRootSchedulingToMicrotask = __TODO_NEXT_RN_MAJOR__;
+export const alwaysThrottleRetries = __TODO_NEXT_RN_MAJOR__;
+export const enableInfiniteRenderLoopDetection = __TODO_NEXT_RN_MAJOR__;
+export const enableComponentStackLocations = __TODO_NEXT_RN_MAJOR__;
 
+// -----------------------------------------------------------------------------
+// These are ready to flip after the next React npm release (or RN switches to
+// Canary, but can't flip before then because of react/renderer mismatches.
+// -----------------------------------------------------------------------------
+export const enableCache = __TODO_NEXT_RN_MAJOR__;
+export const enableRenderableContext = __TODO_NEXT_RN_MAJOR__;
+
+// -----------------------------------------------------------------------------
+// Already enabled for next React Native major.
+// Hardcode these to true after the next RN major.
+//
+// Alias __NEXT_RN_MAJOR__ to true for easier skimming.
+// -----------------------------------------------------------------------------
+const __NEXT_RN_MAJOR__ = true;
+export const disableClientCache = __NEXT_RN_MAJOR__;
+export const disableLegacyContext = __NEXT_RN_MAJOR__;
+export const enableCacheElement = __NEXT_RN_MAJOR__;
+export const enableTaint = __NEXT_RN_MAJOR__;
+export const enableUnifiedSyncLane = __NEXT_RN_MAJOR__;
+export const enableFizzExternalRuntime = __NEXT_RN_MAJOR__; // DOM-only
+export const enableBinaryFlight = __NEXT_RN_MAJOR__; // DOM-only
+export const enableServerComponentKeys = __NEXT_RN_MAJOR__;
+export const enableServerComponentLogs = __NEXT_RN_MAJOR__;
+
+// DEV-only but enabled in the next RN Major.
+// Not supported by flag script to avoid the special case.
 export const debugRenderPhaseSideEffectsForStrictMode = __DEV__;
+
+// TODO: decide on React 19
+export const enableUseMemoCacheHook = false;
+export const enableUseDeferredValueInitialArg = __EXPERIMENTAL__;
+
+// -----------------------------------------------------------------------------
+// All other flags
+// -----------------------------------------------------------------------------
+export const enableCPUSuspense = false;
 export const enableDebugTracing = false;
 export const enableAsyncDebugInfo = false;
-export const enableSchedulingProfiler = false;
-export const enableProfilerTimer = __PROFILE__;
-export const enableProfilerCommitHooks = __PROFILE__;
-export const enableProfilerNestedUpdatePhase = __PROFILE__;
-export const enableUpdaterTracking = __PROFILE__;
-export const enableCache = __NEXT_MAJOR__;
+export const enableSchedulingProfiler = __PROFILE__;
 export const enableLegacyCache = false;
-export const enableCacheElement = true;
 export const enableFetchInstrumentation = false;
-export const enableFormActions = true; // Doesn't affect Native
-export const enableBinaryFlight = true;
-export const enableTaint = true;
 export const enablePostpone = false;
-export const disableJavaScriptURLs = true;
 export const disableCommentsAsDOMContainers = true;
 export const disableInputAttributeSyncing = false;
 export const disableIEWorkarounds = true;
 export const enableScopeAPI = false;
 export const enableCreateEventHandleAPI = false;
 export const enableSuspenseCallback = false;
-export const disableLegacyContext = true;
 export const enableTrustedTypesIntegration = false;
 export const disableTextareaChildren = false;
-export const disableModulePatternComponents = false;
 export const enableSuspenseAvoidThisFallback = false;
 export const enableSuspenseAvoidThisFallbackFizz = false;
-export const enableCPUSuspense = false;
-export const enableUseMemoCacheHook = false;
 export const enableUseEffectEventHook = false;
-export const enableClientRenderFallbackOnTextMismatch = true;
-export const enableComponentStackLocations = false;
+export const favorSafetyOverHydrationPerf = true;
 export const enableLegacyFBSupport = false;
 export const enableFilterEmptyStringAttributesDOM = true;
 export const enableGetInspectorDataForInstanceInProduction = false;
-export const enableRenderableContext = false;
-
 export const enableRetryLaneExpiration = false;
 export const retryLaneExpirationMs = 5000;
 export const syncLaneExpirationMs = 250;
 export const transitionLaneExpirationMs = 5000;
-
 export const enableUseRefAccessWarning = false;
-
 export const disableSchedulerTimeoutInWorkLoop = false;
 export const enableLazyContextPropagation = false;
 export const enableLegacyHidden = false;
 export const forceConcurrentByDefaultForTesting = false;
-export const enableUnifiedSyncLane = true;
 export const allowConcurrentByDefault = false;
-export const enableCustomElementPropertySupport = true;
-export const enableNewBooleanProps = true;
-
-export const consoleManagedByDevToolsDuringStrictMode = false;
-
 export const enableTransitionTracing = false;
-
-export const enableFloat = true;
-
-export const useModernStrictMode = false;
 export const enableDO_NOT_USE_disableStrictPassiveEffect = false;
-export const enableFizzExternalRuntime = true;
-export const enableDeferRootSchedulingToMicrotask = false;
-export const enableInfiniteRenderLoopDetection = false;
-
-export const enableAsyncActions = false;
-
-export const alwaysThrottleDisappearingFallbacks = false;
-export const alwaysThrottleRetries = false;
-
 export const passChildrenWhenCloningPersistedNodes = false;
-export const enableUseDeferredValueInitialArg = __EXPERIMENTAL__;
-export const disableClientCache = true;
-
-export const enableServerComponentKeys = true;
-export const enableServerComponentLogs = true;
-
-// TODO: Should turn this on in next "major" RN release.
-export const enableRefAsProp = false;
-export const disableStringRefs = false;
-
-export const enableReactTestRendererWarning = false;
 
-export const enableBigIntSupport = false;
-export const disableLegacyMode = false;
+// Profiling Only
+export const enableProfilerTimer = __PROFILE__;
+export const enableProfilerCommitHooks = __PROFILE__;
+export const enableProfilerNestedUpdatePhase = __PROFILE__;
+export const enableUpdaterTracking = __PROFILE__;
 
 // Flow magic to verify the exports of this file match the original version.
 ((((null: any): ExportsType): FeatureFlagsType): ExportsType);
diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.js
index 5bc1d25034f7f..df84dd4d4cc60 100644
--- a/packages/shared/forks/ReactFeatureFlags.test-renderer.js
+++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.js
@@ -22,11 +22,9 @@ export const enableCache = true;
 export const enableLegacyCache = __EXPERIMENTAL__;
 export const enableCacheElement = __EXPERIMENTAL__;
 export const enableFetchInstrumentation = true;
-export const enableFormActions = true; // Doesn't affect Test Renderer
 export const enableBinaryFlight = true;
 export const enableTaint = true;
 export const enablePostpone = false;
-export const disableJavaScriptURLs = true;
 export const disableCommentsAsDOMContainers = true;
 export const disableInputAttributeSyncing = false;
 export const disableIEWorkarounds = true;
@@ -40,12 +38,11 @@ export const enableSuspenseAvoidThisFallbackFizz = false;
 export const enableCPUSuspense = false;
 export const enableUseMemoCacheHook = true;
 export const enableUseEffectEventHook = false;
-export const enableClientRenderFallbackOnTextMismatch = true;
+export const favorSafetyOverHydrationPerf = true;
 export const enableComponentStackLocations = true;
 export const enableLegacyFBSupport = false;
 export const enableFilterEmptyStringAttributesDOM = true;
 export const enableGetInspectorDataForInstanceInProduction = false;
-export const enableRenderableContext = false;
 
 export const enableRetryLaneExpiration = false;
 export const retryLaneExpirationMs = 5000;
@@ -60,14 +57,11 @@ export const enableLegacyHidden = false;
 export const forceConcurrentByDefaultForTesting = false;
 export const enableUnifiedSyncLane = __EXPERIMENTAL__;
 export const allowConcurrentByDefault = false;
-export const enableCustomElementPropertySupport = false;
 
 export const consoleManagedByDevToolsDuringStrictMode = false;
 
 export const enableTransitionTracing = false;
 
-export const enableFloat = true;
-
 export const useModernStrictMode = false;
 export const enableDO_NOT_USE_disableStrictPassiveEffect = false;
 export const enableFizzExternalRuntime = true;
@@ -75,7 +69,6 @@ export const enableDeferRootSchedulingToMicrotask = true;
 
 export const enableAsyncActions = true;
 
-export const alwaysThrottleDisappearingFallbacks = true;
 export const alwaysThrottleRetries = true;
 
 export const passChildrenWhenCloningPersistedNodes = false;
@@ -95,12 +88,12 @@ export const enableInfiniteRenderLoopDetection = false;
 const __NEXT_MAJOR__ = __EXPERIMENTAL__;
 export const enableRefAsProp = __NEXT_MAJOR__;
 export const disableStringRefs = __NEXT_MAJOR__;
-export const enableReactTestRendererWarning = false;
 export const enableBigIntSupport = __NEXT_MAJOR__;
 export const disableLegacyMode = __NEXT_MAJOR__;
 export const disableLegacyContext = __NEXT_MAJOR__;
-export const enableNewBooleanProps = __NEXT_MAJOR__;
-export const disableModulePatternComponents = __NEXT_MAJOR__;
+export const disableDOMTestUtils = __NEXT_MAJOR__;
+export const enableRenderableContext = __NEXT_MAJOR__;
+export const enableReactTestRendererWarning = __NEXT_MAJOR__;
 
 // Flow magic to verify the exports of this file match the original version.
 ((((null: any): ExportsType): FeatureFlagsType): ExportsType);
diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.native.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.native.js
index e5a6bf7ec0b3e..879806d751575 100644
--- a/packages/shared/forks/ReactFeatureFlags.test-renderer.native.js
+++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.native.js
@@ -13,7 +13,7 @@ import typeof * as ExportsType from './ReactFeatureFlags.test-renderer';
 export const debugRenderPhaseSideEffectsForStrictMode = false;
 export const enableDebugTracing = false;
 export const enableAsyncDebugInfo = false;
-export const enableSchedulingProfiler = false;
+export const enableSchedulingProfiler = __PROFILE__;
 export const enableProfilerTimer = __PROFILE__;
 export const enableProfilerCommitHooks = __PROFILE__;
 export const enableProfilerNestedUpdatePhase = __PROFILE__;
@@ -22,11 +22,9 @@ export const enableCache = true;
 export const enableLegacyCache = false;
 export const enableCacheElement = true;
 export const enableFetchInstrumentation = false;
-export const enableFormActions = true; // Doesn't affect Test Renderer
 export const enableBinaryFlight = true;
 export const enableTaint = true;
 export const enablePostpone = false;
-export const disableJavaScriptURLs = true;
 export const disableCommentsAsDOMContainers = true;
 export const disableInputAttributeSyncing = false;
 export const disableIEWorkarounds = true;
@@ -36,17 +34,16 @@ export const enableSuspenseCallback = false;
 export const disableLegacyContext = false;
 export const enableTrustedTypesIntegration = false;
 export const disableTextareaChildren = false;
-export const disableModulePatternComponents = true;
 export const enableComponentStackLocations = false;
 export const enableLegacyFBSupport = false;
 export const enableFilterEmptyStringAttributesDOM = true;
 export const enableGetInspectorDataForInstanceInProduction = false;
 export const enableSuspenseAvoidThisFallback = false;
 export const enableSuspenseAvoidThisFallbackFizz = false;
-export const enableCPUSuspense = false;
+export const enableCPUSuspense = true;
 export const enableUseMemoCacheHook = true;
 export const enableUseEffectEventHook = false;
-export const enableClientRenderFallbackOnTextMismatch = true;
+export const favorSafetyOverHydrationPerf = true;
 export const enableUseRefAccessWarning = false;
 export const enableInfiniteRenderLoopDetection = false;
 export const enableRenderableContext = false;
@@ -62,23 +59,19 @@ export const enableLegacyHidden = false;
 export const forceConcurrentByDefaultForTesting = false;
 export const enableUnifiedSyncLane = true;
 export const allowConcurrentByDefault = true;
-export const enableCustomElementPropertySupport = true;
-export const enableNewBooleanProps = true;
 
 export const consoleManagedByDevToolsDuringStrictMode = false;
 
 export const enableTransitionTracing = false;
 
-export const enableFloat = true;
-
 export const useModernStrictMode = false;
 export const enableDO_NOT_USE_disableStrictPassiveEffect = false;
+export const enableFizzExternalRuntime = true;
 export const enableDeferRootSchedulingToMicrotask = false;
 
 export const enableAsyncActions = true;
 
-export const alwaysThrottleDisappearingFallbacks = true;
-export const alwaysThrottleRetries = true;
+export const alwaysThrottleRetries = false;
 
 export const passChildrenWhenCloningPersistedNodes = false;
 export const enableUseDeferredValueInitialArg = __EXPERIMENTAL__;
@@ -92,6 +85,7 @@ export const disableStringRefs = false;
 
 export const enableReactTestRendererWarning = false;
 export const disableLegacyMode = false;
+export const disableDOMTestUtils = false;
 
 export const enableBigIntSupport = false;
 
diff --git a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
index 21740962d076e..137852fad7c5c 100644
--- a/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
+++ b/packages/shared/forks/ReactFeatureFlags.test-renderer.www.js
@@ -22,11 +22,9 @@ export const enableCache = true;
 export const enableLegacyCache = true;
 export const enableCacheElement = true;
 export const enableFetchInstrumentation = false;
-export const enableFormActions = true; // Doesn't affect Test Renderer
 export const enableBinaryFlight = true;
 export const enableTaint = true;
 export const enablePostpone = false;
-export const disableJavaScriptURLs = true;
 export const disableCommentsAsDOMContainers = true;
 export const disableInputAttributeSyncing = false;
 export const disableIEWorkarounds = true;
@@ -36,13 +34,12 @@ export const enableSuspenseCallback = true;
 export const disableLegacyContext = false;
 export const enableTrustedTypesIntegration = false;
 export const disableTextareaChildren = false;
-export const disableModulePatternComponents = true;
 export const enableSuspenseAvoidThisFallback = true;
 export const enableSuspenseAvoidThisFallbackFizz = false;
 export const enableCPUSuspense = false;
 export const enableUseMemoCacheHook = true;
 export const enableUseEffectEventHook = false;
-export const enableClientRenderFallbackOnTextMismatch = true;
+export const favorSafetyOverHydrationPerf = true;
 export const enableComponentStackLocations = true;
 export const enableLegacyFBSupport = false;
 export const enableFilterEmptyStringAttributesDOM = true;
@@ -62,15 +59,11 @@ export const enableLegacyHidden = false;
 export const forceConcurrentByDefaultForTesting = false;
 export const enableUnifiedSyncLane = true;
 export const allowConcurrentByDefault = true;
-export const enableCustomElementPropertySupport = false;
-export const enableNewBooleanProps = false;
 
 export const consoleManagedByDevToolsDuringStrictMode = false;
 
 export const enableTransitionTracing = false;
 
-export const enableFloat = true;
-
 export const useModernStrictMode = false;
 export const enableDO_NOT_USE_disableStrictPassiveEffect = false;
 export const enableFizzExternalRuntime = false;
@@ -78,7 +71,6 @@ export const enableDeferRootSchedulingToMicrotask = true;
 
 export const enableAsyncActions = true;
 
-export const alwaysThrottleDisappearingFallbacks = false;
 export const alwaysThrottleRetries = true;
 
 export const passChildrenWhenCloningPersistedNodes = false;
@@ -94,8 +86,9 @@ export const disableStringRefs = false;
 
 export const enableReactTestRendererWarning = false;
 export const disableLegacyMode = false;
+export const disableDOMTestUtils = false;
 
-export const enableBigIntSupport = false;
+export const enableBigIntSupport = true;
 
 // Flow magic to verify the exports of this file match the original version.
 ((((null: any): ExportsType): FeatureFlagsType): ExportsType);
diff --git a/packages/shared/forks/ReactFeatureFlags.www-dynamic.js b/packages/shared/forks/ReactFeatureFlags.www-dynamic.js
index f8ebfb050fc67..95b9927092fc6 100644
--- a/packages/shared/forks/ReactFeatureFlags.www-dynamic.js
+++ b/packages/shared/forks/ReactFeatureFlags.www-dynamic.js
@@ -15,6 +15,7 @@
 
 export const disableInputAttributeSyncing = __VARIANT__;
 export const disableIEWorkarounds = __VARIANT__;
+export const enableBigIntSupport = __VARIANT__;
 export const enableLegacyFBSupport = __VARIANT__;
 export const enableUseRefAccessWarning = __VARIANT__;
 export const disableSchedulerTimeoutInWorkLoop = __VARIANT__;
@@ -23,16 +24,14 @@ export const forceConcurrentByDefaultForTesting = __VARIANT__;
 export const enableUnifiedSyncLane = __VARIANT__;
 export const enableTransitionTracing = __VARIANT__;
 export const enableDeferRootSchedulingToMicrotask = __VARIANT__;
-export const alwaysThrottleDisappearingFallbacks = __VARIANT__;
 export const alwaysThrottleRetries = __VARIANT__;
 export const enableDO_NOT_USE_disableStrictPassiveEffect = __VARIANT__;
 export const enableUseDeferredValueInitialArg = __VARIANT__;
 export const enableRenderableContext = __VARIANT__;
 export const useModernStrictMode = __VARIANT__;
 export const enableRefAsProp = __VARIANT__;
-export const enableClientRenderFallbackOnTextMismatch = __VARIANT__;
-export const enableNewBooleanProps = __VARIANT__;
 export const enableRetryLaneExpiration = __VARIANT__;
+export const favorSafetyOverHydrationPerf = __VARIANT__;
 export const retryLaneExpirationMs = 5000;
 export const syncLaneExpirationMs = 250;
 export const transitionLaneExpirationMs = 5000;
diff --git a/packages/shared/forks/ReactFeatureFlags.www.js b/packages/shared/forks/ReactFeatureFlags.www.js
index ed502266d112b..79ff994a0ad2d 100644
--- a/packages/shared/forks/ReactFeatureFlags.www.js
+++ b/packages/shared/forks/ReactFeatureFlags.www.js
@@ -17,6 +17,7 @@ const dynamicFeatureFlags: DynamicFeatureFlags = require('ReactFeatureFlags');
 export const {
   disableInputAttributeSyncing,
   disableIEWorkarounds,
+  enableBigIntSupport,
   enableTrustedTypesIntegration,
   enableLegacyFBSupport,
   enableDebugTracing,
@@ -26,7 +27,6 @@ export const {
   enableRetryLaneExpiration,
   enableTransitionTracing,
   enableDeferRootSchedulingToMicrotask,
-  alwaysThrottleDisappearingFallbacks,
   alwaysThrottleRetries,
   enableDO_NOT_USE_disableStrictPassiveEffect,
   disableSchedulerTimeoutInWorkLoop,
@@ -38,8 +38,7 @@ export const {
   enableRenderableContext,
   useModernStrictMode,
   enableRefAsProp,
-  enableNewBooleanProps,
-  enableClientRenderFallbackOnTextMismatch,
+  favorSafetyOverHydrationPerf,
 } = dynamicFeatureFlags;
 
 // On WWW, __EXPERIMENTAL__ is used for a new modern build.
@@ -54,13 +53,10 @@ export const enableUpdaterTracking = __PROFILE__;
 export const enableSuspenseAvoidThisFallback = true;
 export const enableSuspenseAvoidThisFallbackFizz = false;
 
-export const enableCustomElementPropertySupport = true;
 export const enableCPUSuspense = true;
-export const enableFloat = true;
 export const enableUseMemoCacheHook = true;
 export const enableUseEffectEventHook = true;
 export const enableFilterEmptyStringAttributesDOM = true;
-export const enableFormActions = true;
 export const enableAsyncActions = true;
 
 // Logs additional User Timing API marks for use with an experimental profiling tool.
@@ -80,14 +76,10 @@ export const enableTaint = false;
 
 export const enablePostpone = false;
 
-export const disableJavaScriptURLs = true;
-
 // TODO: www currently relies on this feature. It's disabled in open source.
 // Need to remove it.
 export const disableCommentsAsDOMContainers = false;
 
-export const disableModulePatternComponents = true;
-
 export const enableCreateEventHandleAPI = true;
 
 export const enableScopeAPI = true;
@@ -118,13 +110,13 @@ export const enableServerComponentLogs = true;
 
 export const enableReactTestRendererWarning = false;
 
-export const enableBigIntSupport = false;
-
 // TODO: Roll out with GK. Don't keep as dynamic flag for too long, though,
 // because JSX is an extremely hot path.
 export const disableStringRefs = false;
 
 export const disableLegacyMode = false;
 
+export const disableDOMTestUtils = false;
+
 // Flow magic to verify the exports of this file match the original version.
 ((((null: any): ExportsType): FeatureFlagsType): ExportsType);
diff --git a/packages/shared/reportGlobalError.js b/packages/shared/reportGlobalError.js
new file mode 100644
index 0000000000000..6cdb13d6a14ac
--- /dev/null
+++ b/packages/shared/reportGlobalError.js
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ *
+ * @flow
+ */
+
+const reportGlobalError: (error: mixed) => void =
+  typeof reportError === 'function'
+    ? // In modern browsers, reportError will dispatch an error event,
+      // emulating an uncaught JavaScript error.
+      reportError
+    : error => {
+        if (
+          typeof window === 'object' &&
+          typeof window.ErrorEvent === 'function'
+        ) {
+          // Browser Polyfill
+          const message =
+            typeof error === 'object' &&
+            error !== null &&
+            typeof error.message === 'string'
+              ? // eslint-disable-next-line react-internal/safe-string-coercion
+                String(error.message)
+              : // eslint-disable-next-line react-internal/safe-string-coercion
+                String(error);
+          const event = new window.ErrorEvent('error', {
+            bubbles: true,
+            cancelable: true,
+            message: message,
+            error: error,
+          });
+          const shouldLog = window.dispatchEvent(event);
+          if (!shouldLog) {
+            return;
+          }
+        } else if (
+          typeof process === 'object' &&
+          // $FlowFixMe[method-unbinding]
+          typeof process.emit === 'function'
+        ) {
+          // Node Polyfill
+          process.emit('uncaughtException', error);
+          return;
+        }
+        // eslint-disable-next-line react-internal/no-production-logging
+        console['error'](error);
+      };
+
+export default reportGlobalError;
diff --git a/packages/use-subscription/package.json b/packages/use-subscription/package.json
index 628586ff600b7..4f9a38be4609f 100644
--- a/packages/use-subscription/package.json
+++ b/packages/use-subscription/package.json
@@ -15,7 +15,7 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "rxjs": "^5.5.6"
diff --git a/packages/use-sync-external-store/package.json b/packages/use-sync-external-store/package.json
index 58f190549af87..f9b40856598ba 100644
--- a/packages/use-sync-external-store/package.json
+++ b/packages/use-sync-external-store/package.json
@@ -19,7 +19,7 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "react-17": "npm:react@^17",
diff --git a/packages/use-sync-external-store/src/__tests__/useSyncExternalStoreShared-test.js b/packages/use-sync-external-store/src/__tests__/useSyncExternalStoreShared-test.js
index 5d460444440d8..07058d4107158 100644
--- a/packages/use-sync-external-store/src/__tests__/useSyncExternalStoreShared-test.js
+++ b/packages/use-sync-external-store/src/__tests__/useSyncExternalStoreShared-test.js
@@ -143,7 +143,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     };
   }
 
-  test('basic usage', async () => {
+  it('basic usage', async () => {
     const store = createExternalStore('Initial');
 
     function App() {
@@ -165,7 +165,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('Updated');
   });
 
-  test('skips re-rendering if nothing changes', async () => {
+  it('skips re-rendering if nothing changes', async () => {
     const store = createExternalStore('Initial');
 
     function App() {
@@ -189,7 +189,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('Initial');
   });
 
-  test('switch to a different store', async () => {
+  it('switch to a different store', async () => {
     const storeA = createExternalStore(0);
     const storeB = createExternalStore(0);
 
@@ -242,7 +242,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('1');
   });
 
-  test('selecting a specific value inside getSnapshot', async () => {
+  it('selecting a specific value inside getSnapshot', async () => {
     const store = createExternalStore({a: 0, b: 0});
 
     function A() {
@@ -290,7 +290,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
   // In React 18, you can't observe in between a sync render and its
   // passive effects, so this is only relevant to legacy roots
   // @gate enableUseSyncExternalStoreShim
-  test(
+  it(
     "compares to current state before bailing out, even when there's a " +
       'mutation in between the sync and passive effects',
     async () => {
@@ -334,7 +334,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     },
   );
 
-  test('mutating the store in between render and commit when getSnapshot has changed', async () => {
+  it('mutating the store in between render and commit when getSnapshot has changed', async () => {
     const store = createExternalStore({a: 1, b: 1});
 
     const getSnapshotA = () => store.getState().a;
@@ -394,7 +394,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('B2');
   });
 
-  test('mutating the store in between render and commit when getSnapshot has _not_ changed', async () => {
+  it('mutating the store in between render and commit when getSnapshot has _not_ changed', async () => {
     // Same as previous test, but `getSnapshot` does not change
     const store = createExternalStore({a: 1, b: 1});
 
@@ -453,7 +453,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('A1');
   });
 
-  test("does not bail out if the previous update hasn't finished yet", async () => {
+  it("does not bail out if the previous update hasn't finished yet", async () => {
     const store = createExternalStore(0);
 
     function Child1() {
@@ -492,7 +492,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('00');
   });
 
-  test('uses the latest getSnapshot, even if it changed in the same batch as a store update', async () => {
+  it('uses the latest getSnapshot, even if it changed in the same batch as a store update', async () => {
     const store = createExternalStore({a: 0, b: 0});
 
     const getSnapshotA = () => store.getState().a;
@@ -523,7 +523,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('2');
   });
 
-  test('handles errors thrown by getSnapshot', async () => {
+  it('handles errors thrown by getSnapshot', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       static getDerivedStateFromError(error) {
@@ -568,23 +568,41 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     expect(container.textContent).toEqual('0');
 
     // Update that throws in a getSnapshot. We can catch it with an error boundary.
-    await act(() => {
-      store.set({value: 1, throwInGetSnapshot: true, throwInIsEqual: false});
-    });
-    if (gate(flags => !flags.enableUseSyncExternalStoreShim)) {
-      assertLog([
-        'Error in getSnapshot',
-        // In a concurrent root, React renders a second time to attempt to
-        // recover from the error.
-        'Error in getSnapshot',
-      ]);
+    if (__DEV__ && gate(flags => flags.enableUseSyncExternalStoreShim)) {
+      // In 17, the error is re-thrown in DEV.
+      await expect(async () => {
+        await act(() => {
+          store.set({
+            value: 1,
+            throwInGetSnapshot: true,
+            throwInIsEqual: false,
+          });
+        });
+      }).rejects.toThrow('Error in getSnapshot');
     } else {
-      assertLog(['Error in getSnapshot']);
+      await act(() => {
+        store.set({
+          value: 1,
+          throwInGetSnapshot: true,
+          throwInIsEqual: false,
+        });
+      });
     }
+
+    assertLog(
+      gate(flags => flags.enableUseSyncExternalStoreShim)
+        ? ['Error in getSnapshot']
+        : [
+            'Error in getSnapshot',
+            // In a concurrent root, React renders a second time to attempt to
+            // recover from the error.
+            'Error in getSnapshot',
+          ],
+    );
     expect(container.textContent).toEqual('Error in getSnapshot');
   });
 
-  test('Infinite loop if getSnapshot keeps returning new reference', async () => {
+  it('Infinite loop if getSnapshot keeps returning new reference', async () => {
     const store = createExternalStore({});
 
     function App() {
@@ -596,9 +614,11 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     const root = createRoot(container);
 
     await expect(async () => {
-      expect(() =>
-        ReactDOM.flushSync(async () => root.render(<App />)),
-      ).toThrow(
+      await expect(async () => {
+        await act(() => {
+          ReactDOM.flushSync(async () => root.render(<App />));
+        });
+      }).rejects.toThrow(
         'Maximum update depth exceeded. This can happen when a component repeatedly ' +
           'calls setState inside componentWillUpdate or componentDidUpdate. React limits ' +
           'the number of nested updates to prevent infinite loops.',
@@ -606,7 +626,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     }).toErrorDev(
       gate(flags => flags.enableUseSyncExternalStoreShim)
         ? [
-            'Uncaught [',
+            'Maximum update depth exceeded. ',
             'The result of getSnapshot should be cached to avoid an infinite loop',
             'The above error occurred in the',
           ]
@@ -625,7 +645,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     );
   });
 
-  test('getSnapshot can return NaN without infinite loop warning', async () => {
+  it('getSnapshot can return NaN without infinite loop warning', async () => {
     const store = createExternalStore('not a number');
 
     function App() {
@@ -655,7 +675,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
   describe('extra features implemented in user-space', () => {
     // The selector implementation uses the lazy ref initialization pattern
     // @gate !(enableUseRefAccessWarning && __DEV__)
-    test('memoized selectors are only called once per update', async () => {
+    it('memoized selectors are only called once per update', async () => {
       const store = createExternalStore({a: 0, b: 0});
 
       function selector(state) {
@@ -698,7 +718,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
 
     // The selector implementation uses the lazy ref initialization pattern
     // @gate !(enableUseRefAccessWarning && __DEV__)
-    test('Using isEqual to bailout', async () => {
+    it('Using isEqual to bailout', async () => {
       const store = createExternalStore({a: 0, b: 0});
 
       function A() {
@@ -757,7 +777,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
       expect(container.textContent).toEqual('A1B1');
     });
 
-    test('basic server hydration', async () => {
+    it('basic server hydration', async () => {
       const store = createExternalStore('client');
 
       const ref = React.createRef();
@@ -810,7 +830,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
     });
   });
 
-  test('regression test for #23150', async () => {
+  it('regression test for #23150', async () => {
     const store = createExternalStore('Initial');
 
     function App() {
@@ -839,7 +859,7 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
 
   // The selector implementation uses the lazy ref initialization pattern
   // @gate !(enableUseRefAccessWarning && __DEV__)
-  test('compares selection to rendered selection even if selector changes', async () => {
+  it('compares selection to rendered selection even if selector changes', async () => {
     const store = createExternalStore({items: ['A', 'B']});
 
     const shallowEqualArray = (a, b) => {
@@ -958,15 +978,31 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
 
       expect(container.textContent).toEqual('A');
 
-      await expect(async () => {
-        await act(() => {
-          store.set({});
-        });
-      }).toWarnDev(
-        ReactFeatureFlags.enableUseRefAccessWarning
-          ? ['Warning: App: Unsafe read of a mutable value during render.']
-          : [],
-      );
+      if (__DEV__ && gate(flags => flags.enableUseSyncExternalStoreShim)) {
+        // In 17, the error is re-thrown in DEV.
+        await expect(async () => {
+          await expect(async () => {
+            await act(() => {
+              store.set({});
+            });
+          }).rejects.toThrow('Malformed state');
+        }).toWarnDev(
+          ReactFeatureFlags.enableUseRefAccessWarning
+            ? ['Warning: App: Unsafe read of a mutable value during render.']
+            : [],
+        );
+      } else {
+        await expect(async () => {
+          await act(() => {
+            store.set({});
+          });
+        }).toWarnDev(
+          ReactFeatureFlags.enableUseRefAccessWarning
+            ? ['Warning: App: Unsafe read of a mutable value during render.']
+            : [],
+        );
+      }
+
       expect(container.textContent).toEqual('Malformed state');
     });
 
@@ -1003,15 +1039,31 @@ describe('Shared useSyncExternalStore behavior (shim and built-in)', () => {
 
       expect(container.textContent).toEqual('A');
 
-      await expect(async () => {
-        await act(() => {
-          store.set({});
-        });
-      }).toWarnDev(
-        ReactFeatureFlags.enableUseRefAccessWarning
-          ? ['Warning: App: Unsafe read of a mutable value during render.']
-          : [],
-      );
+      if (__DEV__ && gate(flags => flags.enableUseSyncExternalStoreShim)) {
+        // In 17, the error is re-thrown in DEV.
+        await expect(async () => {
+          await expect(async () => {
+            await act(() => {
+              store.set({});
+            });
+          }).rejects.toThrow('Malformed state');
+        }).toWarnDev(
+          ReactFeatureFlags.enableUseRefAccessWarning
+            ? ['Warning: App: Unsafe read of a mutable value during render.']
+            : [],
+        );
+      } else {
+        await expect(async () => {
+          await act(() => {
+            store.set({});
+          });
+        }).toWarnDev(
+          ReactFeatureFlags.enableUseRefAccessWarning
+            ? ['Warning: App: Unsafe read of a mutable value during render.']
+            : [],
+        );
+      }
+
       expect(container.textContent).toEqual('Malformed state');
     });
   });
diff --git a/scripts/babel/__tests__/transform-test-gate-pragma-test.js b/scripts/babel/__tests__/transform-test-gate-pragma-test.js
index 1970ab4c1c2c2..e4b76dd05e859 100644
--- a/scripts/babel/__tests__/transform-test-gate-pragma-test.js
+++ b/scripts/babel/__tests__/transform-test-gate-pragma-test.js
@@ -203,6 +203,15 @@ describe('transform test-gate-pragma: actual runtime', () => {
     console.error('Stop that!');
     throw Error('I told you to stop!');
   });
+
+  // @gate false
+  test('a global error event is treated as a test failure', () => {
+    dispatchEvent(
+      new ErrorEvent('error', {
+        error: new Error('Oops!'),
+      })
+    );
+  });
 });
 
 describe('dynamic gate method', () => {
diff --git a/scripts/error-codes/codes.json b/scripts/error-codes/codes.json
index 1614f95b86b42..cc1985051339a 100644
--- a/scripts/error-codes/codes.json
+++ b/scripts/error-codes/codes.json
@@ -403,7 +403,7 @@
   "415": "Error parsing the data. It's probably an error code or network corruption.",
   "416": "This environment don't support binary chunks.",
   "417": "React currently only supports piping to one writable stream.",
-  "418": "Hydration failed because the initial UI does not match what was rendered on the server.",
+  "418": "Hydration failed because the server rendered HTML didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:\n\n- A server/client branch `if (typeof window !== 'undefined')`.\n- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n- Date formatting in a user's locale which doesn't match the server.\n- External changing data without sending a snapshot of it along with the HTML.\n- Invalid HTML tag nesting.\n\nIt can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n\nhttps://react.dev/link/hydration-mismatch%s",
   "419": "The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.",
   "420": "ServerContext: %s already defined",
   "421": "This Suspense boundary received an update before it finished hydrating. This caused the boundary to switch to client rendering. The usual way to fix this is to wrap the original update in startTransition.",
@@ -494,5 +494,14 @@
   "506": "Functions are not valid as a child of Client Components. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.%s",
   "507": "Expected the last optional `callback` argument to be a function. Instead received: %s.",
   "508": "The first argument must be a React class instance. Instead received: %s.",
-  "509": "ReactDOM: Unsupported Legacy Mode API."
+  "509": "ReactDOM: Unsupported Legacy Mode API.",
+  "510": "React Element cannot be passed to Server Functions from the Client without a temporary reference set. Pass a TemporaryReferenceSet to the options.%s",
+  "511": "Missing a temporary reference set but the RSC response returned a temporary reference. Pass a temporaryReference option with the set that was used with the reply.",
+  "512": "The RSC response contained a reference that doesn't exist in the temporary reference set. Always pass the matching set that was used to create the reply when parsing its response.",
+  "513": "Cannot render a Client Context Provider on the Server. Instead, you can export a Client Component wrapper that itself renders a Client Context Provider.",
+  "514": "Cannot access %s on the server. You cannot dot into a temporary client reference from a server component. You can only pass the value through to the client.",
+  "515": "Cannot assign to a temporary client reference from a server module.",
+  "516": "Attempted to call a temporary Client Reference from the server but it is on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component.",
+  "517": "Symbols cannot be passed to a Server Function without a temporary reference set. Pass a TemporaryReferenceSet to the options.%s",
+  "518": "Saw multiple hydration diff roots in a pass. This is a bug in React."
 }
diff --git a/scripts/flags/flags.js b/scripts/flags/flags.js
index 2b4fced638ff6..50d263cd498ef 100644
--- a/scripts/flags/flags.js
+++ b/scripts/flags/flags.js
@@ -36,6 +36,7 @@ const argv = yargs
         'www-modern',
         'rn',
         'rn-fb',
+        'rn-next',
         'canary',
         'next',
         'experimental',
@@ -55,6 +56,7 @@ const argv = yargs
         'www-modern',
         'rn',
         'rn-fb',
+        'rn-next',
         'canary',
         'next',
         'experimental',
@@ -62,10 +64,10 @@ const argv = yargs
     },
   }).argv;
 
-// Load ReactNativeFeatureFlags with __NEXT_MAJOR__ replace with 'next'.
+// Load ReactFeatureFlags with __NEXT_MAJOR__ replaced with 'next'.
 // We need to do string replace, since the __NEXT_MAJOR__ is assigned to __EXPERIMENTAL__.
-function getReactNativeFeatureFlagsMajor() {
-  const virtualName = 'ReactNativeFeatureFlagsMajor.js';
+function getReactFeatureFlagsMajor() {
+  const virtualName = 'ReactFeatureFlagsMajor.js';
   const file = fs.readFileSync(
     path.join(__dirname, '../../packages/shared/ReactFeatureFlags.js'),
     'utf8'
@@ -89,6 +91,41 @@ function getReactNativeFeatureFlagsMajor() {
   return m.exports;
 }
 
+// Load RN ReactFeatureFlags with __NEXT_RN_MAJOR__ replaced with 'next'.
+// We need to do string replace, since the __NEXT_RN_MAJOR__ is assigned to false.
+function getReactNativeFeatureFlagsMajor() {
+  const virtualName = 'ReactNativeFeatureFlagsMajor.js';
+  const file = fs.readFileSync(
+    path.join(
+      __dirname,
+      '../../packages/shared/forks/ReactFeatureFlags.native-oss.js'
+    ),
+    'utf8'
+  );
+  const fileContent = transformSync(
+    file
+      .replace(
+        'const __NEXT_RN_MAJOR__ = true;',
+        'const __NEXT_RN_MAJOR__ = "next";'
+      )
+      .replace(
+        'const __TODO_NEXT_RN_MAJOR__ = false;',
+        'const __TODO_NEXT_RN_MAJOR__ = "next-todo";'
+      ),
+    {
+      plugins: ['@babel/plugin-transform-modules-commonjs'],
+    }
+  ).code;
+
+  const parent = module.parent;
+  const m = new Module(virtualName, parent);
+  m.filename = virtualName;
+
+  m._compile(fileContent, virtualName);
+
+  return m.exports;
+}
+
 // The RN and www Feature flag files import files that don't exist.
 // Mock the imports with the dynamic flag values.
 function mockDynamicallyFeatureFlags() {
@@ -119,15 +156,14 @@ mockDynamicallyFeatureFlags();
 const ReactFeatureFlags = require('../../packages/shared/ReactFeatureFlags.js');
 const ReactFeatureFlagsWWW = require('../../packages/shared/forks/ReactFeatureFlags.www.js');
 const ReactFeatureFlagsNativeFB = require('../../packages/shared/forks/ReactFeatureFlags.native-fb.js');
-const ReactFeatureFlagsNativeOSS = require('../../packages/shared/forks/ReactFeatureFlags.native-oss.js');
-const ReactFeatureFlagsMajor = getReactNativeFeatureFlagsMajor();
+const ReactFeatureFlagsMajor = getReactFeatureFlagsMajor();
+const ReactNativeFeatureFlagsMajor = getReactNativeFeatureFlagsMajor();
 
 const allFlagsUniqueFlags = Array.from(
   new Set([
     ...Object.keys(ReactFeatureFlags),
     ...Object.keys(ReactFeatureFlagsWWW),
     ...Object.keys(ReactFeatureFlagsNativeFB),
-    ...Object.keys(ReactFeatureFlagsNativeOSS),
   ])
 ).sort();
 
@@ -223,11 +259,37 @@ function getWWWClassicFlagValue(flag) {
   }
 }
 
+function getRNNextMajorFlagValue(flag) {
+  const value = ReactNativeFeatureFlagsMajor[flag];
+  if (value === true || value === 'next') {
+    return '✅';
+  } else if (value === 'next-todo') {
+    return '📋';
+  } else if (value === false || value === 'experimental') {
+    return '❌';
+  } else if (value === 'profile') {
+    return '📊';
+  } else if (value === 'dev') {
+    return '💻';
+  } else if (value === 'gk') {
+    return '🧪';
+  } else if (typeof value === 'number') {
+    return value;
+  } else {
+    throw new Error(`Unexpected RN OSS value ${value} for flag ${flag}`);
+  }
+}
+
 function getRNOSSFlagValue(flag) {
-  const value = ReactFeatureFlagsNativeOSS[flag];
+  const value = ReactNativeFeatureFlagsMajor[flag];
   if (value === true) {
     return '✅';
-  } else if (value === false || value === 'experimental' || value === 'next') {
+  } else if (
+    value === false ||
+    value === 'experimental' ||
+    value === 'next' ||
+    value === 'next-todo'
+  ) {
     return '❌';
   } else if (value === 'profile') {
     return '📊';
@@ -271,6 +333,8 @@ function argToHeader(arg) {
       return 'RN OSS';
     case 'rn-fb':
       return 'RN FB';
+    case 'rn-next':
+      return 'RN Next Major';
     case 'canary':
       return 'OSS Canary';
     case 'next':
@@ -282,20 +346,28 @@ function argToHeader(arg) {
   }
 }
 
+const FLAG_CONFIG = {
+  'OSS Next Major': getNextMajorFlagValue,
+  'OSS Canary': getOSSCanaryFlagValue,
+  'OSS Experimental': getOSSExperimentalFlagValue,
+  'WWW Classic': getWWWClassicFlagValue,
+  'WWW Modern': getWWWModernFlagValue,
+  'RN FB': getRNFBFlagValue,
+  'RN OSS': getRNOSSFlagValue,
+  'RN Next Major': getRNNextMajorFlagValue,
+};
+
+const FLAG_COLUMNS = Object.keys(FLAG_CONFIG);
+
 // Build the table with the value for each flag.
 const isDiff = argv.diff != null && argv.diff.length > 1;
 const table = {};
 // eslint-disable-next-line no-for-of-loops/no-for-of-loops
 for (const flag of allFlagsUniqueFlags) {
-  const values = {
-    'OSS Next Major': getNextMajorFlagValue(flag),
-    'OSS Canary': getOSSCanaryFlagValue(flag),
-    'OSS Experimental': getOSSExperimentalFlagValue(flag),
-    'WWW Classic': getWWWClassicFlagValue(flag),
-    'WWW Modern': getWWWModernFlagValue(flag),
-    'RN FB': getRNFBFlagValue(flag),
-    'RN OSS': getRNOSSFlagValue(flag),
-  };
+  const values = FLAG_COLUMNS.reduce((acc, key) => {
+    acc[key] = FLAG_CONFIG[key](flag);
+    return acc;
+  }, {});
 
   if (!isDiff) {
     table[flag] = values;
@@ -330,17 +402,18 @@ if (isDiff || argv.sort) {
 }
 
 if (argv.csv) {
-  const csvHeader =
-    'Flag name, WWW Classic, RN FB, OSS Canary, OSS Experimental, WWW Modern, RN OSS\n';
-  const csvRows = Object.keys(sorted).map(flag => {
-    const row = sorted[flag];
-    return `${flag}, ${row['WWW Classic']}, ${row['RN FB']}, ${row['OSS Canary']}, ${row['OSS Experimental']}, ${row['WWW Modern']}, ${row['RN OSS']}`;
-  });
-  fs.writeFile('./flags.csv', csvHeader + csvRows.join('\n'), function (err) {
+  const csvRows = [
+    `Flag name, ${FLAG_COLUMNS.join(', ')}`,
+    ...Object.keys(table).map(flag => {
+      const row = sorted[flag];
+      return `${flag}, ${FLAG_COLUMNS.map(col => row[col]).join(', ')}`;
+    }),
+  ];
+  fs.writeFile('./flags.csv', csvRows.join('\n'), function (err) {
     if (err) {
       return console.log(err);
     }
-    console.log('The file was saved!');
+    console.log('The file was saved to ./flags.csv');
   });
 }
 
@@ -354,3 +427,12 @@ Object.keys(sorted).forEach(key => {
 
 // print table with formatting
 console.table(padded);
+console.log(`
+Legend:
+  ✅ On
+  ❌ Off
+  💻 DEV
+  📋 TODO
+  📊 Profiling
+  🧪 Experiment
+`);
diff --git a/scripts/flow/environment.js b/scripts/flow/environment.js
index 255ed4a2b99ba..cba4dd5e61566 100644
--- a/scripts/flow/environment.js
+++ b/scripts/flow/environment.js
@@ -9,25 +9,25 @@
 
 /* eslint-disable */
 
-declare var __PROFILE__: boolean;
-declare var __UMD__: boolean;
-declare var __EXPERIMENTAL__: boolean;
-declare var __VARIANT__: boolean;
+declare const __PROFILE__: boolean;
+declare const __UMD__: boolean;
+declare const __EXPERIMENTAL__: boolean;
+declare const __VARIANT__: boolean;
 
-declare var __REACT_DEVTOOLS_GLOBAL_HOOK__: any; /*?{
+declare const __REACT_DEVTOOLS_GLOBAL_HOOK__: any; /*?{
   inject: ?((stuff: Object) => void)
 };*/
 
-declare var globalThis: Object;
+declare const globalThis: Object;
 
-declare var queueMicrotask: (fn: Function) => void;
-declare var reportError: (error: mixed) => void;
-declare var AggregateError: Class<Error>;
+declare const queueMicrotask: (fn: Function) => void;
+declare const reportError: (error: mixed) => void;
+declare const AggregateError: Class<Error>;
 
-declare var FinalizationRegistry: any;
+declare const FinalizationRegistry: any;
 
 declare module 'create-react-class' {
-  declare var exports: React$CreateClass;
+  declare const exports: React$CreateClass;
 }
 
 // Flow hides the props of React$Element, this overrides it to unhide
@@ -43,7 +43,7 @@ declare opaque type React$Element<
   +ref: any,
 };
 
-declare var trustedTypes: {
+declare const trustedTypes: {
   isHTML: (value: any) => boolean,
   isScript: (value: any) => boolean,
   isScriptURL: (value: any) => boolean,
@@ -89,22 +89,22 @@ declare module 'EventListener' {
 }
 
 declare function __webpack_chunk_load__(id: string): Promise<mixed>;
-declare var __webpack_require__: ((id: string) => any) & {
+declare const __webpack_require__: ((id: string) => any) & {
   u: string => string,
 };
 
 declare function __turbopack_load__(id: string): Promise<mixed>;
-declare var __turbopack_require__: ((id: string) => any) & {
+declare const __turbopack_require__: ((id: string) => any) & {
   u: string => string,
 };
 
 declare module 'fs/promises' {
-  declare var access: (path: string, mode?: number) => Promise<void>;
-  declare var lstat: (
+  declare const access: (path: string, mode?: number) => Promise<void>;
+  declare const lstat: (
     path: string,
     options?: ?{bigint?: boolean},
   ) => Promise<mixed>;
-  declare var readdir: (
+  declare const readdir: (
     path: string,
     options?:
       | ?string
@@ -113,7 +113,7 @@ declare module 'fs/promises' {
           withFileTypes?: ?boolean,
         },
   ) => Promise<Buffer>;
-  declare var readFile: (
+  declare const readFile: (
     path: string,
     options?:
       | ?string
@@ -121,7 +121,7 @@ declare module 'fs/promises' {
           encoding?: ?string,
         },
   ) => Promise<Buffer>;
-  declare var readlink: (
+  declare const readlink: (
     path: string,
     options?:
       | ?string
@@ -129,7 +129,7 @@ declare module 'fs/promises' {
           encoding?: ?string,
         },
   ) => Promise<mixed>;
-  declare var realpath: (
+  declare const realpath: (
     path: string,
     options?:
       | ?string
@@ -137,13 +137,13 @@ declare module 'fs/promises' {
           encoding?: ?string,
         },
   ) => Promise<mixed>;
-  declare var stat: (
+  declare const stat: (
     path: string,
     options?: ?{bigint?: boolean},
   ) => Promise<mixed>;
 }
 declare module 'pg' {
-  declare var Pool: (options: mixed) => {
+  declare const Pool: (options: mixed) => {
     query: (query: string, values?: Array<mixed>) => void,
   };
 }
@@ -320,7 +320,7 @@ declare class AsyncLocalStorage<T> {
   enterWith(store: T): void;
 }
 
-declare var async_hooks: {
+declare const async_hooks: {
   createHook(callbacks: any): any,
   executionAsyncId(): number,
 };
@@ -332,7 +332,7 @@ declare module 'node:worker_threads' {
   }
 }
 
-declare var Bun: {
+declare const Bun: {
   hash(
     input: string | $TypedArray | DataView | ArrayBuffer | SharedArrayBuffer,
   ): number,
diff --git a/scripts/flow/react-devtools.js b/scripts/flow/react-devtools.js
index 86968330ec31f..361ca168190ef 100644
--- a/scripts/flow/react-devtools.js
+++ b/scripts/flow/react-devtools.js
@@ -9,12 +9,12 @@
 
 /* eslint-disable no-unused-vars */
 
-declare var __EXTENSION__: boolean;
-declare var __TEST__: boolean;
+declare const __EXTENSION__: boolean;
+declare const __TEST__: boolean;
 
-declare var DARK_MODE_DIMMED_WARNING_COLOR: string;
-declare var DARK_MODE_DIMMED_ERROR_COLOR: string;
-declare var DARK_MODE_DIMMED_LOG_COLOR: string;
-declare var LIGHT_MODE_DIMMED_WARNING_COLOR: string;
-declare var LIGHT_MODE_DIMMED_ERROR_COLOR: string;
-declare var LIGHT_MODE_DIMMED_LOG_COLOR: string;
+declare const DARK_MODE_DIMMED_WARNING_COLOR: string;
+declare const DARK_MODE_DIMMED_ERROR_COLOR: string;
+declare const DARK_MODE_DIMMED_LOG_COLOR: string;
+declare const LIGHT_MODE_DIMMED_WARNING_COLOR: string;
+declare const LIGHT_MODE_DIMMED_ERROR_COLOR: string;
+declare const LIGHT_MODE_DIMMED_LOG_COLOR: string;
diff --git a/scripts/flow/react-native-host-hooks.js b/scripts/flow/react-native-host-hooks.js
index e1b8b0ca72a17..9c86a8ffeb95c 100644
--- a/scripts/flow/react-native-host-hooks.js
+++ b/scripts/flow/react-native-host-hooks.js
@@ -49,21 +49,21 @@ declare module 'react-native/Libraries/ReactPrivate/ReactNativePrivateInterface'
   ): boolean;
   declare export function deepFreezeAndThrowOnMutationInDev<T>(obj: T): T;
   declare export function flattenStyle(style: any): any;
-  declare export var RCTEventEmitter: {
+  declare export const RCTEventEmitter: {
     register: (eventEmitter: mixed) => void,
     ...
   };
-  declare export var TextInputState: {
+  declare export const TextInputState: {
     blurTextInput: (object: any) => void,
     focusTextInput: (object: any) => void,
     ...
   };
-  declare export var ReactFiberErrorDialog: {
+  declare export const ReactFiberErrorDialog: {
     showErrorDialog: (error: __CapturedError) => boolean,
     ...
   };
-  declare export var Platform: {OS: string, ...};
-  declare export var UIManager: {
+  declare export const Platform: {OS: string, ...};
+  declare export const UIManager: {
     customBubblingEventTypes: Object,
     customDirectEventTypes: Object,
     createView: (
@@ -123,15 +123,15 @@ declare module 'react-native/Libraries/ReactPrivate/ReactNativePrivateInterface'
     ) => void,
     ...
   };
-  declare export var legacySendAccessibilityEvent: (
+  declare export const legacySendAccessibilityEvent: (
     reactTag: number,
     eventTypeName: string,
   ) => void;
-  declare export var BatchedBridge: {
+  declare export const BatchedBridge: {
     registerCallableModule: (name: string, module: Object) => void,
     ...
   };
-  declare export var ReactNativeViewConfigRegistry: {
+  declare export const ReactNativeViewConfigRegistry: {
     customBubblingEventTypes: Object,
     customDirectEventTypes: Object,
 
@@ -139,7 +139,7 @@ declare module 'react-native/Libraries/ReactPrivate/ReactNativePrivateInterface'
     get: (name: string) => __ReactNativeBaseComponentViewConfig,
     ...
   };
-  declare export var RawEventEmitter: {
+  declare export const RawEventEmitter: {
     emit: (channel: string, event: RawEventEmitterEvent) => string,
     ...
   };
@@ -171,7 +171,7 @@ declare const RN$enableMicrotasksInReact: boolean;
 
 // This is needed for a short term solution.
 // See https://github.com/facebook/react/pull/15490 for more info
-declare var nativeFabricUIManager: {
+declare const nativeFabricUIManager: {
   createNode: (
     reactTag: number,
     viewName: string,
diff --git a/scripts/flow/xplat.js b/scripts/flow/xplat.js
index 9c458c2c8ef8c..3b8afbd894ff3 100644
--- a/scripts/flow/xplat.js
+++ b/scripts/flow/xplat.js
@@ -8,16 +8,5 @@
  */
 
 declare module 'ReactNativeInternalFeatureFlags' {
-  declare export var alwaysThrottleDisappearingFallbacks: boolean;
-  declare export var alwaysThrottleRetries: boolean;
-  declare export var consoleManagedByDevToolsDuringStrictMode: boolean;
-  declare export var enableAsyncActions: boolean;
-  declare export var enableComponentStackLocations: boolean;
-  declare export var enableDeferRootSchedulingToMicrotask: boolean;
-  declare export var enableInfiniteRenderLoopDetection: boolean;
-  declare export var enableRenderableContext: boolean;
-  declare export var enableUnifiedSyncLane: boolean;
-  declare export var enableUseRefAccessWarning: boolean;
-  declare export var passChildrenWhenCloningPersistedNodes: boolean;
-  declare export var useModernStrictMode: boolean;
+  declare module.exports: any;
 }
diff --git a/scripts/jest/matchers/toWarnDev.js b/scripts/jest/matchers/toWarnDev.js
index d61f3707b035c..70c7120ace965 100644
--- a/scripts/jest/matchers/toWarnDev.js
+++ b/scripts/jest/matchers/toWarnDev.js
@@ -71,11 +71,7 @@ const createMatcherFor = (consoleMethod, matcherName) =>
       const consoleSpy = (format, ...args) => {
         // Ignore uncaught errors reported by jsdom
         // and React addendums because they're too noisy.
-        if (
-          !logAllErrors &&
-          consoleMethod === 'error' &&
-          shouldIgnoreConsoleError(format, args)
-        ) {
+        if (!logAllErrors && shouldIgnoreConsoleError(format, args)) {
           return;
         }
 
diff --git a/scripts/jest/setupTests.js b/scripts/jest/setupTests.js
index 0d23861568fe4..82797189c43f9 100644
--- a/scripts/jest/setupTests.js
+++ b/scripts/jest/setupTests.js
@@ -3,6 +3,7 @@
 const chalk = require('chalk');
 const util = require('util');
 const shouldIgnoreConsoleError = require('./shouldIgnoreConsoleError');
+const shouldIgnoreConsoleWarn = require('./shouldIgnoreConsoleWarn');
 const {getTestFlags} = require('./TestFlags');
 
 if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
@@ -67,7 +68,12 @@ if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
     const newMethod = function (format, ...args) {
       // Ignore uncaught errors reported by jsdom
       // and React addendums because they're too noisy.
-      if (methodName === 'error' && shouldIgnoreConsoleError(format, args)) {
+      if (shouldIgnoreConsoleError(format, args)) {
+        return;
+      }
+
+      // Ignore certain React warnings causing test failures
+      if (methodName === 'warn' && shouldIgnoreConsoleWarn(format)) {
         return;
       }
 
@@ -241,13 +247,30 @@ if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
     global.Error = ErrorProxy;
   }
 
-  const expectTestToFail = async (callback, error) => {
+  const expectTestToFail = async (callback, errorToThrowIfTestSucceeds) => {
     if (callback.length > 0) {
       throw Error(
         'Gated test helpers do not support the `done` callback. Return a ' +
           'promise instead.'
       );
     }
+
+    // Install a global error event handler. We treat global error events as
+    // test failures, same as Jest's default behavior.
+    //
+    // Becaused we installed our own error event handler, Jest will not report a
+    // test failure. Conceptually it's as if we wrapped the entire test event in
+    // a try-catch.
+    let didError = false;
+    const errorEventHandler = () => {
+      didError = true;
+    };
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof addEventListener === 'function') {
+      // eslint-disable-next-line no-restricted-globals
+      addEventListener('error', errorEventHandler);
+    }
+
     try {
       const maybePromise = callback();
       if (
@@ -262,11 +285,20 @@ if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {
       // throws, we won't have captured it.
       flushAllUnexpectedConsoleCalls();
     } catch (testError) {
-      // Failed as expected
-      resetAllUnexpectedConsoleCalls();
-      return;
+      didError = true;
+    }
+    resetAllUnexpectedConsoleCalls();
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof removeEventListener === 'function') {
+      // eslint-disable-next-line no-restricted-globals
+      removeEventListener('error', errorEventHandler);
+    }
+
+    if (!didError) {
+      // The test did not error like we expected it to. Report this to Jest as
+      // a failure.
+      throw errorToThrowIfTestSucceeds;
     }
-    throw error;
   };
 
   const gatedErrorMessage = 'Gated test was expected to fail, but it passed.';
diff --git a/scripts/jest/shouldIgnoreConsoleError.js b/scripts/jest/shouldIgnoreConsoleError.js
index 2627e927eb892..9b64ea8c66b17 100644
--- a/scripts/jest/shouldIgnoreConsoleError.js
+++ b/scripts/jest/shouldIgnoreConsoleError.js
@@ -1,38 +1,31 @@
 'use strict';
 
-module.exports = function shouldIgnoreConsoleError(
-  format,
-  args,
-  {TODO_ignoreHydrationErrors} = {TODO_ignoreHydrationErrors: false}
-) {
+module.exports = function shouldIgnoreConsoleError(format, args) {
   if (__DEV__) {
     if (typeof format === 'string') {
       if (
         args[0] != null &&
-        typeof args[0].message === 'string' &&
-        typeof args[0].stack === 'string'
+        ((typeof args[0] === 'object' &&
+          typeof args[0].message === 'string' &&
+          typeof args[0].stack === 'string') ||
+          (typeof args[0] === 'string' &&
+            args[0].indexOf('An error occurred in ') === 0))
       ) {
         // This looks like an error with addendum from ReactFiberErrorLogger.
         // They are noisy too so we'll try to ignore them.
         return true;
       }
       if (
-        format.indexOf('ReactDOM.render is no longer supported in React 18') !==
-          -1 ||
+        format.indexOf('ReactDOM.render was removed in React 19') !== -1 ||
+        format.indexOf('ReactDOM.hydrate was removed in React 19') !== -1 ||
         format.indexOf(
-          'ReactDOM.hydrate is no longer supported in React 18'
-        ) !== -1
-      ) {
-        // We haven't finished migrating our tests to use createRoot.
-        return true;
-      }
-      if (
-        TODO_ignoreHydrationErrors &&
+          'ReactDOM.render has not been supported since React 18'
+        ) !== -1 ||
         format.indexOf(
-          'An error occurred during hydration. The server HTML was replaced with client content in'
+          'ReactDOM.hydrate has not been supported since React 18'
         ) !== -1
       ) {
-        // This also gets logged by onRecoverableError, so we can ignore it.
+        // We haven't finished migrating our tests to use createRoot.
         return true;
       }
     }
diff --git a/scripts/jest/shouldIgnoreConsoleWarn.js b/scripts/jest/shouldIgnoreConsoleWarn.js
new file mode 100644
index 0000000000000..9fa8414263bbc
--- /dev/null
+++ b/scripts/jest/shouldIgnoreConsoleWarn.js
@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function shouldIgnoreConsoleWarn(format) {
+  if (typeof format === 'string') {
+    if (format.indexOf('Warning: react-test-renderer is deprecated.') === 0) {
+      return true;
+    }
+  }
+
+  return false;
+};
diff --git a/scripts/jest/typescript/jest.d.ts b/scripts/jest/typescript/jest.d.ts
index 43aa392287e7c..57e93783665a7 100644
--- a/scripts/jest/typescript/jest.d.ts
+++ b/scripts/jest/typescript/jest.d.ts
@@ -1,16 +1,16 @@
-declare var __DEV__: boolean;
-declare var __TEST__: boolean;
-declare var __EXTENSION__: boolean;
+declare const __DEV__: boolean;
+declare const __TEST__: boolean;
+declare const __EXTENSION__: boolean;
 
 declare function afterEach(fn: any): any;
 declare function beforeEach(fn: any): any;
 declare function describe(name: string, fn: any): void;
-declare var it: {
+declare const it: {
   (name: string, fn: any): void;
   only: (name: string, fn: any) => void;
 }
 declare function expect(val: any): Expect;
-declare var jest: Jest;
+declare const jest: Jest;
 declare function pit(name: string, fn: any): void;
 declare function spyOnDev(obj: any, key: string): any;
 declare function spyOnDevAndProd(obj: any, key: string): any;
@@ -70,5 +70,5 @@ interface MockFunction {
   mockReturnValueOnce(value: any): MockFunction
 }
 
-declare var check: any;
-declare var gen: any;
+declare const check: any;
+declare const gen: any;
diff --git a/scripts/rollup/build-all-release-channels.js b/scripts/rollup/build-all-release-channels.js
index b7427d135bcc6..098177baf9a86 100644
--- a/scripts/rollup/build-all-release-channels.js
+++ b/scripts/rollup/build-all-release-channels.js
@@ -158,40 +158,30 @@ function processStable(buildDir) {
   }
 
   if (fs.existsSync(buildDir + '/facebook-www')) {
-    const hash = crypto.createHash('sha1');
     for (const fileName of fs.readdirSync(buildDir + '/facebook-www').sort()) {
       const filePath = buildDir + '/facebook-www/' + fileName;
       const stats = fs.statSync(filePath);
       if (!stats.isDirectory()) {
-        hash.update(fs.readFileSync(filePath));
         fs.renameSync(filePath, filePath.replace('.js', '.classic.js'));
       }
     }
     updatePlaceholderReactVersionInCompiledArtifacts(
       buildDir + '/facebook-www',
-      ReactVersion + '-www-classic-' + hash.digest('hex').slice(0, 8)
+      ReactVersion + '-www-classic-%FILEHASH%'
     );
   }
 
-  const reactNativeBuildDir = buildDir + '/react-native/implementations/';
-  if (fs.existsSync(reactNativeBuildDir)) {
-    const hash = crypto.createHash('sha1');
-    for (const fileName of fs.readdirSync(reactNativeBuildDir).sort()) {
-      const filePath = reactNativeBuildDir + fileName;
-      const stats = fs.statSync(filePath);
-      if (!stats.isDirectory()) {
-        hash.update(fs.readFileSync(filePath));
-      }
+  [
+    buildDir + '/react-native/implementations/',
+    buildDir + '/facebook-react-native/',
+  ].forEach(reactNativeBuildDir => {
+    if (fs.existsSync(reactNativeBuildDir)) {
+      updatePlaceholderReactVersionInCompiledArtifacts(
+        reactNativeBuildDir,
+        ReactVersion + '-' + canaryChannelLabel + '-%FILEHASH%'
+      );
     }
-    updatePlaceholderReactVersionInCompiledArtifacts(
-      reactNativeBuildDir,
-      ReactVersion +
-        '-' +
-        canaryChannelLabel +
-        '-' +
-        hash.digest('hex').slice(0, 8)
-    );
-  }
+  });
 
   // Update remaining placeholders with canary channel version
   updatePlaceholderReactVersionInCompiledArtifacts(
@@ -232,21 +222,31 @@ function processExperimental(buildDir, version) {
   }
 
   if (fs.existsSync(buildDir + '/facebook-www')) {
-    const hash = crypto.createHash('sha1');
     for (const fileName of fs.readdirSync(buildDir + '/facebook-www').sort()) {
       const filePath = buildDir + '/facebook-www/' + fileName;
       const stats = fs.statSync(filePath);
       if (!stats.isDirectory()) {
-        hash.update(fs.readFileSync(filePath));
         fs.renameSync(filePath, filePath.replace('.js', '.modern.js'));
       }
     }
     updatePlaceholderReactVersionInCompiledArtifacts(
       buildDir + '/facebook-www',
-      ReactVersion + '-www-modern-' + hash.digest('hex').slice(0, 8)
+      ReactVersion + '-www-modern-%FILEHASH%'
     );
   }
 
+  [
+    buildDir + '/react-native/implementations/',
+    buildDir + '/facebook-react-native/',
+  ].forEach(reactNativeBuildDir => {
+    if (fs.existsSync(reactNativeBuildDir)) {
+      updatePlaceholderReactVersionInCompiledArtifacts(
+        reactNativeBuildDir,
+        ReactVersion + '-' + canaryChannelLabel + '-%FILEHASH%'
+      );
+    }
+  });
+
   // Update remaining placeholders with canary channel version
   updatePlaceholderReactVersionInCompiledArtifacts(
     buildDir,
@@ -362,9 +362,11 @@ function updatePlaceholderReactVersionInCompiledArtifacts(
 
   for (const artifactFilename of artifactFilenames) {
     const originalText = fs.readFileSync(artifactFilename, 'utf8');
+    const fileHash = crypto.createHash('sha1');
+    fileHash.update(originalText);
     const replacedText = originalText.replaceAll(
       PLACEHOLDER_REACT_VERSION,
-      newVersion
+      newVersion.replace(/%FILEHASH%/g, fileHash.digest('hex').slice(0, 8))
     );
     fs.writeFileSync(artifactFilename, replacedText);
   }
diff --git a/scripts/rollup/forks.js b/scripts/rollup/forks.js
index eef64866e1932..f1ed750c22d60 100644
--- a/scripts/rollup/forks.js
+++ b/scripts/rollup/forks.js
@@ -232,36 +232,6 @@ const forks = Object.freeze({
     }
   },
 
-  // Different dialogs for caught errors.
-  './packages/react-reconciler/src/ReactFiberErrorDialog.js': (
-    bundleType,
-    entry
-  ) => {
-    switch (bundleType) {
-      case FB_WWW_DEV:
-      case FB_WWW_PROD:
-      case FB_WWW_PROFILING:
-        // Use the www fork which shows an error dialog.
-        return './packages/react-reconciler/src/forks/ReactFiberErrorDialog.www.js';
-      case RN_OSS_DEV:
-      case RN_OSS_PROD:
-      case RN_OSS_PROFILING:
-      case RN_FB_DEV:
-      case RN_FB_PROD:
-      case RN_FB_PROFILING:
-        switch (entry) {
-          case 'react-native-renderer':
-          case 'react-native-renderer/fabric':
-            // Use the RN fork which plays well with redbox.
-            return './packages/react-reconciler/src/forks/ReactFiberErrorDialog.native.js';
-          default:
-            return null;
-        }
-      default:
-        return null;
-    }
-  },
-
   './packages/react-reconciler/src/ReactFiberConfig.js': (
     bundleType,
     entry,
diff --git a/scripts/rollup/validate/eslintrc.fb.js b/scripts/rollup/validate/eslintrc.fb.js
index a3f58fc25d928..9f344c5aac3aa 100644
--- a/scripts/rollup/validate/eslintrc.fb.js
+++ b/scripts/rollup/validate/eslintrc.fb.js
@@ -40,6 +40,7 @@ module.exports = {
     // FB
     __DEV__: 'readonly',
     // Node.js Server Rendering
+    process: 'readonly',
     setImmediate: 'readonly',
     Buffer: 'readonly',
     // Trusted Types
diff --git a/scripts/rollup/validate/eslintrc.rn.js b/scripts/rollup/validate/eslintrc.rn.js
index acdb2bacd1a31..d18516f802304 100644
--- a/scripts/rollup/validate/eslintrc.rn.js
+++ b/scripts/rollup/validate/eslintrc.rn.js
@@ -53,6 +53,9 @@ module.exports = {
     reportError: 'readonly',
     AggregateError: 'readonly',
 
+    // Node Feature Detection
+    process: 'readonly',
+
     // Temp
     AsyncLocalStorage: 'readonly',
     async_hooks: 'readonly',
diff --git a/scripts/rollup/validate/eslintrc.umd.js b/scripts/rollup/validate/eslintrc.umd.js
index 800fd645ae614..6c497f08424ec 100644
--- a/scripts/rollup/validate/eslintrc.umd.js
+++ b/scripts/rollup/validate/eslintrc.umd.js
@@ -57,6 +57,9 @@ module.exports = {
     // Flight
     Promise: 'readonly',
 
+    // Node Feature Detection
+    process: 'readonly',
+
     // Temp
     AsyncLocalStorage: 'readonly',
     async_hooks: 'readonly',
diff --git a/yarn.lock b/yarn.lock
index b0b84223f75ec..71c9174c1c238 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -13017,14 +13017,6 @@ react-native-web@0.0.0-26873b469:
     prop-types "^15.6.0"
     react-timer-mixin "^0.13.4"
 
-react-shallow-renderer@^16.15.0:
-  version "16.15.0"
-  resolved "https://registry.yarnpkg.com/react-shallow-renderer/-/react-shallow-renderer-16.15.0.tgz#48fb2cf9b23d23cde96708fe5273a7d3446f4457"
-  integrity sha512-oScf2FqQ9LFVQgA73vr86xl2NaOIX73rh+YFqcOp68CWj56tSfgtGKrEbyhCj0rSijyG9M1CYprTh39fBi5hzA==
-  dependencies:
-    object-assign "^4.1.1"
-    react-is "^16.12.0 || ^17.0.0 || ^18.0.0"
-
 react-timer-mixin@^0.13.4:
   version "0.13.4"
   resolved "https://registry.yarnpkg.com/react-timer-mixin/-/react-timer-mixin-0.13.4.tgz#75a00c3c94c13abe29b43d63b4c65a88fc8264d3"
@@ -15791,9 +15783,9 @@ webpack-cli@^5.1.1:
     webpack-merge "^5.7.3"
 
 webpack-dev-middleware@^5.3.1:
-  version "5.3.3"
-  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-5.3.3.tgz#efae67c2793908e7311f1d9b06f2a08dcc97e51f"
-  integrity sha512-hj5CYrY0bZLB+eTO+x/j67Pkrquiy7kWepMHmUMoPsmcUaeEnQJqFzHJOyxgWlq746/wUuA64p9ta34Kyb01pA==
+  version "5.3.4"
+  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz#eb7b39281cbce10e104eb2b8bf2b63fce49a3517"
+  integrity sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==
   dependencies:
     colorette "^2.0.10"
     memfs "^3.4.3"