@symbiote-native/engine 0.4.0 → 1.0.0

package/build/animated/easing.js

@@ -1,88 +1,17 @@
-// Common easing functions, ported from React Native's Libraries/Animated/Easing.js.
-// Pure math (the only dependency is the equally-pure bezier solver), so it lives
-// unchanged in shared and every adapter re-exports it.
-import { bezier } from './bezier.js';
-let cachedEase;
-export const Easing = {
-    step0(n) {
-        return n > 0 ? 1 : 0;
-    },
-    step1(n) {
-        return n >= 1 ? 1 : 0;
-    },
-    linear(t) {
-        return t;
-    },
-    // A simple inertial interaction (object slowly accelerating to speed).
-    ease(t) {
-        if (cachedEase === undefined) {
-            cachedEase = bezier(0.42, 0, 1, 1);
-        }
-        return cachedEase(t);
-    },
-    quad(t) {
-        return t * t;
-    },
-    cubic(t) {
-        return t * t * t;
-    },
-    // Nth-power: position is the Nth power of elapsed time.
-    poly(n) {
-        return t => Math.pow(t, n);
-    },
-    sin(t) {
-        return 1 - Math.cos((t * Math.PI) / 2);
-    },
-    circle(t) {
-        return 1 - Math.sqrt(1 - t * t);
-    },
-    exp(t) {
-        return Math.pow(2, 10 * (t - 1));
-    },
-    // Elastic: spring-like oscillation. bounciness 1 overshoots once; 0 not at all.
-    elastic(bounciness = 1) {
-        const p = bounciness * Math.PI;
-        return t => 1 - Math.pow(Math.cos((t * Math.PI) / 2), 3) * Math.cos(t * p);
-    },
-    // Animates back slightly before moving forward.
-    back(s = 1.70158) {
-        return t => t * t * ((s + 1) * t - s);
-    },
-    // A simple bouncing effect.
-    bounce(t) {
-        if (t < 1 / 2.75) {
-            return 7.5625 * t * t;
-        }
-        if (t < 2 / 2.75) {
-            const t2 = t - 1.5 / 2.75;
-            return 7.5625 * t2 * t2 + 0.75;
-        }
-        if (t < 2.5 / 2.75) {
-            const t2 = t - 2.25 / 2.75;
-            return 7.5625 * t2 * t2 + 0.9375;
-        }
-        const t2 = t - 2.625 / 2.75;
-        return 7.5625 * t2 * t2 + 0.984375;
-    },
-    // A cubic bezier curve, same as CSS transition-timing-function.
-    bezier(x1, y1, x2, y2) {
-        return bezier(x1, y1, x2, y2);
-    },
-    // Runs an easing function forwards.
-    in(easing) {
-        return easing;
-    },
-    // Runs an easing function backwards.
-    out(easing) {
-        return t => 1 - easing(1 - t);
-    },
-    // Makes any easing function symmetrical (forwards then backwards).
-    inOut(easing) {
-        return t => {
-            if (t < 0.5) {
-                return easing(t * 2) / 2;
-            }
-            return 1 - easing((1 - t) * 2) / 2;
-        };
-    },
-};
+// RN's own Easing, imported rather than ported.
+//
+// The port this replaces was 109 lines beside a 142-line `bezier.ts`, and it reproduced upstream
+// formula for formula. Swept at 20 001 points per function before the swap: 15 of the 17 agree to
+// the bit, and the two bezier-backed ones (`ease`, `bezier`) differ by 2.9e-10, because upstream
+// samples its spline into a Float32Array where the port used a plain (float64) array. That is
+// below a sub-pixel on any animation this drives.
+//
+// The TYPE is ours and stays ours. `Easing` is on the engine barrel and re-exported by all five
+// adapters, and the upstream module ships no types - so importing it untyped would hand every
+// consumer `any`. Twenty lines of interface in exchange for 251 lines of implementation.
+import EasingUpstream from 'react-native/Libraries/Animated/Easing';
+// tsc resolves this deep path but reads the Flow source through allowJs, so the default export
+// arrives shapeless rather than untyped - the mismatch is the only thing the suppression covers,
+// and IEasing above is what every consumer actually sees.
+// @ts-expect-error - upstream ships no usable types for this path.
+export const Easing = EasingUpstream;

package/build/animated/event.js

