@symbiote-native/components 2.0.0 → 3.0.1

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

@@ -15,14 +15,31 @@
 // `./sticky`, because a `<StickyHeader>` is a CHILD and the three props above are functions of
 // whether one registered.
 //
+// TODO(rn-parity): `keyboardShouldPersistTaps` is a type-only prop everywhere — no capture-phase
+// responder negotiation exists to eat a tap-elsewhere and dismiss the keyboard
+// (`ScrollView.js:1360-1590`). Needs a `TextInputState.isTextInput`-equivalent, capture-phase
+// `startShouldSetResponder`/`responderTerminationRequest` wiring on this tag (the same seam
+// `Switch`/`Pressable` already use), and an `_isAnimating()`/momentum signal from the scroll
+// machine. Full scope and the reusable infra already in place: audit skill, "Found, NOT fixed:
+// ScrollView's keyboardShouldPersistTaps".
+//
+// TODO(rn-parity): `stickyHeaderHiddenOnScroll` is completely absent — no prop surface, no state,
+// no adapter wiring (`grep -rn "stickyHeaderHiddenOnScroll\|hiddenOnScroll"` returns zero hits).
+// Vendor composes an `Animated.diffClamp` over the scroll delta and adds it to the ordinary sticky
+// translateY (`ScrollViewStickyHeader.js:39,84-103`). Needs a new running clamped-offset state
+// ADDED to `STICKY_TRANSLATE_PROP` (our sticky pin is a discrete debounced number, not a live
+// `Animated` composition), and the fix touches `reduceSticky`
+// (`state/sticky-header-reducer.ts`) — the shared decision function every adapter's own sticky
+// component plus Angular's projection controller also run — not just this file. Audit skill,
+// "Found, NOT fixed: ScrollView's stickyHeaderHiddenOnScroll".
+//
 // WHAT A COMPOSED PRIMITIVE COSTS TODAY. Every adapter's ScrollView wrapper builds the same two
 // nodes: `selectScrollIntrinsics` picks a scroll intrinsic and a content intrinsic, and the
 // wrapper's body nests `<content>{children}</content>` inside `<scroll>`. That body is a framework
 // component instance per ScrollView — a Vue instance, a Solid props Proxy, Svelte anchors, an
-// Angular LView — which is precisely the currency host-primitive lowering exists to delete
-// (`.claude/rules/host-primitive-tier.md`). `foldPayload` gave a lowered primitive its wrapper's
-// PROP MAPPING; nothing gave it the wrapper's COMPOSITION, so a composed primitive could not be
-// lowered at all no matter what its props did. This is that half.
+// Angular LView — which is precisely the currency a tag exists to delete. `foldPayload` gives a tag
+// its wrapper's PROP MAPPING; nothing gave it the wrapper's COMPOSITION, so a composed primitive
+// could not become a tag at all no matter what its props did. This is that half.
 //
 // WHY THE TAG CARRIES THE AXIS. `buildStructure` runs at `createElement`, before a single prop is
 // routed, so it cannot read `horizontal`. It does not need to: horizontal scroll is already a
@@ -39,15 +56,12 @@
 // content node: `RCTScrollView > RCTScrollContentView > RCTScrollContentView`. So the precondition
 // per adapter is that nothing else builds the content node.
 //
-// A SECOND TAG IS NOT THE ANSWER, and this reverses what this header said until 2026-09-07. The
-// `text-input` / `text-input-managed` split is debt with a deletion date, not a technique
-// (`.claude/rules/fold-only-primitive-recipe.md` §4): each pair exists only to keep two owners
-// apart while a wrapper and a lowered element both emit a tag, and minting one here would buy a
-// rename across every call site now and a second rename when the wrapper dies. The owner's decision
-// is that the ENGINE becomes the single owner of the content node — every adapter's list and
-// wrapper stops building one — so registration waits on that cut rather than on a new spelling.
-// That cut LANDED 2026-09-11: no adapter's wrapper or list builds a content node any more, and all
-// five register this behavior through `@symbiote-native/components/register`.
+// A SECOND TAG WAS NOT THE ANSWER, and this reverses what this header said until 2026-09-07: a
+// second spelling only keeps two owners apart while two paths exist, and it buys a rename across
+// every call site now plus another when one path dies. The decision was that the ENGINE becomes the
+// single owner of the content node. That cut LANDED 2026-09-11: nothing else builds a content node
+// any more, and all five adapters register this behavior through
+// `@symbiote-native/components/register`.
 //
 // STYLE, on both nodes, and the precedence is the part that is easy to get silently wrong. The
 // wrapper composes exactly two arrays, and this reproduces both:
