@symbiote-native/components 1.0.0 → 3.0.0

package/build/behaviors/touchable-opacity.js

@@ -0,0 +1,239 @@
+// TouchableOpacity as an ENGINE-NODE behavior, so it can be an intrinsic tag instead of a
+// framework component (`.claude/rules/host-primitive-tier.md`, tier 2).
+//
+// ONE NODE, and that is a correction rather than a shortcut. Every adapter's wrapper builds two —
+// a `pressable` holding a faded `view` — and RN builds one: `TouchableOpacity.js:302` renders a
+// single `<Animated.View>` carrying the responder handlers AND
+// `style={[props.style, {opacity: anim}]}`. The two-node shape is copied from
+// TouchableNativeFeedback, which genuinely does clone onto a child; the same misreading is on
+// record for `android_ripple` (`.claude/rules/adapter-parity-audit.md`). So the tag collapses the
+// pair and lands on RN's own tree.
+//
+// WHAT IS SHARED AND WHAT IS NEW. The press machine is `./pressable`'s, composed through
+// `createPressBehavior` — one node may hold exactly one press machine, so this tag must not also
+// register the plain `pressable` behavior. The press-scheduling half (delayPressIn defer,
+// flush-on-early-release, the minPressDuration hold) is `../state/touchable`, unchanged and still
+// shared with the wrappers. New here is only WHERE the fade lives: on the engine node, through
+// `setAnimatedBehaviorStyle`, instead of in a component's own Animated wiring.
+//
+// REGISTRATION IS THE HAZARD, not the machine — see `./pressable` for why each adapter's entry
+// does a bare `import './register';` that the barrel does not re-export.
+//
+// TODO(rn-parity, low priority): `TouchableOpacity.js:197-220` gates the active/inactive opacity
+// fade on `onFocus`/`onBlur` too (TV remote focus fires the same fade `onPress` triggers). Neither
+// name is wired into the feedback machine here; they pass through as ordinary, un-intercepted
+// 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 { 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';
+export const TOUCHABLE_OPACITY_TAG = 'touchable-opacity';
+const states = 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;
+function numberOr(value, fallback) {
+    return typeof value === 'number' ? value : fallback;
+}
+// From `parts.explicitStyle`, never `node.props.style`. A fade frame lands as `setNativeProps`,
+// which merges its partial onto `node.props.style` in place — so reading the published slot would
+// hand the resting-opacity math the fade's own output and `afterCommit` would chase itself.
+//
+// It therefore sees the AUTHOR's style and not a class-derived `opacity`, which is exactly RN's
+// scope: `_getChildStyleOpacityWithDefault` reads `this.props.style` and nothing else.
+function restingOpacityOf(node) {
+    return restingOpacityFromStyle(getExplicitStyle(node));
+}
+function fadeTo(state, toValue, ms) {
+    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.
+    startTiming(state.opacity, {
+        toValue,
+        duration: ms,
+        easing: Easing.inOut(Easing.quad),
+        useNativeDriver: true,
+    }).start();
+}
+// Runs once per GESTURE (see IPressConfigRefinement), so the config it reads is whatever the props
+// 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 resting = restingOpacityOf(node);
+    const activeOpacity = numberOr(propOf(node, 'activeOpacity'), DEFAULT_ACTIVE_OPACITY);
+    const handlers = createTouchableFeedbackHandlers({
+        delayPressIn: numberOr(propOf(node, 'delayPressIn'), 0),
+        delayPressOut: numberOr(propOf(node, 'delayPressOut'), 0),
+        // Read raw rather than off `config`, which has already defaulted the absent case to the press
+        // machine's own 130 ms — a floor RN's Touchables never see (TOUCHABLE_MIN_PRESS_DURATION_MS).
+        minPressDuration: numberOr(propOf(node, 'minPressDuration'), TOUCHABLE_MIN_PRESS_DURATION_MS),
+        schedule: (callback, ms) => {
+            const id = setTimeout(() => {
+                state.timers.delete(id);
+                callback();
+            }, ms);
+            state.timers.add(id);
+            return () => {
+                clearTimeout(id);
+                state.timers.delete(id);
+            };
+        },
+        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.
+            const duration = event.type === 'responderMove'
+                ? OPACITY_ACTIVE_DURATION_MS
+                : OPACITY_ACTIVE_GRANT_DURATION_MS;
+            fadeTo(state, activeOpacity, duration);
+            config.onPressIn?.(event);
+        },
+        deactivate(event) {
+            fadeTo(state, resting, OPACITY_INACTIVE_DURATION_MS);
+            config.onPressOut?.(event);
+        },
+    });
+    return {
+        ...config,
+        // RN hands Pressability 0 (TouchableOpacity.js:195): the deactivation floor belongs to the
+        // feedback machine above, and a second one holds the fade for the press machine's default.
+        minPressDuration: 0,
+        onPressIn: handlers.handlePressIn,
+        onPressOut: handlers.handlePressOut,
+    };
+};
+// TouchableOpacity.js:186-189 — `disabled ?? aria-disabled ?? accessibilityState.disabled`, the
+// same three-way answer Button resolves, just never wired to this tag's OWN registration before.
+// 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.
+ */
+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
+    // question is `foldPressableProps` in `SymbioteFabricProps.cpp` and reads the authored bag.
+    const machine = createPressBehavior(refine, 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 });
+            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.
+            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);
+                return;
+            }
+            if (previous.disabled === disabled && previous.resting === resting)
+                return;
+            fadeTo(state, resting, OPACITY_INACTIVE_DURATION_MS);
+        },
+        detach(node) {
+            machine.detach(node);
+            const state = states.get(node);
+            if (state === 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);
+            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.
+// 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
+// until some unrelated write happened to dirty the node.
+function onOwnedListenerChange(node, name) {
+    if (name !== 'press')
+        return;
+    markPropsDirty(node);
+    requestCommitFor(node);
+}
+// Idempotent: an adapter entry may be imported more than once in a bundle.
+export function registerTouchableOpacityBehavior() {
+    const touchable = createTouchableOpacityBehavior(touchableOpacityDisabled);
+    registerHostBehavior(TOUCHABLE_OPACITY_TAG, {
+        ...touchable,
+        onOwnedListenerChange,
+    });
+}

package/build/behaviors/touchable-without-feedback.d.ts

@@ -0,0 +1,2 @@
+export declare const TOUCHABLE_WITHOUT_FEEDBACK_TAG = "touchable-without-feedback";
+export declare function registerTouchableWithoutFeedbackBehavior(): void;

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

@@ -0,0 +1,231 @@
+// TouchableWithoutFeedback as an ENGINE-NODE behavior — the second primitive that commits NO NODE
+// OF ITS OWN (`.claude/rules/host-primitive-tier.md`, tier 2), after `./touchable-native-feedback`.
+//
+// RN'S TWF RENDERS NOTHING, exactly like TNF: `React.Children.only(props.children)`
+// (TouchableWithoutFeedback.js:229) then `cloneElement(element, elementProps, ...children)` (:286).
+// All five of our adapters wrapped a `Pressable` around the children instead, so every TWF in every
+// app committed a node RN does not.
+//
+// The SHAPE — anchor tag, `onChildInserted` adoption, a `cloneElement`-shaped `payloadFold` on the
+// child, the press machine on the CHILD reading the OWNER — is `./touchable-native-feedback`'s and
+// is documented there. Its three KNOWN LIMITS (one child only, a child removed from a live owner
+// keeps its machine, `style` is not cloned) hold here verbatim: RN's TWF declares a `style` prop
+// (:122, tagged "FIXME: not in doc") and then never puts it in `elementProps`, so it is dead
+// upstream too.
+//
+// WHAT DIFFERS FROM TNF, since the two look like one primitive with a different name:
+//
+// 1. THE CLONE IS CONDITIONAL. TNF assigns its whole list unconditionally, so an absent prop CLEARS
+//    the child's (`cloneElement` copies undefined keys). TWF splits: eight names are computed and
+//    assigned unconditionally, and `PASSTHROUGH_PROPS` (:130-153) is copied only
+//    `if (props[prop] !== undefined)` (:281). So a TWF with no `testID` LEAVES the child's alone.
+// 2. NO ANDROID RIPPLE. `background` / `useForeground` / `getBackgroundProp` and the
+//    `setPressed`/`hotspotUpdate` view commands are TNF's alone — they exist to drive the drawable
+//    TNF installs, and TWF installs none. `nativeFeedbackRefinement` is therefore NOT reused.
+// 3. `onBlur` / `onFocus` ARE cloned (:152-153, in the passthrough list), where TNF drops them.
+//    Both are `BASE_EVENTS`, so they route to the stash and trampoline like the other two.
+// 4. `accessibilityIgnoresInvertColors` is cloned; `hasTVPreferredFocus` and the five `nextFocus*`
+//    are NOT — the reverse of TNF on both counts. Read RN's two lists side by side rather than
+//    inheriting either.
+// 5. TWF FORWARDS `delayPressIn` / `delayPressOut` to Pressability (:186-188), which the press
+//    machine does not own — so the tag layers `../state/touchable`'s scheduler on top, the same
+//    machine `./touchable-opacity` uses with the fade replaced by nothing. That is what "without
+//    feedback" means: no VISUAL, not no TIMING.
+//
+// REGISTRATION IS THE HAZARD, not the machine — see `./pressable`. Registered in the same commit
+// that deletes the five wrappers, because the registry is keyed by TAG and a wrapper still emitting
+// its own `pressable` would put two press machines on one tree.
+import { SLOT_DERIVED_ALL, appListenerFor, markPropsDirty, registerHostBehavior, requestCommitFor, setBehaviorListener, propOf, } from '@symbiote-native/engine';
+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.
+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
+// (`.claude/rules/fabric-boolean-event-gates.md`), so the trampoline goes in only while the app has
+// one wired; `blur` and `focus` are not gated but ride the same wiring, since the question — is
+// there a callback to forward — is identical.
+const FORWARDED_LISTENERS = [
+    'layout',
+    'accessibilityAction',
+    'blur',
+    'focus',
+];
+const PRESS_LISTENERS = [
+    'press',
+    'pressIn',
+    'pressOut',
+    'pressMove',
+    'longPress',
+    'startShouldSetResponder',
+    'responderMove',
+    'responderTerminationRequest',
+];
+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) {
+    return (_node, config) => {
+        const handlers = createTouchableFeedbackHandlers({
+            delayPressIn: numberOr(propOf(owner, 'delayPressIn'), 0),
+            delayPressOut: numberOr(propOf(owner, 'delayPressOut'), 0),
+            // Read raw rather than off `config`, which has already defaulted the absent case to the
+            // press machine's own 130 ms — a floor RN's Touchables never see.
+            minPressDuration: numberOr(propOf(owner, 'minPressDuration'), TOUCHABLE_MIN_PRESS_DURATION_MS),
+            schedule: (callback, ms) => {
+                const id = setTimeout(() => {
+                    state.timers.delete(id);
+                    callback();
+                }, ms);
+                state.timers.add(id);
+                return () => {
+                    clearTimeout(id);
+                    state.timers.delete(id);
+                };
+            },
+            now: Date.now,
+        }, state.runtime, {
+            activate(event) {
+                config.onPressIn?.(event);
+            },
+            deactivate(event) {
+                config.onPressOut?.(event);
+            },
+        });
+        return {
+            ...config,
+            // :190, unconditional. The deactivation floor belongs to the scheduler above, and a second
+            // one would defer `onPressOut` by the press machine's 130 ms default on top of it.
+            minPressDuration: 0,
+            onPressIn: handlers.handlePressIn,
+            onPressOut: handlers.handlePressOut,
+        };
+    };
+}
+// The app's callback, read at dispatch time so a fresh closure per render costs nothing.
+function trampolineFor(owner, name) {
+    return (event) => {
+        const listener = appListenerFor(owner, name);
+        if (typeof listener === 'function')
+            listener(event);
+    };
+}
+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.
+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),
+    });
+    for (const name of FORWARDED_LISTENERS) {
+        forwardListener(owner, child, name, appListenerFor(owner, name) !== undefined);
+    }
+}
+function attach(node) {
+    // First attach has no child yet; a re-attach after the sweep does. See `arm`, which is also what
+    // seeds the scheduling cell — a TWF that never adopts a child never needs one.
+    if (node.childHost !== undefined)
+        arm(node, node.childHost);
+}
+function detach(node) {
+    const child = node.childHost;
+    if (child !== undefined)
+        detachPressMachine(child);
+    const state = states.get(node);
+    if (state === undefined)
+        return;
+    for (const id of state.timers)
+        clearTimeout(id);
+    state.timers.clear();
+    states.delete(node);
+}
+function onChildInserted(node, child) {
+    const previous = node.childHost;
+    if (previous === child)
+        return;
+    // A replaced child: release the machine still armed on the one that left. `removeChild` clears
+    // `childHost` (node.ts), so this only runs when a framework inserts without removing first.
+    if (previous !== undefined)
+        detachPressMachine(previous);
+    node.childHost = child;
+    // The owner's props were very likely written BEFORE this child existed (React and Solid set props
+    // at createInstance), so the CLONE owes a run even though nothing was written since. Witnessed by
+    // the MOVED-child case, not by a fresh one — `appendChild` already dirties a node it created.
+    // Still owed now that the rule is in C++: it runs on the child's commit, and a child nothing
+    // dirtied has no commit.
+    markPropsDirty(child);
+    arm(node, child);
+}
+// `focusable` is a function of a LISTENER, and a listener flip changes no payload by itself — so
+// the commit after it is a no-op and no fold re-runs (`IHostBehavior.onOwnedListenerChange`).
+function onOwnedListenerChange(node, name, wired) {
+    const child = node.childHost;
+    if (child === undefined)
+        return;
+    if (FORWARDED_LISTENERS.includes(name)) {
+        forwardListener(node, child, name, wired);
+        return;
+    }
+    if (name !== 'press')
+        return;
+    markPropsDirty(child);
+    requestCommitFor(child);
+}
+// Idempotent: an adapter entry may be imported more than once in a bundle.
+export function registerTouchableWithoutFeedbackBehavior() {
+    const behavior = {
+        attach,
+        detach,
+        onChildInserted,
+        onOwnedListenerChange,
+        // Owned on the OWNER, which is where the app writes them, and read from there by the machine on
+        // the child (`attachPressMachine`'s `source`) and by the trampolines above.
+        ownedListeners: [...PRESS_LISTENERS, ...FORWARDED_LISTENERS],
+        slotDerived: SLOT_DERIVED,
+        // TouchableWithoutFeedback.js's clone overwrites `nativeID` with the raw authored value
+        // (`:279-282`), the reverse of every other component's `id ?? nativeID` — see `routeIdAlias`.
+        nativeIdWinsOverId: true,
+    };
+    registerHostBehavior(TOUCHABLE_WITHOUT_FEEDBACK_TAG, behavior);
+}

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

