@symbiote-native/components 3.1.1 → 3.1.3

package/build/behaviors/touchable-opacity.js

@@ -25,12 +25,32 @@
 // event props. Deliberately not implemented — dead on every device this project targets (no tvOS
 // build, no example app; iOS/Android are the only targets). Audit skill, "Found, NOT fixed: TV
 // (Platform.isTV) focus/blur feedback on TouchableOpacity/Highlight".
-import { AnimatedMock, AnimatedValue, Easing, Platform, dlog, getExplicitStyle, markPropsDirty, registerHostBehavior, requestCommitFor, setAnimatedBehaviorStyle, timing, propOf, propsOf, } from '@symbiote-native/engine';
+import { AnimatedMock, AnimatedValue, Easing, Platform, dlog, getExplicitStyle, markPropsDirty, registerHostBehavior, requestCommitFor, setAnimatedBehaviorStyle, setProp, timing, propOf, propsOf, } from '@symbiote-native/engine';
 import { resolveButtonDisabled } from '../view/render-button.js';
 import { asAccessibilityState, booleanOr, createPressBehavior, } from './pressable.js';
-import { createTouchableFeedbackHandlers, createTouchableFeedbackRuntime, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_DURATION_MS, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, restingOpacityFromStyle, TOUCHABLE_MIN_PRESS_DURATION_MS, } from '../state/touchable.js';
+import { createTouchableFeedbackHandlers, createTouchableFeedbackRuntime, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_DURATION_MS, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, restingOpacityFromStyle, TOUCHABLE_MIN_PRESS_DURATION_MS, } from '../state/touchable.js';
 export const TOUCHABLE_OPACITY_TAG = 'touchable-opacity';
 const states = new WeakMap();
+// Built on the FIRST FADE, not at attach: the three together read 1 343 B per node
+// (`touchable-attach-cost.itest.ts`) and nothing reads them until a finger lands
+function stateOf(node) {
+    const existing = states.get(node);
+    if (existing !== undefined)
+        return existing;
+    // Seeded at the CURRENT resting opacity, which the first `afterCommit` used to set
+    const state = {
+        opacity: new AnimatedValue(restingOpacityOf(node)),
+        runtime: createTouchableFeedbackRuntime(),
+        timers: new Set(),
+        isBound: false,
+    };
+    states.set(node, state);
+    return state;
+}
+// What the last commit settled at, apart from the state above т.к. `afterCommit` runs for every
+// mounted node while that state is owed only by one that actually fades
+// `undefined` is the mount, where RN re-settles nothing (it is `componentDidUpdate` only)
+const settledAt = new WeakMap();
 // `modules/animated`'s barrel swaps the whole driver namespace for the mock when the host reports
 // reduced motion; the one driver used here is swapped on the same flag.
 const startTiming = Platform.isDisableAnimations ? AnimatedMock.timing : timing;
