@symbiote-native/components 1.0.0 → 2.0.0

package/build/behaviors/touchable-opacity.d.ts

@@ -0,0 +1,12 @@
+import { type IHostBehavior } from '@symbiote-native/engine';
+import { type IDisabledResolver } from './pressable';
+export declare const TOUCHABLE_OPACITY_TAG = "touchable-opacity";
+/**
+ * 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 declare function createTouchableOpacityBehavior(disabledOf?: IDisabledResolver): IHostBehavior;
+export declare function registerTouchableOpacityBehavior(): void;

package/build/behaviors/touchable-opacity.js

@@ -0,0 +1,227 @@
+// 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.
+import { AnimatedMock, AnimatedValue, Easing, Platform, appListenerFor, dlog, getExplicitStyle, markPropsDirty, registerHostBehavior, requestCommitFor, setAnimatedBehaviorStyle, timing, } from '@symbiote-native/engine';
+import { resolveTouchableFocusable } from '../view/render-pressable/index.js';
+import { accessibleUnlessOptedOut, booleanOr, createPressBehavior, } from './pressable.js';
+import { createTouchableFeedbackHandlers, createTouchableFeedbackRuntime, DEFAULT_ACTIVE_OPACITY, 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(node.props.activeOpacity, DEFAULT_ACTIVE_OPACITY);
+    const handlers = createTouchableFeedbackHandlers({
+        delayPressIn: numberOr(node.props.delayPressIn, 0),
+        delayPressOut: numberOr(node.props.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(node.props.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) {
+            // 0, not 150 (TouchableOpacity.js:215-220): the duration is chosen by where the press-in
+            // came from, and every pressIn our engine produces is the grant-equivalent.
+            fadeTo(state, activeOpacity, OPACITY_ACTIVE_GRANT_DURATION_MS);
+            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,
+    };
+};
+const press = createPressBehavior(refine);
+// The `id -> nativeID` alias every primitive's spec entry declares, applied here because
+// `HOST_PRIMITIVES` deliberately withholds this primitive's entry until the other adapters'
+// wrappers collapse to one node (the note at its Pressable neighbour says why). A raw `id` is a key
+// no ViewConfig declares, so Fabric drops it and the nativeID is lost on device with nothing red.
+//
+// Unconditional priority when both are set, matching RN (`View.js:77-79`) and `foldHostBag`.
+const foldPayload = props => {
+    const folded = press.foldPayload === undefined ? props : press.foldPayload(props);
+    const next = { ...folded };
+    // TouchableOpacity.js:303. The tag is this primitive's only path, so unlike `pressable` there is
+    // no wrapper for it to disagree with.
+    next.accessible = accessibleUnlessOptedOut(props);
+    if (Object.hasOwn(next, 'id')) {
+        next.nativeID = next.id;
+        delete next.id;
+    }
+    return next;
+};
+/**
+ * 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. `foldPayload` below is the same function either way.
+    const machine = createPressBehavior(refine, disabledOf);
+    return {
+        ...machine,
+        foldPayload,
+        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 disabled = disabledOf?.(node.props) ?? node.props.disabled;
+            const previous = state.settled;
+            state.settled = { disabled, resting };
+            if (previous === undefined) {
+                // RN's `Animated.View` carries `{opacity: anim}` in its style from the FIRST render, so a
+                // resting Touchable commits the key too — a tag that published nothing until the first
+                // press would differ from every wrapper on mount. Set rather than animate: this is the
+                // mount, and RN re-settles on componentDidUpdate only.
+                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');
+        },
+    };
+}
+// `focusable` is NOT in `foldPayload` above, because its middle leg — `onPress !== undefined`
+// (TouchableOpacity.js:338) — is an OWNED name and therefore lives in the stash, which a props-only
+// fold cannot reach. `./button` composes this behavior and resolves its own; the tag resolves it
+// here, over the node.
+//
+// `props.disabled`, not `next.disabled`: the press fold strips it (MACHINE_ONLY_KEYS).
+function tagFold(node) {
+    return props => {
+        const next = foldPayload(props);
+        next.focusable = resolveTouchableFocusable(booleanOr(props.focusable), appListenerFor(node, 'press') !== undefined, booleanOr(props.disabled));
+        return next;
+    };
+}
+// A listener flip changes no payload by itself, so the commit after it is a no-op and no fold
+// re-runs (`IHostBehavior.onOwnedListenerChange`). `./button` carries the twin of this.
+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();
+    registerHostBehavior(TOUCHABLE_OPACITY_TAG, {
+        ...touchable,
+        // `attachHostBehavior` writes `behavior.foldPayload` into the field one line BEFORE it calls
+        // `attach`, so binding here is what stands. Only the TAG binds it — a composing behavior owns
+        // its own node's fold (`./button` sets one in `buildStructure`, which runs later still).
+        attach(node) {
+            touchable.attach(node);
+            node.payloadFold = tagFold(node);
+        },
+        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,296 @@
+// 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 { ARIA_ALIAS_KEYS, appListenerFor, foldAriaProps, markPropsDirty, registerHostBehavior, requestCommitFor, setBehaviorListener, } from '@symbiote-native/engine';
+import { resolveDisabledAccessibilityState, resolveTouchableFocusable, } from '../view/render-pressable/index.js';
+import { accessibleUnlessOptedOut, asAccessibilityState, attachPressMachine, booleanOr, 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';
+// TouchableWithoutFeedback.js:130-153, RN's own order, minus two groups that are NOT props here:
+// the four `on*` names (forwarded as LISTENERS by `FORWARDED_LISTENERS`) and the five raw `aria-*`
+// entries. RN passes those raw because its TWF folds no aria itself and leaves the child View to do
+// it; we fold the owner's bag before the clone runs, so `aria-valuemax` has already become
+// `accessibilityValue` and `aria-modal` `accessibilityViewIsModal` by this point.
+//
+// COPIED ONLY WHEN SET (:281), which is the split from TNF's unconditional clone.
+const CLONED_WHEN_SET = [
+    'accessibilityActions',
+    'accessibilityHint',
+    'accessibilityLanguage',
+    'accessibilityIgnoresInvertColors',
+    'accessibilityLabel',
+    'accessibilityRole',
+    'accessibilityValue',
+    'accessibilityViewIsModal',
+    'hitSlop',
+    'testID',
+];
+// :253-276, assigned whatever their value — including `undefined`, which clears the child's, the
+// same `cloneElement` semantics TNF relies on. Three of them (`accessibilityElementsHidden`,
+// `accessibilityLiveRegion`, `importantForAccessibility`) are in RN's passthrough list TOO, and the
+// later conditional copy can only re-assign the same value the aria fold already resolved — so they
+// belong here, not above.
+const CLONED_ALWAYS = [
+    'accessibilityElementsHidden',
+    'accessibilityLiveRegion',
+    'importantForAccessibility',
+];
+// Owner props the four COMPUTED clones read, on top of the two lists above. `focusable` also
+// derives from the `press` LISTENER, which is not a prop — see `onOwnedListenerChange`.
+const DERIVED_FROM = [
+    'accessible',
+    'accessibilityState',
+    'disabled',
+    'focusable',
+    'id',
+    'nativeID',
+    // Not cloned at all: they configure the scheduler, which reads them live at gesture start. Listed
+    // so a mid-mount change still dirties the child and the next commit re-reads them.
+    'delayPressIn',
+    'delayPressOut',
+    'minPressDuration',
+];
+// Every owner name the child's payload reads. Without it the clone is correct at mount and frozen
+// forever after: `markPropsDirty` bubbles UP, so an owner write never reaches the child on its own.
+const SLOT_DERIVED = [
+    ...CLONED_WHEN_SET,
+    ...CLONED_ALWAYS,
+    ...DERIVED_FROM,
+    ...ARIA_ALIAS_KEYS,
+];
+// :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;
+}
+function stringOr(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * `cloneElement(element, elementProps)` as a payload fold: the child's own props first, the owner's
+ * two lists over them. Pure, as `IPayloadFold` requires — the owner is read, never written.
+ */
+function cloneFold(owner, inner) {
+    return (props) => {
+        const next = {
+            ...(inner === undefined ? props : inner(props)),
+        };
+        // The owner's aria props are on the OWNER, so the engine's own fold at `fabricProps` — which
+        // reads the node being committed — never sees them. Run it here over the source bag; the fold
+        // returns its input by identity when there is nothing to do.
+        const source = owner.hasAriaAlias
+            ? foldAriaProps(owner.props)
+            : owner.props;
+        for (const key of CLONED_ALWAYS)
+            next[key] = source[key];
+        for (const key of CLONED_WHEN_SET) {
+            if (source[key] !== undefined)
+                next[key] = source[key];
+        }
+        // :255-266. `onPress` is an OWNED name, so it lives in the stash and never in `props`.
+        const disabled = booleanOr(source.disabled);
+        next.accessible = accessibleUnlessOptedOut(source);
+        next.focusable = resolveTouchableFocusable(booleanOr(source.focusable), appListenerFor(owner, 'press') !== undefined, disabled);
+        // :275 gives `id` priority; the passthrough loop then re-assigns a set `nativeID` over it
+        // (:280-284), so upstream an explicit `nativeID` wins where TNF's `id` does. NOT reproduced,
+        // and deliberately: the spec entry declares `ID_ALIAS`, so on the three adapters that fold in
+        // the renderer `id` has already become `nativeID` before this runs and the quirk is
+        // unobservable — reproducing it would make the answer depend on WHICH adapter is driving,
+        // which is the divergence `.claude/rules/adapter-parity-audit.md` exists to prevent.
+        next.nativeID = stringOr(source.id) ?? stringOr(source.nativeID);
+        // :257-262 folded by the engine above, then :258-263: an explicit `disabled` overrides the
+        // aria/accessibilityState answer.
+        next.accessibilityState = resolveDisabledAccessibilityState(asAccessibilityState(source.accessibilityState), disabled);
+        return next;
+    };
+}
+/**
+ * `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(owner.props.delayPressIn, 0),
+            delayPressOut: numberOr(owner.props.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(owner.props.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;
+    child.payloadFold = cloneFold(node, child.payloadFold);
+    // The owner's props were very likely written BEFORE this child existed (React and Solid set props
+    // at createInstance), so the fold 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.
+    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,
+    };
+    registerHostBehavior(TOUCHABLE_WITHOUT_FEEDBACK_TAG, behavior);
+}

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

@@ -2,33 +2,42 @@
 // 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 } 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',
+    'text-input': 'AndroidTextInput',
+    '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',
+    'text-input-managed': 'AndroidTextInput',
+    'text-input-multiline-managed': 'AndroidTextInput',
+    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',
+    'switch-managed': '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 +52,13 @@ 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',
+    'safe-area-view': 'RCTSafeAreaView',
+    modal: 'RCTModalHostView',
+    'refresh-control': 'AndroidSwipeRefreshLayout',
+    'sticky-header': 'RCTView',
     // 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',
+    'input-accessory-view': 'RCTView',
 };
 export const COMPONENT_DESCRIPTORS = buildDescriptors(ANDROID_NAMES);
 export const descriptorFor = makeDescriptorFor(COMPONENT_DESCRIPTORS);