diff --git a/.flowconfig b/.flowconfig
index d6100d13..1d2651bc 100644
--- a/.flowconfig
+++ b/.flowconfig
@@ -1,5 +1,5 @@
 [version]
-0.270.0
+0.307.1
 
 [ignore]
 .*/malformed_package_json/.*
@@ -7,6 +7,9 @@
 
 [include]
 
+[declarations]
+.*/node_modules/.*
+
 [options]
 casting_syntax=as
 component_syntax=true
@@ -14,8 +17,17 @@ module.name_mapper='^react-strict-dom$' -> '<PROJECT_ROOT>/packages/react-strict
 module.system.node.resolve_dirname=flow_modules
 module.system.node.resolve_dirname=node_modules
 react.runtime=automatic
-suppress_type=$FlowIssue
-suppress_type=$FlowFixMe
+
+experimental.ts_utility_syntax=true
+experimental.deprecated_utilities='$ReadOnlyArray' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='$NonMaybeType' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='$ReadOnly' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='mixed' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='$ReadOnlyMap' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='$ReadOnlySet' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='$Keys' -> '<PROJECT_ROOT>/'
+experimental.deprecated_utilities='$Values' -> '<PROJECT_ROOT>/'
+experimental.deprecated_colon_extends=<PROJECT_ROOT>/
 
 [strict]
 nonstrict-import
diff --git a/apps/platform-tests/src/components/App.js b/apps/platform-tests/src/components/App.js
index 605380eb..4e4e6b38 100644
--- a/apps/platform-tests/src/components/App.js
+++ b/apps/platform-tests/src/components/App.js
@@ -12,7 +12,7 @@ import { ScrollView } from 'react-native';
 import { css, html } from 'react-strict-dom';
 import { tokens, themeColors, systemColors } from './tokens.css.js';
 