@@ -67,9 +81,10 @@
 // The slot's fold is assigned to the node inside `buildStructure`, not declared on the behavior:
 // `IHostBehavior.foldPayload` is the OWNER's, wired by `attachHostBehavior`, and a behavior that
 // builds a node owns what that node carries.
-import { appendChild, appListenerFor, createElement, dlog, registerHostBehavior, setBehaviorListener, setEventListener, } from '@symbiote-native/engine';
+import { appendChild, appListenerFor, createElement, dlog, registerHostBehavior, setBehaviorListener, setEventListener, setProp, } from '@symbiote-native/engine';
 import { descriptorFor } from '../../component-names';
-import { didContentSizeChange, preservesContentChildren, readLayoutDimension, resolveDecelerationRate, SCROLL_VIEW_BASE_HORIZONTAL, SCROLL_VIEW_BASE_VERTICAL, } from '../../view/render-scroll-view.js';
+import { didContentSizeChange, readLayoutDimension, } from '../../view/render-scroll-view.js';
+import { installResponderPredicates, RESPONDER_OWNED_LISTENERS, } from './responder.js';
 import { handleOwnerScroll, markScrollOwner, reconcileStickyIndices, releaseStickyOwner, stickyHeaderBehavior, STICKY_HEADER_TAG, syncOwnerLayout, } from './sticky.js';
 export const SCROLL_VIEW_TAG = 'scroll-view';
 export const HORIZONTAL_SCROLL_VIEW_TAG = 'horizontal-scroll-view';
@@ -88,8 +103,8 @@ const SLOT_DERIVED = ['maintainVisibleContentPosition', 'snapToAlignment'];
 export const REFRESH_CONTROL = descriptorFor('refresh-control').component;
 // The OWNER's fold: the per-axis base style UNDER the app's (so an explicit `flexDirection` still
 // wins), `decelerationRate` resolved from RN's two words to the platform's friction constant, and
-// the two props a lowered element has no wrapper to write for it. The resolution has to happen here
-// because 'normal'/'fast' reach Fabric as strings it cannot read.
+// the two props a tag has no wrapper to write for it. The resolution has to happen here because
+// 'normal'/'fast' reach Fabric as strings it cannot read.
 //
 // `horizontal` is a real C++ prop (`BaseScrollViewProps.h:56`) and the separate ViewManager is
 // ANDROID's — on iOS both tags resolve to RCTScrollView, so the PROP is what turns the axis there
@@ -100,78 +115,50 @@ export const REFRESH_CONTROL = descriptorFor('refresh-control').component;
 //
 // `nestedScrollEnabled` defaults ON because every wrapper writes it on every ScrollView, both
 // platforms. RN itself only defaults it on the Android RefreshControl WRAP path
