@symbiote-native/components 2.0.0 → 3.0.1

package/build/behaviors/pressable.js

@@ -14,9 +14,9 @@
 // `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, dlog, registerHostBehavior, requestCommitFor, setBehaviorListener, setNodePressed, } from '@symbiote-native/engine';
-import { createPressHandlers, createPressRuntime, disposePressRuntime, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, rippleProps, } from '../state/pressable.js';
-import { buildPressableListeners, resolveDisabledAccessibilityState, resolvePressableFocusable, } from '../view/render-pressable/index.js';
+import { appListenerFor, dlog, propOf, registerHostBehavior, requestCommitFor, setBehaviorListener, 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';
 const states = new WeakMap();
 function isRecord(value) {
@@ -56,24 +56,7 @@ function asRectOffset(value) {
 function isPressHandler(value) {
     return typeof value === 'function';
 }
-// The props the MACHINE consumes and the host must never see. The wrapper drops them by
-// destructuring — they go into `createPressHandlers` / `buildPressableListeners` and are simply
-// absent from the object it spreads onto its View. A lowered element has no destructure, so every
-// one of them rode into the payload as a key no ViewConfig declares.
-const MACHINE_ONLY_KEYS = [
-    // Consumed below and replaced by the resolved `nativeBackgroundAndroid` /
-    // `nativeForegroundAndroid`; the raw config is not a native prop.
-    'android_ripple',
-    'disabled',
-    'cancelable',
-    'delayLongPress',
-    'minPressDuration',
-    'unstable_pressDelay',
-    'pressRetentionOffset',
-    'delayHoverIn',
-    'delayHoverOut',
-];
-// Narrowed field by field rather than cast: the bag arrives as `unknown` off `node.props`. A local
+// 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.
@@ -93,108 +76,81 @@ export function asAccessibilityState(value) {
         state.expanded = value.expanded;
     return state;
 }
-// Narrowed field by field, same reason as the accessibility guard above: the config arrives as
-// `unknown` off `node.props`.
-function asRippleConfig(value) {
-    if (!isRecord(value))
-        return undefined;
-    const config = {};
-    if (typeof value.color === 'string')
-        config.color = value.color;
-    if (typeof value.borderless === 'boolean')
-        config.borderless = value.borderless;
-    if (typeof value.radius === 'number')
-        config.radius = value.radius;
-    if (typeof value.foreground === 'boolean')
-        config.foreground = value.foreground;
-    return config;
-}
-// `disabled` reaches a screen reader ONLY as `accessibilityState.disabled` — it is not a native
-// View prop, so the wrapper folds it (`resolveDisabledAccessibilityState`, called by all five) and
-// forwards the composite. Lowering dropped that fold: press suppression still worked, because the
-// machine reads `node.props.disabled` directly, so the button behaved correctly and announced
-// itself as enabled. An accessibility regression with no visual tell and no failing test.
+// 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>`.
 //
-// Found by the wrapper-vs-behavior import audit (`.claude/rules/adapter-parity-audit.md`).
-function foldPayload(props) {
-    const resolved = resolveDisabledAccessibilityState(asAccessibilityState(props.accessibilityState), typeof props.disabled === 'boolean' ? props.disabled : undefined);
-    // The Android ripple. Our WRAPPER paints it through a dedicated inner View, mirroring
-    // TouchableNativeFeedback — and that reading is what made this look unfixable for a lowered
-    // element, which has no child to put it on. RN's own `Pressable` does NOT do that: it spreads
-    // `useAndroidRippleForView`'s `viewProps` onto its own View (`Pressable.js:251`), so the ripple
-    // background is an ordinary prop of the responder itself and a single node carries it fine.
-    //
-    // `rippleProps` returns undefined off Android, so this whole branch is inert on iOS.
-    //
-    // STILL MISSING ON BOTH PATHS, and lowering did not cause it: RN also dispatches
-    // `Commands.hotspotUpdate(x, y)` on pressIn/pressMove and `Commands.setPressed` on
-    // pressIn/pressOut, which is what makes the ripple originate at the touch point. Neither our
-    // wrapper nor this behavior sends them — grep for `hotspotUpdate` returns nothing in the tree.
-    const rippleConfig = asRippleConfig(props.android_ripple);
-    const ripple = rippleConfig !== undefined ? rippleProps(rippleConfig) : undefined;
-    const out = { ...props };
-    for (const key of MACHINE_ONLY_KEYS)
-        delete out[key];
-    if (ripple !== undefined)
-        Object.assign(out, ripple);
-    // Written only when the fold produced something: an unconditional assignment would put an
-    // `accessibilityState: undefined` key on every lowered Pressable in the tree, and `fabricProps`
-    // skipping undefined is a coincidence to lean on, not a contract to rely on here.
-    if (resolved !== undefined)
-        out.accessibilityState = resolved;
-    out.accessible = accessibleUnlessOptedOut(props);
-    // Pressable.js:258 — the plain form, with no press-handler or disabled leg. A Touchable composing
-    // this tag has already resolved its own three-leg formula and passed the answer in as `focusable`,
-    // which `!== false` leaves alone.
-    out.focusable = resolvePressableFocusable(booleanOr(props.focusable));
-    return out;
-}
+// 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, on either path, so a Pressable reached a screen
-// reader as a plain view unless the app wrote the prop. Landing it in the fold above alone reddens
-// four equivalence arms — correctly, since those compare the wrapper against the lowered path — so
-// the behavior and every adapter's wrapper have to move in ONE change. Exported for the wrappers
-// that need to say it themselves, and for the tags whose behavior is their only path.
+// 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.
 export function accessibleUnlessOptedOut(props) {
     return props.accessible !== false;
 }
-// From the STASH, not from `node.props`. Every name below is in `ownedListeners`, so `routeProp`
+// 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
-// `node.props` here returns undefined for every callback and every press silently does nothing:
+// `propOf` here returns undefined for every callback and every press silently does nothing:
 // the behavior runs, the machine runs, and it calls nobody.
 function callbackAt(node, event) {
     const value = appListenerFor(node, event);
     return isPressHandler(value) ? value : undefined;
 }
-// Callbacks come from `callbackAt` (the stash), scalars from `node.props`. The split is not
+// Callbacks come from `callbackAt` (the stash), scalars from `propOf`. The split is not
 // cosmetic: `delayLongPress` and `hitSlop` are ordinary props that `fabricProps` drops as unknown
-// keys, while `onPress` and friends are OWNED event names that never reach `node.props` at all.
+// keys, while `onPress` and friends are OWNED event names that never reach the props at all.
 function configFor(node) {
+    const unstablePressDelay = numberOr(propOf(node, 'unstable_pressDelay'), 0);
     return {
         onPress: callbackAt(node, 'press'),
         onPressIn: callbackAt(node, 'pressIn'),
         onPressOut: callbackAt(node, 'pressOut'),
         onPressMove: callbackAt(node, 'pressMove'),
         onLongPress: callbackAt(node, 'longPress'),
-        delayLongPress: numberOr(node.props.delayLongPress, DEFAULT_DELAY_LONG_PRESS_MS),
-        unstable_pressDelay: numberOr(node.props.unstable_pressDelay, 0),
+        // 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).
+        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.
-        minPressDuration: numberOr(node.props.minPressDuration, DEFAULT_MIN_PRESS_DURATION_MS),
-        hitSlop: asRectOffset(node.props.hitSlop),
-        pressRetentionOffset: asRectOffset(node.props.pressRetentionOffset),
+        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.
+        android_disableSound: booleanOr(propOf(node, 'android_disableSound')) ??
+            booleanOr(propOf(node, 'touchSoundDisabled')),
     };
 }
 // 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 — `node.props` is literally `{}` there — so a machine built at attach would
+// 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
@@ -208,16 +164,30 @@ function rebuild(node, state) {
     state.isBuilt = true;
     // Re-read every gesture, so a tag whose resolver looks past `disabled` — `./button`, at
     // `aria-disabled` — re-enables on the next touch instead of latching at its first answer.
+    const sourceProps = propsOf(source);
     const disabled = state.disabledOf === undefined
-        ? source.props.disabled
-        : state.disabledOf(source.props);
+        ? sourceProps.disabled
+        : state.disabledOf(sourceProps);
     state.listeners = buildPressableListeners(handlers, {
         disabled: disabled === true ? true : undefined,
-        cancelable: typeof source.props.cancelable === 'boolean'
-            ? source.props.cancelable
-            : undefined,
+        cancelable: resolveCancelable(source),
+        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.
+function resolveCancelable(source) {
+    const cancelable = propOf(source, 'cancelable');
+    if (typeof cancelable === 'boolean')
+        return cancelable;
+    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
@@ -254,16 +224,35 @@ function dispatch(node, state, key, args) {
 //
 // 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.
-const KEY_BY_EVENT = new Map([
+/**
+ * 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 = [
     ['press', 'onPress'],
     ['pressIn', 'onPressIn'],
     ['pressOut', 'onPressOut'],
     ['startShouldSetResponder', 'onStartShouldSetResponder'],
     ['responderMove', 'onResponderMove'],
     ['responderTerminationRequest', 'onResponderTerminationRequest'],
-]);
+    ['responderGrant', 'onResponderGrant'],
+];
 function installListeners(node, state) {
-    for (const [event, key] of KEY_BY_EVENT) {
+    for (const [event, key] of EVENT_KEY_PAIRS) {
         setBehaviorListener(node, event, symbioteEvent => dispatch(node, state, key, [symbioteEvent]));
     }
 }
@@ -362,7 +351,6 @@ export function createPressBehavior(refine, disabledOf) {
     return {
         attach: attachWith(refine, disabledOf),
         detach,
-        foldPayload,
         // Every name the machine needs as an INPUT. The responder pair is not optional — it is how a
         // gesture starts at all, and `RESPONDER_EVENTS` makes those listeners on any node regardless
         // of ViewConfig, so they collide exactly like `press` does.
@@ -375,6 +363,7 @@ export function createPressBehavior(refine, disabledOf) {
             'startShouldSetResponder',
             'responderMove',
             'responderTerminationRequest',
+            'responderGrant',
         ],
     };
 }

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, } from '@symbiote-native/engine';
+import { appListenerFor, dispatchViewCommand, dlog, registerHostBehavior, setBehaviorListener, 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';
@@ -38,12 +38,25 @@ const SET_NATIVE_REFRESHING = 'setNativeRefreshing';
 // authoritative, and an app that drives `refreshing` on its own initiative must never be corrected
 // against a value native never claimed.
 const reported = new WeakMap();
+// TODO(rn-parity, low priority, efficiency not correctness): vendor's `componentDidUpdate`
+// (`RefreshControl.js:139-158`) sends `setNativeRefreshing` only when `refreshing` did NOT change
+// between renders, trusting the ordinary prop diff to carry a real change to native. Ours has no
+// such guard — `evaluateSnapBack` fires the command on any disagreement with `reported`, even when
+// this same commit already carries the authored `refreshing` change (accept-then-finish: app agrees
+// on the gesture, then sets `refreshing: false` to end it — vendor sends zero commands, we send one
+// extra). Both settle on the same native value, so this is a harmless redundant call, not a bug —
+// and NOT a candidate for the same fix as the "repairs a snap-back the app contradicts on a later
+// commit" test below, which relies on this exact unconditional re-check for a genuine cross-
+// framework microtask race. A real fix needs tracking the last-seen authored value alongside
+// `reported`, so a same-commit authored change can be told apart from native drifting on its own —
+// not attempted here.
+//
 // Shared by both triggers — see the module header for why there are two.
 function evaluateSnapBack(node) {
     const lastNativeReport = reported.get(node);
     if (lastNativeReport === undefined)
         return; // no report yet, nothing to disagree with
-    const refreshing = node.props.refreshing === true;
+    const refreshing = propOf(node, 'refreshing') === true;
     if (lastNativeReport === refreshing) {
         dlog(`RefreshControl behavior snap-back no-op refreshing=${refreshing}`);
         return;

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

@@ -6,46 +6,34 @@
 // 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.
 //
-// The two folds below are what neither node can work out alone: the wrapper is the APP's node, so
-// it carries whatever the app wrote on `<RefreshControl>` and knows nothing about the scroll view's
-// style. RN reaches the same place through `cloneElement`, which likewise OVERRIDES the refresh
-// control's own `style` — so replacing it here is parity, not a liberty.
-import {} from '@symbiote-native/engine';
-import { splitScrollViewStyle } from '../../scroll-view-commands.js';
-import { ownerFold, registerScrollViewBehaviors, } from './shared.js';
-// The owner under a wrap: the ordinary fold with the VISUAL half of its own style in place of the
-// composed one. Delegating rather than restating is what keeps `decelerationRate`, `horizontal` and
-// `nestedScrollEnabled` in ONE place — none of the three has anything to do with the wrap, and the
-// hand-written copy this replaced had already lost the first of them.
-function wrappedOwnerFold(base, horizontal) {
-    const plain = ownerFold(base, horizontal);
-    return props => ({
-        ...plain(props),
-        style: splitScrollViewStyle(base, props.style).inner,
-    });
-}
-// The wrapper: the LAYOUT half of the OWNER's style, read off the owner because that is where the
-// app wrote it. Kept in step by `slotDerived` naming `style`, which marks the wrapper dirty on an
-// owner style write.
-function wrapperFold(owner, base) {
-    return props => ({
-        ...props,
-        style: splitScrollViewStyle(base, owner.props.style).outer,
-    });
-}
+// 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.
+import { registerScrollViewBehaviors } from './shared.js';
 const android = {
     claimMode: 'wrap',
     slotDerived: ['style'],
-    onWrapChange: (base, horizontal) => (owner, wrapper) => {
-        // Back to the ordinary composition, not to `undefined` — the plain fold carries the axis and
-        // the gesture props, which have nothing to do with the wrap.
-        owner.payloadFold =
-            wrapper === undefined
-                ? ownerFold(base, horizontal)
-                : wrappedOwnerFold(base, horizontal);
-        if (wrapper !== undefined)
-            wrapper.payloadFold = wrapperFold(owner, base);
-    },
 };
 export function registerScrollViewBehavior() {
     registerScrollViewBehaviors(android);

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

@@ -1,2 +1,3 @@
 export { registerScrollViewBehavior } from './index.ios';
 export { HORIZONTAL_SCROLL_VIEW_TAG, REFRESH_CONTROL, SCROLL_VIEW_TAG, } from './shared';
+export { STICKY_HEADER_TAG } from './sticky';

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

@@ -3,3 +3,6 @@
 // `render-scroll-view`'s own `Platform.select` defaults to it.
 export { registerScrollViewBehavior } from './index.ios.js';
 export { HORIZONTAL_SCROLL_VIEW_TAG, REFRESH_CONTROL, SCROLL_VIEW_TAG, } from './shared.js';
+// The tag, so a test can locate a committed sticky wrapper by what the engine was TOLD rather than
+// by a key its tag rule writes — see `ILiveNode.tagName`.
+export { STICKY_HEADER_TAG } from './sticky.js';

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

@@ -0,0 +1,4 @@
+import { 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;

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

@@ -0,0 +1,202 @@
+// ScrollView's own participation in the responder negotiation
+// (`core/engine/src/events`) — RN's `ScrollView.js` four predicates
+// (`_handleStartShouldSetResponderCapture`/`_handleStartShouldSetResponder`/
+// `_handleResponderTerminationRequest`) plus the grant/release/momentum bookkeeping they read.
+// 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, isRecord, isSymbioteNode, Keyboard, propOf, setBehaviorListener, } 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
+// window still counts as animating, so a touch that lands one frame after the list stops still
+// goes to the ScrollView rather than a child it is still settling under.
+const IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
+const stateByOwner = new WeakMap();
+function stateFor(owner) {
+    let state = stateByOwner.get(owner);
+    if (state === undefined) {
+        state = {
+            observedScrollSinceBecomingResponder: false,
+            becameResponderWhileAnimating: false,
+            lastMomentumScrollBeginTime: 0,
+            lastMomentumScrollEndTime: 0,
+        };
+        stateByOwner.set(owner, state);
+    }
+    return state;
+}
+// RN's `_isAnimating()` (ScrollView.js:1321-1330), unchanged: a momentum scroll in flight
+// (begin > end) or one that just ended within the threshold.
+function isAnimating(state) {
+    const sinceEnd = performance.now() - state.lastMomentumScrollEndTime;
+    return (sinceEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS ||
+        state.lastMomentumScrollEndTime < state.lastMomentumScrollBeginTime);
+}
+// The one thing this repo already has that RN builds from native `Keyboard` events:
+// `Keyboard.metrics()` reads the last-known metrics synchronously (`core/engine/src/keyboard`),
+// the same value RN caches on `_keyboardMetrics`. Reused as-is, no new tracking.
+// `node.component` is the resolved Fabric VIEW NAME (`RCTSinglelineTextInputView` on iOS, its own
+// name on Android), not the tag — the tag is consumed at `createElement` and not retained
+// (`core/engine/src/node.ts:466-470`'s own comment). `descriptorFor` resolves the same tag through
+// the same per-platform table TextInput's own registration used, so the two stay in lockstep by
+// construction rather than by a second hardcoded name list here.
+function isTextInputNode(node) {
+    return (node.component === descriptorFor(TEXT_INPUT_TAG).component ||
+        node.component === descriptorFor(TEXT_INPUT_MULTILINE_TAG).component);
+}
+// RN's `_keyboardIsDismissible()` (ScrollView.js:1527-1541). RN also has `_keyboardEventsAreUnreliable()`
+// — a pre-API-30 Android layout-polling fallback — deliberately not ported: modern targets only,
+// and the omission only ever makes this return `false` more readily (never dismisses when RN
+// would not have been sure either), never a false claim.
+function keyboardIsDismissible() {
+    const focused = currentlyFocusedInput();
+    const hasFocusedTextInput = focused !== null && isTextInputNode(focused);
+    return hasFocusedTextInput && Keyboard.metrics() !== undefined;
+}
+// RN's `_softKeyboardIsDetached()` (ScrollView.js:1543-1546).
+function softKeyboardIsDetached() {
+    const metrics = Keyboard.metrics();
+    return metrics !== undefined && metrics.height === 0;
+}
+// The should-set listeners run on the SCROLL VIEW's own node (`callOwnListener` sets `event.target`
+// to the node being asked, not the node the touch landed on), so RN's `e.target` has to be read
+// back out of the raw touch payload instead — the same place `core/engine/src/touch-history.ts`
+// and `hasRemainingTouchWithin` (`events/index.ts`) already read a touch's `target` from.
+function touchTargetOf(nativeEvent) {
+    for (const key of ['changedTouches', 'touches']) {
+        const touches = nativeEvent[key];
+        if (!Array.isArray(touches) || touches.length === 0)
+            continue;
+        const first = touches[0];
+        if (!isRecord(first))
+            continue;
+        const target = first.target;
+        if (isSymbioteNode(target))
+            return target;
+    }
+    return undefined;
+}
+function keyboardNeverPersistsTaps(persist) {
+    return (persist === undefined ||
+        persist === null ||
+        persist === false ||
+        persist === 'never');
+}
+// `ScrollView.js:1474-1522`. Claims the tap in the CAPTURE phase — before any child sees it —
+// while animating, or (the keyboard-dismiss case) while the default is in force, a dismissible
+// keyboard is up, and the touch did not land on the focused input itself.
+function startShouldSetResponderCapture(owner, event) {
+    const state = stateFor(owner);
+    if (isAnimating(state))
+        return true;
+    if (propOf(owner, 'disableScrollViewPanResponder') === true)
+        return false;
+    if (softKeyboardIsDetached())
+        return false;
+    if (keyboardNeverPersistsTaps(propOf(owner, 'keyboardShouldPersistTaps')) &&
+        keyboardIsDismissible()) {
+        const target = touchTargetOf(event.nativeEvent);
+        if (target !== undefined && !isTextInputNode(target))
+            return true;
+    }
+    return false;
+}
+// `ScrollView.js:1444-1461`. The BUBBLE-phase counterpart — only reachable when capture declined
+// — for `keyboardShouldPersistTaps: 'handled'`: claim only if the tap didn't land on the focused
+// input (letting a child handle it first is the whole point of "handled").
+function startShouldSetResponder(owner, event) {
+    if (propOf(owner, 'disableScrollViewPanResponder') === true)
+        return false;
+    if (propOf(owner, 'keyboardShouldPersistTaps') === 'handled' &&
+        keyboardIsDismissible()) {
+        const target = touchTargetOf(event.nativeEvent);
+        if (target !== currentlyFocusedInput())
+            return true;
+    }
+    return false;
+}
+// `ScrollView.js:1404-1406`. Once real scroll motion has been observed, refuse to give the
+// responder up — matches every other adapter's "don't drop a gesture already committed" rule.
+function responderTerminationRequest(owner) {
+    return !stateFor(owner).observedScrollSinceBecomingResponder;
+}
+// `ScrollView.js:1334-1341`. `onResponderGrant` is an ordinary `IResponderProps` field an app may
+// also set, so — same reason `scroll`/`layout`/`contentSizeChange` are owned — it is composed
+// through the stash rather than claimed outright.
+function handleResponderGrant(owner, event) {
+    const state = stateFor(owner);
+    state.observedScrollSinceBecomingResponder = false;
+    const app = appListenerFor(owner, 'responderGrant');
+    if (typeof app === 'function')
+        app(event);
+    state.becameResponderWhileAnimating = isAnimating(state);
+}
+// `ScrollView.js:1357-1387`. On release, dismiss the keyboard iff: something is focused,
+// `keyboardShouldPersistTaps` isn't `true`/`'always'`, the keyboard is dismissible, the release
+// didn't land on the focused input, and nothing since becoming responder was a real scroll or an
+// animation-time grant (both mean the touch was already "used" for something else).
+function handleResponderRelease(owner, event) {
+    const state = stateFor(owner);
+    const app = appListenerFor(owner, 'responderRelease');
+    if (typeof app === 'function')
+        app(event);
+    const focused = currentlyFocusedInput();
+    const persist = propOf(owner, 'keyboardShouldPersistTaps');
+    if (focused === null ||
+        persist === true ||
+        persist === 'always' ||
+        !keyboardIsDismissible() ||
+        state.observedScrollSinceBecomingResponder ||
+        state.becameResponderWhileAnimating)
+        return;
+    if (touchTargetOf(event.nativeEvent) === focused)
+        return;
+    blurTextInput(focused);
+}
+// `ScrollView.js:1146` — unconditional, exactly as RN sets it from `_handleScroll`: nothing reads
+// the flag unless this node actually holds the responder, so setting it on every scroll is safe.
+export function markScrollObserved(owner) {
+    stateFor(owner).observedScrollSinceBecomingResponder = true;
+}
+// `ScrollView.js:1263-1274`. Both are ordinary `on*` props apps use for pagination, so both are
+// composed through the stash exactly like `handleOwnerScroll` composes `onScroll` (`./sticky.ts`).
+function handleMomentumScrollBegin(owner, event) {
+    stateFor(owner).lastMomentumScrollBeginTime = performance.now();
+    const app = appListenerFor(owner, 'momentumScrollBegin');
+    if (typeof app === 'function')
+        app(event);
+}
+function handleMomentumScrollEnd(owner, event) {
+    stateFor(owner).lastMomentumScrollEndTime = performance.now();
+    const app = appListenerFor(owner, 'momentumScrollEnd');
+    if (typeof app === 'function')
+        app(event);
+}
+export const RESPONDER_OWNED_LISTENERS = [
+    'startShouldSetResponderCapture',
+    'startShouldSetResponder',
+    'responderTerminationRequest',
+    'responderGrant',
+    'responderRelease',
+    '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, 'momentumScrollEnd', event => {
+        handleMomentumScrollEnd(owner, event);
+    });
+}

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

@@ -1,11 +1,9 @@
-import { type IClaimMode, type IHostBehavior, type IPayloadFold, type IViewStyle } from '@symbiote-native/engine';
+import { type IClaimMode } from '@symbiote-native/engine';
 export declare const SCROLL_VIEW_TAG = "scroll-view";
 export declare const HORIZONTAL_SCROLL_VIEW_TAG = "horizontal-scroll-view";
 export declare const REFRESH_CONTROL: string;
-export declare function ownerFold(base: IViewStyle, horizontal: boolean): IPayloadFold;
 export interface IScrollPlatform {
     claimMode: IClaimMode;
-    onWrapChange?: (base: IViewStyle, horizontal: boolean) => IHostBehavior['onWrapChange'];
     slotDerived?: readonly string[];
 }
 export declare function registerScrollViewBehaviors(platform: IScrollPlatform): void;