@symbiote-native/components 3.1.1 → 3.1.3

package/build/behaviors/pressable.js

@@ -1,20 +1,10 @@
 // The press machine as an ENGINE-NODE behavior, so a pressable can be an intrinsic tag instead of
-// a framework component (`.claude/rules/host-primitive-tier.md`, tier 2). Written once; every
-// adapter inherits it by registering, and none re-implements it.
-//
-// The machine itself is unchanged and still shared with the component path — `createPressRuntime`
-// / `createPressHandlers` in `../state/pressable`. What is new is only WHERE its lifecycle lives:
-// on the engine node rather than in a component instance.
-//
-// REGISTRATION IS THE HAZARD, not the machine. Metro enables `inlineRequires` in production only,
-// moving a `require` to the first place its binding is used as a VALUE, and a barrel's
-// `export { X } from './x'` compiles to a lazy getter. A module whose only job is a side effect is
-// never named as a value, so re-exporting it means it NEVER RUNS in a release build — dev perfect,
-// release silently pressless. Each adapter therefore keeps its own `src/register.ts` calling
-// `registerPressableBehavior()`, and its entry does a bare `import './register';` that the barrel
-// does NOT re-export. A bare `import './register';` sitting NEXT TO such a re-export does not work
-// either: Babel merges the two imports of one specifier and the merged dependency stays lazy.
-import { appListenerFor, dispatchViewCommand, dlog, Platform, propOf, registerHostBehavior, requestCommitFor, setBehaviorListener, setNodePressed, propsOf, } from '@symbiote-native/engine';
+// a framework component. Written once; every adapter inherits it by registering, none re-implements
+// it. The machine itself is unchanged and still shared with the component path.
+// Registration, not the machine, is the hazard: Metro's inlineRequires makes a barrel re-export of
+// a side-effect-only module never run in a release build. Each adapter keeps its own
+// `src/register.ts` calling registerPressableBehavior(), reached only by a bare side-effect import.
+import { appListenerFor, dispatchViewCommand, dlog, Platform, propOf, registerHostBehavior, requestCommitFor, setNodeDispatch, setNodePressed, propsOf, } from '@symbiote-native/engine';
 import { createPressHandlers, createPressRuntime, disposePressRuntime, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, } from '../state/pressable.js';
 import { buildPressableListeners } from '../view/render-pressable/index.js';
 export const PRESSABLE_TAG = 'pressable';