@@ -46,7 +66,16 @@ function numberOr(value, fallback) {
 function restingOpacityOf(node) {
     return restingOpacityFromStyle(getExplicitStyle(node));
 }
-function fadeTo(state, toValue, ms) {
+// Registered on FIRST FADE, not at attach: the leaf costs 9.8 us and 5.9 KB per node
+// (`touchable-attach-cost.itest.ts`) and a list nobody presses pays it for a value that never moves
+function ensureLayer(node, state) {
+    if (state.isBound)
+        return;
+    state.isBound = true;
+    setAnimatedBehaviorStyle(node, { opacity: state.opacity });
+}
+function fadeTo(node, state, toValue, ms) {
+    ensureLayer(node, state);
     dlog(`touchable-opacity opacity -> ${toValue} over ${ms}ms`);
     // useNativeDriver is RN's own (TouchableOpacity.js:242): opacity is natively drivable, so the
     // fade survives a busy JS thread, which is the whole point of press feedback.
@@ -61,9 +90,7 @@ function fadeTo(state, toValue, ms) {
 // hold when a finger lands, and the handlers it builds are discarded with the gesture. The runtime
 // that must outlive one — an in-flight delayPressIn timer, the activation clock — is on the node.
 const refine = (node, config) => {
-    const state = states.get(node);
-    if (state === undefined)
-        return config;
+    const state = stateOf(node);
     const resting = restingOpacityOf(node);
     const activeOpacity = numberOr(propOf(node, 'activeOpacity'), DEFAULT_ACTIVE_OPACITY);
     const handlers = createTouchableFeedbackHandlers({
@@ -86,18 +113,16 @@ const refine = (node, config) => {
         now: Date.now,
     }, state.runtime, {
         activate(event) {
-            // TouchableOpacity.js:215-220 picks the duration from WHERE the press-in came from: our
-            // engine's own 'pressIn' event (an ordinary grant, or its delayed replay) is the 0ms leg;
-            // a drift-out/drift-back-in reactivation arrives as 'responderMove'
-            // (`state/pressable.ts`'s `handleResponderMove`) and gets the 150ms ease-back-in instead.
+            // TouchableOpacity.js:215-220 picks the duration from WHERE the press-in came from: a
+            // plain grant fades instantly, a drift-back-in arrives as `responderMove` and eases
             const duration = event.type === 'responderMove'
                 ? OPACITY_ACTIVE_DURATION_MS
                 : OPACITY_ACTIVE_GRANT_DURATION_MS;
-            fadeTo(state, activeOpacity, duration);
+            fadeTo(node, state, activeOpacity, duration);
             config.onPressIn?.(event);
         },
         deactivate(event) {
-            fadeTo(state, resting, OPACITY_INACTIVE_DURATION_MS);
+            fadeTo(node, state, resting, OPACITY_INACTIVE_DURATION_MS);
             config.onPressOut?.(event);
         },
     });
@@ -115,13 +140,9 @@ const refine = (node, config) => {
 // Without it, a caller who sets only `accessibilityState={{disabled: true}}` (no `disabled` prop)
 // gets the greyed-out RN look but a press that still fires here — RN suppresses it.
 const touchableOpacityDisabled = props => resolveButtonDisabled(booleanOr(props.disabled), booleanOr(props['aria-disabled']), asAccessibilityState(props.accessibilityState));
-/**
- * The behavior as PARTS, so a tag that is a TouchableOpacity plus something — `button`, which RN
- * builds as exactly that (Button.js:283) — composes the fade instead of re-implementing it.
- *
- * Safe to hand to two tags: every piece of runtime is keyed by NODE (`states`), and `press` is
- * itself already shared that way.
- */
+// The behavior as PARTS, so a tag that is a TouchableOpacity plus something composes the fade
+// instead of re-implementing it (`button` is exactly that, Button.js:283)
+// Safe to hand to two tags: every piece of runtime is keyed by NODE, `press` included
 export function createTouchableOpacityBehavior(disabledOf) {
     // Its own machine rather than the module-level `press`, so a composing tag can say what
     // `disabled` MEANS to it — the answer feeds the machine, not a payload: the props half of that
@@ -130,95 +151,58 @@ export function createTouchableOpacityBehavior(disabledOf) {
     return {
         ...machine,
         attach(node) {
-            const state = {
-                opacity: new AnimatedValue(RESTING_OPACITY),
-                runtime: createTouchableFeedbackRuntime(),
-                timers: new Set(),
-                settled: undefined,
-            };
-            states.set(node, state);
-            // Bound at ATTACH rather than at the first press, matching RN: the binding is what forces
-            // `collapsable: false`, and a view Fabric un-flattens mid-gesture would lose the responder.
-            // Nothing is published until a fade runs — the leaf writes only when its value moves.
-            setAnimatedBehaviorStyle(node, { opacity: state.opacity });
+            // The half of the binding that CANNOT wait for the first press: a view Fabric flattens
+            // mid-gesture loses the tag the responder lands on. Everything else follows in `stateOf`
+            setProp(node, 'collapsable', false);
             machine.attach(node);
         },
         // RN's componentDidUpdate: a changed `disabled` or a changed style opacity re-settles the view,
         // so a Touchable disabled mid-press does not stay stuck at its active opacity.
         afterCommit(node) {
-            const state = states.get(node);
-            if (state === undefined)
-                return;
             const resting = restingOpacityOf(node);
-            // Through the SAME resolver the press machine uses, not the raw prop: on Button `disabled` is
-            // the three-way answer of `props.disabled ?? aria-disabled ?? accessibilityState.disabled`
-            // (Button.js:331,337), so reading the prop here left an aria-only flip un-settled — the view
-            // stayed at its active opacity while the press was already suppressed. RN's Button has no
-            // such gap because it passes the resolved value DOWN as its touchable's prop.
+            // Through the SAME resolver the press machine uses, not the raw prop: on `button` `disabled`
+            // also answers to `aria-disabled` / `accessibilityState` (Button.js:331,337), and reading the
+            // prop alone left an aria-only flip un-settled at its active opacity
             const props = propsOf(node);
             const disabled = disabledOf?.(props) ?? props.disabled;
-            const previous = state.settled;
-            state.settled = { disabled, resting };
-            if (previous === undefined) {
-                // NOT vendor parity, despite this comment's old claim: `TouchableOpacity-itest.js` ("does
-                // not render explicit opacity when using default") proves a resting, untouched
-                // TouchableOpacity commits no `opacity` key at all. Vendor's native-animated leaf is a
-                // separate channel from the ordinary style diff, so forcing non-flattening never implies
-                // publishing a value. Ours publishes anyway: `setAnimatedBehaviorStyle`/`bindAnimatedValue`
-                // (`host-binding.ts`) force `collapsable: false` and resolve+write the leaf's value in the
-                // SAME call. Untangling that is a change to shared animation infrastructure, not a one-line
-                // fix here — deferred, see the audit skill. Set rather than animate: this is the mount, and
-                // RN re-settles on componentDidUpdate only.
-                //
-                // TODO(rn-parity): skip this initial publish when `resting === RESTING_OPACITY` (1, Fabric's
-                // own opacity default) and no authored `style.opacity` needs another route to Fabric, so a
-                // resting default TouchableOpacity commits no `opacity` key — matching vendor. Needs
-                // `bindAnimatedValue`/`host-binding.ts` to separate "force collapsable:false" from "publish
-                // the leaf's value" (shared by every animated-behavior consumer, not just this tag), plus a
-                // new test for the untouched-default case (no existing case in touchable-opacity.test.ts
-                // covers it — every case authors an explicit style.opacity first).
-                state.opacity.setValue(resting);
+            const previous = settledAt.get(node);
+            settledAt.set(node, { disabled, resting });
+            // The mount, where RN re-settles nothing. An untouched node holds no `AnimatedValue` yet, and
+            // `stateOf` seeds the one it eventually builds at whatever `resting` is by then
+            if (previous === undefined)
                 return;
-            }
             if (previous.disabled === disabled && previous.resting === resting)
                 return;
-            fadeTo(state, resting, OPACITY_INACTIVE_DURATION_MS);
+            fadeTo(node, stateOf(node), resting, OPACITY_INACTIVE_DURATION_MS);
         },
         detach(node) {
             machine.detach(node);
+            settledAt.delete(node);
             const state = states.get(node);
-            if (state === undefined)
+            // Never faded, so the flatten guard `attach` wrote is the only thing owed back
+            if (state === undefined) {
+                setProp(node, 'collapsable', undefined);
                 return;
+            }
             for (const id of state.timers)
                 clearTimeout(id);
             state.timers.clear();
             // RN's componentWillUnmount: stop the animation so a teardown mid-fade leaves no driver
             // running against a node that is gone.
             state.opacity.resetAnimation();
-            setAnimatedBehaviorStyle(node, undefined);
+            // Dropping the layer clears `collapsable` on its way out, so only an unbound node still owes
+            if (state.isBound)
+                setAnimatedBehaviorStyle(node, undefined);
+            else
+                setProp(node, 'collapsable', undefined);
             states.delete(node);
             dlog('touchable-opacity behavior detached');
         },
     };
 }
-// THIS TAG NOW COSTS ZERO TRIPS INTO JS (2026-09-18). `focusable` was the last thing here, and it
-// held out because its middle leg — `onPress !== undefined` (TouchableOpacity.js:338) — is an OWNED
-// name that lives in the stash and never becomes a prop, so a props-only rule could not see it.
-//
-// What moved was not the closure but ONE BIT. `setEventListener` already knew the flip (it computes
-// `wasWired !== isHandler` to fire `onOwnedListenerChange`); it now also records
-// `OP_SET_OWNED_LISTENER`, and `foldPressableProps` resolves the whole three-leg expression off the
-// node. The callback itself never left JS and never will — that is the split a browser draws too,
-// where the UA knows which elements carry a click handler and the handler's body stays the page's.
-//
-// So "a rule cannot read an owned listener" was two claims wearing one sentence, and only the one
-// about the FUNCTION was true. Contract:
-// `core/engine/cpp/tests/js/touchable-focusable-payload.itest.ts`.
-//
-// `./button` keeps its own fold and its own resolution, deliberately: it resolves `disabled` three
-// ways through the projection its derived children share, and it folds an Android view style and
-// ripple regardless — so moving only its `focusable` would duplicate that precedence and buy back
-// no crossing.
+// `focusable`'s three-leg check (disabled, aria-disabled/accessibilityState, `onPress !==
+// undefined`) is `foldPressableProps` in C++, reading `OP_SET_OWNED_LISTENER` for the last leg.
+// Contract: `touchable-focusable-payload.itest.ts`. `./button` keeps its own copy regardless.
 // STILL NEEDED, and for a reason the wire did not remove: `markDirty` on the host marks the node
 // whose payload must be rebuilt, but the COMMIT still has to be asked for. A listener flip changes
 // no prop on this side, so nothing else would schedule one and the new answer would sit in the host

package/build/behaviors/touchable-without-feedback.js

@@ -39,18 +39,9 @@ import { SLOT_DERIVED_ALL, appListenerFor, markPropsDirty, registerHostBehavior,
 import { attachPressMachine, detachPressMachine, } from './pressable.js';
 import { createTouchableFeedbackHandlers, createTouchableFeedbackRuntime, TOUCHABLE_MIN_PRESS_DURATION_MS, } from '../state/touchable.js';
 export const TOUCHABLE_WITHOUT_FEEDBACK_TAG = 'touchable-without-feedback';
-// WHAT THE OWNER'S WRITES DIRTY, and it is EVERY name rather than a list of thirty.
-//
-// RN's two clone lists (`TouchableWithoutFeedback.js:130-153` when-set, `:253-276` always) lived
-// here until 2026-09-18, feeding `slotDerived` alongside the six computed names and the three
-// scheduler ones. The clone is `foldCloneOntoChild` in `SymbioteFabricProps.cpp` now, which turned
-// the list from the RULE into a MIRROR of `kWithoutFeedbackWhenSetKeys` +
-// `kWithoutFeedbackAlwaysKeys` — two lists that must agree, failing silently when they drift.
-//
-// See `touchable-native-feedback.ts` for the same note and what the wildcard costs. The three
-// scheduler names (`delayPressIn`, `delayPressOut`, `minPressDuration`) were the one entry here that
-// was NEVER about the clone — they configure the press machine, which reads them live at gesture
-// start — and a wildcard covers them for free where a list had to remember them.
+// Dirties EVERY owner prop rather than a list: the clone is `foldCloneOntoChild` in C++ now, so a
+// wildcard covers it for free. The three scheduler names (`delayPressIn`, `delayPressOut`,
+// `minPressDuration`) were never about the clone — they configure the press machine, read live.
 const SLOT_DERIVED = [SLOT_DERIVED_ALL];
 // :148-153. Owned, so the app's callback stashes on the owner and a trampoline on the child reads it
 // at dispatch time. `layout` and `accessibilityAction` are Fabric BOOLEAN-GATED events
@@ -77,27 +68,25 @@ const states = new WeakMap();
 function numberOr(value, fallback) {
     return typeof value === 'number' ? value : fallback;
 }
-// `cloneFold` LEFT THIS FILE ON 2026-09-18 — `foldCloneOntoChild` in `SymbioteFabricProps.cpp`,
-// reached through the first rule keyed on the PARENT'S tag (`IOwner`). TWF's two lists are NOT
-// TNF's: the passthrough half is copied only when SET (`:281`), and the C++ rule keeps that split
-// rather than collapsing the two into one.
-//
-// One quirk of upstream's that IS reproduced, and it is NOT free: `:280-284`'s passthrough loop
-// re-assigns a set `nativeID` over the `id` it just resolved, so an explicit `nativeID` wins here
-// where TNF's `id` does. `routeProp` settles the two names into one value before any rule runs, so
-// getting this right needed the collapse itself to know which of the two components it is running
-// for — `node.nativeIdWinsOverId`, set only by this behavior's registration, flips it.
-//
-// Contract: `core/engine/cpp/tests/js/clone-onto-child-payload.itest.ts`.
-/**
- * `delayPressIn` / `delayPressOut` (:186-188) plus RN's unconditional `minPressDuration: 0` (:190).
- *
- * The scheduler is `../state/touchable`'s — the one `./touchable-opacity` drives its fade with,
- * here with `activate` / `deactivate` forwarding and painting nothing. It reads the OWNER, so the
- * owner is closed over rather than taken from the refinement's argument, which is the CHILD.
- */
-function refinementFor(owner, state) {
+// The clone is `foldCloneOntoChild` in C++, keyed on the PARENT'S tag; TWF's passthrough half
+// copies only when SET, unlike TNF's unconditional list. One upstream quirk it reproduces:
+// `nativeID` wins over `id` here (`node.nativeIdWinsOverId`, `clone-onto-child-payload.itest.ts`).
+// Built on the FIRST GESTURE, not at arm: nothing reads the runtime or the timer set until a
+// finger lands, and a list of touchables nobody presses paid ~500 B per item for them
+function stateOf(owner) {
+    const existing = states.get(owner);
+    if (existing !== undefined)
+        return existing;
+    const state = {
+        runtime: createTouchableFeedbackRuntime(),
+        timers: new Set(),
+    };
+    states.set(owner, state);
+    return state;
+}
+function refinementFor(owner) {
     return (_node, config) => {
+        const state = stateOf(owner);
         const handlers = createTouchableFeedbackHandlers({
             delayPressIn: numberOr(propOf(owner, 'delayPressIn'), 0),
             delayPressOut: numberOr(propOf(owner, 'delayPressOut'), 0),
@@ -145,18 +134,13 @@ function trampolineFor(owner, name) {
 function forwardListener(owner, child, name, wired) {
     setBehaviorListener(child, name, wired ? trampolineFor(owner, name) : undefined);
 }
-// The machine plus the forwarded listeners. Split from adoption because a parked subtree comes back
-// with its child and its fold intact but its machine torn down — `attach` re-runs this, and must
-// NOT re-chain the fold.
+// The machine plus the forwarded listeners. Split from adoption т.к. a parked subtree comes back
+// with its child and its fold intact but its machine torn down, so `attach` re-runs this and must
+// NOT re-chain the fold
 function arm(owner, child) {
-    let state = states.get(owner);
-    if (state === undefined) {
-        state = { runtime: createTouchableFeedbackRuntime(), timers: new Set() };
-        states.set(owner, state);
-    }
     attachPressMachine(child, {
         source: owner,
-        refine: refinementFor(owner, state),
+        refine: refinementFor(owner),
     });
     for (const name of FORWARDED_LISTENERS) {
         forwardListener(owner, child, name, appListenerFor(owner, name) !== undefined);

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

@@ -4,17 +4,9 @@
 // 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 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.
+// 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`);