@symbiote-native/components 1.0.0 → 3.0.0

package/build/behaviors/touchable-highlight.js

@@ -0,0 +1,205 @@
+// TouchableHighlight 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, THE SAME SIMPLIFICATION EVERY WRAPPER ALREADY SHIPPED. RN's own TouchableHighlight
+// renders a container View (the responder, the underlay backgroundColor, the whole accessibility
+// fold) and CLONES an extra opacity style onto its single child (TouchableHighlight.js:281-320,
+// `_createExtraStyles` + `cloneElement`). This tag folds both onto the ONE node instead, in
+// `foldTouchableHighlightUnderlay` (`SymbioteFabricProps.cpp`) now — see that rule's own header.
+//
+// KNOWN GAP, and it predates both this port and the fix it reverts. Composing `opacity` onto the
+// SAME node as the underlay's `backgroundColor` fades the underlay itself, so `underlayColor:
+// 'black'` paints grey rather than black — every adapter's wrapper shipped this, and the rule's own
+// header above says so on purpose ("The port keeps that, it does not reopen it"). A 2026-09-15 fix
+// (fd39750b) closed it pointwise, in JS, on this one tag; this revert returns to the shared
+// (buggy) behavior every adapter already had, which is correct for THIS merge — a merge that also
+// changes behavior is unattributable.
+//
+// The reason the old header gave for not splitting it — "needs a child to target and a framework
+// component holding an opaque children slot cannot reach one safely" — no longer holds: that was
+// true of JS wrappers, not of the engine. The DESCENDANT seam this needs already exists: a rule
+// keyed on `IOwner.tagName`, the same shape `foldCloneOntoChild` uses to reach a
+// TouchableNativeFeedback child's own `fabricProps()` call and write onto ITS payload — the write
+// `IFirstChild` cannot do, since that seam only reads a child, from the PARENT's own call.
+//
+// TODO: what actually blocks it is one missing field. `IOwner` carries `{ props, tagName,
+// hasPressListener }`; the child would need the owner's `underlayShown` too (currently only on
+// `ISelf`, the node's own state) to decide whether to paint at all. Closing this is a new
+// descendant-keyed rule plus that one field on `IOwner`, not a `foldTouchableHighlightUnderlay`
+// rewrite.
+//
+// WHAT IS SHARED AND WHAT IS NEW. The underlay show/hide state machine
+// (createHighlightUnderlayHandlers/createHighlightUnderlayRuntime, `../state/touchable`) is already
+// framework-agnostic — every wrapper already calls it. New here is only WHERE `shown` lives (a
+// WeakMap keyed by node, the same shape `./touchable-opacity`'s `states` map uses) and how a flip
+// reaches Fabric: `markPropsDirty` + `requestCommitFor`, the same primitives `./pressable`'s
+// `setPressed` composer uses to re-fold after an internal state change — NOT
+// `setAnimatedBehaviorStyle`, which exists for a continuously-driven `AnimatedValue` and would be
+// the wrong tool for a discrete boolean swap with no easing.
+//
+// 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.
+//
+// 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): `TouchableHighlight.js:206-232` also gates the underlay show/hide
+// on `onFocus`/`onBlur` (TV remote) and skips its own press-triggered show/hide-after-delay
+// entirely when `Platform.isTV`. Neither is wired here. Deliberately not implemented — dead on
+// every device this project targets (no tvOS build). Audit skill, "Found, NOT fixed: TV
+// (Platform.isTV) focus/blur feedback on TouchableOpacity/Highlight".
+import { markPropsDirty, registerHostBehavior, requestCommitFor, setNodeUnderlayShown, propOf, } from '@symbiote-native/engine';
+import { resolveButtonDisabled } from '../view/render-button.js';
+import { asAccessibilityState, booleanOr, createPressBehavior, } from './pressable.js';
+import { createHighlightUnderlayHandlers, createHighlightUnderlayRuntime, hasTouchablePressHandler, } from '../state/touchable.js';
+export const TOUCHABLE_HIGHLIGHT_TAG = 'touchable-highlight';
+// TouchableHighlight.js:194-197 — `disabled ?? accessibilityState.disabled` (RN omits aria-disabled
+// here, unlike Opacity/Button/NativeFeedback — an upstream inconsistency this matches rather than
+// "fixes"). Without it, `accessibilityState={{disabled: true}}` alone greys the label but a press
+// still fires here.
+const touchableHighlightDisabled = props => resolveButtonDisabled(booleanOr(props.disabled), undefined, asAccessibilityState(props.accessibilityState));
+const states = new WeakMap();
+function numberOr(value, fallback) {
+    return typeof value === 'number' ? value : fallback;
+}
+// Runs once per GESTURE, matching `./touchable-opacity`'s `refine` — the config it reads is
+// whatever the props hold when a finger lands, and the underlay handlers it builds read `shown`
+// through the closure below rather than owning it, so a re-arm reads the current props.
+const refine = (node, config) => {
+    const state = states.get(node);
+    if (state === undefined)
+        return config;
+    const hasPressHandler = hasTouchablePressHandler({
+        onPress: config.onPress,
+        onPressIn: config.onPressIn,
+        onPressOut: config.onPressOut,
+        onLongPress: config.onLongPress,
+    });
+    const underlay = createHighlightUnderlayHandlers({
+        delayPressOut: numberOr(propOf(node, 'delayPressOut'), 0),
+        hasPressHandler,
+        testOnlyPressed: propOf(node, 'testOnly_pressed') === true,
+        schedule: (callback, ms) => {
+            const id = setTimeout(() => {
+                state.timers.delete(id);
+                callback();
+            }, ms);
+            state.timers.add(id);
+            return () => {
+                clearTimeout(id);
+                state.timers.delete(id);
+            };
+        },
+    }, state.runtime, {
+        setShown: (shown) => {
+            if (state.shown === shown)
+                return;
+            state.shown = shown;
+            // THE BIT, and nothing else. No style is resolved here: what a showing underlay looks like
+            // is `foldTouchableHighlightUnderlay` in the engine, which reads the same two props it
+            // already strips from the payload. `markPropsDirty` is still owed — the op marks the host's
+            // node, and this marks the JS side's so the commit walk visits it.
+            setNodeUnderlayShown(node, shown);
+            markPropsDirty(node);
+            requestCommitFor(node);
+        },
+        onShowUnderlay: () => {
+            const onShowUnderlay = propOf(node, 'onShowUnderlay');
+            if (typeof onShowUnderlay === 'function')
+                onShowUnderlay();
+        },
+        onHideUnderlay: () => {
+            const onHideUnderlay = propOf(node, 'onHideUnderlay');
+            if (typeof onHideUnderlay === 'function')
+                onHideUnderlay();
+        },
+    });
+    return {
+        ...config,
+        // TouchableHighlight.js:203, verbatim: RN hands Pressability a 0 floor here too — what holds
+        // the underlay visible is the hold TIMER above, not a press-duration floor.
+        minPressDuration: 0,
+        onPress: (event) => {
+            underlay.handlePress(event);
+            config.onPress?.(event);
+        },
+        onPressIn: (event) => {
+            underlay.handlePressIn(event);
+            config.onPressIn?.(event);
+        },
+        onPressOut: (event) => {
+            underlay.handlePressOut(event);
+            config.onPressOut?.(event);
+        },
+    };
+};
+// THE UNDERLAY FOLD LEFT THIS FILE ON 2026-09-18, and with it the last `payloadFold` on this tag —
+// this behavior now costs ZERO trips into JS per commit, down from one on every commit it was dirty
+// in (which for a touchable is FIVE at mount alone, because the opacity settle re-commits it).
+//
+// THE NOTE IT REPLACES SAID THE UNDERLAY WAS "the genuine unportable article" BECAUSE IT IS BUILT
+// FROM LIVE PRESS STATE. Half right, and the half it got wrong is the reusable part: `shown` really
+// does flip mid-gesture and really is JS's, but the RULE was never made of it. Of four inputs, three
+// were already portable — `underlayColor` and `activeOpacity` are ordinary props (ones the engine
+// ALREADY strips), and `_hasPressHandler` is listener EXISTENCE, which has crossed since
+// `OP_SET_OWNED_LISTENER`. The fourth is one bit. "JS holds it" was never the same claim as "only JS
+// can compute it", and this is the third time that distinction has moved a rule.
+//
+// WHAT CROSSES AND WHAT DOES NOT. `setNodeUnderlayShown` sends the bit on a flip — twice a tap. The
+// hold timer, the `press`-then-`pressOut` ordering, the re-arm on a second tap and the
+// `onShowUnderlay` / `onHideUnderlay` callbacks all stay here, where Pressability is, because they
+// run at gesture rate and call into app code. That is the browser's line too: a UA paints `:active`,
+// the page decides what a click means.
+//
+// `focusable` left earlier the same day and carried a bug out with it — it read `props.disabled` off
+// the BAG, which the engine's pressable rule strips, so every DISABLED highlight stayed in the focus
+// order. One rule serves both touchable tags now (`foldPressableProps`), so there is no second copy
+// to drift; pinned in `core/engine/cpp/tests/js/touchable-focusable-payload.itest.ts`.
+//
+// The underlay's own contract: `core/engine/cpp/tests/js/touchable-highlight-underlay.itest.ts`.
+// A listener flip changes no payload by itself, so the commit after it is a no-op and no fold
+// re-runs (`IHostBehavior.onOwnedListenerChange`) — same reason `./touchable-opacity` carries this.
+function onOwnedListenerChange(node, name) {
+    if (name !== 'press')
+        return;
+    markPropsDirty(node);
+    requestCommitFor(node);
+}
+/**
+ * The behavior as PARTS, mirroring `./touchable-opacity`'s shape — a tag that is a
+ * TouchableHighlight plus something composes this instead of re-implementing the underlay.
+ */
+export function createTouchableHighlightBehavior(disabledOf) {
+    const machine = createPressBehavior(refine, disabledOf);
+    return {
+        ...machine,
+        attach(node) {
+            states.set(node, {
+                shown: false,
+                runtime: createHighlightUnderlayRuntime(),
+                timers: new Set(),
+            });
+            machine.attach(node);
+        },
+        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();
+            states.delete(node);
+        },
+    };
+}
+// Idempotent: an adapter entry may be imported more than once in a bundle.
+export function registerTouchableHighlightBehavior() {
+    const touchable = createTouchableHighlightBehavior(touchableHighlightDisabled);
+    // Spread whole: the tag used to override `attach` purely to bind a per-node `payloadFold`, and
+    // with the underlay rule in the engine there is nothing left to add.
+    registerHostBehavior(TOUCHABLE_HIGHLIGHT_TAG, {
+        ...touchable,
+        onOwnedListenerChange,
+    });
+}

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

