peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/worklet-runtime.d.ts

@@ -0,0 +1,987 @@
+import '../profiler/animation-recording-loader.d.ts';
+import { NativeDynamicSynchronizableStorage, type SynchronizableArenaKey } from './native-dynamic-synchronizable.d.ts';
+import { type FocusedInputLayout, type KeyboardAnimationFrameSnapshot } from './native-ui-protocol.d.ts';
+import { type CSSShellHost, type NativeCSSEvent } from './reanimated-css-contract.d.ts';
+import { type ReanimatedAnimationKind, type SharedValuePlayback } from './reanimated-readiness.d.ts';
+import type { NativeRenderer } from '../../../../../src/config.ts';
+import type { SyncReplyBuffer } from './nativeSyncReplyContract.d.ts';
+import type { SootSimAnimationInfo } from '../../../peach-globals/src/index.d.ts';
+import type { ReanimatedAnimationProfile } from '../../../peach-globals/src/profilerContract.d.ts';
+export { CSS_EVENT_MASK, type CSSEventType, type NativeCSSEvent, } from './reanimated-css-contract.d.ts';
+import type { AnimatedDrivenStyleLease, AnimatedDrivenStyleRetirement } from '../engine/animated-driven-style.d.ts';
+import { SAB_COMPOSITOR_TASK_PENDING_INT32_INDEX, SAB_DEMAND_EPOCH_INT32_INDEX, SAB_TENANT_LIVE_FRAMES_INT32_INDEX, SAB_UI_FRAME_DEMAND_INT32_INDEX, SAB_UI_FRAME_DONE_INT32_INDEX, SAB_UI_FRAME_OFFERED_INT32_INDEX, SAB_UI_FRAME_TIME_FLOAT64_INDEX, createSharedValueSAB, createWorkletPeerEpoch, type WorkletPeerEpoch } from './worklet-sab.d.ts';
+export { SAB_COMPOSITOR_TASK_PENDING_INT32_INDEX, SAB_DEMAND_EPOCH_INT32_INDEX, SAB_TENANT_LIVE_FRAMES_INT32_INDEX, SAB_UI_FRAME_DEMAND_INT32_INDEX, SAB_UI_FRAME_DONE_INT32_INDEX, SAB_UI_FRAME_OFFERED_INT32_INDEX, SAB_UI_FRAME_TIME_FLOAT64_INDEX, createSharedValueSAB, createWorkletPeerEpoch, type WorkletPeerEpoch, };
+type WorkletBuiltinName = string;
+type WorkletClosure = Record<string, unknown> | unknown[];
+export interface WorkletViewOwner {
+    surfaceId: string;
+    generation: number;
+}
+export interface WorkletViewRef extends WorkletViewOwner {
+    viewTag: number;
+}
+export type ValueSpec = {
+    kind: 'sv';
+    id: number;
+    bool: boolean;
+    hostDecorator?: WorkletFunctionSpec;
+} | {
+    kind: 'svObject';
+    id: number;
+    hostDecorator?: WorkletFunctionSpec;
+} | {
+    kind: 'svDetached';
+    value: unknown;
+} | {
+    kind: 'synchronizable';
+    id: number;
+    lockId: number;
+    referenceId?: number;
+    boolean?: true;
+} | {
+    kind: 'synchronizableDynamic';
+    id: number;
+    arena: SynchronizableArenaKey;
+    offset: number;
+    referenceId?: number;
+    reanimatedDataHolder?: true;
+} | {
+    kind: 'plain';
+    value: unknown;
+} | {
+    kind: 'nativeValue';
+    value: NativeSerializableValueSpec;
+} | {
+    kind: 'builtin';
+    name: WorkletBuiltinName;
+} | {
+    kind: 'hostValue';
+    codec: string;
+    data: unknown;
+} | {
+    kind: 'fn';
+    reanimated2?: true;
+    code: string;
+    closureSpec: ClosureSpec;
+    closureIsArray?: boolean;
+    hash: number;
+    closureId: number;
+    animationInitializer?: ReanimatedAnimationKind;
+    animationFactory?: ReanimatedAnimationKind;
+    animationProfile?: ReanimatedAnimationProfile;
+} | {
+    kind: 'initializer';
+    init: WorkletFunctionSpec;
+    id?: number;
+} | {
+    kind: 'animatedRef';
+    target: WorkletViewRef;
+} | {
+    kind: 'animatedRefSlot';
+    slotId: number;
+} | {
+    kind: 'jsCallback';
+    id: number;
+} | {
+    kind: 'hostFunction';
+    id: number;
+} | {
+    kind: 'remoteFunction';
+    id: number;
+    name?: string;
+    origin?: 'worklets';
+} | {
+    kind: 'undef';
+} | {
+    kind: 'error';
+    name: string;
+    message: string;
+    stack?: string;
+} | {
+    kind: 'array';
+    items: ValueSpec[];
+} | {
+    kind: 'set';
+    items: ValueSpec[];
+} | {
+    kind: 'map';
+    entries: Array<[ValueSpec, ValueSpec]>;
+} | {
+    kind: 'object';
+    entries: Array<[string, ValueSpec]>;
+    animationProfile?: ReanimatedAnimationProfile;
+} | {
+    kind: 'shareableRef';
+    id: number;
+    snapshot: Array<[string, ValueSpec]>;
+};
+export type ClosureSpec = Record<string, ValueSpec>;
+type NativeSerializableValueSpec = Extract<ValueSpec, {
+    kind: 'error';
+}> | {
+    kind: 'plain';
+    value: boolean;
+} | {
+    kind: 'buffer';
+    buffer: ArrayBuffer;
+    view?: {
+        typeName: string;
+        byteOffset: number;
+        length: number;
+    };
+} | {
+    kind: 'regexp';
+    pattern: string;
+    flags: string;
+};
+export declare const nativeSerializableValues: WeakMap<object, NativeSerializableValueSpec>;
+export declare const nativeHostObjectRefs: WeakMap<object, object>;
+export declare const nativeRemoteFunctionRefs: WeakMap<object, {
+    callable: (...args: unknown[]) => unknown;
+    spec: Extract<ValueSpec, {
+        kind: 'remoteFunction';
+    }>;
+}>;
+export interface SynchronizableStore {
+    boolean?: boolean;
+    read(): number;
+    write(value: number): void;
+    getId(): number;
+    getLockId(): number;
+    getAccess(): Int32Array;
+    setBinding(id: number, lockId: number): void;
+}
+export interface SynchronizableHostObject {
+    getDirty(): number | boolean;
+    getBlocking(): number | boolean;
+    setDirty(value: number | boolean): void;
+    setBlocking(value: number | boolean): void;
+    lock(): void;
+    unlock(): void;
+}
+export declare const nativeShareableHostDecorators: WeakMap<object, WorkletFn>;
+export declare const nativeSynchronizableRefs: WeakMap<object, {
+    kind: 'fixed';
+    operations: SynchronizableHostObject;
+} | {
+    kind: 'dynamic';
+    reanimatedDataHolder: boolean;
+    storage: NativeDynamicSynchronizableStorage;
+    id: number;
+    share(): SynchronizableArenaKey;
+    operations: {
+        getDirty(): unknown;
+        getBlocking(): unknown;
+        setBlocking(value: unknown): void;
+        lock(): void;
+        unlock(): void;
+    };
+}>;
+export declare function createDynamicSynchronizableHostObject(initial: unknown, binding?: {
+    id: number;
+    storage: NativeDynamicSynchronizableStorage;
+    runtime: WorkletRuntime;
+}, reanimatedDataHolder?: boolean): {};
+export declare function unpackDynamicSynchronizable(ref: object): object & {
+    __synchronizableRef: boolean;
+    getDirty: () => unknown;
+    getBlocking: () => unknown;
+    setBlocking: (valueOrFunction: unknown) => void;
+    lock: () => void;
+    unlock: () => void;
+};
+export declare function isSynchronizableLike(value: unknown): value is SynchronizableHostObject;
+export declare function createSynchronizableHostObject(store: SynchronizableStore): SynchronizableHostObject;
+export declare function materializeNativeSerializableValue(spec: NativeSerializableValueSpec): unknown;
+export declare const materializedWorklets: WeakMap<object, number>;
+export declare function getWorkletHash(fn: WorkletFn): number | undefined;
+type WorkletFunctionSpec = Extract<ValueSpec, {
+    kind: 'fn';
+}>;
+type ReanimatedTraceEvent = {
+    type: string;
+    t: number;
+    id?: number;
+    value?: number | boolean | null;
+    skipNotify?: boolean;
+    timestamp?: number;
+    current?: number | boolean | null;
+    toValue?: number | null;
+    velocity?: number | null;
+    startValue?: number | null;
+    finished?: boolean;
+    forceUpdate?: boolean;
+    replayIndex?: number | null;
+    hostTimestamp?: number;
+    startTime?: number | null;
+};
+export declare function setReanimatedTraceEnabled(enabled: boolean, reset?: boolean, limit?: number): void;
+export declare function getReanimatedTraceSnapshot(reset?: boolean): ReanimatedTraceEvent[];
+export declare function isRunningPeerWorklet(): boolean;
+export declare function installWorkletFrameFinalizerScheduler(schedule: (callback: () => void) => void): void;
+export declare function claimUIRuntimeHostGlobals(): void;
+export declare function registerStaticWorkletBody(hash: number, body: (...args: never[]) => unknown): void;
+export declare function getStaticWorkletBody(hash: number): ((...args: unknown[]) => unknown) | undefined;
+export declare function markWorkletBuiltin<T extends object>(name: string, value: T): T;
+export declare function markWorkletHostFunction<T extends (...args: never[]) => void>(fn: T): T;
+export declare function isWorkletHostFunction(value: unknown): value is (...args: unknown[]) => void;
+export interface WorkletHostValueCodec<T extends object, D> {
+    pack(value: T): D;
+    unpack(data: D): T;
+    receive?(data: D): void;
+}
+export interface WorkletHostValueUpdate {
+    codec: string;
+    data: unknown;
+}
+export declare function registerWorkletHostValueCodec<T extends object, D>(name: string, codec: WorkletHostValueCodec<T, D>): void;
+export declare function markWorkletHostValue<T extends object>(target: T, codec: string): T;
+export interface WorkletDispatchOptions {
+    awaitReply?: boolean;
+    callerThreadId?: string;
+    eventTimestamp?: number;
+}
+export interface NamedWorkletRuntimeHandle {
+    toString(): string;
+    readonly name: string;
+    readonly runtimeId: number;
+}
+export interface NamedWorkletRuntimeOptions {
+    name: string;
+    initializer: WorkletFn;
+    initializerArgs: unknown[];
+    useDefaultQueue: boolean;
+}
+export declare const NAMED_RUNTIME_QUEUE_MISSING = "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the async queue is not set. Recreate the runtime with a valid async queue.";
+export interface NamedWorkletRuntimeDelegate {
+    create(options: NamedWorkletRuntimeOptions): NamedWorkletRuntimeHandle;
+    get(runtimeId: number): NamedWorkletRuntimeHandle | undefined;
+    schedule(handle: NamedWorkletRuntimeHandle, fn: WorkletFn, args: unknown[]): void;
+    runSync(handle: NamedWorkletRuntimeHandle, fn: WorkletFn, args: unknown[]): unknown;
+    destroy(handle: NamedWorkletRuntimeHandle): void;
+    dispose(): void;
+}
+export type AnimatedPropsWriteSlots = Record<string, {
+    timestamp: number;
+    version: number;
+}>;
+export type WorkletMessagePayload = ({
+    type: 'runWorklet';
+    reanimated2?: true;
+    runId: number;
+    code: string;
+    hash: number;
+    closureId: number;
+    closureSpec: ClosureSpec;
+    closureIsArray?: boolean;
+    argsSpec: ValueSpec[];
+    awaitReply: boolean;
+    eventTimestamp?: number;
+} & ({
+    sync: true;
+    callerThreadId: string;
+    syncReply?: SyncReplyBuffer;
+} | {
+    sync?: never;
+    callerThreadId?: string;
+    syncReply?: never;
+})) | {
+    type: 'workletReply';
+    runId: number;
+    ok: boolean;
+    returnValueSpec?: ValueSpec;
+    error?: string;
+    hostValueUpdates?: WorkletHostValueUpdate[];
+} | {
+    type: 'hostValueUpdates';
+    updates: WorkletHostValueUpdate[];
+} | {
+    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: ValueSpec;
+    }>;
+} | {
+    type: 'svAlloc';
+    svId: number;
+    initial: number;
+    bool?: boolean;
+} | {
+    type: 'svObjectAlloc';
+    svId: number;
+    initial: ValueSpec;
+} | {
+    type: 'svFree';
+    svId: number;
+} | {
+    type: 'svPlayback';
+    svId: number;
+    playback: SharedValuePlayback;
+} | {
+    type: 'runJSCallback';
+    callbackId: number;
+    argsSpec: ValueSpec[];
+} | {
+    type: 'cacheRelease';
+    closures?: Array<{
+        hash: number;
+        closureId: number;
+    }>;
+    shareables?: number[];
+    jsCallbacks?: number[];
+    synchronizables?: number[];
+} | {
+    type: 'frameCallbackRegister';
+    callbackId: number;
+    callback: WorkletFunctionSpec;
+    active: boolean;
+} | {
+    type: 'frameCallbackSetActive';
+    callbackId: number;
+    active: boolean;
+} | {
+    type: 'frameCallbackUnregister';
+    callbackId: number;
+} | {
+    type: 'eventHandlerRegister';
+    handlerId: number;
+    callback: WorkletFunctionSpec;
+    eventName: string;
+    viewTag: number;
+    ownerKey?: string;
+} | {
+    type: 'eventHandlerUnregister';
+    handlerId: number;
+    ownerKey?: string;
+} | {
+    type: 'eventHandlerDispatch';
+    handlerId: number;
+    ownerKey?: string;
+    event: Record<string, unknown>;
+} | {
+    type: 'keyboardHandlerRegister';
+    handlerId: number;
+    callback: WorkletFunctionSpec;
+} | {
+    type: 'keyboardHandlerUnregister';
+    handlerId: number;
+} | {
+    type: 'sensorHandlerRegister';
+    handlerId: number;
+    sensorType: number;
+    interval: number;
+    callback: WorkletFunctionSpec;
+} | {
+    type: 'sensorHandlerUnregister';
+    handlerId: number;
+} | {
+    type: 'layoutAnimationConfigureBatch';
+    items: Array<{
+        surfaceId: string;
+        generation: number;
+        viewTag: number;
+        animationType: number;
+        config: ValueSpec | null;
+        sharedTransitionTag?: string;
+    }>;
+} | {
+    type: 'layoutAnimationShouldExit';
+    surfaceId: string;
+    generation: number;
+    viewTag: number;
+    shouldAnimate: boolean;
+} | {
+    type: 'layoutAnimationMarkRemovable';
+    surfaceId: string;
+    generation: number;
+    viewTag: number;
+} | {
+    type: 'layoutAnimationUnmarkRemovable';
+    surfaceId: string;
+    generation: number;
+    viewTag: number;
+} | {
+    type: 'cssViewStyleSet';
+    target: WorkletViewRef;
+    style: ValueSpec | null;
+} | {
+    type: 'cssKeyframesRegister';
+    animationName: string;
+    compoundComponentName: string;
+    config: ValueSpec;
+} | {
+    type: 'cssKeyframesUnregister';
+    animationName: string;
+    compoundComponentName: string;
+} | {
+    type: 'cssAnimationsApply';
+    target: WorkletViewRef;
+    compoundComponentName: string;
+    updates: ValueSpec;
+} | {
+    type: 'cssAnimationsUnregister';
+    target: WorkletViewRef;
+} | {
+    type: 'cssViewRemove';
+    target: WorkletViewRef;
+    removalId: number;
+} | {
+    type: 'cssViewRemoveAck';
+    target: WorkletViewRef;
+    removalId: number;
+} | {
+    type: 'cssTransitionRun';
+    target: WorkletViewRef;
+    config: ValueSpec;
+    eventMask?: number;
+} | {
+    type: 'cssTransitionRegister' | 'cssTransitionUpdate';
+    target: WorkletViewRef;
+    config: ValueSpec;
+} | {
+    type: 'cssTransitionUnregister';
+    target: WorkletViewRef;
+} | {
+    type: 'cssEvents';
+    events: NativeCSSEvent[];
+} | {
+    type: 'applyAnimatedProps';
+    ops: Array<{
+        target: WorkletViewRef;
+        updates: Record<string, unknown>;
+        timestamp: number;
+        writeVersion: number;
+        lease?: AnimatedDrivenStyleLease;
+    }>;
+} | {
+    type: 'retireAnimatedDrivenStyle';
+    target: WorkletViewRef;
+    retirement: AnimatedDrivenStyleRetirement;
+} | {
+    type: 'animatedSlotBinding';
+    target: WorkletViewRef;
+    slotVersion: number;
+    writeSlots: AnimatedPropsWriteSlots;
+    template: Record<string, unknown>;
+    snapshotTemplate: Record<string, unknown>;
+    restoreSource?: boolean;
+} | {
+    type: 'animatedSlotUnbind';
+    target: WorkletViewRef;
+    finalUpdates: Record<string, unknown>;
+    retirementId?: number;
+} | {
+    type: 'animatedSlotUnbound';
+    retirementId: number;
+    target: WorkletViewRef;
+    retirement?: AnimatedDrivenStyleRetirement;
+} | {
+    type: 'animatedSlotFence';
+    retirementId: number;
+} | {
+    type: 'animatedSlotFenced';
+    retirementId: number;
+} | {
+    type: 'nativeAnimatedDriveEnd';
+    sourceSurfaceId: string;
+    sourceGeneration: number;
+    driveId: number;
+    lifecycleId: number;
+    finished: boolean;
+    finalValue: number;
+} | {
+    type: 'nativeAnimGraphDriveEnd';
+    sourceSurfaceId: string;
+    sourceGeneration: number;
+    driveId: number;
+    lifecycleId: number;
+    finished: boolean;
+    values: Array<{
+        valueId: number;
+        value: number;
+    }>;
+} | {
+    type: 'nativeAnimGraphDriveSlots';
+    sourceSurfaceId: string;
+    sourceGeneration: number;
+    driveId: number;
+    lifecycleId: number;
+    values: Array<{
+        valueId: number;
+        slot: number;
+    }>;
+} | {
+    type: 'nativeAnimGraphDriveUpdate';
+    sourceSurfaceId: string;
+    sourceGeneration: number;
+    driveId: number;
+    lifecycleId: number;
+    values: Array<{
+        valueId: number;
+        value: number;
+    }>;
+} | {
+    type: 'peerDispose';
+} | {
+    type: 'peerHello';
+};
+type WithPeerEpoch<T> = T extends unknown ? T & {
+    peerEpoch: WorkletPeerEpoch;
+    nativeRenderer?: NativeRenderer;
+} : never;
+export type WorkletMessage = WithPeerEpoch<WorkletMessagePayload>;
+export interface WorkletChannel {
+    send(msg: WorkletMessage): void;
+    bindReceive(handler: (msg: WorkletMessage) => void): void;
+    hasPeer(): boolean;
+}
+export declare class WorkletRuntime {
+    private uiSyncReply;
+    private namedRuntimeDelegate;
+    private readonly bundleModuleGraph;
+    private disposed;
+    private channel;
+    private sab;
+    private floats;
+    private floatBits;
+    private demandEpochInt32;
+    private capacity;
+    private listeners;
+    private lastSlotListenerValue;
+    private freeSlots;
+    private freedSet;
+    private freeObjectSlots;
+    private freedObjectSet;
+    private ownedSlotIds;
+    private localPlayback;
+    private peerPlayback;
+    private svProxyCache;
+    private svObjectProxyCache;
+    private synchronizableProxyCache;
+    private dynamicSynchronizableProxyCache;
+    private synchronizableReferences;
+    private peerSynchronizableHolders;
+    private pendingSynchronizableReleases;
+    private synchronizableReleaseFinalizer;
+    private animationHandles;
+    private nextAnimationHandle;
+    private boolSlots;
+    private nextId;
+    private nextObjectId;
+    private idStride;
+    private role;
+    private readonly ownPeerEpoch;
+    private activePeerEpoch;
+    private retiredPeerEpoch;
+    private hasActivatedPeer;
+    private pendingInitialPeerMessages;
+    private peerOwnedSlotIds;
+    private peerOwnedFrameCallbackIds;
+    private peerOwnedEventHandlerKeys;
+    private peerOwnedSensorHandlerIds;
+    private peerOwnedKeyboardHandlerIds;
+    private peerRetirementListeners;
+    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 pendingClosureReleases;
+    private pendingShareableReleases;
+    private outboundClosures;
+    private closureReleaseFinalizer;
+    private shareableReleaseFinalizer;
+    private registeredShareableIds;
+    private jsCallbacks;
+    private jsCallbackByFn;
+    private nextJsCallbackId;
+    private pendingJSCallbackReleases;
+    private peerCallbackHolders;
+    private retainedSpecHolders;
+    private specReferenceHolders;
+    private peerCallbackReleaseFinalizer;
+    private animatedRefSlots;
+    private animatedRefEntries;
+    private animatedRefReleaseFinalizer;
+    private statRunJSCallbackSent;
+    private statRunJSCallbackReceived;
+    private statRunJSCallbackMissing;
+    private pendingRunWorklets;
+    private runWorkletsIdleSince;
+    private statRunWorkletSent;
+    private statRunWorkletDone;
+    private statRunWorkletFailed;
+    private statClosureCacheHits;
+    private statClosureCacheMisses;
+    private nextFrameCallbackId;
+    private frameCallbacks;
+    private activeFrameCallbacks;
+    private remoteFrameCallbackIds;
+    private previousFrameTimestamp;
+    private frameCallbackSchedule;
+    private frameCallbackRunToken;
+    private nativeFrames;
+    private cssRuntime;
+    private cssRuntimeLoadPromise;
+    private pendingCSSMessages;
+    private cssShellHost;
+    private cssFrameCallbackId;
+    private nextCSSViewRemovalId;
+    private pendingCSSViewRemovals;
+    private cssEventHandler;
+    private nextEventHandlerId;
+    private eventHandlers;
+    private localEventHandlerOwnerKeys;
+    private remoteEventHandlerIds;
+    private remoteEventHandlerOwnerKeys;
+    private nextKeyboardHandlerId;
+    private keyboardHandlers;
+    private remoteKeyboardHandlerIds;
+    private nextSensorHandlerId;
+    private sensorHandlers;
+    private remoteSensorHandlerIds;
+    private keyboardHandlerTransition;
+    private keyboardEventTransition;
+    private keyboardEventTarget;
+    private pendingPeerUpdates;
+    private peerFlushScheduled;
+    private statWriteRequests;
+    private statBatchesSent;
+    private objectSlots;
+    private objectListeners;
+    private pendingObjectUpdates;
+    private pendingHostValueUpdates;
+    private readonly nativeMicrotasks;
+    constructor(opts: {
+        channel: WorkletChannel;
+        sab: SharedArrayBuffer;
+        role: 'tenant' | 'shell' | 'host';
+        peerEpoch?: WorkletPeerEpoch;
+        bundleModuleGraph?: boolean;
+    });
+    readonly receiveMessage: (msg: WorkletMessage) => void;
+    private sendPeer;
+    dispose(): void;
+    installNamedRuntimeDelegate(delegate: NamedWorkletRuntimeDelegate): void;
+    private requireNamedRuntimeDelegate;
+    createNamedWorkletRuntime(options: NamedWorkletRuntimeOptions): NamedWorkletRuntimeHandle;
+    getNamedWorkletRuntime(runtimeId: number): NamedWorkletRuntimeHandle | undefined;
+    scheduleOnNamedRuntime(handle: NamedWorkletRuntimeHandle, fn: WorkletFn, args: unknown[]): void;
+    runOnNamedRuntimeSync(handle: NamedWorkletRuntimeHandle, fn: WorkletFn, args: unknown[]): unknown;
+    destroyNamedWorkletRuntime(handle: NamedWorkletRuntimeHandle): void;
+    allocSharedValueSlot(initial: number, isBool?: boolean): number;
+    private allocSlotId;
+    private logExhaustion;
+    private isObjectId;
+    private releaseSlotState;
+    freeSlot(id: number): void;
+    readSlot(id: number): number;
+    readDecodedSlot(id: number): number | null | undefined;
+    private storeSlot;
+    writeSlot(id: number, value: unknown, skipNotify?: boolean): boolean;
+    writeSlotsSeqlocked(versionSlot: number, writes: readonly number[]): void;
+    readDemandEpoch(): number;
+    waitForSlotDemand(expected: number): PromiseLike<unknown> | null;
+    private bumpDemandEpoch;
+    syncToPeer(id: number, value: unknown): boolean;
+    private enqueuePeerUpdate;
+    private scheduleUnifiedFlush;
+    queueHostValueUpdate(update: WorkletHostValueUpdate): void;
+    private takeHostValueUpdates;
+    private applyHostValueUpdates;
+    private flushPendingPeerUpdates;
+    private queueClosureRelease;
+    private queueShareableRelease;
+    private registerShareableRelease;
+    flushPeerUpdates(): void;
+    allocObjectSharedValueSlot(initial: unknown): number;
+    readObjectSlot(id: number): unknown;
+    writeObjectSlot(id: number, value: unknown, skipNotify?: boolean): boolean;
+    syncObjectToPeer(id: number, value: unknown): boolean;
+    subscribeObjectSlot(id: number, fn: (value: unknown) => void): () => void;
+    private fireObjectLocal;
+    private enqueueObjectUpdate;
+    getPeerStats(reset?: boolean): {
+        replayedFrameCallbacks: number;
+        nativeFrameFirstTimestampMs: number | null;
+        writeRequests: number;
+        batchesSent: number;
+        pendingRunWorklets: number;
+        runWorkletsIdleMs: number | null;
+        runWorkletsSent: number;
+        runWorkletsDone: number;
+        runWorkletsFailed: number;
+        closureCacheHits: number;
+        closureCacheMisses: number;
+    };
+    getSlotStats(): {
+        role: 'tenant' | 'shell' | 'host';
+        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;
+        materializedClosures: number;
+        remoteWorklets: number;
+        shareables: number;
+        eventHandlers: number;
+        hasPeer: boolean;
+        eventHandlerNames: Array<[string, number]>;
+        remoteEventHandlers: number;
+        keyboardHandlers: number;
+        sensorHandlers: number;
+        frameCallbacks: number;
+        activeFrameCallbacks: number;
+        pendingReplies: number;
+        jsCallbacks: number;
+        peerCallbackHolders: number;
+        animatedRefSlots: number;
+        animatedBridgeListeners: number;
+        cssKeyframes: number;
+        cssViews: number;
+        cssActiveViews: number;
+        cssNativeViewTags: number[];
+        cssPendingViewRemovals: number;
+    };
+    countDeadPeerCallbackHolders(): number;
+    getPeerEpoch(): WorkletPeerEpoch | null;
+    subscribeSlot(id: number, fn: (value: number | null | undefined) => void): () => void;
+    private fireLocal;
+    private fireLocalIfChanged;
+    reconcileChangedSlots(): boolean;
+    dispatchWorklet(fn: WorkletFn, args: unknown[], opts?: WorkletDispatchOptions): Promise<unknown>;
+    dispatchWorkletSync(fn: WorkletFn, args: unknown[], readReply?: () => Extract<WorkletMessage, {
+        type: 'workletReply';
+    }>): unknown;
+    registerFrameCallback(callback: WorkletFn, active?: boolean): number;
+    setFrameCallbackActive(callbackId: number, active: boolean): void;
+    unregisterFrameCallback(callbackId: number): void;
+    registerEventHandler(callback: WorkletFn, eventName: string, viewTag: number, ownerKey?: string): number;
+    unregisterEventHandler(handlerId: number): void;
+    dispatchPeerEventHandler(handlerId: number, event: Record<string, unknown>): boolean;
+    private eventHandlerKey;
+    registerKeyboardHandler(callback: WorkletFn): number;
+    unregisterKeyboardHandler(handlerId: number): void;
+    registerSensorHandler(callback: WorkletFn, sensorType: number, interval: number): number;
+    unregisterSensorHandler(handlerId: number): void;
+    dispatchSensorHandlers(sensorType: number, data: Record<string, number>, eventTimestamp?: number): number;
+    private requireShellCSSPeer;
+    private ensureCSSRuntimeReady;
+    private ensureCSSRuntime;
+    private resolveCSSAnimationTimestamp;
+    private setCSSRuntimeActive;
+    private requireShellLayoutAnimationPeer;
+    configureLayoutAnimationBatch(batch: unknown[], resolveTarget: (viewTag: number, animationType: number) => {
+        surfaceId: string;
+        generation: number;
+    } | null): void;
+    bindPendingLayoutAnimations(surfaceId: string, generation: number, nodes: Array<{
+        viewTag: number;
+        nativeId?: string;
+    }>): Extract<WorkletMessage, {
+        type: 'layoutAnimationConfigureBatch';
+    }> | undefined;
+    setShouldAnimateLayoutExit(viewTag: number, shouldAnimate: boolean, target: {
+        surfaceId: string;
+        generation: number;
+    }): void;
+    markLayoutNodeRemovable(viewTag: number, target: {
+        surfaceId: string;
+        generation: number;
+    }): void;
+    unmarkLayoutNodeRemovable(viewTag: number, target: {
+        surfaceId: string;
+        generation: number;
+    }): void;
+    setCSSViewStyle(target: WorkletViewRef, style: unknown): void;
+    registerCSSKeyframes(animationName: string, compoundComponentName: string, config: unknown): void;
+    unregisterCSSKeyframes(animationName: string, compoundComponentName: string): void;
+    applyCSSAnimations(target: WorkletViewRef, compoundComponentName: string, updates: unknown): void;
+    unregisterCSSAnimations(target: WorkletViewRef): void;
+    removeCSSView(target: WorkletViewRef): void;
+    runCSSTransition(target: WorkletViewRef, config: unknown, eventMask?: number): void;
+    registerCSSTransition(target: WorkletViewRef, config: unknown): void;
+    updateCSSTransition(target: WorkletViewRef, config: unknown): void;
+    unregisterCSSTransition(target: WorkletViewRef): void;
+    setCSSEventHandler(handler: (events: NativeCSSEvent[]) => void): void;
+    dispatchCSSEvents(events: NativeCSSEvent[]): void;
+    dispatchKeyboardHandlers(frame: KeyboardAnimationFrameSnapshot): number;
+    setKeyboardEventFocusedInput(focusedInput: FocusedInputLayout | null): number;
+    dispatchKeyboardEventHandlers(frame: KeyboardAnimationFrameSnapshot, eventTimestamp?: number): number;
+    dispatchEventHandlers(viewTag: number, event: {
+        eventName?: string;
+    } & Record<string, unknown>, eventTimestamp?: number, ownerKey?: string): number;
+    private dispatchEventHandlersByName;
+    private invokeEventHandler;
+    private registerLocalFrameCallback;
+    readonly requestNativeAnimationFrame: (callback: FrameRequestCallback) => void;
+    readonly enqueueNativeJob: (callback: () => void) => void;
+    readonly drainNativeJobs: () => void;
+    private cancelNativeFrames;
+    private unregisterLocalFrameCallback;
+    private setLocalFrameCallbackActive;
+    private ensureFrameCallbackLoop;
+    private cancelFrameCallbackLoop;
+    private scheduleFrame;
+    hasSlot(id: number): boolean;
+    private onMessage;
+    private acceptPeerEpoch;
+    private retireActivePeer;
+    private clearPeerOwnedState;
+    private animatedBridgeListeners;
+    onPeerRetired(listener: (peerEpoch: WorkletPeerEpoch) => void): () => void;
+    private pendingAnimatedBridgeMessages;
+    private pendingLayoutAnimationConfigurations;
+    onAnimatedBridge(cb: (msg: WorkletMessage) => void): () => void;
+    setCSSShellHost(host: CSSShellHost | null): void;
+    postAnimatedBridge(msg: WorkletMessagePayload): void;
+    registerJSCallback<T extends (...args: unknown[]) => unknown>(fn: T): T;
+    private shipJSCallback;
+    private queueJSCallbackRelease;
+    private serializeValueForDispatch;
+    private serializeClosureForDispatch;
+    private serializeWorkletFunctionForDispatch;
+    private serializeRemoteFunctionForDispatch;
+    postJSCallback(id: number, args: unknown[]): void;
+    private handleRunWorklet;
+    private replyToWorklet;
+    deserializeClosure(spec: ClosureSpec, closureIsArray?: boolean): WorkletClosure;
+    private getMaterializedClosure;
+    registerNativeShareableHost(id: number, host: object, decorator: unknown): void;
+    private bindNativeShareableHost;
+    deserializeValue(spec: ValueSpec): unknown;
+    private bindRemoteJSCallback;
+    private trackPeerCallbackHolder;
+    private retainSpecReferences;
+    private collectSpecReferences;
+    private bindRemoteFunction;
+    private bindBuiltin;
+    private activeReanimatedMutables;
+    listReanimatedAnimations(): (Omit<SootSimAnimationInfo, 'source' | 'realm'> & {
+        sharedValueId: number;
+    })[];
+    stopReanimatedAnimation(target: number | 'all'): number;
+    sharedValuePlayback(value: object): SharedValuePlayback;
+    private publishSharedValuePlayback;
+    private publishFinishedSharedValuePlayback;
+    private bindSharedValueProxy;
+    private bindObjectSharedValueProxy;
+    private bindRemoteAnimatedRefSlot;
+    writeSynchronizableSlot(id: number, value: number): void;
+    synchronizableAccess(id: number): Int32Array;
+    bindDynamicSynchronizableProxy(spec: Extract<ValueSpec, {
+        kind: 'synchronizableDynamic';
+    }>): object;
+    shipSynchronizable(source: object): number | undefined;
+    bindSynchronizableProxy(id: number, lockId: number, referenceId?: number, boolean?: boolean): SynchronizableHostObject;
+    private serializeAnimatedRefForDispatch;
+    private bindRemoteWorklet;
+}
+export declare function freezeReanimated2Records<T>(value: T, seen?: WeakSet<WeakKey>): T;
+export declare function invokeNativeWorklet(body: (...args: unknown[]) => unknown, receiver: unknown, args: unknown[], closure: object, reanimated2?: boolean): unknown;
+export interface SharedValueProxy {
+    _id: number;
+    _isReanimatedSharedValue: true;
+    value: number | boolean | null | undefined;
+    _value: number | boolean | null | undefined;
+    _animation: unknown;
+    get(): number | boolean | null | undefined;
+    set(v: number | boolean | null | undefined | (() => number | boolean | null | undefined)): void;
+    modify(modifier: (value: number | boolean | null | undefined) => number | boolean | null | undefined, 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;
+    _value: unknown;
+    _animation: 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;
+    setDirty(dirty: boolean): void;
+}
+export interface WorkletFn {
+    __closure?: WorkletClosure;
+    _closure?: WorkletClosure;
+    asString?: string;
+    __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: WorkletClosure): ClosureSpec;
+export declare function markObjectSV(target: object): void;
+interface SanitizeState {
+    seen: WeakMap<object, unknown>;
+    active: WeakSet<object>;
+    depth: number;
+}
+export declare function sanitizeForPeer(value: Record<string, unknown>): Record<string, unknown>;
+export declare function sanitizeForPeer(value: unknown, state?: SanitizeState): unknown;
+export declare function evalWorkletCode(code: string): (...args: unknown[]) => unknown;
+export declare function setActiveWorkletRuntime(rt: WorkletRuntime): void;
+export declare function postWorkletHostValueUpdate(codec: string, data: unknown): void;
+export declare function getActiveWorkletRuntime(): WorkletRuntime | null;
+export declare class NativeFrameQueue {
+    private callbacks;
+    private handle;
+    private cancelled;
+    readonly request: (callback: FrameRequestCallback) => void;
+    cancel(): void;
+}
+export declare function installHeadlessNativeFrames(): void;
+export declare function retireHeadlessNativeFrames(): void;
+export declare function gestureSeamPeerEpoch(): WorkletPeerEpoch;
+export declare function isWorkletRuntimeReady(): boolean;
+export declare const __WORKLET_RUNTIME_INTERNALS: {
+    SAB_HEADER_FLOATS: number;
+    SAB_MAGIC: number;
+    DEFAULT_CAPACITY: number;
+};
+export declare const evaluatedLazyShellBootRoots: string[];