@@ -2,33 +2,35 @@
 // Each name is the ViewManager's REACT_CLASS in react-native/ReactAndroid/.../views/**.
 // device-verify-pending: source-confirmed from RN's Android ViewManagers, proven on a
 // real host by the absence of a "Can't find ViewManager '<name>'" red box.
+import { ANCHOR_COMPONENT, VOID_COMPONENT } from '@symbiote-native/engine';
 import { buildDescriptors, makeDescriptorFor, } from './shared.js';
 const ANDROID_NAMES = {
-    'symbiote-view': 'RCTView',
-    'symbiote-pressable': 'RCTView',
-    'symbiote-text': 'RCTText',
-    'symbiote-image': 'RCTImageView',
-    'symbiote-scroll-view': 'RCTScrollView',
+    view: 'RCTView',
+    pressable: 'RCTView',
+    'touchable-opacity': 'RCTView',
+    // NOT a view name — TNF commits nothing at all, on either platform. See `shared.ts`.
+    'touchable-native-feedback': ANCHOR_COMPONENT,
+    'touchable-without-feedback': ANCHOR_COMPONENT,
+    'touchable-highlight': 'RCTView',
+    button: 'RCTView',
+    text: 'RCTText',
+    image: 'RCTImageView',
+    'image-background': 'RCTView',
+    'scroll-view': 'RCTScrollView',
     // RN's VScrollContentViewNativeComponent is `Platform.OS === 'android' ? View : …`,
     // so a vertical scroll's content is a plain RCTView on Android, not RCTScrollContentView.
-    'symbiote-scroll-content': 'RCTView',
+    'scroll-content': 'RCTView',
     // Horizontal scroll on Android is its own ViewManager; RCTScrollView is vertical-only and
     // ignores `horizontal`. RN routes it to AndroidHorizontalScrollView with a dedicated content
     // view (HScrollViewNativeComponents.js: `Platform.OS === 'android' ? AndroidHorizontal… : …`).
-    'symbiote-horizontal-scroll-view': 'AndroidHorizontalScrollView',
-    'symbiote-horizontal-scroll-content': 'AndroidHorizontalScrollContentView',
+    'horizontal-scroll-view': 'AndroidHorizontalScrollView',
+    'horizontal-scroll-content': 'AndroidHorizontalScrollContentView',
     // Android has one text-input ViewManager for both single- and multiline.
-    'symbiote-text-input': 'AndroidTextInput',
-    'symbiote-text-input-multiline': 'AndroidTextInput',
-    // The component path's pair — same native views, a tag the behavior registry does not
-    // carry. See `shared.ts` for why the wrapper may not share the lowered tag.
-    'symbiote-text-input-managed': 'AndroidTextInput',
-    'symbiote-text-input-multiline-managed': 'AndroidTextInput',
-    'symbiote-switch': 'AndroidSwitch',
-    // The wrapper's tag — same native view, a tag the behavior registry does not carry. See
-    // `shared.ts` for why the wrapper may not share the lowered tag.
-    'symbiote-switch-managed': 'AndroidSwitch',
-    'symbiote-activity-indicator': 'AndroidProgressBar',
+    'text-input': 'AndroidTextInput',
+    'text-input-multiline': 'AndroidTextInput',
+    switch: 'AndroidSwitch',
+    'activity-indicator': 'RCTView',
+    'activity-indicator-spinner': 'AndroidProgressBar',
     // KNOWN DIVERGENCE FROM REACT NATIVE, and it is in our favour — recorded 2026-09-01 because it
     // was arrived at by accident, not decided. Upstream `SafeAreaView.js` is
     // `Platform.select({ ios: RCTSafeAreaViewNativeComponent, default: View })`, so RN's own JS
@@ -43,12 +45,16 @@ const ANDROID_NAMES = {
     // react-native-safe-area-context. Invisible to every audit we have, because both of our paths
     // agree with each other and only disagree with RN — the boundary
     // `.claude/rules/adapter-parity-audit.md` states about itself.
-    'symbiote-safe-area-view': 'RCTSafeAreaView',
-    'symbiote-modal': 'RCTModalHostView',
-    'symbiote-refresh-control': 'AndroidSwipeRefreshLayout',
-    // iOS-only primitive; RN ships no Android InputAccessoryView. Degrade to a plain
-    // container so an iOS-targeted usage doesn't red-box on Android.
-    'symbiote-input-accessory-view': 'RCTView',
+    '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.
+    'input-accessory-view': VOID_COMPONENT,
 };
 export const COMPONENT_DESCRIPTORS = buildDescriptors(ANDROID_NAMES);
 export const descriptorFor = makeDescriptorFor(COMPONENT_DESCRIPTORS);

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

@@ -2,33 +2,38 @@
 // (component-names.ts re-exports it) for headless tsx / tsc / web fallback.
 // Fabric names are the codegen spec's registered name (the new-arch name), not the legacy
 // paperComponentName (RCTSwitch, …).
+import { ANCHOR_COMPONENT } from '@symbiote-native/engine';
 import { buildDescriptors, makeDescriptorFor, } from './shared.js';
 const IOS_NAMES = {
-    'symbiote-view': 'RCTView',
-    'symbiote-pressable': 'RCTView',
-    'symbiote-text': 'RCTText',
-    'symbiote-image': 'RCTImageView',
-    'symbiote-scroll-view': 'RCTScrollView',
-    'symbiote-scroll-content': 'RCTScrollContentView',
+    view: 'RCTView',
+    pressable: 'RCTView',
+    'touchable-opacity': 'RCTView',
+    // NOT a view name — TNF commits nothing at all. See `shared.ts`. Platform-invariant, unlike
+    // every other entry here: RN's TNF renders no view on either platform, it only stops CLONING a
+    // background off Android (TouchableNativeFeedback.js:402).
+    'touchable-native-feedback': ANCHOR_COMPONENT,
+    'touchable-without-feedback': ANCHOR_COMPONENT,
+    'touchable-highlight': 'RCTView',
+    button: 'RCTView',
+    text: 'RCTText',
+    image: 'RCTImageView',
+    'image-background': 'RCTView',
+    'scroll-view': 'RCTScrollView',
+    'scroll-content': 'RCTScrollContentView',
     // iOS uses one scroll view for both axes; horizontal is RCTScrollView with the
     // `horizontal` prop set, so these resolve identically to the vertical pair.
-    'symbiote-horizontal-scroll-view': 'RCTScrollView',
-    'symbiote-horizontal-scroll-content': 'RCTScrollContentView',
-    'symbiote-text-input': 'RCTSinglelineTextInputView',
-    'symbiote-text-input-multiline': 'RCTMultilineTextInputView',
-    // The component path's pair — same native views, a tag the behavior registry does not
-    // carry. See `shared.ts` for why the wrapper may not share the lowered tag.
-    'symbiote-text-input-managed': 'RCTSinglelineTextInputView',
-    'symbiote-text-input-multiline-managed': 'RCTMultilineTextInputView',
-    'symbiote-switch': 'Switch',
-    // The wrapper's tag — same native view, a tag the behavior registry does not carry. See
-    // `shared.ts` for why the wrapper may not share the lowered tag.
-    'symbiote-switch-managed': 'Switch',
-    'symbiote-activity-indicator': 'ActivityIndicatorView',
-    'symbiote-safe-area-view': 'SafeAreaView',
-    'symbiote-modal': 'ModalHostView',
-    'symbiote-refresh-control': 'PullToRefreshView',
-    'symbiote-input-accessory-view': 'RCTInputAccessoryView',
+    'horizontal-scroll-view': 'RCTScrollView',
+    'horizontal-scroll-content': 'RCTScrollContentView',
+    'text-input': 'RCTSinglelineTextInputView',
+    'text-input-multiline': 'RCTMultilineTextInputView',
+    switch: 'Switch',
+    'activity-indicator': 'RCTView',
+    'activity-indicator-spinner': 'ActivityIndicatorView',
+    'safe-area-view': 'SafeAreaView',
+    modal: 'ModalHostView',
+    'refresh-control': 'PullToRefreshView',
+    'sticky-header': 'RCTView',
+    'input-accessory-view': 'RCTInputAccessoryView',
 };
 export const COMPONENT_DESCRIPTORS = buildDescriptors(IOS_NAMES);
 export const descriptorFor = makeDescriptorFor(COMPONENT_DESCRIPTORS);

package/build/component-names/shared.d.ts

@@ -1,4 +1,5 @@
-export type ISymbioteIntrinsic = 'symbiote-view' | 'symbiote-pressable' | 'symbiote-text' | 'symbiote-image' | 'symbiote-scroll-view' | 'symbiote-scroll-content' | 'symbiote-horizontal-scroll-view' | 'symbiote-horizontal-scroll-content' | 'symbiote-text-input' | 'symbiote-text-input-multiline' | 'symbiote-text-input-managed' | 'symbiote-text-input-multiline-managed' | 'symbiote-switch' | 'symbiote-switch-managed' | 'symbiote-activity-indicator' | 'symbiote-safe-area-view' | 'symbiote-modal' | 'symbiote-refresh-control' | 'symbiote-input-accessory-view';
+export type ISymbioteIntrinsic = 'view' | 'pressable' | 'touchable-opacity' | 'touchable-native-feedback' | 'touchable-without-feedback' | 'touchable-highlight' | 'button' | 'text' | 'image' | 'image-background' | 'scroll-view' | 'scroll-content' | 'horizontal-scroll-view' | 'horizontal-scroll-content' | 'text-input' | 'text-input-multiline' | 'switch' | 'activity-indicator' | 'activity-indicator-spinner' | 'safe-area-view' | 'modal' | 'refresh-control' | 'sticky-header' | 'input-accessory-view';
+export type ICrossTypedIntrinsics<LooseProps, Crossed extends Partial<Record<ISymbioteIntrinsic, unknown>>> = Omit<Record<ISymbioteIntrinsic, LooseProps>, keyof Crossed> & Crossed;
 export interface IComponentDescriptor {
     component: string;
     isText: boolean;