@@ -0,0 +1,20 @@
+import { type IPressConfigRefinement } from './pressable';
+export declare const TOUCHABLE_NATIVE_FEEDBACK_TAG = "touchable-native-feedback";
+/**
+ * TNF's own Pressability config, applied to whatever node carries the responder.
+ *
+ * SHARED WITH `./button`, which is what this file's arrival makes possible. Button's Android arm
+ * held a private copy with a comment saying a future `touchable-native-feedback` tag could not
+ * reuse it "while the wrappers wrap" — the tag is here now and the responder node is a parameter
+ * either way, so the copy is gone.
+ *
+ * `minPressDuration: 0` is UNCONDITIONAL in RN (:226), not Android-gated: TNF has no feedback
+ * machine of its own to hold, and the press machine's 130 ms deactivation floor would only defer
+ * `onPressOut` — which on Android leaves `setPressed(false)` ~130 ms late and the ripple lit after
+ * the finger is gone. The two view commands ARE Android-gated (:257,:276): the ripple is a drawable
+ * Android animates off the view's pressed state, and the JS responder consumes the touch before
+ * Android's own pressed handling ever runs, so without them the background is installed and never
+ * moves.
+ */
+export declare const nativeFeedbackRefinement: IPressConfigRefinement;
+export declare function registerTouchableNativeFeedbackBehavior(): void;

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