-// (`ScrollView.js:1862`) — parity here is with the wrapper, which is what the lowered path replaces.
-export function ownerFold(base, horizontal) {
-    return props => {
-        const next = {
-            ...props,
-            style: [base, props.style],
-            nestedScrollEnabled: props.nestedScrollEnabled ?? true,
-        };
-        // The tag is the ONLY axis input, which is what keeps the three halves of the axis from
-        // disagreeing. RN derives all three from one prop, so a mismatch is unrepresentable there, and
-        // on iOS both tags really are RCTScrollView — a stray `horizontal` would turn a vertical
-        // scroller over a content node with no row style, a shape RN cannot produce.
-        if (props.horizontal !== undefined && props.horizontal !== horizontal) {
-            dlog(`ScrollView: horizontal=${String(props.horizontal)} ignored — the axis comes from the ` +
-                `tag; write <${horizontal ? SCROLL_VIEW_TAG : HORIZONTAL_SCROLL_VIEW_TAG}> instead`);
-        }
-        delete next.horizontal;
-        if (horizontal)
-            next.horizontal = true;
-        // The bounce pair is the axis's other consequence (`ScrollView.js:1753-1761`), ASYMMETRIC
-        // because RN falls back to `this.props.horizontal` — unset on a vertical view, so the
-        // horizontal key resolves to undefined and never reaches the payload. Both names are declared
-        // in every adapter's prop type and computed in none: vertical never bounced by default.
-        if (props.alwaysBounceHorizontal === undefined && horizontal)
-            next.alwaysBounceHorizontal = true;
-        if (props.alwaysBounceVertical === undefined)
-            next.alwaysBounceVertical = !horizontal;
-        // Consumed by the behavior and declared by no ViewConfig — neither name appears anywhere under
-        // `ReactCommon/react/renderer/components/scrollview`. `stickyHeaderIndices` decides which
-        // children get a `sticky-header`, `invertStickyHeaders` feeds the pin. Every wrapper strips both
-        // (Vue's `HANDLED_ATTRS` is the reference list), and a key Fabric does not know throws nothing,
-        // logs nothing and paints nothing — so the strip has to be here or it is never noticed.
-        delete next.stickyHeaderIndices;
-        delete next.invertStickyHeaders;
-        const rate = props.decelerationRate;
-        if (rate === 'normal' || rate === 'fast' || typeof rate === 'number')
-            next.decelerationRate = resolveDecelerationRate(rate);
-        return next;
-    };
-}
-// The SLOT's fold. Two halves with different sources, which is why it takes the owner:
+// (`ScrollView.js:1862`) — parity here is with the wrapper this behavior replaced.
+// THE OWNER'S FOLD IS GONE (2026-09-18) — `foldScrollViewProps` in `SymbioteFabricProps.cpp`. Every
+// input it had was the node's own bag plus the AXIS, and the axis is the tag (`scroll-view` vs
+// `horizontal-scroll-view`), so it was a tag rule by every criterion: the base style composition,
+// `nestedScrollEnabled`, the `horizontal` strip, the asymmetric bounce pair, the two ViewConfig-less
+// strips, and `decelerationRate`. Contract:
+// `core/engine/cpp/tests/js/scroll-view-payload.itest.ts`.
+//
+// IT WAS BLOCKED ON A MISSING LOG, not on anything about the rule. An app writing `horizontal` on
+// the vertical tag has it IGNORED, and this fold `dlog`'d where to write it instead — while
+// `core/engine/cpp` had no logging facility at all, only `throw jsi::JSError`. Moving the rule as
+// written would have deleted a diagnostic, which `<keep_logs_gate_behind_DEBUG>` forbids. So
+// `SymbioteDebug.h` was built first and this is its first caller
+// (`core/engine/cpp/tests/js/native-debug-log.itest.ts`).
+//
+// `decelerationRate`'s two constants went with it and are `#ifdef ANDROID` there: on iOS BOTH tags
+// resolve to `RCTScrollView`, so a component name cannot tell iOS-vertical from Android-vertical the
+// way `foldSwitchProps` can. That leaves the Android half outside headless reach — the same gap
+// already recorded for `android_ripple`, and the only part of this rule a test here cannot see.
+// THE SLOT'S FOLD IS GONE (2026-09-18) — `foldScrollContentProps` in `SymbioteFabricProps.cpp`.
+// Its two halves came from different places and the second is why it took until now:
 //
 //   rowStyle             a CONSTANT, horizontal only, composed OVER the app's contentContainerStyle
-//                        (the wrapper writes `[contentContainerStyle, {flexDirection:'row'}]`)
-//   collapsableChildren  DERIVED from props that stay on the OWNER, so it is read back off it
+//                        — a function of the content node's OWN tag, portable from the start
+//   collapsableChildren  DERIVED from `maintainVisibleContentPosition` / `snapToAlignment`, which
+//                        stay on the OWNER
 //
