diff --git a/src/reanimated2/PropAdapters.ts b/src/reanimated2/PropAdapters.ts
index 4c8e0f9af0e..9d3226d0d24 100644
--- a/src/reanimated2/PropAdapters.ts
+++ b/src/reanimated2/PropAdapters.ts
@@ -1,22 +1,24 @@
 'use strict';
 import { addWhitelistedNativeProps } from '../ConfigHelper';
-import type { __AdapterWorkletFunction } from './commonTypes';
-import type { AnimatedPropsAdapterFunction } from './helperTypes';
+import type {
+  AnimatedPropsAdapterFunction,
+  AnimatedPropsAdapterWorklet,
+} from './commonTypes';
 
-// TODO TYPESCRIPT This is a temporary type to get rid of .d.ts file.
-type createAnimatedPropAdapterType = (
+// @ts-expect-error This overload is required by our API.
+export function createAnimatedPropAdapter(
   adapter: AnimatedPropsAdapterFunction,
   nativeProps?: string[]
-) => AnimatedPropsAdapterFunction;
+): AnimatedPropsAdapterFunction;
 
-export const createAnimatedPropAdapter = ((
-  adapter: __AdapterWorkletFunction,
+export function createAnimatedPropAdapter(
+  adapter: AnimatedPropsAdapterWorklet,
   nativeProps?: string[]
-): __AdapterWorkletFunction => {
+): AnimatedPropsAdapterWorklet {
   const nativePropsToAdd: { [key: string]: boolean } = {};
   nativeProps?.forEach((prop) => {
     nativePropsToAdd[prop] = true;
   });
   addWhitelistedNativeProps(nativePropsToAdd);
   return adapter;
-}) as createAnimatedPropAdapterType;
+}
diff --git a/src/reanimated2/commonTypes.ts b/src/reanimated2/commonTypes.ts
index 45ebc410551..31e6a8b24b2 100644
--- a/src/reanimated2/commonTypes.ts
+++ b/src/reanimated2/commonTypes.ts
@@ -60,6 +60,12 @@ export type MapperRegistry = {
   stop: (mapperID: number) => void;
 };
 
