@symbiote-native/engine 0.4.0 → 0.5.0

package/build/accessibility-props.d.ts

@@ -1,3 +1,4 @@
+export declare const ARIA_ALIAS_KEYS: readonly string[];
 /**
  * Whether one key is an alias this fold consumes. `startsWith` rather than a Set lookup: this runs
  * on `setProp`, the hottest write path in the engine (32 001 writes on one benchmark create), and

package/build/accessibility-props.js

@@ -55,7 +55,11 @@ const ROLE_TO_ACCESSIBILITY_ROLE = {
     timer: 'timer',
     toolbar: 'toolbar',
 };
-const ARIA_KEYS = [
+// Exported so a behavior that folds a DIFFERENT node's bag can name them without restating the
+// list. `slotDerived` (host-behavior.ts) takes prop NAMES, so a primitive whose payload derives
+// from an owner's aria props has to enumerate them — and a second hand-written copy is exactly what
+// `.claude/rules/adapter-parity-audit.md` records going stale one member at a time.
+export const ARIA_ALIAS_KEYS = [
     'role',
     'aria-label',
     'aria-labelledby',
@@ -75,8 +79,8 @@ const ARIA_KEYS = [
 // An indexed loop rather than `.some(key => …)`: the callback captures `props`, so a closure is
 // allocated per call, and this is the gate on a path that runs once per node.
 function hasAnyAriaKey(props) {
-    for (let index = 0; index < ARIA_KEYS.length; index += 1) {
-        if (props[ARIA_KEYS[index]] !== undefined)
+    for (let index = 0; index < ARIA_ALIAS_KEYS.length; index += 1) {
+        if (props[ARIA_ALIAS_KEYS[index]] !== undefined)
             return true;
     }
     return false;
@@ -127,8 +131,8 @@ export function foldAriaProps(props) {
     const ariaValueMin = bag['aria-valuemin'];
     const ariaValueNow = bag['aria-valuenow'];
     const ariaValueText = bag['aria-valuetext'];
-    for (let index = 0; index < ARIA_KEYS.length; index += 1) {
-        bag[ARIA_KEYS[index]] = undefined;
+    for (let index = 0; index < ARIA_ALIAS_KEYS.length; index += 1) {
+        bag[ARIA_ALIAS_KEYS[index]] = undefined;
     }
     // RULE ONE, for every scalar: the explicit prop WINS, the alias only fills a hole.
     if (typeof ariaLabelledBy === 'string' &&

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 a lowered `TouchableOpacity` 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,263 @@
+// 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';
+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 a lowered `TouchableOpacity` 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', node.props.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;
+    parked.delete(node);
+    const binding = bindings.get(node);
+    if (binding !== undefined)
+        reconcile(node, binding);
+    reattachAnimatedEvents(node);
+    for (const child of node.children)
+        reattachAnimatedProps(child);
+}

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/commit.js

@@ -21,7 +21,8 @@ import { registerPostCommit, runPostCommitHooks } from './post-commit.js';
 import { fabricProps } from './fabric-props.js';
 import { isRecord } from './type-guards.js';
 import { isAriaAliasKey } from './accessibility-props.js';
-import { runDeferredAttaches, sweepDetachedBehaviors } from './host-behavior.js';
+import { runCommittedHooks, runDeferredAttaches, sweepDetachedBehaviors, teardownSubtree, } from './host-behavior.js';
+import { detachAnimatedProps } from './animated/host-binding.js';
 // Re-exported from ./platform-color so callers don't need to change their import path.
 export { processColor, setColorProcessor } from './platform-color/index.js';
 // Per-commit work counters, surfaced via dlog so a device run can prove the
@@ -186,6 +187,15 @@ function jsonEqual(a, b) {
         return false;
     return keys.every(key => key in b && jsonEqual(a[key], b[key]));
 }
+// The committed-state record (IMirror) and its guarded accessor (committedOf) live on the node
+// itself, in node.ts - see the `committed` field there for why the side table was collapsed into a
+// field, and committedOf's doc comment for the node-identity check that replaced the WeakMap miss.
+// Everything below reads it exclusively through committedOf and writes it as `node.committed`.
+// The predicate both behavior drains take. Passed in rather than imported by `host-behavior.ts`,
+// keeping that dependency one-directional — this module already imports from it, and a cycle is a
+// live hazard under Metro's `inlineRequires`. Hoisted to module scope because two call sites need
+// the identical question.
+const isNodeCommitted = (node) => committedOf(node) !== undefined;
 function isSkippedAtCommit(node) {
     return isAnchor(node) || isEmptyRawText(node);
 }
@@ -515,8 +525,16 @@ export function disposeRoot(rootTag) {
     // Drop any setNativeProps writes still queued for this surface: their flush is a microtask away
     // and would otherwise commit into a container that no longer exists, re-creating it from scratch.
     pendingByRoot.delete(rootTag);
-    if (rootContainers.delete(rootTag))
-        dlog(`root container disposed root=${rootTag}`);
+    const container = rootContainers.get(rootTag);
+    if (container === undefined)
+        return;
+    // BEFORE the delete, which is the only reason the subtree is still reachable. An unmount removes
+    // no child, so `sweepDetachedBehaviors` never hears about these nodes — without this every one of
+    // them keeps its `afterCommit` registration and its timers, and a restarted surface's commits
+    // drain the dead one's hooks forever (`.claude/rules/unmount-does-not-sweep-host-behaviors.md`).
+    teardownSubtree(container, detachAnimatedProps);
+    rootContainers.delete(rootTag);
+    dlog(`root container disposed root=${rootTag}`);
 }
 export function commitChildren(rootTag, children) {
     // The wrapper holds the surface's top-level children; reconcile walks from it so the
@@ -546,7 +564,7 @@ function commitContainer(rootTag) {
     // that `removeChild` unlinked is now either back under a parent (a framework spelling a move as
     // remove-then-reinsert) or gone for good. Costs one Set-size read until an app registers its
     // first host behavior. See host-behavior.ts for why removal cannot answer this itself.
-    sweepDetachedBehaviors(container.children);
+    sweepDetachedBehaviors(container.children, detachAnimatedProps);
     stats.created = 0;
     stats.cloneProps = 0;
     stats.cloneChildren = 0;
@@ -568,20 +586,23 @@ function commitContainer(rootTag) {
     // The container's identity is stable, so its un-cloned flag is the no-op signal:
     // an over-scheduled commit that touched nothing makes zero native calls.
     //
-    // TRAP FOR BEHAVIOR AUTHORS, and it cost two iterations to find: this return is ALSO the gate on
-    // `runDeferredAttaches` and `runPostCommitHooks` below. A host behavior that calls
-    // `requestCommitFor(node)` WITHOUT writing a prop therefore never reaches its `afterCommit` /
-    // `attachAfterCommit` half — the commit it asked for is a no-op, and a no-op returns here.
+    // TRAP FOR BEHAVIOR AUTHORS, and it cost two iterations to find: this return is the gate on
+    // `runPostCommitHooks` and `runDeferredAttaches` below. Both exist to retry once FRESH FABRIC TAGS
+    // are assigned, and a commit that made zero native calls assigned none — so gating them here is
+    // correct, and hoisting them above this line would run every deferred hook on every
+    // over-scheduled commit, which is the common case.
+    //
+    // `afterCommit` is NOT in that group and was gated with them by accident until 2026-09-10. It asks
+    // only "props were published", which a no-op commit satisfies, and gating it made it unreachable
+    // for exactly the props a behavior OWNS: a fold that strips a prop (TouchableOpacity's `disabled`,
+    // Button's `title`/`color`) makes its own commit byte-identical, so the hook that must react to
+    // the flip is the one the flip cannot wake. It is drained on both paths now.
     //
-    // That is correct for what the hooks are FOR: they exist to retry once fresh Fabric tags are
-    // assigned, and a commit that made zero native calls assigned none. So the fix is not to hoist
-    // them above this line — that would run every deferred hook on every over-scheduled commit, which
-    // is the common case. A behavior needing a turn of the loop with nothing to write should schedule
-    // its own (`queueMicrotask`, as Switch's snap-back and Angular's `snapBackIfNeeded` both do) and
-    // keep `afterCommit` registered for the case a microtask cannot reach: a prop change with no
-    // preceding native event.
+    // A behavior needing a turn of the loop with nothing to write at all may still schedule its own
+    // (`queueMicrotask`, as Switch's snap-back and Angular's `snapBackIfNeeded` both do).
     if (!result.changed) {
         dlog(`commit root=${rootTag} no-op (skipped completeRoot)`);
+        runCommittedHooks(isNodeCommitted);
         return;
     }
     const childSet = slot.createChildSet(rootTag);
@@ -594,10 +615,11 @@ function commitContainer(rootTag) {
     runPostCommitHooks();
     // The same moment, for the half of a host behavior that could not run at `attach`. A behavior
     // whose setup needs a Fabric tag (a view command, a native Animated binding, an event attach)
-    // declares `attachAfterCommit` and is drained here. `committedOf` is passed as the predicate
-    // rather than imported by `host-behavior.ts`, keeping that dependency one-directional — this
-    // module already imports from it, and a cycle is a live hazard under Metro's `inlineRequires`.
-    runDeferredAttaches(node => committedOf(node) !== undefined);
+    // declares `attachAfterCommit` and is drained here.
+    runDeferredAttaches(isNodeCommitted);
+    // After the setup half, never before it: a node carrying both hooks has `attachAfterCommit` seed
+    // the mirrors `afterCommit` then compares against. See `runCommittedHooks`.
+    runCommittedHooks(isNodeCommitted);
     if (isDebug()) {
         const mode = stats.created > 0 && stats.reused === 0 ? 'full' : 'incremental';
         dlog(`commit root=${rootTag} ${mode} ` +
@@ -811,6 +833,12 @@ function commitTargeted(nodes) {
     profile.commits += 1;
     profile.nodesVisited += cloned.size;
     runPostCommitHooks();
+    // Same reasoning as the container path's drain, reached from the other end: this commit
+    // published props, which is all `afterCommit` asks. Missing here it was unreachable for a
+    // behavior whose only write is its own bookkeeping — no framework prop changes, so no container
+    // commit follows to drain it. `runDeferredAttaches` deliberately stays out: a targeted commit
+    // only happens after a container commit has already assigned tags and drained them.
+    runCommittedHooks(isNodeCommitted);
     dlog(`commit targeted root=${rootTag} leaves=${writes.length} ` +
         `union=${branches.size}`);
     return true;