diff --git a/packages/react-native-reanimated/src/animation/util.ts b/packages/react-native-reanimated/src/animation/util.ts
index 2466ac9fa55c..68886be0766b 100644
--- a/packages/react-native-reanimated/src/animation/util.ts
+++ b/packages/react-native-reanimated/src/animation/util.ts
@@ -29,6 +29,7 @@ import type {
 } from '../commonTypes';
 import { ReduceMotion } from '../commonTypes';
 import type { EasingFunctionFactory } from '../Easing';
+import type { AnimatedUpdate } from '../hook/commonTypes';
 import { ReducedMotionManager } from '../ReducedMotion';
 import type { HigherOrderAnimation, StyleLayoutAnimation } from './commonTypes';
 import type {
@@ -106,7 +107,7 @@ export function assertEasingIsWorklet(
   }
 }
 
-export function initialUpdaterRun<T>(updater: () => T) {
+export function initialUpdaterRun<TResult>(updater: () => TResult): TResult {
   IN_STYLE_UPDATER.current = true;
   const result = updater();
   IN_STYLE_UPDATER.current = false;
diff --git a/packages/react-native-reanimated/src/commonTypes.ts b/packages/react-native-reanimated/src/commonTypes.ts
index 0938f1f69e8a..89a8e2eca0e7 100644
--- a/packages/react-native-reanimated/src/commonTypes.ts
+++ b/packages/react-native-reanimated/src/commonTypes.ts
@@ -14,7 +14,7 @@ import type { SerializableRef, WorkletFunction } from 'react-native-worklets';
 
 import type { Maybe } from './common/types';
 import type { CSSAnimationProperties, CSSTransitionProperties } from './css';
-import type { AnyRecord } from './css/types';
+import type { AnyRecord, UnknownRecord } from './css/types';
 import type { EasingFunctionFactory } from './Easing';
 
 type LayoutAnimationOptions =
diff --git a/packages/react-native-reanimated/src/createAnimatedComponent/PropsFilter.tsx b/packages/react-native-reanimated/src/createAnimatedComponent/PropsFilter.tsx
index 2002e4f0a8fc..bf2a0e7c3486 100644
--- a/packages/react-native-reanimated/src/createAnimatedComponent/PropsFilter.tsx
+++ b/packages/react-native-reanimated/src/createAnimatedComponent/PropsFilter.tsx
@@ -44,7 +44,7 @@ export class PropsFilter implements IPropsFilter {
               this._initialPropsMap.set(handle, {
                 ...handle.initial.value,
                 ...initialUpdaterRun(handle.initial.updater),
-              } as StyleProps);
+              });
             }
 
             return this._initialPropsMap.get(handle) ?? {};
diff --git a/packages/react-native-reanimated/src/css/types/helpers.ts b/packages/react-native-reanimated/src/css/types/helpers.ts
index e1c94f5d1123..945eedf28422 100644
--- a/packages/react-native-reanimated/src/css/types/helpers.ts
+++ b/packages/react-native-reanimated/src/css/types/helpers.ts
@@ -3,6 +3,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export type AnyRecord = Record<string, any>;
 
+export type UnknownRecord = Record<string, unknown>;
+
 type NoUndef<T> = T extends undefined ? never : T;
 
 export type Repeat<
diff --git a/packages/react-native-reanimated/src/hook/commonTypes.ts b/packages/react-native-reanimated/src/hook/commonTypes.ts
index bfe7d414403e..4ead211e955e 100644
--- a/packages/react-native-reanimated/src/hook/commonTypes.ts
+++ b/packages/react-native-reanimated/src/hook/commonTypes.ts
@@ -7,15 +7,17 @@ import type {
   TextStyle,
   ViewStyle,
 } from 'react-native';
-import type { WorkletFunction } from 'react-native-worklets';
 
 import type {
-  AnimatedPropsAdapterFunction,
-  AnimatedStyle,
+  AnimatableValue,
+  AnimationObject,
+  AnimationsRecord,
+  NestedObject,
+  NestedObjectValues,
   ShadowNodeWrapper,
   WrapperRef,
 } from '../commonTypes';
-import type { AnimatedProps } from '../createAnimatedComponent/commonTypes';
+import type { AnyRecord, UnknownRecord } from '../css/types';
 import type { ReanimatedHTMLElement } from '../ReanimatedModule/js-reanimated';
 import type { ViewDescriptorsSet } from '../ViewDescriptorsSet';
 
@@ -87,31 +89,27 @@ export interface IWorkletEventHandler<Event extends object> {
   unregisterFromEvents: (viewTag: number) => void;
 }
 
-export interface AnimatedStyleHandle<
-  Style extends DefaultStyle | AnimatedProps = DefaultStyle,
-> {
+export type AnimatedValuesUpdate = NestedObject<
+  AnimationObject | AnimatableValue
+>;
+
+export type AnimatedUpdaterHandle<TValues extends object = UnknownRecord> = {
   viewDescriptors: ViewDescriptorsSet;
   initial: {
-    value: AnimatedStyle<Style>;
-    updater: () => AnimatedStyle<Style>;
+    value: TValues;
+    updater: () => AnimatedValuesUpdate;
   };
-}
+};
 
-export interface JestAnimatedStyleHandle<
-  Style extends DefaultStyle | AnimatedProps = DefaultStyle,
-> extends AnimatedStyleHandle<Style> {
-  jestAnimatedValues:
-    | RefObject<AnimatedStyle<Style>>
-    | RefObject<AnimatedProps>;
-  toJSON: () => string;
-}
+export type AnimatedStyleHandle<TStyle extends DefaultStyle = DefaultStyle> =
+  AnimatedUpdaterHandle<TStyle>;
+
+export type AnimatedPropsHandle<TProps extends object = UnknownRecord> =
+  AnimatedUpdaterHandle<TProps>;
 
