@symbiote-native/components 3.1.0 → 3.1.2

package/build/component-names/index.android.js

@@ -31,18 +31,16 @@ const ANDROID_NAMES = {
     switch: 'AndroidSwitch',
     'activity-indicator': 'RCTView',
     'activity-indicator-spinner': 'AndroidProgressBar',
-    // DELIBERATE DIVERGENCE FROM RN (2026-09-23). RN's `SafeAreaView.js` is a plain View on Android,
-    // with no insets. `RCTSafeAreaView` is registered there too (`ReactSafeAreaViewManager`) and
-    // applies the window insets, so one screen is safe on both platforms.
+    // DELIBERATE DIVERGENCE FROM RN: `SafeAreaView.js` is a plain View on Android, with no insets.
+    // `RCTSafeAreaView` applies the window insets there too (`ReactSafeAreaViewManager`), so one
+    // screen is safe on both platforms.
     'safe-area-view': 'RCTSafeAreaView',
     modal: 'RCTModalHostView',
     'refresh-control': 'AndroidSwipeRefreshLayout',
     'sticky-header': 'RCTView',
-    // `InputAccessoryView.js` on Android does `console.warn(...); return null` — the WHOLE component,
-    // children included, renders NOTHING. A plain `RCTView` container (this file's answer until
-    // 2026-09-20) committed a real, laid-out, potentially visible node plus its whole child subtree —
-    // a real divergence from vendor, not a harmless degrade. `VOID_COMPONENT` matches vendor exactly:
-    // no node, no children, on this platform only.
+    // `InputAccessoryView.js` on Android does `console.warn(...); return null` — the WHOLE
+    // component, children included, renders NOTHING. `VOID_COMPONENT` matches vendor exactly: no
+    // node, no children, on this platform only.
     'input-accessory-view': VOID_COMPONENT,
 };
 export const COMPONENT_DESCRIPTORS = buildDescriptors(ANDROID_NAMES);

package/build/component-names/shared.js

@@ -1,9 +1,6 @@
-// The intrinsic JSX types symbiote's host config maps to Fabric components, plus the
-// machinery to turn a platform name table into the descriptors the host config reads.
-// The Fabric NAME of a primitive is platform-specific (iOS 'Switch' vs
-// Android 'AndroidSwitch'), so the name tables live in component-names.ios.ts /
-// .android.ts and the filename selects, no Platform.OS read. The isText flag is
-// platform-invariant, so it lives here once and both tables share it.
+// The intrinsic JSX types symbiote's host config maps to Fabric components. A Fabric name is
+// platform-specific, so name tables live in component-names.ios/.android.ts, selected by
+// filename; `isText` is platform-invariant and lives here once.
 // The only text-laying intrinsic; drives the RCTText / RCTVirtualText nesting choice
 // (a <Text> inside another <Text> becomes a virtual span). Platform-invariant, so it is
 // not part of the per-platform name table.
@@ -20,32 +17,18 @@ export function buildDescriptors(names) {
     }
     return descriptors;
 }