@@ -14,7 +14,7 @@
 //     and registers the key path with the stock native module, so the event drives
 //     the view with zero JS per event.
 import { dlog } from '../debug.js';
-import { getNativeTag, whenCommitted } from '../commit.js';
+import { getNativeTag, whenCommitted } from '../imperative.js';
 import { isSymbioteNode } from '../node.js';
 import { AnimatedNode, flushValue } from './graph.js';
 import { isNativeAnimatedAvailable, nativeAnimated, } from './native/native-animated.js';
@@ -45,6 +45,11 @@ function collectMappedValues(mapping, path, out) {
         }
     }
 }
+// TODO(rn-parity, low priority): vendor's `AnimatedEvent.js` has `validateMapping`, a
+// `__DEV__`-only check that throws when an event's actual shape doesn't match the argMapping
+// structure. We have no equivalent — `extractAtPath` below silently no-ops on a mismatch instead.
+// Judged non-actionable (misuse-detection guard, no runtime-visible effect for a correct mapping,
+// same class as the `numColumns` invariant) — see the audit skill for the full reasoning.
 // Pull the numeric field at `path` out of one event argument. Returns undefined
 // when the path is absent or the leaf is not a number, so a malformed event is a
 // no-op rather than a throw inside an event dispatch.

package/build/animated/graph.d.ts

@@ -3,12 +3,14 @@ import { type IInterpolationConfig } from './interpolation';
 export type IValueListener = (state: {
     value: number | string;
 }) => void;