@@ -0,0 +1,254 @@
+// TouchableNativeFeedback as an ENGINE-NODE behavior — the one primitive that must commit NO NODE
+// OF ITS OWN (`.claude/rules/host-primitive-tier.md`, tier 2).
+//
+// RN'S TNF RENDERS NOTHING. `render()` takes `React.Children.only(this.props.children)`
+// (TouchableNativeFeedback.js:289) and returns `cloneElement(element, {…}, ...children)` (:339) —
+// the child IS the responder, carries the ripple background, and takes the whole accessibility
+// fold. All five of our adapters render a `Pressable` around a feedback `View` instead, so every
+// TNF in every app commits a node RN does not, and the mistake has already spread: our Pressable
+// wrapper and our TouchableOpacity wrapper both copied that inner view from here
+// (`.claude/rules/adapter-parity-audit.md`, "the OTHER half turned up a gap on BOTH paths").
+//
+// WHY THE FIX CANNOT BE PER ADAPTER. At the FRAMEWORK level React, Vue and Solid can clone a child
+// element; Svelte's children arrive as a snippet and Angular's through `<ng-content>`, and neither
+// can have props written onto them there. At the ENGINE level all five can reach the child node.
+// So the clone belongs below the frameworks, once, or it is five copies of one fold.
+//
+// ---------------------------------------------------------------------------------------------
+// THE SHAPE, and which existing engine seam does each half:
+//
+//   commits nothing     the tag resolves to ANCHOR_COMPONENT (component-names), so the node is
+//                       BORN skipped: `renderableChildren` (commit.ts) drops it and flattens its
+//                       child into the grandparent's renderable list. Not a new concept — that is
+//                       precisely what an anchor is, and TNF is its third instance after Vue's
+//                       fragment placeholders and Angular's non-painting component hosts.
+//   finds its child     `onChildInserted`, the one hook this needed. `buildStructure` cannot do it:
+//                       it runs at `attach`, inside `createElement`, and the child is the
+//                       FRAMEWORK'S and does not exist yet.
+//   clones the props    a `payloadFold` on the CHILD reading the owner's bag, re-run because
+//                       `slotDerived` marks the child's props dirty on every owner write. The
+//                       alternative — redirecting each prop onto the child through `slotPropsExcept`
+//                       — was rejected: adapters disagree about ORDER (React writes props before
+//                       children, Vue mounts children before props), so a redirect silently drops
+//                       every prop written before the child arrives, on some adapters only.
+//   presses             the press machine on the CHILD, reading the OWNER (`attachPressMachine`'s
+//                       `source`). It cannot live on the owner: `bubble` (events/index.ts) skips
+//                       anchors for listener lookup, and `handOverNativeResponder` has no Fabric
+//                       handle to hand native for an uncommitted node. So a responder on this tag
+//                       could never fire — checked before the design, not after.
+// ---------------------------------------------------------------------------------------------
+// KNOWN LIMITS, stated rather than left to be found:
+//
+// 1. EXACTLY ONE CHILD, as RN enforces with `React.Children.only`. A second child lands INSIDE the
+//    first (the ordinary `childHost` redirect) rather than throwing. Nothing in RN's surface
+//    produces that shape.
+// 2. A child REMOVED from a still-mounted TNF leaves its press machine armed until the TNF itself
+//    unmounts (`detach` releases whatever `childHost` then holds). Unreachable through the
+//    frameworks we drive: Solid's remove-then-reinsert move and Svelte's parking both move the TNF,
+//    never its single child, and there is no sibling to reorder it against.
+// 3. `style` is NOT cloned, matching RN — its clone list (:342-390) is closed, and a `style` on a
+//    TNF stays on a node that never commits. RN's TNF declares no style prop either.
+//
+// REGISTRATION IS THE HAZARD, not the machine — see `./pressable` for why each adapter entry does a
+// bare `import './register';` that the barrel does not re-export. 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 a wrapper still built its own Pressable + feedback View, registering would have left every
+// TouchableNativeFeedback with two responders.
+import { SLOT_DERIVED_ALL, appListenerFor, dispatchViewCommand, markPropsDirty, Platform, registerHostBehavior, requestCommitFor, setBehaviorListener, } from '@symbiote-native/engine';
+import { resolveButtonDisabled } from '../view/render-button.js';
+import { asAccessibilityState, attachPressMachine, booleanOr, detachPressMachine, } from './pressable.js';
+export const TOUCHABLE_NATIVE_FEEDBACK_TAG = 'touchable-native-feedback';
+// TouchableNativeFeedback.js:214-221 — `disabled != null ? disabled : (aria-disabled ??
+// accessibilityState.disabled)`, read by the OWNER's Pressability config (:213), same three-way
+// answer Button/Opacity resolve. The clone's own `accessibilityState`/`focusable` already use the
+// RAW `disabled` prop correctly (RN does too, :311-321,:369-371) — only the press machine, which
+// lives on the CHILD and reads the OWNER, was missing this.
+const touchableNativeFeedbackDisabled = props => resolveButtonDisabled(booleanOr(props.disabled), booleanOr(props['aria-disabled']), asAccessibilityState(props.accessibilityState));
+// Read once, like `./button`'s: the platform cannot change under a running app.
+const IS_ANDROID = Platform.OS === 'android';
+// WHAT THE OWNER'S WRITES DIRTY, and it is EVERY name rather than a list of thirty.
+//
+// RN's clone list (`TouchableNativeFeedback.js:349-390`) lived here until 2026-09-18 as
+// `CLONED_PROPS` + `DERIVED_FROM` + `ARIA_ALIAS_KEYS`, feeding `slotDerived`. The clone itself is
+// `foldCloneOntoChild` in `SymbioteFabricProps.cpp`, so the list had stopped being the rule and
+// become a MIRROR of `kNativeFeedbackClonedKeys` — two lists that must agree, failing silently (the
+// clone goes stale on the one prop a list forgot) when they drift.
+//
+// `SLOT_DERIVED_ALL` is both the honest spelling and the cheaper one to keep: a `cloneElement` owner
+// re-clones on every render whatever changed, so it never derived its slot from a NAMED set in the
+// first place. The cost is a false dirty on an owner prop the clone does not carry, and for this tag
+// that is nearly empty — its owner is an anchor whose props reach Fabric nowhere else, so every name
+// it holds is either cloned or consumed by the press machine.
+const SLOT_DERIVED = [SLOT_DERIVED_ALL];
+// The two RN clones as EVENTS rather than props (:386-387). Owned, so the app's callback stashes on
+// the owner and a trampoline installed on the child reads it at dispatch time — which keeps a fresh
+// closure per render free, exactly as `ownedListeners` intends.
+//
+// Both are Fabric BOOLEAN-GATED events (`.claude/rules/fabric-boolean-event-gates.md`), so the
+// trampoline goes in only while the app has one wired: `setBehaviorListener` writes and clears the
+// flag with it, and installing eagerly would light the gate on every TNF child in the tree.
+const FORWARDED_LISTENERS = [
+    'layout',
+    'accessibilityAction',
+];
+const PRESS_LISTENERS = [
+    'press',
+    'pressIn',
+    'pressOut',
+    'pressMove',
+    'longPress',
+    'startShouldSetResponder',
+    'responderMove',
+    'responderTerminationRequest',
+];
+// `asFeedbackBackground` went with the fold, and `backgroundProps` — the slot pick it fed — followed
+// on 2026-09-18 as the orphan it had become. The first narrowed the app's `background` dict on its
+// discriminant; the C++ rule asks only whether the value is an OBJECT and copies it into the slot,
+// because the four factories that produce it (`render-touchable-native-feedback.ts`) are ours and
+// the payload is not a place to re-validate what a typed factory already built.
+// TouchableNativeFeedback.js:280 — `locationX ?? 0`. The bag is raw Fabric payload, so guard.
+function hotspotAt(nativeEvent, key) {
+    const value = nativeEvent[key];
+    return typeof value === 'number' ? value : 0;
+}
+/**
+ * TNF's own Pressability config, applied to whatever node carries the responder.
+ *
+ * SHARED WITH `./button`, which is what this file's arrival makes possible. Button's Android arm
+ * held a private copy with a comment saying a future `touchable-native-feedback` tag could not
+ * reuse it "while the wrappers wrap" — the tag is here now and the responder node is a parameter
+ * either way, so the copy is gone.
+ *
+ * `minPressDuration: 0` is UNCONDITIONAL in RN (:226), not Android-gated: TNF has no feedback
+ * machine of its own to hold, and the press machine's 130 ms deactivation floor would only defer
+ * `onPressOut` — which on Android leaves `setPressed(false)` ~130 ms late and the ripple lit after
+ * the finger is gone. The two view commands ARE Android-gated (:257,:276): the ripple is a drawable
+ * Android animates off the view's pressed state, and the JS responder consumes the touch before
+ * Android's own pressed handling ever runs, so without them the background is installed and never
+ * moves.
+ */
+export const nativeFeedbackRefinement = (node, config) => {
+    if (!IS_ANDROID)
+        return { ...config, minPressDuration: 0 };
+    const hotspot = (event) => {
+        dispatchViewCommand(node, 'hotspotUpdate', [
+            hotspotAt(event.nativeEvent, 'locationX'),
+            hotspotAt(event.nativeEvent, 'locationY'),
+        ]);
+    };
+    return {
+        ...config,
+        minPressDuration: 0,
+        onPressIn(event) {
+            // RN's order: hotspot first, so the ripple starts where the finger is rather than at centre.
+            hotspot(event);
+            dispatchViewCommand(node, 'setPressed', [true]);
+            config.onPressIn?.(event);
+        },
+        onPressMove(event) {
+            hotspot(event);
+            // RN drops the app's own onPressMove here; ours forwards it, because on a tag that callback
+            // is the app's and iOS already delivers it.
+            config.onPressMove?.(event);
+        },
+        onPressOut(event) {
+            dispatchViewCommand(node, 'setPressed', [false]);
+            config.onPressOut?.(event);
+        },
+    };
+};
+// `cloneFold` LEFT THIS FILE ON 2026-09-18 — it is `foldCloneOntoChild` in
+// `SymbioteFabricProps.cpp`, and the seam it needed is the first rule keyed on the PARENT'S tag
+// rather than on the node's own (`IOwner`). The child of a TNF is whatever the app wrote, usually a
+// plain `<view>` with no tag at all, so nothing self-keyed could ever have reached it.
+//
+// What it cost to have had here: one JSI round trip per touchable per commit over an eighteen-key
+// bag, and `tag-rule-cost.itest.ts` prices a fold by what it MARSHALS rather than by what it does.
+//
+// Contract: `core/engine/cpp/tests/js/clone-onto-child-payload.itest.ts`.
+// Not RN's own list: RN drops these by never cloning them, and a tag has no clone to omit
+// them from — they would ride into the child's payload as keys no ViewConfig declares. Same strip
+// `./pressable`'s fold does for the machine-only half, applied to the owner's bag instead.
+//
+// (`background` / `useForeground` / `disabled` / `hitSlop` never reach the child's props at all —
+// the fold only ever ADDS to the child's own bag — so nothing needs stripping here. Kept as a
+// comment rather than an empty constant so the next reader does not go looking for the strip.)
+// 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) {
+    attachPressMachine(child, {
+        source: owner,
+        refine: nativeFeedbackRefinement,
+        disabledOf: touchableNativeFeedbackDisabled,
+    });
+    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`.
+    if (node.childHost !== undefined)
+        arm(node, node.childHost);
+}
+function detach(node) {
+    const child = node.childHost;
+    if (child !== undefined)
+        detachPressMachine(child);
+}
+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. Still owed
+    // now that the rule is in C++ and no fold is chained here: the rule 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 registerTouchableNativeFeedbackBehavior() {
+    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_NATIVE_FEEDBACK_TAG, behavior);
+}

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;