-export type UseAnimatedStyleInternal<Style extends DefaultStyle> = (
-  updater: WorkletFunction<[], Style> | (() => Style),
-  dependencies?: DependencyList | null,
-  adapters?:
-    | AnimatedPropsAdapterFunction
-    | AnimatedPropsAdapterFunction[]
-    | null,
-  isAnimatedProps?: boolean
-) => AnimatedStyleHandle<Style> | JestAnimatedStyleHandle<Style>;
+export type JestAnimatedUpdaterHandle<
+  TValues extends AnyRecord = UnknownRecord,
+> = AnimatedUpdaterHandle<TValues> & {
+  jestAnimatedValues: RefObject<TValues>;
+  toJSON: () => string;
+};
diff --git a/packages/react-native-reanimated/src/hook/index.ts b/packages/react-native-reanimated/src/hook/index.ts
index 2d44be5a2cb9..340a5dccb624 100644
--- a/packages/react-native-reanimated/src/hook/index.ts
+++ b/packages/react-native-reanimated/src/hook/index.ts
@@ -15,7 +15,7 @@ export type {
 } from './useAnimatedScrollHandler';
 export { useAnimatedScrollHandler } from './useAnimatedScrollHandler';
 export { useAnimatedSensor } from './useAnimatedSensor';
-export { useAnimatedStyle } from './useAnimatedStyle';
+export { useAnimatedStyle } from './useAnimatedUpdaterInternal';
 export { useComposedEventHandler } from './useComposedEventHandler';
 export type { DerivedValue } from './useDerivedValue';
 export { useDerivedValue } from './useDerivedValue';
diff --git a/packages/react-native-reanimated/src/hook/useAnimatedProps.ts b/packages/react-native-reanimated/src/hook/useAnimatedProps.ts
index 81d6ee4928e7..afd39bbfdc81 100644
--- a/packages/react-native-reanimated/src/hook/useAnimatedProps.ts
+++ b/packages/react-native-reanimated/src/hook/useAnimatedProps.ts
@@ -1,38 +1,14 @@
 'use strict';
-import { SHOULD_BE_USE_WEB } from '../common';
-import type { AnimatedPropsAdapterFunction } from '../commonTypes';
-import type { DependencyList, UseAnimatedStyleInternal } from './commonTypes';
-import { useAnimatedStyle } from './useAnimatedStyle';
 
-// TODO: we should make sure that when useAP is used we are not assigning styles
+import type { WorkletFunction } from 'react-native-worklets';
 
-type UseAnimatedProps = <Props extends object>(
-  updater: () => Partial<Props>,
-  dependencies?: DependencyList | null,
-  adapters?:
-    | AnimatedPropsAdapterFunction
-    | AnimatedPropsAdapterFunction[]
-    | null,
-  isAnimatedProps?: boolean
-) => Partial<Props>;
+import type { AnimatedPropsAdapterWorklet } from '../commonTypes';
+import type { AnimatedPropsHandle, DependencyList } from './commonTypes';
+import { useAnimatedUpdaterInternal } from './useAnimatedUpdaterInternal';
 
-function useAnimatedPropsJS<Props extends object>(
-  updater: () => Props,
-  deps?: DependencyList | null,
-  adapters?:
-    | AnimatedPropsAdapterFunction
-    | AnimatedPropsAdapterFunction[]
-    | null
-) {
-  return (useAnimatedStyle as UseAnimatedStyleInternal<Props>)(
-    updater,
-    deps,
-    adapters,
-    true
-  );
-}
+const HOOK_NAME = 'useAnimatedProps';
 
-const useAnimatedPropsNative = useAnimatedStyle;
+// TODO: we should make sure that when useAP is used we are not assigning styles
 
 /**
  * Lets you create an animated props object which can be animated using shared
@@ -42,12 +18,35 @@ const useAnimatedPropsNative = useAnimatedStyle;
  *   animate.
  * @param dependencies - An optional array of dependencies. Only relevant when
  *   using Reanimated without the Babel plugin on the Web.
- * @param adapters - An optional function or array of functions allowing to
- *   adopt prop naming between JS and the native side.
  * @returns An animated props object which has to be passed to `animatedProps`
  *   property of an Animated component that you want to animate.
  * @see https://docs.swmansion.com/react-native-reanimated/docs/core/useAnimatedProps
  */
-export const useAnimatedProps: UseAnimatedProps = SHOULD_BE_USE_WEB
-  ? (useAnimatedPropsJS as UseAnimatedProps)
-  : useAnimatedPropsNative;
+export function useAnimatedProps<TProps extends object>(
+  updater: WorkletFunction<[], TProps> | (() => TProps),
+  dependencies?: DependencyList | null
+): AnimatedPropsHandle<TProps>;
+
+/**
+ * @deprecated The `adapters` parameter is deprecated and will be removed in a
+ *   future version.
+ */
+export function useAnimatedProps<TProps extends object>(
+  updater: WorkletFunction<[], TProps> | (() => TProps),
+  dependencies?: DependencyList | null,
+  adapters?: AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[] | null
+): AnimatedPropsHandle<TProps>;
+
+export function useAnimatedProps<TProps extends object>(
+  updater: WorkletFunction<[], TProps> | (() => TProps),
+  dependencies?: DependencyList | null,
+  adapters?: AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[] | null
+): AnimatedPropsHandle<TProps> {
+  return useAnimatedUpdaterInternal(
+    HOOK_NAME,
+    updater,
+    dependencies,
+    adapters,
+    true
+  );
+}
diff --git a/packages/react-native-reanimated/src/hook/useAnimatedStyle.ts b/packages/react-native-reanimated/src/hook/useAnimatedStyle.ts
index b5463451d97d..21551c0ef36f 100644
--- a/packages/react-native-reanimated/src/hook/useAnimatedStyle.ts
+++ b/packages/react-native-reanimated/src/hook/useAnimatedStyle.ts
@@ -1,435 +1,16 @@
 'use strict';
-import type { RefObject } from 'react';
-import { useEffect, useRef } from 'react';
+
 import type { WorkletFunction } from 'react-native-worklets';
-import { isWorkletFunction, makeShareable } from 'react-native-worklets';
 
-import { initialUpdaterRun } from '../animation';
-import { IS_JEST, ReanimatedError, SHOULD_BE_USE_WEB } from '../common';
-import type {
-  AnimatedPropsAdapterFunction,
-  AnimatedPropsAdapterWorklet,
-  AnimatedStyle,
-  AnimationObject,
-  NestedObjectValues,
-  SharedValue,
-  StyleProps,
-  Timestamp,
-} from '../commonTypes';
-import { startMapper, stopMapper } from '../core';
-import type { AnimatedProps } from '../createAnimatedComponent/commonTypes';
-import { updateProps, updatePropsJestWrapper } from '../updateProps';
-import type { ViewDescriptorsSet } from '../ViewDescriptorsSet';
-import { makeViewDescriptorsSet } from '../ViewDescriptorsSet';
+import type { AnimatedPropsAdapterWorklet } from '../commonTypes';
 import type {
   AnimatedStyleHandle,
   DefaultStyle,
   DependencyList,
-  Descriptor,
-  JestAnimatedStyleHandle,
 } from './commonTypes';
