react-native-worklets 0.7.2 → 0.8.0-bundle-mode-preview-1

package/src/bundleMode/metroOverrides.native.ts

@@ -0,0 +1,151 @@
+'use strict';
+
+import { WorkletsError } from '../debug/WorkletsError';
+import { isWorkletRuntime } from '../runtimeKind';
+
+/**
+ * Evaluating HMR updates on Worklet Runtimes leads to verbose warnings which
+ * don't affect runtime. This function silences those warnings by providing a
+ * dummy Refresh module to the global scope.
+ *
+ * Use only in dev builds.
+ */
+export function silenceHMRWarnings() {
+  assertWorkletRuntime('silenceHMRWarnings');
+
+  const Refresh = new Proxy(
+    {},
+    {
+      get() {
+        return () => {};
+      },
+    }
+  );
+
+  globalThis.__r.Refresh = Refresh;
+}
+
+/**
+ * Importing `react-native` on Worklet Runtimes will result in a crash due to
+ * the fact that React Native will try to set itself up as on the React Native
+ * runtime. To provide better developer experience we override the main React
+ * Native module with a proxy that puts an actionable warning.
+ *
+ * Note that this doesn't affect deep imports.
+ *
+ * Use only in dev builds.
+ */
+export function disallowRNImports() {
+  assertWorkletRuntime('disallowRNImports');
+
+  const modules = require.getModules();
+  const ReactNativeModuleId = require.resolveWeak('react-native');
+
+  const moduleFactory = makeModuleFactory((module) => {
+    module.exports = new Proxy(
+      {},
+      {
+        get: function get(_target, prop) {
+          globalThis.console.warn(
+            `You tried to import '${String(
+              prop
+            )}' from 'react-native' module on a Worklet Runtime. Using 'react-native' module on a Worklet Runtime is not allowed.`,
+            // eslint-disable-next-line reanimated/use-worklets-error
+            new Error().stack
+          );
+          return {
+            get() {
+              return undefined;
+            },
+          };
+        },
+      }
+    );
+  });
+
+  const mockModule = {
+    dependencyMap: [],
+    moduleFactory,
+    hasError: false,
+    importedAll: {},
+    importedDefault: {},
+    isInitialized: false,
+    publicModule: {
+      exports: {},
+    },
+  };
+
+  modules.set(ReactNativeModuleId, mockModule);
+}
+
+/**
+ * To use code from React Native that obtains TurboModules we need to mock the
+ * registry even if the TurboModules aren't actually used.
+ *
+ * This is needed for example for the XHR setup code that is imported from React
+ * Native.
+ */
+export function mockTurboModuleRegistry() {
+  const modules = require.getModules();
+
+  const TurboModuleRegistryId = require.resolveWeak(
+    'react-native/Libraries/TurboModule/TurboModuleRegistry'
+  );
+
+  const TurboModules = new Map<string, unknown>();
+
+  TurboModules.set('Networking', {});
+
+  globalThis.TurboModules = TurboModules;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const moduleFactory = makeModuleFactory((module: any) => {
+    function get(name: string) {
+      return globalThis.TurboModules.get(name);
+    }
+    function getEnforcing(name: string) {
+      return globalThis.TurboModules.get(name);
+    }
+    module.exports.get = get;
+    module.exports.getEnforcing = getEnforcing;
+  });
+
+  const metroModule = {
+    dependencyMap: [],
+    factory: moduleFactory,
+    hasError: false,
+    importedAll: {},
+    importedDefault: {},
+    isInitialized: false,
+    publicModule: {
+      exports: {},
+    },
+  };
+
+  modules.set(TurboModuleRegistryId, metroModule);
+}
+
+function assertWorkletRuntime(functionName: string) {
+  if (!isWorkletRuntime()) {
+    throw new WorkletsError(
+      `${functionName} can be used only on Worklet Runtimes.`
+    );
+  }
+}
+
+/** Module factory mimicking the one used by Metro bundler. */
+function makeModuleFactory(
+  moduleImpl: (moduleExports: Record<string, unknown>) => void
+) {
+  return function (
+    _global: unknown,
+    _require: unknown,
+    _importDefault: unknown,
+    _importAll: unknown,
+    module: Record<string, unknown>,
+    _exports: unknown,
+    _dependencyMap: unknown
+  ) {
+    moduleImpl(module);
+  };
+}

