react-native-worklets 0.3.0 → 0.4.0-bundle-mode-preview-1

package/src/shareables.ts

@@ -1,7 +1,7 @@
 'use strict';
 import { registerWorkletStackDetails } from './errors';
 import { logger } from './logger';
-import { shouldBeUseWeb } from './PlatformChecker';
+import { SHOULD_BE_USE_WEB } from './PlatformChecker';
 import {
   shareableMappingCache,
   shareableMappingFlag,
@@ -13,13 +13,13 @@ import type {
   FlatShareableRef,
   ShareableRef,
   WorkletFunction,
+  WorkletImport,
 } from './workletTypes';
 
 // for web and jest environments this file provides a stub implementation
 // where no shareable references are used. Instead, the objects themselves are used
 // instead of shareable references, because of the fact that we don't have to deal with
 // running the code on separate VMs.
-const SHOULD_BE_USE_WEB = shouldBeUseWeb();
 
 const MAGIC_KEY = 'REANIMATED_MAGIC_KEY';
 
@@ -33,9 +33,14 @@ function isHostObject(value: NonNullable<object>) {
 }
 
 function isPlainJSObject(object: object): object is Record<string, unknown> {
+  'worklet';
   return Object.getPrototypeOf(object) === Object.prototype;
 }
 
+function isTurboModuleLike(object: object): object is Record<string, unknown> {
+  return isHostObject(Object.getPrototypeOf(object));
+}
+
 function getFromCache(value: object) {
   const cached = shareableMappingCache.get(value);
   if (cached === shareableMappingFlag) {
@@ -159,11 +164,30 @@ function makeShareableCloneRecursiveNative<T>(
   if (Array.isArray(value)) {
     return cloneArray(value, shouldPersistRemote, depth);
   }
+  if (
+    globalThis._WORKLETS_BUNDLE_MODE &&
+    isFunction &&
+    (value as WorkletImport).__bundleData
+  ) {
+    return cloneImport(value as WorkletImport) as ShareableRef<T>;
+  }
   if (isFunction && !isWorkletFunction(value)) {
-    return cloneRemoteFunction(value, shouldPersistRemote);
+    return cloneRemoteFunction(value);
+  }
+  // RN has introduced a new representation of TurboModules as a JS object whose prototype is the host object
+  // More details: https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.cpp#L182
+  if (isTurboModuleLike(value)) {
+    return cloneTurboModuleLike(value, shouldPersistRemote, depth);
   }
   if (isHostObject(value)) {
-    return cloneHostObject(value, shouldPersistRemote);
+    return cloneHostObject(value);
+  }
+  if (isPlainJSObject(value) && value.__init) {
+    return cloneInitializer(
+      value,
+      shouldPersistRemote,
+      depth
+    ) as ShareableRef<T>;
   }
   if (isPlainJSObject(value) && value.__workletContextObjectFactory) {
     return cloneContextObject(value);
@@ -174,6 +198,12 @@ function makeShareableCloneRecursiveNative<T>(
   if (isPlainJSObject(value) || isFunction) {
     return clonePlainJSObject(value, shouldPersistRemote, depth);
   }
+  if (value instanceof Set) {
+    return cloneSet(value);
+  }
+  if (value instanceof Map) {
+    return cloneMap(value);
+  }
   if (value instanceof RegExp) {
     return cloneRegExp(value);
   }
@@ -190,7 +220,16 @@ function makeShareableCloneRecursiveNative<T>(
   return inaccessibleObject(value);
 }
 
-export interface MakeShareableClone {
+if (globalThis._WORKLETS_BUNDLE_MODE) {
+  // TODO: Do it programatically.
+  makeShareableCloneRecursiveNative.__bundleData = {
+    imported: 'makeShareableCloneRecursive',
+    // @ts-expect-error resolveWeak is defined by Metro
+    source: require.resolveWeak('./index'),
+  };
+}
+
+interface MakeShareableClone {
   <T>(value: T, shouldPersistRemote?: boolean, depth?: number): ShareableRef<T>;
 }
 
@@ -248,6 +287,41 @@ function cloneNull(): ShareableRef<null> {
   return WorkletsModule.makeShareableNull();
 }
 
+function cloneObjectProperties<T extends object>(
+  value: T,
+  shouldPersistRemote: boolean,
+  depth: number
+): Record<string, unknown> {
+  const clonedProps: Record<string, unknown> = {};
+  for (const [key, element] of Object.entries(value)) {
+    // We don't need to clone __initData field as it contains long strings
+    // representing the worklet code, source map, and location, and we will
+    // serialize/deserialize it once.
+    if (key === '__initData' && clonedProps.__initData !== undefined) {
+      continue;
+    }
+    clonedProps[key] = makeShareableCloneRecursive(
+      element,
+      shouldPersistRemote,
+      depth + 1
+    );
+  }
+  return clonedProps;
+}
+
+function cloneInitializer(
+  value: object,
+  shouldPersistRemote = false,
+  depth = 0
+): ShareableRef<object> {
+  const clonedProps: Record<string, unknown> = cloneObjectProperties(
+    value,
+    shouldPersistRemote,
+    depth
+  );
+  return WorkletsModule.makeShareableInitializer(clonedProps);
+}
+
 function cloneArray<T extends unknown[]>(
   value: T,
   shouldPersistRemote: boolean,
@@ -256,10 +330,9 @@ function cloneArray<T extends unknown[]>(
   const clonedElements = value.map((element) =>
     makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1)
   );
-  const clone = WorkletsModule.makeShareableClone(
+  const clone = WorkletsModule.makeShareableArray(
     clonedElements,
-    shouldPersistRemote,
-    value
+    shouldPersistRemote
   ) as ShareableRef<T>;
   shareableMappingCache.set(value, clone);
   shareableMappingCache.set(clone);
@@ -268,15 +341,10 @@ function cloneArray<T extends unknown[]>(
   return clone;
 }
 
-function cloneRemoteFunction<T extends object>(
-  value: T,
-  shouldPersistRemote: boolean
-): ShareableRef<T> {
-  const clone = WorkletsModule.makeShareableClone(
-    value,
-    shouldPersistRemote,
-    value
-  );
+function cloneRemoteFunction<TArgs extends unknown[], TReturn>(
+  value: (...args: TArgs) => TReturn
+): ShareableRef<TReturn> {
+  const clone = WorkletsModule.makeShareableFunction(value);
   shareableMappingCache.set(value, clone);
   shareableMappingCache.set(clone);
 
@@ -284,18 +352,11 @@ function cloneRemoteFunction<T extends object>(
   return clone;
 }
 
-function cloneHostObject<T extends object>(
-  value: T,
-  shouldPersistRemote: boolean
-): ShareableRef<T> {
+function cloneHostObject<T extends object>(value: T): ShareableRef<T> {
   // for host objects we pass the reference to the object as shareable and
   // then recreate new host object wrapping the same instance on the UI thread.
   // there is no point of iterating over keys as we do for regular objects.
-  const clone = WorkletsModule.makeShareableClone(
-    value,
-    shouldPersistRemote,
-    value
-  );
+  const clone = WorkletsModule.makeShareableHostObject(value);
   shareableMappingCache.set(value, clone);
   shareableMappingCache.set(clone);
 
@@ -327,33 +388,27 @@ function cloneWorklet<T extends WorkletFunction>(
     // seems more elegant to handle it this way.
     delete (value as WorkletFunction).__stackDetails;
   }
+  const clonedProps: Record<string, unknown> = cloneObjectProperties(
+    value,
+    true,
+    depth
+  );
   // to save on transferring static __initData field of worklet structure
   // we request shareable value to persist its UI counterpart. This means
-  // that the __initData field that contains long strings represeting the
+  // that the __initData field that contains long strings representing the
   // worklet code, source map, and location, will always be
   // serialized/deserialized once.
-  const clonedProps: Record<string, unknown> = {};
   clonedProps.__initData = makeShareableCloneRecursive(
     value.__initData,
     true,
     depth + 1
   );
 
-  for (const [key, element] of Object.entries(value)) {
-    if (key === '__initData' && clonedProps.__initData !== undefined) {
-      continue;
-    }
-    clonedProps[key] = makeShareableCloneRecursive(
-      element,
-      shouldPersistRemote,
-      depth + 1
-    );
-  }
-  const clone = WorkletsModule.makeShareableClone(
+  const clone = WorkletsModule.makeShareableWorklet(
     clonedProps,
+    // TODO: Check after refactor if we can remove shouldPersistRemote parameter (imho it's redundant here since worklets are always persistent)
     // retain all worklets
-    true,
-    value
+    true
   ) as ShareableRef<T>;
   shareableMappingCache.set(value, clone);
   shareableMappingCache.set(clone);
@@ -362,10 +417,28 @@ function cloneWorklet<T extends WorkletFunction>(
   return clone;
 }
 
+/**
+ * TurboModuleLike objects are JS objects that have a TurboModule as their
+ * prototype.
+ */
+function cloneTurboModuleLike<T extends object>(
+  value: T,
+  shouldPersistRemote: boolean,
+  depth: number
+): ShareableRef<T> {
+  const proto = Object.getPrototypeOf(value);
+  const clonedProps = cloneObjectProperties(value, shouldPersistRemote, depth);
+  const clone = WorkletsModule.makeShareableTurboModuleLike(
+    clonedProps,
+    proto
+  ) as ShareableRef<T>;
+  return clone;
+}
+
 function cloneContextObject<T extends object>(value: T): ShareableRef<T> {
   const workletContextObjectFactory = (value as Record<string, unknown>)
     .__workletContextObjectFactory as () => T;
-  const handle = makeShareableCloneRecursive({
+  const handle = cloneInitializer({
     __init: () => {
       'worklet';
       return workletContextObjectFactory();
@@ -380,18 +453,12 @@ function clonePlainJSObject<T extends object>(
   shouldPersistRemote: boolean,
   depth: number
 ): ShareableRef<T> {
-  const clonedProps: Record<string, unknown> = {};
-  for (const [key, element] of Object.entries(value)) {
-    if (key === '__initData' && clonedProps.__initData !== undefined) {
-      continue;
-    }
-    clonedProps[key] = makeShareableCloneRecursive(
-      element,
-      shouldPersistRemote,
-      depth + 1
-    );
-  }
-  const clone = WorkletsModule.makeShareableClone(
+  const clonedProps: Record<string, unknown> = cloneObjectProperties(
+    value,
+    shouldPersistRemote,
+    depth
+  );
+  const clone = WorkletsModule.makeShareableObject(
     clonedProps,
     shouldPersistRemote,
     value
@@ -403,10 +470,43 @@ function clonePlainJSObject<T extends object>(
   return clone;
 }
 
+function cloneMap<T extends Map<unknown, unknown>>(value: T): ShareableRef<T> {
+  const clonedKeys: unknown[] = [];
+  const clonedValues: unknown[] = [];
+  for (const [key, element] of value.entries()) {
+    clonedKeys.push(makeShareableCloneRecursive(key));
+    clonedValues.push(makeShareableCloneRecursive(element));
+  }
+  const clone = WorkletsModule.makeShareableMap(
+    clonedKeys,
+    clonedValues
+  ) as ShareableRef<T>;
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+
+  freezeObjectInDev(value);
+  return clone;
+}
+
+function cloneSet<T extends Set<unknown>>(value: T): ShareableRef<T> {
+  const clonedElements: unknown[] = [];
+  for (const element of value) {
+    clonedElements.push(makeShareableCloneRecursive(element));
+  }
+  const clone = WorkletsModule.makeShareableSet(
+    clonedElements
+  ) as ShareableRef<T>;
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+
+  freezeObjectInDev(value);
+  return clone;
+}
+
 function cloneRegExp<T extends RegExp>(value: T): ShareableRef<T> {
   const pattern = value.source;
   const flags = value.flags;
-  const handle = makeShareableCloneRecursive({
+  const handle = cloneInitializer({
     __init: () => {
       'worklet';
       return new RegExp(pattern, flags);
@@ -419,7 +519,7 @@ function cloneRegExp<T extends RegExp>(value: T): ShareableRef<T> {
 
 function cloneError<T extends Error>(value: T): ShareableRef<T> {
   const { name, message, stack } = value;
-  const handle = makeShareableCloneRecursive({
+  const handle = cloneInitializer({
     __init: () => {
       'worklet';
       // eslint-disable-next-line reanimated/use-worklets-error
@@ -454,7 +554,7 @@ function cloneArrayBufferView<T extends ArrayBufferView>(
 ): ShareableRef<T> {
   const buffer = value.buffer;
   const typeName = value.constructor.name;
-  const handle = makeShareableCloneRecursive({
+  const handle = cloneInitializer({
     __init: () => {
       'worklet';
       if (!VALID_ARRAY_VIEWS_NAMES.includes(typeName)) {
@@ -472,6 +572,18 @@ function cloneArrayBufferView<T extends ArrayBufferView>(
   return handle;
 }
 
+function cloneImport<TValue extends WorkletImport>(
+  value: TValue
+): ShareableRef<TValue> {
+  const { source, imported } = value.__bundleData;
+  const clone = WorkletsModule.makeShareableImport(source, imported);
+
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+
+  return clone as ShareableRef<TValue>;
+}
+
 function inaccessibleObject<T extends object>(value: T): ShareableRef<T> {
   // This is reached for object types that are not of plain Object.prototype.
   // We don't support such objects from being transferred as shareables to
@@ -550,7 +662,7 @@ function freezeObjectInDev<T extends object>(value: T) {
   Object.preventExtensions(value);
 }
 
-export function makeShareableCloneOnUIRecursive<T>(
+function makeShareableCloneOnUIRecursiveLEGACY<T>(
   value: T
 ): FlatShareableRef<T> {
   'worklet';
@@ -568,10 +680,7 @@ export function makeShareableCloneOnUIRecursive<T>(
       if (isHostObject(value)) {
         // We call `_makeShareableClone` to wrap the provided HostObject
         // inside ShareableJSRef.
-        return global._makeShareableClone(
-          value,
-          undefined
-        ) as FlatShareableRef<T>;
+        return global._makeShareableHostObject(value) as FlatShareableRef<T>;
       }
       if (isRemoteFunction<T>(value)) {
         // RemoteFunctions are created by us therefore they are
@@ -580,9 +689,8 @@ export function makeShareableCloneOnUIRecursive<T>(
         return value.__remoteFunction;
       }
       if (Array.isArray(value)) {
-        return global._makeShareableClone(
-          value.map(cloneRecursive),
-          undefined
+        return global._makeShareableArray(
+          value.map(cloneRecursive)
         ) as FlatShareableRef<T>;
       }
       const toAdapt: Record<string, FlatShareableRef<T>> = {};
@@ -621,6 +729,12 @@ export function makeShareableCloneOnUIRecursive<T>(
   return cloneRecursive(value);
 }
 
+export const makeShareableCloneOnUIRecursive = (
+  globalThis._WORKLETS_BUNDLE_MODE
+    ? makeShareableCloneRecursive
+    : makeShareableCloneOnUIRecursiveLEGACY
+) as typeof makeShareableCloneOnUIRecursiveLEGACY;
+
 function makeShareableJS<T extends object>(value: T): T {
   return value;
 }

package/src/specs/NativeWorkletsModule.ts

@@ -2,7 +2,7 @@
 import type { TurboModule } from 'react-native';
 import { TurboModuleRegistry } from 'react-native';
 
-interface Spec extends TurboModule {
+export interface Spec extends TurboModule {
   installTurboModule: () => boolean;
 }
 

package/src/specs/index.ts

@@ -1,5 +1,8 @@
 'use strict';
 
-import WorkletsTurboModule from './NativeWorkletsModule';
+import type { Spec } from './NativeWorkletsModule';
+import RNWorkletsTurboModule from './NativeWorkletsModule';
 
-export { WorkletsTurboModule };
+export const WorkletsTurboModule: Spec | null = globalThis._WORKLET
+  ? null
+  : RNWorkletsTurboModule;

package/src/threads.ts

@@ -1,5 +1,6 @@
 'use strict';
-import { isJest, shouldBeUseWeb } from './PlatformChecker';
+import { IS_JEST, SHOULD_BE_USE_WEB } from './PlatformChecker';
+import { shareableMappingCache } from './shareableMappingCache';
 import {
   makeShareableCloneOnUIRecursive,
   makeShareableCloneRecursive,
@@ -7,15 +8,15 @@ import {
 import { isWorkletFunction } from './workletFunction';
 import { WorkletsError } from './WorkletsError';
 import { WorkletsModule } from './WorkletsModule';
-import type { WorkletFunction } from './workletTypes';
+import type { WorkletFunction, WorkletImport } from './workletTypes';
 
-const IS_JEST = isJest();
-const SHOULD_BE_USE_WEB = shouldBeUseWeb();
+type UIJob<Args extends unknown[] = unknown[], ReturnValue = unknown> = [
+  worklet: WorkletFunction<Args, ReturnValue>,
+  args: Args,
+  resolve?: (value: ReturnValue) => void,
+];
 
-/** An array of [worklet, args, resolve (optional)] pairs. */
-let _runOnUIQueue: Array<
-  [WorkletFunction<unknown[], unknown>, unknown[], ((value: unknown) => void)?]
-> = [];
+let runOnUIQueue: UIJob[] = [];
 
 export function setupMicrotasks() {
   'worklet';
@@ -84,13 +85,12 @@ export function runOnUI<Args extends unknown[], ReturnValue>(
 export function runOnUI<Args extends unknown[], ReturnValue>(
   worklet: WorkletFunction<Args, ReturnValue>
 ): (...args: Args) => void {
-  'worklet';
-  if (__DEV__ && !SHOULD_BE_USE_WEB && globalThis._WORKLET) {
-    throw new WorkletsError(
-      '`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 && !isWorkletFunction(worklet)) {
+  if (
+    __DEV__ &&
+    !SHOULD_BE_USE_WEB &&
+    !isWorkletFunction(worklet) &&
+    !(worklet as unknown as WorkletImport).__bundleData
+  ) {
     throw new WorkletsError('`runOnUI` can only be used with worklets.');
   }
   return (...args) => {
@@ -121,26 +121,23 @@ export function runOnUI<Args extends unknown[], ReturnValue>(
       makeShareableCloneRecursive(worklet);
       makeShareableCloneRecursive(args);
     }
-    _runOnUIQueue.push([worklet as WorkletFunction, args]);
-    if (_runOnUIQueue.length === 1) {
-      queueMicrotask(() => {
-        const queue = _runOnUIQueue;
-        _runOnUIQueue = [];
-        WorkletsModule.scheduleOnUI(
-          makeShareableCloneRecursive(() => {
-            'worklet';
-            // eslint-disable-next-line @typescript-eslint/no-shadow
-            queue.forEach(([worklet, args]) => {
-              worklet(...args);
-            });
-            callMicrotasks();
-          })
-        );
-      });
-    }
+
+    enqueueUI(worklet, args);
   };
 }
 
+if (__DEV__) {
+  function runOnUIWorklet(): void {
+    'worklet';
+    throw new WorkletsError(
+      '`runOnUI` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.'
+    );
+  }
+
+  const shareableRunOnUIWorklet = makeShareableCloneRecursive(runOnUIWorklet);
+  shareableMappingCache.set(runOnUI, shareableRunOnUIWorklet);
+}
+
 // @ts-expect-error Check `executeOnUIRuntimeSync` overload above.
 export function executeOnUIRuntimeSync<Args extends unknown[], ReturnValue>(
   worklet: (...args: Args) => ReturnValue
@@ -239,10 +236,7 @@ export function runOnJS<Args extends unknown[], ReturnValue>(
       fun as
         | ((...args: Args) => ReturnValue)
         | WorkletFunction<Args, ReturnValue>,
-      args.length > 0
-        ? // TODO TYPESCRIPT this cast is terrible but will be fixed
-          (makeShareableCloneOnUIRecursive(args) as unknown as unknown[])
-        : undefined
+      args.length > 0 ? makeShareableCloneOnUIRecursive(args) : undefined
     );
   };
 }
@@ -269,12 +263,6 @@ export function runOnJS<Args extends unknown[], ReturnValue>(
 export function runOnUIAsync<Args extends unknown[], ReturnValue>(
   worklet: (...args: Args) => ReturnValue
 ): (...args: Args) => Promise<ReturnValue> {
-  'worklet';
-  if (__DEV__ && !SHOULD_BE_USE_WEB && globalThis._WORKLET) {
-    throw new WorkletsError(
-      '`runOnUIAsync` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.'
-    );
-  }
   if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorkletFunction(worklet)) {
     throw new WorkletsError('`runOnUIAsync` can only be used with worklets.');
   }
@@ -308,29 +296,51 @@ export function runOnUIAsync<Args extends unknown[], ReturnValue>(
         makeShareableCloneRecursive(args);
       }
 
-      _runOnUIQueue.push([
-        worklet as WorkletFunction,
-        args,
-        resolve as (value: unknown) => void,
-      ]);
-      if (_runOnUIQueue.length === 1) {
-        queueMicrotask(() => {
-          const queue = _runOnUIQueue.slice();
-          _runOnUIQueue = [];
-          WorkletsModule.scheduleOnUI(
-            makeShareableCloneRecursive(() => {
-              'worklet';
-              queue.forEach(([workletFunction, workletArgs, jobResolve]) => {
-                const result = workletFunction(...workletArgs);
-                if (jobResolve) {
-                  runOnJS(jobResolve)(result);
-                }
-              });
-              callMicrotasks();
-            })
-          );
-        });
-      }
+      enqueueUI(worklet as WorkletFunction<Args, ReturnValue>, args, resolve);
     });
   };
 }
+
+if (__DEV__) {
+  function runOnUIAsyncWorklet(): void {
+    'worklet';
+    throw new WorkletsError(
+      '`runOnUIAsync` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.'
+    );
+  }
+
+  const shareableRunOnUIAsyncWorklet =
+    makeShareableCloneRecursive(runOnUIAsyncWorklet);
+  shareableMappingCache.set(runOnUIAsync, shareableRunOnUIAsyncWorklet);
+}
+
+function enqueueUI<Args extends unknown[], ReturnValue>(
+  worklet: WorkletFunction<Args, ReturnValue>,
+  args: Args,
+  resolve?: (value: ReturnValue) => void
+): void {
+  const job = [worklet, args, resolve] as UIJob<Args, ReturnValue>;
+  runOnUIQueue.push(job as unknown as UIJob);
+  if (runOnUIQueue.length === 1) {
+    flushUIQueue();
+  }
+}
+
+function flushUIQueue(): void {
+  queueMicrotask(() => {
+    const queue = runOnUIQueue;
+    runOnUIQueue = [];
+    WorkletsModule.scheduleOnUI(
+      makeShareableCloneRecursive(() => {
+        'worklet';
+        queue.forEach(([workletFunction, workletArgs, jobResolve]) => {
+          const result = workletFunction(...workletArgs);
+          if (jobResolve) {
+            runOnJS(jobResolve)(result);
+          }
+        });
+        callMicrotasks();
+      })
+    );
+  });
+}

package/src/valueUnpacker.ts

@@ -1,8 +1,6 @@
-/* eslint-disable reanimated/use-worklets-error */
 'use strict';
 import type { WorkletFunction } from './workletTypes';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function __valueUnpacker(
   objectToUnpack: ObjectToUnpack,
   category?: string,
@@ -62,14 +60,16 @@ function __valueUnpacker(
       const label = remoteFunctionName
         ? `function \`${remoteFunctionName}\``
         : 'anonymous function';
+      // eslint-disable-next-line reanimated/use-worklets-error
       throw new Error(`[Worklets] Tried to synchronously call a non-worklet ${label} on the UI thread.
 See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-synchronously-call-a-non-worklet-function-on-the-ui-thread for more details.`);
     };
     fun.__remoteFunction = objectToUnpack;
     return fun;
   } else {
+    // eslint-disable-next-line reanimated/use-worklets-error
     throw new Error(
-      `[Worklets] Data type in category "${category}" not recognized by value unpacker: "${_toString(
+      `[Worklets] Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(
         objectToUnpack
       )}".`
     );

package/src/workletRuntimeEntry.ts

@@ -0,0 +1,30 @@
+'use strict';
+
+import { init } from './initializers';
+import { WorkletsError } from './WorkletsError';
+
+/**
+ * This function is an entry point for Worklet Runtimes. We can use it to setup
+ * necessary tools, like the ValueUnpacker.
+ *
+ * We must throw an error at the end of this function to prevent the bundle to
+ * continue executing. This is because the next module to be ran would be the
+ * React Native one, and it would break the Worklet Runtime if initialized. The
+ * error is caught in C++ code.
+ *
+ * This function has no effect on the RN Runtime beside setting the
+ * `_WORKLETS_BUNDLE_MODE` flag.
+ */
+export function bundleModeInit() {
+  globalThis._WORKLETS_BUNDLE_MODE = true;
+  if (globalThis._WORKLET) {
+    /**
+     * We shouldn't call `init()` on RN Runtime here, as it would initialize our
+     * module before React Native has configured the RN Runtime.
+     */
+    init();
+    throw new WorkletsError('Worklets initialized successfully');
+  }
+}
+
+bundleModeInit();