@symbiote-native/engine 0.1.4 → 0.1.5

package/build/accessibility-info/index.android.js

@@ -6,12 +6,10 @@
 // device-event NAMES also differ from iOS (e.g. screen-reader is `touchExplorationDidChange`,
 // reduce-motion is `reduceMotionDidChange`). Metro picks this on an Android host. Mirrors
 // RN's AccessibilityInfo.js Android branches.
-import { getNativeModule } from '../native-modules.js';
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
-import { isSymbioteNode } from '../node.js';
-import { sendAccessibilityEvent as sharedSendAccessibilityEvent } from '../commit.js';
+import { createDeviceEventModule } from '../native-modules.js';
+import {} from '../native-events.js';
 import { dlog } from '../debug.js';
-import { isBoolean, } from './shared.js';
+import { isBoolean, routeSendAccessibilityEvent, } from './shared.js';
 // The Android native module name. This is the module the Android JS wrapper
 // (INativeAccessibilityInfoAndroid) resolves: the stock RN `AccessibilityInfo` Turbo/legacy
 // module. A module name is only provable on a real host (a headless fake answers to any
@@ -28,22 +26,18 @@ const ANDROID_DEVICE_EVENT = {
     invertColorsChanged: 'invertColorDidChange',
     grayscaleChanged: 'grayscaleModeDidChange',
 };