-import { useSharedValue } from './useSharedValue';
-import {
-  buildWorkletsHash,
-  isAnimated,
-  shallowEqual,
-  validateAnimatedStyles,
-} from './utils';
-
-interface AnimatedState {
-  last: AnimatedStyle<any>;
-  animations: AnimatedStyle<any>;
-  isAnimationRunning: boolean;
-  isAnimationCancelled: boolean;
-}
-
-interface AnimatedUpdaterData {
-  initial: {
-    value: AnimatedStyle<any>;
-    updater: () => AnimatedStyle<any>;
-  };
-  remoteState: AnimatedState;
-  viewDescriptors: ViewDescriptorsSet;
-}
-
-function prepareAnimation(
-  frameTimestamp: number,
-  animatedProp: AnimatedStyle<any>,
-  lastAnimation: AnimatedStyle<any>,
-  lastValue: AnimatedStyle<any>
-): void {
-  'worklet';
-  if (Array.isArray(animatedProp)) {
-    animatedProp.forEach((prop, index) => {
-      prepareAnimation(
-        frameTimestamp,
-        prop,
-        lastAnimation && lastAnimation[index],
-        lastValue && lastValue[index]
-      );
-    });
-    // return animatedProp;
-  }
-  if (typeof animatedProp === 'object' && animatedProp.onFrame) {
-    const animation = animatedProp;
-
-    let value = animation.current;
-    if (lastValue !== undefined && lastValue !== null) {
-      if (typeof lastValue === 'object') {
-        if (lastValue.value !== undefined) {
-          // previously it was a shared value
-          value = lastValue.value;
-        } else if (lastValue.onFrame !== undefined) {
-          if (lastAnimation?.current !== undefined) {
-            // it was an animation before, copy its state
-            value = lastAnimation.current;
-          } else if (lastValue?.current !== undefined) {
-            // it was initialized
-            value = lastValue.current;
-          }
-        }
-      } else {
-        // previously it was a plain value, just set it as starting point
-        value = lastValue;
-      }
-    }
-
-    animation.callStart = (timestamp: Timestamp) => {
-      animation.onStart(animation, value, timestamp, lastAnimation);
-    };
-    animation.callStart(frameTimestamp);
-    animation.callStart = null;
-  } else if (typeof animatedProp === 'object') {
-    // it is an object
-    Object.keys(animatedProp).forEach((key) =>
-      prepareAnimation(
-        frameTimestamp,
-        animatedProp[key],
-        lastAnimation && lastAnimation[key],
-        lastValue && lastValue[key]
-      )
-    );
-  }
-}
-
-function runAnimations(
-  animation: AnimatedStyle<any>,
-  timestamp: Timestamp,
-  key: number | string,
-  result: AnimatedStyle<any>,
-  animationsActive: SharedValue<boolean>,
-  forceCopyAnimation?: boolean
-): boolean {
-  'worklet';
-  if (!animationsActive.value) {
-    return true;
-  }
-  if (Array.isArray(animation)) {
-    result[key] = [];
-    let allFinished = true;
-    forceCopyAnimation = key === 'boxShadow';
-    animation.forEach((entry, index) => {
-      if (
-        !runAnimations(
-          entry,
-          timestamp,
-          index,
-          result[key],
-          animationsActive,
-          forceCopyAnimation
-        )
-      ) {
-        allFinished = false;
-      }
-    });
-    return allFinished;
-  } else if (typeof animation === 'object' && animation.onFrame) {
-    let finished = true;
-    if (!animation.finished) {
-      if (animation.callStart) {
-        animation.callStart(timestamp);
-        animation.callStart = null;
-      }
-      finished = animation.onFrame(animation, timestamp);
-      animation.timestamp = timestamp;
-      if (finished) {
-        animation.finished = true;
-        animation.callback?.(true /* finished */);
-      }
-    }
-    /*
-     * If `animation.current` is a boxShadow object, spread its properties into a new object
-     * to avoid modifying the original reference. This ensures when `newValues` has a nested color prop, it stays unparsed
-     * in rgba format, allowing the animation to run correctly.
-     */
-    if (forceCopyAnimation) {
-      result[key] = { ...animation.current };
-    } else {
-      result[key] = animation.current;
-    }
-    return finished;
-  } else if (typeof animation === 'object') {
-    result[key] = {};
-    let allFinished = true;
-    Object.keys(animation).forEach((k) => {
-      if (
-        !runAnimations(
-          animation[k],
-          timestamp,
-          k,
-          result[key],
-          animationsActive,
-          forceCopyAnimation
-        )
-      ) {
-        allFinished = false;
-      }
-    });
-    return allFinished;
-  } else {
-    result[key] = animation;
-    return true;
-  }
-}
-
-function styleUpdater(
-  viewDescriptors: SharedValue<Descriptor[]>,
-  updater: WorkletFunction<[], AnimatedStyle<any>> | (() => AnimatedStyle<any>),
-  state: AnimatedState,
-  animationsActive: SharedValue<boolean>,
-  isAnimatedProps = false
-): void {
-  'worklet';
-  const animations = state.animations ?? {};
-  const newValues = updater() ?? {};
-  const oldValues = state.last;
-  const nonAnimatedNewValues: StyleProps = {};
-
-  let hasAnimations = false;
-  let frameTimestamp: number | undefined;
-  let hasNonAnimatedValues = false;
-  for (const key in newValues) {
-    const value = newValues[key];
-    if (isAnimated(value)) {
-      frameTimestamp =
-        global.__frameTimestamp || global._getAnimationTimestamp();
-      prepareAnimation(frameTimestamp, value, animations[key], oldValues[key]);
-      animations[key] = value;
-      hasAnimations = true;
-    } else {
-      hasNonAnimatedValues = true;
-      nonAnimatedNewValues[key] = value;
-      delete animations[key];
-    }
-  }
-
-  if (hasAnimations) {
-    const frame = (timestamp: Timestamp) => {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      const { animations, last, isAnimationCancelled } = state;
-      if (isAnimationCancelled) {
-        state.isAnimationRunning = false;
-        return;
-      }
-
-      const updates: AnimatedStyle<any> = {};
-      let allFinished = true;
-      for (const propName in animations) {
-        const finished = runAnimations(
-          animations[propName],
-          timestamp,
-          propName,
-          updates,
-          animationsActive
-        );
-        if (finished) {
-          /**
-           * If the animated prop is an array, we need to directly set each
-           * property (manually spread it). This prevents issues where the color
-           * prop might be incorrectly linked with its `toValue` and `current`
-           * states, causing abrupt transitions or 'jumps' in animation states.
-           */
-          if (Array.isArray(updates[propName])) {
-            updates[propName].forEach((obj: StyleProps) => {
-              for (const prop in obj) {
-                if (!last[propName] || typeof last[propName] !== 'object') {
-                  last[propName] = {};
-                }
-                last[propName][prop] = obj[prop];
-              }
-            });
-          } else {
-            last[propName] = updates[propName];
-          }
-          delete animations[propName];
-        } else {
-          allFinished = false;
-        }
-      }
-
-      if (updates) {
-        updateProps(viewDescriptors, updates);
-      }
-
-      if (!allFinished) {
-        requestAnimationFrame(frame);
-      } else {
-        state.isAnimationRunning = false;
-      }
-    };
-
-    state.animations = animations;
-    if (!state.isAnimationRunning) {
-      state.isAnimationCancelled = false;
-      state.isAnimationRunning = true;
-      frame(frameTimestamp!);
-    }
-
-    if (hasNonAnimatedValues) {
-      updateProps(viewDescriptors, nonAnimatedNewValues);
-    }
-  } else {
-    state.isAnimationCancelled = true;
-    state.animations = [];
-
-    if (!shallowEqual(oldValues, newValues)) {
-      updateProps(viewDescriptors, newValues, isAnimatedProps);
-    }
-  }
-  state.last = newValues;
-}
-
-function jestStyleUpdater(
-  viewDescriptors: SharedValue<Descriptor[]>,
-  updater: WorkletFunction<[], AnimatedStyle<any>> | (() => AnimatedStyle<any>),
-  state: AnimatedState,
-  animationsActive: SharedValue<boolean>,
-  animatedValues: RefObject<AnimatedStyle<any>>,
-  adapters: AnimatedPropsAdapterFunction[]
-): void {
-  'worklet';
-  const animations: AnimatedStyle<any> = state.animations ?? {};
-  const newValues = updater() ?? {};
-  const oldValues = state.last;
-
-  // extract animated props
-  let hasAnimations = false;
-  let frameTimestamp: number | undefined;
-  Object.keys(animations).forEach((key) => {
-    const value = newValues[key];
-    if (!isAnimated(value)) {
-      delete animations[key];
-    }
-  });
-  Object.keys(newValues).forEach((key) => {
-    const value = newValues[key];
-    if (isAnimated(value)) {
-      frameTimestamp =
-        global.__frameTimestamp || global._getAnimationTimestamp();
-      prepareAnimation(frameTimestamp, value, animations[key], oldValues[key]);
-      animations[key] = value;
-      hasAnimations = true;
-    }
-  });
-
-  function frame(timestamp: Timestamp) {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    const { animations, last, isAnimationCancelled } = state;
-    if (isAnimationCancelled) {
-      state.isAnimationRunning = false;
-      return;
-    }
+import { useAnimatedUpdaterInternal } from './useAnimatedUpdaterInternal';
 
-    const updates: AnimatedStyle<any> = {};
-    let allFinished = true;
-    Object.keys(animations).forEach((propName) => {
-      const finished = runAnimations(
-        animations[propName],
-        timestamp,
-        propName,
-        updates,
-        animationsActive
-      );
-      if (finished) {
-        last[propName] = updates[propName];
-        delete animations[propName];
-      } else {
-        allFinished = false;
-      }
-    });
-
-    if (Object.keys(updates).length) {
-      updatePropsJestWrapper(
-        viewDescriptors,
-        updates,
-        animatedValues,
-        adapters
-      );
-    }
-
-    if (!allFinished) {
-      requestAnimationFrame(frame);
-    } else {
-      state.isAnimationRunning = false;
-    }
-  }
-
-  if (hasAnimations) {
-    state.animations = animations;
-    if (!state.isAnimationRunning) {
-      state.isAnimationCancelled = false;
-      state.isAnimationRunning = true;
-      frame(frameTimestamp!);
-    }
-  } else {
-    state.isAnimationCancelled = true;
-    state.animations = [];
-  }
-
-  // calculate diff
-  state.last = newValues;
-
-  if (!shallowEqual(oldValues, newValues)) {
-    updatePropsJestWrapper(
-      viewDescriptors,
-      newValues,
-      animatedValues,
-      adapters
-    );
-  }
-}
-
-// check for invalid usage of shared values in returned object
-function checkSharedValueUsage(
-  prop: NestedObjectValues<AnimationObject>,
-  currentKey?: string
-): void {
-  if (Array.isArray(prop)) {
-    // if it's an array (i.ex. transform) validate all its elements
-    for (const element of prop) {
-      checkSharedValueUsage(element, currentKey);
-    }
-  } else if (
-    typeof prop === 'object' &&
-    prop !== null &&
-    prop.value === undefined
-  ) {
-    // if it's a nested object, run validation for all its props
-    for (const key of Object.keys(prop)) {
-      checkSharedValueUsage(prop[key], key);
-    }
-  } else if (
-    currentKey !== undefined &&
-    typeof prop === 'object' &&
-    prop !== null &&
-    prop.value !== undefined
-  ) {
-    // if shared value is passed instead of its value, throw an error
-    throw new ReanimatedError(
-      `Invalid value passed to \`${currentKey}\`, maybe you forgot to use \`.value\`?`
-    );
-  }
-}
+const HOOK_NAME = 'useAnimatedStyle';
 
 /**
  * Lets you create a styles object, similar to StyleSheet styles, which can be
@@ -443,164 +24,31 @@ function checkSharedValueUsage(
  *   property of an Animated component you want to animate.
  * @see https://docs.swmansion.com/react-native-reanimated/docs/core/useAnimatedStyle
  */