-// Written only when false, matching every wrapper — RN sends `collapsableChildren={!preserveChildren}`
-// and therefore an explicit `true`, which is the native default anyway.
-function contentFold(owner, rowStyle) {
-    return props => {
-        const preserve = preservesContentChildren(owner.props.maintainVisibleContentPosition, owner.props.snapToAlignment);
-        // The identity return IPayloadFold's contract asks for: a vertical content view with neither
-        // prop set has nothing to add, which is the common case.
-        if (rowStyle === undefined && !preserve)
-            return props;
-        const next = { ...props };
-        if (rowStyle !== undefined)
-            next.style = [props.style, rowStyle];
-        if (preserve)
-            next.collapsableChildren = false;
-        return next;
-    };
-}
-function buildContent(contentIntrinsic, rowStyle) {
+// "A per-node rule cannot reach another node" is what this file used to say, and it was a fact about
+// the JS FOLD rather than about the engine: the tree lives in C++, so a node knows its parent and
+// `fabricProps` now takes `ownerProps` from it. Contract:
+// `core/engine/cpp/tests/js/scroll-content-payload.itest.ts`.
+// `rowStyle` USED TO BE A PARAMETER HERE and is not one any more: the content node's row direction
+// is decided in the engine from that node's OWN tag (`horizontal-scroll-content`), so this builder
+// no longer needs to know the axis to build it. `scrollBehavior` still derives `horizontal` from the
+// row style for the things that DO still need it in JS.
+function buildContent(contentIntrinsic) {
     return (node) => {
         const descriptor = descriptorFor(contentIntrinsic);
         const content = createElement(descriptor.component, descriptor.isText, contentIntrinsic);
-        // The wrapper sets it on every content node, both axes (react's `contentProps`). Yoga may
-        // collapse a view that only groups children, and a collapsed content node takes the scroll
-        // metrics with it.
-        content.props = { collapsable: false };
-        content.payloadFold = contentFold(node, rowStyle);
+        // `collapsable: false` WAS SEEDED HERE AND IS NOT ANY MORE (2026-09-18). It is unconditional on
+        // every content node in both axes (`ScrollView.js:1747`), which makes it a constant of the TAG
+        // rather than of this builder — `foldScrollContentProps` writes it, and the contract is
+        // `scroll-content-payload.itest.ts` ("from the rule and not a seed", which asserts the authored
+        // prop is ABSENT because that is the only thing distinguishing the two routes).
         // Lands directly on the owner, because `node.childHost` is still undefined here: the engine
         // assigns it from what this returns. That ordering is why `buildStructure` RETURNS the slot
         // instead of setting the field itself — a behavior that set it first would redirect its own
@@ -186,8 +173,8 @@ function buildContent(contentIntrinsic, rowStyle) {
 const lastContentSize = new WeakMap();
 // RN synthesizes onContentSizeChange from the CONTENT view's own onLayout — there is no native
 // content-size event (ScrollView.js:1675 `contentSizeChangeProps`). The wrapper wired that by
-// rendering an `onLayout` onto its inner node; a lowered element has no inner node of its own, so
-// the behavior installs it on the slot it built.
+// rendering an `onLayout` onto its inner node; a tag has no inner node of its own, so the behavior
+// installs it on the slot it built.
 //
 // The app's callback takes `(width, height)`, not an event, which is why `contentSizeChange` is an
 // OWNED listener: `setEventListener` wraps an ordinary listener as `(event) => handler(event)` and
@@ -213,9 +200,9 @@ function contentSizeListener(owner) {
 }
 // RN installs the content `onLayout` only when the app passed `onContentSizeChange`, and so does
 // every wrapper — `onLayout` is a gated event, so wiring it unconditionally would put `onLayout:
-// true` in the payload of every lowered ScrollView's content node and buy a native event nobody
-// reads. A lowering that changes the committed surface in EITHER direction is a bug, so the wiring
-// has to follow the prop.
+// true` in the payload of every ScrollView's content node and buy a native event nobody reads. A
+// change to the committed surface in EITHER direction is a bug, so the wiring has to follow the
+// prop.
 //
 // It follows the LISTENER rather than a commit, which is what `onOwnedListenerChange` is for: a
 // listener flip changes no payload by itself, so the commit after it is a no-op and a post-commit
@@ -242,7 +229,7 @@ function syncOwnedListener(owner, name, wired) {
     else if (name === 'layout')
         syncOwnerLayout(owner);
 }
-function scrollBehavior(contentIntrinsic, base, rowStyle, platform) {
+function scrollBehavior(contentIntrinsic, rowStyle, platform) {
     // The row style is the horizontal tag's constant and nothing else carries it, so it IS the axis —
     // deriving keeps the two from ever disagreeing about which behavior this is.
     const horizontal = rowStyle !== undefined;
@@ -252,13 +239,16 @@ function scrollBehavior(contentIntrinsic, base, rowStyle, platform) {
         // view unconditionally and calls the app's own handler from inside them, and `node.listeners`
         // is single-slot — so a behavior that installed either without owning it would silently evict
         // the app's.
-        ownedListeners: ['contentSizeChange', 'scroll', 'layout'],
+        ownedListeners: [
+            'contentSizeChange',
+            'scroll',
+            'layout',
+            ...RESPONDER_OWNED_LISTENERS,
+        ],
         slotProps: SLOT_PROPS,
         slotDerived: [...SLOT_DERIVED, ...(platform.slotDerived ?? [])],
         claimedChildren: { [REFRESH_CONTROL]: platform.claimMode },
-        onWrapChange: platform.onWrapChange?.(base, horizontal),
-        buildStructure: buildContent(contentIntrinsic, rowStyle),
-        foldPayload: ownerFold(base, horizontal),
+        buildStructure: buildContent(contentIntrinsic),
         // The scroll dispatcher is installed here and never conditionally: it is what drives the
         // sticky AnimatedValue, and a header can register long after this node was created. It costs a
         // forward per scroll event on a ScrollView with no sticky child, which is what RN pays too.
@@ -266,6 +256,7 @@ function scrollBehavior(contentIntrinsic, base, rowStyle, platform) {
         attach(node) {
             markScrollOwner(node);
             setBehaviorListener(node, 'scroll', event => handleOwnerScroll(node, event));
+            installResponderPredicates(node);
         },
         onOwnedListenerChange: syncOwnedListener,
         // The one beat at which the app's children are all present — `stickyHeaderIndices` addresses
@@ -282,8 +273,17 @@ function scrollBehavior(contentIntrinsic, base, rowStyle, platform) {
 // Both axes, given the platform's answer to the RefreshControl question. The platform files call
 // this; nothing else should.
 export function registerScrollViewBehaviors(platform) {
-    registerHostBehavior(SCROLL_VIEW_TAG, scrollBehavior('scroll-content', SCROLL_VIEW_BASE_VERTICAL, undefined, platform));
-    registerHostBehavior(HORIZONTAL_SCROLL_VIEW_TAG, scrollBehavior('horizontal-scroll-content', SCROLL_VIEW_BASE_HORIZONTAL, { flexDirection: 'row' }, platform));
+    registerHostBehavior(SCROLL_VIEW_TAG, scrollBehavior('scroll-content', undefined, platform));
+    registerHostBehavior(HORIZONTAL_SCROLL_VIEW_TAG, scrollBehavior('horizontal-scroll-content', { flexDirection: 'row' }, platform));
+    // REGISTRATIONS WITH NO RUNTIME, and they are what hand the content tags to the host. A tag
+    // crosses only through `recordSetTag`, which `attachHostBehavior` emits, so a tag with no behavior
+    // registered carries an EMPTY `tagName` in C++ and no rule can fire for it. These two nodes are
+    // built by `buildStructure` and named by no app, which is exactly the shape that trap has.
+    //
+    // Same reasoning as `activity-indicator-spinner`'s stub: a registration is how this codebase says
+    // a tag HAS platform semantics, which is the claim being made.
+    for (const contentTag of ['scroll-content', 'horizontal-scroll-content'])
+        registerHostBehavior(contentTag, { attach() { }, detach() { } });
     // With the scroll views, never on its own: a sticky header is meaningless without an owner to
     // find, and registering the pair together is what makes "did the registration run" one question
     // rather than two.

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

@@ -1,5 +1,6 @@
 import { type IHostBehavior, type ISymbioteEvent, type ISymbioteNode } from '@symbiote-native/engine';
 export declare const STICKY_HEADER_TAG = "sticky-header";
+export declare const STICKY_TRANSLATE_PROP = "stickyTranslateY";
 export declare function markScrollOwner(node: ISymbioteNode): void;
 export declare function hasStickyHeaders(owner: ISymbioteNode): boolean;
 export declare function syncOwnerLayout(owner: ISymbioteNode): void;

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

@@ -1,11 +1,11 @@
-// Sticky headers on the lowered path. BOTH forms live here — the CHILD form (`<sticky-header>`, the
-// path our own lists use) and the INDEX form (`stickyHeaderIndices`, RN's public API) — plus the
-// owner-side half that feeds them.
+// Sticky headers. BOTH forms live here — the CHILD form (`<sticky-header>`, the path our own lists
+// use) and the INDEX form (`stickyHeaderIndices`, RN's public API) — plus the owner-side half that
+// feeds them.
 //
 // WHY A CHILD AT ALL. `stickyHeaderIndices` is an index list because JSX has no way to MARK an
-// element — RN walks its own children array and wraps the flagged ones. `<StickyHeader>` says the
-// same thing in the one place a lowered element can read without an index: the tag of a node that
-// is already in the tree.
+// element — RN walks its own children array and wraps the flagged ones. `<sticky-header>` says the
+// same thing in the one place the engine can read without an index: the tag of a node that is
+// already in the tree.
 //
 // THE INDEX FORM IS BUILT (2026-09-07), and this header said it was impossible until then. Both
 // halves of that claim were false, measured against Angular's projection controller, which already
@@ -44,13 +44,19 @@
 // `scrollEventThrottle` (RN raises it so the offset reaches the AnimatedValue at all), the scroll
 // listener that drives that value, and — inverted only — the viewport height the pin math needs.
 // A separate module would have to export a registry back and forth.
-import { AnimatedProps, AnimatedValue, appendChild, appListenerFor, createElement, dlog, insertBefore, isAnchor, isNativeAnimatedAvailable, markPropsDirty, Platform, removeChild, requestCommitFor, setBehaviorListener, setProp, whenCommitted, } from '@symbiote-native/engine';
+import { AnimatedProps, AnimatedValue, appendChild, appListenerFor, createElement, dlog, insertBefore, isAnchor, isNativeAnimatedAvailable, Platform, removeChild, requestCommitFor, setBehaviorListener, setProp, whenCommitted, propOf, childrenOf, parentOf, } from '@symbiote-native/engine';
 import { descriptorFor } from '../../component-names';
 import { attachStickyScroll } from '../../scroll-view-commands.js';
+import { markScrollObserved } from './responder.js';
 import { createInitialStickyState, reduceSticky, } from '../../state/sticky-header-reducer.js';
 import { readLayoutNumber, STICKY_HEADER_Z_INDEX, } from '../../view/render-scroll-sticky.js';
 import { resolveScrollForwarding } from '../../view/render-scroll-view.js';
 export const STICKY_HEADER_TAG = 'sticky-header';
+// The machine's one channel to its tag rule, and the only prop it ever writes. RN's twin is
+// `passthroughAnimatedPropExplicitValues` (`ScrollViewStickyHeader.js:282-304`), a whole style
+// object; ours carries the one number that object ever holds, so it does not borrow the name.
+// `foldStickyHeaderProps` composes it into the style and strips the key — no ViewConfig declares it.
+export const STICKY_TRANSLATE_PROP = 'stickyTranslateY';
 // The scroll views that could own a header, so a header can find its own by walking up. The tag is
 // not on the node (`createElement` looks the behavior up and stores nothing), and the parent chain
 // is the only route — a header may sit any depth below the content view.
@@ -69,7 +75,7 @@ export function hasStickyHeaders(owner) {
 // otherwise), which is exactly when RN wraps the scroll view's own onLayout — so the gate flag
 // lands on the same ScrollViews the wrapper puts it on and on no others.
 function needsViewportHeight(owner) {
-    return hasStickyHeaders(owner) && owner.props.invertStickyHeaders === true;
+    return (hasStickyHeaders(owner) && propOf(owner, 'invertStickyHeaders') === true);
 }
 function ownerSticky(owner) {
     const existing = stickyOwners.get(owner);
@@ -113,7 +119,7 @@ function syncNativeScroll(owner, sticky) {
 // Depth-first over the content subtree, which IS document order — the same order RN's children
 // walk produces, arrived at from the tree instead of from an index array.
 function collectHeaders(node, members, out) {
-    for (const child of node.children) {
+    for (const child of childrenOf(node)) {
         if (members.has(child))
             out.push(child);
         collectHeaders(child, members, out);
@@ -138,7 +144,7 @@ function orderedHeaders(owner, sticky) {
 // The attach happens after the header has registered, which is the same ordering React's
 // `useEffect` gives it.
 function syncThrottle(owner, sticky) {
-    const current = owner.props.scrollEventThrottle;
+    const current = propOf(owner, 'scrollEventThrottle');
     // Whatever stands in the key is the APP's unless it is byte-for-byte the value written here —
     // which is what makes the take-back on the last unregister safe.
     const ours = sticky.writtenThrottle !== undefined && current === sticky.writtenThrottle;
@@ -194,6 +200,10 @@ function readContentOffsetY(event) {
 // the app's own `onScroll` is an OWNED name and would otherwise evict this one from the single
 // listener slot.
 export function handleOwnerScroll(owner, event) {
+    // RN's `_handleScroll` (`ScrollView.js:1145-1147`) sets this unconditionally too — nothing reads
+    // it unless this node actually holds the responder, so an unconditional set on every scroll is
+    // exactly as safe here as it is there. See `./responder.ts`.
+    markScrollObserved(owner);
     const sticky = stickyOwners.get(owner);
     // Skipped while the offset rides the UI thread: the native attach already drives the value every
     // frame, so writing it again from a JS event is a redundant graph update at a WORSE rate.
@@ -226,7 +236,7 @@ export function releaseStickyOwner(owner) {
     stickyOwners.delete(owner);
 }
 // ---------------------------------------------------------------- the index form
-// `stickyHeaderIndices` on the lowered path, and it is deliberately NOT a second machine: a flagged
+// `stickyHeaderIndices`, and it is deliberately NOT a second machine: a flagged
 // child is MOVED into a synthesized `sticky-header` node, so ordering, cross-talk, the raised
 // throttle, the pin and the teardown are the child form's, unchanged. Indices decide only WHICH
 // children get one.
@@ -275,9 +285,19 @@ function wrapForIndex(slot, child) {
     // so the wrapper takes the position the child vacates and nothing has to be removed.
     insertBefore(slot, wrapper, child);
     appendChild(wrapper, child);
+    // AFTER both, or the anchor above would resolve to the wrapper itself. `wrapper` is the engine's
+    // own "what stands in this node's place" indirection (`ISymbioteNode.wrapper`), and a sticky
+    // wrapper is exactly that: the framework keeps naming the ScrollView and the row, while the tree
+    // holds the wrapper in the row's place — so a later `removeChild(owner, row)` takes the wrapper
+    // out with it instead of being refused for naming a parent the row no longer has.
+    child.wrapper = wrapper;
 }
 function unwrapIndex(slot, wrapper) {
-    const child = wrapper.children[0];
+    const child = childrenOf(wrapper)[0];
+    // Before the move, for the same reason it is set after one: `insertBefore` would otherwise put
+    // the wrapper back in the child's place.
+    if (child !== undefined)
+        child.wrapper = undefined;
     if (child !== undefined)
         insertBefore(slot, child, wrapper);
     removeChild(slot, wrapper);
@@ -294,7 +314,7 @@ export function reconcileStickyIndices(owner) {
     const slot = owner.childHost;
     if (slot === undefined)
         return;
-    const wanted = stickyIndexSet(owner.props.stickyHeaderIndices);
+    const wanted = stickyIndexSet(propOf(owner, 'stickyHeaderIndices'));
     if (wanted === undefined && !ownersWithIndexWrappers.has(owner))
         return;
     let paintIndex = 0;
@@ -304,13 +324,14 @@ export function reconcileStickyIndices(owner) {
     //
     // A claimed `<RefreshControl>` needs no filter here, unlike Angular's walk — `hostFor` keeps a
     // claimed child on the OWNER, so it never reaches the slot at all.
-    for (const child of [...slot.children]) {
+    for (const child of [...childrenOf(slot)]) {
         const wrapper = indexWrappers.has(child) ? child : undefined;
         if (wrapper !== undefined) {
             // The framework removes a child from the SLOT, because that is where it appended it — so the
             // engine's `removeChild` finds nothing to splice and only clears `child.parent`, leaving a
             // committed wrapper around a node nobody owns. This walk is the only thing that can see it.
-            if (wrapper.children[0]?.parent !== wrapper) {
+            const held = childrenOf(wrapper)[0];
+            if (held === undefined || parentOf(held) !== wrapper) {
                 removeChild(slot, wrapper);
                 changed = true;
                 continue;
@@ -351,11 +372,11 @@ export function reconcileStickyIndices(owner) {
 }
 // ---------------------------------------------------------------- the header half
 function findScrollOwner(node) {
-    let current = node.parent;
+    let current = parentOf(node);
     while (current !== undefined) {
         if (scrollOwners.has(current))
             return current;
-        current = current.parent;
+        current = parentOf(current);
     }
     return undefined;
 }
@@ -370,28 +391,16 @@ function nextHeaderY(runtime, node) {
     const next = order[order.indexOf(node) + 1];
     return next === undefined ? undefined : sticky.layoutYs.get(next);
 }
-// The committed half of the pin: the debounced translateY RN pushes into the transform for
-// hit-testing (`passthroughAnimatedPropExplicitValues`), plus the two constants the wrapper always
-// carries. The SMOOTH half rides the AnimatedProps leaf below and never passes through here.
+// STICKY FOLD LEFT THIS FILE ON 2026-09-18, and it was the last `payloadFold` in the codebase.
 //
-// A per-node fold, assigned in `attach`, because what it reads is per-node runtime state rather
-// than a prop — the behavior-level `foldPayload` gets props and nothing else.
-function stickyFold(runtime) {
-    return props => {
-        const pin = { zIndex: STICKY_HEADER_Z_INDEX };
-        if (runtime.state.translateY !== null)
-            pin.transform = [{ translateY: runtime.state.translateY }];
-        return {
-            ...props,
-            // Over the app's, never under: the pin is the whole point of the element, and a header whose
-            // own style set a transform would otherwise cancel it.
-            style: [props.style, pin],
-            // Yoga may flatten a view that only groups children, and a flattened header has no transform
-            // to animate. RN's sticky wrapper sets it for the same reason.
-            collapsable: false,
-        };
-    };
-}
+// It wrote three things and they had two different origins. `zIndex: 10` and `collapsable: false`
+// are constants of the wrapper — the platform's in any app — and the debounced translate is the
+// machine's. Splitting them that way is what let the whole rule move: `foldStickyHeaderProps` in
+// `SymbioteFabricProps.cpp` owns the composition now, and the one live number crosses as an
+// ordinary prop (`STICKY_TRANSLATE_PROP`), which is how RN spells it too.
+//
+// Contract: `core/engine/cpp/tests/js/sticky-header-payload.itest.ts`. There is no JS twin — a
+// payload rule asserted against a second copy of itself is asserted against nothing.
 function dispatch(node, action) {
     const runtime = headerRuntimes.get(node);
     if (runtime === undefined || runtime.owner === undefined)
@@ -399,7 +408,7 @@ function dispatch(node, action) {
     const sticky = stickyOwners.get(runtime.owner);
     const result = reduceSticky(runtime.state, action, {
         os: Platform.OS,
-        inverted: runtime.owner.props.invertStickyHeaders === true,
+        inverted: propOf(runtime.owner, 'invertStickyHeaders') === true,
         scrollViewHeight: sticky?.viewportHeight,
         nextHeaderLayoutY: nextHeaderY(runtime, node),
     });
@@ -420,16 +429,21 @@ function runEffects(node, runtime, effects) {
                 }, effect.delay);
                 break;
             case 'apply-passthrough':
-                // The fold reads `runtime.state`, which no prop write touched, so nothing has marked the
-                // node — and dirtying is not publishing, hence both calls.
+                // The machine's one channel to its tag rule. A prop rather than runtime state the fold
+                // reaches back for, because RN spells this the same way
+                // (`ScrollViewStickyHeader.js:302`, `passthroughAnimatedPropExplicitValues`) and because a
+                // prop write is what the rule in `SymbioteFabricProps.cpp` can read at all.
+                //
+                // The write marks the node itself, so only the commit request is still owed — dirtying is
+                // not publishing.
                 //
-                // NOT witnessed by a headless test, and the reason is worth knowing before deleting it:
-                // while the pin is JS-driven the animated leaf's own `setNativeProps` has already written
-                // the same transform and marked the node, so removing this line reddens nothing here. It
-                // is the NATIVE-driver path this exists for — there the leaf stops writing JS-side and the
-                // committed transform is all hit-testing has, which is exactly why RN keeps
-                // `passthroughAnimatedPropExplicitValues` beside the animated one.
-                markPropsDirty(node);
+                // WHY A COMMIT IS REQUESTED AT ALL, and it is NOT witnessed by a headless test: while the
+                // pin is JS-driven the animated leaf's own `setNativeProps` has already written the same
+                // transform and marked the node, so removing this reddens nothing here. It is the
+                // NATIVE-driver path it exists for — there the leaf stops writing JS-side and the committed
+                // transform is all hit-testing has, which is why RN keeps that explicit value beside the
+                // animated one.
+                setProp(node, STICKY_TRANSLATE_PROP, effect.translateY);
                 requestCommitFor(node);
                 break;
             case 'record-header-y':
@@ -509,7 +523,6 @@ function attach(node) {
         cancelBind: undefined,
     };
     headerRuntimes.set(node, runtime);
-    node.payloadFold = stickyFold(runtime);
     setBehaviorListener(node, 'layout', event => handleHeaderLayout(node, event));
 }
 // The registration waits for a committed tag rather than happening in `attach`, and both halves of