package/src/bundleMode/network.native.ts

@@ -0,0 +1,59 @@
+'use strict';
+
+import { WorkletsError } from '../debug/WorkletsError';
+
+/**
+ * Mocks necessary networking TurboModules on Worklet Runtimes to prevent
+ * crashes when code running on Worklet Runtimes tries to use networking APIs.
+ * The NetworkingModule itself is injected via C++.
+ */
+export function initializeNetworking() {
+  const TurboModules = globalThis.TurboModules;
+
+  TurboModules.set('FileReaderModule', makeMockTurboModule('FileReaderModule'));
+  TurboModules.set(
+    'PlatformConstants',
+    makeMockTurboModule('PlatformConstants')
+  );
+  TurboModules.set('WebSocketModule', makeMockTurboModule('WebSocketModule'));
+  TurboModules.set(
+    'BlobModule',
+    makeMockTurboModule('BlobModule', ['addNetworkingHandler'])
+  );
+
+  /**
+   * This require statement below is the key part of the implementation here. It
+   * pulls all the code that properly sets up XHR on a Runtime, using underlying
+   * C++ NetworkingModule. Thanks to that we can have the same JavaScript
+   * implementation for fetch on all runtimes in the app and we don't have to
+   * write the code ourselves.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require('react-native/Libraries/Core/setUpXHR');
+}
+
+const noopMethods = ['getConstants'];
+
+function makeMockTurboModule(name: string, extraNoopMethods?: string[]) {
+  const proxy = new Proxy(
+    {},
+    {
+      get: function get(_target, prop) {
+        if (
+          [...noopMethods, ...(extraNoopMethods ?? [])].includes(prop as string)
+        ) {
+          return () => {
+            return () => {};
+          };
+        }
+        throw new WorkletsError(
+          `You tried to call method '${String(
+            prop
+          )}' from '${name}' TurboModule on a Worklet Runtime. Using '${name}' TurboModule on a Worklet Runtime is not allowed.`
+        );
+      },
+    }
+  );
+
+  return proxy;
+}

package/src/debug/jsVersion.ts

@@ -5,4 +5,4 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '0.7.2';
+export const jsVersion = '0.8.0-bundle-mode-preview-1';

package/src/featureFlags/staticFlags.json

@@ -1,4 +1,6 @@
 {
   "RUNTIME_TEST_FLAG": false,
+  "BUNDLE_MODE_ENABLED": false,
+  "FETCH_PREVIEW_ENABLED": false,
   "IOS_DYNAMIC_FRAMERATE_ENABLED": true
 }

package/src/featureFlags/types.ts

@@ -21,7 +21,9 @@ export type DynamicFlagName = keyof Omit<
  */
 export const DefaultStaticFeatureFlags = {
   RUNTIME_TEST_FLAG: false,
-  IOS_DYNAMIC_FRAMERATE_ENABLED: false,
+  BUNDLE_MODE_ENABLED: false,
+  FETCH_PREVIEW_ENABLED: false,
+  IOS_DYNAMIC_FRAMERATE_ENABLED: true,
 } as const satisfies typeof StaticFeatureFlagsJSON;
 
 export type StaticFeatureFlagsSchema = {

package/src/index.ts

@@ -3,6 +3,7 @@
 import { init } from './initializers/initializers';
 import { bundleModeInit } from './initializers/workletRuntimeEntry';
 
+// is-tree-shakable-suppress
 init();
 
 // @ts-expect-error We must trick the bundler to include
@@ -40,10 +41,18 @@ export type {
   Synchronizable,
   SynchronizableRef,
 } from './memory/types';
-export { getRuntimeKind, RuntimeKind } from './runtimeKind';
+export {
+  getRuntimeKind,
+  isRNRuntime,
+  isUIRuntime,
+  isWorkerRuntime,
+  isWorkletRuntime,
+  RuntimeKind,
+} from './runtimeKind';
 export {
   createWorkletRuntime,
   runOnRuntime,
+  runOnRuntimeSync,
   scheduleOnRuntime,
 } from './runtimes';
 export {

package/src/initializers/initializers.native.ts

@@ -1,10 +1,18 @@
 'use strict';
 
+import {
+  disallowRNImports,
+  mockTurboModuleRegistry,
+  silenceHMRWarnings,
+} from '../bundleMode/metroOverrides';
+import { initializeNetworking } from '../bundleMode/network';
 import { setupCallGuard } from '../callGuard';
 import { registerReportFatalRemoteError } from '../debug/errors';
 import { registerWorkletsError, WorkletsError } from '../debug/WorkletsError';
+import { getStaticFeatureFlag } from '../featureFlags/featureFlags';
 import { bundleValueUnpacker } from '../memory/bundleUnpacker';
 import { __installUnpacker as installCustomSerializableUnpacker } from '../memory/customSerializableUnpacker';
+import { makeShareableCloneOnUIRecursive } from '../memory/serializable';
 import { __installUnpacker as installSynchronizableUnpacker } from '../memory/synchronizableUnpacker';
 import { setupSetImmediate } from '../runLoop/common/setImmediatePolyfill';
 import { setupSetInterval } from '../runLoop/common/setIntervalPolyfill';
@@ -82,6 +90,11 @@ export function setupConsole(boundCapturableConsole: typeof console) {
   };
 }
 
+export function setupSerializer() {
+  'worklet';
+  globalThis.__serializer = makeShareableCloneOnUIRecursive;
+}
+
 let initialized = false;
 
 export function init() {
@@ -102,7 +115,7 @@ export function init() {
 
 /** A function that should be run on any kind of runtime. */
 function initializeRuntime() {
-  if (globalThis._WORKLETS_BUNDLE_MODE) {
+  if (globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
     globalThis.__valueUnpacker = bundleValueUnpacker as ValueUnpacker;
   }
   installSynchronizableUnpacker();
@@ -127,68 +140,17 @@ function initializeRNRuntime() {
 
 /** A function that should be run only on Worklet runtimes. */
 function initializeWorkletRuntime() {
-  if (globalThis._WORKLETS_BUNDLE_MODE) {
+  if (globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
     setupCallGuard();
 
     if (__DEV__) {
-      /*
-       * Temporary workaround for Metro bundler. We must implement a dummy
-       * Refresh module to prevent Metro from throwing irrelevant errors.
-       */
-      const Refresh = new Proxy(
-        {},
-        {
-          get() {
-            return () => {};
-          },
-        }
-      );
-
-      globalThis.__r.Refresh = Refresh;
-
-      /* Gracefully handle unwanted imports from React Native. */
-      const modules = require.getModules();
-      const ReactNativeModuleId = require.resolveWeak('react-native');
-
-      const factory = function (
-        _global: unknown,
-        _require: unknown,
-        _importDefault: unknown,
-        _importAll: unknown,
-        module: Record<string, unknown>,
-        _exports: unknown,
-        _dependencyMap: unknown
-      ) {
-        module.exports = new Proxy(
-          {},
-          {
-            get: function get(_target, prop) {
-              globalThis.console.warn(
-                `You tried to import '${String(prop)}' from 'react-native' module on a Worklet Runtime. Using 'react-native' module on a Worklet Runtime is not allowed.`
-              );
-              return {
-                get() {
-                  return undefined;
-                },
-              };
-            },
-          }
-        );
-      };
-
-      const mod = {
-        dependencyMap: [],
-        factory,
-        hasError: false,
-        importedAll: {},
-        importedDefault: {},
-        isInitialized: false,
-        publicModule: {
-          exports: {},
-        },
-      };
+      silenceHMRWarnings();
+      disallowRNImports();
+    }
 
-      modules.set(ReactNativeModuleId, mod);
+    if (getStaticFeatureFlag('FETCH_PREVIEW_ENABLED')) {
+      mockTurboModuleRegistry();
+      initializeNetworking();
     }
   }
 }
@@ -204,22 +166,19 @@ function installRNBindingsOnUIRuntime() {
     );
   }
 
-  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
-
-  if (!globalThis._WORKLETS_BUNDLE_MODE) {
-    /** In bundle mode Runtimes setup their callGuard themselves. */
+  if (!globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
+    /** In Bundle Mode Runtimes setup their callGuard themselves. */
     runOnUISync(setupCallGuard);
 
-    /**
-     * Register WorkletsError in the UI runtime global scope. (we are using
-     * `executeOnUIRuntimeSync` here to make sure that the changes are applied
-     * before any async operations are executed on the UI runtime).
-     *
-     * There's no need to register the error in bundle mode.
-     */
+    /** In Bundle Mode the error is taken from the bundle. */
     runOnUISync(registerWorkletsError);
+
+    /** In Bundle Mode the serializer is taken from the bundle. */
+    runOnUISync(setupSerializer);
   }
 
+  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
+
   runOnUISync(() => {
     'worklet';
 

package/src/initializers/workletRuntimeEntry.native.ts

@@ -14,14 +14,14 @@ import { init } from './initializers';
  * error is caught in C++ code.
  *
  * This function has no effect on the RN Runtime beside setting the
- * `_WORKLETS_BUNDLE_MODE` flag.
+ * `_WORKLETS_BUNDLE_MODE_ENABLED` flag.
  */
 export function bundleModeInit() {
   // Worklets Babel Plugin replaces `false` with `true` here
   // when Bundle Mode is enabled.
-  globalThis._WORKLETS_BUNDLE_MODE = false;
+  globalThis._WORKLETS_BUNDLE_MODE_ENABLED = false;
 
-  if (!globalThis._WORKLETS_BUNDLE_MODE) {
+  if (!globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
     return;
   }
 

package/src/memory/bundleUnpacker.native.ts

@@ -48,11 +48,9 @@ function getWorklet(
   if (__DEV__) {
     try {
       worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
-    } catch (_e) {
+    } catch (e) {
       logger.error(
-        'Unable to resolve worklet with hash ' +
-          workletHash +
-          '. Try reloading the app.'
+        `Unable to resolve worklet with hash ${workletHash}. Try reloading the app. Original error: ${(e as Error).message}`
       );
     }
   } else {

package/src/memory/serializable.native.ts

@@ -174,7 +174,7 @@ export function createSerializable<TValue>(
     return cloneArray(value, shouldPersistRemote, depth);
   }
   if (
-    globalThis._WORKLETS_BUNDLE_MODE &&
+    globalThis._WORKLETS_BUNDLE_MODE_ENABLED &&
     isFunction &&
     (value as WorkletImport).__bundleData
   ) {
@@ -238,7 +238,7 @@ export function createSerializable<TValue>(
   return inaccessibleObject(value);
 }
 
-if (globalThis._WORKLETS_BUNDLE_MODE) {
+if (globalThis._WORKLETS_BUNDLE_MODE_ENABLED) {
   // TODO: Do it programmatically.
   createSerializable.__bundleData = {
     imported: 'createSerializable',
@@ -870,7 +870,7 @@ function makeShareableCloneOnUIRecursiveLEGACY<TValue>(
 
 /** @deprecated This function is no longer supported. */
 export const makeShareableCloneOnUIRecursive = (
-  globalThis._WORKLETS_BUNDLE_MODE
+  globalThis._WORKLETS_BUNDLE_MODE_ENABLED
     ? createSerializable
     : makeShareableCloneOnUIRecursiveLEGACY
 ) as typeof makeShareableCloneOnUIRecursiveLEGACY;

package/src/memory/synchronizableUnpacker.native.ts

@@ -6,16 +6,16 @@ import { type Synchronizable, type SynchronizableRef } from './types';
 export function __installUnpacker() {
   // TODO: Add cache for synchronizables.
   const serializer =
-    !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE
-      ? (value: unknown, _: unknown) => createSerializable(value)
-      : globalThis._createSerializable;
+    !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE_ENABLED
+      ? createSerializable
+      : (value: unknown) => globalThis.__serializer(value);
 
   function synchronizableUnpacker<TValue>(
     synchronizableRef: SynchronizableRef<TValue>
   ): Synchronizable<TValue> {
     const synchronizable =
       synchronizableRef as unknown as Synchronizable<TValue>;
-    const proxy = globalThis.__workletsModuleProxy!;
+    const proxy = globalThis.__workletsModuleProxy;
 
     synchronizable.__synchronizableRef = true;
     synchronizable.getDirty = () => {
@@ -34,19 +34,13 @@ export function __installUnpacker() {
         const prev = synchronizable.getBlocking();
         newValue = func(prev);
 
-        proxy.synchronizableSetBlocking(
-          synchronizable,
-          serializer(newValue, undefined)
-        );
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue));
 
         synchronizable.unlock();
       } else {
         const value = valueOrFunction;
         newValue = value;
-        proxy.synchronizableSetBlocking(
-          synchronizable,
-          serializer(newValue, undefined)
-        );
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue));
       }
     };
     synchronizable.lock = () => {

package/src/platformChecker.ts

@@ -3,6 +3,7 @@
 import { Platform } from 'react-native';
 
 export const IS_JEST: boolean = !!process.env.JEST_WORKER_ID;
-export const IS_WEB: boolean = Platform.OS === 'web';
-export const IS_WINDOWS: boolean = Platform.OS === 'windows';
+export const IS_WEB: boolean = /* @__PURE__ */ (() => Platform.OS === 'web')();
+export const IS_WINDOWS: boolean = /* @__PURE__ */ (() =>
+  Platform.OS === 'windows')();
 export const SHOULD_BE_USE_WEB: boolean = IS_JEST || IS_WEB || IS_WINDOWS;

package/src/privateGlobals.d.ts

@@ -5,6 +5,7 @@
 import type { callGuardDEV } from './callGuard';
 import type { reportFatalRemoteError } from './debug/errors';
 import type { CustomSerializableUnpacker } from './memory/customSerializableUnpacker';
+import type { makeShareableCloneOnUIRecursive } from './memory/serializable';
 import type { SynchronizableUnpacker } from './memory/synchronizableUnpacker';
 import type { CustomSerializationRegistry } from './memory/types';
 import type { Queue } from './runLoop/workletRuntime/taskQueue';
@@ -17,8 +18,8 @@ declare global {
     Record<string, unknown>;
 
   var _toString: (value: unknown) => string;
-  var __workletsModuleProxy: WorkletsModuleProxy | undefined;
-  var _WORKLETS_BUNDLE_MODE: boolean | undefined;
+  var __workletsModuleProxy: WorkletsModuleProxy;
+  var _WORKLETS_BUNDLE_MODE_ENABLED: boolean | undefined;
   var _WORKLETS_VERSION_CPP: string | undefined;
   var _WORKLETS_VERSION_JS: string | undefined;
   var _createSerializable: <T>(
@@ -54,6 +55,8 @@ declare global {
   var _createSerializableSynchronizable: (
     value: object
   ) => FlatShareableRef<object>;
+  /** Only outside of Bundle Mode on Worklet Runtimes. */
+  var __serializer: typeof makeShareableCloneOnUIRecursive;
   var __callMicrotasks: () => void;
   var _scheduleHostFunctionOnJS: (fun: (...args: A) => R, args?: A) => void;
   var _scheduleRemoteFunctionOnJS: (fun: (...args: A) => R, args?: A) => void;
@@ -81,6 +84,8 @@ declare global {
   var __hasNativeState: (value: object) => boolean;
   /** Only in Debug builds. */
   var __isHostObject: (value: object) => boolean;
+  /** Only in Bundle Mode on Worklet Runtimes. */
+  var TurboModules: Map<string, unknown>;
   interface NodeRequire {
     resolveWeak(id: string): number;
     getModules(): Map<number, unknown>;

package/src/runtimeKind.ts

@@ -29,6 +29,53 @@ export function getRuntimeKind(): RuntimeKind {
   return globalThis.__RUNTIME_KIND;
 }
 
+/**
+ * Checks if the current runtime is the [React Native
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds/#rn-runtime).
+ *
+ * @returns `true` if the current runtime is the React Native Runtime, `false`
+ *   otherwise.
+ */
+export function isRNRuntime(): boolean {
+  'worklet';
+  return globalThis.__RUNTIME_KIND === 1;
+}
+
+/**
+ * Checks if the current runtime is a [Worklet
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds/#worklet-runtime).
+ *
+ * @returns `true` if the current runtime is a Worklet Runtime, `false`
+ *   otherwise.
+ */
+export function isWorkletRuntime(): boolean {
+  'worklet';
+  return globalThis.__RUNTIME_KIND !== 1;
+}
+
+/**
+ * Checks if the current runtime is the [UI
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds/#ui-runtime).
+ *
+ * @returns `true` if the current runtime is the UI Runtime, `false` otherwise.
+ */
+export function isUIRuntime(): boolean {
+  'worklet';
+  return globalThis.__RUNTIME_KIND === 2;
+}
+
+/**
+ * Checks if the current runtime is a [Worker
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds/#worker-runtime).
+ *
+ * @returns `true` if the current runtime is a Worker Runtime, `false`
+ *   otherwise.
+ */
+export function isWorkerRuntime(): boolean {
+  'worklet';
+  return globalThis.__RUNTIME_KIND === 3;
+}
+
 if (globalThis.__RUNTIME_KIND === undefined) {
   // In Jest environments eager imports make this file to evaluate before
   // `initializers.ts` file, therefore we have to set the RuntimeKind here,

package/src/runtimes.native.ts

@@ -5,6 +5,7 @@ import { registerWorkletsError, WorkletsError } from './debug/WorkletsError';
 import {
   getMemorySafeCapturableConsole,
   setupConsole,
+  setupSerializer,
 } from './initializers/initializers';
 import {
   createSerializable,
@@ -91,6 +92,7 @@ export function createWorkletRuntime(
     createSerializable(() => {
       'worklet';
       setupCallGuard();
+      setupSerializer();
       registerWorkletsError();
       setupConsole(runtimeBoundCapturableConsole);
       if (enableEventLoop) {
@@ -121,8 +123,8 @@ export function createWorkletRuntime(
  *   or another [Worker
  *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds#worker-runtime),
  *   unless the [Bundle
- *   Mode](https://docs.swmansion.com/react-native-worklets/docs/experimental/bundleMode)
- *   is enabled.
+ *   Mode](https://docs.swmansion.com/react-native-worklets/docs/bundleMode/) is
+ *   enabled.
  *
  * @param workletRuntime - The runtime to schedule the worklet on.
  * @param worklet - The worklet to schedule.
@@ -196,3 +198,42 @@ export function runOnRuntime<Args extends unknown[], ReturnValue>(
 type WorkletRuntimeConfigInternal = WorkletRuntimeConfig & {
   initializer?: WorkletFunction<[], void>;
 };
+
+/**
+ * Lets you run a function synchronously on a [Worker
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds#worker-runtime).
+ *
+ * - This function cannot be called from the [UI
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds#ui-runtime).
+ *   or another [Worker
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds#worker-runtime),
+ *   unless the [Bundle
+ *   Mode](https://docs.swmansion.com/react-native-worklets/docs/bundleMode/) is
+ *   enabled.
+ *
+ * @param workletRuntime - The runtime to run the worklet on.
+ * @param worklet - The worklet to run.
+ * @param args - The arguments to pass to the worklet.
+ * @returns The return value of the worklet.
+ */
+export function runOnRuntimeSync<Args extends unknown[], ReturnValue>(
+  workletRuntime: WorkletRuntime,
+  worklet: (...args: Args) => ReturnValue,
+  ...args: Args
+): ReturnValue {
+  'worklet';
+  if (__DEV__ && !isWorkletFunction(worklet)) {
+    throw new WorkletsError(
+      'The function passed to `runOnRuntimeSync` is not a worklet.'
+    );
+  }
+
+  return WorkletsModule.runOnRuntimeSync(
+    workletRuntime,
+    createSerializable(() => {
+      'worklet';
+      const result = worklet(...args);
+      return makeShareableCloneOnUIRecursive(result);
+    })
+  );
+}