-// Resolve an intrinsic type to its descriptor, against the platform-selected map. The
-// logic is identical for every adapter (and was duplicated in React's host-config and
-// Vue's component-names), so it lives here once; each platform file binds it to its own
-// COMPONENT_DESCRIPTORS. A `symbiote-*` miss is a typo in our own code; any other string
-// is a raw Fabric view name from a library's codegen component and flows through untouched
-// (the engine derives its events/processors from the view's ViewConfig, no per-library glue).
+// Resolve an intrinsic type to its descriptor against the platform-selected map, so each
+// platform file binds it to its own COMPONENT_DESCRIPTORS. Any string with no descriptor is a
+// raw Fabric view name from a library's codegen component and flows through untouched.
 export function makeDescriptorFor(descriptors) {
     const unrewritten = publicNamesThatAreNotViewNames(descriptors);
     return type => {
         const descriptor = descriptors[type];
         if (descriptor !== undefined)
             return descriptor;
-        // NO "unknown tag of ours" throw any more, and the reason is the whole cost of dropping the
-        // prefix: `symbiote-*` was a MARKER, so a miss carrying it could only be our own typo. Without
-        // it this namespace holds three populations that a string cannot tell apart —
-        //
-        //   view · scroll-view          ours
-        //   counter-child · app-root    an Angular app's OWN component selectors, kebab by convention
-        //   RCTView · RNCSlider         a Fabric view name, resolving through the fallthrough below
-        //
-        // — and the first attempt at a replacement ("lowercase is ours") threw on the second row, which
-        // is most of an Angular app. Measured: 222 tests, the primary failure being `counter-child`.
-        //
-        // What replaces it is stronger and is not runtime at all: `ISymbioteIntrinsic` is a closed
-        // union, so a misspelled tag in our own source is a compile error at every call site that names
-        // one. The guard was only ever a backstop for a name built dynamically.
+        // No "unknown tag" throw here: this namespace holds three populations no string alone can
+        // tell apart — our own tags, an Angular app's own kebab-case selectors, and a Fabric view
+        // name. `ISymbioteIntrinsic` being a closed union makes a misspelled tag a compile error.
         if (unrewritten.has(type)) {
             throw new Error(`"${type}" is a primitive's PUBLIC name, not a Fabric view name — a rewrite was missed. ` +
                 `Expected the intrinsic tag (e.g. "view"). Falling through would have committed ` +
@@ -54,22 +37,9 @@ export function makeDescriptorFor(descriptors) {
         return { component: type, isText: false };
     };
 }
-// A primitive's public name reaching here means an adapter's rewrite missed a call site. Without
-// this the name falls through as a raw Fabric view name and commits a view literally called `View`
-// — no error at any layer, wrong only on a device.
-//
-// Both halves are DERIVED, because a hand-written list of either would be wrong within a release.
-// The names come from the intrinsic union (kebab -> Pascal); the exclusions come from the platform's
-// own table, and deriving them is not tidiness — two public names ARE real Fabric view names, so a
-// hand-written block list would break an adapter's thin wrapper over a third-party native view,
-// which resolves by view name through this same function.
-//
-// AND THE EXCLUSION IS PER PLATFORM, which is why it must be computed from the table rather than
-// stated. `Switch` and `SafeAreaView` are iOS view names; Android spells them `AndroidSwitch` and
-// `RCTSafeAreaView`, so the same public name is EXCLUDED on iOS and BLOCKED on Android. That
-// asymmetry is correct — nothing legitimate resolves by the bare name on Android — but a reader who
-// takes "these two are real view names" as platform-invariant will conclude the guard is broken on
-// one side or the other.
+// A primitive's public name reaching here means an adapter's rewrite missed a call site —
+// otherwise it commits a view literally called `View`. Both halves are DERIVED, not hand-written:
+// some public names (`Switch` on iOS) ARE real view names, and which is per-platform.
 function publicNamesThatAreNotViewNames(descriptors) {
     const viewNames = new Set(Object.values(descriptors).map(descriptor => descriptor.component));
     const names = new Set();

package/build/index.js

@@ -53,10 +53,8 @@ export { canUseNativeForeground, selectableBackground, selectableBackgroundBorde
 // element is a tag now, and a tag is a string that cannot carry `.Ripple`.
 TouchableNativeFeedback, } from './view/render-touchable-native-feedback.js';
 // Button: `resolveButtonDisabled` alone now — the `props.disabled ?? aria ?? state.disabled`
-// precedence, which the press MACHINE reads and which is therefore still JS. Every platform fold
-// Button.js performs left this barrel between 2026-09-17 and 2026-09-18 for
-// `SymbioteFabricProps.cpp`; the last two, `buttonViewStyle` and `resolveButtonViewStyle`, went with
-// the Android arm of the test host that finally made their branch assertable.
+// precedence, which the press MACHINE reads and stays JS. Every platform fold Button.js performs
+// is `SymbioteFabricProps.cpp`'s.
 export { resolveButtonDisabled } from './view/render-button.js';
 // TextInput: the controlled-value / event-count handshake, and ONLY that now — the machine. The
 // W3C->native prop resolution that used to sit beside it is the engine's (`foldTextInputAliases`,
@@ -80,25 +78,21 @@ export { registerPressableBehavior, PRESSABLE_TAG, } from './behaviors/pressable
 export { registerTouchableOpacityBehavior, TOUCHABLE_OPACITY_TAG, } from './behaviors/touchable-opacity.js';
 export { registerTouchableHighlightBehavior, TOUCHABLE_HIGHLIGHT_TAG, } from './behaviors/touchable-highlight.js';
 export { registerButtonBehavior, BUTTON_TAG } from './behaviors/button.js';
-// Registered by ALL FIVE adapters since 2026-09-09, in the same commit that deleted the five
-// wrappers — which is what makes it safe. While those wrappers still rendered a `Pressable` around
-// a feedback `View`, registering would have put a second responder on every existing
-// TouchableNativeFeedback. The ActivityIndicator and ScrollView blocks below are still in the
-// withheld state this one just left.
+// Registered by ALL FIVE adapters, in the same commit that deleted the five wrappers — safe
+// only because those wrappers no longer render their own Pressable, which would put a second
+// responder on every TouchableNativeFeedback.
 export { registerTouchableNativeFeedbackBehavior, TOUCHABLE_NATIVE_FEEDBACK_TAG, } from './behaviors/touchable-native-feedback.js';
 // The second tag that commits no node, and registered by all five adapters in the same commit that
 // deleted their five wrappers — while those wrappers still rendered a `Pressable` around the app's
 // children, registering would have put a second responder on every TouchableWithoutFeedback.
 export { registerTouchableWithoutFeedbackBehavior, TOUCHABLE_WITHOUT_FEEDBACK_TAG, } from './behaviors/touchable-without-feedback.js';
-// Registered by all five adapters since 2026-09-09, in the same commit that deleted the five
-// wrappers — the tag builds its own spinner, so a surviving wrapper would have painted a second one.
-// The prop type rides along: there is no `view/render-activity-indicator.ts` any more, because the
-// only render this primitive had was the two nodes the behavior now builds.
+// Registered by all five adapters, in the same commit that deleted the five wrappers — the tag
+// builds its own spinner, so a surviving wrapper would have painted a second one. No
+// `view/render-activity-indicator.ts`: the behavior now builds the only two nodes this had.
 export { ACTIVITY_INDICATOR_SPINNER_TAG, ACTIVITY_INDICATOR_TAG, registerActivityIndicatorBehavior, } from './behaviors/activity-indicator';
 export { IMAGE_TAG, registerImageBehavior } from './behaviors/image.js';
-// Registered by all five adapters since 2026-09-09, in the same commit that deleted the five
-// wrappers — the tag builds the background image itself, so a surviving wrapper would have
-// committed a second one under it.
+// Registered by all five adapters, in the same commit that deleted the five wrappers — the tag
+// builds the background image itself, so a surviving wrapper would have committed a second one.
 export { IMAGE_BACKGROUND_TAG, registerImageBackgroundBehavior, } from './behaviors/image-background.js';
 export { INPUT_ACCESSORY_VIEW_TAG, registerInputAccessoryViewBehavior, } from './behaviors/input-accessory-view.js';
 export { registerTextInputBehavior, buildTextInputHandle, TEXT_INPUT_TAG, TEXT_INPUT_MULTILINE_TAG, } from './behaviors/text-input.js';
@@ -109,7 +103,7 @@ export { registerRefreshControlBehavior, REFRESH_CONTROL_TAG, } from './behavior
 // caller of `registerScrollViewBehavior()` names it. The shape CLAUDE.md forbids is a module whose
 // evaluation alone registers.
 //
-// EVERY ADAPTER CALLS IT since 2026-09-11, through `@symbiote-native/components/register`. It was
-// withheld while the wrappers built their own content node — registering then would have
-// double-nested every ScrollView. They are gone; the engine is the single owner.
+// EVERY ADAPTER CALLS IT, through `@symbiote-native/components/register`. Withheld while the
+// wrappers built their own content node — registering then would have double-nested every
+// ScrollView. They are gone; the engine is the single owner.
 export { HORIZONTAL_SCROLL_VIEW_TAG, registerScrollViewBehavior, SCROLL_VIEW_TAG, STICKY_HEADER_TAG, } from './behaviors/scroll-view';

package/build/scroll-view-commands.js

@@ -1,20 +1,12 @@
-// ScrollView: the imperative + style-routing module (framework-agnostic, no 3-layer split:
-// ScrollView has no state machine). The imperative handle, the layout/visual style split for
-// the Android RefreshControl wrap, the scroll-event guard/forwarder, and the native sticky
-// scroll-attach are all platform- and framework-invariant, so they live here. The adapter
-// supplies the lifecycle (the node getter, the effect) and re-exports these.
-import { attachNativeEvent, dlog, flattenStyle, isSymbioteEvent, } from '@symbiote-native/engine';
-// THE ANDROID WRAP SPLIT LEFT THIS FILE ON 2026-09-18, and with it the last copy of RN's
-// `splitLayoutProps` key partition. Both halves are `SymbioteFabricProps.cpp` now
-// (`splitScrollViewStyle`, `foldRefreshWrapperProps`), reached off the tag and the tree rather than
-// from a `payloadFold` per node — see `behaviors/scroll-view/index.android.ts` for what made the
-// wrapper's half possible at all.
-//
-// Nothing replaced them here on purpose: a JS copy kept for a caller that no longer exists is the
-// mirror shape this migration keeps deleting, and the twenty-eight layout keys are exactly the kind
-// of list that drifts in silence. `core/engine/cpp/tests/js/scroll-view-wrap-payload.itest.ts`
-// asserts the split on the payload a commit actually sent, which is the only place it can now be
-// wrong.
+// ScrollView: the imperative + event-routing module (framework-agnostic, no 3-layer split:
+// ScrollView has no state machine). The imperative handle, the scroll-event guard/forwarder, and
+// the native sticky scroll-attach are platform- and framework-invariant, so they live here. The
+// Android RefreshControl wrap's style split moved out — see the note below. The adapter supplies
+// the lifecycle (the node getter, the effect) and re-exports these.
+import { attachNativeEvent, dlog, isSymbioteEvent, } from '@symbiote-native/engine';
+// The Android wrap's style split (`splitScrollViewStyle`, `foldRefreshWrapperProps`) is
+// `SymbioteFabricProps.cpp`'s, reached off the tag and tree rather than a `payloadFold` per node.
+// Contract: `scroll-view-wrap-payload.itest.ts`, asserted on the payload a commit actually sent.
 // Re-exported so the package barrel (index.ts) can still export this guard to
 // '@symbiote-native/components' callers, now that it lives in the engine, next to ISymbioteEvent.
 export { isSymbioteEvent };

package/build/state/pressable.js

@@ -1,22 +1,14 @@
-// Pressable, the logic half (framework-agnostic, zero render, zero framework imports). The
-// press lifecycle RN's Pressability runs in JS (pressIn/pressOut/press synthesis, the
-// long-press timer, unstable_pressDelay deferral, and the pressRetentionOffset drift test)
-// lives here as a pure state machine over a mutable runtime plus an adapter-supplied host. The
-// adapter owns only the lifecycle wiring: React holds the runtime in a ref and flips `pressed`
-// via setState; Vue holds it in setup scope and flips a ref. Both call the SAME handlers.
-//
-// Framework-specific, stays in the adapter: the `pressed` state cell (it drives a
-// re-render, so each framework owns its reactive primitive) and the raw frame-measure (the host
-// node plus its measure call). The rest (the timers, the geometry, the suppression flags,
-// the decision of when each callback fires) is here, shared by every adapter.
+// Pressable, the logic half (framework-agnostic, zero render). The press lifecycle RN's
+// Pressability runs in JS lives here as a pure state machine over a mutable runtime plus an
+// adapter-supplied host. Both React and Vue call the SAME handlers, differing only in lifecycle.
+// Framework-specific, stays in the adapter: the `pressed` state cell (drives a re-render, so each
+// framework owns its reactive primitive) and the raw frame-measure. The rest — timers, geometry,
+// suppression flags, when each callback fires — is here, shared by every adapter.
 import { dlog, Platform, SoundManager, } from '@symbiote-native/engine';
 export const DEFAULT_DELAY_LONG_PRESS_MS = 500;
-// Pressability.js's DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE. A SEPARATE, smaller radius than
-// `pressRetentionOffset`/`hitSlop`: any move past it cancels a pending long press even while the
-// finger is still well inside the retention rect — real presses jitter a few px, long-press must
-// not fire mid-scroll. Vendor exposes it only as a rare static override
-// (`Pressability.setLongPressDeactivationDistance`, used by e.g. gesture libraries), never as a
-// per-component prop, so it stays a plain constant here rather than a config field.
+// A SEPARATE, smaller radius than pressRetentionOffset/hitSlop: any move past it cancels a
+// pending long press even while the finger is still well inside the retention rect — real presses
+// jitter a few px, long-press must not fire mid-scroll.
 export const LONG_PRESS_DEACTIVATION_DISTANCE = 10;
 // Pressability's default active-visual floor for a plain Pressable. Touchable* overrides this to 0.
 export const DEFAULT_MIN_PRESS_DURATION_MS = 130;
@@ -120,10 +112,8 @@ export function disposePressRuntime(runtime) {
     runtime.delayElapsed = false;
 }
 // Measure the responder's on-screen frame and cache it as the retention region for the life of
-// the press (RN measures on responder grant, _measureResponderRegion). When measure is
-// unavailable (no node yet, an uncommitted node, or a host slot without a measure method,
-// headless) the region stays undefined and the move test falls back to the radius bound. The
-// try/catch guards that last case: a slot lacking measure throws rather than no-opping.
+// the press. When measure is unavailable the region stays undefined and the move test falls back
+// to the radius bound; the try/catch guards a slot lacking measure throwing rather than no-opping.
 function measureRegion(runtime, measureFn) {
     runtime.region = undefined;
     if (measureFn === undefined)
@@ -157,18 +147,9 @@ export function createPressHandlers(config, runtime, host) {
     const fallbackThreshold = maxEdge(hitSlopRect) + maxEdge(pressRectOffset);
     // True iff the touch still belongs to the active press: against the measured rect when we have
     // one (the RN-faithful path), else the symmetric radius fallback.
-    //
-    // TODO(rn-parity): `Pressability.js`'s `onResponderMove` (:489-493) returns right after the
-    // app's `onPressMove`, before any drift/long-press-jitter check, whenever the region is not yet
-    // measured — vendor treats "no measurement yet" as "do nothing until one arrives." The radius
-    // fallback below diverges: it judges drift/jitter on synthetic geometry instead of waiting.
-    // Confirmed unreachable on a real device (`Tree::measure` in `SymbioteTree.cpp` is a synchronous
-    // JSI call, so the region is always populated before `handleResponderMove` can fire), so the
-    // fallback only ever fires in this codebase's own test harness, which wires
-    // `getMeasureFn: () => undefined` everywhere (`state/pressable.test.ts:84` and every touchable
-    // test built on it). A real fix needs a synchronous mock-measure harness under 11+ existing
-    // drift/retention/long-press call sites across `pressable.test.ts`, `touchable-opacity.test.ts`
-    // and `render-pressable.test.ts`, not a one-line guard — see the audit skill for the finding.
+    // Known divergence: vendor does nothing until the region is measured, this judges drift/jitter
+    // on synthetic geometry instead. Unreachable on a real device (measure is a synchronous JSI
+    // call), so the fallback only ever fires in this codebase's own test harness.
     function isWithinRetention(point) {
         const region = runtime.region;
         if (region !== undefined) {
@@ -188,12 +169,8 @@ export function createPressHandlers(config, runtime, host) {
     function clearPressOut() {
         cancelRuntimeTimer(runtime, 'pressOutCancel');
     }
-    // Pressability.js arms this ONCE, at RESPONDER_GRANT, and a drift out/back-in never re-arms it
-    // (`onResponderMove` only ever CANCELS via `_cancelLongPressDelayTimeout`, permanently, for the
-    // rest of the gesture). Splitting it out of `activate()` is what makes that possible: `activate`
-    // itself runs again on every drift-back-in, and used to re-arm a fresh full-duration timer each
-    // time, which is wrong on two counts — it can resurrect a long press the finger already
-    // disqualified, and if it never left, it's simply the same timer restarted for no reason.
+    // Arms ONCE, at grant; a drift out/back-in never re-arms it, only cancels. Split out of
+    // activate(), which runs again on drift-back-in and would resurrect a disqualified long press.
     function armLongPress(event) {
         if (!onLongPress)
             return;
@@ -277,10 +254,8 @@ export function createPressHandlers(config, runtime, host) {
             runtime.pressOrigin = readPoint(event);
             runtime.driftedOut = false;
             measureRegion(runtime, host.getMeasureFn());
-            // Armed at GRANT, unconditionally — before the `unstable_pressDelay` branch below, which only
-            // defers the PRESSED VISUAL. `delayLongPress` already has `unstable_pressDelay` baked out of
-            // its default (`configFor`), so adding it back here is what keeps the long-press threshold at
-            // a constant time-from-touch-down regardless of how long the visual is deferred.
+            // Armed at GRANT, unconditionally — the unstable_pressDelay branch below only defers the
+            // PRESSED VISUAL, keeping the long-press threshold constant from touch-down.
             armLongPress(event);
             if (unstable_pressDelay > 0) {
                 dlog(`Pressable pressIn deferred ${unstable_pressDelay}ms`);

package/build/state/sticky-header-reducer.js

@@ -1,19 +1,6 @@
-// Sticky-header effect machine: the framework-agnostic STATE MACHINE that folds every per-adapter
-// sticky-header effect skeleton into one place. Before this, each adapter (React useState/useEffect,
-// Vue refs/watchEffect, Angular fields/ngOnChanges — and, in Angular, a SECOND copy inside the
-// projection wrapper) re-wrote the same per-header sequence — gate the freshly-rebuilt
-// interpolation's spurious zero, debounce the settled translateY, rebuild the top/inverted ranges on
-// a layout/collision-input change — in its own reactive dialect, so the zero-swallow gate, the
-// debounce-delay pick, and the rebuild decision lived FOUR times and quietly drifted.
-//
-// Here the whole decision half is one pure `reduceSticky(state, action, inputs) -> {state, effects}`,
-// PER sticky header. The adapter keeps only what is genuinely framework-bound: translate a native
-// event / animated tick / timer fire into an ACTION, hold ONE state cell, and EXECUTE the returned
-// EFFECTS with its own primitives (build the interpolation node + wire addListener/removeListener,
-// hold the debounce setTimeout, trigger its own re-render, record the cross-talk y). The math leaf
-// (computeStickyInterpolation) and the debounce-window pick (stickyDebounceMs) still live in
-// ./view/render-scroll-sticky; this module composes them into the ordered transition every adapter
-// shares. Ported from ScrollViewStickyHeader.js's effect.
+// Sticky-header effect machine: one pure `reduceSticky(state, action, inputs)` shared by every
+// adapter, so the zero-swallow gate, debounce pick, and rebuild decision live once, not once per
+// framework's reactive dialect. Math leaf + debounce window live in ./view/render-scroll-sticky.
 import { dlog } from '@symbiote-native/engine';
 import { computeStickyInterpolation, stickyDebounceMs, } from '../view/render-scroll-sticky.js';
 // The un-measured identity interpolation (RN: a fresh AnimatedInterpolation before the header has
@@ -43,8 +30,8 @@ function arraysEqual(a, b) {
         return false;
     return a.every((value, index) => value === b[index]);
 }
-// Recompute the derived interpolation ranges off the current state + inputs (wrapping the load-bearing
-// computeStickyInterpolation math), store them, and return them for the rebuild effect.
+// Recompute the derived ranges off the current state + inputs, store them, and return them for
+// the rebuild effect.
 function deriveRanges(state, inputs) {
     const { inputRange, outputRange } = computeStickyInterpolation({
         measured: state.measured,
@@ -58,14 +45,99 @@ function deriveRanges(state, inputs) {
     state.outputRange = outputRange;
     return { inputRange, outputRange };
 }
-// The single transition every sticky-header adapter shares. The adapter maps a native event / animated
-// tick / timer fire to an action, calls this, stores the returned state, and executes the effects.
-// DIAGNOSTIC-only, gated: identifies which header instance a log line belongs to across a
-// device dump without needing full state dumps at every call — layoutY doubles as a stable
-// per-header id once measured (0 before the first layout).
+// Diagnostic-only, gated: identifies which header instance a log line belongs to — layoutY
+// doubles as a stable per-header id once measured (0 before the first layout).
 function headerTag(state) {
     return `y=${state.layoutY}`;
 }
+// Redundant-geometry guard: Yoga re-fires onLayout with the same y/height on an unrelated
+// relayout — without this a fresh prop identity per redundant layout trips an unbounded
+// rebuild loop.
+function handleLayout(state, action, inputs) {
+    const alreadyAtThisGeometry = state.measured &&
+        state.layoutY === action.y &&
+        state.layoutHeight === action.height;
+    state.layoutY = action.y;
+    state.layoutHeight = action.height;
+    state.measured = true;
+    const effects = [];
+    if (inputs.index !== undefined) {
+        effects.push({ kind: 'record-header-y', index: inputs.index, y: action.y });
+    }
+    if (alreadyAtThisGeometry && state.rangesEmitted) {
+        dlog(`STICKY[reducer ${headerTag(state)}] layout: redundant geometry, skipped rebuild`);
+        return { state, effects, changed: effects.length > 0 };
+    }
+    const { inputRange, outputRange } = deriveRanges(state, inputs);
+    state.rangesEmitted = true;
+    dlog(`STICKY[reducer ${headerTag(state)}] layout: measured=true inputRange=${JSON.stringify(inputRange)} ` +
+        `outputRange=${JSON.stringify(outputRange)}`);
+    effects.push({ kind: 'rebuild-interpolation', inputRange, outputRange });
+    return { state, effects, changed: true };
+}
+// Redundant-ranges guard (same cause as layout's): compare the derived result, not raw
+// inputs. `hadEmitted` is load-bearing: an unmeasured header derives the same identity
+// ranges the initial state holds, so without it the first dispatch reads as redundant.
+function handleInputsChanged(state, inputs) {
+    const previousInputRange = state.inputRange;
+    const previousOutputRange = state.outputRange;
+    const hadEmitted = state.rangesEmitted;
+    const { inputRange, outputRange } = deriveRanges(state, inputs);
+    state.rangesEmitted = true;
+    if (hadEmitted &&
+        arraysEqual(previousInputRange, inputRange) &&
+        arraysEqual(previousOutputRange, outputRange)) {
+        dlog(`STICKY[reducer ${headerTag(state)}] inputs-changed: ranges unchanged, skipped rebuild`);
+        return { state, effects: [], changed: false };
+    }
+    dlog(`STICKY[reducer ${headerTag(state)}] inputs-changed: inputRange ${JSON.stringify(previousInputRange)}->` +
+        `${JSON.stringify(inputRange)} outputRange ${JSON.stringify(previousOutputRange)}->` +
+        `${JSON.stringify(outputRange)}`);
+    return {
+        state,
+        effects: [{ kind: 'rebuild-interpolation', inputRange, outputRange }],
+        changed: true,
+    };
+}
+// A freshly-rebuilt interpolation re-emits 0 to its listeners; swallow that first zero once a
+// real value has committed. Otherwise schedule the host-tuned debounce.
+function handleAnimatedTick(state, action, inputs) {
+    if (action.value === 0 && !state.haveReceivedInitialZeroTranslateY) {
+        state.haveReceivedInitialZeroTranslateY = true;
+        dlog(`STICKY[reducer ${headerTag(state)}] animated-tick: swallowed re-emitted zero translateY`);
+        return { state, effects: [], changed: false };
+    }
+    dlog(`STICKY[reducer ${headerTag(state)}] animated-tick: scheduling debounce delay=${stickyDebounceMs(inputs.os)} ` +
+        `value=${action.value}`);
+    return {
+        state,
+        effects: [
+            {
+                kind: 'schedule-debounce',
+                delay: stickyDebounceMs(inputs.os),
+                value: action.value,
+            },
+        ],
+        changed: false,
+    };
+}
+// Already-sitting-at-this-value bails to break a re-arriving settled value's cascade
+// (apply-passthrough -> fresh identity -> reconnect -> another tick).
+function handleDebounceFired(state, action) {
+    if (state.translateY === action.value) {
+        dlog(`STICKY[reducer ${headerTag(state)}] debounce-fired: already at translateY=${action.value}, no-op`);
+        return { state, effects: [], changed: false };
+    }
+    dlog(`STICKY[reducer ${headerTag(state)}] debounce-fired: committing translateY=${action.value}`);
+    state.translateY = action.value;
+    if (action.value !== 0)
+        state.haveReceivedInitialZeroTranslateY = false;
+    return {
+        state,
+        effects: [{ kind: 'apply-passthrough', translateY: action.value }],
+        changed: true,
+    };
+}
 export function reduceSticky(state, action, inputs) {
     dlog(`STICKY[reducer ${headerTag(state)}] action=${action.kind}` +
         (action.kind === 'layout'
@@ -76,131 +148,13 @@ export function reduceSticky(state, action, inputs) {
             : '') +
         ` inputs={inverted=${inputs.inverted} scrollViewHeight=${inputs.scrollViewHeight} nextHeaderLayoutY=${inputs.nextHeaderLayoutY}}`);
     switch (action.kind) {
-        case 'layout': {
-            // Record own y/height, mark measured, rebuild the interpolation, and (when the reducer owns the
-            // cross-talk index) hand the parent this header's y so the PREVIOUS header learns its collision
-            // point. Matches RN ScrollViewStickyHeader.js._onLayout.
-            //
-            // Redundant-geometry guard: Yoga legitimately re-fires onLayout with the SAME y/height (relayout
-            // passes triggered by an unrelated sibling, a native-driven prop commit, ...) — every consumer
-            // must tolerate that. React's port gets this guard for FREE: `setLayoutY(sameValue)` is a no-op
-            // (React bails out of re-rendering on an unchanged primitive), so a redundant onLayout never
-            // reaches the rebuild `useEffect`. This reducer has no such implicit bail-out, so it must skip
-            // the rebuild explicitly — device-confirmed (2026-08-13) that omitting this guard lets a
-            // native-driven rebuild (fresh AnimatedProps/AnimatedStyle graph, fresh native connect) commit a
-            // fresh prop identity on every redundant layout, which can itself provoke another relayout pass —
-            // an unbounded same-tick rebuild ping-pong that trips Svelte's effect_update_depth_exceeded guard.
-            const alreadyAtThisGeometry = state.measured &&
-                state.layoutY === action.y &&
-                state.layoutHeight === action.height;
-            state.layoutY = action.y;
-            state.layoutHeight = action.height;
-            state.measured = true;
-            const effects = [];
-            if (inputs.index !== undefined) {
-                effects.push({
-                    kind: 'record-header-y',
-                    index: inputs.index,
-                    y: action.y,
-                });
-            }
-            if (alreadyAtThisGeometry && state.rangesEmitted) {
-                dlog(`STICKY[reducer ${headerTag(state)}] layout: redundant geometry, skipped rebuild`);
-                return { state, effects, changed: effects.length > 0 };
-            }
-            const { inputRange, outputRange } = deriveRanges(state, inputs);
-            state.rangesEmitted = true;
-            dlog(`STICKY[reducer ${headerTag(state)}] layout: measured=true inputRange=${JSON.stringify(inputRange)} ` +
-                `outputRange=${JSON.stringify(outputRange)}`);
-            effects.push({ kind: 'rebuild-interpolation', inputRange, outputRange });
-            return { state, effects, changed: true };
-        }
-        case 'inputs-changed': {
-            // A collision/viewport input changed (RN effect deps: inverted, scrollViewHeight,
-            // nextHeaderLayoutY): recompute the ranges and rebuild.
-            //
-            // Redundant-ranges guard (sibling of 'layout's `alreadyAtThisGeometry` above, same root
-            // cause): the adapter's own mount `$effect` re-dispatches 'inputs-changed' whenever its
-            // `inverted`/`scrollViewHeight`/`nextHeaderLayoutY` derived values re-evaluate — which can
-            // happen on an unrelated parent re-render (e.g. VirtualizedList re-deriving
-            // `nextHeaderLayoutYFor(cell.index)` off its cross-talk Map on every reactive pass) even when
-            // the COMPUTED value is identical. React gets no implicit protection here either (this is a
-            // real `useEffect` with real deps), but RN's own deps array only fires on an ACTUAL primitive
-            // change; a framework-agnostic caller re-dispatching on every derive needs the reducer itself
-            // to compare the RESULT (the ranges), not the raw inputs (which may recompute to the same
-            // ranges via different intermediate values) — device-confirmed (2026-08-13) this is a second,
-            // independent source of the same unbounded same-tick rebuild loop the 'layout' guard fixed.
-            const previousInputRange = state.inputRange;
-            const previousOutputRange = state.outputRange;
-            const hadEmitted = state.rangesEmitted;
-            const { inputRange, outputRange } = deriveRanges(state, inputs);
-            state.rangesEmitted = true;
-            // `hadEmitted` is load-bearing, not defensive: an unmeasured header derives exactly the
-            // identity ranges the initial state already holds, so without it the FIRST dispatch (Angular
-            // sends one from ngOnInit, before any layout) reads as redundant and the header never emits
-            // a rebuild at all — its wrapper then never commits. Regression-covered in
-            // sticky-header-reducer.test.ts.
-            if (hadEmitted &&
-                arraysEqual(previousInputRange, inputRange) &&
-                arraysEqual(previousOutputRange, outputRange)) {
-                dlog(`STICKY[reducer ${headerTag(state)}] inputs-changed: ranges unchanged, skipped rebuild`);
-                return { state, effects: [], changed: false };
-            }
-            dlog(`STICKY[reducer ${headerTag(state)}] inputs-changed: inputRange ${JSON.stringify(previousInputRange)}->` +
-                `${JSON.stringify(inputRange)} outputRange ${JSON.stringify(previousOutputRange)}->` +
-                `${JSON.stringify(outputRange)}`);
-            return {
-                state,
-                effects: [{ kind: 'rebuild-interpolation', inputRange, outputRange }],
-                changed: true,
-            };
-        }
-        case 'animated-tick': {
-            // A freshly-rebuilt interpolation re-emits 0 to its listeners; swallow that first zero once a
-            // real value has committed (RN). Otherwise schedule the host-tuned debounce that pushes the
-            // settled value into the committed transform for hit-testing.
-            if (action.value === 0 && !state.haveReceivedInitialZeroTranslateY) {
-                state.haveReceivedInitialZeroTranslateY = true;
-                dlog(`STICKY[reducer ${headerTag(state)}] animated-tick: swallowed re-emitted zero translateY`);
-                return { state, effects: [], changed: false };
-            }
-            dlog(`STICKY[reducer ${headerTag(state)}] animated-tick: scheduling debounce delay=${stickyDebounceMs(inputs.os)} ` +
-                `value=${action.value}`);
-            return {
-                state,
-                effects: [
-                    {
-                        kind: 'schedule-debounce',
-                        delay: stickyDebounceMs(inputs.os),
-                        value: action.value,
-                    },
-                ],
-                changed: false,
-            };
-        }
-        case 'debounce-fired': {
-            // Already sitting at this value: emit nothing. Same bail-out the 'layout' case above spells
-            // out, for the same reason - React's own header gets it free from setTranslateY (an unchanged
-            // primitive bails out of the re-render), a reducer has to say it. Device-confirmed 2026-08-18:
-            // without it a re-arriving settled value emits apply-passthrough, the adapter force-renders,
-            // the passthrough prop gets a fresh identity, the animated graph reconnects and re-emits into
-            // another tick -> another debounce -> another passthrough. One header survives it; a screen of
-            // 200 trips React's "Maximum update depth exceeded" and takes the app down.
-            if (state.translateY === action.value) {
-                dlog(`STICKY[reducer ${headerTag(state)}] debounce-fired: already at translateY=${action.value}, no-op`);
-                return { state, effects: [], changed: false };
-            }
-            // The debounce completed: commit the settled translateY. Once a NON-zero value commits, re-arm
-            // the swallow gate so the next interpolation rebuild's spurious 0 is dropped (RN).
-            dlog(`STICKY[reducer ${headerTag(state)}] debounce-fired: committing translateY=${action.value}`);
-            state.translateY = action.value;
-            if (action.value !== 0)
-                state.haveReceivedInitialZeroTranslateY = false;
-            return {
-                state,
-                effects: [{ kind: 'apply-passthrough', translateY: action.value }],
-                changed: true,
-            };
-        }
+        case 'layout':
+            return handleLayout(state, action, inputs);
+        case 'inputs-changed':
+            return handleInputsChanged(state, inputs);
+        case 'animated-tick':
+            return handleAnimatedTick(state, action, inputs);
+        case 'debounce-fired':
+            return handleDebounceFired(state, action);
     }
 }

package/build/state/touchable.js

@@ -100,11 +100,9 @@ export function createTouchableFeedbackHandlers(config, runtime, callbacks) {
         },
     };
 }
-// ---- RN-audited additions (2026-08-19) --------------------------------------------------------
-//
-// Measured against .vendors/react-native. Everything above predates that audit and is still what
-// the React, Vue, Svelte and Angular adapters call; the names below are the RN-accurate forms and
-// are additive on purpose, so the tree stays green while each adapter migrates.
+// ---- RN-audited additions ----
+// Measured against .vendors/react-native. The names below are the RN-accurate forms, kept
+// additive so the tree stays green while each adapter migrates off the names above.
 // RN's Touchable* family OVERRIDES Pressability's own floor with 0 — TouchableOpacity.js:195,
 // TouchableHighlight.js:203 and TouchableWithoutFeedback.js all pass `minPressDuration: 0`. So
 // Pressability's own default of 130 (Pressability.js:264) reaches a Touchable in RN NEVER: what holds the active visual there is the Animated fade's own duration,