@symbiote-native/components 3.1.0 → 3.1.2

package/build/behaviors/image-background.js

@@ -1,35 +1,11 @@
-// ImageBackground's host behavior: the composition and the prop split the wrapper component did,
-// moved below the framework so the primitive can be a bare tag.
-//
-// THE TWO-NODE SHAPE IS RN'S. `ImageBackground.js:74-103` opens a `<View>` carrying the app's
-// `style`, puts an absolutely-filled `<Image>` inside it, and lays the app's `{children}` AFTER
-// that image so they paint on top. The tag commits the same two nodes — `image-background` (an
-// RCTView, the tag an app writes) with an RCTImageView built under it.
-//
-// WHY THE SLOT TAKES NO CHILDREN, which is the one thing this primitive needed that ScrollView,
-// ActivityIndicator and Button did not. `childHost` answers two questions at once — which node an
-// owner prop redirects onto, and which node the app's children go under — and those had the same
-// answer for every primitive until this one. Here they differ: the image takes `imageStyle` and the
-// whole `...props` spread, while the children belong beside it. `slotTakesNoChildren` is what
-// splits them (`IHostBehavior`, and it is not a JSX nicety upstream could have collapsed — an
-// Android `<Image>` is an `ImageView`, not a `ViewGroup`).
-//
-// WHERE THE APP'S PROPS GO. RN destructures `children, style, imageStyle, imageRef,
-// importantForAccessibility, ...props` and spreads `...props` onto the Image
-// (`ImageBackground.js:62-81`), so the set that moves is OPEN — every event, every accessibility
-// prop, `testID`, `id`, whatever an app writes next — and only a complement can express it.
-// `IMAGE_BACKGROUND_HOST_PROPS` is that complement, and `importantForAccessibility` is IN it despite
-// never being part of the spread: RN reapplies it explicitly to both nodes (`:76,82`), so it stays on
-// the owner here too and the image gets its own copy derived from `ownerProps` (FIXED 2026-09-20 —
-// it used to redirect to the image alone and never reach the owner at all, which the module's own
-// comment rationalized as "the divergence from RN predates all of it").
-//
-// WHAT THE IMAGE'S FOLD OWES. Everything on the image arrives as a real prop write, so its payload
-// is built by the shared `foldImagePayload` like any other `image`. Two things cannot arrive that
-// way and are folded here: the style, which is DERIVED from the owner's own `style` (RN proxies the
-// wrapper's width/height onto the image so it fills the box rather than collapsing to the source's
-// intrinsic size), and `id`, whose rename to `nativeID` is applied per adapter on the tag THEY
-// create and so never reaches a node a behavior built.
+// ImageBackground's host behavior. RN's `ImageBackground.js:74-103` opens a `<View>` with the
+// app's `style`, an absolutely-filled `<Image>` inside, children painted AFTER on top — this tag
+// commits the same two nodes (`image-background` + its inner image).
+// `childHost` normally answers both "where do owner props redirect" and "where do children go" —
+// here they differ (image takes the spread, children stay on the owner), so
+// `slotTakesNoChildren` splits them; not a JSX nicety, an Android `<Image>` is not a ViewGroup.
+// RN spreads an OPEN prop set onto the Image (`ImageBackground.js:62-81`);
+// `IMAGE_BACKGROUND_HOST_PROPS` below is the complement RN keeps on the wrapper instead.
 import { appendChild, createElement, registerHostBehavior, } from '@symbiote-native/engine';
 import { descriptorFor } from '../component-names';
 import { IMAGE_TAG, registerImageBehavior } from './image.js';
@@ -37,12 +13,9 @@ export const IMAGE_BACKGROUND_TAG = 'image-background';
 // The inner image's own tag. Distinct from `image` because the absolute fill must NOT reach a bare
 // `<image>`, and a tag is the only thing a per-node rule can branch on.
 export const IMAGE_BACKGROUND_IMAGE_TAG = 'image-background-image';