@@ -56,10 +46,9 @@ function asRectOffset(value) {
 function isPressHandler(value) {
     return typeof value === 'function';
 }
-// Narrowed field by field rather than cast: the bag arrives as `unknown` off `propOf`. A local
-// twin of the guard each adapter keeps for its own attrs (Vue's `asAccessibilityState`) — exported
-// to the sibling behaviors that fold the same bag, and deliberately NOT to the shared barrel, which
-// every adapter re-exports wholesale: a narrowing helper is not API anyone should be able to import.
+// Narrowed field by field rather than cast: the bag arrives as `unknown` off propOf. Exported to
+// sibling behaviors folding the same bag, deliberately NOT to the shared barrel — a narrowing
+// helper isn't API anyone should import.
 export function asAccessibilityState(value) {
     if (!isRecord(value))
         return undefined;
@@ -76,36 +65,19 @@ export function asAccessibilityState(value) {
         state.expanded = value.expanded;
     return state;
 }
-// THE PAYLOAD FOLD MOVED TO THE ENGINE — `foldPressableProps` in `SymbioteFabricProps.cpp`, and
-// its contract is `core/engine/cpp/tests/js/pressable-payload.itest.ts`. It is not re-implemented
-// here in any form, which is the point: `disabled` -> `accessibilityState`, `accessible`/`focusable`
-// defaulting on, the Android ripple config, and the nine machine-only keys being kept out of the
-// payload are all functions of the TAG alone. That is user-agent behavior — RN does it for every
-// Pressable in every app — and it belongs beside the tree, like a browser's `<button>`.
-//
-// It cost a trip: a `payloadFold` marshals the whole bag out and the whole bag back, ~17 us per
-// pressable per commit, and a benchmark row carries two.
-//
-// What is still here is the MACHINE, which is where a browser keeps it too: timers, the responder
-// claim, hit-slop retention, and the callbacks into app code.
-//
-// The one thing that did NOT move with it is `hitSlop`, and that is deliberate — it is a real
-// native View prop, so it never was part of the fold.
-// RN makes every pressable accessible unless the app opts OUT — `Pressable.js:252`
-// (`accessible: accessible !== false`), and the whole Touchable family repeats it verbatim
-// (`TouchableOpacity.js:303`, `TouchableHighlight.js:337`). `!== false` rather than `?? true`, so
-// only a literal `false` opts out and an explicit `undefined` still reads as accessible.
-//
-// Nothing in this repo did it until 2026-09-09, so a Pressable reached a screen reader as a plain
-// view unless the app wrote the prop. Exported so anything composing this tag can say it too.
+// The payload fold moved to the engine (foldPressableProps in SymbioteFabricProps.cpp), not
+// re-implemented here: disabled -> accessibilityState, accessible/focusable defaulting on, the
+// ripple config and the machine-only keys are all functions of the TAG alone, user-agent behavior.
+// What's still here is the MACHINE: timers, the responder claim, hit-slop retention, callbacks
+// into app code. `hitSlop` did NOT move with the fold — it's a real native View prop.
+// RN makes every pressable accessible unless the app opts OUT (`accessible !== false`), and the
+// whole Touchable family repeats it. `!== false` not `?? true`, so only a literal `false` opts out.
 export function accessibleUnlessOptedOut(props) {
     return props.accessible !== false;
 }
-// From the STASH, not from the props. Every name below is in `ownedListeners`, so `routeProp`
-// diverts the app's `onPress` away from `node.listeners` (where it would evict the behavior's own
-// dispatcher) and into the stash — which makes the stash the only place it exists. Reading
-// `propOf` here returns undefined for every callback and every press silently does nothing:
-// the behavior runs, the machine runs, and it calls nobody.
+// From the STASH, not the props: every name below is in ownedListeners, so routeProp diverts the
+// app's onPress away from node.listeners into the stash. Reading propOf here would return
+// undefined for every callback and every press would silently call nobody.
 function callbackAt(node, event) {
     const value = appListenerFor(node, event);
     return isPressHandler(value) ? value : undefined;
@@ -121,29 +93,19 @@ function configFor(node) {
         onPressOut: callbackAt(node, 'pressOut'),
         onPressMove: callbackAt(node, 'pressMove'),
         onLongPress: callbackAt(node, 'longPress'),
-        // Pressability.js:471-474 — `normalizeDelay(authored, 10, DEFAULT_LONG_PRESS_DELAY_MS -
-        // delayPressIn)`. The subtraction applies only to the FALLBACK, never to an authored value —
-        // it exists so the long-press threshold, timed from the grant that also arms
-        // `unstable_pressDelay`, lands at a constant 500ms from touch-down by default, not
-        // 500ms + unstable_pressDelay. See `createPressHandlers`'s `handlePressIn` for the other half
-        // (the timer must be ARMED at grant, not after the pressDelay fires, or this compensation
-        // does nothing).
+        // The subtraction applies only to the FALLBACK, never an authored value — it keeps the
+        // long-press threshold at a constant 500ms from touch-down by default, not
+        // 500ms + unstable_pressDelay (see createPressHandlers.handlePressIn for the other half).
         delayLongPress: Math.max(10, numberOr(propOf(node, 'delayLongPress'), DEFAULT_DELAY_LONG_PRESS_MS - unstablePressDelay)),
         unstable_pressDelay: unstablePressDelay,
-        // RN's Touchables own the deactivation floor in their OWN machine and hand Pressability
-        // `minPressDuration: 0` (TouchableOpacity.js:195). While they were wrappers they passed it as
-        // an internal input; on the tag there is nowhere else to say it, so the floor has to be a
-        // readable prop or every Touchable holds its fade for the machine's 130 ms default.
+        // RN's Touchables own the deactivation floor in their own machine, handing Pressability
+        // `minPressDuration: 0`. On the tag there's nowhere else to say it, so it's a readable prop.
         minPressDuration: numberOr(propOf(node, 'minPressDuration'), DEFAULT_MIN_PRESS_DURATION_MS),
         hitSlop: asRectOffset(propOf(node, 'hitSlop')),
         pressRetentionOffset: asRectOffset(propOf(node, 'pressRetentionOffset')),
-        // Pressable.js's own name is `android_disableSound`; every composed touchable (Highlight,
-        // NativeFeedback, WithoutFeedback, Button) instead forwards vendor's `touchSoundDisabled` to
-        // this same config field (`TouchableHighlight.js:205`, `TouchableWithoutFeedback.js:199`,
-        // `TouchableNativeFeedback.js:228`). `node` here is whichever tag AUTHORS the prop — itself for
-        // a plain pressable/highlight/button, the owner for a clone-onto-child touchable, since
-        // `configFor` is always called with that source — so reading both names off it resolves
-        // correctly for every composition without a per-tag override.
+        // Pressable's own name is `android_disableSound`; every composed touchable instead forwards
+        // `touchSoundDisabled` to this same field. `node` here is whichever tag AUTHORS the prop, so
+        // reading both names resolves correctly for every composition without a per-tag override.
         android_disableSound: booleanOr(propOf(node, 'android_disableSound')) ??
             booleanOr(propOf(node, 'touchSoundDisabled')),
     };
@@ -164,12 +126,8 @@ function hotspotAt(nativeEvent, key) {
     const value = nativeEvent[key];
     return typeof value === 'number' ? value : 0;
 }
-/**
- * The Android ripple's three view commands around the app's callbacks (TNF :230-252,
- * useAndroidRippleForView.js:77-104). The JS responder takes the touch before Android's own
- * pressed handling, so without them the ripple never animates. Hotspot first: it starts under
- * the finger.
- */
+// The Android ripple's three view commands around the app's callbacks. The JS responder takes
+// the touch before Android's own pressed handling, so without them the ripple never animates.
 export function withNativeFeedbackCommands(node, config) {
     const hotspot = (event) => {
         dispatchViewCommand(node, 'hotspotUpdate', [
@@ -194,13 +152,9 @@ export function withNativeFeedbackCommands(node, config) {
         },
     };
 }
-// Rebuilding at GESTURE START is the whole reason for the dispatcher indirection, and skipping it
-// is a bug that looks like working code. `attach` runs inside `createElement`, before a single
-// prop has been routed — the node holds nothing at all there — so a machine built at attach would
-// capture no `onPress` at all and every press would silently do nothing. `createPressHandlers`
-// destructures its config eagerly, so it cannot be handed a live view either; it has to be re-made
-// once the props exist. A gesture is one interaction, so a handful of closures per press is
-// invisible — unlike doing it per prop write, which is the cost this whole tier exists to remove.
+// Rebuilding at GESTURE START is the whole reason for the dispatcher indirection: `attach` runs
+// inside createElement before a single prop is routed, so a machine built at attach would capture
+// no onPress at all. A gesture is one interaction, so a handful of closures per press is invisible.
 function rebuild(node, state) {
     // `state.source` for everything READ, `node` for the refinement, which acts on the responder
     // (dispatching a view command needs the committed node, not the one holding the props).
@@ -223,13 +177,9 @@ function rebuild(node, state) {
         blockNativeResponder: propOf(source, 'blockNativeResponder') === true,
     });
 }
-// Pressable is the only member of the family with a `cancelable` prop of its own (`Pressable.js:41`).
-// TouchableOpacity/TouchableHighlight/TouchableNativeFeedback instead expose `rejectResponderTermination`
-// and derive `cancelable: !this.props.rejectResponderTermination` internally
-// (`TouchableOpacity.js:186`, `TouchableHighlight.js:194`, `TouchableNativeFeedback.js:217`) — every
-// composed touchable shares this `rebuild()`, so without this the authored name never reached the
-// machine and every Touchable silently kept the RN native default (yield the responder) regardless of
-// what the app asked for. An explicit `cancelable` still wins, matching Pressable's own precedence.
+// Pressable is the only family member with its own `cancelable` prop; the Touchables instead
+// expose `rejectResponderTermination` and derive cancelable internally. Without this the authored
+// name never reaches the machine. An explicit `cancelable` still wins, matching Pressable's rule.
 function resolveCancelable(source) {
     const cancelable = propOf(source, 'cancelable');
     if (typeof cancelable === 'boolean')
@@ -237,24 +187,17 @@ function resolveCancelable(source) {
     const reject = propOf(source, 'rejectResponderTermination');
     return typeof reject === 'boolean' ? !reject : undefined;
 }
-// WHICHEVER EVENT OPENS THE GESTURE REBUILDS, and pinning that to one name was a real bug.
-// `onStartShouldSetResponder` looks like the opener and is not: `core/engine/src/events/index.ts`
-// bubbles PRESS_IN and only THEN calls `negotiateResponder`, so `pressIn` arrives FIRST on every
-// gesture. Rebuilding only on the responder claim therefore handed the first `pressIn` an empty
-// listener bag — the press-in half of every press was dropped, the pressed style never reached
-// Fabric, and `onPress` still fired because by then the machine existed. That is exactly the
-// device report: the callback works, the button does not light up.
-//
-// So the trigger is a FLAG, not a name: build if this gesture has not built yet, and clear it when
-// the gesture ends. Order-independent, and it survives the engine reordering its own events.
-//
-// A key `buildPressableListeners` omitted — every one of them when `disabled` is true — resolves to
-// undefined here and the dispatcher returns undefined, which is what an absent listener would do.
+// WHICHEVER EVENT OPENS THE GESTURE REBUILDS: `onStartShouldSetResponder` looks like the opener
+// and isn't, since the engine bubbles PRESS_IN and only then negotiates the responder, so
+// `pressIn` arrives first. Rebuilding only on the responder claim handed it an empty listener bag.
+// The trigger is a FLAG, not a name: build if this gesture hasn't built yet, clear on gesture end
+// — order-independent, survives the engine reordering its own events.
 const GESTURE_END_KEYS = new Set([
     'onPressOut',
     'onResponderTerminationRequest',
 ]);
-function dispatch(node, state, key, args) {
+function dispatch(node, options, key, args) {
+    const state = stateOf(node, options);
     if (!state.isBuilt)
         rebuild(node, state);
     const listener = state.listeners[key];
@@ -267,31 +210,10 @@ function dispatch(node, state, key, args) {
         state.isBuilt = false;
     return result;
 }
-// Installed straight into the listener slot rather than through `routeProp`: the behavior OWNS
-// these names, and `setEventListener` diverts an owned name into the app stash — routing its own
-// dispatcher through there would stash it and leave the slot empty.
-//
-// The engine event names, not the `onX` prop spellings. `buildPressableListeners` speaks the prop
-// spelling, so the two are mapped here rather than guessed at either end.
-/**
- * Engine event name -> the app-facing callback key its dispatcher routes to.
- *
- * AN ARRAY OF PAIRS RATHER THAN A `Map`, and the reason is measured rather than stylistic.
- * `installListeners` below is the only reader, and it runs once per node that carries a press
- * machine — which is every `<TextInput>` on the screen, not just every `<Pressable>`. A `for…of` over
- * a `Map` builds a fresh two-element array per entry for the destructuring to read back: seven
- * allocations per node, for seven fixed pairs that never change. The tuples here already exist, so
- * the same loop allocates nothing but its iterator.
- *
- * Priced on `-O` Hermes by `text-input-attach-ladder.itest.ts`, one pass over the seven pairs:
- * `Map` 1.04 us, this 0.39, two parallel arrays 0.29. The parallel arrays are cheapest and give up
- * the pairing, which is not worth 0.1 us on a table that a drift would silently unwire.
- *
- * NOT the same list as `createPressBehavior`'s `ownedListeners`, and they must not be merged: that
- * one is every name the machine takes as an INPUT (`pressMove` and `longPress` included), this one
- * is only the names it installs a dispatcher for.
- */
-const EVENT_KEY_PAIRS = [
+// Engine event name -> the app-facing callback key it routes to. NOT the same list as
+// `createPressBehavior`'s `ownedListeners`, which is every name the machine takes as an INPUT;
+// this is only what it answers when Fabric fires
+const DISPATCH_KEYS = new Map([
     ['press', 'onPress'],
     ['pressIn', 'onPressIn'],
     ['pressOut', 'onPressOut'],
@@ -299,30 +221,55 @@ const EVENT_KEY_PAIRS = [
     ['responderMove', 'onResponderMove'],
     ['responderTerminationRequest', 'onResponderTerminationRequest'],
     ['responderGrant', 'onResponderGrant'],
-];
-function installListeners(node, state) {
-    for (const [event, key] of EVENT_KEY_PAIRS) {
-        setBehaviorListener(node, event, symbioteEvent => dispatch(node, state, key, [symbioteEvent]));
-    }
-}
+]);
+// The per-node half of what the seven dispatcher closures used to capture. A behavior that
+// registered no refinement leaves its nodes out of here entirely
+const attached = new WeakMap();
+// ONE object for every pressable in the app, where seven closures plus the `Map` holding them used
+// to sit per node. `attach` runs inside `createElement`, so what it allocates every list item pays
+// Exported for a tag that is a pressable PLUS something with names of its own (`./text-input`): it
+// composes a union and delegates here, since a node holds exactly one dispatch
+export const PRESS_DISPATCH = {
+    names: new Set(DISPATCH_KEYS.keys()),
+    deliver(node, name, event) {
+        const key = DISPATCH_KEYS.get(name);
+        if (key === undefined)
+            return undefined;
+        return dispatch(node, attached.get(node) ?? NO_OPTIONS, key, [event]);
+    },
+};
 function attachWith(refine, disabledOf) {
-    return node => attach(node, { refine, disabledOf });
+    // One bag per BEHAVIOR, not per node: `refine` and `disabledOf` are fixed at registration, and a
+    // behavior with neither shares the empty one so a plain `<pressable>` stores nothing
+    const options = refine === undefined && disabledOf === undefined
+        ? NO_OPTIONS
+        : { refine, disabledOf };
+    return node => attach(node, options);
 }
-/**
- * The machine on `node`, reading its props and the app's callbacks off `options.source` when that
- * is a different node.
- *
- * Exported for a behavior whose responder is not its own node — `./touchable-native-feedback`,
- * whose tag commits nothing and adopts the app's single child as the responder. Every other caller
- * goes through `createPressBehavior`, where source and node are the same.
- *
- * Re-callable on the same node: a second call replaces the state and the dispatchers, which is what
- * a re-arm after `detachPressMachine` needs.
- */
-export function attachPressMachine(node, options = {}) {
+const NO_OPTIONS = {};
+// The machine on `node`, reading props and callbacks off `options.source` when different.
+// Exported for touchable-native-feedback, whose tag commits nothing and adopts the app's single
+// child as the responder; every other caller goes through createPressBehavior where they're equal.
+// Re-callable on the same node: a second call replaces the state and dispatchers, which is what
+// re-arming after detachPressMachine needs.
+export function attachPressMachine(node, options = NO_OPTIONS) {
     attach(node, options);
 }
+// One pointer, plus one map slot for a refined behavior: everything below is read from `dispatch`
+// alone, so a pressable nobody touches never builds a gesture runtime
+// A re-attach drops the old state so the new options take effect on the next gesture
 function attach(node, options) {
+    states.delete(node);
+    if (options === NO_OPTIONS)
+        attached.delete(node);
+    else
+        attached.set(node, options);
+    setNodeDispatch(node, PRESS_DISPATCH);
+}
+function stateOf(node, options) {
+    const existing = states.get(node);
+    if (existing !== undefined)
+        return existing;
     const timers = new Set();
     const runtime = createPressRuntime();
     const host = {
@@ -330,10 +277,8 @@ function attach(node, options) {
         // through the style registry's `:active` variant, and never crosses into it.
         setPressed: pressed => {
             setNodePressed(node, pressed);
-            // Dirtying is not publishing. A press arrives from a native event, outside every renderer
-            // mutation path, so nothing schedules a commit — `native-events.ts` requests none, and no
-            // adapter does either. `setNodeHidden`'s React twin never hit this because the reconciler is
-            // already in its commit phase when it calls.
+            // Dirtying is not publishing: a press arrives outside every renderer mutation path, so
+            // nothing else schedules a commit.
             requestCommitFor(node);
         },
         // `measure` needs a committed Fabric tag, which a node has by the time a human can touch it.
@@ -367,20 +312,21 @@ function attach(node, options) {
         isBuilt: false,
     };
     states.set(node, state);
-    installListeners(node, state);
+    return state;
 }
 /** See `attachPressMachine`: the same teardown `createPressBehavior` registers as its `detach`. */
 export function detachPressMachine(node) {
     detach(node);
 }
 function detach(node) {
+    setNodeDispatch(node, undefined);
+    attached.delete(node);
     const state = states.get(node);
+    // A pressable nobody touched has no state at all, and the two releases above are all it owes
     if (state === undefined)
         return;
-    // The machine's own teardown, which every wrapper calls from its destroy hook. Not load-bearing
-    // here and no test can make it so: `host.schedule` puts every timer the machine arms into
-    // `state.timers` — the 130ms floor's deferred `pressOut` included — so the loop below already
-    // cancels them. Kept as the contract, and for a timer armed by some future route.
+    // The machine's own teardown. Not load-bearing here: host.schedule puts every timer the machine
+    // arms into state.timers, so the loop below already cancels them — kept as the contract.
     disposePressRuntime(state.runtime);
     for (const id of state.timers)
         clearTimeout(id);
@@ -388,15 +334,9 @@ function detach(node) {
     states.delete(node);
     dlog('pressable behavior detached');
 }
-/**
- * The press machine as behavior parts, so a tag that is a pressable PLUS something can compose it
- * instead of re-implementing it.
- *
- * Spread into the caller's own behavior and wrap `attach`/`detach` around these — the touchable
- * family needs a per-node Animated value opened before the machine and closed after it. The
- * WeakMap holding the machine's own state is keyed by node, so one node may hold exactly one of
- * these; a tag composing it therefore must not also register the plain `pressable` behavior.
- */
+// The press machine as behavior parts, so a tag that is a pressable PLUS something can compose
+// it instead of re-implementing it — the touchable family wraps attach/detach for its own
+// per-node Animated value. One node may hold exactly one of these; don't also register `pressable`.
 export function createPressBehavior(refine, disabledOf) {
     return {
         attach: attachWith(refine, disabledOf),

package/build/behaviors/refresh-control.js

@@ -29,7 +29,7 @@
 // `behaviors/switch.ts`'s module header, verbatim. Same shape, same two triggers, same reasons —
 // an ACCEPTING app's state reaches `node.props` only after its own reconciliation, and a REJECTING
 // app writes no prop at all, so the commit that `afterCommit` waits for never comes.
-import { appListenerFor, dispatchViewCommand, dlog, registerHostBehavior, setBehaviorListener, propOf, } from '@symbiote-native/engine';
+import { appListenerFor, dispatchViewCommand, dlog, registerHostBehavior, setNodeDispatch, propOf, } from '@symbiote-native/engine';
 export const REFRESH_CONTROL_TAG = 'refresh-control';
 // RN's own name for the command, sent to whichever of the two native views the platform resolved.
 const SET_NATIVE_REFRESHING = 'setNativeRefreshing';
@@ -75,10 +75,16 @@ function onRefresh(node, event) {
         listener(event);
     queueMicrotask(() => evaluateSnapBack(node));
 }
+// ONE object for every RefreshControl in the app, where a closure per node used to be
+const REFRESH_DISPATCH = {
+    names: new Set(['refresh']),
+    deliver: (node, _name, event) => onRefresh(node, event),
+};
 function attach(node) {
-    setBehaviorListener(node, 'refresh', event => onRefresh(node, event));
+    setNodeDispatch(node, REFRESH_DISPATCH);
 }
 function detach(node) {
+    setNodeDispatch(node, undefined);
     reported.delete(node);
 }
 // Idempotent: an adapter entry may be imported more than once in a bundle, and re-registering the

package/build/behaviors/scroll-view/index.android.js

@@ -1,35 +1,15 @@
 // ScrollView's behavior on Android, where a RefreshControl is not a child at all.
-//
 // An Android ScrollView holds exactly ONE child, so a sibling refresh control is an `addViewAt`
-// crash rather than a layout mistake. RN inverts the tree instead: `AndroidSwipeRefreshLayout`
-// WRAPS the scroll view, and the scroll view's style is split across the two boxes — layout on the
-// wrapper's frame, visual on the scroller (`ScrollView.js:1856`). `nestedScrollEnabled` goes on the
-// inner view so it consumes the gesture before the refresh parent sees it.
-//
-// THIS FILE IS A CLAIM MODE AND NOTHING ELSE NOW (2026-09-18). It carried two `payloadFold`s until
-// then — the last two folds in ScrollView and the last structural blocker in the behavior
-// migration — and both are `SymbioteFabricProps.cpp` now: `foldScrollViewProps` takes the visual
-// half when its parent is a refresh control, and `foldRefreshWrapperProps` takes the layout half of
-// the child it wraps.
-//
-// WHY THEY RESISTED THREE ITERATIONS, and what changed. Every seam the engine had read UP —
-// `ownerProps`, `IOwner.tagName`, `IAncestorLookup` — and the wrapper is the scroll view's PARENT
-// asking for the scroll view's style, the one direction none of them go. `IFirstChild` is that
-// direction, and it is the same argument `ownerProps` already made rather than a new one: the tree
-// lives in C++, so reading another node is a pointer hop, and RN itself builds this parent FROM its
-// child (`cloneElement(refreshControl, {style: outer}, scrollView)`).
-//
-// `slotDerived: ['style']` STAYS AND IS NOW LOAD-BEARING FOR THE ENGINE'S RULE. A rule re-runs when
-// ITS node is dirty; the wrapper derives from a node that is not itself, so an owner style write
-// must mark it (`routeProp`'s `node.wrapper` branch). Without this entry the wrapper freezes at its
-// mount frame while the scroller visibly restyles inside it —
-// `core/engine/cpp/tests/js/scroll-view-wrap-payload.itest.ts` is the case that says so.
-//
-// AND NOTHING HERE IS `#ifdef ANDROID` OR `Platform.OS`, on either side: the engine's rules are
-// gated on TOPOLOGY. iOS claims the refresh control BESIDE the content, so a scroll view is never
-// one's child there and neither branch can fire. That is strictly better than a compile-time split
-// for the reason `Switch`/`AndroidSwitch` already showed — and it is why the wrap's payload fixture
-// runs on the ORDINARY test host rather than needing the Android arm.
+// crash. RN inverts the tree instead: `AndroidSwipeRefreshLayout` WRAPS the scroll view
+// (`ScrollView.js:1856`) — layout style on the wrapper, visual style on the scroller.
+// This file is a CLAIM MODE and nothing else: both prop folds are `SymbioteFabricProps.cpp` now —
+// `foldScrollViewProps` takes the visual half when its parent is a refresh control,
+// `foldRefreshWrapperProps` the layout half of the child it wraps.
+// `slotDerived: ['style']` is load-bearing: the wrapper derives from a node that is not itself, so
+// an owner style write must mark IT dirty (`routeProp`'s `node.wrapper` branch) or it freezes at
+// its mount frame while the scroller visibly restyles (`scroll-view-wrap-payload.itest.ts`).
+// Gated on TOPOLOGY, not `#ifdef ANDROID`/`Platform.OS`: iOS claims the refresh control BESIDE
+// the content, so a scroll view is never one's child there and neither branch can fire.
 import { registerScrollViewBehaviors } from './shared.js';
 const android = {
     claimMode: 'wrap',

package/build/behaviors/scroll-view/responder.d.ts

@@ -1,4 +1,5 @@
-import { type ISymbioteNode } from '@symbiote-native/engine';
+import { type ISymbioteEvent, type ISymbioteNode } from '@symbiote-native/engine';
 export declare function markScrollObserved(owner: ISymbioteNode): void;
 export declare const RESPONDER_OWNED_LISTENERS: readonly string[];
-export declare function installResponderPredicates(owner: ISymbioteNode): void;
+export declare const RESPONDER_DISPATCHED_NAMES: ReadonlySet<string>;
+export declare function deliverResponderEvent(owner: ISymbioteNode, name: string, event: ISymbioteEvent): unknown;

package/build/behaviors/scroll-view/responder.js

@@ -5,7 +5,7 @@
 // Ported line-for-line from `ScrollView.js:1263-1546` — the negotiation engine itself and the
 // `IResponderProps` prop surface already exist and needed no change; this file is ScrollView opting
 // into the same mechanism Pressable already uses (`../pressable.ts:329-384`).
-import { appListenerFor, currentlyFocusedInput, blurTextInput, dlog, isDebug, isRecord, isSymbioteNode, Keyboard, Platform, propOf, setBehaviorListener, } from '@symbiote-native/engine';
+import { appListenerFor, currentlyFocusedInput, blurTextInput, dlog, isDebug, isRecord, isSymbioteNode, Keyboard, Platform, propOf, } from '@symbiote-native/engine';
 import { descriptorFor } from '../../component-names';
 import { TEXT_INPUT_MULTILINE_TAG, TEXT_INPUT_TAG } from '../text-input.js';
 // RN's `IS_ANIMATING_TOUCH_START_THRESHOLD_MS` (ScrollView.js:695) — a momentum end inside this
@@ -208,24 +208,22 @@ export const RESPONDER_OWNED_LISTENERS = [
     'momentumScrollBegin',
     'momentumScrollEnd',
 ];
-// Installed once per owner, in `attach` — same beat Pressable wires its own responder pair.
-export function installResponderPredicates(owner) {
-    setBehaviorListener(owner, 'startShouldSetResponderCapture', event => startShouldSetResponderCapture(owner, event));
-    setBehaviorListener(owner, 'startShouldSetResponder', event => startShouldSetResponder(owner, event));
-    setBehaviorListener(owner, 'responderTerminationRequest', () => responderTerminationRequest(owner));
-    setBehaviorListener(owner, 'responderGrant', event => {
-        handleResponderGrant(owner, event);
-    });
-    setBehaviorListener(owner, 'responderRelease', event => {
-        handleResponderRelease(owner, event);
-    });
-    setBehaviorListener(owner, 'momentumScrollBegin', event => {
-        handleMomentumScrollBegin(owner, event);
-    });
-    setBehaviorListener(owner, 'scrollBeginDrag', event => {
-        handleScrollBeginDrag(owner, event);
-    });
-    setBehaviorListener(owner, 'momentumScrollEnd', event => {
-        handleMomentumScrollEnd(owner, event);
-    });
+// The eight names an owner answers, as ONE module-level table where eight closures per node used to
+// be. `./shared` composes it with its own `scroll` into the owner's `IEventDispatch`
+const HANDLERS = new Map([
+    ['startShouldSetResponderCapture', startShouldSetResponderCapture],
+    ['startShouldSetResponder', startShouldSetResponder],
+    [
+        'responderTerminationRequest',
+        (owner) => responderTerminationRequest(owner),
+    ],
+    ['responderGrant', handleResponderGrant],
+    ['responderRelease', handleResponderRelease],
+    ['momentumScrollBegin', handleMomentumScrollBegin],
+    ['scrollBeginDrag', handleScrollBeginDrag],
+    ['momentumScrollEnd', handleMomentumScrollEnd],
+]);
+export const RESPONDER_DISPATCHED_NAMES = new Set(HANDLERS.keys());
+export function deliverResponderEvent(owner, name, event) {
+    return HANDLERS.get(name)?.(owner, event);
 }