+export type WorkletStackDetails = [
+  error: Error,
+  lineOffset: number,
+  columnOffset: number
+];
+
 type WorkletClosure = Record<string, unknown>;
 
 interface WorkletInitDataCommon {
@@ -85,7 +91,10 @@ interface WorkletBaseRelease extends WorkletBaseCommon {
 
 interface WorkletBaseDev extends WorkletBaseCommon {
   __initData: WorkletInitDataDev;
-  __stackDetails: Error;
+  /**
+   * `__stackDetails` is removed after parsing.
+   */
+  __stackDetails?: WorkletStackDetails;
 }
 
 export type WorkletFunction<
@@ -93,6 +102,30 @@ export type WorkletFunction<
   ReturnValue = unknown
 > = ((...args: Args) => ReturnValue) & (WorkletBaseRelease | WorkletBaseDev);
 
+/**
+ * This function works well on the JS thread performance-wise, since the JIT can inline it.
+ * However, on other threads it will not get optimized and we will get a function call overhead.
+ */
+export function isWorklet<
+  Args extends unknown[] = unknown[],
+  ReturnValue = unknown,
+  BuildType extends WorkletBaseDev | WorkletBaseRelease = WorkletBaseDev
+>(value: unknown): value is WorkletFunction<Args, ReturnValue> & BuildType {
+  'worklet';
+  // Since host objects always return true for `in` operator, we have to use dot notation to check if the property exists.
+  // See https://github.com/facebook/hermes/blob/340726ef8cf666a7cce75bc60b02fa56b3e54560/lib/VM/JSObject.cpp#L1276.
+  return !!(value as Record<string, unknown>).__workletHash;
+}
+
+export type AnimatedPropsAdapterFunction = (
+  props: Record<string, unknown>
+) => void;
+
+export type AnimatedPropsAdapterWorklet = WorkletFunction<
+  [props: Record<string, unknown>],
+  void
+>;
+
 export interface NestedObject<T> {
   [key: string]: NestedObjectValues<T>;
 }
@@ -253,36 +286,3 @@ export enum ReduceMotion {
   Always = 'always',
   Never = 'never',
 }
-
-// THE LAND OF THE DEPRECATED
-
-/**
- * @deprecated don't use
- */
-export interface __WorkletFunction {
-  __closure?: Record<string, unknown>;
-  __workletHash?: number;
-}
-
-/**
- * @deprecated don't use
- */
-export interface __BasicWorkletFunction<T> extends __WorkletFunction {
-  (): T;
-}
-
-/**
- * @deprecated don't use
- */
-export interface __ComplexWorkletFunction<A extends any[], R>
-  extends __WorkletFunction {
-  (...args: A): R;
-  __remoteFunction?: (...args: A) => R;
-}
-
-/**
- * @deprecated don't use
- */
-export interface __AdapterWorkletFunction extends __WorkletFunction {
-  (value: NestedObject<string | number | AnimationObject>): void;
-}
diff --git a/src/reanimated2/errors.ts b/src/reanimated2/errors.ts
index 89b563663c8..4073489b010 100644
--- a/src/reanimated2/errors.ts
+++ b/src/reanimated2/errors.ts
@@ -1,11 +1,11 @@
 'use strict';
-type StackDetails = [Error, number, number];
+import type { WorkletStackDetails } from './commonTypes';
 
-const _workletStackDetails = new Map<number, StackDetails>();
+const _workletStackDetails = new Map<number, WorkletStackDetails>();
 
 export function registerWorkletStackDetails(
   hash: number,
-  stackDetails: StackDetails
+  stackDetails: WorkletStackDetails
 ) {
   _workletStackDetails.set(hash, stackDetails);
 }
diff --git a/src/reanimated2/globals.d.ts b/src/reanimated2/globals.d.ts
index 4bbae6d930c..dbc346cc2a9 100644
--- a/src/reanimated2/globals.d.ts
+++ b/src/reanimated2/globals.d.ts
@@ -7,7 +7,6 @@ import type {
   MapperRegistry,
   ShareableRef,
   ShadowNodeWrapper,
-  __ComplexWorkletFunction,
   FlatShareableRef,
 } from './commonTypes';
 import type { AnimatedStyle } from './helperTypes';
@@ -42,10 +41,7 @@ declare global {
   var _notifyAboutEnd: (tag: number, removeView: boolean) => void;
   var _setGestureState: (handlerTag: number, newState: number) => void;
   var _makeShareableClone: <T>(value: T) => FlatShareableRef<T>;
-  var _scheduleOnJS: (
-    fun: __ComplexWorkletFunction<A, R>,
-    args?: unknown[]
-  ) => void;
+  var _scheduleOnJS: (fun: (...args: A) => R, args?: A) => void;
   var _scheduleOnRuntime: (
     runtime: WorkletRuntime,
     worklet: ShareableRef<() => void>
diff --git a/src/reanimated2/helperTypes.ts b/src/reanimated2/helperTypes.ts
index 9bfd4ff5b9d..e26438eff65 100644
--- a/src/reanimated2/helperTypes.ts
+++ b/src/reanimated2/helperTypes.ts
@@ -23,7 +23,6 @@ import type {
 } from './layoutReanimation/animationBuilder/commonTypes';
 import type { ReanimatedKeyframe } from './layoutReanimation/animationBuilder/Keyframe';
 import type { SharedTransition } from './layoutReanimation/sharedTransitions';
-import type { DependencyList } from './hook/commonTypes';
 
 export type TransformArrayItem = Extract<
   TransformsStyle['transform'],
@@ -160,20 +159,6 @@ export type AnimatedProps<Props extends object> = RestProps<Props> &
     animatedProps?: Partial<AnimatedPropsProp<Props>>;
   };
 
-export type AnimatedPropsAdapterFunction = (
-  props: Record<string, unknown>
-) => void;
-
-export type useAnimatedPropsType = <Props extends object>(
-  updater: () => Partial<Props>,
-  deps?: DependencyList | null,
-  adapters?:
-    | AnimatedPropsAdapterFunction
-    | AnimatedPropsAdapterFunction[]
-    | null,
-  isAnimatedProps?: boolean
-) => Partial<Props>;
-
 // THE LAND OF THE DEPRECATED
 
 /**
diff --git a/src/reanimated2/hook/commonTypes.ts b/src/reanimated2/hook/commonTypes.ts
index a346da9a47f..e294c9b10db 100644
--- a/src/reanimated2/hook/commonTypes.ts
+++ b/src/reanimated2/hook/commonTypes.ts
@@ -1,6 +1,11 @@
 'use strict';
 import type { Component, MutableRefObject } from 'react';
-import type { ShadowNodeWrapper, SharedValue } from '../commonTypes';
+import type {
+  AnimatedPropsAdapterFunction,
+  ShadowNodeWrapper,
+  SharedValue,
+  WorkletFunction,
+} from '../commonTypes';
 import type {
   ImageStyle,
   NativeSyntheticEvent,
@@ -92,3 +97,13 @@ export interface JestAnimatedStyleHandle<
 > extends AnimatedStyleHandle<Style> {
   jestAnimatedStyle: MutableRefObject<AnimatedStyle<Style>>;
 }
+
+export type UseAnimatedStyleInternal<Style extends DefaultStyle> = (
+  updater: WorkletFunction<[], Style> | (() => Style),
+  dependencies?: DependencyList | null,
+  adapters?:
+    | AnimatedPropsAdapterFunction
+    | AnimatedPropsAdapterFunction[]
+    | null,
+  isAnimatedProps?: boolean
+) => AnimatedStyleHandle<Style> | JestAnimatedStyleHandle<Style>;
diff --git a/src/reanimated2/hook/useAnimatedProps.ts b/src/reanimated2/hook/useAnimatedProps.ts
index 789c0c178d4..558c4970ada 100644
--- a/src/reanimated2/hook/useAnimatedProps.ts
+++ b/src/reanimated2/hook/useAnimatedProps.ts
@@ -1,15 +1,38 @@
 'use strict';
 import { useAnimatedStyle } from './useAnimatedStyle';
-import type { DependencyList } from './commonTypes';
-import type {
-  AnimatedPropsAdapterFunction,
-  useAnimatedPropsType,
-} from '../helperTypes';
+import type { DependencyList, UseAnimatedStyleInternal } from './commonTypes';
 import { shouldBeUseWeb } from '../PlatformChecker';
+import type { AnimatedPropsAdapterFunction } from '../commonTypes';
 
 // TODO: we should make sure that when useAP is used we are not assigning styles
-// when you need styles to animated you should always use useAS
-// TODO TYPESCRIPT This is a temporary cast to get rid of .d.ts file.
+
+type UseAnimatedProps = <Props extends object>(
+  updater: () => Partial<Props>,
+  dependencies?: DependencyList | null,
+  adapters?:
+    | AnimatedPropsAdapterFunction
+    | AnimatedPropsAdapterFunction[]
+    | null,
+  isAnimatedProps?: boolean
+) => Partial<Props>;
+
+function useAnimatedPropsJS<Props extends object>(
+  updater: () => Props,
+  deps?: DependencyList | null,
+  adapters?:
+    | AnimatedPropsAdapterFunction
+    | AnimatedPropsAdapterFunction[]
+    | null
+) {
+  return (useAnimatedStyle as UseAnimatedStyleInternal<Props>)(
+    updater,
+    deps,
+    adapters,
+    true
+  );
+}
+
+const useAnimatedPropsNative = useAnimatedStyle;
 
 /**
  * Lets you create an animated props object which can be animated using shared values.
@@ -20,24 +43,6 @@ import { shouldBeUseWeb } from '../PlatformChecker';
  * @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 let useAnimatedProps: useAnimatedPropsType;
-
-if (shouldBeUseWeb()) {
-  useAnimatedProps = function <T extends object>(
-    updater: () => Partial<T>,
-    deps?: DependencyList | null,
-    adapters?:
-      | AnimatedPropsAdapterFunction
-      | AnimatedPropsAdapterFunction[]
-      | null
-  ) {
-    return (useAnimatedStyle as useAnimatedPropsType)(
-      updater,
-      deps,
-      adapters,
-      true
-    );
-  };
-} else {
-  useAnimatedProps = useAnimatedStyle as useAnimatedPropsType;
-}
+export const useAnimatedProps: UseAnimatedProps = shouldBeUseWeb()
+  ? (useAnimatedPropsJS as UseAnimatedProps)
+  : useAnimatedPropsNative;
diff --git a/src/reanimated2/hook/useAnimatedStyle.ts b/src/reanimated2/hook/useAnimatedStyle.ts
index 21a93b7ad4b..eb7492402a2 100644
--- a/src/reanimated2/hook/useAnimatedStyle.ts
+++ b/src/reanimated2/hook/useAnimatedStyle.ts
@@ -28,11 +28,12 @@ import type {
   NestedObjectValues,
   SharedValue,
   StyleProps,
-  __AdapterWorkletFunction,
-  __BasicWorkletFunction,
   WorkletFunction,
+  AnimatedPropsAdapterFunction,
+  AnimatedPropsAdapterWorklet,
 } from '../commonTypes';
 import type { AnimatedStyle } from '../helperTypes';
+import { isWorklet } from '../commonTypes';
 
 const SHOULD_BE_USE_WEB = shouldBeUseWeb();
 
@@ -175,7 +176,7 @@ function runAnimations(
 
 function styleUpdater(
   viewDescriptors: SharedValue<Descriptor[]>,
-  updater: __BasicWorkletFunction<AnimatedStyle<any>>,
+  updater: WorkletFunction<[], AnimatedStyle<any>> | (() => AnimatedStyle<any>),
   state: AnimatedState,
   maybeViewRef: ViewRefSet<any> | undefined,
   animationsActive: SharedValue<boolean>,
@@ -265,12 +266,12 @@ function styleUpdater(
 
 function jestStyleUpdater(
   viewDescriptors: SharedValue<Descriptor[]>,
-  updater: __BasicWorkletFunction<AnimatedStyle<any>>,
+  updater: WorkletFunction<[], AnimatedStyle<any>> | (() => AnimatedStyle<any>),
   state: AnimatedState,
   maybeViewRef: ViewRefSet<any> | undefined,
   animationsActive: SharedValue<boolean>,
   animatedStyle: MutableRefObject<AnimatedStyle<any>>,
-  adapters: __AdapterWorkletFunction[] = []
+  adapters: AnimatedPropsAdapterFunction[]
 ): void {
   'worklet';
   const animations: AnimatedStyle<any> = state.animations ?? {};
@@ -413,9 +414,11 @@ export function useAnimatedStyle<Style extends DefaultStyle>(
 ): Style;
 
 export function useAnimatedStyle<Style extends DefaultStyle>(
-  updater: WorkletFunction<[], Style>,
+  updater:
+    | WorkletFunction<[], Style>
+    | ((() => Style) & Record<string, unknown>),
   dependencies?: DependencyList | null,
-  adapters?: WorkletFunction | WorkletFunction[],
+  adapters?: AnimatedPropsAdapterWorklet | AnimatedPropsAdapterWorklet[] | null,
   isAnimatedProps = false
 ): AnimatedStyleHandle<Style> | JestAnimatedStyleHandle<Style> {
   const viewsRef: ViewRefSet<unknown> | undefined = useViewRefSet();
@@ -426,7 +429,7 @@ export function useAnimatedStyle<Style extends DefaultStyle>(
       // let web work without a Babel plugin
       inputs = dependencies;
     }
-    if (__DEV__ && !inputs.length && !dependencies && !updater.__workletHash) {
+    if (__DEV__ && !inputs.length && !dependencies && !isWorklet(updater)) {
       throw new Error(
         `[Reanimated] \`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\`.`
@@ -483,7 +486,7 @@ For more, see the docs: \`https://docs.swmansion.com/react-native-reanimated/doc
         'worklet';
         const newValues = updater();
         adaptersArray.forEach((adapter) => {
-          adapter(newValues);
+          adapter(newValues as Record<string, unknown>);
         });
         return newValues;
       }) as WorkletFunction<[], Style>;
diff --git a/src/reanimated2/hook/utils.ts b/src/reanimated2/hook/utils.ts
index a9e37102e43..69d10ea6722 100644
--- a/src/reanimated2/hook/utils.ts
+++ b/src/reanimated2/hook/utils.ts
@@ -3,12 +3,15 @@ import type { WorkletFunction } from '../commonTypes';
 import type { DependencyList } from './commonTypes';
 
 // Builds one big hash from multiple worklets' hashes.
-export function buildWorkletsHash(
-  worklets: Record<string, WorkletFunction> | WorkletFunction[]
+export function buildWorkletsHash<Args extends unknown[], ReturnValue>(
+  worklets:
+    | Record<string, WorkletFunction<Args, ReturnValue>>
+    | WorkletFunction<Args, ReturnValue>[]
 ) {
   // For arrays `Object.values` returns the array itself.
   return Object.values(worklets).reduce(
-    (acc, worklet: WorkletFunction) => acc + worklet.__workletHash.toString(),
+    (acc, worklet: WorkletFunction<Args, ReturnValue>) =>
+      acc + worklet.__workletHash.toString(),
     ''
   );
 }
diff --git a/src/reanimated2/runtimes.ts b/src/reanimated2/runtimes.ts
index c71abda9683..d0ebd010b6e 100644
--- a/src/reanimated2/runtimes.ts
+++ b/src/reanimated2/runtimes.ts
@@ -1,5 +1,6 @@
 'use strict';
-import type { __ComplexWorkletFunction, WorkletFunction } from './commonTypes';
+import { isWorklet } from './commonTypes';
+import type { WorkletFunction } from './commonTypes';
 import { setupCallGuard, setupConsole } from './initializers';
 import NativeReanimatedModule from './NativeReanimated';
 import { shouldBeUseWeb } from './PlatformChecker';
@@ -23,10 +24,16 @@ export type WorkletRuntime = {
  * @returns WorkletRuntime which is a jsi::HostObject\<reanimated::WorkletRuntime\> - {@link WorkletRuntime}
  * @see https://docs.swmansion.com/react-native-reanimated/docs/threading/createWorkletRuntime
  */
+// @ts-expect-error Check `runOnUI` overload.
+export function createWorkletRuntime(
+  name: string,
+  initializer?: () => void
+): WorkletRuntime;
+
 export function createWorkletRuntime(
   name: string,
-  initializer?: __ComplexWorkletFunction<[], void>
-) {
+  initializer?: WorkletFunction<[], void>
+): WorkletRuntime {
   return NativeReanimatedModule.createWorkletRuntime(
     name,
     makeShareableCloneRecursive(() => {
@@ -51,7 +58,7 @@ export function runOnRuntime<Args extends unknown[], ReturnValue>(
   worklet: WorkletFunction<Args, ReturnValue>
 ): (...args: Args) => void {
   'worklet';
-  if (__DEV__ && !SHOULD_BE_USE_WEB && worklet.__workletHash === undefined) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorklet(worklet)) {
     throw new Error(
       '[Reanimated] The function passed to `runOnRuntime` is not a worklet.' +
         (_WORKLET
diff --git a/src/reanimated2/shareables.ts b/src/reanimated2/shareables.ts
index 4f0c9720a17..47510a4e680 100644
--- a/src/reanimated2/shareables.ts
+++ b/src/reanimated2/shareables.ts
@@ -1,9 +1,10 @@
 'use strict';
 import NativeReanimatedModule from './NativeReanimated';
+import { isWorklet } from './commonTypes';
 import type {
   ShareableRef,
   FlatShareableRef,
-  __WorkletFunction,
+  WorkletFunction,
 } from './commonTypes';
 import { shouldBeUseWeb } from './PlatformChecker';
 import { registerWorkletStackDetails } from './errors';
@@ -138,7 +139,7 @@ export function makeShareableCloneRecursive<T>(
         toAdapt = value.map((element) =>
           makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1)
         );
-      } else if (isTypeFunction && value.__workletHash === undefined) {
+      } else if (isTypeFunction && !isWorklet(value)) {
         // this is a remote function
         toAdapt = value;
       } else if (isHostObject(value)) {
@@ -148,8 +149,7 @@ export function makeShareableCloneRecursive<T>(
         toAdapt = value;
       } else if (isPlainJSObject(value) || isTypeFunction) {
         toAdapt = {};
-        if (value.__workletHash !== undefined) {
-          // we are converting a worklet
+        if (isWorklet(value)) {
           if (__DEV__) {
             const babelVersion = value.__initData.version;
             if (babelVersion !== undefined && babelVersion !== jsVersion) {
@@ -159,7 +159,7 @@ Offending code was: \`${getWorkletCode(value)}\``);
             }
             registerWorkletStackDetails(
               value.__workletHash,
-              value.__stackDetails
+              value.__stackDetails!
             );
           }
           if (value.__stackDetails) {
@@ -264,7 +264,7 @@ Offending code was: \`${getWorkletCode(value)}\``);
 
 const WORKLET_CODE_THRESHOLD = 255;
 
-function getWorkletCode(value: __WorkletFunction) {
+function getWorkletCode(value: WorkletFunction) {
   // @ts-ignore this is fine
   const code = value?.__initData?.code;
   if (!code) {
diff --git a/src/reanimated2/threads.ts b/src/reanimated2/threads.ts
index feced8abfa2..e7cfc74d8b9 100644
--- a/src/reanimated2/threads.ts
+++ b/src/reanimated2/threads.ts
@@ -6,6 +6,7 @@ import {
   makeShareableCloneOnUIRecursive,
   makeShareableCloneRecursive,
 } from './shareables';
+import { isWorklet } from './commonTypes';
 
 const IS_JEST = isJest();
 const SHOULD_BE_USE_WEB = shouldBeUseWeb();
@@ -79,7 +80,7 @@ export function runOnUI<Args extends unknown[], ReturnValue>(
       '[Reanimated] `runOnUI` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.'
     );
   }
-  if (__DEV__ && !SHOULD_BE_USE_WEB && worklet.__workletHash === undefined) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorklet(worklet)) {
     throw new Error('[Reanimated] `runOnUI` can only be used on worklets.');
   }
   return (...args) => {
@@ -110,8 +111,7 @@ export function runOnUI<Args extends unknown[], ReturnValue>(
       makeShareableCloneRecursive(worklet);
       makeShareableCloneRecursive(args);
     }
-    //
-    _runOnUIQueue.push([worklet as WorkletFunction<unknown[], unknown>, args]);
+    _runOnUIQueue.push([worklet as WorkletFunction, args]);
     if (_runOnUIQueue.length === 1) {
       queueMicrotask(() => {
         const queue = _runOnUIQueue;
@@ -166,7 +166,7 @@ export function runOnUIImmediately<Args extends unknown[], ReturnValue>(
       '[Reanimated] `runOnUIImmediately` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.'
     );
   }
-  if (__DEV__ && !SHOULD_BE_USE_WEB && worklet.__workletHash === undefined) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorklet(worklet)) {
     throw new Error(
       '[Reanimated] `runOnUIImmediately` can only be used on worklets.'
     );
@@ -216,7 +216,6 @@ export function runOnJS<Args extends unknown[], ReturnValue>(
     | WorkletFunction<Args, ReturnValue>
 ): (...args: Args) => void {
   'worklet';
-  type FunWorklet = Extract<typeof fun, WorkletFunction<Args, ReturnValue>>;
   type FunDevRemote = Extract<typeof fun, DevRemoteFunction<Args, ReturnValue>>;
   if (SHOULD_BE_USE_WEB || !_WORKLET) {
     // if we are already on the JS thread, we just schedule the worklet on the JS queue
@@ -227,7 +226,7 @@ export function runOnJS<Args extends unknown[], ReturnValue>(
           : (fun as () => ReturnValue)
       );
   }
-  if ((fun as FunWorklet).__workletHash) {
+  if (isWorklet<Args, ReturnValue>(fun)) {
     // If `fun` is a worklet, we schedule a call of a remote function `runWorkletOnJS`
     // and pass the worklet as a first argument followed by original arguments.
 
@@ -241,7 +240,7 @@ export function runOnJS<Args extends unknown[], ReturnValue>(
     // In development mode the function provided as `fun` throws an error message
     // such that when someone accidentally calls it directly on the UI runtime, they
     // see that they should use `runOnJS` instead. To facilitate that we put the
-    // reference to the original remote function in the `__functionInDEV` property.
+    // reference to the original remote function in the `__remoteFunction` property.
     fun = (fun as FunDevRemote).__remoteFunction;
   }
   return (...args) => {
diff --git a/src/reanimated2/valueUnpacker.ts b/src/reanimated2/valueUnpacker.ts
index d5d1e775f32..77416c0aeaa 100644
--- a/src/reanimated2/valueUnpacker.ts
+++ b/src/reanimated2/valueUnpacker.ts
@@ -1,5 +1,6 @@
 'use strict';
 import { shouldBeUseWeb } from './PlatformChecker';
+import { isWorklet } from './commonTypes';
 import type { WorkletFunction } from './commonTypes';
 
 function valueUnpacker(objectToUnpack: any, category?: string): any {
@@ -75,12 +76,12 @@ if (__DEV__ && !shouldBeUseWeb()) {
   const testWorklet = (() => {
     'worklet';
   }) as WorkletFunction<[], void>;
-  if (testWorklet.__workletHash === undefined) {
+  if (!isWorklet(testWorklet)) {
     throw new Error(
       `[Reanimated] Failed to create a worklet. See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#failed-to-create-a-worklet for more details.`
     );
   }
-  if (!('__workletHash' in valueUnpacker)) {
+  if (!isWorklet(valueUnpacker)) {
     throw new Error('[Reanimated] `valueUnpacker` is not a worklet');
   }
   const closure = (valueUnpacker as ValueUnpacker).__closure;