diff --git a/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js b/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
index bab0772ca57cd..d75afafcff8e1 100644
--- a/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
+++ b/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
@@ -1036,19 +1036,6 @@ export function bindInstance(
 
 export const supportsHydration = true;
 
-// With Resources, some HostComponent types will never be server rendered and need to be
-// inserted without breaking hydration
-export function isHydratableType(type: string, props: Props): boolean {
-  if (enableFloat) {
-    if (type === 'script') {
-      const {async, onLoad, onError} = (props: any);
-      return !(async && (onLoad || onError));
-    }
-    return true;
-  } else {
-    return true;
-  }
-}
 export function isHydratableText(text: string): boolean {
   return text !== '';
 }
@@ -1164,21 +1151,22 @@ export function canHydrateInstance(
           // if we learn it is problematic
           const srcAttr = element.getAttribute('src');
           if (
-            srcAttr &&
-            element.hasAttribute('async') &&
-            !element.hasAttribute('itemprop')
-          ) {
-            // This is an async script resource
-            break;
-          } else if (
             srcAttr !== (anyProps.src == null ? null : anyProps.src) ||
             element.getAttribute('type') !==
               (anyProps.type == null ? null : anyProps.type) ||
             element.getAttribute('crossorigin') !==
               (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)
           ) {
-            // This script is for a different src
-            break;
+            // This script is for a different src/type/crossOrigin. It may be a script resource
+            // or it may just be a mistmatch
+            if (
+              srcAttr &&
+              element.hasAttribute('async') &&
+              !element.hasAttribute('itemprop')
+            ) {
+              // This is an async script resource
+              break;
+            }
           }
           return element;
         }
diff --git a/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js b/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
index 9a05521eac3ed..788b201566aa4 100644
--- a/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
+++ b/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
@@ -2642,128 +2642,102 @@ function pushScript(
   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 ||
-      typeof props.src !== 'string' ||
-      !props.src
+      props.itemProp != null
     ) {
-      // This script will not be a resource nor can it be preloaded, we bailout early
-      // and emit it in place.
+      // 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('script', src);
-    if (props.async !== true || props.onLoad || props.onError) {
-      // we don't want to preload nomodule scripts
-      if (props.noModule !== true) {
-        // We can't resourcify scripts with load listeners. To avoid ambiguity with
-        // other Resourcified async scripts on the server we omit them from the server
-        // stream and expect them to be inserted during hydration on the client.
-        // We can still preload them however so the client can start fetching the script
-        // as soon as possible
-        let resource = resources.preloadsMap.get(key);
-        if (!resource) {
-          resource = {
-            type: 'preload',
-            chunks: [],
-            state: NoState,
-            props: preloadAsScriptPropsFromProps(props.src, props),
-          };
-          resources.preloadsMap.set(key, resource);
-          if (__DEV__) {
-            markAsImplicitResourceDEV(resource, props, resource.props);
+    // We can make this <script> into a ScriptResource
+    let resource = resources.scriptsMap.get(key);
+    if (__DEV__) {
+      const devResource = getAsResourceDEV(resource);
+      if (devResource) {
+        switch (devResource.__provenance) {
+          case 'rendered': {
+            const differenceDescription = describeDifferencesForScripts(
+              // Diff the props from the JSX element, not the derived resource props
+              props,
+              devResource.__originalProps,
+            );
+            if (differenceDescription) {
+              console.error(
+                'React encountered a <script async={true} src="%s" .../> that has props that conflict' +
+                  ' with another hoistable script with the same `src`. When rendering hoistable scripts (async scripts without any loading handlers)' +
+                  ' the props from the first encountered instance will be used and props from later instances will be ignored.' +
+                  ' Update the props on both <script async={true} .../> instance so they agree.%s',
+                src,
+                differenceDescription,
+              );
+            }
+            break;
           }
-          resources.usedScripts.add(resource);
-          pushLinkImpl(resource.chunks, resource.props);
-        }
-      }
-
-      if (props.async !== true) {
-        // This is not an async script, we can preloaded it but it still needs to
-        // be emitted in place since it needs to hydrate on the client
-        pushScriptImpl(target, props);
-        return null;
-      }
-    } else {
-      // We can make this <script> into a ScriptResource
-      let resource = resources.scriptsMap.get(key);
-      if (__DEV__) {
-        const devResource = getAsResourceDEV(resource);
-        if (devResource) {
-          switch (devResource.__provenance) {
-            case 'rendered': {
-              const differenceDescription = describeDifferencesForScripts(
+          case 'preinit': {
+            const differenceDescription =
+              describeDifferencesForScriptOverPreinit(
                 // Diff the props from the JSX element, not the derived resource props
                 props,
-                devResource.__originalProps,
+                devResource.__propsEquivalent,
+              );
+            if (differenceDescription) {
+              console.error(
+                'React encountered a <script async={true} src="%s" .../> with props that conflict' +
+                  ' with the options provided to `ReactDOM.preinit("%s", { as: "script", ... })`. React will use the first props or preinitialization' +
+                  ' options encountered when rendering a hoistable script with a particular `src` and will ignore any newer props or' +
+                  ' options. The first instance of this script resource was created using the `ReactDOM.preinit()` function.' +
+                  ' Please note, `ReactDOM.preinit()` is modeled off of module import assertions capabilities and does not support' +
+                  ' arbitrary props. If you need to have props not included with the preinit options you will need to rely on rendering' +
+                  ' <script> tags only.%s',
+                src,
+                src,
+                differenceDescription,
               );
-              if (differenceDescription) {
-                console.error(
-                  'React encountered a <script async={true} src="%s" .../> that has props that conflict' +
-                    ' with another hoistable script with the same `src`. When rendering hoistable scripts (async scripts without any loading handlers)' +
-                    ' the props from the first encountered instance will be used and props from later instances will be ignored.' +
-                    ' Update the props on both <script async={true} .../> instance so they agree.%s',
-                  src,
-                  differenceDescription,
-                );
-              }
-              break;
-            }
-            case 'preinit': {
-              const differenceDescription =
-                describeDifferencesForScriptOverPreinit(
-                  // Diff the props from the JSX element, not the derived resource props
-                  props,
-                  devResource.__propsEquivalent,
-                );
-              if (differenceDescription) {
-                console.error(
-                  'React encountered a <script async={true} src="%s" .../> with props that conflict' +
-                    ' with the options provided to `ReactDOM.preinit("%s", { as: "script", ... })`. React will use the first props or preinitialization' +
-                    ' options encountered when rendering a hoistable script with a particular `src` and will ignore any newer props or' +
-                    ' options. The first instance of this script resource was created using the `ReactDOM.preinit()` function.' +
-                    ' Please note, `ReactDOM.preinit()` is modeled off of module import assertions capabilities and does not support' +
-                    ' arbitrary props. If you need to have props not included with the preinit options you will need to rely on rendering' +
-                    ' <script> tags only.%s',
-                  src,
-                  src,
-                  differenceDescription,
-                );
-              }
-              break;
             }
+            break;
           }
         }
       }
-      if (!resource) {
-        resource = {
-          type: 'script',
-          chunks: [],
-          state: NoState,
-          props: null,
-        };
-        resources.scriptsMap.set(key, resource);
-        if (__DEV__) {
-          markAsRenderedResourceDEV(resource, props);
-        }
-        // Add to the script flushing queue
-        resources.scripts.add(resource);
-
-        let scriptProps = props;
-        const preloadResource = resources.preloadsMap.get(key);
-        if (preloadResource) {
-          // If we already had a preload we don't want that resource to flush directly.
-          // We let the newly created resource govern flushing.
-          preloadResource.state |= Blocked;
-          scriptProps = {...props};
-          adoptPreloadPropsForScriptProps(scriptProps, preloadResource.props);
-        }
-        // encode the tag as Chunks
-        pushScriptImpl(resource.chunks, scriptProps);
+    }
+    if (!resource) {
+      resource = {
+        type: 'script',
+        chunks: [],
+        state: NoState,
+        props: null,
+      };
+      resources.scriptsMap.set(key, resource);
+      if (__DEV__) {
+        markAsRenderedResourceDEV(resource, props);
+      }
+      // Add to the script flushing queue
+      resources.scripts.add(resource);
+
+      let scriptProps = props;
+      const preloadResource = resources.preloadsMap.get(key);
+      if (preloadResource) {
+        // If we already had a preload we don't want that resource to flush directly.
+        // We let the newly created resource govern flushing.
+        preloadResource.state |= Blocked;
+        scriptProps = {...props};
+        adoptPreloadPropsForScriptProps(scriptProps, preloadResource.props);
       }
+      // encode the tag as Chunks
+      pushScriptImpl(resource.chunks, scriptProps);
     }
 
     if (textEmbedded) {
@@ -4239,9 +4213,6 @@ export function writePreamble(
   resources.scripts.forEach(flushResourceInPreamble, destination);
   resources.scripts.clear();
 
-  resources.usedScripts.forEach(flushResourceInPreamble, destination);
-  resources.usedScripts.clear();
-
   resources.explicitStylesheetPreloads.forEach(
     flushResourceInPreamble,
     destination,
@@ -4319,9 +4290,6 @@ export function writeHoistables(
   resources.scripts.forEach(flushResourceLate, destination);
   resources.scripts.clear();
 
-  resources.usedScripts.forEach(flushResourceLate, destination);
-  resources.usedScripts.clear();
-
   resources.explicitStylesheetPreloads.forEach(flushResourceLate, destination);
   resources.explicitStylesheetPreloads.clear();
 
@@ -4873,7 +4841,6 @@ export type Resources = {
   precedences: Map<string, Set<StyleResource>>,
   stylePrecedences: Map<string, StyleTagResource>,
   scripts: Set<ScriptResource>,
-  usedScripts: Set<PreloadResource>,
   explicitStylesheetPreloads: Set<PreloadResource>,
   // explicitImagePreloads: Set<PreloadResource>,
   explicitScriptPreloads: Set<PreloadResource>,
@@ -4900,7 +4867,6 @@ export function createResources(): Resources {
     precedences: new Map(),
     stylePrecedences: new Map(),
     scripts: new Set(),
-    usedScripts: new Set(),
     explicitStylesheetPreloads: new Set(),
     // explicitImagePreloads: new Set(),
     explicitScriptPreloads: new Set(),
@@ -5563,19 +5529,6 @@ function preloadAsStylePropsFromProps(href: string, props: any): PreloadProps {
   };
 }
 
-function preloadAsScriptPropsFromProps(href: string, props: any): PreloadProps {
-  return {
-    rel: 'preload',
-    as: 'script',
-    href,
-    crossOrigin: props.crossOrigin,
-    fetchPriority: props.fetchPriority,
-    integrity: props.integrity,
-    nonce: props.nonce,
-    referrerPolicy: props.referrerPolicy,
-  };
-}
-
 function stylesheetPropsFromPreinitOptions(
   href: string,
   precedence: string,
@@ -5694,29 +5647,6 @@ function markAsImperativeResourceDEV(
   }
 }
 
-function markAsImplicitResourceDEV(
-  resource: Resource,
-  underlyingProps: any,
-  impliedProps: any,
-): void {
-  if (__DEV__) {
-    const devResource: ImplicitResourceDEV = (resource: any);
-    if (typeof devResource.__provenance === 'string') {
-      console.error(
-        'Resource already marked for DEV type. This is a bug in React.',
-      );
-    }
-    devResource.__provenance = 'implicit';
-    devResource.__underlyingProps = underlyingProps;
-    devResource.__impliedProps = impliedProps;
-  } else {
-    // eslint-disable-next-line react-internal/prod-error-codes
-    throw new Error(
-      'markAsImplicitResourceDEV was included in a production build. This is a bug in React.',
-    );
-  }
-}
-
 function getAsResourceDEV(
   resource: null | void | Resource,
 ): null | ResourceDEV {
diff --git a/packages/react-dom/src/__tests__/ReactDOMFloat-test.js b/packages/react-dom/src/__tests__/ReactDOMFloat-test.js
index c36ee84f21622..92e2f2eef85fa 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFloat-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFloat-test.js
@@ -456,12 +456,12 @@ describe('ReactDOMFloat', () => {
     expect(getMeaningfulChildren(document)).toEqual(
       <html>
         <head>
-          <link rel="preload" href="foo" as="script" />
           <meta property="foo" content="bar" />
           <title>foo</title>
           <link rel="foo" href="bar" />
           <noscript>&lt;link rel="icon" href="icon"&gt;</noscript>
           <base target="foo" href="bar" />
+          <script async="" src="foo" />
         </head>
         <body>foo</body>
       </html>,
@@ -487,7 +487,6 @@ describe('ReactDOMFloat', () => {
     expect(getMeaningfulChildren(document)).toEqual(
       <html>
         <head>
-          <link rel="preload" href="foo" as="script" />
           <meta property="foo" content="bar" />
           <title>foo</title>
           <link rel="foo" href="bar" />
@@ -2668,8 +2667,6 @@ body {
           {/* Hoisted Resources and elements */}
           <link rel="stylesheet" href="stylesheet" data-precedence="default" />
           <script async="" src="rendered" />
-          <link rel="preload" as="script" href="sync rendered" />
-          <link rel="preload" as="script" href="async rendered" />
           <link rel="foo" href="foo" />
           <meta name="foo" content="foo" />
           <title>title</title>
@@ -2678,6 +2675,7 @@ body {
           <link rel="stylesheet" href="stylesheet" />
           <script src="sync rendered" data-meaningful="" />
           <style>{'body { background-color: red; }'}</style>
+          <script src="async rendered" async="" />
           <noscript>&lt;meta name="noscript" content="noscript"&gt;</noscript>
           <link rel="foo" href="foo" />
         </head>
@@ -2734,8 +2732,6 @@ body {
           <style>{'body { background-color: blue; }'}</style>
           <link rel="stylesheet" href="stylesheet" data-precedence="default" />
           <script async="" src="rendered" />
-          <link rel="preload" as="script" href="sync rendered" />
-          <link rel="preload" as="script" href="async rendered" />
           <link rel="foo" href="foo" />
           <meta name="foo" content="foo" />
           <title>title</title>
@@ -2780,8 +2776,6 @@ body {
           <style>{'body { background-color: blue; }'}</style>
           <link rel="stylesheet" href="stylesheet" data-precedence="default" />
           <script async="" src="rendered" />
-          <link rel="preload" as="script" href="sync rendered" />
-          <link rel="preload" as="script" href="async rendered" />
           <style>{'body { background-color: blue; }'}</style>
           <div />
           <script async="" src="injected" />
@@ -6061,6 +6055,7 @@ background-color: green;
               <script src="foo" async={true} />
               <script src="bar" async={true} onLoad={() => {}} />
               <script src="baz" data-meaningful="" />
+              <script src="qux" defer={true} data-meaningful="" />
               hello world
             </body>
           </html>,
@@ -6076,17 +6071,17 @@ background-color: green;
         <html>
           <head>
             <script src="foo" async="" />
-            <link rel="preload" href="bar" as="script" />
-            <link rel="preload" href="baz" as="script" />
           </head>
           <body>
+            <script src="bar" async="" />
             <script src="baz" data-meaningful="" />
+            <script src="qux" defer="" data-meaningful="" />
             hello world
           </body>
         </html>,
       );
 
-      ReactDOMClient.hydrateRoot(
+      const root = ReactDOMClient.hydrateRoot(
         document,
         <html>
           <head />
@@ -6094,6 +6089,7 @@ background-color: green;
             <script src="foo" async={true} />
             <script src="bar" async={true} onLoad={() => {}} />
             <script src="baz" data-meaningful="" />
+            <script src="qux" defer={true} data-meaningful="" />
             hello world
           </body>
         </html>,
@@ -6105,53 +6101,26 @@ background-color: green;
         <html>
           <head>
             <script src="foo" async="" />
-            <link rel="preload" href="bar" as="script" />
-            <link rel="preload" href="baz" as="script" />
           </head>
           <body>
             <script src="bar" async="" />
             <script src="baz" data-meaningful="" />
+            <script src="qux" defer="" data-meaningful="" />
             hello world
           </body>
         </html>,
       );
-    });
-
-    // @gate enableFloat
-    it('respects attributes defined on the script element when preloading scripts during server rendering', async () => {
-      await act(() => {
-        const {pipe} = renderToPipeableStream(
-          <html>
-            <head />
-            <body>
-              <script src="foo" fetchPriority="high" nonce="1234" />
-              <script src="bar" fetchPriority="low" nonce="1234" />
-              hello world
-            </body>
-          </html>,
-        );
-        pipe(writable);
-      });
 
+      root.unmount();
+      // When we unmount we expect to retain singletons and any content that is not cleared within them.
+      // The foo script is a resource so it sticks around. The other scripts are regular HostComponents
+      // so they unmount and are removed from the DOM.
       expect(getMeaningfulChildren(document)).toEqual(
         <html>
           <head>
-            <link
-              rel="preload"
-              href="foo"
-              fetchpriority="high"
-              nonce="1234"
-              as="script"
-            />
-            <link
-              rel="preload"
-              href="bar"
-              fetchpriority="low"
-              nonce="1234"
-              as="script"
-            />
+            <script src="foo" async="" />
           </head>
-          <body>hello world</body>
+          <body />
         </html>,
       );
     });
diff --git a/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js b/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js
index 68ad81c2c7578..f467cbb86b733 100644
--- a/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js
+++ b/packages/react-reconciler/src/ReactFiberConfigWithNoHydration.js
@@ -21,7 +21,6 @@ function shim(...args: any): empty {
 // Hydration (when unsupported)
 export type SuspenseInstance = mixed;
 export const supportsHydration = false;
-export const isHydratableType = shim;
 export const isHydratableText = shim;
 export const isSuspenseInstancePending = shim;
 export const isSuspenseInstanceFallback = shim;
diff --git a/packages/react-reconciler/src/ReactFiberHydrationContext.js b/packages/react-reconciler/src/ReactFiberHydrationContext.js
index 6fd9226466561..3453fcb451631 100644
--- a/packages/react-reconciler/src/ReactFiberHydrationContext.js
+++ b/packages/react-reconciler/src/ReactFiberHydrationContext.js
@@ -37,7 +37,6 @@ import {
 } from './ReactFiberFlags';
 import {
   enableHostSingletons,
-  enableFloat,
   enableClientRenderFallbackOnTextMismatch,
   diffInCommitPhase,
 } from 'shared/ReactFeatureFlags';
@@ -77,7 +76,6 @@ import {
   canHydrateInstance,
   canHydrateTextInstance,
   canHydrateSuspenseInstance,
-  isHydratableType,
   isHydratableText,
 } from './ReactFiberConfig';
 import {OffscreenLane} from './ReactFiberLane';
@@ -450,15 +448,6 @@ function tryToClaimNextHydratableInstance(fiber: Fiber): void {
   if (!isHydrating) {
     return;
   }
-  if (enableFloat) {
-    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
-      // This fiber never hydrates from the DOM and always does an insert
-      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      return;
-    }
-  }
   const initialInstance = nextHydratableInstance;
   const nextInstance = nextHydratableInstance;
   if (!nextInstance) {
diff --git a/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js b/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js
index b73edb87a0042..2fa2f733ead75 100644
--- a/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js
+++ b/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js
@@ -135,7 +135,6 @@ export const cloneHiddenTextInstance = $$$config.cloneHiddenTextInstance;
 //     Hydration
 //     (optional)
 // -------------------
-export const isHydratableType = $$$config.isHydratableType;
 export const isHydratableText = $$$config.isHydratableText;
 export const isSuspenseInstancePending = $$$config.isSuspenseInstancePending;
 export const isSuspenseInstanceFallback = $$$config.isSuspenseInstanceFallback;