-// Lazily resolved so importing this module has no native side effect. `null` when unlinked.
-let accessibilityModule;
-let emitter;
+// Lazily resolved so importing this module has no native side effect. `null` when
+// unlinked. The lazy-resolve + lazy-emitter shape lives in `createDeviceEventModule`
+// (native-modules.ts); Android adds no self-subscription on top of it.
+const deviceEventModule = createDeviceEventModule({
+    moduleName: ACCESSIBILITY_MODULE,
+    moduleLogPrefix: 'AccessibilityInfo(android): module',
+});
 function getModule() {
-    if (accessibilityModule === undefined) {
-        accessibilityModule = getNativeModule(ACCESSIBILITY_MODULE);
-        dlog(`AccessibilityInfo(android): module ${accessibilityModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return accessibilityModule;
+    return deviceEventModule.getModule();
 }
 function getEmitter() {
-    if (emitter === undefined) {
-        installDeviceEventHub();
-        emitter = new NativeEventEmitter(getModule() ?? undefined);
-    }
-    return emitter;
+    return deviceEventModule.getEmitter();
 }
 // Run a single-callback Android getter as a Promise. Resolves false when the module is
 // unlinked OR the optional method is absent on this host; mirrors RN's "missing query ->
@@ -132,18 +126,12 @@ class AccessibilityInfoAndroid {
             query.call(module, originalTimeout, timeout => resolve(timeout));
         });
     }
-    // Emit a named accessibility event at a view through the Fabric slot. RN's Fabric path
-    // hands the public-instance handle to nativeFabricUIManager.sendAccessibilityEvent with the
-    // STRING eventType; the C++ side maps it to the platform's AccessibilityEvent kind. The
-    // handle here IS the SymbioteNode (symbiote augments the node in place as its public
-    // instance), so resolve it with the runtime guard and route through shared.
+    // Emit a named accessibility event at a view through the Fabric slot. The shared
+    // routing (isSymbioteNode guard + dispatch) lives in shared.ts, identical on both
+    // platforms; Android has no early-return special case, so it passes no shouldSkip
+    // hook - every event reaches the slot.
     sendAccessibilityEvent(handle, eventType) {
-        if (!isSymbioteNode(handle)) {
-            dlog(`AccessibilityInfo(android).sendAccessibilityEvent("${eventType}") -> handle is not a node (no-op)`);
-            return;
-        }
-        dlog(`AccessibilityInfo(android).sendAccessibilityEvent("${eventType}") -> slot`);
-        sharedSendAccessibilityEvent(handle, eventType);
+        routeSendAccessibilityEvent('android', handle, eventType);
     }
     // Subscribe to an accessibility-state change. Android events all carry a bare boolean.
     // Never throws: a public event with no Android device mapping yields an inert

package/build/accessibility-info/index.ios.js

@@ -2,16 +2,14 @@
 // based state getters (VoiceOver / reduce-motion / bold-text / grayscale / invert-colors /
 // reduce-transparency / darker-system-colors), announce + focus side effects, and the
 // observe-counters for the device-event subscription. Subscribes to iOS device events
-// (`screenReaderChanged` / `reduceMotionChanged` / `boldTextChanged` / …) via a
+// (`screenReaderChanged` / `reduceMotionChanged` / `boldTextChanged` / ...) via a
 // NativeEventEmitter and re-broadcasts to JS listeners. Metro picks this on an iOS host;
 // the bare accessibility-info.ts re-exports it as the default for tsc / tsx / headless.
 // Mirrors RN's AccessibilityInfo.js iOS branches.
-import { getNativeModule } from '../native-modules.js';
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
-import { isSymbioteNode } from '../node.js';
-import { sendAccessibilityEvent as sharedSendAccessibilityEvent } from '../commit.js';
+import { createDeviceEventModule } from '../native-modules.js';
+import {} from '../native-events.js';
 import { dlog } from '../debug.js';
-import { isBoolean, } from './shared.js';
+import { isBoolean, routeSendAccessibilityEvent, } from './shared.js';
 // The iOS native module name RN registers this under. NOTE: this is the name the iOS JS
 // wrapper (INativeAccessibilityManagerIOS) resolves via
 // `TurboModuleRegistry.get('AccessibilityManager')`, NOT the spec filename
@@ -32,24 +30,18 @@ const IOS_DEVICE_EVENT = {
 };
 // Lazily resolved so importing this module has no native side effect: a headless run
 // without a fake __turboModuleProxy still loads it; resolution happens on first use.
-// `null` when the module isn't linked.
-let accessibilityModule;
-let emitter;
+// `null` when the module isn't linked. The lazy-resolve + lazy-emitter shape itself
+// lives in `createDeviceEventModule` (native-modules.ts); iOS adds no self-subscription
+// on top of it, unlike app-state/appearance/back-handler/keyboard.
+const deviceEventModule = createDeviceEventModule({
+    moduleName: ACCESSIBILITY_MODULE,
+    moduleLogPrefix: 'AccessibilityInfo(ios): module',
+});
 function getModule() {
-    if (accessibilityModule === undefined) {
-        accessibilityModule = getNativeModule(ACCESSIBILITY_MODULE);
-        dlog(`AccessibilityInfo(ios): module ${accessibilityModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return accessibilityModule;
+    return deviceEventModule.getModule();
 }
 function getEmitter() {
-    if (emitter === undefined) {
-        // WHY lazy: install on first subscribe so the hub exists before native emits,
-        // without a hard bootstrap-order dependency. Idempotent.
-        installDeviceEventHub();
-        emitter = new NativeEventEmitter(getModule() ?? undefined);
-    }
-    return emitter;
+    return deviceEventModule.getEmitter();
 }
 // Run a callback-based native getter as a Promise; resolves false when the module is
 // unlinked, mirroring RN's "unavailable query -> false" contract for the cross-platform
@@ -162,24 +154,18 @@ class AccessibilityInfoIOS {
     getRecommendedTimeoutMillis(originalTimeout) {
         return Promise.resolve(originalTimeout);
     }
-    // Emit an accessibility event at a view through the Fabric slot. RN's Fabric
-    // sendAccessibilityEvent hands the public-instance handle straight to
-    // nativeFabricUIManager.sendAccessibilityEvent with the STRING eventType, and the C++
-    // side maps it. The handle here IS the SymbioteNode (symbiote augments the node in place
-    // as its public instance), so resolve it with the runtime guard and route through shared.
-    // RN early-returns 'click' on iOS only (AccessibilityInfo.js) because VoiceOver has no click
-    // producer, so preserve that one no-op; every other event reaches the slot.
+    // Emit an accessibility event at a view through the Fabric slot. The shared routing
+    // (isSymbioteNode guard + dispatch) lives in shared.ts, identical on both platforms;
+    // the ONE thing iOS adds is its own early return on 'click' (VoiceOver has no click
+    // producer, AccessibilityInfo.js), passed as the shouldSkip hook so it keeps its
+    // exact log text.
     sendAccessibilityEvent(handle, eventType) {
-        if (eventType === 'click') {
+        routeSendAccessibilityEvent('ios', handle, eventType, () => {
+            if (eventType !== 'click')
+                return false;
             dlog('AccessibilityInfo(ios).sendAccessibilityEvent("click") -> iOS no-op (RN parity)');
-            return;
-        }
-        if (!isSymbioteNode(handle)) {
-            dlog(`AccessibilityInfo(ios).sendAccessibilityEvent("${eventType}") -> handle is not a node (no-op)`);
-            return;
-        }
-        dlog(`AccessibilityInfo(ios).sendAccessibilityEvent("${eventType}") -> slot`);
-        sharedSendAccessibilityEvent(handle, eventType);
+            return true;
+        });
     }
     // Subscribe to an accessibility-state change. A handler for a boolean event receives a
     // boolean; the iOS-only `announcementFinished` carries the announcement payload. Never

package/build/accessibility-info/shared.d.ts

@@ -1,5 +1,6 @@
-import type { ISymbioteNode } from '../node';
+import { type ISymbioteNode } from '../node';
 import type { IEventSubscription } from '../native-events';
+export { isBoolean } from '../type-guards';
 export type IAccessibilityChangeEventName = 'screenReaderChanged' | 'reduceMotionChanged' | 'boldTextChanged' | 'grayscaleChanged' | 'invertColorsChanged' | 'reduceTransparencyChanged' | 'darkerSystemColorsChanged' | 'announcementFinished' | 'accessibilityServiceChanged' | 'highTextContrastChanged';
 export type IAccessibilityChangeEvent = IAccessibilityChangeEventName;
 export type IAccessibilityHandle = ISymbioteNode | number | null | undefined;
@@ -31,4 +32,4 @@ export interface IAccessibilityInfoStatic {
     addEventListener(eventName: IAccessibilityChangeEventName, handler: IAccessibilityChangeEventHandler): IEventSubscription;
 }
 export type IAccessibilityEventType = 'click' | 'focus' | 'viewHoverEnter' | 'windowStateChange';
-export declare function isBoolean(value: unknown): value is boolean;
+export declare function routeSendAccessibilityEvent(platformLabel: string, handle: IAccessibilityHandle, eventType: IAccessibilityEventType, shouldSkip?: () => boolean): void;

package/build/accessibility-info/shared.js

@@ -9,6 +9,29 @@
 // Platform.OS read: the native module name is resolved per platform inside those
 // files, not derived from this file's name. Mirrors
 // RN's Libraries/Components/AccessibilityInfo/AccessibilityInfo.js.
-export function isBoolean(value) {
-    return typeof value === 'boolean';
+import { isSymbioteNode } from '../node.js';
+import { sendAccessibilityEvent as dispatchAccessibilityEvent } from '../commit.js';
+import { dlog } from '../debug.js';
+export { isBoolean } from '../type-guards.js';
+// The routing behind IAccessibilityInfoStatic.sendAccessibilityEvent, shared by both
+// platforms: resolve the handle to a real SymbioteNode and dispatch through the Fabric
+// slot. RN's Fabric path hands the public-instance handle straight to
+// nativeFabricUIManager.sendAccessibilityEvent with the STRING eventType, and the C++
+// side maps it; the handle here IS the SymbioteNode (symbiote augments the node in
+// place as its public instance).
+//
+// The one thing that genuinely diverges by platform - iOS's early return on 'click'
+// (VoiceOver has no click producer, AccessibilityInfo.js) - is NOT decided here: a
+// platform passes `shouldSkip`, which both decides AND logs its own skip (so iOS keeps
+// its exact "iOS no-op (RN parity)" message); Android omits it and every event reaches
+// the slot.
+export function routeSendAccessibilityEvent(platformLabel, handle, eventType, shouldSkip) {
+    if (shouldSkip?.() === true)
+        return;
+    if (!isSymbioteNode(handle)) {
+        dlog(`AccessibilityInfo(${platformLabel}).sendAccessibilityEvent("${eventType}") -> handle is not a node (no-op)`);
+        return;
+    }
+    dlog(`AccessibilityInfo(${platformLabel}).sendAccessibilityEvent("${eventType}") -> slot`);
+    dispatchAccessibilityEvent(handle, eventType);
 }

package/build/action-sheet-ios/index.d.ts

@@ -1,3 +1,4 @@
+export declare const ACTION_SHEET_MANAGER = "ActionSheetManager";
 export interface IActionSheetIOSOptions {
     title?: string;
     message?: string;
@@ -29,6 +30,11 @@ export interface IShareActionSheetError {
     userInfo?: Record<string, unknown>;
     message: string;
 }
+export interface INativeActionSheetManager {
+    showActionSheetWithOptions(options: IActionSheetIOSOptions, callback: (buttonIndex: number) => void): void;
+    showShareActionSheetWithOptions(options: IShareActionSheetIOSOptions, failureCallback: (error: IShareActionSheetError) => void, successCallback: (completed: boolean, activityType?: string) => void): void;
+    dismissActionSheet?(): void;
+}
 export declare const ActionSheetIOS: {
     showActionSheetWithOptions(options: IActionSheetIOSOptions, callback: (buttonIndex: number) => void): void;
     showShareActionSheetWithOptions(options: IShareActionSheetIOSOptions, failureCallback: (error: IShareActionSheetError) => void, successCallback: (completed: boolean, activityType?: string) => void): void;

package/build/action-sheet-ios/index.js

@@ -18,7 +18,7 @@
 // through untouched. The canary needs no colors; revisit when wiring real colors.
 import { dlog } from '../debug.js';
 import { getNativeModule } from '../native-modules.js';
-const ACTION_SHEET_MANAGER = 'ActionSheetManager';
+export const ACTION_SHEET_MANAGER = 'ActionSheetManager';
 // The static imperative API RN exposes, mirrored as a static-method object.
 export const ActionSheetIOS = {
     showActionSheetWithOptions(options, callback) {

package/build/alert/index.android.js

@@ -18,6 +18,7 @@
 // Non-throwing, like StatusBar: a missing native module is a no-op, never a crash.
 import { dlog } from '../debug.js';
 import { getNativeModule } from '../native-modules.js';
+import { isRecord } from '../type-guards.js';
 import { DEFAULT_POSITIVE_TEXT, normalizeButtons, } from './shared.js';
 const DIALOG_MANAGER = 'DialogManagerAndroid';
 // RN's hardwired Android fallbacks for the button-key constants (NativeDialogManager-
@@ -32,9 +33,6 @@ const ANDROID_DIALOG_CONSTANTS = {
 };
 // The trust boundary for getConstants(): native sends an untyped HostObject. Read each key
 // with a typeof guard and fall back to RN's documented default when it's missing.
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function readDialogConstants(raw) {
     if (!isRecord(raw)) {
         dlog('Alert: DialogManagerAndroid.getConstants() returned a non-object — using defaults');

package/build/animated/animations/base.js

@@ -8,7 +8,6 @@
 // owns its own requestAnimationFrame loop. They are declared as methods (not
 // class fields) so a subclass override is not shadowed under
 // useDefineForClassFields.
-import { flushValue } from '../graph.js';
 import { dlog, isDebug } from '../../debug.js';
 import { generateNativeAnimationId, isNativeAnimatedAvailable, nativeAnimated, } from '../native/native-animated.js';
 export class BaseAnimation {
@@ -41,7 +40,7 @@ export class BaseAnimation {
         this.onEndCallback = onEnd;
         this.__active = true;
     }
-    // A native driver overrides this with its curve config (`{type:'frames'|'spring'|'decay', …}`).
+    // A native driver overrides this with its curve config (`{type:'frames'|'spring'|'decay', ...}`).
     getNativeAnimationConfig() {
         throw new Error('This animation type cannot be offloaded to the native driver');
     }
@@ -57,19 +56,11 @@ export class BaseAnimation {
             dlog('useNativeDriver requested but native animated module is missing; using JS driver');
             return false;
         }
-        const config = this.getNativeAnimationConfig();
-        // RN hands the curve's platform bag down to the value node (Animation.js:137)
-        // so the node's create config carries it too.
-        animatedValue.__makeNative(this.__platformConfig);
         this.nativeId = generateNativeAnimationId();
-        nativeAnimated.startAnimatingNode(this.nativeId, animatedValue.__getNativeTag(), config, result => {
-            this.__notifyAnimationEnd({ finished: result.finished });
-            // Sync the JS value to native's final value, then run leaf callbacks once.
-            if (result.value !== undefined) {
-                animatedValue.__onNativeUpdate(result.value, result.offset);
-                flushValue(animatedValue);
-            }
-        });
+        // The value owns the native handshake (make native, mint tag, sync back on
+        // completion); we hand over only what THIS driver owns: the curve, RN's
+        // Animation.js:137 platform bag, this animation's id, and its own end callback.
+        animatedValue.__startNativeAnimation(this.getNativeAnimationConfig(), this.nativeId, finished => this.__notifyAnimationEnd({ finished }), this.__platformConfig);
         return true;
     }
     stop() {

package/build/animated/event.js

@@ -18,9 +18,7 @@ import { getNativeTag, whenCommitted } from '../commit.js';
 import { isSymbioteNode } from '../node.js';
 import { AnimatedNode, flushValue } from './graph.js';
 import { isNativeAnimatedAvailable, nativeAnimated } from './native/native-animated.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
+import { isRecord } from '../type-guards.js';
 // A value node settable from an event field. AnimatedValue carries setValue; we
 // duck-type it (rather than importing AnimatedValue) to keep this leaf-agnostic
 // and avoid a value<->event import cycle.
@@ -68,9 +66,9 @@ export class AnimatedEvent {
     // RN parity: the event remembers whether useNativeDriver was requested. Honored only
     // when a native module is present (__isNative); otherwise the JS path drives values.
     nativeDriverRequested;
-    // Flipped once a host view native-attaches this event. The JS handler then stops
-    // setting values (native owns them on the UI thread) and only forwards listeners.
-    // no double-drive, no redundant per-tick commit.
+    // Flipped once a host view native-attaches this event: the JS handler then stops
+    // setting values (native owns them on the UI thread) and only forwards listeners,
+    // avoiding a double drive and a redundant per-tick commit.
     attachedNatively = false;
     constructor(argMapping, config) {
         if (config?.listener !== undefined)
@@ -165,8 +163,8 @@ export function attachNativeEvent(node, eventName, argMapping) {
     const animatedEvent = new AnimatedEvent(argMapping);
     let attachedTag;
     // Bind once the node is committed: now if it already has a Fabric tag, else after the commit that
-    // assigns it. Vue/Svelte batch commits on a microtask, so the adapter can wire this — e.g. the
-    // sticky-header scroll — before the tag exists; whenCommitted defers instead of silently binding
+    // assigns it. Vue/Svelte batch commits on a microtask, so the adapter can wire this (e.g. the
+    // sticky-header scroll) before the tag exists; whenCommitted defers instead of silently binding
     // nothing. React commits synchronously and binds on the first try.
     const cancel = whenCommitted(node, () => {
         const viewTag = getNativeTag(node);
@@ -187,7 +185,7 @@ export function attachNativeEvent(node, eventName, argMapping) {
 // Native-attach the AnimatedEvent already behind a handler from `event(...)`, binding it
 // to a committed host node. Unlike attachNativeEvent (which builds a fresh event from a
 // raw mapping for ScrollView's internal sticky value), this REUSES the caller's handler,
-// so createAnimatedComponent can offload `onScroll={Animated.event(…, {useNativeDriver})}`
+// so createAnimatedComponent can offload `onScroll={Animated.event(..., {useNativeDriver})}`
 // to the UI thread, and the __makeNative cascade carries the bound interpolations/props
 // native with it. Returns undefined (caller keeps the JS path) when the prop is not a native
 // event handler; if it IS but the node has no tag yet, the bind defers to the commit (same race).

package/build/animated/graph.d.ts

@@ -1,7 +1,11 @@
 import { type INativeNodeConfig, type IPlatformConfig } from './native/native-animated';
+import type { IInterpolationConfig } from './interpolation';
+import type { AnimatedInterpolation } from './interpolation-node';
 export type IValueListener = (state: {
     value: number | string;
 }) => void;
+type IInterpolationFactory = (parent: AnimatedNode, config: IInterpolationConfig) => AnimatedInterpolation;
+export declare function registerInterpolationFactory(factory: IInterpolationFactory): void;
 export declare class AnimatedNode {
     private readonly listeners;
     private suspendCallbacks;
@@ -17,6 +21,7 @@ export declare class AnimatedNode {
     __getNativeConfig(): INativeNodeConfig;
     __getValue(): unknown;
     __getAnimatedValue(): unknown;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
     __addChild(_child: AnimatedNode): void;
     __removeChild(_child: AnimatedNode): void;
     __getChildren(): readonly AnimatedNode[];
@@ -36,3 +41,4 @@ export declare class AnimatedWithChildren extends AnimatedNode {
     __callListeners(value: number | string): void;
 }
 export declare function flushValue(rootNode: AnimatedNode): void;
+export {};

package/build/animated/graph.js

@@ -11,6 +11,10 @@
 //      to rebuild composite props (e.g. transform from many parents).
 import { generateNativeNodeTag, nativeAnimated, } from './native/native-animated.js';
 let nextListenerId = 1;
+let createInterpolationNode;
+export function registerInterpolationFactory(factory) {
+    createInterpolationNode = factory;
+}
 // Depth of the currently-active withSuspendedCallbacks blocks. While > 0, a
 // composite setter (AnimatedColor.setValue) is driving several channels in a row;
 // each channel's own flushValue is suppressed so the bound leaf commits ONCE (at
@@ -98,6 +102,16 @@ export class AnimatedNode {
     __getAnimatedValue() {
         return this.__getValue();
     }
+    // Map this node's value before it reaches a prop, e.g. 0..1 -> 0..10. Defined once
+    // here (Information Expert: every node subclass wants the identical one-liner)
+    // instead of duplicated per subclass; see registerInterpolationFactory above for
+    // why the concrete constructor is injected rather than imported directly.
+    interpolate(config) {
+        if (createInterpolationNode === undefined) {
+            throw new Error('AnimatedNode.interpolate: interpolation factory not registered');
+        }
+        return createInterpolationNode(this, config);
+    }
     __addChild(_child) { }
     __removeChild(_child) { }
     __getChildren() {

package/build/animated/interpolation-node.d.ts

@@ -8,7 +8,6 @@ export declare class AnimatedInterpolation extends AnimatedWithChildren {
     constructor(parent: AnimatedNode, config: IInterpolationConfig);
     private getInterpolation;
     __getValue(): number | string;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
     __attach(): void;
     __detach(): void;
     __makeNative(platformConfig?: IPlatformConfig): void;

package/build/animated/interpolation-node.js

@@ -2,7 +2,7 @@
 // through an interpolation. Ported from RN's AnimatedInterpolation.js: numeric,
 // string-with-units, and color output ranges (the value graph; native config
 // removed). Platform (Native) colors stay out of scope, color.ts defers them.
-import { AnimatedNode, AnimatedWithChildren } from './graph.js';
+import { AnimatedNode, AnimatedWithChildren, registerInterpolationFactory } from './graph.js';
 import { checkValidRanges, createInterpolation } from './interpolation.js';
 export class AnimatedInterpolation extends AnimatedWithChildren {
     parent;
@@ -28,9 +28,6 @@ export class AnimatedInterpolation extends AnimatedWithChildren {
         }
         return this.getInterpolation()(parentValue);
     }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
     __attach() {
         this.parent.__addChild(this);
         super.__attach();
@@ -55,3 +52,7 @@ export class AnimatedInterpolation extends AnimatedWithChildren {
         };
     }
 }
+// Hand graph.ts's AnimatedNode.interpolate() the real constructor at module load,
+// so every node subclass's base-class interpolate() produces an actual
+// AnimatedInterpolation without graph.ts ever value-importing this module.
+registerInterpolationFactory((parent, config) => new AnimatedInterpolation(parent, config));

package/build/animated/native/native-animated.js

@@ -12,6 +12,7 @@
 import { dlog } from '../../debug.js';
 import { getNativeModule } from '../../native-modules.js';
 import { NativeEventEmitter } from '../../native-events.js';
+import { isRecord } from '../../type-guards.js';
 // iOS bridgeless registers the Turbo variant; the legacy name is the fallback.
 const TURBO_MODULE_NAME = 'NativeAnimatedTurboModule';
 const LEGACY_MODULE_NAME = 'NativeAnimatedModule';
@@ -50,9 +51,6 @@ export function generateNativeAnimationId() {
 const VALUE_UPDATE_EVENT = 'onAnimatedValueUpdate';
 const valueListeners = new Map();
 let valueUpdateSubscription;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function ensureValueUpdateSubscription() {
     if (valueUpdateSubscription !== undefined)
         return;

package/build/animated/operators.d.ts

@@ -1,50 +1,31 @@
 import { AnimatedNode, AnimatedWithChildren } from './graph';
-import { AnimatedInterpolation } from './interpolation-node';
-import type { IInterpolationConfig } from './interpolation';
 import type { INativeNodeConfig, IPlatformConfig } from './native/native-animated';
-export declare class AnimatedAddition extends AnimatedWithChildren {
-    private readonly a;
-    private readonly b;
+declare abstract class AnimatedBinaryOp extends AnimatedWithChildren {
+    protected readonly a: AnimatedNode;
+    protected readonly b: AnimatedNode;
     constructor(a: AnimatedNode | number, b: AnimatedNode | number);
+    protected abstract compute(a: number, b: number): number;
     __getValue(): number;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
     __attach(): void;
     __detach(): void;
     __makeNative(platformConfig?: IPlatformConfig): void;
+}
+export declare class AnimatedAddition extends AnimatedBinaryOp {
+    protected compute(a: number, b: number): number;
     __getNativeConfig(): INativeNodeConfig;
 }
-export declare class AnimatedSubtraction extends AnimatedWithChildren {
-    private readonly a;
-    private readonly b;
-    constructor(a: AnimatedNode | number, b: AnimatedNode | number);
-    __getValue(): number;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
-    __attach(): void;
-    __detach(): void;
-    __makeNative(platformConfig?: IPlatformConfig): void;
+export declare class AnimatedSubtraction extends AnimatedBinaryOp {
+    protected compute(a: number, b: number): number;
     __getNativeConfig(): INativeNodeConfig;
 }
-export declare class AnimatedMultiplication extends AnimatedWithChildren {
-    private readonly a;
-    private readonly b;
-    constructor(a: AnimatedNode | number, b: AnimatedNode | number);
-    __getValue(): number;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
-    __attach(): void;
-    __detach(): void;
-    __makeNative(platformConfig?: IPlatformConfig): void;
+export declare class AnimatedMultiplication extends AnimatedBinaryOp {
+    protected compute(a: number, b: number): number;
     __getNativeConfig(): INativeNodeConfig;
 }
-export declare class AnimatedDivision extends AnimatedWithChildren {
-    private readonly a;
-    private readonly b;
+export declare class AnimatedDivision extends AnimatedBinaryOp {
     private warnedAboutDivideByZero;
     constructor(a: AnimatedNode | number, b: AnimatedNode | number);
-    __getValue(): number;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
-    __attach(): void;
-    __detach(): void;
-    __makeNative(platformConfig?: IPlatformConfig): void;
+    protected compute(a: number, b: number): number;
     __getNativeConfig(): INativeNodeConfig;
 }
 export declare class AnimatedModulo extends AnimatedWithChildren {
@@ -52,7 +33,6 @@ export declare class AnimatedModulo extends AnimatedWithChildren {
     private readonly modulus;
     constructor(a: AnimatedNode, modulus: number);
     __getValue(): number;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
     __attach(): void;
     __detach(): void;
     __makeNative(platformConfig?: IPlatformConfig): void;
@@ -66,7 +46,6 @@ export declare class AnimatedDiffClamp extends AnimatedWithChildren {
     private lastValue;
     constructor(a: AnimatedNode, min: number, max: number);
     __getValue(): number;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
     __attach(): void;
     __detach(): void;
     __makeNative(platformConfig?: IPlatformConfig): void;
@@ -78,3 +57,4 @@ export declare function multiply(a: AnimatedNode | number, b: AnimatedNode | num
 export declare function divide(a: AnimatedNode | number, b: AnimatedNode | number): AnimatedDivision;
 export declare function modulo(a: AnimatedNode, modulus: number): AnimatedModulo;
 export declare function diffClamp(a: AnimatedNode, min: number, max: number): AnimatedDiffClamp;
+export {};