+export declare function hasAnimatedNodes(): boolean;
 export declare class AnimatedNode {
     private readonly listeners;
     private suspendCallbacks;
     protected isNative: boolean;
     private nativeTag;
     private platformConfig;
+    constructor();
     __attach(): void;
     __detach(): void;
     __isNative(): boolean;

package/build/animated/graph.js

@@ -20,6 +20,17 @@ let nextListenerId = 1;
 // channel. RN tolerates the per-channel flushes and relies on a downstream commit-
 // coalescing layer; symbiote has none here, so it coalesces at the source.
 let flushSuspendDepth = 0;
+// Has this process ever constructed an Animated node at all?
+//
+// `routeProp` has to answer "does this prop hold an animated value" on EVERY prop write - 32 001
+// of them on one benchmark create - and for an app that animates nothing the only cheap answer is
+// that no AnimatedNode exists to find. One boolean read, the discipline `hasHostBehaviors` and
+// `isDebug` already set. Set in the base constructor so every node type raises it, including the
+// operators and interpolations an app never names directly.
+let anyAnimatedNode = false;
+export function hasAnimatedNodes() {
+    return anyAnimatedNode;
+}
 export class AnimatedNode {
     listeners = new Map();
     // While > 0, this node's own __callListeners is a no-op. A composite setter
@@ -39,6 +50,9 @@ export class AnimatedNode {
     // native config at creation (__getNativeTag). Optional: undefined when no caller
     // supplied one, matching today's behavior.
     platformConfig;
+    constructor() {
+        anyAnimatedNode = true;
+    }
     __attach() { }
     __detach() {
         this.removeAllListeners();

package/build/animated/host-binding.d.ts

@@ -0,0 +1,39 @@
+import { type ISymbioteNode } from '../node';
+export declare function hasAnimatedBindings(): boolean;
+/**
+ * Give a node a behavior-owned animated style layer, or drop it by passing `undefined`.
+ *
+ * The seam `<touchable-opacity>` needs: RN runs its press fade from an `Animated.View` whose
+ * style is `[props.style, {opacity: anim}]` (TouchableOpacity.js:302), and a tag has no such
+ * wrapper. The layer is bound to the leaf, never folded into `node.props.style` — so the behavior
+ * can still read the AUTHOR's resting opacity back without seeing its own fade.
+ */
+export declare function setAnimatedBehaviorStyle(node: ISymbioteNode, style: unknown): void;
+/**
+ * Resolve an animated value in a prop, returning what should be published for it.
+ *
+ * Returns its input by IDENTITY when the value holds nothing animated, so `routeProp` can call it
+ * unconditionally and every downstream branch — class, style, activeStyle, `on*`, `setProp` —
+ * keeps seeing a plain value and needs no change.
+ */
+export declare function bindAnimatedValue(node: ISymbioteNode, key: string, value: unknown): unknown;
+/**
+ * Bind a native-driven `Animated.event` handler written as an `on*` prop. A no-op for every other
+ * handler, so `routeProp` calls it for any `on*` name behind the same one-boolean gate.
+ */
+export declare function bindAnimatedEvent(node: ISymbioteNode, propName: string, handler: unknown): void;
+/**
+ * Release a node's animated subscription. Called per node from the commit sweep, which is where a
+ * genuine removal is first distinguishable from a framework spelling a move as remove-then-insert
+ * (host-behavior.ts, `markDetachCandidate`).
+ */
+export declare function detachAnimatedProps(node: ISymbioteNode): void;
+/**
+ * Re-arm a subtree the sweep tore down and the framework put back — Svelte parks LIVE nodes
+ * offscreen across commits and returns them with their props unwritten, so without this the
+ * animation stops with nothing red anywhere.
+ *
+ * A WeakSet miss and no walk at all for every node in a freshly built tree, which is the path that
+ * runs ~9 000 times per benchmark create.
+ */
+export declare function reattachAnimatedProps(node: ISymbioteNode): void;

package/build/animated/host-binding.js

@@ -0,0 +1,278 @@
+// An AnimatedNode written straight into a prop of a HOST NODE — the engine half of what
+// `createAnimatedComponent` used to broker.
+//
+// WHY IT EXISTS. `Animated.View` is `createAnimatedComponent(View)`: a wrapper whose whole job is
+// to keep an `AnimatedProps` leaf alive beside a base COMPONENT. Once a primitive is a bare
+// intrinsic tag there is no component to wrap, so every `Animated.*` built that way loses its
+// base. The two halves the wrapper actually brokered — the value graph and the node's Fabric view
+// tag — are both already engine-side (`animated/props.ts`, `commit.ts`'s `getNativeTag`), so the
+// wrapper was standing between two things that live in the same room. An app writes
+//
+//     <view style={{ opacity: someAnimatedValue }} />
+//
+// and `routeProp` resolves it here: publish the current value so the first paint is concrete,
+// subscribe the leaf so every frame lands as one targeted `setNativeProps` commit, and tear the
+// subscription down when the node leaves the tree for good.
+//
+// THE PRECEDENT IT FOLLOWS is `routeProp`'s own `isStyleCallback` branch: a `style` function is
+// already a value the engine INTERPRETS rather than forwards, resolved at both values of
+// `pressed`. An AnimatedNode is the same shape of problem one step further — the resolution is
+// continuous rather than two-valued, so it needs a subscription instead of a second call.
+//
+// THE CYCLE IS DELIBERATE, and it is the one `node.ts` already carries with `commit.ts`: node.ts
+// imports this module for `routeProp`, and this module reaches back into node.ts for `setProp`.
+// Neither side touches the other at module-evaluation time — only inside a function body — so
+// every loader resolves it. The alternative, a
+// `registerAnimatedResolver` installed from elsewhere, is exactly the load-time-side-effect shape
+// Metro's `inlineRequires` drops in release builds (CLAUDE.md; and see `graph.ts`'s note on why
+// `AnimatedInterpolation` lives next to its base class).
+import { AnimatedNode } from './graph.js';
+import { AnimatedStyle } from './style.js';
+import { attachNativeEventHandler } from './event.js';
+import { createAnimatedLeafLifecycle, } from './leaf-lifecycle.js';
+import { setProp } from '../node.js';
+import { propOf, subtreesOf } from '../host-access.js';
+const bindings = new WeakMap();
+// Nodes the commit sweep tore down, whether or not they carried a binding — the twin of
+// host-behavior.ts's `tornDown`, and marked for every node for the same reason: the node a
+// framework re-inserts is usually a plain container whose DESCENDANT holds the subscription.
+const parked = new WeakSet();
+// The gate, matching `hasHostBehaviors`. `removeChild` and the two inserts read it on every call,
+// so an app that animates nothing must pay one boolean read rather than a WeakMap probe.
+let anyBinding = false;
+export function hasAnimatedBindings() {
+    return anyBinding;
+}
+// Only what `AnimatedProps` can actually bind: a prop that IS a node, or a `style` holding one.
+// Deliberately NOT a general deep walk — an arbitrary prop bag can hold an app object with a
+// cycle in it, and a walk that never terminates would be a hang on the engine's hottest path.
+function styleHoldsAnimated(style) {
+    if (Array.isArray(style))
+        return style.some(styleHoldsAnimated);
+    if (typeof style !== 'object' || style === null)
+        return false;
+    for (const key of Object.keys(style)) {
+        const entry = Reflect.get(style, key);
+        if (entry instanceof AnimatedNode)
+            return true;
+        // `transform: [{ translateX: node }]` — the one nesting `AnimatedTransform` reads.
+        if (key !== 'transform' || !Array.isArray(entry))
+            continue;
+        for (const item of entry) {
+            if (typeof item !== 'object' || item === null)
+                continue;
+            for (const inner of Object.keys(item)) {
+                if (Reflect.get(item, inner) instanceof AnimatedNode)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+// The value to PUBLISH now, or undefined when there is nothing animated after all. A false
+// positive from the scan above lands here and is turned away, so the raw value still reaches
+// `setProp` unchanged and nothing new can break.
+function rasterize(key, value) {
+    if (value instanceof AnimatedNode)
+        return value.__getValue();
+    if (key !== 'style')
+        return undefined;
+    return AnimatedStyle.from(value)?.__getValue();
+}
+function reconcile(node, binding) {
+    parked.delete(node);
+    if (Object.keys(binding.raw).length > 0) {
+        // `wantsNative: false` — nothing here forces the native driver. A leaf becomes native by
+        // CASCADE, from the value it is a child of (`AnimatedWithChildren.__addChild` /
+        // `__connectNativeChildren`), which is what makes `useNativeDriver` on the animation the only
+        // thing that decides. The wrapper's own `wantsNative` was keyed on
+        // `passthroughAnimatedPropExplicitValues`, a wrapper-ism with no meaning on a bare tag.
+        //
+        // And NO `scheduleNativeBind`, though a prop write always precedes the node's first commit:
+        // nothing the bind does needs a Fabric tag on the spot. `setNativeView` only stores the
+        // target, `connectToView` defers itself through `pendingViewConnects` + the post-commit hook
+        // (`props.ts`), and `attachNativeEventHandler` wraps its own `whenCommitted`. A deferral here
+        // would be unfalsifiable code, so it is not here.
+        binding.lifecycle.reconcile(binding.raw, node, false);
+        return;
+    }
+    binding.lifecycle.teardown();
+    bindings.delete(node);
+    // Fabric may flatten a view again once nothing animates it.
+    setProp(node, 'collapsable', undefined);
+}
+// A style layer a HOST BEHAVIOR owns on its own node, composed OVER the app's style.
+//
+// WHY IT IS NOT AN ORDINARY PROP. TouchableOpacity's press fade is an AnimatedValue that has to
+// beat whatever `opacity` the caller's own style asks for, and `fabricProps` hoists the style slot
+// AFTER every plain prop — so a top-level `opacity` loses to `style={{opacity: 0.6}}`, silently and
+// only for the styled call sites. The layer has to sit INSIDE the style, above the author's.
+//
+// AND IT CANNOT SHARE `raw.style` WITH THE APP. The leaf keys its bound props by name, so the app's
+// next plain `style` write would find `raw.style` holding nothing animated and tear the behavior's
+// binding down. Composing here means that write still sees an animated style — ours — and
+// re-registers the pair instead.
+const behaviorStyles = new WeakMap();
+// The gate, matching `anyBinding`: one boolean read on the style branch of every prop write in an
+// app whose behaviors own no animated layer, which is nearly all of them.
+let anyBehaviorStyle = false;
+function withBehaviorStyle(node, style) {
+    if (!anyBehaviorStyle)
+        return style;
+    const layer = behaviorStyles.get(node);
+    return layer === undefined ? style : [style, layer];
+}
+/**
+ * Give a node a behavior-owned animated style layer, or drop it by passing `undefined`.
+ *
+ * The seam `<touchable-opacity>` needs: RN runs its press fade from an `Animated.View` whose
+ * style is `[props.style, {opacity: anim}]` (TouchableOpacity.js:302), and a tag has no such
+ * wrapper. The layer is bound to the leaf, never folded into `node.props.style` — so the behavior
+ * can still read the AUTHOR's resting opacity back without seeing its own fade.
+ */
+export function setAnimatedBehaviorStyle(node, style) {
+    if (style === undefined)
+        behaviorStyles.delete(node);
+    else {
+        behaviorStyles.set(node, style);
+        anyBehaviorStyle = true;
+    }
+    // Re-register against the style standing right now, so the pair the leaf holds is always
+    // (author, layer) whichever of the two moved last.
+    bindAnimatedValue(node, 'style', propOf(node, 'style'));
+}
+/**
+ * Resolve an animated value in a prop, returning what should be published for it.
+ *
+ * Returns its input by IDENTITY when the value holds nothing animated, so `routeProp` can call it
+ * unconditionally and every downstream branch — class, style, activeStyle, `on*`, `setProp` —
+ * keeps seeing a plain value and needs no change.
+ */
+export function bindAnimatedValue(node, key, value) {
+    const existing = bindings.get(node);
+    const bound = key === 'style' ? withBehaviorStyle(node, value) : value;
+    const isAnimated = bound instanceof AnimatedNode ||
+        (key === 'style' && styleHoldsAnimated(bound));
+    if (!isAnimated) {
+        // A prop that USED to be animated and no longer is: drop it, or the leaf keeps writing a
+        // stale value over whatever the app just wrote.
+        if (existing !== undefined && Object.hasOwn(existing.raw, key)) {
+            delete existing.raw[key];
+            reconcile(node, existing);
+        }
+        return value;
+    }
+    const binding = existing ?? {
+        raw: {},
+        lifecycle: createAnimatedLeafLifecycle('host'),
+    };
+    if (existing === undefined) {
+        bindings.set(node, binding);
+        anyBinding = true;
+    }
+    binding.raw[key] = bound;
+    // Fabric flattens a view whose props do not require one, and a flattened view has no tag for
+    // the native driver to bind to. RN forces the same flag from `reduceAnimatedProps`.
+    setProp(node, 'collapsable', false);
+    reconcile(node, binding);
+    // The AUTHOR's value, rasterized — never the composed one. A behavior's layer reaches Fabric
+    // through the per-frame `setNativeProps` merge, and folding it in here would publish the fade's
+    // own output as the node's declarative style, which the behavior then reads back as resting.
+    const own = rasterize(key, value);
+    return own === undefined ? value : own;
+}
+const eventBindings = new WeakMap();
+/**
+ * Bind a native-driven `Animated.event` handler written as an `on*` prop. A no-op for every other
+ * handler, so `routeProp` calls it for any `on*` name behind the same one-boolean gate.
+ */
+export function bindAnimatedEvent(node, propName, handler) {
+    const bound = eventBindings.get(node);
+    if (bound !== undefined) {
+        const current = bound.get(propName);
+        if (current !== undefined) {
+            // A framework hands a fresh closure most renders; only a different handler is worth a
+            // detach/attach round trip through the native module.
+            if (current.handler === handler)
+                return;
+            current.attachment.detach();
+            bound.delete(propName);
+        }
+    }
+    // Returns undefined unless this really is a native-driven AnimatedEvent, and defers itself
+    // through `whenCommitted` until the node has a Fabric tag — no second deferral invented here.
+    const attachment = attachNativeEventHandler(node, propName, handler);
+    if (attachment === undefined)
+        return;
+    const map = bound ?? new Map();
+    if (bound === undefined)
+        eventBindings.set(node, map);
+    map.set(propName, { handler, attachment });
+    // The same gate the props half raises: teardown and re-arm are both behind it.
+    anyBinding = true;
+}
+// Re-attach against the tag the node has NOW. The old handles are spent — each detached against
+// the tag it attached with, which is the point — so re-arming is a fresh attach, not a resume, and
+// it goes back through `bindAnimatedEvent` rather than growing a second attach path. Only a node
+// the sweep parked reaches here, and parking always detaches, so clearing without detaching first
+// drops nothing live.
+function reattachAnimatedEvents(node) {
+    const bound = eventBindings.get(node);
+    if (bound === undefined)
+        return;
+    const spent = [...bound];
+    bound.clear();
+    for (const [propName, binding] of spent)
+        bindAnimatedEvent(node, propName, binding.handler);
+}
+/**
+ * Release a node's animated subscription. Called per node from the commit sweep, which is where a
+ * genuine removal is first distinguishable from a framework spelling a move as remove-then-insert
+ * (host-behavior.ts, `markDetachCandidate`).
+ */
+export function detachAnimatedProps(node) {
+    // The sweep runs for host behaviors too, so an app that animates nothing must not pay a WeakSet
+    // insert per removed node to learn it has nothing to release.
+    if (!anyBinding)
+        return;
+    parked.add(node);
+    bindings.get(node)?.lifecycle.teardown();
+    const bound = eventBindings.get(node);
+    if (bound === undefined)
+        return;
+    for (const binding of bound.values())
+        binding.attachment.detach();
+}
+/**
+ * Re-arm a subtree the sweep tore down and the framework put back — Svelte parks LIVE nodes
+ * offscreen across commits and returns them with their props unwritten, so without this the
+ * animation stops with nothing red anywhere.
+ *
+ * A WeakSet miss and no walk at all for every node in a freshly built tree, which is the path that
+ * runs ~9 000 times per benchmark create.
+ */
+export function reattachAnimatedProps(node) {
+    if (!parked.has(node))
+        return;
+    // FLAT, one host read for the whole subtree — the twin of `reattachSubtree` in `host-behavior.ts`,
+    // which was converted when the teardown sweep turned out to be paying a JSI crossing per node.
+    // This one was missed then. It is reached far less often (the guard above is a WeakSet miss for
+    // every node of a freshly built tree) but costs the same per node when it does run, and a parked
+    // subtree is a whole screen's worth in the case it exists for — Svelte parking live nodes
+    // offscreen across commits.
+    //
+    // The recursion stopped at an unparked node where this skips it and carries on; the two agree
+    // because `parked` is filled by `detachAnimatedProps` over a whole detached subtree, so a node in
+    // it has its descendants in it.
+    for (const each of subtreesOf([node]))
+        reattachOneAnimated(each);
+}
+function reattachOneAnimated(node) {
+    if (!parked.has(node))
+        return;
+    parked.delete(node);
+    const binding = bindings.get(node);
+    if (binding !== undefined)
+        reconcile(node, binding);
+    reattachAnimatedEvents(node);
+}

package/build/animated/index.d.ts

@@ -4,7 +4,7 @@ export { AnimatedValueXY, type IValueXY } from './value-xy';
 export { AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, add, subtract, multiply, divide, modulo, diffClamp, } from './operators';
 export { AnimatedEvent, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, type IEventConfig, type IEventListener, type IAnimatedEventHandler, type INativeEventAttachment, } from './event';
 export { AnimatedColor, type IRgbaValue, type IColorInput } from './color';
-export { Easing, type IEasingFunction } from './easing';
+export { Easing, type IEasing, type IEasingFunction } from './easing';
 export { createNumericInterpolation, createInterpolation, checkValidRanges, type IInterpolationConfig, type IExtrapolateType, } from './interpolation';
 export type { IAnimation, IEndCallback, IEndResult } from './animation';
 export { TimingAnimation } from './animations/timing';

package/build/animated/leaf-lifecycle.js

@@ -1,6 +1,6 @@
 // The AnimatedProps leaf lifecycle every Animated.* wrapper needs: build a leaf from the current
-// props, swap it into the value graph, bind it to the committed node, go native when asked, and
-// rebind native event props. Framework-agnostic on purpose - it knows nothing about hooks,
+// props, swap it into the value graph, bind it to the committed node, and go native when asked.
+// Framework-agnostic on purpose - it knows nothing about hooks,
 // effects, change detection or reactivity, only the engine's own Animated primitives.
 //
 // WHY THIS LIVES IN THE ENGINE. It used to live four times, once per adapter (React's
@@ -15,7 +15,6 @@
 // What stays in the adapter: WHEN to call reconcile (an effect, onUpdated, ngOnChanges, a $effect)
 // and HOW to find the host node (a ref, a ViewChild, a shim). Everything below is the same for all.
 import { AnimatedProps } from './props.js';
-import { attachNativeEventHandler } from './event.js';
 import { dlog } from '../debug.js';
 // Diagnostic-only, DEBUG-gated: a process-wide sequence number so every reconcile call across
 // every Animated.* instance in a log dump is individually identifiable and orderable.
@@ -66,7 +65,6 @@ function describeTransform(value) {
 }
 export function createAnimatedLeafLifecycle(label) {
     let attached = null;
-    let eventDetachers = [];
     // Diagnostic-only: the last node identity, plus a reentrancy flag to catch reconcile() being
     // called AGAIN from inside its own call stack - the smoking-gun shape for a synchronous
     // same-flush loop, as opposed to merely "called often".
@@ -77,11 +75,6 @@ export function createAnimatedLeafLifecycle(label) {
     let lastWantsNative = false;
     // Canceller for a native bind the caller deferred and that has not run yet.
     let cancelPendingBind;
-    function detachEvents() {
-        for (const detach of eventDetachers)
-            detach();
-        eventDetachers = [];
-    }
     return {
         reconcile(props, node, wantsNative, scheduleNativeBind) {
             const seq = ++globalReconcileSeq;
@@ -142,23 +135,19 @@ export function createAnimatedLeafLifecycle(label) {
                 if (attached !== null && attached !== newLeaf)
                     attached.__detach();
                 attached = newLeaf;
-                // The native half, which a caller may defer. Rebinds events each reconcile so a new inline
-                // event re-attaches, detaching first so the prior binding does not leak;
-                // attachNativeEventHandler no-ops unless the prop really is a native event handler on a
-                // committed node, so the JS path stays the fallback.
+                // The native half, which a caller may defer.
+                //
+                // It used to native-attach every `Animated.event` prop here as well. It must not any more:
+                // a wrapper hands those same props DOWN to a host element, so they reach `routeProp`,
+                // which binds them itself (`host-binding.ts`, `bindAnimatedEvent`) — that is what makes a
+                // bare `<scroll-view onScroll={…} />` work with no wrapper at all. Doing it here too
+                // registered the SAME mapping twice on one view tag, caught by the Vue and Svelte
+                // wrapper tests the day the engine half landed.
                 const bindNative = () => {
                     if (node !== null)
                         newLeaf.setNativeView(node);
                     if (wantsNative)
                         newLeaf.__makeNative();
-                    detachEvents();
-                    if (node === null)
-                        return;
-                    for (const key of Object.keys(props)) {
-                        const attachment = attachNativeEventHandler(node, key, props[key]);
-                        if (attachment !== undefined)
-                            eventDetachers.push(attachment.detach);
-                    }
                 };
                 cancelPendingBind?.();
                 cancelPendingBind = undefined;
@@ -175,7 +164,6 @@ export function createAnimatedLeafLifecycle(label) {
         teardown() {
             cancelPendingBind?.();
             cancelPendingBind = undefined;
-            detachEvents();
             if (attached !== null) {
                 attached.__detach();
                 attached = null;

package/build/animated/mock.d.ts

@@ -16,25 +16,7 @@ export declare const AnimatedMock: {
     Value: typeof AnimatedValue;
     ValueXY: typeof AnimatedValueXY;
     Color: typeof AnimatedColor;
-    Easing: {
-        step0(n: number): number;
-        step1(n: number): number;
-        linear(t: number): number;
-        ease(t: number): number;
-        quad(t: number): number;
-        cubic(t: number): number;
-        poly(n: number): import("./easing").IEasingFunction;
-        sin(t: number): number;
-        circle(t: number): number;
-        exp(t: number): number;
-        elastic(bounciness?: number): import("./easing").IEasingFunction;
-        back(s?: number): import("./easing").IEasingFunction;
-        bounce(t: number): number;
-        bezier(x1: number, y1: number, x2: number, y2: number): import("./easing").IEasingFunction;
-        in(easing: import("./easing").IEasingFunction): import("./easing").IEasingFunction;
-        out(easing: import("./easing").IEasingFunction): import("./easing").IEasingFunction;
-        inOut(easing: import("./easing").IEasingFunction): import("./easing").IEasingFunction;
-    };
+    Easing: import("./easing").IEasing;
     timing: typeof timing;
     spring: typeof spring;
     decay: typeof decay;

package/build/animated/props.js

@@ -12,7 +12,7 @@
 // a `update` function off the node, and under useDefineForClassFields a field
 // initialiser would shadow it and break subclassing. (See shared graph.ts leafUpdate.)
 import { AnimatedNode, AnimatedWithChildren } from './graph.js';
-import { setNativeProps, getNativeTag } from '../commit.js';
+import { setNativeProps, getNativeTag } from '../imperative.js';
 import { isSymbioteNode } from '../node.js';
 import { registerPostCommit } from '../post-commit.js';
 import { nativeAnimated, } from './native/native-animated.js';