-type ExampleBlockProps = $ReadOnly<{
+type ExampleBlockProps = Readonly<{
   title: string,
   children: React.Node
 }>;
@@ -71,24 +71,30 @@ const themedStyles = css.create({
 
 function ThemeExample() {
   return (
+    // $FlowFixMe[incompatible-type]
     <html.div style={themedStyles.container}>
       {/* default theme */}
+      {/* $FlowFixMe[incompatible-type] */}
       <html.div style={themedStyles.square} />
       {/* redblue theme */}
       <html.div style={redBlueTheme}>
+        {/* $FlowFixMe[incompatible-type] */}
         <html.div style={themedStyles.square} />
       </html.div>
       {/* purpleyellow theme */}
       <html.div style={purpleYellowTheme}>
+        {/* $FlowFixMe[incompatible-type] */}
         <html.div style={themedStyles.square} />
       </html.div>
       {/* greenpink theme */}
       <html.div style={greenPinkTheme}>
+        {/* $FlowFixMe[incompatible-type] */}
         <html.div style={themedStyles.square} />
       </html.div>
       {/* nested theme */}
       <html.div style={redBlueTheme}>
         <html.div style={greenPinkTheme}>
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={themedStyles.square} />
         </html.div>
       </html.div>
@@ -152,6 +158,7 @@ function Shell(): React.MixedElement {
           <html.div>dfadsafdsfadsf inside div (kind of) works</html.div>
           <html.span>
             span inside div inside span...
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={styles.textAncestorTest}>
               <html.span>works</html.span>
             </html.div>
@@ -212,6 +219,7 @@ function Shell(): React.MixedElement {
               console.log(e.type, e);
             }}
             src="http://placehold.jp/150x150.png"
+            // $FlowFixMe[incompatible-type]
             style={styles.objContain}
             width={150}
           />
@@ -290,8 +298,11 @@ function Shell(): React.MixedElement {
 
           {/* flex row undoes block layout emulation and correct flex child layout */}
           <html.p>display:flex defaults and children</html.p>
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={styles.row}>
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={[styles.square, styles.w1000]} />
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={[styles.square, styles.blueSquare]}>
               <html.div style={styles.whiteBox}>
                 <html.p>Back to block</html.p>
@@ -303,6 +314,7 @@ function Shell(): React.MixedElement {
 
           <html.p>display:block resets flex properties</html.p>
           {/* display block undoes row layout and emulates block again */}
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={[styles.row, styles.blockW300]}>
             <html.div style={styles.square} />
             <html.div style={[styles.square, styles.bgBlue]} />
@@ -328,19 +340,26 @@ function Shell(): React.MixedElement {
         {/* logical styles emulation */}
         <ExampleBlock title="CSS Logical">
           <html.div>
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={styles.logicalPadding} />
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={styles.logicalMargin} />
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={styles.logicalBorder} />
           </html.div>
         </ExampleBlock>
 
         {/* CSS positioning (static by default) */}
         <ExampleBlock title="CSS Position">
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={[styles.p50, styles.relative]}>
             <html.div style={styles.p50}>
+              {/* $FlowFixMe[incompatible-type] */}
               <html.div style={[styles.square, styles.absTopLeft]} />
             </html.div>
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={[styles.relative, styles.p50]}>
+              {/* $FlowFixMe[incompatible-type] */}
               <html.div style={[styles.square, styles.absTopLeft]} />
             </html.div>
           </html.div>
@@ -348,11 +367,13 @@ function Shell(): React.MixedElement {
 
         {/* CSS text */}
         <ExampleBlock title="CSS Text styles">
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={styles.lineHeightUnitless}>
             <html.span style={styles.text}>
               <html.span style={styles.text}>test</html.span> (unitless)
             </html.span>
           </html.div>
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={styles.lineHeightEm}>
             <html.span style={styles.text}>test (em)</html.span>
           </html.div>
@@ -462,6 +483,7 @@ function Shell(): React.MixedElement {
           </html.button>
           <html.p>Transform + Opacity</html.p>
           <html.div
+            // $FlowFixMe[incompatible-type]
             style={[
               styles.square,
               styles.transitionAll,
@@ -478,9 +500,13 @@ function Shell(): React.MixedElement {
 
         {/* visibility */}
         <ExampleBlock title="CSS Visibility">
+          {/* $FlowFixMe[incompatible-type] */}
           <html.div style={styles.flex}>
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={[styles.square, styles.visibilityCollapse]} />
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={[styles.square, styles.visibilityHidden]} />
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={[styles.square, styles.visibilityVisible]} />
           </html.div>
         </ExampleBlock>
@@ -491,7 +517,7 @@ function Shell(): React.MixedElement {
           <html.div style={styles.square} />
           <html.input
             placeholder="input type:text"
-            // $FlowFixMe
+            // $FlowFixMe[incompatible-type]
             style={styles.input}
             type="text"
           />
@@ -511,7 +537,7 @@ function Shell(): React.MixedElement {
             <html.div style={styles.square} />
             <html.input
               placeholder="input type:text"
-              // $FlowFixMe
+              // $FlowFixMe[incompatible-type]
               style={styles.input}
               type="text"
             />
@@ -523,7 +549,7 @@ function Shell(): React.MixedElement {
               <html.div style={styles.square} />
               <html.input
                 placeholder="input type:text"
-                // $FlowFixMe
+                // $FlowFixMe[incompatible-type]
                 style={styles.input}
                 type="text"
               />
@@ -535,6 +561,7 @@ function Shell(): React.MixedElement {
 
         {/* hover */}
         <ExampleBlock title="CSS :hover, :focus, :active">
+          {/* $FlowFixMe[incompatible-type] */}
           <html.textarea style={styles.pseudoStates} />
         </ExampleBlock>
 
@@ -581,7 +608,9 @@ function Shell(): React.MixedElement {
             style={[styles.h100, styles.dynamicBg(clickData.color)]}
           >
             <html.span style={styles.bgWhite}>{clickData.text}</html.span>
+            {/* $FlowFixMe[incompatible-type] */}
             <html.div style={styles.flex}>
+              {/* $FlowFixMe[incompatible-type] */}
               <html.div style={[styles.flex, styles.flexGrow]}>
                 <html.div>
                   <html.span>
@@ -604,6 +633,7 @@ function Shell(): React.MixedElement {
                   </html.span>
                 </html.div>
               </html.div>
+              {/* $FlowFixMe[incompatible-type] */}
               <html.div style={[styles.flex, styles.flexGrow]}>
                 <html.div>
                   <html.span>button: {clickEventData.button}</html.span>
@@ -624,6 +654,7 @@ function Shell(): React.MixedElement {
               setImageLoadText(`${e.type}: loaded`);
             }}
             src="http://placehold.jp/150x150.png"
+            // $FlowFixMe[incompatible-type]
             style={styles.objContain}
             width={150}
           />
@@ -634,6 +665,7 @@ function Shell(): React.MixedElement {
               setImageErrorText(`${e.type}: errored`);
             }}
             src="http://error"
+            // $FlowFixMe[incompatible-type]
             style={styles.objContain}
             width={150}
           />
diff --git a/apps/platform-tests/src/components/tokens.css.js b/apps/platform-tests/src/components/tokens.css.js
index 3e5d7820..7c198dd7 100644
--- a/apps/platform-tests/src/components/tokens.css.js
+++ b/apps/platform-tests/src/components/tokens.css.js
@@ -12,7 +12,7 @@ import type { StyleVars } from 'react-strict-dom';
 import { css } from 'react-strict-dom';
 
 export const tokens: StyleVars<
-  $ReadOnly<{
+  Readonly<{
     squareColor: string,
     textColor: string,
     inputColor: string,
@@ -29,7 +29,7 @@ export const tokens: StyleVars<
 });
 
 export const themeColors: StyleVars<
-  $ReadOnly<{
+  Readonly<{
     primary100: string,
     primary200: string
   }>
@@ -39,7 +39,7 @@ export const themeColors: StyleVars<
 });
 
 export const systemColors: StyleVars<
-  $ReadOnly<{
+  Readonly<{
     squareColor: string,
     outlineColor: string
   }>
diff --git a/flow-typed/environments/bom.js b/flow-typed/environments/bom.js
index 2c7c3cb0..a575c445 100644
--- a/flow-typed/environments/bom.js
+++ b/flow-typed/environments/bom.js
@@ -18,7 +18,7 @@ declare class Screen {
     lock(): Promise<void>;
     unlock(): void;
     angle: number;
-    onchange: () => mixed;
+    onchange: () => unknown;
     type: 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
     ...
   };
@@ -26,7 +26,7 @@ declare class Screen {
   mozLockOrientation?: (orientation: string | Array<string>) => boolean;
   mozUnlockOrientation?: () => void;
   mozOrientation?: string;
-  onmozorientationchange?: (...args: any[]) => mixed;
+  onmozorientationchange?: (...args: any[]) => unknown;
 }
 
 declare var screen: Screen;
@@ -34,7 +34,7 @@ declare var screen: Screen;
 declare interface Crypto {
   // Not using $TypedArray as that would include Float32Array and Float64Array which are not accepted
   getRandomValues: <
-    T: Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array
+    T extends Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array
   >(typedArray: T) => T;
   randomUUID: () => string;
 }
@@ -84,10 +84,10 @@ type BatteryManager = {
   +chargingTime: number,
   +dischargingTime: number,
   +level: number,
-  onchargingchange: ?((event: any) => mixed),
-  onchargingtimechange: ?((event: any) => mixed),
-  ondischargingtimechange: ?((event: any) => mixed),
-  onlevelchange: ?((event: any) => mixed),
+  onchargingchange: ?((event: any) => unknown),
+  onchargingtimechange: ?((event: any) => unknown),
+  ondischargingtimechange: ?((event: any) => unknown),
+  onlevelchange: ?((event: any) => unknown),
   ...
 }
 
@@ -159,7 +159,7 @@ type FileSystemHandlePermissionDescriptor = {|
 |}
 
 declare class PermissionStatus extends EventTarget {
-  onchange: ?((event: any) => mixed);
+  onchange: ?((event: any) => unknown);
   +state: PermissionState;
 }
 
@@ -212,13 +212,13 @@ declare class MIDIPort extends EventTarget {
   +version?: string;
   +state: MIDIPortDeviceState;
   +connection: MIDIPortConnectionState;
-  onstatechange: ?((ev: MIDIConnectionEvent) => mixed);
+  onstatechange: ?((ev: MIDIConnectionEvent) => unknown);
   open(): Promise<MIDIPort>;
   close(): Promise<MIDIPort>;
 }
 
 declare class MIDIInput extends MIDIPort {
-  onmidimessage: ?((ev: MIDIMessageEvent) => mixed);
+  onmidimessage: ?((ev: MIDIMessageEvent) => unknown);
 }
 
 declare class MIDIOutput extends MIDIPort {
@@ -234,7 +234,7 @@ declare class MIDIAccess extends EventTarget {
   +inputs: MIDIInputMap;
   +outputs: MIDIOutputMap;
   +sysexEnabled: boolean;
-  onstatechange: ?((ev: MIDIConnectionEvent) => mixed);
+  onstatechange: ?((ev: MIDIConnectionEvent) => unknown);
 }
 
 declare class NavigatorID {
@@ -248,7 +248,7 @@ declare class NavigatorID {
 
 declare class NavigatorLanguage {
     +language: string;
-    +languages: $ReadOnlyArray<string>;
+    +languages: ReadonlyArray<string>;
 }
 
 declare class NavigatorContentUtils {
@@ -360,7 +360,7 @@ declare class Navigator mixins
 declare class Clipboard extends EventTarget {
     read(): Promise<DataTransfer>;
     readText(): Promise<string>;
-    write(data: $ReadOnlyArray<ClipboardItem>): Promise<void>;
+    write(data: ReadonlyArray<ClipboardItem>): Promise<void>;
     writeText(data: string): Promise<void>;
 }
 
@@ -504,7 +504,7 @@ declare class TaskAttributionTiming extends PerformanceEntry {
 
 // https://w3c.github.io/longtasks/#sec-PerformanceLongTaskTiming
 declare class PerformanceLongTaskTiming extends PerformanceEntry {
-  attribution: $ReadOnlyArray<TaskAttributionTiming>;
+  attribution: ReadonlyArray<TaskAttributionTiming>;
 }
 
 // https://www.w3.org/TR/navigation-timing-2/
@@ -523,12 +523,12 @@ declare class PerformanceNavigationTiming extends PerformanceResourceTiming {
 
 // https://www.w3.org/TR/user-timing/#extensions-performance-interface
 declare type PerformanceMarkOptions = {|
-  detail?: mixed,
+  detail?: unknown,
   startTime?: number,
 |};
 
 declare type PerformanceMeasureOptions = {|
-  detail?: mixed,
+  detail?: unknown,
   start?: number | string,
   end?: number | string,
   duration?: number,
@@ -560,7 +560,7 @@ declare class Performance {
     navigation: PerformanceNavigation;
     timing: PerformanceTiming;
 
-    onresourcetimingbufferfull: (ev: any) => mixed;
+    onresourcetimingbufferfull: (ev: any) => unknown;
     clearMarks(name?: string): void;
     clearMeasures(name?: string): void;
     clearResourceTimings(): void;
@@ -592,7 +592,7 @@ type PerformanceObserverInit = {
 }
 
 declare class PerformanceObserver {
-  constructor(callback: (entries: PerformanceObserverEntryList, observer: PerformanceObserver) => mixed): void;
+  constructor(callback: (entries: PerformanceObserverEntryList, observer: PerformanceObserver) => unknown): void;
 
   observe(options: ?PerformanceObserverInit): void;
   disconnect(): void;
@@ -677,7 +677,7 @@ declare type IntersectionObserverEntry = {
 declare type IntersectionObserverCallback = (
     entries: Array<IntersectionObserverEntry>,
     observer: IntersectionObserver,
-) => mixed;
+) => unknown;
 
 declare type IntersectionObserverOptions = {
   root?: Node | null,
@@ -721,19 +721,19 @@ declare interface ResizeObserverEntry {
    * An array containing the Element's border box size when
    * ResizeObserverCallback is invoked.
    */
-  +borderBoxSize: $ReadOnlyArray<ResizeObserverSize>;
+  +borderBoxSize: ReadonlyArray<ResizeObserverSize>;
   /**
    * An array containing the Element's content rect size when
    * ResizeObserverCallback is invoked.
    */
-  +contentBoxSize: $ReadOnlyArray<ResizeObserverSize>;
+  +contentBoxSize: ReadonlyArray<ResizeObserverSize>;
   /**
    * An array containing the Element's content rect size in integral device
    * pixels when ResizeObserverCallback is invoked.
    *
    * Not implemented in Firefox or Safari as of July 2021
    */
-  +devicePixelContentBoxSize?: $ReadOnlyArray<ResizeObserverSize> | void;
+  +devicePixelContentBoxSize?: ReadonlyArray<ResizeObserverSize> | void;
 }
 
 /**
@@ -755,7 +755,7 @@ declare type ResizeObserverOptions = {
  * The ResizeObserver interface is used to observe changes to Element's size.
  */
 declare class ResizeObserver {
-  constructor(callback: (entries: ResizeObserverEntry[], observer: ResizeObserver) => mixed): void;
+  constructor(callback: (entries: ResizeObserverEntry[], observer: ResizeObserver) => unknown): void;
   /**
    * Adds target to the list of observed elements.
    */
@@ -783,10 +783,10 @@ declare class WebSocket extends EventTarget {
     readyState: number;
     bufferedAmount: number;
     extensions: string;
-    onopen: (ev: any) => mixed;
-    onmessage: (ev: MessageEvent) => mixed;
-    onclose: (ev: CloseEvent) => mixed;
-    onerror: (ev: any) => mixed;
+    onopen: (ev: any) => unknown;
+    onmessage: (ev: MessageEvent) => unknown;
+    onclose: (ev: CloseEvent) => unknown;
+    onerror: (ev: any) => unknown;
     binaryType: 'blob' | 'arraybuffer';
     url: string;
     close(code?: number, reason?: string): void;
@@ -809,9 +809,9 @@ type WorkerOptions = {
 
 declare class Worker extends EventTarget {
     constructor(stringUrl: string | TrustedScriptURL, workerOptions?: WorkerOptions): void;
-    onerror: null | (ev: any) => mixed;
-    onmessage: null | (ev: MessageEvent) => mixed;
-    onmessageerror: null | (ev: MessageEvent) => mixed;
+    onerror: null | (ev: any) => unknown;
+    onmessage: null | (ev: MessageEvent) => unknown;
+    onmessageerror: null | (ev: MessageEvent) => unknown;
     postMessage(message: any, ports?: any): void;
     terminate(): void;
 }
@@ -820,34 +820,35 @@ declare class SharedWorker extends EventTarget {
     constructor(stringUrl: string | TrustedScriptURL, name?: string): void;
     constructor(stringUrl: string | TrustedScriptURL, workerOptions?: WorkerOptions): void;
     port: MessagePort;
-    onerror: (ev: any) => mixed;
+    onerror: (ev: any) => unknown;
 }
 
 declare function importScripts(...urls: Array<string | TrustedScriptURL>): void;
 
 declare class WorkerGlobalScope extends EventTarget {
+    // $FlowFixMe[incompatible-variance]
     self: this;
     location: WorkerLocation;
     navigator: WorkerNavigator;
     close(): void;
     importScripts(...urls: Array<string | TrustedScriptURL>): void;
-    onerror: (ev: any) => mixed;
-    onlanguagechange: (ev: any) => mixed;
-    onoffline: (ev: any) => mixed;
-    ononline: (ev: any) => mixed;
-    onrejectionhandled: (ev: PromiseRejectionEvent) => mixed;
-    onunhandledrejection: (ev: PromiseRejectionEvent) => mixed;
+    onerror: (ev: any) => unknown;
+    onlanguagechange: (ev: any) => unknown;
+    onoffline: (ev: any) => unknown;
+    ononline: (ev: any) => unknown;
+    onrejectionhandled: (ev: PromiseRejectionEvent) => unknown;
+    onunhandledrejection: (ev: PromiseRejectionEvent) => unknown;
 }
 
 declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope {
-    onmessage: (ev: MessageEvent) => mixed;
-    onmessageerror: (ev: MessageEvent) => mixed;
+    onmessage: (ev: MessageEvent) => unknown;
+    onmessageerror: (ev: MessageEvent) => unknown;
     postMessage(message: any, transfer?: Iterable<any>): void;
 }
 
 declare class SharedWorkerGlobalScope extends WorkerGlobalScope {
     name: string;
-    onconnect: (ev: MessageEvent) => mixed;
+    onconnect: (ev: MessageEvent) => unknown;
 }
 
 declare class WorkerLocation {
@@ -874,10 +875,10 @@ declare class WorkerNavigator mixins
 // deprecated
 declare class XDomainRequest {
     timeout: number;
-    onerror: () => mixed;
-    onload: () => mixed;
-    onprogress: () => mixed;
-    ontimeout: () => mixed;
+    onerror: () => unknown;
+    onload: () => unknown;
+    onprogress: () => unknown;
+    ontimeout: () => unknown;
     +responseText: string;
     +contentType: string;
     open(method: "GET" | "POST", url: string): void;
@@ -901,7 +902,7 @@ declare class XMLHttpRequest extends EventTarget {
     responseURL: string;
     ontimeout: ProgressEventHandler;
     statusText: string;
-    onreadystatechange: (ev: any) => mixed;
+    onreadystatechange: (ev: any) => unknown;
     timeout: number;
     onload: ProgressEventHandler;
     response: any;
@@ -947,13 +948,13 @@ declare class XMLSerializer {
 
 declare class Geolocation {
     getCurrentPosition(
-        success: (position: Position) => mixed,
-        error?: (error: PositionError) => mixed,
+        success: (position: Position) => unknown,
+        error?: (error: PositionError) => unknown,
         options?: PositionOptions
     ): void;
     watchPosition(
-        success: (position: Position) => mixed,
-        error?: (error: PositionError) => mixed,
+        success: (position: Position) => unknown,
+        error?: (error: PositionError) => unknown,
         options?: PositionOptions
     ): number;
     clearWatch(id: number): void;
@@ -1025,7 +1026,7 @@ declare class BaseAudioContext extends EventTarget {
   listener: AudioListener;
   sampleRate: number;
   state: AudioContextState;
-  onstatechange: (ev: any) => mixed;
+  onstatechange: (ev: any) => unknown;
   createBuffer(numOfChannels: number, length: number, sampleRate: number): AudioBuffer;
   createBufferSource(myMediaElement?: HTMLMediaElement): AudioBufferSourceNode;
   createMediaElementSource(myMediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
@@ -1051,7 +1052,7 @@ declare class BaseAudioContext extends EventTarget {
   createPeriodicWave(real: Float32Array, img: Float32Array, options?: { disableNormalization: boolean, ... }): PeriodicWave;
   createStereoPanner(): StereoPannerNode;
   createWaveShaper(): WaveShaperNode;
-  decodeAudioData(arrayBuffer: ArrayBuffer, decodeSuccessCallback: (decodedData: AudioBuffer) => mixed, decodeErrorCallback: (err: DOMError) => mixed): void;
+  decodeAudioData(arrayBuffer: ArrayBuffer, decodeSuccessCallback: (decodedData: AudioBuffer) => unknown, decodeErrorCallback: (err: DOMError) => unknown): void;
   decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;
 }
 
@@ -1078,7 +1079,7 @@ declare class OfflineAudioContext extends BaseAudioContext {
   startRendering(): Promise<AudioBuffer>;
   suspend(suspendTime: number): Promise<void>;
   length: number;
-  oncomplete: (ev: OfflineAudioCompletionEvent) => mixed;
+  oncomplete: (ev: OfflineAudioCompletionEvent) => unknown;
 }
 
 declare class AudioNode extends EventTarget {
@@ -1139,7 +1140,7 @@ declare class AudioBufferSourceNode extends AudioNode {
   loopStart: number;
   loopEnd: number;
   playbackRate: AudioParam;
-  onended: (ev: any) => mixed;
+  onended: (ev: any) => unknown;
   start(when?: number, offset?: number, duration?: number): void;
   stop(when?: number): void;
 }
@@ -1278,7 +1279,7 @@ type MediaTrackCapabilities = {
 }
 
 declare class MediaDevices extends EventTarget {
-  ondevicechange: (ev: any) => mixed;
+  ondevicechange: (ev: any) => unknown;
   enumerateDevices: () => Promise<Array<MediaDeviceInfo>>;
   getSupportedConstraints: () => MediaTrackSupportedConstraints;
   getDisplayMedia: (constraints?: DisplayMediaStreamConstraints) => Promise<MediaStream>;
@@ -1307,12 +1308,12 @@ declare class MediaRecorder extends EventTarget {
   +mimeType: string;
   +state: 'inactive' | 'recording' | 'paused';
 
-  onstart: (ev: any) => mixed;
-  onstop: (ev: any) => mixed;
-  ondataavailable: (ev: any) => mixed;
-  onpause: (ev: any) => mixed;
-  onresume: (ev: any) => mixed;
-  onerror: (ev: any) => mixed;
+  onstart: (ev: any) => unknown;
+  onstop: (ev: any) => unknown;
+  ondataavailable: (ev: any) => unknown;
+  onpause: (ev: any) => unknown;
+  onresume: (ev: any) => unknown;
+  onerror: (ev: any) => unknown;
 
   +videoBitsPerSecond: number;
   +audioBitsPerSecond: number;
@@ -1331,11 +1332,11 @@ declare class MediaStream extends EventTarget {
   active: boolean;
   ended: boolean;
   id: string;
-  onactive: (ev: any) => mixed;
-  oninactive: (ev: any) => mixed;
-  onended: (ev: any) => mixed;
-  onaddtrack: (ev: MediaStreamTrackEvent) => mixed;
-  onremovetrack: (ev: MediaStreamTrackEvent) => mixed;
+  onactive: (ev: any) => unknown;
+  oninactive: (ev: any) => unknown;
+  onended: (ev: any) => unknown;
+  onaddtrack: (ev: MediaStreamTrackEvent) => unknown;
+  onremovetrack: (ev: MediaStreamTrackEvent) => unknown;
   addTrack(track: MediaStreamTrack): void;
   clone(): MediaStream;
   getAudioTracks(): MediaStreamTrack[];
@@ -1355,11 +1356,11 @@ declare class MediaStreamTrack extends EventTarget {
   readyState: 'live' | 'ended';
   remote: boolean;
   contentHint?: string;
-  onstarted: (ev: any) => mixed;
-  onmute: (ev: any) => mixed;
-  onunmute: (ev: any) => mixed;
-  onoverconstrained: (ev: any) => mixed;
-  onended: (ev: any) => mixed;
+  onstarted: (ev: any) => unknown;
+  onmute: (ev: any) => unknown;
+  onunmute: (ev: any) => unknown;
+  onoverconstrained: (ev: any) => unknown;
+  onended: (ev: any) => unknown;
   getConstraints(): MediaTrackConstraints;
   applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
   getSettings(): MediaTrackSettings;
@@ -1383,7 +1384,7 @@ declare class MediaStreamAudioDestinationNode extends AudioNode {
 // deprecated
 declare class ScriptProcessorNode extends AudioNode {
   bufferSize: number;
-  onaudioprocess: (ev: AudioProcessingEvent) => mixed;
+  onaudioprocess: (ev: AudioProcessingEvent) => unknown;
 }
 
 declare class AnalyserNode extends AudioNode {
@@ -1414,7 +1415,7 @@ type ConstantSourceOptions = { offset?: number, ... }
 declare class ConstantSourceNode extends AudioNode {
   constructor(context: BaseAudioContext, options?: ConstantSourceOptions): void;
   offset: AudioParam;
-  onended: (ev: any) => mixed;
+  onended: (ev: any) => unknown;
   start(when?: number): void;
   stop(when?: number): void;
 }
@@ -1452,7 +1453,7 @@ declare class OscillatorNode extends AudioNode {
   start(when?: number): void;
   stop(when?: number): void;
   setPeriodicWave(periodicWave: PeriodicWave): void;
-  onended: (ev: any) => mixed;
+  onended: (ev: any) => unknown;
 }
 
 declare class StereoPannerNode extends AudioNode {
@@ -1492,7 +1493,7 @@ declare class Headers {
     append(name: string, value: string): void;
     delete(name: string): void;
     entries(): Iterator<[string, string]>;
-    forEach<This>(callback: (this : This, value: string, name: string, headers: Headers) => mixed, thisArg: This): void;
+    forEach<This>(callback: (this : This, value: string, name: string, headers: Headers) => unknown, thisArg: This): void;
     get(name: string): null | string;
     has(name: string): boolean;
     keys(): Iterator<string>;
@@ -1509,7 +1510,7 @@ declare class URLSearchParams {
     append(name: string, value: string): void;
     delete(name: string, value?: string): void;
     entries(): Iterator<[string, string]>;
-    forEach<This>(callback: (this : This, value: string, name: string, params: URLSearchParams) => mixed, thisArg: This): void;
+    forEach<This>(callback: (this : This, value: string, name: string, params: URLSearchParams) => unknown, thisArg: This): void;
     get(name: string): null | string;
     getAll(name: string): Array<string>;
     has(name: string, value?: string): boolean;
@@ -1863,8 +1864,8 @@ declare class MessagePort extends EventTarget {
   start(): void;
   close(): void;
 
-  onmessage: null | (ev: MessageEvent) => mixed;
-  onmessageerror: null | (ev: MessageEvent) => mixed;
+  onmessage: null | (ev: MessageEvent) => unknown;
+  onmessageerror: null | (ev: MessageEvent) => unknown;
 }
 
 declare class MessageChannel {
@@ -1886,7 +1887,7 @@ declare class VRDisplay extends EventTarget {
   getEyeParameters(VREye): VREyeParameters;
   getFrameData(VRFrameData): boolean;
   getLayers(): VRLayerInit[];
-  requestAnimationFrame(cb: (number) => mixed): number;
+  requestAnimationFrame(cb: (number) => unknown): number;
   requestPresent(VRLayerInit[]): Promise<void>;
   submitFrame(): void;
 }
@@ -2020,7 +2021,7 @@ declare class SpeechSynthesis extends EventTarget {
   +speaking: boolean;
   +paused: boolean;
 
-  onvoiceschanged: ?((ev: Event) => mixed);
+  onvoiceschanged: ?((ev: Event) => unknown);
 
   speak(utterance: SpeechSynthesisUtterance): void;
   cancel(): void;
@@ -2041,13 +2042,13 @@ declare class SpeechSynthesisUtterance extends EventTarget {
   rate: number;
   pitch: number;
 
-  onstart: ?((ev: SpeechSynthesisEvent) => mixed);
-  onend: ?((ev: SpeechSynthesisEvent) => mixed);
-  onerror: ?((ev: SpeechSynthesisErrorEvent) => mixed);
-  onpause: ?((ev: SpeechSynthesisEvent) => mixed);
-  onresume: ?((ev: SpeechSynthesisEvent) => mixed);
-  onmark: ?((ev: SpeechSynthesisEvent) => mixed);
-  onboundary: ?((ev: SpeechSynthesisEvent) => mixed);
+  onstart: ?((ev: SpeechSynthesisEvent) => unknown);
+  onend: ?((ev: SpeechSynthesisEvent) => unknown);
+  onerror: ?((ev: SpeechSynthesisErrorEvent) => unknown);
+  onpause: ?((ev: SpeechSynthesisEvent) => unknown);
+  onresume: ?((ev: SpeechSynthesisEvent) => unknown);
+  onmark: ?((ev: SpeechSynthesisEvent) => unknown);
+  onboundary: ?((ev: SpeechSynthesisEvent) => unknown);
 }
 
 type SpeechSynthesisEvent$Init = Event$Init & {
@@ -2167,16 +2168,16 @@ declare class SpeechRecognition extends EventTarget {
   +maxAlternatives: number;
   +serviceURI: string;
 
-  onaudiostart: ?((ev: Event) => mixed);
-  onaudioend: ?((ev: Event) => mixed);
-  onend: ?((ev: Event) => mixed);
-  onerror: ?((ev: Event) => mixed);
-  onnomatch: ?((ev: Event) => mixed);
-  onsoundstart: ?((ev: Event) => mixed);
-  onsoundend: ?((ev: Event) => mixed);
-  onspeechstart: ?((ev: Event) => mixed);
-  onspeechend: ?((ev: Event) => mixed);
-  onstart: ?((ev: Event) => mixed);
+  onaudiostart: ?((ev: Event) => unknown);
+  onaudioend: ?((ev: Event) => unknown);
+  onend: ?((ev: Event) => unknown);
+  onerror: ?((ev: Event) => unknown);
+  onnomatch: ?((ev: Event) => unknown);
+  onsoundstart: ?((ev: Event) => unknown);
+  onsoundend: ?((ev: Event) => unknown);
+  onspeechstart: ?((ev: Event) => unknown);
+  onspeechend: ?((ev: Event) => unknown);
+  onstart: ?((ev: Event) => unknown);
 
   abort(): void;
   start(): void;
@@ -2203,15 +2204,15 @@ declare class TrustedScriptURL {
 
 declare class TrustedTypePolicy {
   +name: string;
-  createHTML(input: string, ...args: Array<mixed>): TrustedHTML;
-  createScript(input: string, ...args: Array<mixed>): TrustedScript;
-  createScriptURL(input: string, ...args: Array<mixed>): TrustedScriptURL;
+  createHTML(input: string, ...args: Array<unknown>): TrustedHTML;
+  createScript(input: string, ...args: Array<unknown>): TrustedScript;
+  createScriptURL(input: string, ...args: Array<unknown>): TrustedScriptURL;
 }
 
 declare type TrustedTypePolicyOptions = {|
-  createHTML?: (string, ...args: Array<mixed>) => string;
-  createScript?: (string, ...args: Array<mixed>) => string;
-  createScriptURL?: (string, ...args: Array<mixed>) => string;
+  createHTML?: (string, ...args: Array<unknown>) => string;
+  createScript?: (string, ...args: Array<unknown>) => string;
+  createScriptURL?: (string, ...args: Array<unknown>) => string;
 |}
 
 // window.trustedTypes?: TrustedTypePolicyFactory
@@ -2219,9 +2220,9 @@ declare class TrustedTypePolicyFactory {
   +emptyHTML: TrustedHTML;
   +emptyScript: TrustedScript;
   +defaultPolicy: ?TrustedTypePolicy;
-  +isHTML: (value: mixed) => value is TrustedHTML;
-  +isScript: (value: mixed) => value is TrustedScript;
-  +isScriptURL: (value: mixed) => value is TrustedScriptURL;
+  +isHTML: (value: unknown) => value is TrustedHTML;
+  +isScript: (value: unknown) => value is TrustedScript;
+  +isScriptURL: (value: unknown) => value is TrustedScriptURL;
   createPolicy(policyName: string, policyOptions?: TrustedTypePolicyOptions): TrustedTypePolicy;
   getAttributeType(tagName: string, attribute?: string, elementNS?: string, attrNS?: string): null | string;
   getPropertyType(tagName: string, property: string, elementNS?: string): null | string;
@@ -2287,7 +2288,7 @@ declare class USBConfiguration {
   constructor(): void;
   configurationName: ?string;
   configurationValue: number;
-  interfaces: $ReadOnlyArray<USBInterface>;
+  interfaces: ReadonlyArray<USBInterface>;
 
 }
 
diff --git a/flow-typed/environments/dom.js b/flow-typed/environments/dom.js
index 2cf16042..4fa4b2e0 100644
--- a/flow-typed/environments/dom.js
+++ b/flow-typed/environments/dom.js
@@ -46,7 +46,7 @@ declare type FilePropertyBag = {
 };
 declare class File extends Blob {
   constructor(
-    fileBits: $ReadOnlyArray<string | BufferDataSource | Blob>,
+    fileBits: ReadonlyArray<string | BufferDataSource | Blob>,
     filename: string,
     options?: FilePropertyBag,
   ): void;
@@ -94,43 +94,43 @@ declare type ScrollToOptions = {
   ...
 }
 
-type EventHandler = (event: Event) => mixed
+type EventHandler = (event: Event) => unknown
 type EventListener = { handleEvent: EventHandler, ... } | EventHandler
-type MouseEventHandler = (event: MouseEvent) => mixed
+type MouseEventHandler = (event: MouseEvent) => unknown
 type MouseEventListener = { handleEvent: MouseEventHandler, ... } | MouseEventHandler
-type FocusEventHandler = (event: FocusEvent) => mixed
+type FocusEventHandler = (event: FocusEvent) => unknown
 type FocusEventListener = { handleEvent: FocusEventHandler, ... } | FocusEventHandler
-type KeyboardEventHandler = (event: KeyboardEvent) => mixed
+type KeyboardEventHandler = (event: KeyboardEvent) => unknown
 type KeyboardEventListener = { handleEvent: KeyboardEventHandler, ... } | KeyboardEventHandler
-type InputEventHandler = (event: InputEvent) => mixed
+type InputEventHandler = (event: InputEvent) => unknown
 type InputEventListener = { handleEvent: InputEventHandler, ... } | InputEventHandler
-type TouchEventHandler = (event: TouchEvent) => mixed
+type TouchEventHandler = (event: TouchEvent) => unknown
 type TouchEventListener = { handleEvent: TouchEventHandler, ... } | TouchEventHandler
-type WheelEventHandler = (event: WheelEvent) => mixed
+type WheelEventHandler = (event: WheelEvent) => unknown
 type WheelEventListener = { handleEvent: WheelEventHandler, ... } | WheelEventHandler
-type AbortProgressEventHandler = (event: ProgressEvent) => mixed
+type AbortProgressEventHandler = (event: ProgressEvent) => unknown
 type AbortProgressEventListener = { handleEvent: AbortProgressEventHandler, ... } | AbortProgressEventHandler
-type ProgressEventHandler = (event: ProgressEvent) => mixed
+type ProgressEventHandler = (event: ProgressEvent) => unknown
 type ProgressEventListener = { handleEvent: ProgressEventHandler, ... } | ProgressEventHandler
-type DragEventHandler = (event: DragEvent) => mixed
+type DragEventHandler = (event: DragEvent) => unknown
 type DragEventListener = { handleEvent: DragEventHandler, ... } | DragEventHandler
-type PointerEventHandler = (event: PointerEvent) => mixed
+type PointerEventHandler = (event: PointerEvent) => unknown
 type PointerEventListener = { handleEvent: PointerEventHandler, ... } | PointerEventHandler
-type AnimationEventHandler = (event: AnimationEvent) => mixed
+type AnimationEventHandler = (event: AnimationEvent) => unknown
 type AnimationEventListener = { handleEvent: AnimationEventHandler, ... } | AnimationEventHandler
-type ClipboardEventHandler = (event: ClipboardEvent) => mixed
+type ClipboardEventHandler = (event: ClipboardEvent) => unknown
 type ClipboardEventListener = { handleEvent: ClipboardEventHandler, ... } | ClipboardEventHandler
-type TransitionEventHandler = (event: TransitionEvent) => mixed
+type TransitionEventHandler = (event: TransitionEvent) => unknown
 type TransitionEventListener = { handleEvent: TransitionEventHandler, ... } | TransitionEventHandler
-type MessageEventHandler = (event: MessageEvent) => mixed
+type MessageEventHandler = (event: MessageEvent) => unknown
 type MessageEventListener = { handleEvent: MessageEventHandler, ... } | MessageEventHandler
-type BeforeUnloadEventHandler = (event: BeforeUnloadEvent) => mixed
+type BeforeUnloadEventHandler = (event: BeforeUnloadEvent) => unknown
 type BeforeUnloadEventListener = { handleEvent: BeforeUnloadEventHandler, ... } | BeforeUnloadEventHandler
-type StorageEventHandler = (event: StorageEvent) => mixed
+type StorageEventHandler = (event: StorageEvent) => unknown
 type StorageEventListener = { handleEvent: StorageEventHandler, ... } | StorageEventHandler
-type SecurityPolicyViolationEventHandler = (event: SecurityPolicyViolationEvent) => mixed
+type SecurityPolicyViolationEventHandler = (event: SecurityPolicyViolationEvent) => unknown
 type SecurityPolicyViolationEventListener = { handleEvent: SecurityPolicyViolationEventHandler, ... } | SecurityPolicyViolationEventHandler
-type USBConnectionEventHandler = (event: USBConnectionEvent) => mixed
+type USBConnectionEventHandler = (event: USBConnectionEvent) => unknown
 type USBConnectionEventListener = { handleEvent: USBConnectionEventHandler, ... } | USBConnectionEventHandler
 
 type MediaKeySessionType = 'temporary' | 'persistent-license';
@@ -536,7 +536,7 @@ declare class PageTransitionEvent extends Event {
 // and
 // https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interfaces
 declare class MessageEvent extends Event {
-  data: mixed;
+  data: unknown;
   origin: string;
   lastEventId: string;
   source: WindowProxy;
@@ -776,7 +776,7 @@ type ClipboardItemOptions = {
 }
 
 declare class ClipboardItem {
-  +types: $ReadOnlyArray<string>;
+  +types: ReadonlyArray<string>;
   getType(type: string): Promise<Blob>;
   constructor(items: {[type: string]: ClipboardItemData}, options?: ClipboardItemOptions): void;
 }
@@ -864,7 +864,7 @@ declare class AbortSignal extends EventTarget {
     +aborted: boolean;
     +reason: any;
     abort(reason?: any): AbortSignal;
-    onabort: (event: Event) => mixed;
+    onabort: (event: Event) => unknown;
     throwIfAborted(): void;
     timeout(time: number): AbortSignal;
 }
@@ -885,22 +885,22 @@ declare class Node extends EventTarget {
   previousSibling: ?Node;
   rootNode: Node;
   textContent: string;
-  appendChild<T: Node>(newChild: T): T;
+  appendChild<T extends Node>(newChild: T): T;
   cloneNode(deep?: boolean): this;
   compareDocumentPosition(other: Node): number;
   contains(other: ?Node): boolean;
   getRootNode(options?: { composed: boolean, ... }): Node;
   hasChildNodes(): boolean;
-  insertBefore<T: Node>(newChild: T, refChild?: ?Node): T;
+  insertBefore<T extends Node>(newChild: T, refChild?: ?Node): T;
   isDefaultNamespace(namespaceURI: string): boolean;
   isEqualNode(arg: Node): boolean;
   isSameNode(other: Node): boolean;
   lookupNamespaceURI(prefix: string): string;
   lookupPrefix(namespaceURI: string): string;
   normalize(): void;
-  removeChild<T: Node>(oldChild: T): T;
-  replaceChild<T: Node>(newChild: Node, oldChild: T): T;
-  replaceChildren(...nodes: $ReadOnlyArray<Node | string>): void;
+  removeChild<T extends Node>(oldChild: T): T;
+  replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
+  replaceChildren(...nodes: ReadonlyArray<Node | string>): void;
   static ATTRIBUTE_NODE: number;
   static CDATA_SECTION_NODE: number;
   static COMMENT_NODE: number;
@@ -961,11 +961,12 @@ declare class Attr extends Node {
   localName: string;
 }
 
-declare class HTMLCollection<+Elem: Element> {
+declare class HTMLCollection<+Elem extends Element> {
   @@iterator(): Iterator<Elem>;
   length: number;
   item(nameOrIndex?: any, optionalIndex?: any): Elem | null;
   namedItem(name: string): Elem | null;
+  // $FlowFixMe[incompatible-variance]
   [index: number | string]: Elem;
 }
 
@@ -975,9 +976,9 @@ type ElementRegistrationOptions = {
        +prototype?: {
               // from https://www.w3.org/TR/custom-elements/#types-of-callbacks
               // See also https://github.com/w3c/webcomponents/
-              +createdCallback?: () => mixed,
-              +attachedCallback?: () => mixed,
-              +detachedCallback?: () => mixed,
+              +createdCallback?: () => unknown,
+              +attachedCallback?: () => unknown,
+              +detachedCallback?: () => unknown,
               +attributeChangedCallback?:
               // attribute is set
               ((
@@ -985,21 +986,21 @@ type ElementRegistrationOptions = {
                 oldAttributeValue: null,
                 newAttributeValue: string,
                 attributeNamespace: string
-              ) => mixed) &
+              ) => unknown) &
               // attribute is changed
               ((
                 attributeLocalName: string,
                 oldAttributeValue: string,
                 newAttributeValue: string,
                 attributeNamespace: string
-              ) => mixed) &
+              ) => unknown) &
               // attribute is removed
               ((
                 attributeLocalName: string,
                 oldAttributeValue: string,
                 newAttributeValue: null,
                 attributeNamespace: string
-              ) => mixed),
+              ) => unknown),
               ...
        },
        +extends?: string,
@@ -1034,7 +1035,7 @@ declare type MutationObserverInit = MutationObserverInitRequired & {
 }
 
 declare class MutationObserver {
-  constructor(callback: (arr: Array<MutationRecord>, observer: MutationObserver) => mixed): void;
+  constructor(callback: (arr: Array<MutationRecord>, observer: MutationObserver) => unknown): void;
   observe(target: Node, options: MutationObserverInit): void;
   takeRecords(): Array<MutationRecord>;
   disconnect(): void;
@@ -1044,7 +1045,7 @@ declare class Document extends Node {
   +timeline: DocumentTimeline;
   getAnimations(): Array<Animation>;
   +URL: string;
-  adoptNode<T: Node>(source: T): T;
+  adoptNode<T extends Node>(source: T): T;
   anchors: HTMLCollection<HTMLAnchorElement>;
   applets: HTMLCollection<HTMLAppletElement>;
   body: HTMLBodyElement | null;
@@ -1062,8 +1063,8 @@ declare class Document extends Node {
   createCDATASection(data: string): Text;
   createComment(data: string): Comment;
   createDocumentFragment(): DocumentFragment;
-  createElement<TName: $Keys<HTMLElementTagNameMap>>(localName: TName, options?: string | ElementCreationOptions): HTMLElementTagNameMap[TName];
-  createElementNS<TName: $Keys<HTMLElementTagNameMap>>(namespaceURI: 'http://www.w3.org/1999/xhtml', qualifiedName: TName, options?: string | ElementCreationOptions): HTMLElementTagNameMap[TName];
+  createElement<TName extends $Keys<HTMLElementTagNameMap>>(localName: TName, options?: string | ElementCreationOptions): HTMLElementTagNameMap[TName];
+  createElementNS<TName extends $Keys<HTMLElementTagNameMap>>(namespaceURI: 'http://www.w3.org/1999/xhtml', qualifiedName: TName, options?: string | ElementCreationOptions): HTMLElementTagNameMap[TName];
   createElementNS(namespaceURI: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
   createTextNode(data: string): Text;
   currentScript: HTMLScriptElement | null;
@@ -1082,13 +1083,13 @@ declare class Document extends Node {
   fullscreenEnabled: boolean;
   getElementsByClassName(classNames: string): HTMLCollection<HTMLElement>;
   getElementsByName(elementName: string): HTMLCollection<HTMLElement>;
-  getElementsByTagName<TName: $Keys<HTMLElementTagNameMap>>(qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
-  getElementsByTagNameNS<TName: $Keys<HTMLElementTagNameMap>>(namespaceURI: 'http://www.w3.org/1999/xhtml', qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
+  getElementsByTagName<TName extends $Keys<HTMLElementTagNameMap>>(qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
+  getElementsByTagNameNS<TName extends $Keys<HTMLElementTagNameMap>>(namespaceURI: 'http://www.w3.org/1999/xhtml', qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
   getElementsByTagNameNS(namespaceURI: string | null, qualifiedName: string): HTMLCollection<Element>;
   head: HTMLHeadElement | null;
   images: HTMLCollection<HTMLImageElement>;
   +implementation: DOMImplementation;
-  importNode<T: Node>(importedNode: T, deep: boolean): T;
+  importNode<T extends Node>(importedNode: T, deep: boolean): T;
   /**
    * Legacy alias of `characterSet`
    * @deprecated
@@ -1140,8 +1141,8 @@ declare class Document extends Node {
   append(...nodes: Array<string | Node>): void;
   prepend(...nodes: Array<string | Node>): void;
 
-  querySelector<TSelector: $Keys<HTMLElementTagNameMap>>(selector: TSelector): HTMLElementTagNameMap[TSelector] | null;
-  querySelectorAll<TSelector: $Keys<HTMLElementTagNameMap>>(selector: TSelector): NodeList<HTMLElementTagNameMap[TSelector]>;
+  querySelector<TSelector extends $Keys<HTMLElementTagNameMap>>(selector: TSelector): HTMLElementTagNameMap[TSelector] | null;
+  querySelectorAll<TSelector extends $Keys<HTMLElementTagNameMap>>(selector: TSelector): NodeList<HTMLElementTagNameMap[TSelector]>;
   // Interface DocumentTraversal
   // http://www.w3.org/TR/2000/REC-DOM-Level-2-Traversal-Range-20001113/traversal.html#Traversal-Document
 
@@ -1157,104 +1158,104 @@ declare class Document extends Node {
   // NodeFilter.SHOW_ATTRIBUTE === 1), RootNodeT must be Attr, and when
   // RootNodeT is Attr, bitmasks other than NodeFilter.SHOW_ATTRIBUTE are
   // meaningless.
-  createNodeIterator<RootNodeT: Attr>(root: RootNodeT, whatToShow: 2, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Attr>;
-  createTreeWalker<RootNodeT: Attr>(root: RootNodeT, whatToShow: 2, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Attr>;
+  createNodeIterator<RootNodeT extends Attr>(root: RootNodeT, whatToShow: 2, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Attr>;
+  createTreeWalker<RootNodeT extends Attr>(root: RootNodeT, whatToShow: 2, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Attr>;
 
   // NodeFilter.SHOW_PROCESSING_INSTRUCTION is not implemented because Flow
   // does not currently define a ProcessingInstruction class.
 
   // When (whatToShow & NodeFilter.SHOW_DOCUMENT === 1 || whatToShow &
   // NodeFilter.SHOW_DOCUMENT_TYPE === 1), RootNodeT must be Document.
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 256, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 257, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 260, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Text>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 261, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element|Text>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 384, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 385, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 388, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Text|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 389, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element|Text|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 512, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 513, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 516, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Text>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 517, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element|Text>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 640, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 641, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 644, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Text|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 645, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element|Text|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 768, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 769, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 772, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Text>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 773, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element|Text>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 896, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 897, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 900, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Text|Comment>;
-  createNodeIterator<RootNodeT: Document>(root: RootNodeT, whatToShow: 901, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element|Text|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 256, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 257, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 260, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Text>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 261, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element|Text>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 384, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 385, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 388, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Text|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 389, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element|Text|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 512, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 513, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 516, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Text>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 517, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element|Text>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 640, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 641, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 644, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Text|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 645, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element|Text|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 768, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 769, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 772, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Text>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 773, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element|Text>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 896, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 897, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 900, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Text|Comment>;
-  createTreeWalker<RootNodeT: Document>(root: RootNodeT, whatToShow: 901, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element|Text|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 256, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 257, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 260, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Text>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 261, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element|Text>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 384, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 385, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 388, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Text|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 389, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Document|Element|Text|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 512, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 513, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 516, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Text>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 517, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element|Text>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 640, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 641, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 644, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Text|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 645, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Element|Text|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 768, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 769, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 772, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Text>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 773, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element|Text>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 896, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 897, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 900, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Text|Comment>;
+  createNodeIterator<RootNodeT extends Document>(root: RootNodeT, whatToShow: 901, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentType|Document|Element|Text|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 256, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 257, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 260, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Text>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 261, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element|Text>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 384, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 385, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 388, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Text|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 389, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Document|Element|Text|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 512, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 513, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 516, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Text>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 517, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element|Text>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 640, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 641, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 644, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Text|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 645, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Element|Text|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 768, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 769, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 772, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Text>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 773, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element|Text>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 896, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 897, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 900, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Text|Comment>;
+  createTreeWalker<RootNodeT extends Document>(root: RootNodeT, whatToShow: 901, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentType|Document|Element|Text|Comment>;
 
   // When (whatToShow & NodeFilter.SHOW_DOCUMENT_FRAGMENT === 1), RootNodeT
   // must be a DocumentFragment.
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1024, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1025, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1028, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Text>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1029, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element|Text>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1152, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Comment>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1153, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element|Comment>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1156, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Text|Comment>;
-  createNodeIterator<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1157, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element|Text|Comment>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1024, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1025, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1028, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Text>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1029, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element|Text>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1152, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Comment>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1153, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element|Comment>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1156, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Text|Comment>;
-  createTreeWalker<RootNodeT: DocumentFragment>(root: RootNodeT, whatToShow: 1157, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element|Text|Comment>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1024, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1025, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1028, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Text>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1029, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element|Text>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1152, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Comment>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1153, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element|Comment>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1156, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Text|Comment>;
+  createNodeIterator<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1157, filter?: NodeFilterInterface): NodeIterator<RootNodeT, DocumentFragment|Element|Text|Comment>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1024, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1025, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1028, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Text>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1029, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element|Text>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1152, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Comment>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1153, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element|Comment>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1156, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Text|Comment>;
+  createTreeWalker<RootNodeT extends DocumentFragment>(root: RootNodeT, whatToShow: 1157, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, DocumentFragment|Element|Text|Comment>;
 
   // In the general case, RootNodeT may be any Node and whatToShow may be
   // NodeFilter.SHOW_ALL or any combination of NodeFilter.SHOW_ELEMENT,
   // NodeFilter.SHOW_TEXT and/or NodeFilter.SHOW_COMMENT
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 1, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Element>;
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 4, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Text>;
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 5, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Element|Text>;
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 128, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Comment>;
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 129, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Element|Comment>;
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 132, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Text|Comment>;
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow: 133, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Text|Element|Comment>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 1, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Element>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 4, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Text>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 5, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Element|Text>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 128, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Comment>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 129, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Element|Comment>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 132, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Text|Comment>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow: 133, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Text|Element|Comment>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 1, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Element>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 4, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Text>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 5, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Element|Text>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 128, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Comment>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 129, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Element|Comment>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 132, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Text|Comment>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow: 133, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Text|Element|Comment>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 1, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Element>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 4, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Text>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 5, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Element|Text>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 128, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Comment>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 129, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Element|Comment>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 132, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Text|Comment>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow: 133, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Text|Element|Comment>;
 
   // Catch all for when we don't know the value of `whatToShow`
   // And for when whatToShow is not provided, it is assumed to be SHOW_ALL
-  createNodeIterator<RootNodeT: Node>(root: RootNodeT, whatToShow?: number, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Node>;
-  createTreeWalker<RootNodeT: Node>(root: RootNodeT, whatToShow?: number, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Node>;
+  createNodeIterator<RootNodeT extends Node>(root: RootNodeT, whatToShow?: number, filter?: NodeFilterInterface): NodeIterator<RootNodeT, Node>;
+  createTreeWalker<RootNodeT extends Node>(root: RootNodeT, whatToShow?: number, filter?: NodeFilterInterface, entityReferenceExpansion?: boolean): TreeWalker<RootNodeT, Node>;
 
   // From NonElementParentNode Mixin.
   getElementById(elementId: string): HTMLElement | null;
@@ -1404,8 +1405,8 @@ declare class Element extends Node mixins mixin$Animatable {
   getBoundingClientRect(): DOMRect;
   getClientRects(): DOMRectList;
   getElementsByClassName(names: string): HTMLCollection<HTMLElement>;
-  getElementsByTagName<TName: $Keys<HTMLElementTagNameMap>>(qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
-  getElementsByTagNameNS<TName: $Keys<HTMLElementTagNameMap>>(namespaceURI: 'http://www.w3.org/1999/xhtml', qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
+  getElementsByTagName<TName extends $Keys<HTMLElementTagNameMap>>(qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
+  getElementsByTagNameNS<TName extends $Keys<HTMLElementTagNameMap>>(namespaceURI: 'http://www.w3.org/1999/xhtml', qualifiedName: TName): HTMLCollection<HTMLElementTagNameMap[TName]>;
   getElementsByTagNameNS(namespaceURI: string | null, qualifiedName: string): HTMLCollection<Element>;
 
   hasAttribute(name: string): boolean;
@@ -1451,8 +1452,8 @@ declare class Element extends Node mixins mixin$Animatable {
   append(...nodes: Array<string | Node>): void;
   prepend(...nodes: Array<string | Node>): void;
 
-  querySelector<TSelector: $Keys<HTMLElementTagNameMap>>(selector: TSelector): HTMLElementTagNameMap[TSelector] | null;
-  querySelectorAll<TSelector: $Keys<HTMLElementTagNameMap>>(selector: TSelector): NodeList<HTMLElementTagNameMap[TSelector]>;
+  querySelector<TSelector extends $Keys<HTMLElementTagNameMap>>(selector: TSelector): HTMLElementTagNameMap[TSelector] | null;
+  querySelectorAll<TSelector extends $Keys<HTMLElementTagNameMap>>(selector: TSelector): NodeList<HTMLElementTagNameMap[TSelector]>;
 
   // from ChildNode interface
   after(...nodes: Array<string | Node>): void;
@@ -2739,13 +2740,13 @@ declare class Notification extends EventTarget {
   constructor(title: string, options?: NotificationOptions): void;
   static +permission: NotificationPermission;
   static requestPermission(
-    callback?: (perm: NotificationPermission) => mixed
+    callback?: (perm: NotificationPermission) => unknown
   ): Promise<NotificationPermission>;
   static +maxActions: number;
-  onclick: ?(evt: Event) => mixed;
-  onclose: ?(evt: Event) => mixed;
-  onerror: ?(evt: Event) => mixed;
-  onshow: ?(evt: Event) => mixed;
+  onclick: ?(evt: Event) => unknown;
+  onclose: ?(evt: Event) => unknown;
+  onerror: ?(evt: Event) => unknown;
+  onshow: ?(evt: Event) => unknown;
   +title: string;
   +dir: NotificationDirection;
   +lang: string;
diff --git a/flow-typed/environments/html.js b/flow-typed/environments/html.js
index 0296fee5..a79deaaf 100644
--- a/flow-typed/environments/html.js
+++ b/flow-typed/environments/html.js
@@ -29,7 +29,7 @@ declare class DataTransferItemList {
 declare class DataTransferItem {
   kind: string; // readonly
   type: string; // readonly
-  getAsString(_callback: ?(data: string) => mixed): void;
+  getAsString(_callback: ?(data: string) => unknown): void;
   getAsFile(): ?File;
   /*
    * This is not supported by all browsers, please have a fallback plan for it.
@@ -113,7 +113,7 @@ declare class BroadcastChannel extends EventTarget {
   onmessageerror: ?(event: MessageEvent) => void;
 
   constructor(name: string): void;
-  postMessage(msg: mixed): void;
+  postMessage(msg: unknown): void;
   close(): void;
 }
 
@@ -572,7 +572,7 @@ declare class CanvasRenderingContext2D {
     y: number,
     w: number,
     h: number,
-    radii?: number | DOMPointInit | $ReadOnlyArray<number | DOMPointInit>
+    radii?: number | DOMPointInit | ReadonlyArray<number | DOMPointInit>
   ): void;
   strokeRect(x: number, y: number, w: number, h: number): void;
 
diff --git a/flow-typed/environments/indexeddb.js b/flow-typed/environments/indexeddb.js
index f71be9b4..46e643d1 100644
--- a/flow-typed/environments/indexeddb.js
+++ b/flow-typed/environments/indexeddb.js
@@ -34,13 +34,13 @@ declare interface IDBRequest extends EventTarget {
   source: ?(IDBIndex | IDBObjectStore | IDBCursor);
   transaction: IDBTransaction;
   readyState: 'pending'|'done';
-  onerror: (err: any) => mixed;
-  onsuccess: (e: any) => mixed;
+  onerror: (err: any) => unknown;
+  onsuccess: (e: any) => unknown;
 }
 
 declare interface IDBOpenDBRequest extends IDBRequest {
-  onblocked: (e: any) => mixed;
-  onupgradeneeded: (e: any) => mixed;
+  onblocked: (e: any) => unknown;
+  onupgradeneeded: (e: any) => unknown;
 }
 
 declare interface IDBTransactionOptions {
@@ -63,10 +63,10 @@ declare interface IDBDatabase extends EventTarget {
   name: string;
   version: number;
   objectStoreNames: DOMStringList;
-  onabort: (e: any) => mixed;
-  onclose: (e: any) => mixed;
-  onerror: (e: any) => mixed;
-  onversionchange: (e: any) => mixed;
+  onabort: (e: any) => unknown;
+  onclose: (e: any) => unknown;
+  onerror: (e: any) => unknown;
+  onversionchange: (e: any) => unknown;
 }
 
 declare interface IDBTransaction extends EventTarget {
@@ -77,9 +77,9 @@ declare interface IDBTransaction extends EventTarget {
   mode: 'readonly'|'readwrite'|'versionchange';
   name: string;
   objectStore(name: string): IDBObjectStore;
-  onabort: (e: any) => mixed;
-  oncomplete: (e: any) => mixed;
-  onerror: (e: any) => mixed;
+  onabort: (e: any) => unknown;
+  oncomplete: (e: any) => unknown;
+  onerror: (e: any) => unknown;
 }
 
 declare interface IDBObjectStore {
diff --git a/flow-typed/environments/jsx.js b/flow-typed/environments/jsx.js
index 81aa71cb..70aa2077 100644
--- a/flow-typed/environments/jsx.js
+++ b/flow-typed/environments/jsx.js
@@ -18,7 +18,7 @@ type ModifierKey =
   | 'Symbol'
   | 'SymbolLock';
 
-declare class SyntheticEvent<+T: EventTarget = EventTarget, +E: Event = Event> {
+declare class SyntheticEvent<+T extends EventTarget = EventTarget, +E extends Event = Event> {
   bubbles: boolean;
   cancelable: boolean;
   +currentTarget: T;
@@ -27,6 +27,7 @@ declare class SyntheticEvent<+T: EventTarget = EventTarget, +E: Event = Event> {
   isDefaultPrevented(): boolean;
   isPropagationStopped(): boolean;
   isTrusted: boolean;
+  // $FlowFixMe[incompatible-variance]
   nativeEvent: E;
   persist(): void;
   preventDefault(): void;
@@ -38,7 +39,7 @@ declare class SyntheticEvent<+T: EventTarget = EventTarget, +E: Event = Event> {
   type: string;
 }
 
-declare class SyntheticAnimationEvent<+T: EventTarget = EventTarget>
+declare class SyntheticAnimationEvent<+T extends EventTarget = EventTarget>
   extends SyntheticEvent<T>
 {
   animationName: string;
@@ -46,39 +47,39 @@ declare class SyntheticAnimationEvent<+T: EventTarget = EventTarget>
   pseudoElement: string;
 }
 
-declare class SyntheticClipboardEvent<+T: EventTarget = EventTarget>
+declare class SyntheticClipboardEvent<+T extends EventTarget = EventTarget>
   extends SyntheticEvent<T>
 {
   clipboardData: any;
 }
 
-declare class SyntheticCompositionEvent<+T: EventTarget = EventTarget>
+declare class SyntheticCompositionEvent<+T extends EventTarget = EventTarget>
   extends SyntheticEvent<T>
 {
   data: any;
 }
 
-declare class SyntheticInputEvent<+T: EventTarget = EventTarget>
+declare class SyntheticInputEvent<+T extends EventTarget = EventTarget>
   extends SyntheticEvent<T>
 {
   data: any;
   +target: HTMLInputElement;
 }
 
-declare class SyntheticUIEvent<+T: EventTarget = EventTarget, +E: Event = Event>
+declare class SyntheticUIEvent<+T extends EventTarget = EventTarget, +E extends Event = Event>
   extends SyntheticEvent<T, E>
 {
   detail: number;
   view: any;
 }
 
-declare class SyntheticFocusEvent<+T: EventTarget = EventTarget>
+declare class SyntheticFocusEvent<+T extends EventTarget = EventTarget>
   extends SyntheticUIEvent<T>
 {
   relatedTarget: EventTarget;
 }
 
-declare class SyntheticKeyboardEvent<+T: EventTarget = EventTarget>
+declare class SyntheticKeyboardEvent<+T extends EventTarget = EventTarget>
   extends SyntheticUIEvent<T, KeyboardEvent>
 {
   altKey: boolean;
@@ -116,13 +117,13 @@ declare class SyntheticMouseEvent<
   shiftKey: boolean;
 }
 
-declare class SyntheticDragEvent<+T: EventTarget = EventTarget>
+declare class SyntheticDragEvent<+T extends EventTarget = EventTarget>
   extends SyntheticMouseEvent<T, DragEvent>
 {
   dataTransfer: any;
 }
 
-declare class SyntheticWheelEvent<+T: EventTarget = EventTarget>
+declare class SyntheticWheelEvent<+T extends EventTarget = EventTarget>
   extends SyntheticMouseEvent<T, WheelEvent>
 {
   deltaMode: number;
@@ -131,7 +132,7 @@ declare class SyntheticWheelEvent<+T: EventTarget = EventTarget>
   deltaZ: number;
 }
 
-declare class SyntheticPointerEvent<+T: EventTarget = EventTarget>
+declare class SyntheticPointerEvent<+T extends EventTarget = EventTarget>
   extends SyntheticMouseEvent<T, PointerEvent>
 {
   height: number;
@@ -146,7 +147,7 @@ declare class SyntheticPointerEvent<+T: EventTarget = EventTarget>
   width: number;
 }
 
-declare class SyntheticTouchEvent<+T: EventTarget = EventTarget>
+declare class SyntheticTouchEvent<+T extends EventTarget = EventTarget>
   extends SyntheticUIEvent<T, TouchEvent>
 {
   altKey: boolean;
@@ -159,7 +160,7 @@ declare class SyntheticTouchEvent<+T: EventTarget = EventTarget>
   touches: TouchList;
 }
 
-declare class SyntheticTransitionEvent<+T: EventTarget = EventTarget>
+declare class SyntheticTransitionEvent<+T extends EventTarget = EventTarget>
   extends SyntheticEvent<T>
 {
   elapsedTime: number;
@@ -369,7 +370,7 @@ type ReactDOM$SVGElementJSXIntrinsic = {
   ...
 };
 
-type ReactDOM$SVGElementJSXIntrinsicTyped<Props: {...}, Instance: Element> = {|
+type ReactDOM$SVGElementJSXIntrinsicTyped<Props extends {...}, Instance extends Element> = {|
   instance: Instance,
   props: {
     ...Props,
@@ -380,7 +381,7 @@ type ReactDOM$SVGElementJSXIntrinsicTyped<Props: {...}, Instance: Element> = {|
 |};
 
 // Override this if you want to add custom props to all HTML elements
-type ReactDOM$CustomHTMLElementProps = $ReadOnly<{||}>;
+type ReactDOM$CustomHTMLElementProps = Readonly<{||}>;
 
 // Override this if you want to change the types accepted by data-prefixed props
 type ReactDOM$DataPropValues = ?(string | boolean | number);
@@ -389,7 +390,7 @@ type ReactDOM$DataPropValues = ?(string | boolean | number);
 type ReactDOM$UserVisibleString = string;
 
 // Override this if you want to add custom events to all HTML elements
-type ReactDOM$CustomEvents<-E> = $ReadOnly<{||}>;
+type ReactDOM$CustomEvents<-E> = Readonly<{||}>;
 
 type ReactDOM$BooleanishString = boolean | 'true' | 'false';
 
@@ -397,7 +398,7 @@ type ReactDOM$Style = any;
 
 type ReactDOM$Number = number | string;
 
-type ReactDOM$Boolean<AttributeName: string> = AttributeName | boolean;
+type ReactDOM$Boolean<AttributeName extends string> = AttributeName | boolean;
 
 type ReactDOM$CrossOrigin = ?('anonymous' | 'use-credentials' | '');
 
@@ -647,206 +648,206 @@ type ReactDOM$AriaAttributes = {|
   'aria-valuetext'?: ?ReactDOM$UserVisibleString,
 |};
 
-type ReactDOM$EventHandlers<-E> = $ReadOnly<{|
+type ReactDOM$EventHandlers<-E> = Readonly<{|
   // Animation Events
-  onAnimationEnd?: ?(SyntheticAnimationEvent<E>) => mixed,
-  onAnimationEndCapture?: ?(SyntheticAnimationEvent<E>) => mixed,
-  onAnimationIteration?: ?(SyntheticAnimationEvent<E>) => mixed,
-  onAnimationIterationCapture?: ?(SyntheticAnimationEvent<E>) => mixed,
-  onAnimationStart?: ?(SyntheticAnimationEvent<E>) => mixed,
-  onAnimationStartCapture?: ?(SyntheticAnimationEvent<E>) => mixed,
+  onAnimationEnd?: ?(SyntheticAnimationEvent<E>) => unknown,
+  onAnimationEndCapture?: ?(SyntheticAnimationEvent<E>) => unknown,
+  onAnimationIteration?: ?(SyntheticAnimationEvent<E>) => unknown,
+  onAnimationIterationCapture?: ?(SyntheticAnimationEvent<E>) => unknown,
+  onAnimationStart?: ?(SyntheticAnimationEvent<E>) => unknown,
+  onAnimationStartCapture?: ?(SyntheticAnimationEvent<E>) => unknown,
 
   // Clipboard Events
-  onCopy?: ?(SyntheticEvent<E>) => mixed,
-  onCopyCapture?: ?(SyntheticEvent<E>) => mixed,
-  onCut?: ?(SyntheticEvent<E>) => mixed,
-  onCutCapture?: ?(SyntheticEvent<E>) => mixed,
-  onPaste?: ?(SyntheticEvent<E>) => mixed,
-  onPasteCapture?: ?(SyntheticEvent<E>) => mixed,
+  onCopy?: ?(SyntheticEvent<E>) => unknown,
+  onCopyCapture?: ?(SyntheticEvent<E>) => unknown,
+  onCut?: ?(SyntheticEvent<E>) => unknown,
+  onCutCapture?: ?(SyntheticEvent<E>) => unknown,
+  onPaste?: ?(SyntheticEvent<E>) => unknown,
+  onPasteCapture?: ?(SyntheticEvent<E>) => unknown,
 
   // Composition Events
-  onCompositionEnd?: ?(SyntheticCompositionEvent<E>) => mixed,
-  onCompositionEndCapture?: ?(SyntheticCompositionEvent<E>) => mixed,
-  onCompositionStart?: ?(SyntheticCompositionEvent<E>) => mixed,
-  onCompositionStartCapture?: ?(SyntheticCompositionEvent<E>) => mixed,
-  onCompositionUpdate?: ?(SyntheticCompositionEvent<E>) => mixed,
-  onCompositionUpdateCapture?: ?(SyntheticCompositionEvent<E>) => mixed,
+  onCompositionEnd?: ?(SyntheticCompositionEvent<E>) => unknown,
+  onCompositionEndCapture?: ?(SyntheticCompositionEvent<E>) => unknown,
+  onCompositionStart?: ?(SyntheticCompositionEvent<E>) => unknown,
+  onCompositionStartCapture?: ?(SyntheticCompositionEvent<E>) => unknown,
+  onCompositionUpdate?: ?(SyntheticCompositionEvent<E>) => unknown,
+  onCompositionUpdateCapture?: ?(SyntheticCompositionEvent<E>) => unknown,
 
   // Focus Events
-  onFocus?: ?(SyntheticFocusEvent<E>) => mixed,
-  onFocusCapture?: ?(SyntheticFocusEvent<E>) => mixed,
-  onBlur?: ?(SyntheticFocusEvent<E>) => mixed,
-  onBlurCapture?: ?(SyntheticFocusEvent<E>) => mixed,
+  onFocus?: ?(SyntheticFocusEvent<E>) => unknown,
+  onFocusCapture?: ?(SyntheticFocusEvent<E>) => unknown,
+  onBlur?: ?(SyntheticFocusEvent<E>) => unknown,
+  onBlurCapture?: ?(SyntheticFocusEvent<E>) => unknown,
 
   // Form Events
-  onBeforeInput?: ?(SyntheticInputEvent<E>) => mixed,
-  onBeforeInputCapture?: ?(SyntheticInputEvent<E>) => mixed,
-  onChange?: ?(SyntheticEvent<E>) => mixed,
-  onChangeCapture?: ?(SyntheticEvent<E>) => mixed,
-  onInput?: ?(SyntheticEvent<E>) => mixed,
-  onInputCapture?: ?(SyntheticEvent<E>) => mixed,
-  onInvalid?: ?(SyntheticEvent<E>) => mixed,
-  onInvalidCapture?: ?(SyntheticEvent<E>) => mixed,
-  onReset?: ?(SyntheticEvent<E>) => mixed,
-  onResetCapture?: ?(SyntheticEvent<E>) => mixed,
-  onSubmit?: ?(SyntheticEvent<E>) => mixed,
-  onSubmitCapture?: ?(SyntheticEvent<E>) => mixed,
+  onBeforeInput?: ?(SyntheticInputEvent<E>) => unknown,
+  onBeforeInputCapture?: ?(SyntheticInputEvent<E>) => unknown,
+  onChange?: ?(SyntheticEvent<E>) => unknown,
+  onChangeCapture?: ?(SyntheticEvent<E>) => unknown,
+  onInput?: ?(SyntheticEvent<E>) => unknown,
+  onInputCapture?: ?(SyntheticEvent<E>) => unknown,
+  onInvalid?: ?(SyntheticEvent<E>) => unknown,
+  onInvalidCapture?: ?(SyntheticEvent<E>) => unknown,
+  onReset?: ?(SyntheticEvent<E>) => unknown,
+  onResetCapture?: ?(SyntheticEvent<E>) => unknown,
+  onSubmit?: ?(SyntheticEvent<E>) => unknown,
+  onSubmitCapture?: ?(SyntheticEvent<E>) => unknown,
 
   // Image Events
-  onError?: ?(SyntheticEvent<E>) => mixed,
-  onErrorCapture?: ?(SyntheticEvent<E>) => mixed,
-  onLoad?: ?(SyntheticEvent<E>) => mixed,
-  onLoadCapture?: ?(SyntheticEvent<E>) => mixed,
+  onError?: ?(SyntheticEvent<E>) => unknown,
+  onErrorCapture?: ?(SyntheticEvent<E>) => unknown,
+  onLoad?: ?(SyntheticEvent<E>) => unknown,
+  onLoadCapture?: ?(SyntheticEvent<E>) => unknown,
 
   // Keyboard Events
-  onKeyDown?: ?(SyntheticKeyboardEvent<E>) => mixed,
-  onKeyDownCapture?: ?(SyntheticKeyboardEvent<E>) => mixed,
-  onKeyPress?: ?(SyntheticKeyboardEvent<E>) => mixed,
-  onKeyPressCapture?: ?(SyntheticKeyboardEvent<E>) => mixed,
-  onKeyUp?: ?(SyntheticKeyboardEvent<E>) => mixed,
-  onKeyUpCapture?: ?(SyntheticKeyboardEvent<E>) => mixed,
+  onKeyDown?: ?(SyntheticKeyboardEvent<E>) => unknown,
+  onKeyDownCapture?: ?(SyntheticKeyboardEvent<E>) => unknown,
+  onKeyPress?: ?(SyntheticKeyboardEvent<E>) => unknown,
+  onKeyPressCapture?: ?(SyntheticKeyboardEvent<E>) => unknown,
+  onKeyUp?: ?(SyntheticKeyboardEvent<E>) => unknown,
+  onKeyUpCapture?: ?(SyntheticKeyboardEvent<E>) => unknown,
 
   // Media Events
-  onAbort?: ?(SyntheticEvent<E>) => mixed,
-  onAbortCapture?: ?(SyntheticEvent<E>) => mixed,
-  onCanPlay?: ?(SyntheticEvent<E>) => mixed,
-  onCanPlayCapture?: ?(SyntheticEvent<E>) => mixed,
-  onCanPlayThrough?: ?(SyntheticEvent<E>) => mixed,
-  onCanPlayThroughCapture?: ?(SyntheticEvent<E>) => mixed,
-  onDurationChange?: ?(SyntheticEvent<E>) => mixed,
-  onDurationChangeCapture?: ?(SyntheticEvent<E>) => mixed,
-  onEmptied?: ?(SyntheticEvent<E>) => mixed,
-  onEmptiedCapture?: ?(SyntheticEvent<E>) => mixed,
-  onEncrypted?: ?(SyntheticEvent<E>) => mixed,
-  onEncryptedCapture?: ?(SyntheticEvent<E>) => mixed,
-  onEnded?: ?(SyntheticEvent<E>) => mixed,
-  onEndedCapture?: ?(SyntheticEvent<E>) => mixed,
-  onLoadedData?: ?(SyntheticEvent<E>) => mixed,
-  onLoadedDataCapture?: ?(SyntheticEvent<E>) => mixed,
-  onLoadedMetadata?: ?(SyntheticEvent<E>) => mixed,
-  onLoadedMetadataCapture?: ?(SyntheticEvent<E>) => mixed,
-  onLoadStart?: ?(SyntheticEvent<E>) => mixed,
-  onLoadStartCapture?: ?(SyntheticEvent<E>) => mixed,
-  onPause?: ?(SyntheticEvent<E>) => mixed,
-  onPauseCapture?: ?(SyntheticEvent<E>) => mixed,
-  onPlay?: ?(SyntheticEvent<E>) => mixed,
-  onPlayCapture?: ?(SyntheticEvent<E>) => mixed,
-  onPlaying?: ?(SyntheticEvent<E>) => mixed,
-  onPlayingCapture?: ?(SyntheticEvent<E>) => mixed,
-  onProgress?: ?(SyntheticEvent<E>) => mixed,
-  onProgressCapture?: ?(SyntheticEvent<E>) => mixed,
-  onRateChange?: ?(SyntheticEvent<E>) => mixed,
-  onRateChangeCapture?: ?(SyntheticEvent<E>) => mixed,
-  onResize?: ?(SyntheticEvent<E>) => mixed,
-  onResizeCapture?: ?(SyntheticEvent<E>) => mixed,
-  onSeeked?: ?(SyntheticEvent<E>) => mixed,
-  onSeekedCapture?: ?(SyntheticEvent<E>) => mixed,
-  onSeeking?: ?(SyntheticEvent<E>) => mixed,
-  onSeekingCapture?: ?(SyntheticEvent<E>) => mixed,
-  onStalled?: ?(SyntheticEvent<E>) => mixed,
-  onStalledCapture?: ?(SyntheticEvent<E>) => mixed,
-  onSuspend?: ?(SyntheticEvent<E>) => mixed,
-  onSuspendCapture?: ?(SyntheticEvent<E>) => mixed,
-  onTimeUpdate?: ?(SyntheticEvent<E>) => mixed,
-  onTimeUpdateCapture?: ?(SyntheticEvent<E>) => mixed,
-  onVolumeChange?: ?(SyntheticEvent<E>) => mixed,
-  onVolumeChangeCapture?: ?(SyntheticEvent<E>) => mixed,
-  onWaiting?: ?(SyntheticEvent<E>) => mixed,
-  onWaitingCapture?: ?(SyntheticEvent<E>) => mixed,
+  onAbort?: ?(SyntheticEvent<E>) => unknown,
+  onAbortCapture?: ?(SyntheticEvent<E>) => unknown,
+  onCanPlay?: ?(SyntheticEvent<E>) => unknown,
+  onCanPlayCapture?: ?(SyntheticEvent<E>) => unknown,
+  onCanPlayThrough?: ?(SyntheticEvent<E>) => unknown,
+  onCanPlayThroughCapture?: ?(SyntheticEvent<E>) => unknown,
+  onDurationChange?: ?(SyntheticEvent<E>) => unknown,
+  onDurationChangeCapture?: ?(SyntheticEvent<E>) => unknown,
+  onEmptied?: ?(SyntheticEvent<E>) => unknown,
+  onEmptiedCapture?: ?(SyntheticEvent<E>) => unknown,
+  onEncrypted?: ?(SyntheticEvent<E>) => unknown,
+  onEncryptedCapture?: ?(SyntheticEvent<E>) => unknown,
+  onEnded?: ?(SyntheticEvent<E>) => unknown,
+  onEndedCapture?: ?(SyntheticEvent<E>) => unknown,
+  onLoadedData?: ?(SyntheticEvent<E>) => unknown,
+  onLoadedDataCapture?: ?(SyntheticEvent<E>) => unknown,
+  onLoadedMetadata?: ?(SyntheticEvent<E>) => unknown,
+  onLoadedMetadataCapture?: ?(SyntheticEvent<E>) => unknown,
+  onLoadStart?: ?(SyntheticEvent<E>) => unknown,
+  onLoadStartCapture?: ?(SyntheticEvent<E>) => unknown,
+  onPause?: ?(SyntheticEvent<E>) => unknown,
+  onPauseCapture?: ?(SyntheticEvent<E>) => unknown,
+  onPlay?: ?(SyntheticEvent<E>) => unknown,
+  onPlayCapture?: ?(SyntheticEvent<E>) => unknown,
+  onPlaying?: ?(SyntheticEvent<E>) => unknown,
+  onPlayingCapture?: ?(SyntheticEvent<E>) => unknown,
+  onProgress?: ?(SyntheticEvent<E>) => unknown,
+  onProgressCapture?: ?(SyntheticEvent<E>) => unknown,
+  onRateChange?: ?(SyntheticEvent<E>) => unknown,
+  onRateChangeCapture?: ?(SyntheticEvent<E>) => unknown,
+  onResize?: ?(SyntheticEvent<E>) => unknown,
+  onResizeCapture?: ?(SyntheticEvent<E>) => unknown,
+  onSeeked?: ?(SyntheticEvent<E>) => unknown,
+  onSeekedCapture?: ?(SyntheticEvent<E>) => unknown,
+  onSeeking?: ?(SyntheticEvent<E>) => unknown,
+  onSeekingCapture?: ?(SyntheticEvent<E>) => unknown,
+  onStalled?: ?(SyntheticEvent<E>) => unknown,
+  onStalledCapture?: ?(SyntheticEvent<E>) => unknown,
+  onSuspend?: ?(SyntheticEvent<E>) => unknown,
+  onSuspendCapture?: ?(SyntheticEvent<E>) => unknown,
+  onTimeUpdate?: ?(SyntheticEvent<E>) => unknown,
+  onTimeUpdateCapture?: ?(SyntheticEvent<E>) => unknown,
+  onVolumeChange?: ?(SyntheticEvent<E>) => unknown,
+  onVolumeChangeCapture?: ?(SyntheticEvent<E>) => unknown,
+  onWaiting?: ?(SyntheticEvent<E>) => unknown,
+  onWaitingCapture?: ?(SyntheticEvent<E>) => unknown,
 
   // Mouse Events
-  onAuxClick?: ?(SyntheticMouseEvent<E>) => mixed,
-  onAuxClickCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onClick?: ?(SyntheticMouseEvent<E>) => mixed,
-  onClickCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onContextMenu?: ?(SyntheticMouseEvent<E>) => mixed,
-  onContextMenuCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onDoubleClick?: ?(SyntheticMouseEvent<E>) => mixed,
-  onDoubleClickCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onDrag?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragEnd?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragEndCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragEnter?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragEnterCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragExit?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragExitCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragLeave?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragLeaveCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragOver?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragOverCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragStart?: ?(SyntheticDragEvent<E>) => mixed,
-  onDragStartCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onDrop?: ?(SyntheticDragEvent<E>) => mixed,
-  onDropCapture?: ?(SyntheticDragEvent<E>) => mixed,
-  onMouseDown?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseDownCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseEnter?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseLeave?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseMove?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseMoveCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseOut?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseOutCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseOver?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseOverCapture?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseUp?: ?(SyntheticMouseEvent<E>) => mixed,
-  onMouseUpCapture?: ?(SyntheticMouseEvent<E>) => mixed,
+  onAuxClick?: ?(SyntheticMouseEvent<E>) => unknown,
+  onAuxClickCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onClick?: ?(SyntheticMouseEvent<E>) => unknown,
+  onClickCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onContextMenu?: ?(SyntheticMouseEvent<E>) => unknown,
+  onContextMenuCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onDoubleClick?: ?(SyntheticMouseEvent<E>) => unknown,
+  onDoubleClickCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onDrag?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragEnd?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragEndCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragEnter?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragEnterCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragExit?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragExitCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragLeave?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragLeaveCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragOver?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragOverCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragStart?: ?(SyntheticDragEvent<E>) => unknown,
+  onDragStartCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onDrop?: ?(SyntheticDragEvent<E>) => unknown,
+  onDropCapture?: ?(SyntheticDragEvent<E>) => unknown,
+  onMouseDown?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseDownCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseEnter?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseLeave?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseMove?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseMoveCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseOut?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseOutCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseOver?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseOverCapture?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseUp?: ?(SyntheticMouseEvent<E>) => unknown,
+  onMouseUpCapture?: ?(SyntheticMouseEvent<E>) => unknown,
 
   // Pointer Events
-  onGotPointerCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onGotPointerCaptureCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onLostPointerCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onLostPointerCaptureCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerCancel?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerCancelCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerDown?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerDownCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerEnter?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerLeave?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerMove?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerMoveCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerOut?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerOutCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerOver?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerOverCapture?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerUp?: ?(SyntheticPointerEvent<E>) => mixed,
-  onPointerUpCapture?: ?(SyntheticPointerEvent<E>) => mixed,
+  onGotPointerCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onGotPointerCaptureCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onLostPointerCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onLostPointerCaptureCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerCancel?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerCancelCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerDown?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerDownCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerEnter?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerLeave?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerMove?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerMoveCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerOut?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerOutCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerOver?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerOverCapture?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerUp?: ?(SyntheticPointerEvent<E>) => unknown,
+  onPointerUpCapture?: ?(SyntheticPointerEvent<E>) => unknown,
 
   // Selection Events
-  onSelect?: ?(SyntheticEvent<E>) => mixed,
-  onSelectCapture?: ?(SyntheticEvent<E>) => mixed,
+  onSelect?: ?(SyntheticEvent<E>) => unknown,
+  onSelectCapture?: ?(SyntheticEvent<E>) => unknown,
 
   // Toggle Events
-  onToggle?: ?(SyntheticEvent<E>) => mixed,
-  onToggleCapture?: ?(SyntheticEvent<E>) => mixed,
+  onToggle?: ?(SyntheticEvent<E>) => unknown,
+  onToggleCapture?: ?(SyntheticEvent<E>) => unknown,
 
   // Touch Events
-  onTouchCancel?: ?(SyntheticTouchEvent<E>) => mixed,
-  onTouchCancelCapture?: ?(SyntheticTouchEvent<E>) => mixed,
-  onTouchEnd?: ?(SyntheticTouchEvent<E>) => mixed,
-  onTouchEndCapture?: ?(SyntheticTouchEvent<E>) => mixed,
-  onTouchMove?: ?(SyntheticEvent<E>) => mixed,
-  onTouchMoveCapture?: ?(SyntheticEvent<E>) => mixed,
-  onTouchStart?: ?(SyntheticTouchEvent<E>) => mixed,
-  onTouchStartCapture?: ?(SyntheticTouchEvent<E>) => mixed,
+  onTouchCancel?: ?(SyntheticTouchEvent<E>) => unknown,
+  onTouchCancelCapture?: ?(SyntheticTouchEvent<E>) => unknown,
+  onTouchEnd?: ?(SyntheticTouchEvent<E>) => unknown,
+  onTouchEndCapture?: ?(SyntheticTouchEvent<E>) => unknown,
+  onTouchMove?: ?(SyntheticEvent<E>) => unknown,
+  onTouchMoveCapture?: ?(SyntheticEvent<E>) => unknown,
+  onTouchStart?: ?(SyntheticTouchEvent<E>) => unknown,
+  onTouchStartCapture?: ?(SyntheticTouchEvent<E>) => unknown,
 
   // Transition Events
-  onTransitionCancel?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionCancelCapture?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionEnd?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionEndCapture?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionRun?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionRunCapture?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionStart?: ?(SyntheticTransitionEvent<E>) => mixed,
-  onTransitionStartCapture?: ?(SyntheticTransitionEvent<E>) => mixed,
+  onTransitionCancel?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionCancelCapture?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionEnd?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionEndCapture?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionRun?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionRunCapture?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionStart?: ?(SyntheticTransitionEvent<E>) => unknown,
+  onTransitionStartCapture?: ?(SyntheticTransitionEvent<E>) => unknown,
 
   // UI Events
-  onScroll?: ?(SyntheticUIEvent<E>) => mixed,
-  onScrollCapture?: ?(SyntheticUIEvent<E>) => mixed,
+  onScroll?: ?(SyntheticUIEvent<E>) => unknown,
+  onScrollCapture?: ?(SyntheticUIEvent<E>) => unknown,
 
   // Wheel Events
-  onWheel?: ?(SyntheticWheelEvent<E>) => mixed,
-  onWheelCapture?: ?(SyntheticWheelEvent<E>) => mixed,
+  onWheel?: ?(SyntheticWheelEvent<E>) => unknown,
+  onWheelCapture?: ?(SyntheticWheelEvent<E>) => unknown,
 
   ...ReactDOM$CustomEvents<E>,
 |}>;
@@ -858,7 +859,7 @@ type ReactDOM$ReactSpecificProps = {|
     __html: ReactDOM$UserVisibleString,
   |},
   defaultChecked?: ?boolean,
-  defaultValue?: ?(string | number | $ReadOnlyArray<string>),
+  defaultValue?: ?(string | number | ReadonlyArray<string>),
   suppressContentEditableWarning?: ?boolean,
   suppressHydrationWarning?: ?boolean,
 |};
@@ -1050,7 +1051,7 @@ type ReactDOM$buttonProps = {|
   formTarget?: ?string,
   name?: ?string,
   type?: ?('submit' | 'reset' | 'button'),
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 type ReactDOM$buttonInstance = HTMLButtonElement;
 
@@ -1081,7 +1082,7 @@ type ReactDOM$colgroupInstance = HTMLTableColElement;
 
 type ReactDOM$dataProps = {|
   ...ReactDOM$HTMLElementProps,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 
 type ReactDOM$dataInstance = HTMLDataElement;
@@ -1111,8 +1112,8 @@ type ReactDOM$dfnInstance = HTMLElement;
 
 type ReactDOM$dialogProps = {|
   ...ReactDOM$HTMLElementProps,
-  onCancel?: ?(SyntheticEvent<HTMLDialogElement>) => mixed,
-  onClose?: ?(SyntheticEvent<HTMLDialogElement>) => mixed,
+  onCancel?: ?(SyntheticEvent<HTMLDialogElement>) => unknown,
+  onClose?: ?(SyntheticEvent<HTMLDialogElement>) => unknown,
   open?: ?boolean,
 |};
 type ReactDOM$dialogInstance = HTMLDialogElement;
@@ -1266,7 +1267,7 @@ type ReactDOM$inputProps = {|
   minLength?: ?number,
   multiple?: ?boolean,
   name?: ?string,
-  onChange?: ?(SyntheticInputEvent<HTMLInputElement>) => mixed,
+  onChange?: ?(SyntheticInputEvent<HTMLInputElement>) => unknown,
   pattern?: ?string,
   placeholder?: ?ReactDOM$UserVisibleString,
   readOnly?: ?boolean,
@@ -1275,7 +1276,7 @@ type ReactDOM$inputProps = {|
   src?: ?string,
   step?: ?(number | string),
   type?: ?string,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
   width?: ?(number | string),
 |};
 type ReactDOM$inputInstance = HTMLInputElement;
@@ -1313,7 +1314,7 @@ type ReactDOM$legendInstance = HTMLLegendElement;
 
 type ReactDOM$liProps = {|
   ...ReactDOM$HTMLElementProps,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 
 type ReactDOM$liInstance = HTMLLIElement;
@@ -1391,7 +1392,7 @@ type ReactDOM$meterProps = {|
   max?: ?(number | string),
   min?: ?(number | string),
   optimum?: ?number,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 type ReactDOM$meterInstance = HTMLMeterElement;
 
@@ -1436,7 +1437,7 @@ type ReactDOM$optionProps = {|
   disabled?: ?boolean,
   label?: ?ReactDOM$UserVisibleString,
   selected?: ?boolean,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 type ReactDOM$optionInstance = HTMLOptionElement;
 
@@ -1454,7 +1455,7 @@ type ReactDOM$pInstance = HTMLParagraphElement;
 type ReactDOM$paramProps = {|
   ...ReactDOM$SelfClosingHTMLElementProps,
   name?: ?string,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 type ReactDOM$paramInstance = HTMLParamElement;
 
@@ -1467,7 +1468,7 @@ type ReactDOM$preInstance = HTMLPreElement;
 type ReactDOM$progressProps = {|
   ...ReactDOM$HTMLElementProps,
   max?: ?(number | string),
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 type ReactDOM$progressInstance = HTMLProgressElement;
 
@@ -1514,10 +1515,10 @@ type ReactDOM$selectProps = {|
   form?: ?string,
   multiple?: ?boolean,
   name?: ?string,
-  onChange?: ?(SyntheticEvent<HTMLSelectElement>) => mixed,
+  onChange?: ?(SyntheticEvent<HTMLSelectElement>) => unknown,
   required?: ?boolean,
   size?: ?number,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
 |};
 type ReactDOM$selectInstance = HTMLSelectElement;
 
@@ -1608,12 +1609,12 @@ type ReactDOM$textareaProps = {|
   maxLength?: ?number,
   minLength?: ?number,
   name?: ?string,
-  onChange?: ?(SyntheticEvent<HTMLTextAreaElement>) => mixed,
+  onChange?: ?(SyntheticEvent<HTMLTextAreaElement>) => unknown,
   placeholder?: ?ReactDOM$UserVisibleString,
   readOnly?: ?boolean,
   required?: ?boolean,
   rows?: ?number,
-  value?: ?(string | $ReadOnlyArray<string> | number),
+  value?: ?(string | ReadonlyArray<string> | number),
   wrap?: ?string,
 |};
 type ReactDOM$textareaInstance = HTMLTextAreaElement;
diff --git a/flow-typed/environments/node.js b/flow-typed/environments/node.js
index 99e36654..55842cff 100644
--- a/flow-typed/environments/node.js
+++ b/flow-typed/environments/node.js
@@ -12,7 +12,7 @@ interface ErrnoError extends Error {
   syscall?: string;
 }
 
-type Node$Conditional<T: boolean, IfTrue, IfFalse> = T extends true
+type Node$Conditional<T extends boolean, IfTrue, IfFalse> = T extends true
   ? IfTrue
   : T extends false
     ? IfFalse
@@ -697,7 +697,7 @@ declare module "crypto" {
     callback: (err: ?Error, buffer: Buffer) => void
   ): void
   declare function randomUUID(
-    options?: $ReadOnly<{|disableEntropyCache?: boolean|}>,
+    options?: Readonly<{|disableEntropyCache?: boolean|}>,
   ): string;
   declare function timingSafeEqual(
     a: Buffer | $TypedArray | DataView,
@@ -730,7 +730,7 @@ declare class dgram$Socket extends events$EventEmitter {
     msg: Buffer,
     port: number,
     address: string,
-    callback?: (err: ?Error, bytes: any) => mixed,
+    callback?: (err: ?Error, bytes: any) => unknown,
   ): void;
   send(
     msg: Buffer,
@@ -738,7 +738,7 @@ declare class dgram$Socket extends events$EventEmitter {
     length: number,
     port: number,
     address: string,
-    callback?: (err: ?Error, bytes: any) => mixed,
+    callback?: (err: ?Error, bytes: any) => unknown,
   ): void;
   setBroadcast(flag: boolean): void;
   setMulticastLoopback(flag: boolean): void;
@@ -1316,7 +1316,7 @@ declare module "fs" {
   declare function copyFile(src: string, dest: string, flags?: number, callback: (err: ErrnoError) => void): void;
   declare function copyFileSync(src: string, dest: string, flags?: number): void;
 
-  declare type GlobOptions<WithFileTypes: boolean> = $ReadOnly<{
+  declare type GlobOptions<WithFileTypes extends boolean> = Readonly<{
     /**
      * Current working directory.
      * @default process.cwd()
@@ -1336,7 +1336,7 @@ declare module "fs" {
      */
     exclude?:
       | ((fileName: Node$Conditional<WithFileTypes, Dirent, string>) => boolean)
-      | $ReadOnlyArray<string>,
+      | ReadonlyArray<string>,
     ...
   }>;
 
@@ -1354,12 +1354,12 @@ declare module "fs" {
    * @since v22.0.0
    */
   declare function glob(
-    pattern: string | $ReadOnlyArray<string>,
+    pattern: string | ReadonlyArray<string>,
     callback: (err: ?ErrnoError, matches: Array<string>) => void,
   ): void;
 
-  declare function glob<WithFileTypes: boolean = false>(
-    pattern: string | $ReadOnlyArray<string>,
+  declare function glob<WithFileTypes extends boolean = false>(
+    pattern: string | ReadonlyArray<string>,
     options: GlobOptions<WithFileTypes>,
     callback: (
       err: ?ErrnoError,
@@ -1376,8 +1376,8 @@ declare module "fs" {
    * @since v22.0.0
    * @returns paths of files that match the pattern.
    */
-  declare function globSync<WithFileTypes: boolean = false>(
-    pattern: string | $ReadOnlyArray<string>,
+  declare function globSync<WithFileTypes extends boolean = false>(
+    pattern: string | ReadonlyArray<string>,
     options?: GlobOptions<WithFileTypes>,
   ): Node$Conditional<WithFileTypes, Array<Dirent>, Array<string>>;
 
@@ -1448,7 +1448,7 @@ declare module "fs" {
     close(): Promise<void>;
     datasync(): Promise<void>;
     fd: number;
-    read<T: Buffer | Uint8Array>(
+    read<T extends Buffer | Uint8Array>(
       buffer: T,
       offset: number,
       length: number,
@@ -1483,8 +1483,8 @@ declare module "fs" {
     ftruncate(filehandle: FileHandle, len?: number): Promise<void>,
     futimes(filehandle: FileHandle, atime: number | string | Date, mtime: number | string | Date): Promise<void>,
     lchmod(path: FSPromisePath, mode: number): Promise<void>,
-    glob<WithFileTypes: boolean = false>(
-      pattern: string | $ReadOnlyArray<string>,
+    glob<WithFileTypes extends boolean = false>(
+      pattern: string | ReadonlyArray<string>,
       options?: GlobOptions<WithFileTypes>,
     ): Node$Conditional<
       WithFileTypes,
@@ -1501,7 +1501,7 @@ declare module "fs" {
     }): Promise<void>,
     mkdtemp(prefix: string, options?: EncodingOptions): Promise<string>,
     open(path: FSPromisePath, flags?: string | number, mode?: number): Promise<FileHandle>,
-    read<T: Buffer | Uint8Array>(
+    read<T extends Buffer | Uint8Array>(
       filehandle: FileHandle,
       buffer: T,
       offset: number,
@@ -1533,7 +1533,7 @@ declare module "fs" {
     truncate(path: FSPromisePath, len?: number): Promise<void>,
     unlink(path: FSPromisePath): Promise<void>,
     utimes(path: FSPromisePath, atime: number | string | Date, mtime: number | string | Date): Promise<void>,
-    write<T: Buffer | Uint8Array>(
+    write<T extends Buffer | Uint8Array>(
       filehandle: FileHandle,
       buffer: T,
       offset: number,
@@ -1566,7 +1566,8 @@ type http$agentOptions = {
 declare class http$Agent<+SocketT = net$Socket> {
   constructor(options: http$agentOptions): void;
   destroy(): void;
-  freeSockets: { [name: string]: $ReadOnlyArray<SocketT>, ... };
+  // $FlowFixMe[incompatible-variance]
+  freeSockets: { [name: string]: ReadonlyArray<SocketT>, ... };
   getName(options: {
     host: string,
     port: number,
@@ -1575,8 +1576,10 @@ declare class http$Agent<+SocketT = net$Socket> {
   }): string;
   maxFreeSockets: number;
   maxSockets: number;
-  requests: { [name: string]: $ReadOnlyArray<http$ClientRequest<SocketT>>, ... };
-  sockets: { [name: string]: $ReadOnlyArray<SocketT>, ... };
+  // $FlowFixMe[incompatible-variance]
+  requests: { [name: string]: ReadonlyArray<http$ClientRequest<SocketT>>, ... };
+  // $FlowFixMe[incompatible-variance]
+  sockets: { [name: string]: ReadonlyArray<SocketT>, ... };
 }
 
 declare class http$IncomingMessage<SocketT = net$Socket> extends stream$Readable {
@@ -1651,7 +1654,7 @@ declare class http$Server extends net$Server {
     ...
   }, callback?: Function): this;
   listening: boolean;
-  close(callback?: (error: ?Error) => mixed): this;
+  close(callback?: (error: ?Error) => unknown): this;
   closeAllConnections(): void;
   closeIdleConnections(): void;
   maxHeadersCount: number;
@@ -1679,7 +1682,7 @@ declare class https$Server extends tls$Server {
     ipv6Only?: boolean,
     ...
   }, callback?: Function): this;
-  close(callback?: (error: ?Error) => mixed): this;
+  close(callback?: (error: ?Error) => unknown): this;
   closeAllConnections(): void;
   closeIdleConnections(): void;
   keepAliveTimeout: number;
@@ -1692,7 +1695,7 @@ type requestOptions = {|
   auth?: string,
   defaultPort?: number,
   family?: number,
-  headers?: { [key: string] : mixed, ... },
+  headers?: { [key: string] : unknown, ... },
   host?: string,
   hostname?: string,
   localAddress?: string,
@@ -1811,10 +1814,10 @@ declare class net$Socket extends stream$Duplex {
   bufferSize: number;
   bytesRead: number;
   bytesWritten: number;
-  connect(path: string, connectListener?: () => mixed): net$Socket;
-  connect(port: number, host?: string, connectListener?: () => mixed): net$Socket;
-  connect(port: number, connectListener?: () => mixed): net$Socket;
-  connect(options: Object, connectListener?: () => mixed): net$Socket;
+  connect(path: string, connectListener?: () => unknown): net$Socket;
+  connect(port: number, host?: string, connectListener?: () => unknown): net$Socket;
+  connect(port: number, connectListener?: () => unknown): net$Socket;
+  connect(options: Object, connectListener?: () => unknown): net$Socket;
   destroyed: boolean;
   end(
     chunkOrEncodingOrCallback?: Buffer | Uint8Array | string | (data: any) => void,
@@ -1866,7 +1869,7 @@ type net$connectOptions = {
     domain: string,
     options?: ?number | ?Object,
     callback?: (err: ?Error, address: string, family: number) => void
-  ) => mixed,
+  ) => unknown,
   path?: string,
   ...
 };
@@ -2116,7 +2119,7 @@ declare class stream$Readable extends stream$Stream {
   destroy(error?: Error): this;
   isPaused(): boolean;
   pause(): this;
-  pipe<T: stream$Writable>(dest: T, options?: { end? : boolean, ... }): T;
+  pipe<T extends stream$Writable>(dest: T, options?: { end? : boolean, ... }): T;
   read(size?: number): ?(string | Buffer);
   readable: boolean;
   readableHighWaterMark: number;
@@ -2229,25 +2232,25 @@ declare module "stream" {
     },
     callback: (error?: Error) => void,
   ): () => void;
-  declare function pipeline<T: stream$Writable>(
+  declare function pipeline<T extends stream$Writable>(
     s1: stream$Readable,
     last: T,
     cb: (error?: Error) => void,
   ): T;
-  declare function pipeline<T: stream$Writable>(
+  declare function pipeline<T extends stream$Writable>(
     s1: stream$Readable,
     s2: stream$Duplex,
     last: T,
     cb: (error?: Error) => void,
   ): T;
-  declare function pipeline<T: stream$Writable>(
+  declare function pipeline<T extends stream$Writable>(
     s1: stream$Readable,
     s2: stream$Duplex,
     s3: stream$Duplex,
     last: T,
     cb: (error?: Error) => void,
   ): T;
-  declare function pipeline<T: stream$Writable>(
+  declare function pipeline<T extends stream$Writable>(
     s1: stream$Readable,
     s2: stream$Duplex,
     s3: stream$Duplex,
@@ -2255,7 +2258,7 @@ declare module "stream" {
     last: T,
     cb: (error?: Error) => void,
   ): T;
-  declare function pipeline<T: stream$Writable>(
+  declare function pipeline<T extends stream$Writable>(
     s1: stream$Readable,
     s2: stream$Duplex,
     s3: stream$Duplex,
@@ -2264,7 +2267,7 @@ declare module "stream" {
     last: T,
     cb: (error?: Error) => void,
   ): T;
-  declare function pipeline<T: stream$Writable>(
+  declare function pipeline<T extends stream$Writable>(
     s1: stream$Readable,
     s2: stream$Duplex,
     s3: stream$Duplex,
@@ -2331,7 +2334,7 @@ declare module "stream" {
       options?: StreamPipelineOptions,
     ): Promise<void>,
     pipeline(
-      streams: $ReadOnlyArray<stream$Stream>,
+      streams: ReadonlyArray<stream$Stream>,
       options?: StreamPipelineOptions,
     ): Promise<void>;
     ...
@@ -2441,7 +2444,7 @@ type tls$connectOptions = {
     domain: string,
     options?: ?number | ?Object,
     callback?: (err: ?Error, address: string, family: number) => void
-  ) => mixed,
+  ) => unknown,
   requestOCSP?: boolean,
   ...
 };
@@ -2588,7 +2591,7 @@ declare module "url" {
     append(name: string, value: string): void;
     delete(name: string, value?: void): void;
     entries(): Iterator<[string, string]>;
-    forEach<This>(callback: (this : This, value: string, name: string, searchParams: URLSearchParams) => mixed, thisArg?: This): void;
+    forEach<This>(callback: (this : This, value: string, name: string, searchParams: URLSearchParams) => unknown, thisArg?: This): void;
     get(name: string): string | null;
     getAll(name: string): string[];
     has(name: string, value?: string): boolean;
@@ -2750,45 +2753,45 @@ declare module "util" {
   }
 
   declare var types: {
-    isAnyArrayBuffer: (value: mixed) => boolean;
-    isArgumentsObject:(value: mixed) => boolean;
-    isArrayBuffer:(value: mixed) => boolean;
-    isAsyncFunction:(value: mixed) => boolean;
-    isBigInt64Array:(value: mixed) => boolean;
-    isBigUint64Array:(value: mixed) => boolean;
-    isBooleanObject:(value: mixed) => boolean;
-    isBoxedPrimitive:(value: mixed) => boolean;
-    isDataView:(value: mixed) => boolean;
-    isDate:(value: mixed) => boolean;
-    isExternal:(value: mixed) => boolean;
-    isFloat32Array:(value: mixed) => boolean;
-    isFloat64Array:(value: mixed) => boolean;
-    isGeneratorFunction:(value: mixed) => boolean;
-    isGeneratorObject:(value: mixed) => boolean;
-    isInt8Array:(value: mixed) => boolean;
-    isInt16Array:(value: mixed) => boolean;
-    isInt32Array:(value: mixed) => boolean;
-    isMap:(value: mixed) => boolean;
-    isMapIterator:(value: mixed) => boolean;
-    isModuleNamespaceObject:(value: mixed) => boolean;
-    isNativeError:(value: mixed) => boolean;
-    isNumberObject:(value: mixed) => boolean;
-    isPromise:(value: mixed) => boolean;
-    isProxy:(value: mixed) => boolean;
-    isRegExp:(value: mixed) => boolean;
-    isSet:(value: mixed) => boolean;
-    isSetIterator:(value: mixed) => boolean;
-    isSharedArrayBuffer:(value: mixed) => boolean;
-    isStringObject:(value: mixed) => boolean;
-    isSymbolObject:(value: mixed) => boolean;
-    isTypedArray:(value: mixed) => boolean;
-    isUint8Array:(value: mixed) => boolean;
-    isUint8ClampedArray:(value: mixed) => boolean;
-    isUint16Array:(value: mixed) => boolean;
-    isUint32Array:(value: mixed) => boolean;
-    isWeakMap:(value: mixed) => boolean;
-    isWeakSet:(value: mixed) => boolean;
-    isWebAssemblyCompiledModule:(value: mixed) => boolean;
+    isAnyArrayBuffer: (value: unknown) => boolean;
+    isArgumentsObject:(value: unknown) => boolean;
+    isArrayBuffer:(value: unknown) => boolean;
+    isAsyncFunction:(value: unknown) => boolean;
+    isBigInt64Array:(value: unknown) => boolean;
+    isBigUint64Array:(value: unknown) => boolean;
+    isBooleanObject:(value: unknown) => boolean;
+    isBoxedPrimitive:(value: unknown) => boolean;
+    isDataView:(value: unknown) => boolean;
+    isDate:(value: unknown) => boolean;
+    isExternal:(value: unknown) => boolean;
+    isFloat32Array:(value: unknown) => boolean;
+    isFloat64Array:(value: unknown) => boolean;
+    isGeneratorFunction:(value: unknown) => boolean;
+    isGeneratorObject:(value: unknown) => boolean;
+    isInt8Array:(value: unknown) => boolean;
+    isInt16Array:(value: unknown) => boolean;
+    isInt32Array:(value: unknown) => boolean;
+    isMap:(value: unknown) => boolean;
+    isMapIterator:(value: unknown) => boolean;
+    isModuleNamespaceObject:(value: unknown) => boolean;
+    isNativeError:(value: unknown) => boolean;
+    isNumberObject:(value: unknown) => boolean;
+    isPromise:(value: unknown) => boolean;
+    isProxy:(value: unknown) => boolean;
+    isRegExp:(value: unknown) => boolean;
+    isSet:(value: unknown) => boolean;
+    isSetIterator:(value: unknown) => boolean;
+    isSharedArrayBuffer:(value: unknown) => boolean;
+    isStringObject:(value: unknown) => boolean;
+    isSymbolObject:(value: unknown) => boolean;
+    isTypedArray:(value: unknown) => boolean;
+    isUint8Array:(value: unknown) => boolean;
+    isUint8ClampedArray:(value: unknown) => boolean;
+    isUint16Array:(value: unknown) => boolean;
+    isUint32Array:(value: unknown) => boolean;
+    isWeakMap:(value: unknown) => boolean;
+    isWeakSet:(value: unknown) => boolean;
+    isWebAssemblyCompiledModule:(value: unknown) => boolean;
     ...
   }
 }
@@ -3438,13 +3441,13 @@ declare class Process extends events$EventEmitter {
   domain? : domain$Domain;
   env : { [key: string] : string | void, ... };
   emitWarning(warning: string | Error): void;
-  emitWarning(warning: string, typeOrCtor: string | (...empty) => mixed): void;
-  emitWarning(warning: string, type: string, codeOrCtor: string | (...empty) => mixed): void;
+  emitWarning(warning: string, typeOrCtor: string | (...empty) => unknown): void;
+  emitWarning(warning: string, type: string, codeOrCtor: string | (...empty) => unknown): void;
   emitWarning(
     warning: string,
     type: string,
     code: string,
-    ctor?: (...empty) => mixed
+    ctor?: (...empty) => unknown
   ): void;
   execArgv : Array<string>;
   execPath : string;
@@ -3471,7 +3474,7 @@ declare class Process extends events$EventEmitter {
     external : number,
     ...
   };
-  nextTick: <T>(cb: (...T) => mixed, ...T) => void;
+  nextTick: <T>(cb: (...T) => unknown, ...T) => void;
   pid : number;
   platform : string;
   release : {
@@ -3488,7 +3491,7 @@ declare class Process extends events$EventEmitter {
   setegid? : (id : number | string) => void;
   seteuid? : (id : number | string) => void;
   setgid? : (id : number | string) => void;
-  setgroups? : <Group: string | number>(groups : Array<Group>) => void;
+  setgroups? : <Group extends string | number>(groups : Array<Group>) => void;
   setuid? : (id : number | string) => void;
   stderr : stream$Writable | tty$WriteStream;
   stdin : stream$Readable | tty$ReadStream;
@@ -3509,7 +3512,7 @@ declare var process: Process;
 declare var __filename: string;
 declare var __dirname: string;
 
-declare function setImmediate(callback: ((...args: Array<any>) => mixed), ...args: Array<any>): Object;
+declare function setImmediate(callback: ((...args: Array<any>) => unknown), ...args: Array<any>): Object;
 declare function clearImmediate(immediateObject: any): Object;
 
 // https://nodejs.org/api/esm.html#node-imports
diff --git a/flow-typed/environments/serviceworkers.js b/flow-typed/environments/serviceworkers.js
index f26c12ed..76ed27fa 100644
--- a/flow-typed/environments/serviceworkers.js
+++ b/flow-typed/environments/serviceworkers.js
@@ -20,7 +20,7 @@ declare class Client {
 }
 
 declare class ExtendableEvent extends Event {
-  waitUntil(f: Promise<mixed>): void,
+  waitUntil(f: Promise<unknown>): void,
 }
 
 type NotificationEvent$Init = {
@@ -140,7 +140,7 @@ declare class ServiceWorkerRegistration extends EventTarget {
   +updateViaCache: ServiceWorkerUpdateViaCache,
   +pushManager: PushManager,
 
-  getNotifications?: (filter?: GetNotificationOptions) => Promise<$ReadOnlyArray<Notification>>,
+  getNotifications?: (filter?: GetNotificationOptions) => Promise<ReadonlyArray<Notification>>,
   showNotification?: (title: string, options?: NotificationOptions) => Promise<void>,
   update(): Promise<void>,
   unregister(): Promise<boolean>,
diff --git a/flow-typed/environments/web-animations.js b/flow-typed/environments/web-animations.js
index 71824960..567db936 100644
--- a/flow-typed/environments/web-animations.js
+++ b/flow-typed/environments/web-animations.js
@@ -134,9 +134,9 @@ declare class Animation extends EventTarget {
   +pending: boolean;
   +ready: Promise<Animation>;
   +finished: Promise<Animation>;
-  onfinish: ?(ev: AnimationPlaybackEvent) => mixed;
-  oncancel: ?(ev: AnimationPlaybackEvent) => mixed;
-  onremove: ?(ev: AnimationPlaybackEvent) => mixed;
+  onfinish: ?(ev: AnimationPlaybackEvent) => unknown;
+  oncancel: ?(ev: AnimationPlaybackEvent) => unknown;
+  onremove: ?(ev: AnimationPlaybackEvent) => unknown;
   cancel(): void;
   finish(): void;
   play(): void;
diff --git a/flow-typed/environments/webassembly.js b/flow-typed/environments/webassembly.js
index a880854a..10801356 100644
--- a/flow-typed/environments/webassembly.js
+++ b/flow-typed/environments/webassembly.js
@@ -16,7 +16,7 @@ type ResultObject = {
 
 // https://github.com/WebAssembly/design/blob/master/JS.md#exported-function-exotic-objects
 declare class ExportedFunctionExoticObject extends Function {
-  (): mixed;
+  (): unknown;
 }
 
 declare class WebAssembly$Module {
diff --git a/flow-typed/npm/styleq.js b/flow-typed/npm/styleq.js
index 8c4d590c..30cdb163 100644
--- a/flow-typed/npm/styleq.js
+++ b/flow-typed/npm/styleq.js
@@ -11,14 +11,14 @@ type InlineStyle = {
   [key: string]: string | number
 };
 
-type StylesArray<+T> = T | $ReadOnlyArray<StylesArray<T>>;
+type StylesArray<+T> = T | ReadonlyArray<StylesArray<T>>;
 type Styles = StylesArray<?{ ... } | boolean>;
 type Style<+T = { ... }> = StylesArray<boolean | ?T>;
 
 type StyleqOptions = {
   disableCache?: boolean,
   disableMix?: boolean,
-  transform?: (mixed) => { ... }
+  transform?: (unknown) => { ... }
 };
 
 type StyleqResult = [
@@ -30,7 +30,7 @@ type StyleqResult = [
 type Styleq = (styles: Styles) => StyleqResult;
 
 type IStyleq = {
-  (...styles: $ReadOnlyArray<Styles>): StyleqResult,
+  (...styles: ReadonlyArray<Styles>): StyleqResult,
   factory: (options?: StyleqOptions) => Styleq
 };
 
diff --git a/package-lock.json b/package-lock.json
index 066533fe..9b61b131 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -32,7 +32,7 @@
         "eslint-plugin-react": "^7.33.1",
         "eslint-plugin-react-hooks": "6.1.0-canary-12bc60f5-20250613",
         "flow-api-translator": "^0.32.1",
-        "flow-bin": "^0.270.0",
+        "flow-bin": "^0.307.1",
         "glob": "^11.1.0",
         "hermes-eslint": "^0.32.0",
         "husky": "^8.0.0",
@@ -393,7 +393,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.1.0.tgz",
       "integrity": "sha512-FS+XFBNvn3GTAWq26joslQgWNoFu08F4kl0J4CgdNKADkdSGXQyTCnKteIAJy96Br6YbpEU1LSzV5dYtjMkMDg==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -581,7 +580,6 @@
       "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.1.tgz",
       "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
       "dev": true,
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -827,7 +825,6 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -839,7 +836,6 @@
       "version": "19.2.1",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.1.tgz",
       "integrity": "sha512-DGrYcCWK7tvYMnWh79yrPHt+vdx9tY+1gPZa7nJQtO/p8bLTDaHp4dzwEhQB7pZ4Xe3ok4XKuEPrVuc+wlpkmw==",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -881,7 +877,6 @@
       "version": "7.2.6",
       "resolved": "https://registry.npmjs.org/vite/-/vite-7.2.6.tgz",
       "integrity": "sha512-tI2l/nFHC5rLh7+5+o7QjKjSR04ivXDF4jcgV0f/bTQ+OJiITy5S6gaynVsEM+7RqzufMnVbIon6Sr5x1SDYaQ==",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.5.0",
@@ -1127,7 +1122,6 @@
       "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.29.0.tgz",
       "integrity": "sha512-cZ0Iq3OzFUPpgszzDr1G1aJV5UMIZ4VygJ2Az252q4Rdf5cQMhYEIKArWY/oUjMhQmosM8ygOovNq7gvA9CdCg==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@algolia/client-common": "5.29.0",
         "@algolia/requester-browser-xhr": "5.29.0",
@@ -1304,7 +1298,6 @@
       "version": "7.28.5",
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -3512,7 +3505,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -3535,7 +3527,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -3616,7 +3607,6 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
       "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -3980,7 +3970,6 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
       "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -4981,7 +4970,6 @@
       "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.8.1.tgz",
       "integrity": "sha512-oByRkSZzeGNQByCMaX+kif5Nl2vmtj2IHQI2fWjCfCootsdKZDPFLonhIp5s3IGJO7PLUfe0POyw0Xh/RrGXJA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@docusaurus/core": "3.8.1",
         "@docusaurus/logger": "3.8.1",
@@ -8325,7 +8313,6 @@
       "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.0.tgz",
       "integrity": "sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/mdx": "^2.0.0"
       },
@@ -9636,7 +9623,6 @@
       "resolved": "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz",
       "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/core": "^7.21.3",
         "@svgr/babel-preset": "8.1.0",
@@ -9786,6 +9772,7 @@
       "integrity": "sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.10.4",
         "@babel/runtime": "^7.12.5",
@@ -9806,6 +9793,7 @@
       "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -9819,6 +9807,7 @@
       "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "ansi-regex": "^5.0.1",
         "ansi-styles": "^5.0.0",
@@ -9833,7 +9822,8 @@
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
       "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@testing-library/react": {
       "version": "16.3.0",
@@ -9898,14 +9888,14 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
       "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
       "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/parser": "^7.20.7",
         "@babel/types": "^7.20.7",
@@ -10252,7 +10242,6 @@
       "version": "19.2.7",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.7.tgz",
       "integrity": "sha512-MWtvHrGZLFttgeEj28VXHxpmwYbor/ATPYbBfSFZEIRK0ecCFLl2Qo55z52Hss+UV9CRN7trSeq1zbgx7YDWWg==",
-      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -11458,7 +11447,6 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -11542,7 +11530,6 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
       "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -11607,7 +11594,6 @@
       "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.29.0.tgz",
       "integrity": "sha512-E2l6AlTWGznM2e7vEE6T6hzObvEyXukxMOlBmVlMyixZyK1umuO/CiVc6sDBbzVH0oEviCE5IfVY1oZBmccYPQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@algolia/client-abtesting": "5.29.0",
         "@algolia/client-analytics": "5.29.0",
@@ -11780,6 +11766,7 @@
       "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "dequal": "^2.0.3"
       }
@@ -12801,7 +12788,6 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -14198,7 +14184,6 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
       "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -15248,7 +15233,8 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/dom-converter": {
       "version": "0.2.0",
@@ -15861,7 +15847,6 @@
       "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
       "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -15976,7 +15961,6 @@
       "integrity": "sha512-VGMpFQGUQWYT9LfnPcX8ouFojyrZ/2w3K5BucvxL/spdNehccKhB4jUyB1yBCXpr2XFm0jkECxgrpXBW2ipoAw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.44.0",
         "@typescript-eslint/types": "8.44.0",
@@ -16269,7 +16253,6 @@
       "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@rtsao/scc": "^1.1.0",
         "array-includes": "^3.1.9",
@@ -16961,7 +16944,6 @@
       "resolved": "https://registry.npmjs.org/expo/-/expo-53.0.22.tgz",
       "integrity": "sha512-sJ2I4W/e5iiM4u/wYCe3qmW4D7WPCRqByPDD0hJcdYNdjc9HFFFdO4OAudZVyC/MmtoWZEIH5kTJP1cw9FjzYA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.20.0",
         "@expo/cli": "0.24.21",
@@ -17100,7 +17082,6 @@
       "resolved": "https://registry.npmjs.org/expo-font/-/expo-font-13.3.2.tgz",
       "integrity": "sha512-wUlMdpqURmQ/CNKK/+BIHkDA5nGjMqNlYmW0pJFXY/KE/OG80Qcavdu2sHsL4efAIiNGvYdBS10WztuQYU4X0A==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fontfaceobserver": "^2.1.0"
       },
@@ -17882,9 +17863,9 @@
       }
     },
     "node_modules/flow-bin": {
-      "version": "0.270.0",
-      "resolved": "https://registry.npmjs.org/flow-bin/-/flow-bin-0.270.0.tgz",
-      "integrity": "sha512-luYf2Sv5zD7xJkAgU59UbBhfb3mCVhqLK5qZgLg6NN2QIj0pJp9H3OplRbrD+zts7MA+vPIlP83ktYhm57IhRA==",
+      "version": "0.307.1",
+      "resolved": "https://registry.npmjs.org/flow-bin/-/flow-bin-0.307.1.tgz",
+      "integrity": "sha512-0AglecFYaFu5ooF1IJmm4SBUZO7sopMU0jTr/Bburm/XxkJUtql+MDpwqKBFe1DTd2I/3kBzqOIFgwsZ8gS7tw==",
       "dev": true,
       "license": "MIT",
       "bin": {
@@ -19085,7 +19066,6 @@
       "integrity": "sha512-3ljktN2ek+bRRsPAcMeqMEJou6s2MRe6VuLkLsXDXuVrJfRZ7V2VUw41T9uAt9lcA2xaJP4yykYAnMg15nsRPw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esrecurse": "^4.3.0",
         "hermes-estree": "0.32.1",
@@ -22740,6 +22720,7 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -27433,7 +27414,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -28349,7 +28329,6 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz",
       "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -28902,7 +28881,6 @@
       "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.0.tgz",
       "integrity": "sha512-ujSB9uXHJKzM/2GBuE0hBOUgC77CN3Bnpqa+g80bkv3T3A93wL/xlzDATHhnhkzifz/UE2SNOvmbTz5hSkDlHw==",
       "license": "MIT",
-      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -28919,7 +28897,6 @@
       "integrity": "sha512-B5vzcDyTA/T0R7LGMSkLTp3VtRCEe1NItzsM6L/4gDOBGzDDMMMOwxRxogwL9xL07GPBOJrzlggwFaSQOhLVLw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "hermes-estree": "0.25.0",
         "hermes-parser": "0.25.0",
@@ -29325,7 +29302,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.0.0.tgz",
       "integrity": "sha512-V8AVnmPIICiWpGfm6GLzCR/W5FXLchHop40W4nXBmdlEceh16rCN8O8LNWm5bh5XUX91fh7KpA+W0TgMKmgTpQ==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -29366,7 +29342,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.0.0.tgz",
       "integrity": "sha512-4GV5sHFG0e/0AD4X+ySy6UJd3jVl1iNsNHdpad0qhABJ11twS3TTBnseqsKurKcsNqCEFeGL3uLpVChpIO3QfQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "scheduler": "^0.25.0"
       },
@@ -29428,7 +29403,6 @@
       "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz",
       "integrity": "sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/react": "*"
       },
@@ -29457,7 +29431,6 @@
       "resolved": "https://registry.npmjs.org/react-native/-/react-native-0.79.5.tgz",
       "integrity": "sha512-jVihwsE4mWEHZ9HkO1J2eUZSwHyDByZOqthwnGrVZCh6kTQBCm4v8dicsyDa6p0fpWNE5KicTcpX/XXl0ASJFg==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/create-cache-key-function": "^29.7.0",
         "@react-native/assets-registry": "0.79.5",
@@ -29689,7 +29662,6 @@
       "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz",
       "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.12.13",
         "history": "^4.9.0",
@@ -31110,7 +31082,6 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
       "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -33099,7 +33070,6 @@
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -33519,7 +33489,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
       "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -33585,7 +33554,6 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.48.1.tgz",
       "integrity": "sha512-PC0PDZfJg8sP7cmKe6L3QIL8GZwU5aRvUFedqSIpw3B+QjRSUZeeITC2M5XKeMXEzL6wccN196iy3JLwKNvDVA==",
       "dev": true,
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.48.1",
         "@typescript-eslint/types": "8.48.1",
@@ -34551,7 +34519,6 @@
       "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.99.9.tgz",
       "integrity": "sha512-brOPwM3JnmOa+7kd3NsmOUOwbDAj8FT9xDsG3IW0MgbN9yZV7Oi/s/+MNQ/EcSMqw7qfoRyXPoeEWT8zLVdVGg==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.6",
@@ -35391,7 +35358,6 @@
       "integrity": "sha512-2eHWfjaoXgTBC2jNM1LRef62VQa0umtvRiDSk6HSzW7RvS5YtkabJrwYLLEKWBc8a5U2PTSCs+dJjUTJdlHsWQ==",
       "devOptional": true,
       "license": "ISC",
-      "peer": true,
       "engines": {
         "node": ">= 14"
       }
@@ -35480,7 +35446,6 @@
       "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
diff --git a/package.json b/package.json
index 4646631f..18146d8e 100644
--- a/package.json
+++ b/package.json
@@ -35,7 +35,7 @@
     "eslint-plugin-react": "^7.33.1",
     "eslint-plugin-react-hooks": "6.1.0-canary-12bc60f5-20250613",
     "flow-api-translator": "^0.32.1",
-    "flow-bin": "^0.270.0",
+    "flow-bin": "^0.307.1",
     "glob": "^11.1.0",
     "hermes-eslint": "^0.32.0",
     "husky": "^8.0.0",
diff --git a/packages/react-strict-animated/src/native/Animation.js b/packages/react-strict-animated/src/native/Animation.js
index afce02e2..1ab24e99 100644
--- a/packages/react-strict-animated/src/native/Animation.js
+++ b/packages/react-strict-animated/src/native/Animation.js
@@ -51,7 +51,7 @@ export function spring(
   return Animated.spring(value, { ...config, useNativeDriver: true });
 }
 
-export function interpolate<TOutput: string | number>(
+export function interpolate<TOutput extends string | number>(
   value: Animated.Node,
   config: InterpolationConfig<TOutput>
 ): Animated.Node {
diff --git a/packages/react-strict-animated/src/native/components.js b/packages/react-strict-animated/src/native/components.js
index 03ef1f2d..5be2d99b 100644
--- a/packages/react-strict-animated/src/native/components.js
+++ b/packages/react-strict-animated/src/native/components.js
@@ -82,20 +82,22 @@ export component AnimatedDiv(
   animatedStyle?: AnimatedStyleValue<Animated.Node>,
   children?: React.Node,
   ref?: React.RefSetter<React.RefOf<html.div>>,
-  ...htmlProps: Omit<React.PropsOf<html.div>, 'children'>
+  ...htmlProps: Omit<React.PropsOf<html.div>, 'children' | 'ref'>
 ) {
   const scaledAnimatedStyle = useViewportScaledAnimatedStyle(animatedStyle);
 
   return (
-    // $FlowFixMe[prop-missing] - RSD missing ref type on compat.native API
+    // $FlowFixMe[incompatible-type]
     <compat.native
       {...htmlProps}
       as="div"
       ref={ref}
+      // $FlowFixMe[incompatible-type]
       style={[styles.defaults, htmlProps.style]}
     >
       {(nativeProps: React.PropsOf<View>) => {
         return (
+          // $FlowFixMe[invalid-component-prop]
           <Animated.View
             {...nativeProps}
             style={[nativeProps.style, scaledAnimatedStyle]}
@@ -112,20 +114,23 @@ export component AnimatedSpan(
   animatedStyle: AnimatedStyleValue<Animated.Node>,
   children?: React.Node,
   ref?: React.RefSetter<React.RefOf<html.span>>,
-  ...htmlProps: Omit<React.PropsOf<html.span>, 'children'>
+  ...htmlProps: Omit<React.PropsOf<html.span>, 'children' | 'ref'>
 ) {
   const scaledAnimatedStyle = useViewportScaledAnimatedStyle(animatedStyle);
 
   return (
-    // $FlowFixMe[prop-missing] - RSD missing ref type on compat.native API
+    // $FlowFixMe[incompatible-type]
     <compat.native
       {...htmlProps}
       as="span"
       ref={ref}
+      // $FlowFixMe[incompatible-type]
       style={[styles.defaults, htmlProps.style]}
     >
       {(nativeProps: React.PropsOf<Text>) => {
         return (
+          // $FlowFixMe[incompatible-type]
+          // $FlowFixMe[invalid-component-prop]
           <Animated.Text
             {...nativeProps}
             style={[nativeProps.style, scaledAnimatedStyle]}
@@ -141,16 +146,17 @@ export component AnimatedSpan(
 export component AnimatedImg(
   animatedStyle: AnimatedStyleValue<Animated.Node>,
   ref?: React.RefSetter<React.RefOf<html.img>>,
-  ...htmlProps: React.PropsOf<html.img>
+  ...htmlProps: Omit<React.PropsOf<html.img>, 'ref'>
 ) {
   const scaledAnimatedStyle = useViewportScaledAnimatedStyle(animatedStyle);
 
   return (
-    // $FlowFixMe[prop-missing] - RSD missing ref type on compat.native API
+    // $FlowFixMe[incompatible-type]
     <compat.native
       {...htmlProps}
       as="img"
       ref={ref}
+      // $FlowFixMe[incompatible-type]
       style={[styles.defaults, htmlProps.style]}
     >
       {(nativeProps: ImageProps) => {
diff --git a/packages/react-strict-animated/src/shared/SharedAnimatedTypes.js b/packages/react-strict-animated/src/shared/SharedAnimatedTypes.js
index 93b6dbe7..dbd2399d 100644
--- a/packages/react-strict-animated/src/shared/SharedAnimatedTypes.js
+++ b/packages/react-strict-animated/src/shared/SharedAnimatedTypes.js
@@ -15,22 +15,22 @@ export type TimingAnimationConfig = {
 };
 
 export type AnimatedTransformValue<TAnimatedNode> =
-  | $ReadOnly<{ perspective: number | TAnimatedNode }>
-  | $ReadOnly<{ rotate: string | TAnimatedNode }>
-  | $ReadOnly<{ rotateX: string | TAnimatedNode }>
-  | $ReadOnly<{ rotateY: string | TAnimatedNode }>
-  | $ReadOnly<{ rotateZ: string | TAnimatedNode }>
-  | $ReadOnly<{ scale: number | TAnimatedNode }>
-  | $ReadOnly<{ scaleX: number | TAnimatedNode }>
-  | $ReadOnly<{ scaleY: number | TAnimatedNode }>
-  | $ReadOnly<{ translateX: number | string | TAnimatedNode }>
-  | $ReadOnly<{ translateY: number | string | TAnimatedNode }>
-  | $ReadOnly<{ skewX: string | TAnimatedNode }>
-  | $ReadOnly<{ skewY: string | TAnimatedNode }>;
+  | Readonly<{ perspective: number | TAnimatedNode }>
+  | Readonly<{ rotate: string | TAnimatedNode }>
+  | Readonly<{ rotateX: string | TAnimatedNode }>
+  | Readonly<{ rotateY: string | TAnimatedNode }>
+  | Readonly<{ rotateZ: string | TAnimatedNode }>
+  | Readonly<{ scale: number | TAnimatedNode }>
+  | Readonly<{ scaleX: number | TAnimatedNode }>
+  | Readonly<{ scaleY: number | TAnimatedNode }>
+  | Readonly<{ translateX: number | string | TAnimatedNode }>
+  | Readonly<{ translateY: number | string | TAnimatedNode }>
+  | Readonly<{ skewX: string | TAnimatedNode }>
+  | Readonly<{ skewY: string | TAnimatedNode }>;
 
-export type AnimatedStyleValue<TAnimatedNode> = $ReadOnly<{
+export type AnimatedStyleValue<TAnimatedNode> = Readonly<{
   opacity?: number | TAnimatedNode,
-  transform?: $ReadOnlyArray<AnimatedTransformValue<TAnimatedNode>>
+  transform?: ReadonlyArray<AnimatedTransformValue<TAnimatedNode>>
 }>;
 
 export type ParallelConfig = {
@@ -55,7 +55,7 @@ export type SpringAnimationConfig = {
 
 type ExtrapolateType = 'extend' | 'identity' | 'clamp';
 
-export type InterpolationConfig<TOutput: string | number> = {
+export type InterpolationConfig<TOutput extends string | number> = {
   easing?: (input: number) => number,
   extrapolate?: ExtrapolateType,
   extrapolateLeft?: ExtrapolateType,
diff --git a/packages/react-strict-animated/src/web/Animation.js b/packages/react-strict-animated/src/web/Animation.js
index bfb589ff..4d0a456a 100644
--- a/packages/react-strict-animated/src/web/Animation.js
+++ b/packages/react-strict-animated/src/web/Animation.js
@@ -68,12 +68,12 @@ export function spring(
   };
 }
 
-export function interpolate<TOutput: number | string>(
+export function interpolate<TOutput extends number | string>(
   value: AnimatedNodeType,
   config: InterpolationConfig<TOutput>
 ): AnimatedNodeType {
   return Interpolate(
-    // $FlowFixMe[incompatible-cast] - need a sketchy cast to be compatible with RN version of Animated
+    // $FlowFixMe[incompatible-type] - need a sketchy cast to be compatible with RN version of Animated
     value as AnimatedWithChildren<number>,
     config
   );
diff --git a/packages/react-strict-animated/src/web/components.js b/packages/react-strict-animated/src/web/components.js
index c99106e2..26678d66 100644
--- a/packages/react-strict-animated/src/web/components.js
+++ b/packages/react-strict-animated/src/web/components.js
@@ -25,7 +25,7 @@ export component AnimatedDiv(
   animatedStyle?: AnimatedStyleValue<AnimatedNodeType>,
   ref?: React.RefSetter<React.RefOf<html.div>>,
   style as incomingStyle?: React.PropsOf<html.div>['style'],
-  ...restProps: Omit<React.PropsOf<html.div>, 'style'>
+  ...restProps: Omit<React.PropsOf<html.div>, 'style' | 'ref'>
 ) {
   const [{ opacity, transform }, animatedRefSetter] =
     useAnimatedStyle<HTMLDivElement | null>(animatedStyle, ref);
@@ -46,7 +46,7 @@ export component AnimatedSpan(
   animatedStyle?: AnimatedStyleValue<AnimatedNodeType>,
   ref?: React.RefSetter<React.RefOf<html.span>>,
   style as incomingStyle?: React.PropsOf<html.span>['style'],
-  ...restProps: Omit<React.PropsOf<html.span>, 'style'>
+  ...restProps: Omit<React.PropsOf<html.span>, 'style' | 'ref'>
 ) {
   const [{ opacity, transform }, animatedRefSetter] =
     useAnimatedStyle<HTMLSpanElement | null>(animatedStyle, ref);
@@ -67,7 +67,7 @@ export component AnimatedImg(
   animatedStyle?: AnimatedStyleValue<AnimatedNodeType>,
   ref?: React.RefSetter<React.RefOf<html.img>>,
   style as incomingStyle?: React.PropsOf<html.img>['style'],
-  ...restProps: Omit<React.PropsOf<html.img>, 'style'>
+  ...restProps: Omit<React.PropsOf<html.img>, 'style' | 'ref'>
 ) {
   const [{ opacity, transform }, animatedRefSetter] =
     useAnimatedStyle<HTMLImageElement | null>(animatedStyle, ref);
diff --git a/packages/react-strict-animated/src/web/nodes/AnimatedInterpolation.js b/packages/react-strict-animated/src/web/nodes/AnimatedInterpolation.js
index 5eeb9970..3f3e4036 100644
--- a/packages/react-strict-animated/src/web/nodes/AnimatedInterpolation.js
+++ b/packages/react-strict-animated/src/web/nodes/AnimatedInterpolation.js
@@ -15,7 +15,7 @@ import normalizeColor from '@react-native/normalize-colors';
 
 type ExtrapolateType = 'extend' | 'identity' | 'clamp';
 
-function findRange(input: number, inputRange: $ReadOnlyArray<number>) {
+function findRange(input: number, inputRange: ReadonlyArray<number>) {
   let i;
   for (i = 1; i < inputRange.length - 1; ++i) {
     if (inputRange[i] >= input) {
@@ -100,7 +100,7 @@ function performInterpolation(
 function createNumericInterpolation(
   config: InterpolationConfig<number>
 ): (input: number) => number {
-  const outputRange: $ReadOnlyArray<number> = config.outputRange;
+  const outputRange: ReadonlyArray<number> = config.outputRange;
   const inputRange = config.inputRange;
 
   const easing = config.easing || ((t) => t);
@@ -145,7 +145,7 @@ function mapStringToNumericComponents(
   input: string
 ):
   | { components: [number, number, number, number], isColor: true }
-  | { components: $ReadOnlyArray<number | string>, isColor: false } {
+  | { components: ReadonlyArray<number | string>, isColor: false } {
   let normalizedColor = normalizeColor(input);
 
   if (typeof normalizedColor === 'number') {
@@ -198,7 +198,7 @@ function createStringInterpolation(
 
   const isColor = outputRange[0].isColor;
 
-  const numericComponents: $ReadOnlyArray<$ReadOnlyArray<number>> =
+  const numericComponents: ReadonlyArray<ReadonlyArray<number>> =
     outputRange.map((output) => {
       if (output.isColor) {
         return output.components;
@@ -237,7 +237,7 @@ function createStringInterpolation(
 }
 
 class AnimatedInterpolation<
-  TOutput: number | string
+  TOutput extends number | string
 > extends AnimatedWithChildren<TOutput> {
   #parent: AnimatedWithChildren<number>;
   #interpolation: (input: number) => TOutput;
@@ -265,7 +265,7 @@ class AnimatedInterpolation<
   }
 }
 
-function createInterpolator<TOutput: number | string>(
+function createInterpolator<TOutput extends number | string>(
   config: InterpolationConfig<TOutput>
 ): ((number) => TOutput) | null {
   switch (typeof config.outputRange[0]) {
@@ -281,7 +281,7 @@ function createInterpolator<TOutput: number | string>(
   }
 }
 
-export function Interpolate<TOutput: number | string>(
+export function Interpolate<TOutput extends number | string>(
   value: AnimatedWithChildren<number>,
   config: InterpolationConfig<TOutput>
 ): AnimatedInterpolation<TOutput> {
diff --git a/packages/react-strict-animated/src/web/nodes/AnimatedStyle.js b/packages/react-strict-animated/src/web/nodes/AnimatedStyle.js
index 04880302..faac07c2 100644
--- a/packages/react-strict-animated/src/web/nodes/AnimatedStyle.js
+++ b/packages/react-strict-animated/src/web/nodes/AnimatedStyle.js
@@ -23,10 +23,10 @@ type OutputAnimatedStyle = {
   transform?: string
 };
 
-export type ReadOnlyOutputAnimatedStyle = $ReadOnly<OutputAnimatedStyle>;
+export type ReadOnlyOutputAnimatedStyle = Readonly<OutputAnimatedStyle>;
 
 export default class AnimatedStyleNode extends AnimatedNode<ReadOnlyOutputAnimatedStyle> {
-  #style: $ReadOnly<{
+  #style: Readonly<{
     ...Omit<AnimatedStyleValue<AnimatedNodeType>, 'transform'>,
     transform?: AnimatedTransform
   }>;
diff --git a/packages/react-strict-animated/src/web/nodes/AnimatedTransform.js b/packages/react-strict-animated/src/web/nodes/AnimatedTransform.js
index e1f85f00..74a957ce 100644
--- a/packages/react-strict-animated/src/web/nodes/AnimatedTransform.js
+++ b/packages/react-strict-animated/src/web/nodes/AnimatedTransform.js
@@ -15,7 +15,7 @@ import type { AnimatedNodeType } from '../types/AnimatedTypes';
 import AnimatedNode from './AnimatedNode';
 import AnimatedWithChildren from './AnimatedWithChildren';
 
-const UNIT: $ReadOnly<{
+const UNIT: Readonly<{
   rotate: string,
   rotateX: string,
   rotateY: string,
@@ -60,7 +60,7 @@ function mapTransform(t: AnimatedTransformValue<AnimatedNodeType>): string {
   throw new Error('value is neither a number or string');
 }
 
-type TransformsArray = $ReadOnlyArray<AnimatedTransformValue<AnimatedNodeType>>;
+type TransformsArray = ReadonlyArray<AnimatedTransformValue<AnimatedNodeType>>;
 
 export default class AnimatedTransform extends AnimatedWithChildren<string> {
   #transforms: TransformsArray;
diff --git a/packages/react-strict-animated/src/web/nodes/AnimatedValue.js b/packages/react-strict-animated/src/web/nodes/AnimatedValue.js
index ed50db0f..96418fdb 100644
--- a/packages/react-strict-animated/src/web/nodes/AnimatedValue.js
+++ b/packages/react-strict-animated/src/web/nodes/AnimatedValue.js
@@ -14,13 +14,13 @@ import type { AnimatedAnimation, KeyframeMap } from '../animations/Animation';
 import AnimatedStyle from './AnimatedStyle';
 import AnimatedWithChildren from './AnimatedWithChildren';
 
-type AnimationData = $ReadOnly<{
+type AnimationData = Readonly<{
   animatedAnimation: AnimatedAnimation,
-  webAnimations: $ReadOnlyArray<Animation>
+  webAnimations: ReadonlyArray<Animation>
 }>;
 
 function findAnimatedStyles(
-  node: AnimatedNode<mixed>,
+  node: AnimatedNode<unknown>,
   animatedStyles: Set<AnimatedStyle>
 ) {
   if (node instanceof AnimatedStyle) {
diff --git a/packages/react-strict-animated/src/web/nodes/AnimatedWithChildren.js b/packages/react-strict-animated/src/web/nodes/AnimatedWithChildren.js
index 6abe8f82..d4af2233 100644
--- a/packages/react-strict-animated/src/web/nodes/AnimatedWithChildren.js
+++ b/packages/react-strict-animated/src/web/nodes/AnimatedWithChildren.js
@@ -12,21 +12,21 @@ import AnimatedNode from './AnimatedNode';
 export default class AnimatedWithChildren<
   TOutput
 > extends AnimatedNode<TOutput> {
-  #children: Array<AnimatedNode<mixed>>;
+  #children: Array<AnimatedNode<unknown>>;
 
   constructor() {
     super();
     this.#children = [];
   }
 
-  __addChild(child: AnimatedNode<mixed>): void {
+  __addChild(child: AnimatedNode<unknown>): void {
     if (this.#children.length === 0) {
       this.__attach();
     }
     this.#children.push(child);
   }
 
-  __removeChild(child: AnimatedNode<mixed>): void {
+  __removeChild(child: AnimatedNode<unknown>): void {
     const index = this.#children.indexOf(child);
     if (index === -1) {
       console.warn("Trying to remove a child that doesn't exist");
@@ -38,7 +38,7 @@ export default class AnimatedWithChildren<
     }
   }
 
-  __getChildren(): Array<AnimatedNode<mixed>> {
+  __getChildren(): Array<AnimatedNode<unknown>> {
     return this.#children;
   }
 }
diff --git a/packages/react-strict-animated/src/web/types/AnimatedTypes.js b/packages/react-strict-animated/src/web/types/AnimatedTypes.js
index 0192d4cc..7780afdd 100644
--- a/packages/react-strict-animated/src/web/types/AnimatedTypes.js
+++ b/packages/react-strict-animated/src/web/types/AnimatedTypes.js
@@ -19,7 +19,7 @@ export type AnimatedNodeType = InternalAnimatedNode<$FlowFixMe>;
 export type EndResult = { finished: boolean, ... };
 export type EndCallback = (result: EndResult) => void;
 
-export type CompositeAnimation = $ReadOnly<{
+export type CompositeAnimation = Readonly<{
   reset: () => void,
   start: (callback?: EndCallback) => void,
   stop: () => void
diff --git a/packages/react-strict-animated/src/web/useAnimatedStyle.js b/packages/react-strict-animated/src/web/useAnimatedStyle.js
index fec9a6cd..e6b8744b 100644
--- a/packages/react-strict-animated/src/web/useAnimatedStyle.js
+++ b/packages/react-strict-animated/src/web/useAnimatedStyle.js
@@ -29,16 +29,18 @@ import {
 type CallbackRef<T> = (T) => void;
 
 type CompositeKeyComponent =
-  | AnimatedNode<mixed>
-  | $ReadOnlyArray<CompositeKeyComponent | null>
-  | $ReadOnly<{ [string]: CompositeKeyComponent }>;
-
-type $ReadOnlyCompositeKeyComponent =
-  | AnimatedNode<mixed>
-  | $ReadOnlyArray<$ReadOnlyCompositeKeyComponent | null>
-  | $ReadOnly<{ [string]: $ReadOnlyCompositeKeyComponent }>;
-
-function isPlainObject(value: mixed): value is $ReadOnly<{ [string]: mixed }> {
+  | AnimatedNode<unknown>
+  | ReadonlyArray<CompositeKeyComponent | null>
+  | Readonly<{ [string]: CompositeKeyComponent }>;
+
+type ReadOnlyCompositeKeyComponent =
+  | AnimatedNode<unknown>
+  | ReadonlyArray<ReadOnlyCompositeKeyComponent | null>
+  | Readonly<{ [string]: ReadOnlyCompositeKeyComponent }>;
+
+function isPlainObject(
+  value: unknown
+): value is Readonly<{ [string]: unknown }> {
   return (
     /* $FlowFixMe[incompatible-type-guard] - Flow does not know that the prototype
    and ReactElement checks preserve the type refinement of `value`. */
@@ -50,9 +52,9 @@ function isPlainObject(value: mixed): value is $ReadOnly<{ [string]: mixed }> {
 }
 
 function createCompositeKeyForArray(
-  array: $ReadOnlyArray<mixed>
-): $ReadOnlyArray<$ReadOnlyCompositeKeyComponent | null> | null {
-  let compositeKey: Array<$ReadOnlyCompositeKeyComponent | null> | null = null;
+  array: ReadonlyArray<unknown>
+): ReadonlyArray<ReadOnlyCompositeKeyComponent | null> | null {
+  let compositeKey: Array<ReadOnlyCompositeKeyComponent | null> | null = null;
 
   for (let ii = 0, length = array.length; ii < length; ii++) {
     const value = array[ii];
@@ -67,7 +69,7 @@ function createCompositeKeyForArray(
     }
     if (compositeKeyComponent != null) {
       if (compositeKey == null) {
-        compositeKey = new Array<$ReadOnlyCompositeKeyComponent | null>(
+        compositeKey = new Array<ReadOnlyCompositeKeyComponent | null>(
           array.length
         ).fill(null);
       }
@@ -79,9 +81,9 @@ function createCompositeKeyForArray(
 }
 
 function createCompositeKeyForObject(
-  object: $ReadOnly<{ [string]: mixed }>
-): $ReadOnly<{ [string]: $ReadOnlyCompositeKeyComponent }> | null {
-  let compositeKey: { [string]: $ReadOnlyCompositeKeyComponent } | null = null;
+  object: Readonly<{ [string]: unknown }>
+): Readonly<{ [string]: ReadOnlyCompositeKeyComponent }> | null {
+  let compositeKey: { [string]: ReadOnlyCompositeKeyComponent } | null = null;
 
   const keys = Object.keys(object);
   for (let ii = 0, length = keys.length; ii < length; ii++) {
@@ -98,7 +100,7 @@ function createCompositeKeyForObject(
     }
     if (compositeKeyComponent != null) {
       if (compositeKey == null) {
-        compositeKey = {} as { [string]: $ReadOnlyCompositeKeyComponent };
+        compositeKey = {} as { [string]: ReadOnlyCompositeKeyComponent };
       }
       compositeKey[key] = compositeKeyComponent;
     }
@@ -108,8 +110,8 @@ function createCompositeKeyForObject(
 }
 
 function areCompositeKeyComponentsEqual(
-  prev: $ReadOnlyCompositeKeyComponent | null,
-  next: $ReadOnlyCompositeKeyComponent | null
+  prev: ReadOnlyCompositeKeyComponent | null,
+  next: ReadOnlyCompositeKeyComponent | null
 ): boolean {
   if (prev === next) {
     return true;
@@ -157,7 +159,7 @@ function areCompositeKeyComponentsEqual(
 
 function useMemoizedAnimatedStyle(
   create: () => ?AnimatedStyle,
-  style: ?AnimatedStyleValue<AnimatedNode<mixed>>
+  style: ?AnimatedStyleValue<AnimatedNode<unknown>>
 ): ?AnimatedStyle {
   const compositeKey = useMemo(
     () => (style != null ? createCompositeKeyForObject(style) : null),
@@ -165,7 +167,7 @@ function useMemoizedAnimatedStyle(
   );
 
   const [currentData, updateData] = useState<
-    $ReadOnly<{
+    Readonly<{
       compositeKey: typeof compositeKey,
       node: ?AnimatedStyle
     }>
@@ -184,8 +186,8 @@ function useMemoizedAnimatedStyle(
   return currentData.node;
 }
 
-export default function useAnimatedStyle<TInstance: HTMLElement | null>(
-  style: ?AnimatedStyleValue<AnimatedNode<mixed>>,
+export default function useAnimatedStyle<TInstance extends HTMLElement | null>(
+  style: ?AnimatedStyleValue<AnimatedNode<unknown>>,
   parentRef?: React.RefSetter<TInstance>
 ): [ReadOnlyOutputAnimatedStyle, CallbackRef<TInstance>] {
   const domElemRef = useRef<TInstance | null>(null);
diff --git a/packages/react-strict-dom/src/native/css/CSSLengthUnitValue.js b/packages/react-strict-dom/src/native/css/CSSLengthUnitValue.js
index ac0b2158..86a9b823 100644
--- a/packages/react-strict-dom/src/native/css/CSSLengthUnitValue.js
+++ b/packages/react-strict-dom/src/native/css/CSSLengthUnitValue.js
@@ -13,7 +13,7 @@ const LENGTH_REGEX = /^(-?[0-9]*[.]?[0-9]+)(em|px|rem|vh|vmax|vmin|vw)$/;
 
 type CSSLengthUnitType = 'em' | 'px' | 'rem' | 'vh' | 'vmax' | 'vmin' | 'vw';
 
-type ResolvePixelValueOptions = $ReadOnly<{
+type ResolvePixelValueOptions = Readonly<{
   fontScale: number | void,
   inheritedFontSize: ?number,
   viewportHeight: number,
diff --git a/packages/react-strict-dom/src/native/css/CSSTransformValue.js b/packages/react-strict-dom/src/native/css/CSSTransformValue.js
index 5edb3a51..88b252ab 100644
--- a/packages/react-strict-dom/src/native/css/CSSTransformValue.js
+++ b/packages/react-strict-dom/src/native/css/CSSTransformValue.js
@@ -10,19 +10,19 @@
 import type { ReactNativeTransform } from '../../types/renderer.native';
 
 export class CSSTransformValue {
-  value: $ReadOnlyArray<ReactNativeTransform>;
+  value: ReadonlyArray<ReactNativeTransform>;
   cachedScaledTransform: void | {
     viewportScale: number,
-    value: $ReadOnlyArray<ReactNativeTransform>
+    value: ReadonlyArray<ReactNativeTransform>
   };
 
-  constructor(value: $ReadOnlyArray<ReactNativeTransform>) {
+  constructor(value: ReadonlyArray<ReactNativeTransform>) {
     this.value = value;
   }
 
   resolveTransformValue(
     viewportScale?: number = 1
-  ): $ReadOnlyArray<ReactNativeTransform> {
+  ): ReadonlyArray<ReactNativeTransform> {
     if (viewportScale === 1) {
       return this.value;
     }
diff --git a/packages/react-strict-dom/src/native/css/customProperties.js b/packages/react-strict-dom/src/native/css/customProperties.js
index c59b5a90..7389215f 100644
--- a/packages/react-strict-dom/src/native/css/customProperties.js
+++ b/packages/react-strict-dom/src/native/css/customProperties.js
@@ -49,7 +49,7 @@ function resolveVariableReferenceValue(
   const variableName = normalizeVariableName(variable.variable);
   const fallbackValue = variable.fallback;
 
-  let variableValue: mixed = propertyRegistry[variableName];
+  let variableValue: unknown = propertyRegistry[variableName];
 
   // Perform variable resolution on the variable's resolved value if it itself
   // contains variables
@@ -100,7 +100,7 @@ export function resolveVariableReferences(
   propertyRegistry: CustomProperties,
   colorScheme: 'light' | 'dark' = 'light'
 ): string | number | null {
-  const result: Array<mixed> = [];
+  const result: Array<unknown> = [];
   for (const value of propValue.values()) {
     if (value instanceof CSSVariableReferenceValue) {
       const resolvedValue = resolveVariableReferenceValue(
diff --git a/packages/react-strict-dom/src/native/css/flattenStyleXStyles.js b/packages/react-strict-dom/src/native/css/flattenStyleXStyles.js
index 28fa3256..c87cc7ec 100644
--- a/packages/react-strict-dom/src/native/css/flattenStyleXStyles.js
+++ b/packages/react-strict-dom/src/native/css/flattenStyleXStyles.js
@@ -8,15 +8,15 @@
  */
 
 type InlineStyle = {
-  +[key: string]: mixed
+  +[key: string]: unknown
 };
 
-type StylesArray<+T> = T | $ReadOnlyArray<StylesArray<T>>;
+type StylesArray<+T> = T | ReadonlyArray<StylesArray<T>>;
 
 type Styles = StylesArray<InlineStyle | false | void | null>;
 
-export function flattenStyle(styles: InlineStyle | $ReadOnlyArray<Styles>): {
-  +[key: string]: mixed
+export function flattenStyle(styles: InlineStyle | ReadonlyArray<Styles>): {
+  +[key: string]: unknown
 } {
   if (!Array.isArray(styles)) {
     return styles;
diff --git a/packages/react-strict-dom/src/native/css/index.js b/packages/react-strict-dom/src/native/css/index.js
index 1d12d559..dc2b7dfe 100644
--- a/packages/react-strict-dom/src/native/css/index.js
+++ b/packages/react-strict-dom/src/native/css/index.js
@@ -31,10 +31,10 @@ export const __customProperties: MutableCustomProperties = {};
  * which can be done at initialization-time (could potentially be done at
  * compile-time in the future).
  */
-function _create<S: { +[string]: { +[string]: mixed } }>(styles: S): {
-  [string]: mixed
+function _create<S extends { +[string]: { +[string]: unknown } }>(styles: S): {
+  [string]: unknown
 } {
-  const result: { [string]: mixed } = {};
+  const result: { [string]: unknown } = {};
   for (const styleName in styles) {
     const val = styles[styleName];
     if (typeof val === 'function') {
@@ -86,8 +86,8 @@ export const defineVars = (tokens: CustomProperties): Tokens => {
   return result;
 };
 
-export const firstThatWorks = <T: string | number>(
-  ...values: $ReadOnlyArray<T>
+export const firstThatWorks = <T extends string | number>(
+  ...values: ReadonlyArray<T>
 ): T => {
   return values[0];
 };
@@ -114,7 +114,7 @@ function _positionTry(p: PositionTry): PositionTry {
 }
 export const positionTry: (PositionTry) => string = _positionTry as $FlowFixMe;
 
-type ResolveStyleOptions = $ReadOnly<{
+type ResolveStyleOptions = Readonly<{
   active?: ?boolean,
   colorScheme: ?('light' | 'dark'),
   customProperties: CustomProperties,
@@ -136,9 +136,9 @@ type ResolveStyleOptions = $ReadOnly<{
 const mqDark = '@media (prefers-color-scheme: dark)';
 
 function resolveStyle(
-  style: $ReadOnlyArray<?{ +[string]: mixed }> | { +[string]: mixed },
+  style: ReadonlyArray<?{ +[string]: unknown }> | { +[string]: unknown },
   options: ResolveStyleOptions
-): { +[string]: mixed } {
+): { +[string]: unknown } {
   const {
     active,
     focus,
@@ -154,8 +154,8 @@ function resolveStyle(
   const colorScheme = options.colorScheme || 'light';
   const customProperties = options.customProperties || __customProperties;
 
-  const result: { [string]: mixed } = {};
-  const stylesToReprocess: { [string]: mixed } = {};
+  const result: { [string]: unknown } = {};
+  const stylesToReprocess: { [string]: unknown } = {};
   const flatStyle = flattenStyle(style);
 
   for (const propName in flatStyle) {
@@ -301,7 +301,7 @@ function resolveStyle(
 
 export function props(
   this: ResolveStyleOptions,
-  ...style: $ReadOnlyArray<?{ [key: string]: mixed }>
+  ...style: ReadonlyArray<?{ [key: string]: unknown }>
 ): ReactNativeProps {
   const options = this;
 
diff --git a/packages/react-strict-dom/src/native/css/parseTextShadow.js b/packages/react-strict-dom/src/native/css/parseTextShadow.js
index 520051ab..6b641600 100644
--- a/packages/react-strict-dom/src/native/css/parseTextShadow.js
+++ b/packages/react-strict-dom/src/native/css/parseTextShadow.js
@@ -46,9 +46,9 @@ function parseValue(str: string) {
   };
 }
 
-export type TextShadowStyle = $ReadOnly<{
+export type TextShadowStyle = Readonly<{
   textShadowColor: string | null,
-  textShadowOffset: $ReadOnly<{
+  textShadowOffset: Readonly<{
     height: number | string,
     width: number | string
   }>,
diff --git a/packages/react-strict-dom/src/native/css/processStyle.js b/packages/react-strict-dom/src/native/css/processStyle.js
index 70078a1c..7329436f 100644
--- a/packages/react-strict-dom/src/native/css/processStyle.js
+++ b/packages/react-strict-dom/src/native/css/processStyle.js
@@ -65,10 +65,10 @@ const timeValuedProperties = new Set<string>([
 const unsupportedValues = new Set<string>(['currentcolor', 'initial']);
 
 export function processStyle(
-  style: { +[string]: mixed },
+  style: { +[string]: unknown },
   skipValidation?: boolean
-): { +[string]: mixed } {
-  const result: { [string]: mixed } = {};
+): { +[string]: unknown } {
+  const result: { [string]: unknown } = {};
 
   for (const propName in style) {
     const styleValue = style[propName];
diff --git a/packages/react-strict-dom/src/native/html.js b/packages/react-strict-dom/src/native/html.js
index 048e26a0..4773d430 100644
--- a/packages/react-strict-dom/src/native/html.js
+++ b/packages/react-strict-dom/src/native/html.js
@@ -97,7 +97,9 @@ const headingProps = {
 export const a: component(
   ref?: React.RefSetter<HTMLAnchorElement>,
   ...StrictReactDOMAnchorProps
-) = createStrictText('a', { style: [styles.defaults, styles.a] }) as $FlowFixMe;
+) = createStrictText('a', {
+  style: [styles.defaults, styles.a]
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "article" (block)
@@ -105,7 +107,9 @@ export const a: component(
 export const article: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('article', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('article', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "aside" (block)
@@ -113,7 +117,9 @@ export const article: component(
 export const aside: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('aside', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('aside', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "b" (inline)
@@ -123,7 +129,7 @@ export const b: component(
   ...StrictReactDOMProps
 ) = createStrictText('b', {
   style: [styles.defaults, styles.bold]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "bdi" (inline)
@@ -131,7 +137,9 @@ export const b: component(
 export const bdi: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrictText('bdi', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('bdi', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "bdo" (inline)
@@ -139,7 +147,9 @@ export const bdi: component(
 export const bdo: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrictText('bdo', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('bdo', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "blockquote" (block)
@@ -147,7 +157,9 @@ export const bdo: component(
 export const blockquote: component(
   ref?: React.RefSetter<HTMLQuoteElement>,
   ...StrictReactDOMProps
-) = createStrict('blockquote', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('blockquote', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "br"
@@ -166,7 +178,7 @@ export const button: component(
 ) = createStrict('button', {
   style: [styles.defaults, styles.button],
   type: 'button'
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "code" (inline)
@@ -176,7 +188,7 @@ export const code: component(
   ...StrictReactDOMProps
 ) = createStrictText('code', {
   style: [styles.defaults, styles.code]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "del" (inline)
@@ -186,7 +198,7 @@ export const del: component(
   ...StrictReactDOMProps
 ) = createStrictText('del', {
   style: [styles.defaults, styles.lineThrough]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "div" (block)
@@ -194,7 +206,7 @@ export const del: component(
 export const div: component(
   ref?: React.RefSetter<HTMLDivElement>,
   ...StrictReactDOMProps
-) = createStrict('div', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('div', { style: styles.defaults } as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "em" (inline)
@@ -204,7 +216,7 @@ export const em: component(
   ...StrictReactDOMProps
 ) = createStrictText('em', {
   style: [styles.defaults, styles.italic]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "fieldset" (block)
@@ -212,7 +224,9 @@ export const em: component(
 export const fieldset: component(
   ref?: React.RefSetter<HTMLFieldSetElement>,
   ...StrictReactDOMProps
-) = createStrict('fieldset', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('fieldset', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "footer" (block)
@@ -220,7 +234,9 @@ export const fieldset: component(
 export const footer: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('footer', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('footer', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "form" (block)
@@ -228,7 +244,9 @@ export const footer: component(
 export const form: component(
   ref?: React.RefSetter<HTMLFormElement>,
   ...StrictReactDOMProps
-) = createStrict('form', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('form', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "h1-h6" (block)
@@ -236,27 +254,27 @@ export const form: component(
 export const h1: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrictText('h1', headingProps) as $FlowFixMe;
+) = createStrictText('h1', headingProps as $FlowFixMe) as $FlowFixMe;
 export const h2: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrictText('h2', headingProps) as $FlowFixMe;
+) = createStrictText('h2', headingProps as $FlowFixMe) as $FlowFixMe;
 export const h3: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrictText('h3', headingProps) as $FlowFixMe;
+) = createStrictText('h3', headingProps as $FlowFixMe) as $FlowFixMe;
 export const h4: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrictText('h4', headingProps) as $FlowFixMe;
+) = createStrictText('h4', headingProps as $FlowFixMe) as $FlowFixMe;
 export const h5: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrictText('h5', headingProps) as $FlowFixMe;
+) = createStrictText('h5', headingProps as $FlowFixMe) as $FlowFixMe;
 export const h6: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrictText('h6', headingProps) as $FlowFixMe;
+) = createStrictText('h6', headingProps as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "header" (block)
@@ -264,7 +282,9 @@ export const h6: component(
 export const header: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('header', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('header', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "hr" (block)
@@ -272,7 +292,9 @@ export const header: component(
 export const hr: component(
   ref?: React.RefSetter<HTMLHRElement>,
   ...StrictReactDOMProps
-) = createStrict('hr', { style: [styles.defaults, styles.hr] }) as $FlowFixMe;
+) = createStrict('hr', {
+  style: [styles.defaults, styles.hr]
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "i" (inline)
@@ -282,7 +304,7 @@ export const i: component(
   ...StrictReactDOMProps
 ) = createStrictText('i', {
   style: [styles.defaults, styles.italic]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "img" (inline)
@@ -292,7 +314,7 @@ export const img: component(
   ...StrictReactDOMImageProps
 ) = createStrictImage('img', {
   style: [styles.defaults, styles.img]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "input" (inline-block)
@@ -302,7 +324,7 @@ export const input: component(
   ...StrictReactDOMInputProps
 ) = createStrictTextInput('input', {
   style: [styles.defaults, styles.input]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "ins" (inline)
@@ -312,7 +334,7 @@ export const ins: component(
   ...StrictReactDOMProps
 ) = createStrictText('ins', {
   style: [styles.defaults, styles.underline]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "kbd" (inline)
@@ -322,7 +344,7 @@ export const kbd: component(
   ...StrictReactDOMProps
 ) = createStrictText('kbd', {
   style: [styles.defaults, styles.code]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "label" (inline)
@@ -330,7 +352,9 @@ export const kbd: component(
 export const label: component(
   ref?: React.RefSetter<HTMLLabelElement>,
   ...StrictReactDOMLabelProps
-) = createStrictText('label', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('label', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "li" (block)
@@ -338,7 +362,7 @@ export const label: component(
 export const li: component(
   ref?: React.RefSetter<HTMLLIElement>,
   ...StrictReactDOMListItemProps
-) = createStrict('li', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('li', { style: styles.defaults } as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "main" (block)
@@ -346,7 +370,9 @@ export const li: component(
 export const main: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('main', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('main', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "mark" (inline)
@@ -356,7 +382,7 @@ export const mark: component(
   ...StrictReactDOMProps
 ) = createStrictText('mark', {
   style: [styles.defaults, styles.mark]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "nav" (block)
@@ -364,7 +390,7 @@ export const mark: component(
 export const nav: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('nav', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('nav', { style: styles.defaults } as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "ol" (block)
@@ -372,7 +398,7 @@ export const nav: component(
 export const ol: component(
   ref?: React.RefSetter<HTMLOListElement>,
   ...StrictReactDOMProps
-) = createStrict('ol', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('ol', { style: styles.defaults } as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "optgroup" (block)
@@ -380,7 +406,9 @@ export const ol: component(
 export const optgroup: component(
   ref?: React.RefSetter<HTMLOptGroupElement>,
   ...StrictReactDOMOptionGroupProps
-) = createStrict('optgroup', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('optgroup', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "option"
@@ -388,7 +416,9 @@ export const optgroup: component(
 export const option: component(
   ref?: React.RefSetter<HTMLOptionElement>,
   ...StrictReactDOMOptionProps
-) = createStrictText('option', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('option', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "p" (block)
@@ -396,7 +426,9 @@ export const option: component(
 export const p: component(
   ref?: React.RefSetter<HTMLParagraphElement>,
   ...StrictReactDOMProps
-) = createStrictText('p', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('p', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "pre" (block)
@@ -406,7 +438,7 @@ export const pre: component(
   ...StrictReactDOMProps
 ) = createStrictText('pre', {
   style: [styles.defaults, styles.code]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "s" (inline)
@@ -416,7 +448,7 @@ export const s: component(
   ...StrictReactDOMProps
 ) = createStrictText('s', {
   style: [styles.defaults, styles.lineThrough]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "section" (block)
@@ -424,7 +456,9 @@ export const s: component(
 export const section: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('section', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('section', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "select" (inline-block)
@@ -432,7 +466,9 @@ export const section: component(
 export const select: component(
   ref?: React.RefSetter<HTMLSelectElement>,
   ...StrictReactDOMSelectProps
-) = createStrict('select', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('select', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "span" (inline)
@@ -440,7 +476,9 @@ export const select: component(
 export const span: component(
   ref?: React.RefSetter<HTMLSpanElement>,
   ...StrictReactDOMProps
-) = createStrictText('span', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('span', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "strong" (inline)
@@ -450,7 +488,7 @@ export const strong: component(
   ...StrictReactDOMProps
 ) = createStrictText('strong', {
   style: [styles.defaults, styles.bold]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "sub" (inline)
@@ -458,7 +496,9 @@ export const strong: component(
 export const sub: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrictText('sub', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('sub', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "sup" (inline)
@@ -466,7 +506,9 @@ export const sub: component(
 export const sup: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrictText('sup', { style: styles.defaults }) as $FlowFixMe;
+) = createStrictText('sup', {
+  style: styles.defaults
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "textarea" (inline-block)
@@ -476,7 +518,7 @@ export const textarea: component(
   ...StrictReactDOMTextAreaProps
 ) = createStrictTextInput('textarea', {
   style: [styles.defaults, styles.textarea]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "u" (inline)
@@ -486,7 +528,7 @@ export const u: component(
   ...StrictReactDOMProps
 ) = createStrictText('u', {
   style: [styles.defaults, styles.underline]
-}) as $FlowFixMe;
+} as $FlowFixMe) as $FlowFixMe;
 
 /**
  * "ul" (block)
@@ -494,4 +536,4 @@ export const u: component(
 export const ul: component(
   ref?: React.RefSetter<HTMLUListElement>,
   ...StrictReactDOMProps
-) = createStrict('ul', { style: styles.defaults }) as $FlowFixMe;
+) = createStrict('ul', { style: styles.defaults } as $FlowFixMe) as $FlowFixMe;
diff --git a/packages/react-strict-dom/src/native/index.js b/packages/react-strict-dom/src/native/index.js
index 177410a5..e4b64e96 100644
--- a/packages/react-strict-dom/src/native/index.js
+++ b/packages/react-strict-dom/src/native/index.js
@@ -32,9 +32,9 @@ type StyleVars<T> = VarGroup<T>;
 type Styles<T> = StyleXStyles<T>;
 type StylesWithout<T> = StyleXStylesWithout<T>;
 
-type ProviderValue = $ReadOnly<{ [string]: string | number }>;
+type ProviderValue = Readonly<{ [string]: string | number }>;
 
-type ProviderProps = $ReadOnly<{
+type ProviderProps = Readonly<{
   children: React.Node,
   customProperties: ProviderValue
 }>;
diff --git a/packages/react-strict-dom/src/native/modules/ContextInheritedStyles.js b/packages/react-strict-dom/src/native/modules/ContextInheritedStyles.js
index 4027d4dd..e376b8a2 100644
--- a/packages/react-strict-dom/src/native/modules/ContextInheritedStyles.js
+++ b/packages/react-strict-dom/src/native/modules/ContextInheritedStyles.js
@@ -15,7 +15,7 @@ import { shallowEqual } from './shallowEqual';
 
 type Value = Style;
 
-type ProviderProps = $ReadOnly<{
+type ProviderProps = Readonly<{
   children: React.Node,
   value: Value
 }>;
diff --git a/packages/react-strict-dom/src/native/modules/ContextViewportScale.js b/packages/react-strict-dom/src/native/modules/ContextViewportScale.js
index eab7e791..0af481fb 100644
--- a/packages/react-strict-dom/src/native/modules/ContextViewportScale.js
+++ b/packages/react-strict-dom/src/native/modules/ContextViewportScale.js
@@ -10,11 +10,11 @@
 import * as React from 'react';
 import * as ReactNative from '../react-native';
 
-type Value = $ReadOnly<{
+type Value = Readonly<{
   scale: number
 }>;
 
-type ProviderProps = $ReadOnly<{
+type ProviderProps = Readonly<{
   children: React.Node,
   viewportWidth: number
 }>;
diff --git a/packages/react-strict-dom/src/native/modules/TextString.js b/packages/react-strict-dom/src/native/modules/TextString.js
index 997a65af..9e8ef04a 100644
--- a/packages/react-strict-dom/src/native/modules/TextString.js
+++ b/packages/react-strict-dom/src/native/modules/TextString.js
@@ -13,7 +13,7 @@ import * as ReactNative from '../react-native';
 import { useCustomProperties } from './ContextCustomProperties';
 import { useStyleProps } from './useStyleProps';
 
-type Props = $ReadOnly<{|
+type Props = Readonly<{|
   children: string
 |}>;
 
@@ -32,7 +32,7 @@ export function TextString(props: Props): React.Node {
   });
 
   return (
-    // $FlowFixMe
+    // $FlowFixMe[incompatible-type]
     <ReactNative.Text {...nativeProps} children={children} />
   );
 }
diff --git a/packages/react-strict-dom/src/native/modules/createStrictDOMComponent.js b/packages/react-strict-dom/src/native/modules/createStrictDOMComponent.js
index eff82a1b..b2b0b8d2 100644
--- a/packages/react-strict-dom/src/native/modules/createStrictDOMComponent.js
+++ b/packages/react-strict-dom/src/native/modules/createStrictDOMComponent.js
@@ -21,25 +21,32 @@ import { errorMsg } from '../../shared/logUtils';
 import { useNativeProps } from './useNativeProps';
 import { useStrictDOMElement } from './useStrictDOMElement';
 
-type StrictProps = $ReadOnly<{
+type StrictProps = Readonly<{
   ...StrictPropsOriginal,
   children?: React.Node | ((ReactNativeProps) => React.Node)
 }>;
 
 const AnimatedPressable = ReactNative.Animated.createAnimatedComponent<
+  // $FlowFixMe[invalid-component-prop]
   React.ElementConfig<typeof ReactNative.Pressable>,
   typeof ReactNative.Pressable
+  // $FlowFixMe[incompatible-type]
 >(ReactNative.Pressable);
 
-export function createStrictDOMComponent<T, P: StrictProps>(
+export function createStrictDOMComponent<T, P extends StrictProps>(
   tagName: string,
   defaultProps?: P
 ): component(ref?: React.RefSetter<T>, ...P) {
   const provideInheritableStyle =
+    // $FlowFixMe[invalid-compare]
     tagName !== 'br' || tagName !== 'hr' || tagName !== 'option';
 
   component Component(ref: React.RefSetter<T>, ...props: P) {
-    let NativeComponent =
+    let NativeComponent:
+      | typeof ReactNative.Pressable
+      | typeof ReactNative.ViewNativeComponent
+      | typeof ReactNative.Animated.View
+      | typeof AnimatedPressable =
       tagName === 'button'
         ? ReactNative.Pressable
         : ReactNative.ViewNativeComponent;
@@ -70,12 +77,16 @@ export function createStrictDOMComponent<T, P: StrictProps>(
     // Tag-specific props
 
     if (tagName === 'button') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.role ??= 'button';
     } else if (tagName === 'header') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.role ??= 'header';
     } else if (tagName === 'li') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.role ??= 'listitem';
     } else if (tagName === 'ol' || tagName === 'ul') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.role ??= 'list';
     }
 
@@ -83,22 +94,26 @@ export function createStrictDOMComponent<T, P: StrictProps>(
 
     if (NativeComponent === ReactNative.Pressable) {
       if (props.disabled === true) {
+        // $FlowFixMe[react-rule-hook-mutation]
         nativeProps.disabled = true;
+        // $FlowFixMe[react-rule-hook-mutation]
         nativeProps.focusable = false;
       }
     }
 
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.ref = elementRef;
 
     // Workaround: React Native doesn't support raw text children of View
     // Sometimes we can auto-fix this
     if (typeof nativeProps.children === 'string') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.children = <TextString children={nativeProps.children} />;
     }
 
     // Polyfill for default of "display:block"
     // which implies "displayInside:flow"
-    let nextDisplayInsideValue = 'flow';
+    let nextDisplayInsideValue: 'flow' | 'flex' = 'flow';
     const displayInsideValue = useDisplayInside();
     const displayValue = nativeProps.style.display;
 
@@ -126,27 +141,42 @@ export function createStrictDOMComponent<T, P: StrictProps>(
 
     if (displayValue === 'flex') {
       nextDisplayInsideValue = 'flex';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.alignContent ??= 'stretch';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.alignItems ??= 'stretch';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexBasis ??= 'auto';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexDirection ??= 'row';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexShrink ??= 1;
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexWrap ??= 'nowrap';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.justifyContent ??= 'flex-start';
     } else if (displayValue === 'block' && displayInsideValue === 'flow') {
       // Force the block emulation styles
       nextDisplayInsideValue = 'flow';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.alignItems = 'stretch';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.display = 'flex';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexBasis = 'auto';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexDirection = 'column';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexShrink = 0;
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexWrap = 'nowrap';
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.justifyContent = 'flex-start';
     }
 
     if (displayInsideValue === 'flex') {
       // flex child should not shrink by default
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.flexShrink ??= 1;
     }
 
@@ -168,7 +198,7 @@ export function createStrictDOMComponent<T, P: StrictProps>(
       typeof props.children === 'function' ? (
         props.children(nativeProps)
       ) : (
-        // $FlowFixMe
+        // $FlowFixMe[incompatible-type]
         <NativeComponent {...nativeProps} />
       );
 
diff --git a/packages/react-strict-dom/src/native/modules/createStrictDOMImageComponent.js b/packages/react-strict-dom/src/native/modules/createStrictDOMImageComponent.js
index 52a4be12..979b19a1 100644
--- a/packages/react-strict-dom/src/native/modules/createStrictDOMImageComponent.js
+++ b/packages/react-strict-dom/src/native/modules/createStrictDOMImageComponent.js
@@ -16,12 +16,17 @@ import { useNativeProps } from './useNativeProps';
 import { useStrictDOMElement } from './useStrictDOMElement';
 import * as css from '../css';
 
-export function createStrictDOMImageComponent<P: StrictReactDOMImageProps, T>(
+export function createStrictDOMImageComponent<
+  P extends StrictReactDOMImageProps,
+  T
+>(
   tagName: string,
   _defaultProps?: P
 ): component(ref?: React.RefSetter<T>, ...P) {
   component Component(ref: React.RefSetter<T>, ...props: P) {
-    let NativeComponent = ReactNative.Image;
+    let NativeComponent:
+      | typeof ReactNative.Image
+      | typeof ReactNative.Animated.Image = ReactNative.Image;
     const elementRef = useStrictDOMElement<T>(ref, { tagName });
 
     const {
@@ -56,15 +61,19 @@ export function createStrictDOMImageComponent<P: StrictReactDOMImageProps, T>(
     // Tag-specific props
 
     if (alt != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.alt = alt;
     }
     if (crossOrigin != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.crossOrigin = crossOrigin;
     }
     if (height != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.height = height;
     }
     if (onError != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.onError = function () {
         onError({
           type: 'error'
@@ -72,6 +81,7 @@ export function createStrictDOMImageComponent<P: StrictReactDOMImageProps, T>(
       };
     }
     if (onLoad != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.onLoad = function (e) {
         const { source } = e.nativeEvent;
         onLoad({
@@ -84,20 +94,25 @@ export function createStrictDOMImageComponent<P: StrictReactDOMImageProps, T>(
       };
     }
     if (referrerPolicy != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.referrerPolicy = referrerPolicy;
     }
     if (src != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.src = src;
     }
     if (srcSet != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.srcSet = srcSet;
     }
     if (width != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.width = width;
     }
 
     // Component-specific props
 
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.ref = elementRef;
 
     // Use Animated components if necessary
@@ -109,7 +124,7 @@ export function createStrictDOMImageComponent<P: StrictReactDOMImageProps, T>(
       typeof props.children === 'function' ? (
         props.children(nativeProps)
       ) : (
-        // $FlowFixMe
+        // $FlowFixMe[incompatible-type]
         <NativeComponent {...nativeProps} />
       );
 
diff --git a/packages/react-strict-dom/src/native/modules/createStrictDOMTextComponent.js b/packages/react-strict-dom/src/native/modules/createStrictDOMTextComponent.js
index bf9f30a0..30deca61 100644
--- a/packages/react-strict-dom/src/native/modules/createStrictDOMTextComponent.js
+++ b/packages/react-strict-dom/src/native/modules/createStrictDOMTextComponent.js
@@ -19,21 +19,23 @@ import { errorMsg } from '../../shared/logUtils';
 import { useNativeProps } from './useNativeProps';
 import { useStrictDOMElement } from './useStrictDOMElement';
 
-type StrictProps = $ReadOnly<{
+type StrictProps = Readonly<{
   ...StrictPropsOriginal,
   children?: React.Node | ((ReactNativeProps) => React.Node)
 }>;
 
-function hasElementChildren(children: mixed): boolean {
+function hasElementChildren(children: unknown): boolean {
   return children != null && typeof children !== 'string';
 }
 
-export function createStrictDOMTextComponent<T, P: StrictProps>(
+export function createStrictDOMTextComponent<T, P extends StrictProps>(
   tagName: string,
   defaultProps?: P
 ): component(ref?: React.RefSetter<T>, ...P) {
   component Component(ref?: React.RefSetter<T>, ...props: P) {
-    let NativeComponent = ReactNative.Text;
+    let NativeComponent:
+      | typeof ReactNative.Text
+      | typeof ReactNative.Animated.Text = ReactNative.Text;
     const elementRef = useStrictDOMElement<T>(ref, { tagName });
 
     const { href, label } = props;
@@ -48,6 +50,7 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
       {
         provideInheritableStyle:
           tagName !== 'br' ||
+          // $FlowFixMe[invalid-compare]
           tagName !== 'option' ||
           hasElementChildren(props.children),
         withInheritedStyle: true,
@@ -58,8 +61,10 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
     // Tag-specific props
 
     if (tagName === 'a') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.role ??= 'link';
       if (href != null) {
+        // $FlowFixMe[react-rule-hook-mutation]
         nativeProps.onPress = function (e) {
           if (__DEV__) {
             errorMsg('<a> "href" handling is not implemented in React Native.');
@@ -67,6 +72,7 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
         };
       }
     } else if (tagName === 'br') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.children = '\n';
     } else if (
       tagName === 'h1' ||
@@ -76,13 +82,16 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
       tagName === 'h5' ||
       tagName === 'h6'
     ) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.role ??= 'heading';
     } else if (tagName === 'option') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.children = label;
     }
 
     // Component-specific props
 
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.ref = elementRef;
 
     // Workaround: Android doesn't support ellipsis truncation if Text is selectable
@@ -93,6 +102,7 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
       nativeProps.style.userSelect !== 'none';
 
     // $FlowExpectedError[unsafe-object-assign]
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.style = Object.assign(
       nativeProps.style,
       disableUserSelect ? { userSelect: 'none' } : null
@@ -101,7 +111,9 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
     // Native components historically clip text. Opt into web-style default of
     // visible overflow by default
     if (nativeProps.style?.overflow == null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style = nativeProps.style ?? {};
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.style.overflow = 'visible';
     }
 
@@ -118,7 +130,7 @@ export function createStrictDOMTextComponent<T, P: StrictProps>(
       typeof props.children === 'function' ? (
         props.children(nativeProps)
       ) : (
-        // $FlowFixMe
+        // $FlowFixMe[incompatible-type]
         <NativeComponent {...nativeProps} />
       );
 
diff --git a/packages/react-strict-dom/src/native/modules/createStrictDOMTextInputComponent.js b/packages/react-strict-dom/src/native/modules/createStrictDOMTextInputComponent.js
index 794ff933..64d99912 100644
--- a/packages/react-strict-dom/src/native/modules/createStrictDOMTextInputComponent.js
+++ b/packages/react-strict-dom/src/native/modules/createStrictDOMTextInputComponent.js
@@ -21,7 +21,7 @@ import { useStrictDOMElement } from './useStrictDOMElement';
 const AnimatedTextInput = ReactNative.Animated.createAnimatedComponent<
   React.ElementConfig<typeof ReactNative.TextInput>,
   typeof ReactNative.TextInput
-  // $FlowFixMe: React Native animated component typing issue
+  // $FlowFixMe[incompatible-type]: React Native animated component typing issue
 >(ReactNative.TextInput);
 
 // $FlowFixMe[unclear-type]
@@ -40,7 +40,10 @@ function updateCachedSelection(
   }
 }
 
-export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
+export function createStrictDOMTextInputComponent<
+  P extends StrictInputProps,
+  T
+>(
   tagName: string,
   defaultProps?: P
 ): component(ref?: React.RefSetter<T>, ...P) {
@@ -101,9 +104,11 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
         _inputMode = 'numeric';
       }
       if (_inputMode != null) {
+        // $FlowFixMe[react-rule-hook-mutation]
         nativeProps.inputMode = _inputMode;
       }
       if (type === 'password') {
+        // $FlowFixMe[react-rule-hook-mutation]
         nativeProps.secureTextEntry = true;
       }
       if (type === 'checkbox' || type === 'date' || type === 'radio') {
@@ -114,8 +119,10 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
         }
       }
     } else if (tagName === 'textarea') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.multiline = true;
       if (rows != null) {
+        // $FlowFixMe[react-rule-hook-mutation]
         nativeProps.numberOfLines = rows;
       }
     }
@@ -123,27 +130,36 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
     // Component-specific props
 
     if (autoCapitalize != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.autoCapitalize = autoCapitalize;
     }
     if (autoComplete != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.autoComplete = autoComplete;
     }
     if (defaultValue != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.defaultValue = defaultValue;
     }
     if (disabled === true) {
       // polyfill disabled elements
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.disabled = true;
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.editable = false;
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.focusable = false;
     }
     if (enterKeyHint != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.enterKeyHint = enterKeyHint;
     }
     if (maxLength != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.maxLength = maxLength;
     }
     if (onChange != null || onInput != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.onChange = function (e) {
         const { text, selection } = e.nativeEvent;
         // Update cached selection state immediately to ensure sync with onChange
@@ -167,6 +183,7 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
       };
     }
     if (onKeyDown != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.onKeyPress = function (e) {
         const { key } = e.nativeEvent;
         // Filter out bad iOS keypress data on submit
@@ -181,6 +198,7 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
           });
         }
       };
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.onSubmitEditing = function (e) {
         onKeyDown({
           key: 'Enter',
@@ -189,6 +207,7 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
       };
     }
     // Part of polyfill for selectionStart/End
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onSelectionChange = function (e) {
       const { selection } = e.nativeEvent;
       updateCachedSelection(nodeRef.current, selection);
@@ -197,18 +216,23 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
       }
     };
     if (placeholder != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.placeholder = placeholder;
     }
     if (readOnly != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.editable = !readOnly;
     }
     if (spellCheck != null) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.spellCheck = spellCheck;
     }
     if (value != null && typeof value === 'string') {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.value = value;
     }
 
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.ref = React.useMemo(
       () =>
         mergeRefs((node) => {
@@ -226,7 +250,7 @@ export function createStrictDOMTextInputComponent<P: StrictInputProps, T>(
       typeof props.children === 'function' ? (
         props.children(nativeProps)
       ) : (
-        // $FlowFixMe
+        // $FlowFixMe[incompatible-type]
         <NativeComponent {...nativeProps} />
       );
 
diff --git a/packages/react-strict-dom/src/native/modules/extractStyleThemes.js b/packages/react-strict-dom/src/native/modules/extractStyleThemes.js
index 66f08c08..2dd8ab53 100644
--- a/packages/react-strict-dom/src/native/modules/extractStyleThemes.js
+++ b/packages/react-strict-dom/src/native/modules/extractStyleThemes.js
@@ -9,7 +9,7 @@
 
 import type { CustomProperties, Style, Styles } from '../../types/styles';
 
-const emptyValue = [{}, null];
+const emptyValue: [Style, ?CustomProperties] = [{}, null];
 
 export function extractStyleThemes(
   mixOfStyleAndTheme: ?Styles | Style | Array<Styles | Style>
diff --git a/packages/react-strict-dom/src/native/modules/mediaQuery.js.flow b/packages/react-strict-dom/src/native/modules/mediaQuery.js.flow
index 865c345a..9b2f81d4 100644
--- a/packages/react-strict-dom/src/native/modules/mediaQuery.js.flow
+++ b/packages/react-strict-dom/src/native/modules/mediaQuery.js.flow
@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-type MediaQueryValues = $ReadOnly<{
+type MediaQueryValues = Readonly<{
   type?: 'screen',
   width?: number,
   height?: number,
diff --git a/packages/react-strict-dom/src/native/modules/shallowEqual.js b/packages/react-strict-dom/src/native/modules/shallowEqual.js
index 70c7e04e..d98283c8 100644
--- a/packages/react-strict-dom/src/native/modules/shallowEqual.js
+++ b/packages/react-strict-dom/src/native/modules/shallowEqual.js
@@ -19,7 +19,7 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
  * when any key has values which are not strictly equal between the arguments.
  * Returns true when the values of all keys are strictly equal.
  */
-export function shallowEqual(objA: mixed, objB: mixed): boolean {
+export function shallowEqual(objA: unknown, objB: unknown): boolean {
   if (Object.is(objA, objB)) {
     return true;
   }
diff --git a/packages/react-strict-dom/src/native/modules/useNativeProps.js b/packages/react-strict-dom/src/native/modules/useNativeProps.js
index 0c824c85..b185cbee 100644
--- a/packages/react-strict-dom/src/native/modules/useNativeProps.js
+++ b/packages/react-strict-dom/src/native/modules/useNativeProps.js
@@ -18,7 +18,7 @@ import { isPropAllowed } from '../../shared/isPropAllowed';
 import { useCustomProperties } from './ContextCustomProperties';
 import { useStyleProps } from './useStyleProps';
 
-type StrictProps = $ReadOnly<{
+type StrictProps = Readonly<{
   ...StrictPropsOriginal,
   children?: React.Node | ((ReactNativeProps) => React.Node)
 }>;
@@ -60,6 +60,7 @@ type EventHandler =
   | ReactNativeProps['onPointerUp']
   | ReactNativeProps['onPointerLeave'];
 
+// $FlowFixMe[incompatible-type]
 function combineEventHandlers(a: EventHandler, b: EventHandler): $FlowFixMe {
   if (a == null) {
     return b;
@@ -168,6 +169,7 @@ export function useNativeProps(
   const displayValue = nativeProps.style.display;
   // 'hidden' polyfill (only if "display" is not set)
   if (displayValue == null && hidden && hidden !== 'until-found') {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.style.display = 'none';
   }
 
@@ -176,36 +178,46 @@ export function useNativeProps(
    */
 
   if (typeof children !== 'function') {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.children = children;
   }
 
   if (ariaHidden != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityElementsHidden = ariaHidden;
     if (ariaHidden === true) {
+      // $FlowFixMe[react-rule-hook-mutation]
       nativeProps.importantForAccessibility = 'no-hide-descendants';
     }
   }
   if (ariaLabel != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityLabel = ariaLabel;
   }
   if (ariaLabelledBy != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityLabelledBy = ariaLabelledBy?.split(/\s*,\s*/g);
   }
   if (ariaLive != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityLiveRegion =
       ariaLive === 'off' ? 'none' : ariaLive;
   }
   if (ariaModal != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityViewIsModal = ariaModal;
   }
   if (ariaPosInSet != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityPosInSet = ariaPosInSet;
   }
   const ariaRole = role;
   if (ariaRole) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.role = ariaRole;
   }
   if (ariaSetSize != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilitySetSize = ariaSetSize;
   }
   if (
@@ -215,6 +227,7 @@ export function useNativeProps(
     ariaExpanded != null ||
     ariaSelected != null
   ) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityState = {
       busy: ariaBusy,
       checked: ariaChecked,
@@ -229,6 +242,7 @@ export function useNativeProps(
     ariaValueNow != null ||
     ariaValueText != null
   ) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.accessibilityValue = {
       max: ariaValueMax,
       min: ariaValueMin,
@@ -237,24 +251,30 @@ export function useNativeProps(
     };
   }
   if (dataTestID != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.testID = dataTestID;
   }
   if (id != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.nativeID = id;
   }
   if (tabIndex != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.focusable = !tabIndex;
   }
 
   // Events
 
   if (onBlur != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onBlur = combineEventHandlers(nativeProps.onBlur, onBlur);
   }
   // TODO: remove once PointerEvent onClick is available
   if (onClick != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
+    // $FlowFixMe[missing-local-annot]
     nativeProps.onPress = function ({ nativeEvent }) {
-      const event: mixed = nativeEvent;
+      const event: unknown = nativeEvent;
       let altKey = false;
       let ctrlKey = false;
       let metaKey = false;
@@ -308,90 +328,112 @@ export function useNativeProps(
     };
   }
   if (onFocus != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onFocus = combineEventHandlers(nativeProps.onFocus, onFocus);
   }
   if (onGotPointerCapture != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onGotPointerCapture = onGotPointerCapture;
   }
   if (onLostPointerCapture != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onLostPointerCapture = onLostPointerCapture;
   }
   if (onMouseDown != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onMouseDown = onMouseDown;
   }
   if (onMouseEnter != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onMouseEnter = combineEventHandlers(
       nativeProps.onMouseEnter,
       onMouseEnter
     );
   }
   if (onMouseLeave != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onMouseLeave = combineEventHandlers(
       nativeProps.onMouseLeave,
       onMouseLeave
     );
   }
   if (onMouseOut != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onMouseOut = onMouseOut;
   }
   if (onMouseOver != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onMouseOver = onMouseOver;
   }
   if (onMouseUp != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onMouseUp = onMouseUp;
   }
   if (onPointerCancel != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerCancel = combineEventHandlers(
       nativeProps.onPointerCancel,
       onPointerCancel
     );
   }
   if (onPointerDown != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerDown = combineEventHandlers(
       nativeProps.onPointerDown,
       onPointerDown
     );
   }
   if (onPointerEnter != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerEnter = combineEventHandlers(
       nativeProps.onPointerEnter,
       onPointerEnter
     );
   }
   if (onPointerLeave != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerLeave = combineEventHandlers(
       nativeProps.onPointerLeave,
       onPointerLeave
     );
   }
   if (onPointerMove != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerMove = onPointerMove;
   }
   if (onPointerOut != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerOut = onPointerOut;
   }
   if (onPointerOver != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerOver = onPointerOver;
   }
   if (onPointerUp != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onPointerUp = combineEventHandlers(
       nativeProps.onPointerUp,
       onPointerUp
     );
   }
   if (onScroll != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onScroll = onScroll;
   }
   if (onTouchCancel != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onTouchCancel = onTouchCancel;
   }
   if (onTouchEnd != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onTouchEnd = onTouchEnd;
   }
   if (onTouchMove != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onTouchMove = onTouchMove;
   }
   if (onTouchStart != null) {
+    // $FlowFixMe[react-rule-hook-mutation]
     nativeProps.onTouchStart = onTouchStart;
   }
 
diff --git a/packages/react-strict-dom/src/native/modules/useStrictDOMElement.js b/packages/react-strict-dom/src/native/modules/useStrictDOMElement.js
index 285007bb..d9368040 100644
--- a/packages/react-strict-dom/src/native/modules/useStrictDOMElement.js
+++ b/packages/react-strict-dom/src/native/modules/useStrictDOMElement.js
@@ -22,7 +22,7 @@ type Options = {
 // $FlowFixMe[unclear-type]
 type Node = any;
 
-const memoizedStrictRefs: WeakMap<Node, mixed> = new WeakMap();
+const memoizedStrictRefs: WeakMap<Node, unknown> = new WeakMap();
 
 const lengthPropertySet = new Set([
   'clientHeight',
diff --git a/packages/react-strict-dom/src/native/modules/useStyleProps.js b/packages/react-strict-dom/src/native/modules/useStyleProps.js
index ca99c149..698be171 100644
--- a/packages/react-strict-dom/src/native/modules/useStyleProps.js
+++ b/packages/react-strict-dom/src/native/modules/useStyleProps.js
@@ -144,8 +144,10 @@ export function useStyleProps(
 
   if (handlers != null) {
     for (const handler of eventHandlerNames) {
+      // $FlowFixMe[invalid-computed-prop]
       const handlerValue = handlers[handler];
       if (handlerValue != null) {
+        // $FlowFixMe[prop-missing]
         styleProps[handler] = handlerValue;
       }
     }
@@ -194,6 +196,7 @@ export function useStyleProps(
 
   for (const key of inheritedProperties) {
     const value = styleProps.style[key];
+    // $FlowFixMe[invalid-computed-prop]
     const inheritedValue = inheritedValues[key];
 
     let val = value;
diff --git a/packages/react-strict-dom/src/native/modules/useStyleTransition.js b/packages/react-strict-dom/src/native/modules/useStyleTransition.js
index c9aca588..36609d26 100644
--- a/packages/react-strict-dom/src/native/modules/useStyleTransition.js
+++ b/packages/react-strict-dom/src/native/modules/useStyleTransition.js
@@ -20,23 +20,23 @@ import * as ReactNative from '../react-native';
 import { errorMsg, warnMsg } from '../../shared/logUtils';
 
 type AnimatedStyle = {
-  [string]: ?ReactNativeStyleValue | $ReadOnlyArray<mixed>
+  [string]: ?ReactNativeStyleValue | ReadonlyArray<unknown>
 };
 
-type TransitionMetadata = $ReadOnly<{
+type TransitionMetadata = Readonly<{
   delay: number,
   duration: number,
   timingFunction: string | null,
   shouldUseNativeDriver: boolean
 }>;
 
-const INPUT_RANGE: $ReadOnlyArray<number> = [0, 1];
+const INPUT_RANGE: ReadonlyArray<number> = [0, 1];
 
-function isNumber(num: mixed): num is number {
+function isNumber(num: unknown): num is number {
   return typeof num === 'number';
 }
 
-function isString(str: mixed): str is string {
+function isString(str: unknown): str is string {
   return typeof str === 'string';
 }
 
@@ -54,6 +54,7 @@ function canUseNativeDriver(
     if (
       property === 'transform' &&
       Array.isArray(value) &&
+      // $FlowFixMe[incompatible-type]
       !value.includes('skew')
     ) {
       continue;
@@ -81,7 +82,7 @@ function getEasingFunction(input: ?string) {
   return ReactNative.Easing.linear;
 }
 
-function getTransitionProperties(property: mixed): ?(string[]) {
+function getTransitionProperties(property: unknown): ?(string[]) {
   if (property === 'all') {
     return ['opacity', 'transform'];
   }
@@ -92,8 +93,8 @@ function getTransitionProperties(property: mixed): ?(string[]) {
 }
 
 function transformsHaveSameLengthTypesAndOrder(
-  transformsA: $ReadOnlyArray<ReactNativeTransform>,
-  transformsB: $ReadOnlyArray<ReactNativeTransform>
+  transformsA: ReadonlyArray<ReactNativeTransform>,
+  transformsB: ReadonlyArray<ReactNativeTransform>
 ): boolean {
   if (transformsA.length !== transformsB.length) {
     return false;
@@ -123,8 +124,8 @@ function transformsHaveSameLengthTypesAndOrder(
 }
 
 function transformListsAreEqual(
-  transformsA: $ReadOnlyArray<ReactNativeTransform>,
-  transformsB: $ReadOnlyArray<ReactNativeTransform>
+  transformsA: ReadonlyArray<ReactNativeTransform>,
+  transformsB: ReadonlyArray<ReactNativeTransform>
 ): boolean {
   if (!transformsHaveSameLengthTypesAndOrder(transformsA, transformsB)) {
     return false;
@@ -428,7 +429,7 @@ export function useStyleTransition(style: ReactNativeStyle): ReactNativeStyle {
       }
 
       // Animate the transforms
-      const animatedTransforms: Array<mixed> = [];
+      const animatedTransforms: Array<unknown> = [];
       for (let i = 0; i < transforms.length; i++) {
         const singleTransform = transforms[i];
         const singlePrevTransform = prevTransforms[i];
diff --git a/packages/react-strict-dom/src/native/modules/version.js b/packages/react-strict-dom/src/native/modules/version.js
index 97e7e523..aeaaf67b 100644
--- a/packages/react-strict-dom/src/native/modules/version.js
+++ b/packages/react-strict-dom/src/native/modules/version.js
@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-// $FlowFixMe(nonstrict-import)
+// $FlowFixMe[nonstrict-import]
 import * as ReactNative from '../react-native';
 
 const reactNativeVersion = ReactNative.Platform.constants.reactNativeVersion;
diff --git a/packages/react-strict-dom/src/shared/mergeRefs.js b/packages/react-strict-dom/src/shared/mergeRefs.js
index f9806070..957a0934 100644
--- a/packages/react-strict-dom/src/shared/mergeRefs.js
+++ b/packages/react-strict-dom/src/shared/mergeRefs.js
@@ -12,7 +12,7 @@ import type { CallbackRef, Ref } from '../types/react';
 export type RefType<TElement> = null | void | Ref<TElement>;
 
 export function mergeRefs<TElement>(
-  ...args: $ReadOnlyArray<RefType<TElement>>
+  ...args: ReadonlyArray<RefType<TElement>>
 ): CallbackRef<TElement> {
   return function forwardRef(node: TElement | null) {
     args.forEach((ref) => {
diff --git a/packages/react-strict-dom/src/types/StrictProps.js b/packages/react-strict-dom/src/types/StrictProps.js
index 1f974a1c..a05ef0f9 100644
--- a/packages/react-strict-dom/src/types/StrictProps.js
+++ b/packages/react-strict-dom/src/types/StrictProps.js
@@ -19,7 +19,7 @@ import type { StrictReactDOMOptionProps } from './StrictReactDOMOptionProps';
 import type { StrictReactDOMSelectProps } from './StrictReactDOMSelectProps';
 import type { StrictReactDOMTextAreaProps } from './StrictReactDOMTextAreaProps';
 
-export type StrictProps = $ReadOnly<{
+export type StrictProps = Readonly<{
   ...StrictReactDOMProps,
   ...StrictReactDOMAnchorProps,
   ...StrictReactDOMButtonProps,
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMAnchorProps.js b/packages/react-strict-dom/src/types/StrictReactDOMAnchorProps.js
index 4ab85d69..d010bee4 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMAnchorProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMAnchorProps.js
@@ -9,7 +9,7 @@
 
 import type { StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMAnchorProps = $ReadOnly<{
+export type StrictReactDOMAnchorProps = Readonly<{
   ...StrictReactDOMProps,
   download?: ?string,
   href?: string,
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMImageProps.js b/packages/react-strict-dom/src/types/StrictReactDOMImageProps.js
index fd1e18f0..41525beb 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMImageProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMImageProps.js
@@ -9,7 +9,7 @@
 
 import type { StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMImageProps = $ReadOnly<{
+export type StrictReactDOMImageProps = Readonly<{
   ...StrictReactDOMProps,
   alt?: ?Stringish,
   crossOrigin?: ?('anonymous' | 'use-credentials'),
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMInputProps.js b/packages/react-strict-dom/src/types/StrictReactDOMInputProps.js
index eb2b6224..25fda721 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMInputProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMInputProps.js
@@ -9,7 +9,7 @@
 
 import type { AutoComplete, StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMInputProps = $ReadOnly<{
+export type StrictReactDOMInputProps = Readonly<{
   ...StrictReactDOMProps,
   autoComplete?: AutoComplete,
   checked?: ?(boolean | 'mixed'),
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMLabelProps.js b/packages/react-strict-dom/src/types/StrictReactDOMLabelProps.js
index d1be4a73..78264c90 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMLabelProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMLabelProps.js
@@ -9,7 +9,7 @@
 
 import type { StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMLabelProps = $ReadOnly<{
+export type StrictReactDOMLabelProps = Readonly<{
   ...StrictReactDOMProps,
   for?: string
 }>;
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMListItemProps.js b/packages/react-strict-dom/src/types/StrictReactDOMListItemProps.js
index db679bc6..795bd8a0 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMListItemProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMListItemProps.js
@@ -9,7 +9,7 @@
 
 import type { StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMListItemProps = $ReadOnly<{
+export type StrictReactDOMListItemProps = Readonly<{
   ...StrictReactDOMProps,
   value?: number
 }>;
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMOptionGroupProps.js b/packages/react-strict-dom/src/types/StrictReactDOMOptionGroupProps.js
index 7eb6fd4f..643d6c3b 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMOptionGroupProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMOptionGroupProps.js
@@ -9,7 +9,7 @@
 
 import type { StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMOptionGroupProps = $ReadOnly<{
+export type StrictReactDOMOptionGroupProps = Readonly<{
   ...StrictReactDOMProps,
   disabled?: ?boolean,
   label?: ?Stringish
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMOptionProps.js b/packages/react-strict-dom/src/types/StrictReactDOMOptionProps.js
index 070e7888..cdeeb633 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMOptionProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMOptionProps.js
@@ -9,7 +9,7 @@
 
 import type { StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMOptionProps = $ReadOnly<{
+export type StrictReactDOMOptionProps = Readonly<{
   ...StrictReactDOMProps,
   disabled?: ?boolean,
   label?: ?Stringish,
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMProps.js b/packages/react-strict-dom/src/types/StrictReactDOMProps.js
index 351cc67f..ff3ca610 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMProps.js
@@ -156,7 +156,7 @@ export type AutoComplete = ?(
 type IDRef = string;
 
 /*
-type SyntheticEvent<+T> = $ReadOnly<{|
+type SyntheticEvent<+T> = Readonly<{|
   ...T,
   bubbles: ?boolean,
   cancelable: ?boolean,
@@ -173,7 +173,7 @@ type SyntheticEvent<+T> = $ReadOnly<{|
 |}>;
 */
 
-type StrictClickEvent = $ReadOnly<{|
+type StrictClickEvent = Readonly<{|
   altKey: boolean,
   button: number,
   ctrlKey: boolean,
@@ -188,7 +188,7 @@ type StrictClickEvent = $ReadOnly<{|
   type: 'click'
 |}>;
 
-export type StrictReactDOMProps = $ReadOnly<{
+export type StrictReactDOMProps = Readonly<{
   ...ReactStrictDOMDataProps,
 
   // ARIA props
@@ -253,7 +253,7 @@ export type StrictReactDOMProps = $ReadOnly<{
   onFullscreenChange?: $FlowFixMe,
   onFullscreenError?: $FlowFixMe,
   onGotPointerCapture?: $FlowFixMe,
-  onKeyDown?: (event: $ReadOnly<{ key: string, type: ?string, ... }>) => void,
+  onKeyDown?: (event: Readonly<{ key: string, type: ?string, ... }>) => void,
   onKeyUp?: $FlowFixMe,
   onLostPointerCapture?: $FlowFixMe,
   onPaste?: $FlowFixMe,
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMSelectProps.js b/packages/react-strict-dom/src/types/StrictReactDOMSelectProps.js
index a3981b07..04a4fb53 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMSelectProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMSelectProps.js
@@ -9,7 +9,7 @@
 
 import type { AutoComplete, StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMSelectProps = $ReadOnly<{
+export type StrictReactDOMSelectProps = Readonly<{
   ...StrictReactDOMProps,
   autoComplete?: AutoComplete,
   defaultValue?: ?(Stringish | Array<Stringish>),
diff --git a/packages/react-strict-dom/src/types/StrictReactDOMTextAreaProps.js b/packages/react-strict-dom/src/types/StrictReactDOMTextAreaProps.js
index e0f4ecdb..313a81eb 100644
--- a/packages/react-strict-dom/src/types/StrictReactDOMTextAreaProps.js
+++ b/packages/react-strict-dom/src/types/StrictReactDOMTextAreaProps.js
@@ -9,7 +9,7 @@
 
 import type { AutoComplete, StrictReactDOMProps } from './StrictReactDOMProps';
 
-export type StrictReactDOMTextAreaProps = $ReadOnly<{
+export type StrictReactDOMTextAreaProps = Readonly<{
   ...StrictReactDOMProps,
   autoComplete?: AutoComplete,
   defaultValue?: ?Stringish,
diff --git a/packages/react-strict-dom/src/types/Utilities.js b/packages/react-strict-dom/src/types/Utilities.js
index 4769de2c..c935a84d 100644
--- a/packages/react-strict-dom/src/types/Utilities.js
+++ b/packages/react-strict-dom/src/types/Utilities.js
@@ -7,4 +7,4 @@
  * @flow strict
  */
 
-export type ReactRef<T> = { -current: T | null, ... } | ((T | null) => mixed);
+export type ReactRef<T> = { -current: T | null, ... } | ((T | null) => unknown);
diff --git a/packages/react-strict-dom/src/types/react.js b/packages/react-strict-dom/src/types/react.js
index fdbf4aa8..4210d2f7 100644
--- a/packages/react-strict-dom/src/types/react.js
+++ b/packages/react-strict-dom/src/types/react.js
@@ -9,6 +9,6 @@
 
 import * as React from 'react';
 
-export type CallbackRef<T> = (node: T | null) => mixed;
+export type CallbackRef<T> = (node: T | null) => unknown;
 export type ObjectRef<T> = { -current: T, ... };
 export type Ref<T> = CallbackRef<T> | ObjectRef<T | null> | React.RefObject<T>;
diff --git a/packages/react-strict-dom/src/types/renderer.native.js b/packages/react-strict-dom/src/types/renderer.native.js
index 8254fc93..703cc602 100644
--- a/packages/react-strict-dom/src/types/renderer.native.js
+++ b/packages/react-strict-dom/src/types/renderer.native.js
@@ -124,20 +124,20 @@ type ReactNativeProps = {
 };
 
 type ReactNativeTransform =
-  | $ReadOnly<{ matrix: number[] }>
-  | $ReadOnly<{ perspective: number }>
-  | $ReadOnly<{ rotate: string }>
-  | $ReadOnly<{ rotateX: string }>
-  | $ReadOnly<{ rotateY: string }>
-  | $ReadOnly<{ rotateZ: string }>
-  | $ReadOnly<{ scale: number }>
-  | $ReadOnly<{ scaleX: number }>
-  | $ReadOnly<{ scaleY: number }>
-  | $ReadOnly<{ scaleZ: number }>
-  | $ReadOnly<{ translateX: number | string }>
-  | $ReadOnly<{ translateY: number | string }>
-  | $ReadOnly<{ skewX: string }>
-  | $ReadOnly<{ skewY: string }>;
+  | Readonly<{ matrix: number[] }>
+  | Readonly<{ perspective: number }>
+  | Readonly<{ rotate: string }>
+  | Readonly<{ rotateX: string }>
+  | Readonly<{ rotateY: string }>
+  | Readonly<{ rotateZ: string }>
+  | Readonly<{ scale: number }>
+  | Readonly<{ scaleX: number }>
+  | Readonly<{ scaleY: number }>
+  | Readonly<{ scaleZ: number }>
+  | Readonly<{ translateX: number | string }>
+  | Readonly<{ translateY: number | string }>
+  | Readonly<{ skewX: string }>
+  | Readonly<{ skewY: string }>;
 
 type ReactNativeStyleValue =
   | number
diff --git a/packages/react-strict-dom/src/types/renderer.web.js b/packages/react-strict-dom/src/types/renderer.web.js
index 76672427..8e175d6f 100644
--- a/packages/react-strict-dom/src/types/renderer.web.js
+++ b/packages/react-strict-dom/src/types/renderer.web.js
@@ -7,8 +7,8 @@
  * @flow strict
  */
 
-export type ReactDOMStyleProps = $ReadOnly<{
+export type ReactDOMStyleProps = Readonly<{
   className?: string,
   'data-style-src'?: string,
-  style?: $ReadOnly<{ [string]: string | number }>
+  style?: Readonly<{ [string]: string | number }>
 }>;
diff --git a/packages/react-strict-dom/src/types/styles.js b/packages/react-strict-dom/src/types/styles.js
index 797fa5ee..b6190c75 100644
--- a/packages/react-strict-dom/src/types/styles.js
+++ b/packages/react-strict-dom/src/types/styles.js
@@ -20,10 +20,10 @@ import typeof * as TStyleX from '@stylexjs/stylex';
 export type Style = InlineStyles;
 
 export type Styles = StyleXArray<
-  StyleXStyles<> | Theme<VarGroup<{ +[string]: mixed }>>
+  StyleXStyles<> | Theme<VarGroup<{ +[string]: unknown }>>
 >;
 
-export type IStyleX = $ReadOnly<{
+export type IStyleX = Readonly<{
   create: TStyleX['create'],
   createTheme: TStyleX['createTheme'],
   defineConsts: TStyleX['defineConsts'],
@@ -35,5 +35,5 @@ export type IStyleX = $ReadOnly<{
   ...
 }>;
 
-export type MutableCustomProperties = { [string]: mixed };
-export type CustomProperties = $ReadOnly<MutableCustomProperties>;
+export type MutableCustomProperties = { [string]: unknown };
+export type CustomProperties = Readonly<MutableCustomProperties>;
diff --git a/packages/react-strict-dom/src/web/css/merge.js b/packages/react-strict-dom/src/web/css/merge.js
index 5ff06845..d8a3daf1 100644
--- a/packages/react-strict-dom/src/web/css/merge.js
+++ b/packages/react-strict-dom/src/web/css/merge.js
@@ -11,22 +11,22 @@
 
 import { styleq } from 'styleq';
 
-type CompiledStyle = $ReadOnly<{
+type CompiledStyle = Readonly<{
   $$css: true,
   [key: string]: string
 }>;
 
-type InlineStyle = $ReadOnly<{
+type InlineStyle = Readonly<{
   $$css?: void,
   [key: string]: string
 }>;
 
-type StylesArray<+T> = T | $ReadOnlyArray<StylesArray<T>>;
+type StylesArray<+T> = T | ReadonlyArray<StylesArray<T>>;
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   className?: string,
   'data-style-src'?: string,
-  style?: $ReadOnly<{ [string]: string | number }>
+  style?: Readonly<{ [string]: string | number }>
 }>;
 
 const optimizedStyleq = styleq.factory({
@@ -38,9 +38,9 @@ const optimizedStyleq = styleq.factory({
 });
 
 export function merge(
-  ...styles: $ReadOnlyArray<
+  ...styles: ReadonlyArray<
     StylesArray<
-      ?boolean | ?CompiledStyle | ?$ReadOnly<[CompiledStyle, InlineStyle]>
+      ?boolean | ?CompiledStyle | ?Readonly<[CompiledStyle, InlineStyle]>
     >
   >
 ): Props {
@@ -48,7 +48,7 @@ export function merge(
   const result: {
     className?: string,
     'data-style-src'?: string,
-    style?: $ReadOnly<{ [string]: string | number }>
+    style?: Readonly<{ [string]: string | number }>
   } = {};
   if (className != null && className !== '') {
     result.className = className;
diff --git a/packages/react-strict-dom/src/web/html.js b/packages/react-strict-dom/src/web/html.js
index dc60eb9e..944a23d1 100644
--- a/packages/react-strict-dom/src/web/html.js
+++ b/packages/react-strict-dom/src/web/html.js
@@ -28,7 +28,10 @@ import { defaultStyles } from './runtime';
 export const a: component(
   ref?: React.RefSetter<HTMLAnchorElement>,
   ...StrictReactDOMAnchorProps
-) = createStrict('a', defaultStyles.a);
+) = createStrict<HTMLAnchorElement, StrictReactDOMAnchorProps>(
+  'a',
+  defaultStyles.a
+);
 
 /**
  * "article" (block)
@@ -36,7 +39,10 @@ export const a: component(
 export const article: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('article', defaultStyles.article);
+) = createStrict<HTMLElement, StrictReactDOMProps>(
+  'article',
+  defaultStyles.article
+);
 
 /**
  * "aside" (block)
@@ -44,7 +50,10 @@ export const article: component(
 export const aside: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('aside', defaultStyles.aside);
+) = createStrict<HTMLElement, StrictReactDOMProps>(
+  'aside',
+  defaultStyles.aside
+);
 
 /**
  * "b" (inline)
@@ -52,7 +61,7 @@ export const aside: component(
 export const b: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('b', defaultStyles.b);
+) = createStrict<HTMLElement, StrictReactDOMProps>('b', defaultStyles.b);
 
 /**
  * "bdi" (inline)
@@ -60,7 +69,7 @@ export const b: component(
 export const bdi: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('bdi', defaultStyles.bdi);
+) = createStrict<HTMLElement, StrictReactDOMProps>('bdi', defaultStyles.bdi);
 
 /**
  * "bdo" (inline)
@@ -68,7 +77,7 @@ export const bdi: component(
 export const bdo: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('bdo', defaultStyles.bdo);
+) = createStrict<HTMLElement, StrictReactDOMProps>('bdo', defaultStyles.bdo);
 
 /**
  * "blockquote" (block)
@@ -76,7 +85,10 @@ export const bdo: component(
 export const blockquote: component(
   ref?: React.RefSetter<HTMLQuoteElement>,
   ...StrictReactDOMProps
-) = createStrict('blockquote', defaultStyles.blockquote);
+) = createStrict<HTMLQuoteElement, StrictReactDOMProps>(
+  'blockquote',
+  defaultStyles.blockquote
+);
 
 /**
  * "br"
@@ -84,7 +96,7 @@ export const blockquote: component(
 export const br: component(
   ref?: React.RefSetter<HTMLBRElement>,
   ...StrictReactDOMProps
-) = createStrict('br', defaultStyles.br);
+) = createStrict<HTMLBRElement, StrictReactDOMProps>('br', defaultStyles.br);
 
 /**
  * "button" (inline-block)
@@ -92,7 +104,10 @@ export const br: component(
 export const button: component(
   ref?: React.RefSetter<HTMLButtonElement>,
   ...StrictReactDOMButtonProps
-) = createStrict('button', defaultStyles.button);
+) = createStrict<HTMLButtonElement, StrictReactDOMButtonProps>(
+  'button',
+  defaultStyles.button
+);
 
 /**
  * "code" (inline)
@@ -100,7 +115,7 @@ export const button: component(
 export const code: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('code', defaultStyles.code);
+) = createStrict<HTMLElement, StrictReactDOMProps>('code', defaultStyles.code);
 
 /**
  * "del" (inline)
@@ -108,7 +123,7 @@ export const code: component(
 export const del: component(
   ref?: React.RefSetter<HTMLModElement>,
   ...StrictReactDOMProps
-) = createStrict('del', defaultStyles.del);
+) = createStrict<HTMLModElement, StrictReactDOMProps>('del', defaultStyles.del);
 
 /**
  * "div" (block)
@@ -116,7 +131,7 @@ export const del: component(
 export const div: component(
   ref?: React.RefSetter<HTMLDivElement>,
   ...StrictReactDOMProps
-) = createStrict('div', defaultStyles.div);
+) = createStrict<HTMLDivElement, StrictReactDOMProps>('div', defaultStyles.div);
 
 /**
  * "em" (inline)
@@ -124,7 +139,7 @@ export const div: component(
 export const em: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('em', defaultStyles.em);
+) = createStrict<HTMLElement, StrictReactDOMProps>('em', defaultStyles.em);
 
 /**
  * "fieldset" (block)
@@ -132,7 +147,10 @@ export const em: component(
 export const fieldset: component(
   ref?: React.RefSetter<HTMLFieldSetElement>,
   ...StrictReactDOMProps
-) = createStrict('fieldset', defaultStyles.fieldset);
+) = createStrict<HTMLFieldSetElement, StrictReactDOMProps>(
+  'fieldset',
+  defaultStyles.fieldset
+);
 
 /**
  * "footer" (block)
@@ -140,7 +158,10 @@ export const fieldset: component(
 export const footer: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('footer', defaultStyles.footer);
+) = createStrict<HTMLElement, StrictReactDOMProps>(
+  'footer',
+  defaultStyles.footer
+);
 
 /**
  * "form" (block)
@@ -148,7 +169,10 @@ export const footer: component(
 export const form: component(
   ref?: React.RefSetter<HTMLFormElement>,
   ...StrictReactDOMProps
-) = createStrict('form', defaultStyles.form);
+) = createStrict<HTMLFormElement, StrictReactDOMProps>(
+  'form',
+  defaultStyles.form
+);
 
 /**
  * "h1-h6" (block)
@@ -156,27 +180,45 @@ export const form: component(
 export const h1: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrict('h1', defaultStyles.h1);
+) = createStrict<HTMLHeadingElement, StrictReactDOMProps>(
+  'h1',
+  defaultStyles.h1
+);
 export const h2: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrict('h2', defaultStyles.h2);
+) = createStrict<HTMLHeadingElement, StrictReactDOMProps>(
+  'h2',
+  defaultStyles.h2
+);
 export const h3: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrict('h3', defaultStyles.h3);
+) = createStrict<HTMLHeadingElement, StrictReactDOMProps>(
+  'h3',
+  defaultStyles.h3
+);
 export const h4: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrict('h4', defaultStyles.h4);
+) = createStrict<HTMLHeadingElement, StrictReactDOMProps>(
+  'h4',
+  defaultStyles.h4
+);
 export const h5: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrict('h5', defaultStyles.h5);
+) = createStrict<HTMLHeadingElement, StrictReactDOMProps>(
+  'h5',
+  defaultStyles.h5
+);
 export const h6: component(
   ref?: React.RefSetter<HTMLHeadingElement>,
   ...StrictReactDOMProps
-) = createStrict('h6', defaultStyles.h6);
+) = createStrict<HTMLHeadingElement, StrictReactDOMProps>(
+  'h6',
+  defaultStyles.h6
+);
 
 /**
  * "header" (block)
@@ -184,7 +226,10 @@ export const h6: component(
 export const header: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('header', defaultStyles.header);
+) = createStrict<HTMLElement, StrictReactDOMProps>(
+  'header',
+  defaultStyles.header
+);
 
 /**
  * "hr" (block)
@@ -192,7 +237,7 @@ export const header: component(
 export const hr: component(
   ref?: React.RefSetter<HTMLHRElement>,
   ...StrictReactDOMProps
-) = createStrict('hr', defaultStyles.hr);
+) = createStrict<HTMLHRElement, StrictReactDOMProps>('hr', defaultStyles.hr);
 
 /**
  * "i" (inline)
@@ -200,7 +245,7 @@ export const hr: component(
 export const i: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('i', defaultStyles.i);
+) = createStrict<HTMLElement, StrictReactDOMProps>('i', defaultStyles.i);
 
 /**
  * "img" (inline)
@@ -208,7 +253,10 @@ export const i: component(
 export const img: component(
   ref?: React.RefSetter<HTMLImageElement>,
   ...StrictReactDOMImageProps
-) = createStrict('img', defaultStyles.img);
+) = createStrict<HTMLImageElement, StrictReactDOMImageProps>(
+  'img',
+  defaultStyles.img
+);
 
 /**
  * "input" (inline-block)
@@ -216,7 +264,10 @@ export const img: component(
 export const input: component(
   ref?: React.RefSetter<HTMLInputElement>,
   ...StrictReactDOMInputProps
-) = createStrict('input', defaultStyles.input);
+) = createStrict<HTMLInputElement, StrictReactDOMInputProps>(
+  'input',
+  defaultStyles.input
+);
 
 /**
  * "ins" (inline)
@@ -224,7 +275,7 @@ export const input: component(
 export const ins: component(
   ref?: React.RefSetter<HTMLModElement>,
   ...StrictReactDOMProps
-) = createStrict('ins', defaultStyles.ins);
+) = createStrict<HTMLModElement, StrictReactDOMProps>('ins', defaultStyles.ins);
 
 /**
  * "kbd" (inline)
@@ -232,7 +283,7 @@ export const ins: component(
 export const kbd: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('kbd', defaultStyles.kbd);
+) = createStrict<HTMLElement, StrictReactDOMProps>('kbd', defaultStyles.kbd);
 
 /**
  * "label" (inline)
@@ -240,7 +291,10 @@ export const kbd: component(
 export const label: component(
   ref?: React.RefSetter<HTMLLabelElement>,
   ...StrictReactDOMLabelProps
-) = createStrict('label', defaultStyles.label);
+) = createStrict<HTMLLabelElement, StrictReactDOMLabelProps>(
+  'label',
+  defaultStyles.label
+);
 
 /**
  * "li" (block)
@@ -248,7 +302,10 @@ export const label: component(
 export const li: component(
   ref?: React.RefSetter<HTMLLIElement>,
   ...StrictReactDOMListItemProps
-) = createStrict('li', defaultStyles.li);
+) = createStrict<HTMLLIElement, StrictReactDOMListItemProps>(
+  'li',
+  defaultStyles.li
+);
 
 /**
  * "main" (block)
@@ -256,7 +313,7 @@ export const li: component(
 export const main: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('main', defaultStyles.main);
+) = createStrict<HTMLElement, StrictReactDOMProps>('main', defaultStyles.main);
 
 /**
  * "mark" (inline)
@@ -264,7 +321,7 @@ export const main: component(
 export const mark: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('mark', defaultStyles.mark);
+) = createStrict<HTMLElement, StrictReactDOMProps>('mark', defaultStyles.mark);
 
 /**
  * "nav" (block)
@@ -272,7 +329,7 @@ export const mark: component(
 export const nav: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('nav', defaultStyles.nav);
+) = createStrict<HTMLElement, StrictReactDOMProps>('nav', defaultStyles.nav);
 
 /**
  * "ol" (block)
@@ -280,7 +337,7 @@ export const nav: component(
 export const ol: component(
   ref?: React.RefSetter<HTMLOListElement>,
   ...StrictReactDOMProps
-) = createStrict('ol', defaultStyles.ol);
+) = createStrict<HTMLOListElement, StrictReactDOMProps>('ol', defaultStyles.ol);
 
 /**
  * "optgroup"
@@ -288,7 +345,10 @@ export const ol: component(
 export const optgroup: component(
   ref?: React.RefSetter<HTMLOptGroupElement>,
   ...StrictReactDOMOptionGroupProps
-) = createStrict('optgroup', defaultStyles.optgroup);
+) = createStrict<HTMLOptGroupElement, StrictReactDOMOptionGroupProps>(
+  'optgroup',
+  defaultStyles.optgroup
+);
 
 /**
  * "option"
@@ -307,7 +367,10 @@ export const option: component(
 export const p: component(
   ref?: React.RefSetter<HTMLParagraphElement>,
   ...StrictReactDOMProps
-) = createStrict('p', defaultStyles.p);
+) = createStrict<HTMLParagraphElement, StrictReactDOMProps>(
+  'p',
+  defaultStyles.p
+);
 
 /**
  * "pre" (block)
@@ -315,7 +378,7 @@ export const p: component(
 export const pre: component(
   ref?: React.RefSetter<HTMLPreElement>,
   ...StrictReactDOMProps
-) = createStrict('pre', defaultStyles.pre);
+) = createStrict<HTMLPreElement, StrictReactDOMProps>('pre', defaultStyles.pre);
 
 /**
  * "s" (inline)
@@ -323,7 +386,7 @@ export const pre: component(
 export const s: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('s', defaultStyles.s);
+) = createStrict<HTMLElement, StrictReactDOMProps>('s', defaultStyles.s);
 
 /**
  * "section" (block)
@@ -331,7 +394,10 @@ export const s: component(
 export const section: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('section', defaultStyles.section);
+) = createStrict<HTMLElement, StrictReactDOMProps>(
+  'section',
+  defaultStyles.section
+);
 
 /**
  * "select" (inline-block)
@@ -339,7 +405,10 @@ export const section: component(
 export const select: component(
   ref?: React.RefSetter<HTMLSelectElement>,
   ...StrictReactDOMSelectProps
-) = createStrict('select', defaultStyles.select);
+) = createStrict<HTMLSelectElement, StrictReactDOMSelectProps>(
+  'select',
+  defaultStyles.select
+);
 
 /**
  * "span" (inline)
@@ -347,7 +416,10 @@ export const select: component(
 export const span: component(
   ref?: React.RefSetter<HTMLSpanElement>,
   ...StrictReactDOMProps
-) = createStrict('span', defaultStyles.span);
+) = createStrict<HTMLSpanElement, StrictReactDOMProps>(
+  'span',
+  defaultStyles.span
+);
 
 /**
  * "strong" (inline)
@@ -355,7 +427,10 @@ export const span: component(
 export const strong: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('strong', defaultStyles.strong);
+) = createStrict<HTMLElement, StrictReactDOMProps>(
+  'strong',
+  defaultStyles.strong
+);
 
 /**
  * "sub" (inline)
@@ -363,7 +438,7 @@ export const strong: component(
 export const sub: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('sub', defaultStyles.sub);
+) = createStrict<HTMLElement, StrictReactDOMProps>('sub', defaultStyles.sub);
 
 /**
  * "sup" (inline)
@@ -371,7 +446,7 @@ export const sub: component(
 export const sup: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('sup', defaultStyles.sup);
+) = createStrict<HTMLElement, StrictReactDOMProps>('sup', defaultStyles.sup);
 
 /**
  * "textarea" (inline-block)
@@ -379,7 +454,10 @@ export const sup: component(
 export const textarea: component(
   ref?: React.RefSetter<HTMLTextAreaElement>,
   ...StrictReactDOMTextAreaProps
-) = createStrict('textarea', defaultStyles.textarea);
+) = createStrict<HTMLTextAreaElement, StrictReactDOMTextAreaProps>(
+  'textarea',
+  defaultStyles.textarea
+);
 
 /**
  * "u" (inline)
@@ -387,7 +465,7 @@ export const textarea: component(
 export const u: component(
   ref?: React.RefSetter<HTMLElement>,
   ...StrictReactDOMProps
-) = createStrict('u', defaultStyles.u);
+) = createStrict<HTMLElement, StrictReactDOMProps>('u', defaultStyles.u);
 
 /**
  * "ul" (block)
@@ -395,4 +473,4 @@ export const u: component(
 export const ul: component(
   ref?: React.RefSetter<HTMLUListElement>,
   ...StrictReactDOMProps
-) = createStrict('ul', defaultStyles.ul);
+) = createStrict<HTMLUListElement, StrictReactDOMProps>('ul', defaultStyles.ul);
diff --git a/packages/react-strict-dom/src/web/modules/createStrictDOMComponent.js b/packages/react-strict-dom/src/web/modules/createStrictDOMComponent.js
index e582ed24..78e86020 100644
--- a/packages/react-strict-dom/src/web/modules/createStrictDOMComponent.js
+++ b/packages/react-strict-dom/src/web/modules/createStrictDOMComponent.js
@@ -27,7 +27,7 @@ function validateStrictProps(props: any) {
   });
 }
 
-export function createStrictDOMComponent<T, P: StrictProps>(
+export function createStrictDOMComponent<T, P extends StrictProps>(
   TagName: string,
   defaultStyle: StrictProps['style']
 ): component(ref?: React.RefSetter<T>, ...P) {
@@ -51,7 +51,7 @@ export function createStrictDOMComponent<T, P: StrictProps>(
     }
     if (props.role != null) {
       // "presentation" synonym has wider browser support
-      // $FlowFixMe
+      // $FlowFixMe[incompatible-type]
       hostProps.role = props.role === 'none' ? 'presentation' : props.role;
     }
     if (TagName === 'button') {
@@ -63,7 +63,7 @@ export function createStrictDOMComponent<T, P: StrictProps>(
     /**
      * get host style props
      */
-    // $FlowFixMe
+    // $FlowFixMe[incompatible-type]
     const hostStyleProps: ReactDOMStyleProps = merge([
       debugStyle,
       defaultStyle,
diff --git a/packages/react-strict-dom/src/web/runtime.js b/packages/react-strict-dom/src/web/runtime.js
index c1b08bd2..e7b24009 100644
--- a/packages/react-strict-dom/src/web/runtime.js
+++ b/packages/react-strict-dom/src/web/runtime.js
@@ -81,52 +81,88 @@ const styles = stylex.create({
   }
 });
 
+// $FlowFixMe[incompatible-type]
 const a: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const article: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const aside: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const b: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const bdi: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const bdo: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const blockquote: StrictReactDOMPropsStyle = styles.block;
 const br: StrictReactDOMPropsStyle = null;
+// $FlowFixMe[incompatible-type]
 const button: StrictReactDOMPropsStyle = [styles.inlineblock, styles.button];
+// $FlowFixMe[incompatible-type]
 const code: StrictReactDOMPropsStyle = [styles.inline, styles.codePre];
 const del: StrictReactDOMPropsStyle = null;
+// $FlowFixMe[incompatible-type]
 const div: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const em: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const fieldset: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const footer: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const form: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const heading: StrictReactDOMPropsStyle = [styles.block, styles.heading];
+// $FlowFixMe[incompatible-type]
 const header: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const hr: StrictReactDOMPropsStyle = [styles.block, styles.hr];
+// $FlowFixMe[incompatible-type]
 const i: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const img: StrictReactDOMPropsStyle = styles.img;
+// $FlowFixMe[incompatible-type]
 const input: StrictReactDOMPropsStyle = [styles.inlineblock, styles.input];
 const ins: StrictReactDOMPropsStyle = null;
 const kbd: StrictReactDOMPropsStyle = null;
+// $FlowFixMe[incompatible-type]
 const label: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const li: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const main: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const mark: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const nav: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const ol: StrictReactDOMPropsStyle = [styles.list, styles.block];
 const optgroup: StrictReactDOMPropsStyle = null;
 const option: StrictReactDOMPropsStyle = null;
+// $FlowFixMe[incompatible-type]
 const p: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const pre: StrictReactDOMPropsStyle = [styles.block, styles.codePre];
 const s: StrictReactDOMPropsStyle = null;
+// $FlowFixMe[incompatible-type]
 const section: StrictReactDOMPropsStyle = styles.block;
+// $FlowFixMe[incompatible-type]
 const select: StrictReactDOMPropsStyle = styles.inlineblock;
+// $FlowFixMe[incompatible-type]
 const span: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const strong: StrictReactDOMPropsStyle = [styles.inline, styles.strong];
+// $FlowFixMe[incompatible-type]
 const sub: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const sup: StrictReactDOMPropsStyle = styles.inline;
+// $FlowFixMe[incompatible-type]
 const textarea: StrictReactDOMPropsStyle = [
   styles.inlineblock,
   styles.textarea
 ];
 const u: StrictReactDOMPropsStyle = null;
+// $FlowFixMe[incompatible-type]
 const ul: StrictReactDOMPropsStyle = [styles.list, styles.block];
 
 export const defaultStyles = {