@felipe-software/react-native-gpui 0.0.0-stage → 1.0.1

package/dist/reanimated/worklet-runtime.d.ts

@@ -0,0 +1,466 @@
+type WorkletBuiltinName = string;
+export type ValueSpec = {
+    kind: 'sv';
+    id: number;
+} | {
+    kind: 'svObject';
+    id: number;
+} | {
+    kind: 'svDetached';
+    value: unknown;
+} | {
+    kind: 'animation';
+    type: string;
+    args: ValueSpec[];
+} | {
+    kind: 'plain';
+    value: unknown;
+} | {
+    kind: 'builtin';
+    name: WorkletBuiltinName;
+} | {
+    kind: 'fn';
+    code: string;
+    closureSpec: ClosureSpec;
+    hash: number;
+    closureId: number;
+} | {
+    kind: 'initializer';
+    init: WorkletFunctionSpec;
+} | {
+    kind: 'animatedRef';
+    viewTag: number;
+} | {
+    kind: 'animatedRefSlot';
+    slotId: number;
+} | {
+    kind: 'jsCallback';
+    id: number;
+} | {
+    kind: 'undef';
+} | {
+    kind: 'array';
+    items: ValueSpec[];
+} | {
+    kind: 'object';
+    entries: Array<[string, ValueSpec]>;
+} | {
+    kind: 'shareableRef';
+    id: number;
+    snapshot: Array<[string, ValueSpec]>;
+};
+export type ClosureSpec = Record<string, ValueSpec>;
+type WorkletFunctionSpec = Extract<ValueSpec, {
+    kind: 'fn';
+}>;
+export declare function markWorkletBuiltin<T extends (...args: never[]) => unknown>(name: string, fn: T): T;
+/**
+ * Register a worklet builtin by name. The integrator populates this from the
+ * UI-side upstream reanimated module so that closures captured on the React side
+ * (which serialize builtins as {kind:'builtin', name}) resolve to the real UI
+ * implementation on deserialization. See bindBuiltin's special cases.
+ *
+ * The value is usually a function (withSpring, scrollTo, …) but may be a namespace
+ * object exposed to worklet bodies by name (e.g. `Easing`), so the registry holds
+ * `unknown`. Functions also get the hidden name brand (for outbound serialization);
+ * non-functions just land in the registry for by-name resolution.
+ */
+export declare function registerWorkletBuiltin(name: string, value: unknown): void;
+export interface WorkletDispatchOptions {
+    awaitReply?: boolean;
+    eventTimestamp?: number;
+}
+export type WorkletMessage = {
+    type: 'runWorklet';
+    runId: number;
+    code: string;
+    hash: number;
+    closureId: number;
+    closureSpec: ClosureSpec;
+    argsSpec: ValueSpec[];
+    awaitReply: boolean;
+    eventTimestamp?: number;
+} | {
+    type: 'workletReply';
+    runId: number;
+    ok: boolean;
+    returnValueSpec?: ValueSpec;
+    error?: string;
+} | {
+    type: 'workletDone';
+    runId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'svUpdate';
+    svId: number;
+    value: number;
+} | {
+    type: 'svUpdateBatch';
+    updates: Array<{
+        svId: number;
+        value: number;
+    }>;
+    objectUpdates?: Array<{
+        svId: number;
+        value: unknown;
+    }>;
+} | {
+    type: 'svAlloc';
+    svId: number;
+    initial: number;
+    bool?: boolean;
+} | {
+    type: 'svObjectAlloc';
+    svId: number;
+    initial: unknown;
+} | {
+    type: 'svFree';
+    svId: number;
+} | {
+    type: 'runJSCallback';
+    callbackId: number;
+    argsSpec: ValueSpec[];
+};
+export interface WorkletChannel {
+    send(msg: WorkletMessage): void;
+    hasPeer(): boolean;
+}
+export type WorkletRuntimeRole = 'react' | 'ui';
+export declare class WorkletRuntime {
+    private channel;
+    private buffer;
+    private floats;
+    private capacity;
+    private listeners;
+    private lastSlotListenerValue;
+    private freeSlots;
+    private freedSet;
+    private freeObjectSlots;
+    private freedObjectSet;
+    private svProxyCache;
+    private svObjectProxyCache;
+    private boolSlots;
+    private nextId;
+    private nextObjectId;
+    private idStride;
+    private role;
+    private statPrimitiveAllocs;
+    private statObjectAllocs;
+    private statReusedAllocs;
+    private statFrees;
+    private exhaustionLoggedAt;
+    private exhaustionSuppressed;
+    private runIdCounter;
+    private pending;
+    private workletCache;
+    private materializedClosureCache;
+    private remoteWorkletCache;
+    private shareableCache;
+    private serializedWorklets;
+    private nextSerializedClosureId;
+    private jsCallbacks;
+    private jsCallbackByFn;
+    private nextJsCallbackId;
+    private animatedRefSlots;
+    private statRunJSCallbackSent;
+    private statRunJSCallbackReceived;
+    private statRunJSCallbackMissing;
+    private pendingRunWorklets;
+    private statRunWorkletSent;
+    private statRunWorkletDone;
+    private statRunWorkletFailed;
+    private statClosureCacheHits;
+    private statClosureCacheMisses;
+    private pendingPeerUpdates;
+    private peerFlushScheduled;
+    private statWriteRequests;
+    private statBatchesSent;
+    private objectSlots;
+    private objectListeners;
+    private pendingObjectUpdates;
+    constructor(opts: {
+        channel: WorkletChannel;
+        buffer: ArrayBuffer;
+        role: WorkletRuntimeRole;
+    });
+    /**
+     * Inbound channel entry point. The channel adapter calls this with each
+     * decoded message. Public so the adapter (worklet-channel.ts) can wire it.
+     */
+    onMessage(msg: WorkletMessage): void;
+    /**
+     * Allocate a slot, write the initial value, and announce to the peer.
+     * Returns the slot id. Slots 0..3 are reserved (header).
+     */
+    allocSharedValueSlot(initial: number, isBool?: boolean): number;
+    /**
+     * Reuse a reclaimed slot id if one is available, else advance the matching
+     * counter. Primitive and object ids live in DISJOINT ranges with their own
+     * counters + free-lists (see OBJECT_ID_BASE): primitive ids index the shared
+     * Float64 array so they are capacity-bounded; object ids are JS-Map-backed so
+     * their range is effectively unbounded. A freed id is fully reset by
+     * releaseSlotState() before it returns to its pool.
+     */
+    private allocSlotId;
+    /**
+     * Throttled exhaustion logging. A re-render storm can hit the exhausted
+     * allocator hundreds of thousands of times in a burst; building an Error+stack
+     * and console.error-ing each time is itself enough to OOM/crash the runtime.
+     * Throttle to one log per window with a suppressed-count.
+     */
+    private logExhaustion;
+    /** true if `id` belongs to the disjoint object-slot id range. */
+    private isObjectId;
+    /**
+     * Clear every per-id structure for `id` and return the cell to zero. Shared by
+     * freeSlot() (owner side) and the inbound 'svFree' handler (peer side); both
+     * need the mirror dropped, only the owner recycles.
+     */
+    private releaseSlotState;
+    /**
+     * Reclaim a SharedValue slot whose JS wrapper was garbage-collected. Mirrors
+     * reanimated's native Shareable lifetime: once the JS Mutable is collected
+     * nothing can reference the value (live mappers / useAnimatedStyle deps keep the
+     * wrapper alive), so the slot is safe to recycle. Idempotent. Owner-only — a
+     * runtime only frees ids it allocates (even=react / odd=ui); the parity guard
+     * keeps a stray call from poisoning the peer's id space.
+     */
+    freeSlot(id: number): void;
+    readSlot(id: number): number;
+    /**
+     * Write a value to a slot, fire local listeners, and notify the peer.
+     * skipNotify=true is used when a write came in via inbound svUpdate to avoid
+     * bouncing it back. peer notifications coalesce per microtask — see
+     * `enqueuePeerUpdate`.
+     */
+    writeSlot(id: number, value: unknown, skipNotify?: boolean): boolean;
+    /**
+     * Used by createShareable's local-write echo: updates the cell and notifies the
+     * peer, but skips fireLocal. Required because the local SharedValue's listeners
+     * already fired the upstream fan-out — we don't want subscribeSlot listeners to
+     * fire again and recurse back into upstream's `_value` setter.
+     */
+    syncToPeer(id: number, value: unknown): boolean;
+    /**
+     * Queue an svUpdate for the peer. Within a single JS turn, repeat writes to the
+     * same slot collapse to last-write-wins. Flush happens at microtask boundary as
+     * a single `svUpdateBatch` message.
+     */
+    private enqueuePeerUpdate;
+    /**
+     * Single microtask schedules both primitive and object pending updates so a
+     * mixed-write turn ships at most one combined batch message per microtask (not
+     * two — one per kind). Both sides decode `svUpdateBatch` with optional
+     * `objectUpdates` for backward compat.
+     */
+    private scheduleUnifiedFlush;
+    private flushPendingPeerUpdates;
+    /**
+     * Force-flush any pending svUpdate batch to the peer. Used by tests and callers
+     * that need a synchronous handoff. Normal callers should rely on the microtask
+     * flush.
+     */
+    flushPeerUpdates(): void;
+    /**
+     * Allocate an object SV slot, seed the local Map, and announce to the peer.
+     * Returns the slot id. Object SVs use the same react-even / ui-odd lane
+     * convention as primitive SVs, but in a disjoint high range so object churn
+     * never consumes primitive cells.
+     */
+    allocObjectSharedValueSlot(initial: unknown): number;
+    readObjectSlot(id: number): unknown;
+    /**
+     * Write an object value to a slot, fire local listeners, and queue a peer
+     * notification. skipNotify avoids bouncing inbound updates back. Identity
+     * comparison would be too expensive (deep equality); we always notify on write
+     * — callers that want dedup should compare before calling.
+     */
+    writeObjectSlot(id: number, value: unknown, skipNotify?: boolean): boolean;
+    /**
+     * Object-slot equivalent of syncToPeer: updates the local Map and notifies the
+     * peer, but skips fireObjectLocal. Used by createShareable to avoid recursing
+     * into upstream listener fan-out.
+     */
+    syncObjectToPeer(id: number, value: unknown): boolean;
+    subscribeObjectSlot(id: number, fn: (value: unknown) => void): () => void;
+    private fireObjectLocal;
+    private enqueueObjectUpdate;
+    /**
+     * Snapshot of the per-runtime svUpdate coalescing counters. Read by tests for
+     * empirical perf validation. ratio (writeRequests / batchesSent) is the average
+     * coalescing factor — higher is better.
+     */
+    getPeerStats(reset?: boolean): {
+        writeRequests: number;
+        batchesSent: number;
+        pendingRunWorklets: number;
+        runWorkletsSent: number;
+        runWorkletsDone: number;
+        runWorkletsFailed: number;
+        closureCacheHits: number;
+        closureCacheMisses: number;
+    };
+    getSlotStats(): {
+        role: WorkletRuntimeRole;
+        capacity: number;
+        nextId: number;
+        freeSlots: number;
+        freedSlots: number;
+        nextObjectId: number;
+        freeObjectSlots: number;
+        freedObjectSlots: number;
+        primitiveAllocs: number;
+        objectAllocs: number;
+        reusedAllocs: number;
+        frees: number;
+        listenerSlots: number;
+        objectListenerSlots: number;
+        objectSlots: number;
+        pendingPrimitiveUpdates: number;
+        pendingObjectUpdates: number;
+        runJSCallbackSent: number;
+        runJSCallbackReceived: number;
+        runJSCallbackMissing: number;
+    };
+    subscribeSlot(id: number, fn: (value: number) => void): () => void;
+    private fireLocal;
+    private fireLocalIfChanged;
+    /**
+     * Ship a worklet to the peer for execution. The fn must have been processed by
+     * react-native-worklets/plugin so it carries __initData, __closure,
+     * __workletHash. Returns a Promise that resolves with the worklet's return value
+     * (when awaitReply is true) or undefined for fire-and-forget.
+     */
+    dispatchWorklet(fn: WorkletFn, args: unknown[], opts?: WorkletDispatchOptions): Promise<unknown>;
+    /** returns true if a SharedValue with this id has a slot in the shared array */
+    hasSlot(id: number): boolean;
+    /**
+     * Register a React-local callback so it can be invoked by UI-side worklets via
+     * runOnJS. Returns a wrapper function that:
+     *   - when called locally on react, just runs `fn` (so existing call sites that
+     *     don't ship to ui still work)
+     *   - when serialized via serializeValue, becomes a kind:'jsCallback' spec
+     *     carrying the registration id
+     *
+     * Memoizes per source fn so the same `runOnJS(fn)` call returns a stable wrapper
+     * across renders, keeping the id space small.
+     */
+    registerJSCallback<T extends (...args: unknown[]) => unknown>(fn: T): T;
+    private serializeValueForDispatch;
+    private serializeClosureForDispatch;
+    private serializeWorkletFunctionForDispatch;
+    private serializeRegisteredJSCallback;
+    /**
+     * Send a `runJSCallback` to the peer. UI-side bindRemoteJSCallback uses this
+     * when a deserialized callback wrapper is invoked.
+     */
+    postJSCallback(id: number, args: unknown[]): void;
+    private handleRunWorklet;
+    /**
+     * Re-hydrate a closure spec into an object the worklet body can read via
+     * `this.__closure`. SV refs become live SharedValue proxies bound to this
+     * runtime's slot view; nested fn specs become callable worklets that themselves
+     * dispatch back to the peer.
+     */
+    deserializeClosure(spec: ClosureSpec): Record<string, unknown>;
+    private getMaterializedClosure;
+    deserializeValue(spec: ValueSpec): unknown;
+    /**
+     * Bind a peer-side js-callback id to a local function that ships args back
+     * across the channel. Used on the UI runtime for runOnJS-tagged callbacks
+     * captured in the closure.
+     */
+    private bindRemoteJSCallback;
+    private bindBuiltin;
+    /**
+     * A SharedValue proxy on the receiving side: reads/writes route through the slot,
+     * and sets fan out to listeners. the proxy intentionally matches the same minimal
+     * shape the worklet body expects (.value getter/setter, .get(), .set()) so
+     * worklets authored against the real SharedValue API run unmodified here.
+     */
+    private bindSharedValueProxy;
+    /**
+     * Object-SV equivalent of bindSharedValueProxy. Reads return the local Map entry;
+     * writes update local + queue a peer notification. Identity isn't preserved across
+     * runtimes (the value is structured-cloned across the channel), but each side's Map
+     * holds the latest snapshot so .value always returns the most recent post-flush
+     * state.
+     */
+    private bindObjectSharedValueProxy;
+    private bindRemoteAnimatedRefSlot;
+    private serializeAnimatedRefForDispatch;
+    /**
+     * Bind a remote worklet that lived in the original closure as a callable.
+     * Calling it dispatches back through this runtime to the peer where the worklet's
+     * home runtime can execute it. This is how runOnJS-from-ui round-trips: the
+     * closure had a runOnJS-wrapped worklet, we call it, we ship it back across the
+     * channel.
+     */
+    private bindRemoteWorklet;
+}
+export interface SharedValueProxy {
+    _id: number;
+    _isReanimatedSharedValue: true;
+    value: number | boolean;
+    _value: number | boolean;
+    _animation: unknown;
+    get(): number | boolean;
+    set(v: number | boolean | (() => number | boolean)): void;
+    modify(modifier: (value: number | boolean) => number | boolean, forceUpdate?: boolean): void;
+    addListener(id: number, fn: (value: number) => void): void;
+    removeListener(id: number): void;
+    setDirty(dirty: boolean): void;
+}
+export interface ObjectSharedValueProxy {
+    _id: number;
+    _isReanimatedSharedValue: true;
+    value: unknown;
+    get(): unknown;
+    set(v: unknown): void;
+    modify(modifier: (value: unknown) => unknown, forceUpdate?: boolean): void;
+    addListener(id: number, fn: (value: unknown) => void): void;
+    removeListener(id: number): void;
+}
+export interface WorkletFn {
+    __closure?: Record<string, unknown>;
+    __workletHash?: number;
+    __initData?: {
+        code?: string;
+        location?: string;
+        sourceMap?: string;
+    };
+    (...args: unknown[]): unknown;
+}
+export declare const SHAREABLE_ID_KEY: unique symbol;
+export declare function serializeValue(value: unknown): ValueSpec;
+export declare function serializeClosure(closure: Record<string, unknown>): ClosureSpec;
+export declare function markObjectSV(target: object): void;
+export declare function evalWorkletCode(code: string): (...args: unknown[]) => unknown;
+export declare function createSharedValueBuffer(capacity?: number): ArrayBuffer;
+export declare function setActiveWorkletRuntime(rt: WorkletRuntime): void;
+export declare function getWorkletRuntime(): WorkletRuntime | null;
+export declare function isWorkletRuntimeReady(): boolean;
+/**
+ * Install (or return the existing) per-runtime WorkletRuntime singleton. Reads the
+ * shared-slot ArrayBuffer from `globalThis.__rngpui_svSlots` (installed by the rust
+ * host). The channel adapter (worklet-channel.ts) wires itself in via installChannel
+ * — this installs the runtime against a supplied channel. If no channel is supplied
+ * the caller is expected to follow up with installChannel(role, runtime).
+ *
+ * Returns null when the shared-slot buffer is absent (bun unit tests without the
+ * host bridge): callers then keep their local-only path.
+ */
+export declare function installWorkletRuntime(opts: {
+    role: WorkletRuntimeRole;
+    channel: WorkletChannel;
+    buffer?: ArrayBuffer;
+}): WorkletRuntime | null;
+export declare const __WORKLET_RUNTIME_INTERNALS: {
+    SAB_HEADER_FLOATS: number;
+    SAB_MAGIC: number;
+    DEFAULT_CAPACITY: number;
+    OBJECT_ID_BASE: number;
+    SHARED_SLOTS_KEY: string;
+};
+export {};