-// The props RN keeps on the wrapper View (`ImageBackground.js:74-78`), plus the two spellings of a
-// class name — `routeProp`'s slot redirect runs above its own class branch, so an unlisted `class`
-// would style the image instead of the box. `importantForAccessibility` stays too: RN destructures
-// it out of `...props` and reapplies it explicitly to BOTH the wrapper (:76) and the image (:82), so
-// it is never part of the spread — the engine derives the image's own copy from this node
-// (`foldImageBackgroundImageProps` in `SymbioteFabricProps.cpp`), the same seam the box proxy uses.
+// Kept on the wrapper (`ImageBackground.js:74-78`), plus both class spellings — the slot redirect
+// runs above the class branch, so an unlisted `class` would style the image instead. RN reapplies
+// `importantForAccessibility` to BOTH nodes (:76,82); the image gets its own derived copy.
 const IMAGE_BACKGROUND_HOST_PROPS = [
     'style',
     'class',
@@ -56,49 +29,16 @@ const IMAGE_BACKGROUND_SLOT_DERIVED = ['style', 'importantForAccessibility'];
 // value for it — every adapter's wrapper resolved one — and `routeProp` routes a string landing on
 // `style` as `class` instead, so the registry resolves it on the image with nothing needed here.
 const IMAGE_BACKGROUND_SLOT_PROPS = { imageStyle: 'style' };
-// The owner's fold is GONE (2026-09-18), not moved into this file under another name: its whole
-// content was `accessibilityIgnoresInvertColors: true`, a function of the tag and nothing else, and
-// it is `foldImageBackgroundProps` in `SymbioteFabricProps.cpp` now. The owner therefore pays no
-// trip into JS at all, and a committed ImageBackground is down from two crossings to one — the
-// remaining one is the inner image's, below, which derives its style from THIS node and so cannot be
-// a per-node rule. Contract: `core/engine/cpp/tests/js/image-background-payload.itest.ts`.
-// THE IMAGE'S FOLD IS GONE TOO (2026-09-18) — `foldImageBackgroundImageProps` in
-// `SymbioteFabricProps.cpp`, and with it this primitive costs ZERO trips into JS on both nodes.
-//
-// It outlived every other fold in this file because both of its inputs live on the node ABOVE: the
-// app writes `style` on the `<image-background>` and `IMAGE_BACKGROUND_HOST_PROPS` keeps it there.
-// "A per-node rule cannot reach another node" is what this file used to say, and it was a fact about
-// the JS FOLD rather than the engine — the tree is in C++, so `fabricProps` takes `ownerProps` from
-// `node.parent` and the proxy reads it there.
-//
-// The `id -> nativeID` half went earlier still and was DEAD before this port: `foldIdAlias` applies
-// to every tagged node and runs ahead of any fold, so by the time this ran the key was already
-// renamed. Worth naming, because a fold that still spells a rule someone else now applies reads as
-// load-bearing and is not.
-//
-// Contract: `core/engine/cpp/tests/js/image-background-image-payload.itest.ts`.
-// Returns the image, so `slotProps` / `slotPropsExcept` / `slotDerived` all point at it — and the
-// app's children stay on the owner because of `slotTakesNoChildren`, not because of what this
-// returns. The image is appended FIRST and nothing else is ever placed in front of it, which is
-// what makes the children paint over it.
-//
-// Built WITH `IMAGE_TAG` since 2026-09-18, which is the reverse of what it used to do and for a
-// reason that reversed with it. It used to withhold the tag so the node would not get Image's
-// `payloadFold` — a single slot this primitive needed for its own derived style — and call the
-// shared mapping by hand at the end. The mapping is the ENGINE's now, reached off the tag, so the
-// tag is how this node gets the platform half at all; the JS slot is free for the composition.
-//
-// ONE ORDERING DIFFERENCE FALLS OUT, and it is deliberate rather than overlooked. The image rule
-// folds the image's own `width`/`height` PROPS under its style, and the background rule then layers
-// the box's dimensions over that — where RN nests it the other way (`ImageBackground.js:83-98` puts
-// the props under the proxied box size). So when an app sets BOTH a `width` prop on the
-// ImageBackground and a conflicting width in its `style`, RN gives the style's and we give the
-// prop's.
-//
-// It is left this way rather than reproduced: RN's own comment calls that nesting a "Temporary
-// Workaround" for an Image that overwrites its own dimensions, and an explicit prop winning over an
-// inherited box is the less surprising of the two. Pinned in
-// `core/components/src/behaviors/image-background.test.ts` so it stays a decision.
+// The owner's fold is GONE: its one job (`accessibilityIgnoresInvertColors: true`) is
+// `foldImageBackgroundProps` in C++ now (`image-background-payload.itest.ts`).
+// The image's fold is GONE too — `foldImageBackgroundImageProps` in C++, reading `ownerProps`
+// from `node.parent` for the style proxy (`image-background-image-payload.itest.ts`).
+// Returns the image, so `slotProps`/`slotPropsExcept`/`slotDerived` point at it; children stay on
+// the owner via `slotTakesNoChildren`. Built WITH `IMAGE_TAG` so the engine's Image mapping still
+// applies to it — the JS slot is free for composition only.
+// ONE ORDERING DIFFERENCE, deliberate: the image rule folds its own `width`/`height` under its
+// style, then the box's dimensions layer over that — RN nests it the other way
+// (`ImageBackground.js:83-98`). Pinned in `image-background.test.ts` so it stays a decision.
 //
 // THE TAG IS ITS OWN, and that is what the C++ port needed. The node used to carry plain `image`,
 // which is right for everything the ordinary image rule does and wrong for the fill — a bare

package/build/behaviors/image.js

@@ -1,13 +1,6 @@
-// Image's host behavior, and it carries no runtime at all — no listeners, no timers, no commit
-// hook, and since 2026-09-18 no fold either. What is left is ONE declaration: that this tag's three
-// source props are resolved on the way in.
-//
-// WHERE THE FOLD WENT: `foldImageProps` in `SymbioteFabricProps.cpp`, with
-// `core/engine/cpp/tests/js/image-payload.itest.ts` as its contract. The `srcSet`/`src`/`source`
-// precedence, the W3C header decoration, the `width`/`height` fold into style, `alt` becoming
-// `accessibilityLabel` + `accessible`, `resizeMode`/`tintColor` falling back to style keys, and
-// `loadingIndicatorSource` being plucked down to a bare uri — all of it is a function of the tag,
-// which is what makes it the platform's.
+// Image's host behavior carries no runtime — no listeners, no timers, no fold. `foldImageProps`
+// in C++ resolves the `srcSet`/`src`/`source` precedence, style folds and a11y mapping, asserted
+// in `core/engine/cpp/tests/js/image-payload.itest.ts`.
 //
 // WHY THIS ONE DID NOT MOVE WHOLE, and it is the first that did not. `resolveAssetSource` turns the
 // number `require('./logo.png')` returns into a `{uri, width, height, scale}` by asking METRO'S

package/build/behaviors/input-accessory-view.js

@@ -1,54 +1,13 @@
-// InputAccessoryView's host behavior. This file itself still owns no per-node runtime — the
-// primitive's real rule lives in `foldInputAccessoryViewProps` (`SymbioteFabricProps.cpp`) now.
-//
-// THE OLD FOLD WAS GONE, not moved (2026-09-18): read end to end it split the bag into
-// consumed/passthrough and reassembled it — there was no aliasing at all, every consumed name left
-// under the same name, and the one thing it actually changed was dropping a `nativeID` or
-// `backgroundColor` that was not a `string`. That is defensive narrowing of a typed view object,
-// not a rule native cares about — and it was WRONG on `backgroundColor`, whose validAttributes
-// entry carries `processColor` and therefore accepts a number.
-//
-// A REAL RULE WAS FOUND WHILE READING VENDOR FOR THE PORT (2026-09-20):
-// `InputAccessoryView.js`'s `styles.container = {position: 'absolute'}`, composed AFTER the app's
-// own style (`[props.style, styles.container]`) so it wins over any `position` an app authors.
-// Every InputAccessoryView is positioned absolutely; nothing about it is per-instance, so it is
-// `foldInputAccessoryViewProps` now rather than anything here. Contract:
-// `core/engine/cpp/tests/js/touchable-payload.itest.ts`.
-//
-// NOT YET PORTED, and recorded honestly rather than silently skipped: vendor also wraps the app's
-// children in an inner `SafeAreaView` sized to `useWindowDimensions().width` (`InputAccessoryView.js`
-// render body) and returns nothing at all when it has zero children. Both are real structural gaps
-// — a composed child node plus a live window-dimension binding — genuinely larger than a tag-only
-// rule, and are NOT covered by this pass.
-//
-// TODO(rn-parity): port both. Needs (a) a `buildStructure` composing an inner wrapper node styled
-// `{flex: 1, width}` around the app's children, with `width` read from a live window-dimensions
-// subscription (no `SafeAreaView` primitive exists in this codebase yet — it would need building),
-// and (b) suppressing the whole node (both platforms, not just Android's void case already fixed
-// here) when it has zero children, matching `React.Children.count(props.children) === 0`.
-//
-// The `id -> nativeID` alias — is `foldIdAlias` in `SymbioteFabricProps.cpp`, applied to every
-// tagged node rather than per primitive.
-//
-// PLATFORM. This is the only primitive in its group that is not platform-invariant in what it
-// COMMITS TO: `input-accessory-view` resolves to `RCTInputAccessoryView` on iOS and to the void
-// component on Android. The fold itself is platform-invariant on purpose.
-//
-// FIXED (2026-09-20). `InputAccessoryView.js` on Android does `console.warn('<InputAccessoryView>
-// is only supported on iOS.'); return null` — the WHOLE component, children included, renders
-// NOTHING. We used to commit a real `RCTView` and its whole children subtree (the toolbar content
-// an app wrapped in it) — an extra, laid-out, potentially visible view where a real device shows
-// none. `backgroundColor` being a declared iOS prop vs an Android style key is the SAME already-
-// narrow gap, unaffected by this.
-//
-// The fix needed a new engine primitive, because every existing "commits no node of its own"
-// tier-2 primitive (`touchable-native-feedback`, `touchable-without-feedback`) is an ANCHOR — it
-// hoists its single child up in its own place, which is the opposite of what this tag needs: its
-// whole subtree must vanish. `VOID_COMPONENT` (`core/engine/src/node.ts`, `OP_CREATE_VOID` in
-// `mutation-buffer.ts`) is that primitive — a node the commit walk stops at, recursively,
-// contributing neither itself nor its children. Wired purely through
-// `core/components/src/component-names/index.android.ts`'s per-platform table, the same seam
-// `ANCHOR_COMPONENT` already used — this behavior file needed no change at all.
+// InputAccessoryView's host behavior owns no per-node runtime — the rule is
+// `foldInputAccessoryViewProps` in C++, including the container's absolute-position style RN
+// always composes over the app's own (`core/engine/cpp/tests/js/touchable-payload.itest.ts`).
+// NOT YET PORTED: vendor also wraps children in an inner SafeAreaView sized to
+// `useWindowDimensions().width` and renders nothing with zero children.
+// TODO(rn-parity): needs a `buildStructure` wrapper node, a live window-dimensions subscription,
+// and suppressing the whole node on both platforms when childless.
+// Android resolves to `VOID_COMPONENT` (`core/engine/src/node.ts`, `OP_CREATE_VOID`): the commit
+// walk stops there recursively, contributing neither the node nor its children — wired through
+// `component-names/index.android.ts`, this behavior file needed no change.
 import { Platform, registerHostBehavior, } from '@symbiote-native/engine';
 export const INPUT_ACCESSORY_VIEW_TAG = 'input-accessory-view';
 // `InputAccessoryView.js:110-113` — off iOS it warns and renders nothing (the void component).

package/build/behaviors/pressable.d.ts

@@ -2,52 +2,13 @@ import { type IHostBehavior, type ISymbioteNode } from '@symbiote-native/engine'
 import { type IPressMachineConfig } from '../state/pressable';
 import type { IAccessibilityStateValue } from '../accessibility-props';
 export declare const PRESSABLE_TAG = "pressable";
-/**
- * A last look at the machine's config before its handlers are built, for a tag that IS a pressable
- * plus something — TouchableOpacity, whose fade has to run between the machine and the app's own
- * `onPressIn`.
- *
- * Called from `rebuild`, so once per gesture rather than once per mount: it sees the config the
- * props actually hold by the time a finger lands, and anything it captures is discarded with the
- * gesture. Per-node state that must OUTLIVE a gesture belongs on the caller's own WeakMap.
- */
 export type IPressConfigRefinement = (node: ISymbioteNode, config: IPressMachineConfig) => IPressMachineConfig;
-/**
- * What the machine reads as `disabled`, for a tag whose spelling of it is not the raw prop.
- *
- * There is no resolver by default because RN's Pressable hands Pressability the RAW prop
- * (`Pressable.js:266`) — `aria-disabled` there changes only what is ANNOUNCED. Button is the one
- * primitive that differs: it resolves `disabled ?? aria-disabled ?? accessibilityState.disabled` in
- * the component and passes the ANSWER down as the touchable's own prop (`Button.js:337` -> `:386`),
- * which a single tag has no second node to pass to.
- *
- * Reads the bag and returns the answer; it must never write one back. `resolveButtonDisabled`
- * short-circuits on an authored `disabled`, so a resolved value stored in `node.props.disabled`
- * would answer the NEXT resolution as if the app had written it and the tag could never re-enable.
- */
 export type IDisabledResolver = (props: Readonly<Record<string, unknown>>) => boolean | undefined;
 export type ICancelableResolver = (source: ISymbioteNode) => boolean | undefined;
 export declare function booleanOr(value: unknown): boolean | undefined;
 export declare function asAccessibilityState(value: unknown): IAccessibilityStateValue | undefined;
 export declare function accessibleUnlessOptedOut(props: Readonly<Record<string, unknown>>): boolean;
-/**
- * The Android ripple's three view commands around the app's callbacks (TNF :230-252,
- * useAndroidRippleForView.js:77-104). The JS responder takes the touch before Android's own
- * pressed handling, so without them the ripple never animates. Hotspot first: it starts under
- * the finger.
- */
 export declare function withNativeFeedbackCommands(node: ISymbioteNode, config: IPressMachineConfig): IPressMachineConfig;
-/**
- * The machine on `node`, reading its props and the app's callbacks off `options.source` when that
- * is a different node.
- *
- * Exported for a behavior whose responder is not its own node — `./touchable-native-feedback`,
- * whose tag commits nothing and adopts the app's single child as the responder. Every other caller
- * goes through `createPressBehavior`, where source and node are the same.
- *
- * Re-callable on the same node: a second call replaces the state and the dispatchers, which is what
- * a re-arm after `detachPressMachine` needs.
- */
 export declare function attachPressMachine(node: ISymbioteNode, options?: {
     readonly refine?: IPressConfigRefinement;
     readonly disabledOf?: IDisabledResolver;
@@ -56,14 +17,5 @@ export declare function attachPressMachine(node: ISymbioteNode, options?: {
 }): void;
 /** See `attachPressMachine`: the same teardown `createPressBehavior` registers as its `detach`. */
 export declare function detachPressMachine(node: ISymbioteNode): void;
-/**
- * The press machine as behavior parts, so a tag that is a pressable PLUS something can compose it
- * instead of re-implementing it.
- *
- * Spread into the caller's own behavior and wrap `attach`/`detach` around these — the touchable
- * family needs a per-node Animated value opened before the machine and closed after it. The
- * WeakMap holding the machine's own state is keyed by node, so one node may hold exactly one of
- * these; a tag composing it therefore must not also register the plain `pressable` behavior.
- */
 export declare function createPressBehavior(refine?: IPressConfigRefinement, disabledOf?: IDisabledResolver): Pick<IHostBehavior, 'attach' | 'detach' | 'ownedListeners'>;
 export declare function registerPressableBehavior(): void;

package/build/behaviors/pressable.js

@@ -1,19 +1,9 @@
 // The press machine as an ENGINE-NODE behavior, so a pressable can be an intrinsic tag instead of
-// a framework component (`.claude/rules/host-primitive-tier.md`, tier 2). Written once; every
-// adapter inherits it by registering, and none re-implements it.
-//
-// The machine itself is unchanged and still shared with the component path — `createPressRuntime`
-// / `createPressHandlers` in `../state/pressable`. What is new is only WHERE its lifecycle lives:
-// on the engine node rather than in a component instance.
-//
-// REGISTRATION IS THE HAZARD, not the machine. Metro enables `inlineRequires` in production only,
-// moving a `require` to the first place its binding is used as a VALUE, and a barrel's
-// `export { X } from './x'` compiles to a lazy getter. A module whose only job is a side effect is
-// never named as a value, so re-exporting it means it NEVER RUNS in a release build — dev perfect,
-// release silently pressless. Each adapter therefore keeps its own `src/register.ts` calling
-// `registerPressableBehavior()`, and its entry does a bare `import './register';` that the barrel
-// does NOT re-export. A bare `import './register';` sitting NEXT TO such a re-export does not work
-// either: Babel merges the two imports of one specifier and the merged dependency stays lazy.
+// a framework component. Written once; every adapter inherits it by registering, none re-implements
+// it. The machine itself is unchanged and still shared with the component path.
+// Registration, not the machine, is the hazard: Metro's inlineRequires makes a barrel re-export of
+// a side-effect-only module never run in a release build. Each adapter keeps its own
+// `src/register.ts` calling registerPressableBehavior(), reached only by a bare side-effect import.
 import { appListenerFor, dispatchViewCommand, dlog, Platform, propOf, registerHostBehavior, requestCommitFor, setBehaviorListener, setNodePressed, propsOf, } from '@symbiote-native/engine';
 import { createPressHandlers, createPressRuntime, disposePressRuntime, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, } from '../state/pressable.js';
 import { buildPressableListeners } from '../view/render-pressable/index.js';
@@ -56,10 +46,9 @@ function asRectOffset(value) {
 function isPressHandler(value) {
     return typeof value === 'function';
 }
-// Narrowed field by field rather than cast: the bag arrives as `unknown` off `propOf`. A local
-// twin of the guard each adapter keeps for its own attrs (Vue's `asAccessibilityState`) — exported
-// to the sibling behaviors that fold the same bag, and deliberately NOT to the shared barrel, which
-// every adapter re-exports wholesale: a narrowing helper is not API anyone should be able to import.
+// Narrowed field by field rather than cast: the bag arrives as `unknown` off propOf. Exported to
+// sibling behaviors folding the same bag, deliberately NOT to the shared barrel — a narrowing
+// helper isn't API anyone should import.
 export function asAccessibilityState(value) {
     if (!isRecord(value))
         return undefined;
@@ -76,36 +65,19 @@ export function asAccessibilityState(value) {
         state.expanded = value.expanded;
     return state;
 }
-// THE PAYLOAD FOLD MOVED TO THE ENGINE — `foldPressableProps` in `SymbioteFabricProps.cpp`, and
-// its contract is `core/engine/cpp/tests/js/pressable-payload.itest.ts`. It is not re-implemented
-// here in any form, which is the point: `disabled` -> `accessibilityState`, `accessible`/`focusable`
-// defaulting on, the Android ripple config, and the nine machine-only keys being kept out of the
-// payload are all functions of the TAG alone. That is user-agent behavior — RN does it for every
-// Pressable in every app — and it belongs beside the tree, like a browser's `<button>`.
-//
-// It cost a trip: a `payloadFold` marshals the whole bag out and the whole bag back, ~17 us per
-// pressable per commit, and a benchmark row carries two.
-//
-// What is still here is the MACHINE, which is where a browser keeps it too: timers, the responder
-// claim, hit-slop retention, and the callbacks into app code.
-//
-// The one thing that did NOT move with it is `hitSlop`, and that is deliberate — it is a real
-// native View prop, so it never was part of the fold.
-// RN makes every pressable accessible unless the app opts OUT — `Pressable.js:252`
-// (`accessible: accessible !== false`), and the whole Touchable family repeats it verbatim
-// (`TouchableOpacity.js:303`, `TouchableHighlight.js:337`). `!== false` rather than `?? true`, so
-// only a literal `false` opts out and an explicit `undefined` still reads as accessible.
-//
-// Nothing in this repo did it until 2026-09-09, so a Pressable reached a screen reader as a plain
-// view unless the app wrote the prop. Exported so anything composing this tag can say it too.
+// The payload fold moved to the engine (foldPressableProps in SymbioteFabricProps.cpp), not
+// re-implemented here: disabled -> accessibilityState, accessible/focusable defaulting on, the
+// ripple config and the machine-only keys are all functions of the TAG alone, user-agent behavior.
+// What's still here is the MACHINE: timers, the responder claim, hit-slop retention, callbacks
+// into app code. `hitSlop` did NOT move with the fold — it's a real native View prop.
+// RN makes every pressable accessible unless the app opts OUT (`accessible !== false`), and the
+// whole Touchable family repeats it. `!== false` not `?? true`, so only a literal `false` opts out.
 export function accessibleUnlessOptedOut(props) {
     return props.accessible !== false;
 }
-// From the STASH, not from the props. Every name below is in `ownedListeners`, so `routeProp`
-// diverts the app's `onPress` away from `node.listeners` (where it would evict the behavior's own
-// dispatcher) and into the stash — which makes the stash the only place it exists. Reading
-// `propOf` here returns undefined for every callback and every press silently does nothing:
-// the behavior runs, the machine runs, and it calls nobody.
+// From the STASH, not the props: every name below is in ownedListeners, so routeProp diverts the
+// app's onPress away from node.listeners into the stash. Reading propOf here would return
+// undefined for every callback and every press would silently call nobody.
 function callbackAt(node, event) {
     const value = appListenerFor(node, event);
     return isPressHandler(value) ? value : undefined;
@@ -121,29 +93,19 @@ function configFor(node) {
         onPressOut: callbackAt(node, 'pressOut'),
         onPressMove: callbackAt(node, 'pressMove'),
         onLongPress: callbackAt(node, 'longPress'),
-        // Pressability.js:471-474 — `normalizeDelay(authored, 10, DEFAULT_LONG_PRESS_DELAY_MS -
-        // delayPressIn)`. The subtraction applies only to the FALLBACK, never to an authored value —
-        // it exists so the long-press threshold, timed from the grant that also arms
-        // `unstable_pressDelay`, lands at a constant 500ms from touch-down by default, not
-        // 500ms + unstable_pressDelay. See `createPressHandlers`'s `handlePressIn` for the other half
-        // (the timer must be ARMED at grant, not after the pressDelay fires, or this compensation
-        // does nothing).
+        // The subtraction applies only to the FALLBACK, never an authored value — it keeps the
+        // long-press threshold at a constant 500ms from touch-down by default, not
+        // 500ms + unstable_pressDelay (see createPressHandlers.handlePressIn for the other half).
         delayLongPress: Math.max(10, numberOr(propOf(node, 'delayLongPress'), DEFAULT_DELAY_LONG_PRESS_MS - unstablePressDelay)),
         unstable_pressDelay: unstablePressDelay,
-        // RN's Touchables own the deactivation floor in their OWN machine and hand Pressability
-        // `minPressDuration: 0` (TouchableOpacity.js:195). While they were wrappers they passed it as
-        // an internal input; on the tag there is nowhere else to say it, so the floor has to be a
-        // readable prop or every Touchable holds its fade for the machine's 130 ms default.
+        // RN's Touchables own the deactivation floor in their own machine, handing Pressability
+        // `minPressDuration: 0`. On the tag there's nowhere else to say it, so it's a readable prop.
         minPressDuration: numberOr(propOf(node, 'minPressDuration'), DEFAULT_MIN_PRESS_DURATION_MS),
         hitSlop: asRectOffset(propOf(node, 'hitSlop')),
         pressRetentionOffset: asRectOffset(propOf(node, 'pressRetentionOffset')),
-        // Pressable.js's own name is `android_disableSound`; every composed touchable (Highlight,
-        // NativeFeedback, WithoutFeedback, Button) instead forwards vendor's `touchSoundDisabled` to
-        // this same config field (`TouchableHighlight.js:205`, `TouchableWithoutFeedback.js:199`,
-        // `TouchableNativeFeedback.js:228`). `node` here is whichever tag AUTHORS the prop — itself for
-        // a plain pressable/highlight/button, the owner for a clone-onto-child touchable, since
-        // `configFor` is always called with that source — so reading both names off it resolves
-        // correctly for every composition without a per-tag override.
+        // Pressable's own name is `android_disableSound`; every composed touchable instead forwards
+        // `touchSoundDisabled` to this same field. `node` here is whichever tag AUTHORS the prop, so
+        // reading both names resolves correctly for every composition without a per-tag override.
         android_disableSound: booleanOr(propOf(node, 'android_disableSound')) ??
             booleanOr(propOf(node, 'touchSoundDisabled')),
     };
@@ -164,12 +126,8 @@ function hotspotAt(nativeEvent, key) {
     const value = nativeEvent[key];
     return typeof value === 'number' ? value : 0;
 }
-/**
- * The Android ripple's three view commands around the app's callbacks (TNF :230-252,
- * useAndroidRippleForView.js:77-104). The JS responder takes the touch before Android's own
- * pressed handling, so without them the ripple never animates. Hotspot first: it starts under
- * the finger.
- */
+// The Android ripple's three view commands around the app's callbacks. The JS responder takes
+// the touch before Android's own pressed handling, so without them the ripple never animates.
 export function withNativeFeedbackCommands(node, config) {
     const hotspot = (event) => {
         dispatchViewCommand(node, 'hotspotUpdate', [
@@ -194,13 +152,9 @@ export function withNativeFeedbackCommands(node, config) {
         },
     };
 }
-// Rebuilding at GESTURE START is the whole reason for the dispatcher indirection, and skipping it
-// is a bug that looks like working code. `attach` runs inside `createElement`, before a single
-// prop has been routed — the node holds nothing at all there — so a machine built at attach would
-// capture no `onPress` at all and every press would silently do nothing. `createPressHandlers`
-// destructures its config eagerly, so it cannot be handed a live view either; it has to be re-made
-// once the props exist. A gesture is one interaction, so a handful of closures per press is
-// invisible — unlike doing it per prop write, which is the cost this whole tier exists to remove.
+// Rebuilding at GESTURE START is the whole reason for the dispatcher indirection: `attach` runs
+// inside createElement before a single prop is routed, so a machine built at attach would capture
+// no onPress at all. A gesture is one interaction, so a handful of closures per press is invisible.
 function rebuild(node, state) {
     // `state.source` for everything READ, `node` for the refinement, which acts on the responder
     // (dispatching a view command needs the committed node, not the one holding the props).
@@ -223,13 +177,9 @@ function rebuild(node, state) {
         blockNativeResponder: propOf(source, 'blockNativeResponder') === true,
     });
 }
-// Pressable is the only member of the family with a `cancelable` prop of its own (`Pressable.js:41`).
-// TouchableOpacity/TouchableHighlight/TouchableNativeFeedback instead expose `rejectResponderTermination`
-// and derive `cancelable: !this.props.rejectResponderTermination` internally
-// (`TouchableOpacity.js:186`, `TouchableHighlight.js:194`, `TouchableNativeFeedback.js:217`) — every
-// composed touchable shares this `rebuild()`, so without this the authored name never reached the
-// machine and every Touchable silently kept the RN native default (yield the responder) regardless of
-// what the app asked for. An explicit `cancelable` still wins, matching Pressable's own precedence.
+// Pressable is the only family member with its own `cancelable` prop; the Touchables instead
+// expose `rejectResponderTermination` and derive cancelable internally. Without this the authored
+// name never reaches the machine. An explicit `cancelable` still wins, matching Pressable's rule.
 function resolveCancelable(source) {
     const cancelable = propOf(source, 'cancelable');
     if (typeof cancelable === 'boolean')
@@ -237,19 +187,11 @@ function resolveCancelable(source) {
     const reject = propOf(source, 'rejectResponderTermination');
     return typeof reject === 'boolean' ? !reject : undefined;
 }
-// WHICHEVER EVENT OPENS THE GESTURE REBUILDS, and pinning that to one name was a real bug.
-// `onStartShouldSetResponder` looks like the opener and is not: `core/engine/src/events/index.ts`
-// bubbles PRESS_IN and only THEN calls `negotiateResponder`, so `pressIn` arrives FIRST on every
-// gesture. Rebuilding only on the responder claim therefore handed the first `pressIn` an empty
-// listener bag — the press-in half of every press was dropped, the pressed style never reached
-// Fabric, and `onPress` still fired because by then the machine existed. That is exactly the
-// device report: the callback works, the button does not light up.
-//
-// So the trigger is a FLAG, not a name: build if this gesture has not built yet, and clear it when
-// the gesture ends. Order-independent, and it survives the engine reordering its own events.
-//
-// A key `buildPressableListeners` omitted — every one of them when `disabled` is true — resolves to
-// undefined here and the dispatcher returns undefined, which is what an absent listener would do.
+// WHICHEVER EVENT OPENS THE GESTURE REBUILDS: `onStartShouldSetResponder` looks like the opener
+// and isn't, since the engine bubbles PRESS_IN and only then negotiates the responder, so
+// `pressIn` arrives first. Rebuilding only on the responder claim handed it an empty listener bag.
+// The trigger is a FLAG, not a name: build if this gesture hasn't built yet, clear on gesture end
+// — order-independent, survives the engine reordering its own events.
 const GESTURE_END_KEYS = new Set([
     'onPressOut',
     'onResponderTerminationRequest',
@@ -267,30 +209,14 @@ function dispatch(node, state, key, args) {
         state.isBuilt = false;
     return result;
 }
-// Installed straight into the listener slot rather than through `routeProp`: the behavior OWNS
-// these names, and `setEventListener` diverts an owned name into the app stash — routing its own
-// dispatcher through there would stash it and leave the slot empty.
-//
-// The engine event names, not the `onX` prop spellings. `buildPressableListeners` speaks the prop
-// spelling, so the two are mapped here rather than guessed at either end.
-/**
- * Engine event name -> the app-facing callback key its dispatcher routes to.
- *
- * AN ARRAY OF PAIRS RATHER THAN A `Map`, and the reason is measured rather than stylistic.
- * `installListeners` below is the only reader, and it runs once per node that carries a press
- * machine — which is every `<TextInput>` on the screen, not just every `<Pressable>`. A `for…of` over
- * a `Map` builds a fresh two-element array per entry for the destructuring to read back: seven
- * allocations per node, for seven fixed pairs that never change. The tuples here already exist, so
- * the same loop allocates nothing but its iterator.
- *
- * Priced on `-O` Hermes by `text-input-attach-ladder.itest.ts`, one pass over the seven pairs:
- * `Map` 1.04 us, this 0.39, two parallel arrays 0.29. The parallel arrays are cheapest and give up
- * the pairing, which is not worth 0.1 us on a table that a drift would silently unwire.
- *
- * NOT the same list as `createPressBehavior`'s `ownedListeners`, and they must not be merged: that
- * one is every name the machine takes as an INPUT (`pressMove` and `longPress` included), this one
- * is only the names it installs a dispatcher for.
- */
+// Installed straight into the listener slot, not through routeProp: the behavior OWNS these
+// names, and setEventListener diverts an owned name into the app stash — routing the dispatcher
+// through there would stash it and leave the slot empty.
+// Engine event name -> the app-facing callback key its dispatcher routes to. An array of pairs
+// rather than a Map: installListeners runs once per node carrying a press machine, and a `for…of`
+// over a Map allocates a fresh pair per entry where these tuples already exist.
+// NOT the same list as createPressBehavior's ownedListeners — that's every name the machine takes
+// as an INPUT, this is only the names it installs a dispatcher for.
 const EVENT_KEY_PAIRS = [
     ['press', 'onPress'],
     ['pressIn', 'onPressIn'],
@@ -308,17 +234,11 @@ function installListeners(node, state) {
 function attachWith(refine, disabledOf) {
     return node => attach(node, { refine, disabledOf });
 }
-/**
- * The machine on `node`, reading its props and the app's callbacks off `options.source` when that
- * is a different node.
- *
- * Exported for a behavior whose responder is not its own node — `./touchable-native-feedback`,
- * whose tag commits nothing and adopts the app's single child as the responder. Every other caller
- * goes through `createPressBehavior`, where source and node are the same.
- *
- * Re-callable on the same node: a second call replaces the state and the dispatchers, which is what
- * a re-arm after `detachPressMachine` needs.
- */
+// The machine on `node`, reading props and callbacks off `options.source` when different.
+// Exported for touchable-native-feedback, whose tag commits nothing and adopts the app's single
+// child as the responder; every other caller goes through createPressBehavior where they're equal.
+// Re-callable on the same node: a second call replaces the state and dispatchers, which is what
+// re-arming after detachPressMachine needs.
 export function attachPressMachine(node, options = {}) {
     attach(node, options);
 }
@@ -330,10 +250,8 @@ function attach(node, options) {
         // through the style registry's `:active` variant, and never crosses into it.
         setPressed: pressed => {
             setNodePressed(node, pressed);
-            // Dirtying is not publishing. A press arrives from a native event, outside every renderer
-            // mutation path, so nothing schedules a commit — `native-events.ts` requests none, and no
-            // adapter does either. `setNodeHidden`'s React twin never hit this because the reconciler is
-            // already in its commit phase when it calls.
+            // Dirtying is not publishing: a press arrives outside every renderer mutation path, so
+            // nothing else schedules a commit.
             requestCommitFor(node);
         },
         // `measure` needs a committed Fabric tag, which a node has by the time a human can touch it.
@@ -377,10 +295,8 @@ function detach(node) {
     const state = states.get(node);
     if (state === undefined)
         return;
-    // The machine's own teardown, which every wrapper calls from its destroy hook. Not load-bearing
-    // here and no test can make it so: `host.schedule` puts every timer the machine arms into
-    // `state.timers` — the 130ms floor's deferred `pressOut` included — so the loop below already
-    // cancels them. Kept as the contract, and for a timer armed by some future route.
+    // The machine's own teardown. Not load-bearing here: host.schedule puts every timer the machine
+    // arms into state.timers, so the loop below already cancels them — kept as the contract.
     disposePressRuntime(state.runtime);
     for (const id of state.timers)
         clearTimeout(id);
@@ -388,15 +304,9 @@ function detach(node) {
     states.delete(node);
     dlog('pressable behavior detached');
 }
-/**
- * The press machine as behavior parts, so a tag that is a pressable PLUS something can compose it
- * instead of re-implementing it.
- *
- * Spread into the caller's own behavior and wrap `attach`/`detach` around these — the touchable
- * family needs a per-node Animated value opened before the machine and closed after it. The
- * WeakMap holding the machine's own state is keyed by node, so one node may hold exactly one of
- * these; a tag composing it therefore must not also register the plain `pressable` behavior.
- */
+// The press machine as behavior parts, so a tag that is a pressable PLUS something can compose
+// it instead of re-implementing it — the touchable family wraps attach/detach for its own
+// per-node Animated value. One node may hold exactly one of these; don't also register `pressable`.
 export function createPressBehavior(refine, disabledOf) {
     return {
         attach: attachWith(refine, disabledOf),