-// You cannot pass Shared Values to `useAnimatedStyle` directly.
-// @ts-expect-error This overload is required by our API.
-export function useAnimatedStyle<Style extends DefaultStyle>(
-  updater: () => Style,
+export function useAnimatedStyle<TStyle extends DefaultStyle>(
+  updater: WorkletFunction<[], TStyle> | (() => TStyle),
   dependencies?: DependencyList | null
-): Style;
+): AnimatedStyleHandle<TStyle>;
 
-export function useAnimatedStyle<Style extends DefaultStyle | AnimatedProps>(
-  updater:
-    | WorkletFunction<[], Style>
-    | ((() => Style) & Record<string, unknown>),
+/**
+ * @deprecated The `adapters` parameter is deprecated and will be removed in a
+ *   future version.
+ */
+export function useAnimatedStyle<TStyle extends DefaultStyle>(
+  updater: WorkletFunction<[], TStyle> | (() => TStyle),
   dependencies?: DependencyList | null,
-  adapters?: AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[] | null,
-  isAnimatedProps = false
-):
-  | AnimatedStyleHandle<Style | AnimatedProps>
-  | JestAnimatedStyleHandle<Style | AnimatedProps> {
-  const animatedUpdaterData = useRef<AnimatedUpdaterData | null>(null);
-  let inputs = Object.values(updater.__closure ?? {});
-  if (SHOULD_BE_USE_WEB) {
-    if (!inputs.length && dependencies?.length) {
-      // let web work without a Babel plugin
-      inputs = dependencies;
-    }
-    if (
-      __DEV__ &&
-      !inputs.length &&
-      !dependencies &&
-      !isWorkletFunction(updater)
-    ) {
-      throw new ReanimatedError(
-        `\`useAnimatedStyle\` was used without a dependency array or Babel plugin. Please explicitly pass a dependency array, or enable the Babel plugin.
-For more, see the docs: \`https://docs.swmansion.com/react-native-reanimated/docs/guides/web-support#web-without-the-babel-plugin\`.`
-      );
-    }
-  }
-  const adaptersArray = adapters
-    ? Array.isArray(adapters)
-      ? adapters
-      : [adapters]
-    : [];
-  const adaptersHash = adapters ? buildWorkletsHash(adaptersArray) : null;
-  const areAnimationsActive = useSharedValue<boolean>(true);
-  const jestAnimatedValues = useRef<Style | AnimatedProps>(
-    {} as Style | AnimatedProps
-  );
-
-  // build dependencies
-  if (!dependencies) {
-    dependencies = [...inputs, updater.__workletHash];
-  } else {
-    dependencies.push(updater.__workletHash);
-  }
-  if (adaptersHash) {
-    dependencies.push(adaptersHash);
-  }
-
-  if (!animatedUpdaterData.current) {
-    const initialStyle = initialUpdaterRun(updater);
-    if (__DEV__) {
-      validateAnimatedStyles(initialStyle);
-    }
-    animatedUpdaterData.current = {
-      initial: {
-        value: initialStyle,
-        updater,
-      },
-      remoteState: makeShareable({
-        last: initialStyle,
-        animations: {},
-        isAnimationCancelled: false,
-        isAnimationRunning: false,
-      }),
-      viewDescriptors: makeViewDescriptorsSet(),
-    };
-  }
+  adapters?: AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[] | null
+): AnimatedStyleHandle<TStyle>;
 
-  const { initial, remoteState, viewDescriptors } = animatedUpdaterData.current;
-  const shareableViewDescriptors = viewDescriptors.shareableViewDescriptors;
-
-  dependencies.push(shareableViewDescriptors);
-
-  useEffect(() => {
-    let fun;
-    let updaterFn = updater;
-    if (adapters) {
-      updaterFn = (() => {
-        'worklet';
-        const newValues = updater();
-        adaptersArray.forEach((adapter) => {
-          adapter(newValues as Record<string, unknown>);
-        });
-        return newValues;
-      }) as WorkletFunction<[], Style>;
-    }
-
-    if (IS_JEST) {
-      fun = () => {
-        'worklet';
-        jestStyleUpdater(
-          shareableViewDescriptors,
-          updater,
-          remoteState,
-          areAnimationsActive,
-          jestAnimatedValues,
-          adaptersArray
-        );
-      };
-    } else {
-      fun = () => {
-        'worklet';
-        styleUpdater(
-          shareableViewDescriptors,
-          updaterFn,
-          remoteState,
-          areAnimationsActive,
-          isAnimatedProps
-        );
-      };
-    }
-    const mapperId = startMapper(fun, inputs);
-    return () => {
-      stopMapper(mapperId);
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, dependencies);
-
-  useEffect(() => {
-    areAnimationsActive.value = true;
-    return () => {
-      areAnimationsActive.value = false;
-    };
-  }, [areAnimationsActive]);
-
-  if (__DEV__) {
-    checkSharedValueUsage(initial.value);
-  }
-
-  const animatedStyleHandle = useRef<
-    | AnimatedStyleHandle<Style | AnimatedProps>
-    | JestAnimatedStyleHandle<Style | AnimatedProps>
-    | null
-  >(null);
-
-  if (!animatedStyleHandle.current) {
-    animatedStyleHandle.current = IS_JEST
-      ? {
-          viewDescriptors,
-          initial,
-          jestAnimatedValues,
-          toJSON: animatedStyleHandleToJSON,
-        }
-      : { viewDescriptors, initial };
-  }
-
-  return animatedStyleHandle.current;
-}
-
-function animatedStyleHandleToJSON(): string {
-  return '{}';
+export function useAnimatedStyle<TStyle extends DefaultStyle>(
+  updater: WorkletFunction<[], TStyle> | (() => TStyle),
+  dependencies?: DependencyList | null,
+  adapters?: AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[] | null
+): AnimatedStyleHandle<TStyle> {
+  return useAnimatedUpdaterInternal(
+    HOOK_NAME,
+    updater,
+    dependencies,
+    adapters,
+    false
+  );
 }
diff --git a/packages/react-native-reanimated/src/hook/useAnimatedUpdaterInternal.ts b/packages/react-native-reanimated/src/hook/useAnimatedUpdaterInternal.ts
new file mode 100644
index 000000000000..b439a839336c
--- /dev/null
+++ b/packages/react-native-reanimated/src/hook/useAnimatedUpdaterInternal.ts
@@ -0,0 +1,573 @@
+'use strict';
+import type { RefObject } from 'react';
+import { useEffect, useRef } from 'react';
+import type { WorkletFunction } from 'react-native-worklets';
+import { isWorkletFunction, makeShareable } from 'react-native-worklets';
+
+import { initialUpdaterRun } from '../animation';
+import type { Maybe } from '../common';
+import { IS_JEST, logger, ReanimatedError, SHOULD_BE_USE_WEB } from '../common';
+import type {
+  AnimatableValue,
+  AnimatedPropsAdapterWorklet,
+  AnimationObject,
+  NestedObject,
+  NestedObjectValues,
+  SharedValue,
+  Timestamp,
+} from '../commonTypes';
+import { startMapper, stopMapper } from '../core';
+import type { AnyRecord, UnknownRecord } from '../css/types';
+import { updateProps, updatePropsJestWrapper } from '../updateProps';
+import type { ViewDescriptorsSet } from '../ViewDescriptorsSet';
+import { makeViewDescriptorsSet } from '../ViewDescriptorsSet';
+import type {
+  AnimatedUpdaterHandle,
+  AnimatedValuesUpdate,
+  DependencyList,
+  Descriptor,
+  JestAnimatedUpdaterHandle,
+} from './commonTypes';
+import { useSharedValue } from './useSharedValue';
+import { isAnimated, shallowEqual, validateAnimatedStyles } from './utils';
+
+type AnimatedState = {
+  last: AnimatedValuesUpdate;
+  animations: NestedObject<AnimationObject>;
+  isAnimationRunning: boolean;
+  isAnimationCancelled: boolean;
+};
+
+type AnimatedUpdaterData<TValues extends object> = {
+  initial: {
+    value: TValues;
+    updater: () => AnimatedValuesUpdate;
+  };
+  remoteState: AnimatedState;
+  viewDescriptors: ViewDescriptorsSet;
+};
+
+function isAnimationObject(
+  animation: NestedObjectValues<AnimationObject | AnimatableValue>
+): animation is AnimationObject {
+  'worklet';
+  return (
+    typeof animation === 'object' &&
+    animation !== null &&
+    'onFrame' in animation
+  );
+}
+
+function prepareAnimation(
+  frameTimestamp: number,
+  animatedProp: NestedObjectValues<AnimationObject | AnimatableValue>,
+  lastAnimation: NestedObjectValues<AnimationObject | AnimatableValue>,
+  lastValue: NestedObjectValues<AnimationObject | AnimatableValue>
+): void {
+  'worklet';
+  if (Array.isArray(animatedProp)) {
+    animatedProp.forEach((prop, index) => {
+      prepareAnimation(
+        frameTimestamp,
+        prop,
+        lastAnimation?.[index],
+        lastValue?.[index]
+      );
+    });
+    // return animatedProp;
+  }
+  if (isAnimationObject(animatedProp)) {
+    const animation = animatedProp;
+
+    let value = animation.current;
+    if (lastValue !== undefined && lastValue !== null) {
+      if (typeof lastValue === 'object') {
+        if (lastValue.value !== undefined) {
+          // previously it was a shared value
+          value = lastValue.value;
+        } else if (lastValue.onFrame !== undefined) {
+          if (lastAnimation?.current !== undefined) {
+            // it was an animation before, copy its state
+            value = lastAnimation.current;
+          } else if (lastValue?.current !== undefined) {
+            // it was initialized
+            value = lastValue.current;
+          }
+        }
+      } else {
+        // previously it was a plain value, just set it as starting point
+        value = lastValue;
+      }
+    }
+
+    animation.callStart = (timestamp: Timestamp) => {
+      animation.onStart(animation, value, timestamp, lastAnimation);
+    };
+    animation.callStart(frameTimestamp);
+    animation.callStart = null;
+  } else if (typeof animatedProp === 'object') {
+    // it is an object
+    Object.keys(animatedProp).forEach((key) =>
+      prepareAnimation(
+        frameTimestamp,
+        animatedProp[key],
+        lastAnimation && lastAnimation[key],
+        lastValue && lastValue[key]
+      )
+    );
+  }
+}
+
+function runAnimations(
+  animations: NestedObjectValues<AnimationObject>,
+  timestamp: Timestamp,
+  key: number | string,
+  result: NestedObjectValues<AnimatableValue>,
+  animationsActive: SharedValue<boolean>,
+  forceCopyAnimation?: boolean
+): boolean {
+  'worklet';
+  if (!animationsActive.value) {
+    return true;
+  }
+
+  const res = result as NestedObject<AnimatableValue>;
+
+  if (Array.isArray(animations)) {
+    res[key] = [];
+    forceCopyAnimation = key === 'boxShadow';
+
+    return animations.reduce(
+      (allFinished, entry, index) =>
+        allFinished &&
+        runAnimations(
+          entry,
+          timestamp,
+          index,
+          res[key],
+          animationsActive,
+          forceCopyAnimation
+        ),
+      true
+    );
+  }
+
+  if (isAnimationObject(animations)) {
+    let finished = true;
+    if (!animations.finished) {
+      if (animations.callStart) {
+        animations.callStart(timestamp);
+        animations.callStart = null;
+      }
+      finished = animations.onFrame(animations, timestamp);
+      animations.timestamp = timestamp;
+      if (finished) {
+        animations.finished = true;
+        animations.callback?.(true /* finished */);
+      }
+    }
+    /*
+     * If `animation.current` is a boxShadow object, spread its properties into a new object
+     * to avoid modifying the original reference. This ensures when `newValues` has a nested color prop, it stays unparsed
+     * in rgba format, allowing the animation to run correctly.
+     */
+    if (forceCopyAnimation && typeof animations.current === 'object') {
+      res[key] = { ...animations.current };
+    } else {
+      res[key] = animations.current!;
+    }
+    return finished;
+  }
+
+  if (typeof animations === 'object') {
+    res[key] = {};
+    let allFinished = true;
+    Object.keys(animations).forEach((k) => {
+      if (
+        !runAnimations(
+          animations[k],
+          timestamp,
+          k,
+          res[key],
+          animationsActive,
+          forceCopyAnimation
+        )
+      ) {
+        allFinished = false;
+      }
+    });
+    return allFinished;
+  }
+
+  res[key] = animations;
+  return true;
+}
+
+function styleUpdater(
+  viewDescriptors: SharedValue<Descriptor[]>,
+  updater: () => AnimatedValuesUpdate,
+  state: AnimatedState,
+  animationsActive: SharedValue<boolean>,
+  isAnimatedProps: boolean
+): void {
+  'worklet';
+  const animations = state.animations ?? {};
+  const newValues = updater() ?? {};
+  const oldValues = state.last;
+  const nonAnimatedNewValues: UnknownRecord = {};
+
+  let hasAnimations = false;
+  let frameTimestamp: number | undefined;
+  let hasNonAnimatedValues = false;
+
+  for (const key in newValues) {
+    const value = newValues[key];
+    if (isAnimated(value)) {
+      frameTimestamp =
+        global.__frameTimestamp || global._getAnimationTimestamp();
+      prepareAnimation(frameTimestamp, value, animations[key], oldValues[key]);
+      animations[key] = value;
+      hasAnimations = true;
+    } else {
+      hasNonAnimatedValues = true;
+      nonAnimatedNewValues[key] = value;
+      delete animations[key];
+    }
+  }
+
+  if (hasAnimations) {
+    const frame = (timestamp: Timestamp) => {
+      // eslint-disable-next-line @typescript-eslint/no-shadow
+      const { animations, last, isAnimationCancelled } = state;
+      if (isAnimationCancelled) {
+        state.isAnimationRunning = false;
+        return;
+      }
+
+      const updates: AnimatedValuesUpdate = {};
+      let allFinished = true;
+      for (const propName in animations) {
+        const finished = runAnimations(
+          animations[propName],
+          timestamp,
+          propName,
+          updates,
+          animationsActive
+        );
+        if (finished) {
+          /**
+           * If the animated prop is an array, we need to directly set each
+           * property (manually spread it). This prevents issues where the color
+           * prop might be incorrectly linked with its `toValue` and `current`
+           * states, causing abrupt transitions or 'jumps' in animation states.
+           */
+          if (Array.isArray(updates[propName])) {
+            updates[propName].forEach((obj) => {
+              for (const prop in obj) {
+                if (!last[propName] || typeof last[propName] !== 'object') {
+                  last[propName] = {};
+                }
+                last[propName][prop] = obj[prop];
+              }
+            });
+          } else {
+            last[propName] = updates[propName];
+          }
+          delete animations[propName];
+        } else {
+          allFinished = false;
+        }
+      }
+
+      if (updates) {
+        updateProps(viewDescriptors, updates);
+      }
+
+      if (!allFinished) {
+        requestAnimationFrame(frame);
+      } else {
+        state.isAnimationRunning = false;
+      }
+    };
+
+    state.animations = animations;
+    if (!state.isAnimationRunning) {
+      state.isAnimationCancelled = false;
+      state.isAnimationRunning = true;
+      frame(frameTimestamp!);
+    }
+
+    if (hasNonAnimatedValues) {
+      updateProps(viewDescriptors, nonAnimatedNewValues);
+    }
+  } else {
+    state.isAnimationCancelled = true;
+    state.animations = {};
+
+    if (!shallowEqual(oldValues, newValues)) {
+      updateProps(viewDescriptors, newValues, isAnimatedProps);
+    }
+  }
+  state.last = newValues;
+}
+
+function jestStyleUpdater<TValues extends object>(
+  viewDescriptors: SharedValue<Descriptor[]>,
+  updater: () => AnimatedValuesUpdate,
+  state: AnimatedState,
+  animationsActive: SharedValue<boolean>,
+  animatedValues: RefObject<TValues>
+): void {
+  'worklet';
+  const animations: NestedObject<AnimationObject> = state.animations ?? {};
+  const newValues = updater() ?? {};
+  const oldValues = state.last;
+
+  // extract animated props
+  let hasAnimations = false;
+  let frameTimestamp: number | undefined;
+  Object.keys(animations).forEach((key) => {
+    const value = newValues[key];
+    if (!isAnimated(value)) {
+      delete animations[key];
+    }
+  });
+  Object.keys(newValues).forEach((key) => {
+    const value = newValues[key];
+    if (isAnimated(value)) {
+      frameTimestamp =
+        global.__frameTimestamp || global._getAnimationTimestamp();
+      prepareAnimation(frameTimestamp, value, animations[key], oldValues[key]);
+      animations[key] = value;
+      hasAnimations = true;
+    }
+  });
+
+  function frame(timestamp: Timestamp) {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    const { animations, last, isAnimationCancelled } = state;
+    if (isAnimationCancelled) {
+      state.isAnimationRunning = false;
+      return;
+    }
+
+    const updates: AnimatedValuesUpdate = {};
+    let allFinished = true;
+    Object.keys(animations).forEach((propName) => {
+      const finished = runAnimations(
+        animations[propName],
+        timestamp,
+        propName,
+        updates,
+        animationsActive
+      );
+      if (finished) {
+        last[propName] = updates[propName];
+        delete animations[propName];
+      } else {
+        allFinished = false;
+      }
+    });
+
+    if (Object.keys(updates).length) {
+      updatePropsJestWrapper(viewDescriptors, updates, animatedValues);
+    }
+
+    if (!allFinished) {
+      requestAnimationFrame(frame);
+    } else {
+      state.isAnimationRunning = false;
+    }
+  }
+
+  if (hasAnimations) {
+    state.animations = animations;
+    if (!state.isAnimationRunning) {
+      state.isAnimationCancelled = false;
+      state.isAnimationRunning = true;
+      frame(frameTimestamp!);
+    }
+  } else {
+    state.isAnimationCancelled = true;
+    state.animations = {};
+  }
+
+  // calculate diff
+  state.last = newValues;
+
+  if (!shallowEqual(oldValues, newValues)) {
+    updatePropsJestWrapper(viewDescriptors, newValues, animatedValues);
+  }
+}
+
+// check for invalid usage of shared values in returned object
+function checkSharedValueUsage(
+  prop: NestedObjectValues<SharedValue | AnimatableValue>,
+  currentKey?: string
+): void {
+  if (Array.isArray(prop)) {
+    // if it's an array (i.ex. transform) validate all its elements
+    for (const element of prop) {
+      checkSharedValueUsage(element, currentKey);
+    }
+  } else if (
+    typeof prop === 'object' &&
+    prop !== null &&
+    prop.value === undefined
+  ) {
+    // if it's a nested object, run validation for all its props
+    for (const key of Object.keys(prop)) {
+      checkSharedValueUsage(
+        (prop as NestedObject<SharedValue | AnimatableValue>)[key],
+        key
+      );
+    }
+  } else if (
+    currentKey !== undefined &&
+    typeof prop === 'object' &&
+    prop !== null &&
+    prop.value !== undefined
+  ) {
+    // if shared value is passed instead of its value, throw an error
+    throw new ReanimatedError(
+      `Invalid value passed to \`${currentKey}\`, maybe you forgot to use \`.value\`?`
+    );
+  }
+}
+
+export function useAnimatedUpdaterInternal<TValues extends AnyRecord>(
+  hookName: string,
+  updater:
+    | WorkletFunction<[], TValues>
+    | ((() => TValues) & Partial<WorkletFunction>),
+  dependencies: Maybe<DependencyList>,
+  adapters: Maybe<AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[]>,
+  isAnimatedProps: boolean
+): AnimatedUpdaterHandle<TValues> | JestAnimatedUpdaterHandle<TValues> {
+  const animatedUpdaterData = useRef<AnimatedUpdaterData<TValues>>(null);
+  let inputs = Object.values(updater.__closure ?? {});
+
+  if (SHOULD_BE_USE_WEB) {
+    if (!inputs.length && dependencies?.length) {
+      // let web work without a Babel plugin
+      inputs = dependencies;
+    }
+    if (
+      __DEV__ &&
+      !inputs.length &&
+      !dependencies &&
+      !isWorkletFunction(updater)
+    ) {
+      throw new ReanimatedError(
+        `\`${hookName}\` was used without a dependency array or Babel plugin. Please explicitly pass a dependency array, or enable the Babel plugin.
+For more, see the docs: \`https://docs.swmansion.com/react-native-reanimated/docs/guides/web-support#web-without-the-babel-plugin\`.`
+      );
+    }
+  }
+
+  if (adapters) {
+    logger.warn(
+      `The \`adapters\` parameter is no longer necessary in Reanimated 4 and will be removed in next version. Please remove this parameter from the \`${hookName}\` call and pass the adapter function directly.`
+    );
+  }
+
+  const areAnimationsActive = useSharedValue(true);
+  const jestAnimatedValues = useRef({} as TValues);
+
+  // build dependencies
+  if (!dependencies) {
+    dependencies = [...inputs, updater.__workletHash];
+  } else {
+    dependencies.push(updater.__workletHash);
+  }
+
+  if (!animatedUpdaterData.current) {
+    const initialStyle = initialUpdaterRun(updater);
+    if (__DEV__) {
+      validateAnimatedStyles(initialStyle);
+    }
+    animatedUpdaterData.current = {
+      initial: {
+        value: initialStyle,
+        updater,
+      },
+      remoteState: makeShareable({
+        last: initialStyle,
+        animations: {},
+        isAnimationCancelled: false,
+        isAnimationRunning: false,
+      }),
+      viewDescriptors: makeViewDescriptorsSet(),
+    };
+  }
+
+  const { initial, remoteState, viewDescriptors } = animatedUpdaterData.current;
+  const shareableViewDescriptors = viewDescriptors.shareableViewDescriptors;
+
+  dependencies.push(shareableViewDescriptors);
+
+  useEffect(() => {
+    let fun;
+
+    if (IS_JEST) {
+      fun = () => {
+        'worklet';
+        jestStyleUpdater(
+          shareableViewDescriptors,
+          updater,
+          remoteState,
+          areAnimationsActive,
+          jestAnimatedValues
+        );
+      };
+    } else {
+      fun = () => {
+        'worklet';
+        styleUpdater(
+          shareableViewDescriptors,
+          updater,
+          remoteState,
+          areAnimationsActive,
+          isAnimatedProps
+        );
+      };
+    }
+    const mapperId = startMapper(fun, inputs);
+    return () => {
+      stopMapper(mapperId);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, dependencies);
+
+  useEffect(() => {
+    areAnimationsActive.value = true;
+    return () => {
+      areAnimationsActive.value = false;
+    };
+  }, [areAnimationsActive]);
+
+  if (__DEV__) {
+    checkSharedValueUsage(initial.value);
+  }
+
+  const animatedUpdaterHandle = useRef<
+    AnimatedUpdaterHandle<TValues> | JestAnimatedUpdaterHandle<TValues>
+  >(null);
+
+  if (!animatedUpdaterHandle.current) {
+    animatedUpdaterHandle.current = IS_JEST
+      ? {
+          viewDescriptors,
+          initial,
+          jestAnimatedValues,
+          toJSON: animatedStyleHandleToJSON,
+        }
+      : { viewDescriptors, initial };
+  }
+
+  return animatedUpdaterHandle.current;
+}
+
+function animatedStyleHandleToJSON(): string {
+  return '{}';
+}
diff --git a/packages/react-native-reanimated/src/hook/utils.ts b/packages/react-native-reanimated/src/hook/utils.ts
index 3754d1a2ae7a..aaefe567f749 100644
--- a/packages/react-native-reanimated/src/hook/utils.ts
+++ b/packages/react-native-reanimated/src/hook/utils.ts
@@ -3,6 +3,8 @@ import type { WorkletFunction } from 'react-native-worklets';
 import { isWorkletFunction } from 'react-native-worklets';
 
 import { ReanimatedError } from '../common';
+import type { AnimationObject, NestedObjectValues } from '../commonTypes';
+import type { AnyRecord } from '../css/types';
 import type { DependencyList } from './commonTypes';
 
 // Builds one big hash from multiple worklets' hashes.
@@ -97,7 +99,9 @@ export function areDependenciesEqual(
   return areHookInputsEqual(nextDependencies, prevDependencies);
 }
 
-export function isAnimated(prop: unknown) {
+export function isAnimated(
+  prop: unknown
+): prop is NestedObjectValues<AnimationObject> {
   'worklet';
   if (Array.isArray(prop)) {
     return prop.some(isAnimated);
@@ -114,9 +118,7 @@ export function isAnimated(prop: unknown) {
 // This function works because `Object.keys`
 // return empty array of primitives and on arrays
 // it returns array of its indices.
-export function shallowEqual<
-  T extends Record<string | number | symbol, unknown>,
->(a: T, b: T) {
+export function shallowEqual<T extends AnyRecord>(a: T, b: T) {
   'worklet';
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
diff --git a/packages/react-native-reanimated/src/updateProps/updateProps.ts b/packages/react-native-reanimated/src/updateProps/updateProps.ts
index 065074881c14..9bb47628ff6e 100644
--- a/packages/react-native-reanimated/src/updateProps/updateProps.ts
+++ b/packages/react-native-reanimated/src/updateProps/updateProps.ts
@@ -64,8 +64,7 @@ if (SHOULD_BE_USE_WEB) {
 export const updatePropsJestWrapper = (
   viewDescriptors: ViewDescriptorsWrapper,
   updates: AnimatedStyle<any>,
-  animatedValues: RefObject<AnimatedStyle<any>>,
-  adapters: ((updates: AnimatedStyle<any>) => void)[]
+  animatedValues: RefObject<AnimatedStyle<any>>
 ): void => {
   adapters.forEach((adapter) => {
     adapter(updates);