package/dist/reanimated/worklets.d.ts

@@ -0,0 +1,199 @@
+import './seam';
+import { type WorkletRuntime as WorkletRuntimeInstance } from './worklet-runtime';
+export interface WorkletFunction {
+    __workletHash?: number;
+    __initData?: {
+        code?: string;
+        location?: string;
+        sourceMap?: string;
+    };
+    __closure?: Record<string, unknown>;
+    (...args: unknown[]): unknown;
+}
+export interface SerializableRef {
+    __init?: () => unknown;
+}
+export interface Synchronizable<T> {
+    getBlocking(): T;
+    setBlocking(value: T): void;
+}
+export interface IWorkletsModule {
+    makeShareableClone: (value: unknown) => unknown;
+    scheduleOnUI: (fn: () => void) => void;
+    executeOnUIRuntimeSync: <T extends (...args: unknown[]) => unknown>(fn: T) => T;
+    createWorkletRuntime: (name: string, initializer?: () => void) => unknown;
+}
+export type MakeShareableClone = (value: unknown) => unknown;
+export type WorkletRuntime = unknown;
+export declare enum RuntimeKind {
+    ReactNative = 1,
+    UI = 2,
+    Worker = 3
+}
+export declare function getUIRuntimeHolder(): object;
+export declare function getUISchedulerHolder(): object;
+export declare const UIRuntimeId = 1;
+interface ShareableGuestBase<TValue = unknown> {
+    isHost: false;
+    __shareableRef: true;
+    getSync(): TValue;
+    setAsync(value: TValue | ((prev: TValue) => TValue)): void;
+    setSync(value: TValue | ((prev: TValue) => TValue)): void;
+    getAsync(): Promise<TValue>;
+    modify?(modifier: (value: TValue) => TValue, forceUpdate?: boolean): void;
+}
+interface ShareableConfig<H = unknown, G = unknown> {
+    hostDecorator?: (host: {
+        value: unknown;
+    }) => H;
+    guestDecorator?: (guest: ShareableGuestBase) => G;
+    initSynchronously?: boolean;
+}
+export declare function createShareable<TValue, THostDecorated = unknown, TGuestDecorated = unknown>(_hostRuntimeId: number, initial: TValue, config?: ShareableConfig<THostDecorated, TGuestDecorated>): unknown;
+/**
+ * In real reanimated, runOnJS schedules `fn` on the JS runtime. On rngpui the React
+ * runtime IS the JS runtime, so the wrapper executes locally — the worklet runtime
+ * registers the wrapper so that when it's captured in a closure that later ships to
+ * the UI runtime, the UI-side proxy routes call-args back here. Without the runtime,
+ * identity.
+ */
+export declare function runOnJS<T extends (...args: unknown[]) => unknown>(fn: T): T;
+/**
+ * `runOnUI(fn)` returns a wrapper that schedules workletized functions on the UI
+ * runtime; the UI runtime itself runs them on its local microtask path.
+ */
+export declare function runOnUI<T extends (...args: unknown[]) => unknown>(fn: T): T;
+/**
+ * `runOnRuntime(runtime, fn)` is the explicit cross-runtime escape hatch. rngpui has
+ * one peer runtime (the UI runtime); this routes through the worklet runtime when
+ * available so callers that genuinely need off-thread execution still get it.
+ * Degrades to local execution when no peer is wired.
+ */
+export declare function runOnRuntime<T extends (...args: unknown[]) => unknown>(_runtime: unknown, fn: T): T;
+/** Real signature: scheduleOnRN(fn, ...args) — calls fn(...args) async. */
+export declare function scheduleOnRN<T extends (...args: unknown[]) => unknown>(fn: T, ...args: unknown[]): void;
+/**
+ * `scheduleOnUI(fn, ...args)` — real iOS schedules `fn` on the UI runtime. rngpui's
+ * UI runtime is the second JavaScriptCore runtime, so workletized callbacks dispatch there
+ * from the React runtime. plain callbacks (not serializable worklets) and the no-
+ * bridge path keep the local microtask behavior.
+ */
+export declare function scheduleOnUI<T extends (...args: unknown[]) => unknown>(fn: T, ...args: unknown[]): void;
+/**
+ * Invoke a GestureDetector lifecycle callback respecting RN's worklet / non-worklet
+ * runtime split. a callback that IS a worklet runs on the UI runtime — the same
+ * runtime as the `useAnimatedStyle` mapper and the `withTiming`/`withSpring` driver —
+ * so a shared value's `valueSetter` animation lifecycle stays coherent.
+ *
+ * the `gesture` carries RNGH's `runOnJS` flag. a callback is dispatched to the UI
+ * runtime ONLY when it is a worklet AND the gesture did not opt into `runOnJS(true)`.
+ * a `runOnJS(true)` gesture (e.g. tamagui's press gesture, whose onBegin/onEnd are
+ * babel-workletized yet mutate React state) must run on the React runtime. a
+ * non-worklet callback — and every callback when the bridge is absent — runs
+ * synchronously on the React runtime as before.
+ */
+export declare function invokeGestureCallback(cb: ((...a: any[]) => unknown) | null | undefined, gesture: {
+    _runOnJS?: boolean;
+} | null | undefined, ...args: unknown[]): void;
+/**
+ * Sync UI execution is not feasible across runtimes (a blocking wait on the React
+ * runtime would freeze the bundle). Best-effort: identity. Upstream only uses
+ * executeOnUIRuntimeSync for init-time reads — apps that genuinely need synchronous
+ * UI-runtime semantics will see local/stale state, which is acceptable for those
+ * bootstrap reads.
+ */
+export declare function executeOnUIRuntimeSync<T extends (...args: unknown[]) => unknown>(fn: T): T;
+/** Sync runOnUI — runs LOCALLY on the React runtime. cross-runtime sync is impossible;
+ * upstream only uses this for init-time reads. set `this = fn` so the babel-emitted
+ * `this.__closure.X` and `this._recur` references inside worklet bodies resolve. */
+export declare function runOnUISync<T extends (...args: unknown[]) => unknown>(fn: T, ...args: unknown[]): unknown;
+export declare function runOnUIAsync<T extends (...args: unknown[]) => unknown>(fn: T, ...args: unknown[]): Promise<unknown>;
+export declare function makeShareable<T>(value: T): T;
+export declare function createSerializable(config: {
+    __init?: () => unknown;
+}): unknown;
+export declare function createSynchronizable<T>(initial: T): Synchronizable<T>;
+export declare const serializableMappingCache: WeakMap<object, unknown>;
+export declare function isWorkletFunction(fn: unknown): fn is WorkletFunction;
+export declare function createWorkletRuntime(name: string, _initializer?: () => void): unknown;
+export declare function callMicrotasks(): void;
+export declare const WorkletsModule: IWorkletsModule;
+export declare function useWorklet<T>(fn: T, _deps?: unknown[]): T;
+export declare function createWorklet<T extends (...args: unknown[]) => unknown>(fn: T): T;
+export declare class WorkletRuntimeClass {
+    name: string;
+    constructor(name?: string);
+    run<T>(fn: () => T): T;
+    destroy(): void;
+}
+export declare const Worklets: {
+    defaultContext: {
+        name: string;
+    };
+    createContext(name?: string): {
+        name: string;
+    };
+    createRuntime(name?: string, _initializer?: () => void): WorkletRuntimeClass;
+    createSharedValue<T>(initial: T): {
+        value: T;
+    };
+};
+export declare function currentContext(): {
+    name: string;
+};
+export declare const shareableMappingCache: WeakMap<object, unknown>;
+export declare function makeShareableCloneRecursive(value: unknown): unknown;
+export declare function makeShareableCloneOnUIRecursive(value: unknown): unknown;
+export declare function isShareableRef(_value: unknown): boolean;
+export declare const isSerializableRef: typeof isShareableRef;
+export declare function getRuntimeKind(): RuntimeKind;
+export declare function scheduleOnRuntime(_runtime: unknown, fn: WorkletFunction, ...args: unknown[]): void;
+export declare function isRNRuntime(): boolean;
+export declare function isUIRuntime(): boolean;
+export declare function isWorkerRuntime(): boolean;
+export declare function isWorkletRuntime(): boolean;
+export declare function runOnRuntimeAsync<T extends (...args: unknown[]) => unknown>(runtime: unknown, fn: T): T;
+export declare function runOnRuntimeSyncWithId<T extends (...args: unknown[]) => unknown>(_runtimeId: number, fn: T, ...args: unknown[]): unknown;
+export declare function scheduleOnRuntimeWithId(_runtimeId: number, fn: WorkletFunction, ...args: unknown[]): void;
+export declare function isShareable(value: unknown): boolean;
+export declare function isSynchronizable(value: unknown): boolean;
+export declare function registerCustomSerializable(klass: unknown, serializer: unknown): void;
+export declare function getStaticFeatureFlag(_name: string): boolean;
+export declare function getDynamicFeatureFlag(_name: string): boolean;
+export declare function setDynamicFeatureFlag(_name: string, _value: boolean): void;
+export declare function toggleSlowAnimationsOnUIRuntime(): boolean;
+declare const _default: {
+    runOnJS: typeof runOnJS;
+    runOnUI: typeof runOnUI;
+    runOnRuntime: typeof runOnRuntime;
+    scheduleOnRN: typeof scheduleOnRN;
+    scheduleOnUI: typeof scheduleOnUI;
+    makeShareable: typeof makeShareable;
+    createSerializable: typeof createSerializable;
+    createSynchronizable: typeof createSynchronizable;
+    serializableMappingCache: WeakMap<object, unknown>;
+    isWorkletFunction: typeof isWorkletFunction;
+    executeOnUIRuntimeSync: typeof executeOnUIRuntimeSync;
+    createWorkletRuntime: typeof createWorkletRuntime;
+    callMicrotasks: typeof callMicrotasks;
+    WorkletsModule: IWorkletsModule;
+    RuntimeKind: typeof RuntimeKind;
+    useWorklet: typeof useWorklet;
+    createWorklet: typeof createWorklet;
+    WorkletRuntime: typeof WorkletRuntimeClass;
+    Worklets: {
+        defaultContext: {
+            name: string;
+        };
+        createContext(name?: string): {
+            name: string;
+        };
+        createRuntime(name?: string, _initializer?: () => void): WorkletRuntimeClass;
+        createSharedValue<T>(initial: T): {
+            value: T;
+        };
+    };
+    currentContext: typeof currentContext;
+};
+export default _default;
+export type { WorkletRuntimeInstance };