@symbiote-native/components 1.0.0 → 3.0.0

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

@@ -1,53 +1,31 @@
-// InputAccessoryView: the render half (framework-agnostic, iOS). A real Fabric host node,
-// RCTInputAccessoryView, that docks its content above the keyboard. It is referenced by
-// `nativeID`, which a TextInput points at through its `inputAccessoryViewID` prop; native pairs
-// the two by id. There is no JS-side translation: style / nativeID / backgroundColor map straight
-// onto the intrinsic and the user children (injected by the adapter) nest under it. Shared
-// verbatim across adapters: React and Vue both bridge this Descriptor.
-import { dlog, } from '@symbiote-native/engine';
-import { el } from '../descriptor.js';
-// The names this fold CONSUMES, exported so an adapter splitting props before calling the render fn
-// reads the list instead of copying it — the drift `render-image.ts` records paying for once.
-export const INPUT_ACCESSORY_VIEW_PROP_NAMES = [
-    'nativeID',
-    'backgroundColor',
-    'style',
-];
-// The whole mapping, so the wrapper path and the lowered path share ONE implementation. There is no
-// aliasing here at all: every consumed name leaves under the same name, which is what makes the
-// fold idempotent by construction (asserted in `behaviors/input-accessory-view.test.ts`, not
-// assumed).
+// InputAccessoryView: the framework-agnostic prop SHAPE (iOS). The tag commits a real Fabric host
+// node, RCTInputAccessoryView, that docks its content above the keyboard; it is referenced by
+// `nativeID`, which a TextInput points at through its `inputAccessoryViewID` prop, and native pairs
+// the two by id. There is no JS-side translation — style / nativeID / backgroundColor map straight
+// onto the intrinsic.
 //
-// The `undefined` guards on `nativeID` / `backgroundColor` are LOAD-BEARING, and the asymmetry with
-// the unguarded `style` above is not the tell it looks like.
+// THE MAPPING FUNCTION IS GONE (2026-09-18) and only the type is left, which is the honest residue:
+// `mapInputAccessoryViewProps` took the bag apart and put it back together unchanged, so the
+// behavior stopped calling it and nothing else ever did. Angular still names the type for its
+// `@Input()` declarations (`adapters/angular/src/elements.ts`), so the shape stays; the fold does
+// not. Why it was never a rule, and the numeric `backgroundColor` it used to drop:
+// `core/components/src/behaviors/input-accessory-view.ts`.
+export {};
+// WHAT THE DELETED FOLD KNEW THAT THIS FILE NO LONGER HAS TO, kept because the trap is a property
+// of the engine and outlives the function that hit it. The `undefined` guards on `nativeID` /
+// `backgroundColor` were LOAD-BEARING, and not for the reason they look it:
 //
-// They were removed on 2026-09-01 on the reasoning `.claude/rules/fabric-boolean-event-gates.md`
-// states — `setProp` collapses an undefined value to an absent key, so a conditional write in a
-// shared render fn is cosmetic — and that reasoning was checked against a payload carrying no `id`,
-// which is exactly the case where it holds. The equivalence oracle caught it on its first run:
-//
-//   authored <InputAccessoryView id="p" testID="p" />
+//   authored <input-accessory-view id="p" testID="p">
 //   guarded    RCTInputAccessoryView{testID, nativeID:"p"}
 //   unguarded  RCTInputAccessoryView{testID}              <- the alias result, deleted
 //
-// `nativeID` has an ALIAS SOURCE. The wrapper leaves `id` in `passthrough`, the renderer's
-// PROP_ALIASES renames it to `nativeID`, and a `nativeID: undefined` written afterwards deletes what
-// the rename just produced — last write wins, and `undefined` collapsing to "absent" is precisely
-// what makes it destructive rather than inert. So the guard is cosmetic for a key nothing else can
-// produce, and required for a key an alias also targets.
-export function mapInputAccessoryViewProps(view) {
-    const out = {
-        ...view.passthrough,
-        style: view.style,
-    };
-    if (view.nativeID !== undefined)
-        out.nativeID = view.nativeID;
-    if (view.backgroundColor !== undefined)
-        out.backgroundColor = view.backgroundColor;
-    return out;
-}
-export function renderInputAccessoryView(view) {
-    dlog('InputAccessoryView -> RCTInputAccessoryView');
-    // Empty structural children: the adapter appends the user children directly under the host.
-    return el('symbiote-input-accessory-view', mapInputAccessoryViewProps(view), []);
-}
+// `setProp` collapses an undefined value to an absent key, so a conditional write is normally
+// cosmetic (`.claude/rules/fabric-boolean-event-gates.md`) — it is destructive precisely when the
+// key has an ALIAS SOURCE. `id` arrives, something renames it to `nativeID`, and a
+// `nativeID: undefined` written afterwards deletes what the rename just produced. Removing the
+// guards on that reasoning cost a day on 2026-09-01.
+//
+// It cannot recur here, and that is the point: the rename is `foldIdAlias` in
+// `SymbioteFabricProps.cpp` now, one rule at the end of the payload build with nothing downstream
+// of it to overwrite the result. Anything that reintroduces a JS-side alias for this tag
+// reintroduces the trap with it.

package/build/view/render-keyboard-avoiding-view.d.ts

@@ -1,4 +1,4 @@
-import type { IKeyboardEventName, IPlatformOSType, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IKeyboardEventName, ILayoutAnimationConfig, IPlatformOSType, IStyleProp, IViewStyle } from '@symbiote-native/engine';
 export type IKeyboardAvoidingBehavior = 'height' | 'position' | 'padding';
 export declare const DEFAULT_VERTICAL_OFFSET = 0;
 export interface IMeasuredFrame {
@@ -17,6 +17,12 @@ export type IKeyboardAvoidingEventNames = {
 };
 export declare function keyboardAvoidingEventNamesFor(os: IPlatformOSType): IKeyboardAvoidingEventNames;
 export declare function readPrefersCrossFadeTransitions(query?: () => Promise<boolean>): Promise<boolean>;
+export interface IKeyboardAnimationTiming {
+    duration: number;
+    easing: string;
+}
+export declare function readKeyboardAnimationTiming(payload: unknown): IKeyboardAnimationTiming | undefined;
+export declare function configureKeyboardAvoidingAnimation(timing: IKeyboardAnimationTiming | undefined, enabled: boolean, configure?: (config: ILayoutAnimationConfig) => void): void;
 export type IComputeInsetOptions = {
     behavior?: IKeyboardAvoidingBehavior;
     previousInset?: number;

package/build/view/render-keyboard-avoiding-view.js

@@ -9,7 +9,7 @@
 // carry. Instead we return a layout DESCRIPTION (which styles to apply and whether to nest)
 // and the adapter builds its own element tree with its children. Mirrors RN's
 // Libraries/Components/Keyboard/KeyboardAvoidingView.js inset/behavior logic.
-import { AccessibilityInfo, dlog, isRecord, KEYBOARD_EVENT, Platform, } from '@symbiote-native/engine';
+import { AccessibilityInfo, dlog, isRecord, KEYBOARD_EVENT, LayoutAnimation, Platform, } from '@symbiote-native/engine';
 // RN's default keyboardVerticalOffset (KeyboardAvoidingView.js).
 export const DEFAULT_VERTICAL_OFFSET = 0;
 // RN rounds nothing here; 'height' mode collapses flex so the shrunk height holds.
@@ -60,6 +60,45 @@ export function readPrefersCrossFadeTransitions(query = () => AccessibilityInfo.
         return false;
     });
 }
+// RCTLayoutAnimation.m's minimal accepted duration — RN's own comment at the call site
+// (`KeyboardAvoidingView.js:172-173`): "We have to pass the duration equal to minimal accepted
+// duration defined here".
+const MIN_LAYOUT_ANIMATION_DURATION = 10;
+// The keyboard event's own transition curve, read off the SAME raw payload `readKeyboardFrame`
+// reads `endCoordinates` from — `duration`/`easing` sit one level up, beside it.
+export function readKeyboardAnimationTiming(payload) {
+    if (!isRecord(payload))
+        return undefined;
+    const { duration, easing } = payload;
+    if (typeof duration !== 'number' || typeof easing !== 'string')
+        return undefined;
+    return { duration, easing };
+}
+// RN's `_updateBottomIfNecessary` (`:169-179`): once the inset actually changes, arm the NEXT
+// commit to animate over the keyboard's own transition curve instead of snapping. Gated on
+// `enabled` and on the event carrying BOTH a duration and an easing name — Android's
+// DID_SHOW/DID_HIDE notifications carry neither, so this is correctly a no-op there, same as
+// vendor's `if (enabled && duration && easing)`.
+//
+// `configure` is injectable purely for testability, the same shape `readPrefersCrossFadeTransitions`
+// takes its `query`; callers pass nothing and get the real `LayoutAnimation.configureNext`.
+export function configureKeyboardAvoidingAnimation(timing, enabled, configure = config => LayoutAnimation.configureNext(config)) {
+    if (!enabled || timing === undefined)
+        return;
+    const { duration, easing } = timing;
+    if (!duration || !easing)
+        return;
+    const flooredDuration = duration > MIN_LAYOUT_ANIMATION_DURATION
+        ? duration
+        : MIN_LAYOUT_ANIMATION_DURATION;
+    configure({
+        duration: flooredDuration,
+        update: {
+            duration: flooredDuration,
+            type: LayoutAnimation.coerceType(easing),
+        },
+    });
+}
 // RN's _relativeKeyboardHeight: how far up the view must move so it no longer overlaps the
 // keyboard. keyboardY is the keyboard's top edge minus the caller's vertical offset; the inset
 // is the overlap of the view's bottom past that edge, clamped at 0.

package/build/view/render-modal.d.ts

@@ -20,4 +20,4 @@ export type IModalViewProps = {
     style?: IStyleProp<IViewStyle>;
     passthrough: Record<string, unknown>;
 };
-export declare function renderModal(view: IModalViewProps): IDescriptor;
+export declare function renderModal(view: IModalViewProps, isRTL?: boolean): IDescriptor;

package/build/view/render-modal.js

@@ -2,10 +2,10 @@
 // node: it lives in the SAME childSet and commits through the SAME completeRoot as the rest of
 // the tree. The native iOS/Android view presents its own window internally; there is no second
 // root or second surface on the JS side. So this is a thin render exactly like the others: it
-// maps to the `symbiote-modal` intrinsic the host config routes to ModalHostView, wrapping a
+// maps to the `modal` intrinsic the host config routes to ModalHostView, wrapping a
 // full-screen container View that holds the user children (injected by the adapter). Shared
 // verbatim: React and Vue both bridge this Descriptor; the keep-alive state lives in state/modal.ts.
-import { dlog, } from '@symbiote-native/engine';
+import { dlog, I18nManager, } from '@symbiote-native/engine';
 import { el } from '../descriptor.js';
 // The full-screen box RN anchors the modal content in (Modal.js styles.container: [side]:0,
 // top:0, flex:1, backgroundColor:'white'). It is NOT position:absolute, it is a flex child that
@@ -13,8 +13,11 @@ import { el } from '../descriptor.js';
 // (ModalHostViewComponentDescriptor sets the node size to screenSize). An absolute container with
 // only top/left would collapse to its content instead. The backdrop color is layered on at render
 // time so transparent/backdropColor win.
-const CONTAINER_STYLE = {
-    left: 0,
+//
+// `[side]` is NOT always 'left' — vendor computes it once at module load from
+// `I18nManager.getConstants().isRTL` (`Modal.js:372`: `isRTL ? 'right' : 'left'`), so a modal in an
+// RTL layout pins its container to the RIGHT edge. `renderModal`'s own `isRTL` parameter supplies it.
+const CONTAINER_STYLE_BASE = {
     top: 0,
     flex: 1,
 };
@@ -30,7 +33,10 @@ const DEFAULT_ANIMATION_TYPE = 'none';
 // 'overFullScreen').
 const PRESENTATION_FULL_SCREEN = 'fullScreen';
 const PRESENTATION_OVER_FULL_SCREEN = 'overFullScreen';
-export function renderModal(view) {
+// `isRTL` is injectable purely for testability, the same shape `computeInset`'s `os` option
+// takes: `I18nManager`'s constants are resolved once at module load with no setter, so a test
+// exercising the RTL branch cannot toggle the real module and must pass the value in.
+export function renderModal(view, isRTL = I18nManager.isRTL) {
     // Only override backgroundColor when transparent or backdropColor are explicitly set, so these
     // Modal-specific props take precedence over the generic style prop (Modal.js: containerStyles
     // composed LAST in [styles.container, props.style, containerStyles]).
@@ -40,7 +46,11 @@ export function renderModal(view) {
             ? { backgroundColor: view.backdropColor }
             : {};
     const containerStyle = [
-        { ...CONTAINER_STYLE, backgroundColor: OPAQUE_BACKDROP },
+        {
+            ...CONTAINER_STYLE_BASE,
+            ...(isRTL ? { right: 0 } : { left: 0 }),
+            backgroundColor: OPAQUE_BACKDROP,
+        },
         view.style,
         backdropOverride,
     ];
@@ -52,8 +62,8 @@ export function renderModal(view) {
     // collapsable:false keeps the container as a real shadow node (RN sets this so the wrapper is
     // never flattened away under the host). Empty structural children: the adapter injects the
     // user children UNDER this container, never as a direct sibling of the host.
-    const container = el('symbiote-view', { style: containerStyle, collapsable: false }, []);
-    return el('symbiote-modal', {
+    const container = el('view', { style: containerStyle, collapsable: false }, []);
+    return el('modal', {
         ...view.passthrough,
         style: MODAL_HOST_STYLE,
         transparent: view.transparent,

package/build/view/render-pressable/index.d.ts

@@ -1,11 +1,14 @@
 import type { IAccessibilityStateValue } from '../../accessibility-props';
 import type { IPressHandlers } from '../../state/pressable';
 export declare function resolveDisabledAccessibilityState(accessibilityState: IAccessibilityStateValue | undefined, disabled: boolean | undefined): IAccessibilityStateValue | undefined;
+export declare function resolvePressableFocusable(focusable: boolean | undefined): boolean;
+export declare function resolveTouchableFocusable(focusable: boolean | undefined, hasOnPress: boolean, disabled: boolean | undefined): boolean;
 export declare function shouldSuppressPress(disabled: boolean | undefined): boolean;
 export declare function shouldClaimResponder(disabled: boolean | undefined): boolean;
 export declare function isTerminationAllowed(cancelable: boolean | undefined): boolean;
 export declare function buildPressableListeners(handlers: IPressHandlers, options: {
     disabled?: boolean;
     cancelable?: boolean;
+    blockNativeResponder?: boolean;
 }): Record<string, unknown>;
 export declare function noteHoverNoop(onHoverIn: unknown, onHoverOut: unknown): void;

package/build/view/render-pressable/index.js

@@ -12,6 +12,30 @@ export function resolveDisabledAccessibilityState(accessibilityState, disabled)
         ? { ...accessibilityState, disabled }
         : accessibilityState;
 }
+// RN computes `focusable` in all five touchables and we computed it nowhere until 2026-09-09, so a
+// DISABLED control stayed focusable — a keyboard, a TV remote or switch control could land on
+// something that cannot be pressed. There are TWO formulas, split by primitive and not by platform;
+// do not collapse them.
+//
+// Pressable defaults it ON (Pressable.js:258). `!== false`, not `?? true`: only a literal `false`
+// opts out, the same shape `accessible` uses one file over.
+export function resolvePressableFocusable(focusable) {
+    return focusable !== false;
+}
+// The four Touchable* additionally require a press handler and a non-disabled state —
+// TouchableOpacity.js:336-340, TouchableHighlight.js:370-374,
+// TouchableWithoutFeedback.js:263-266, TouchableNativeFeedback.js:369-372, one expression verbatim.
+//
+// `hasOnPress` is RN's `onPress !== undefined` and NOT `hasTouchablePressHandler`, which also counts
+// onPressIn/onPressOut/onLongPress — that gate is the underlay's, and reusing it here would make a
+// press-in-only Touchable focusable where RN leaves it out of the focus order.
+//
+// A Touchable that composes our Pressable passes the result DOWN as the `focusable` prop; Pressable
+// then applies `!== false` to a value that is already boolean, which is why the two compose without
+// either side knowing about the other.
+export function resolveTouchableFocusable(focusable, hasOnPress, disabled) {
+    return (resolvePressableFocusable(focusable) && hasOnPress && disabled !== true);
+}
 // The 3 agnostic gating predicates behind the listener bag below. Angular has no bag to spread -
 // it binds these directly onto template event outputs (see adapters/angular/src/components/
 // pressable/index.ts), so they're exported and shared rather than folded back into
@@ -48,6 +72,10 @@ export function buildPressableListeners(handlers, options) {
         onPressOut: handlers.handlePressOut,
         onStartShouldSetResponder: () => shouldClaimResponder(options.disabled),
         onResponderMove: handlers.handleResponderMove,
+        // Pressability.js:479 — returned from onResponderGrant unconditionally, so native learns
+        // whether to stand down the moment the gesture is claimed. Unset resolves to false, matching
+        // the engine's own fallback for an absent listener (`events/index.ts`).
+        onResponderGrant: () => options.blockNativeResponder === true,
     };
     if (options.cancelable !== undefined) {
         listeners.onResponderTerminationRequest = () => isTerminationAllowed(options.cancelable);

package/build/view/render-scroll-view.d.ts

@@ -1,13 +1,9 @@
 import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
 import type { ISymbioteIntrinsic } from '../component-names/shared';
 export declare function readLayoutDimension(event: ISymbioteEvent, key: 'width' | 'height'): number | undefined;
-export declare function resolveDecelerationRate(rate: 'normal' | 'fast' | number): number;
-export declare const SCROLL_VIEW_BASE_HORIZONTAL: IViewStyle;
-export declare const SCROLL_VIEW_BASE_VERTICAL: IViewStyle;
 export type IScrollIntrinsics = {
     scrollViewIntrinsic: ISymbioteIntrinsic;
     contentIntrinsic: ISymbioteIntrinsic;
-    scrollViewBaseStyle: IViewStyle;
     contentStyle: IStyleProp<IViewStyle>;
 };
 export declare function selectScrollIntrinsics(isHorizontal: boolean, contentContainerStyle: IStyleProp<IViewStyle> | undefined): IScrollIntrinsics;
@@ -26,6 +22,7 @@ export interface IScrollForwarding {
     capturesViewportHeight: boolean;
     collapsableChildren: boolean;
 }
+export declare function preservesContentChildren(maintainVisibleContentPosition: unknown, snapToAlignment: unknown): boolean;
 export declare function resolveScrollForwarding(inputs: IScrollForwardingInputs): IScrollForwarding;
 export type IContentSize = {
     width: number;

package/build/view/render-scroll-view.js

@@ -5,7 +5,6 @@
 // adapter owns the lifecycle (refs/state/effects) and the element assembly; it calls these pure
 // helpers from prepareScrollView. What diverges per platform, and how a RefreshControl
 // integrates, stays in the adapter's .ios/.android files.
-import { Platform } from '@symbiote-native/engine';
 import { readLayoutField } from './layout-event.js';
 // Thin re-export kept for the existing public surface (adapters import this name from
 // `@symbiote-native/components`); the actual field read is shared with render-scroll-sticky's
@@ -13,66 +12,22 @@ import { readLayoutField } from './layout-event.js';
 export function readLayoutDimension(event, key) {
     return readLayoutField(event, key);
 }
-// 'normal'/'fast' resolve to DIFFERENT friction constants per platform: RN's
-// processDecelerationRate.js Platform.select()s them: iOS glides longer (0.998/0.99),
-// Android sooner (0.985/0.9). Hardcoding the iOS pair made Android momentum scroll
-// glide far too long on 'fast'. This is the file's one Platform read: the header's
-// "no Platform.OS" rule governs component-intrinsic selection, not a value transform
-// RN itself platform-branches. `default` mirrors iOS so any non-ios/android host stays
-// defined (select would otherwise yield undefined). Numeric rates pass through unchanged.
-export function resolveDecelerationRate(rate) {
-    if (typeof rate === 'number')
-        return rate;
-    // select() types as `number | undefined`; the always-present `default` makes the
-    // `??` fallback unreachable, but it narrows the return to a plain `number` (no cast).
-    if (rate === 'normal')
-        return (Platform.select({ ios: 0.998, android: 0.985, default: 0.998 }) ?? 0.998);
-    return Platform.select({ ios: 0.99, android: 0.9, default: 0.99 }) ?? 0.99;
-}
-// RN applies a base style to the scroll-view NODE itself, per axis (ScrollView.js
-// styles.baseHorizontal/baseVertical). Two parts carry weight:
-//   - `overflow: 'scroll'`: clips content to the scroll view's frame. On iOS Fabric the
-//     node only clips when this is set; without it a fixed-height ScrollView lets its
-//     content bleed out over siblings (Android's native ViewGroup clips regardless, which
-//     is why the bug showed only on iOS). RN sets it on BOTH axes, so we do too.
-//   - `flexDirection: 'row'` (horizontal only): makes the single content child a MAIN-axis
-//     item, so Yoga sizes it to its content width and the view overflows and scrolls.
-//     Without it the content is a CROSS-axis item, stretched to the viewport, nothing to
-//     scroll. Vertical keeps the default `column`.
-// Both axes match RN's baseHorizontal/baseVertical exactly. Composed UNDER the user style,
-// so an explicit value still wins.
-export const SCROLL_VIEW_BASE_HORIZONTAL = {
-    flexGrow: 1,
-    flexShrink: 1,
-    flexDirection: 'row',
-    overflow: 'scroll',
-};
-export const SCROLL_VIEW_BASE_VERTICAL = {
-    flexGrow: 1,
-    flexShrink: 1,
-    flexDirection: 'column',
-    overflow: 'scroll',
-};
 export function selectScrollIntrinsics(isHorizontal, contentContainerStyle) {
     // Horizontal scroll resolves to a different native component on Android (its own
     // ViewManager, not RCTScrollView+flag); on iOS both intrinsics map back to RCTScrollView.
     // The name table does the per-platform mapping; here we only pick the intrinsic.
     const scrollViewIntrinsic = isHorizontal
-        ? 'symbiote-horizontal-scroll-view'
-        : 'symbiote-scroll-view';
+        ? 'horizontal-scroll-view'
+        : 'scroll-view';
     const contentIntrinsic = isHorizontal
-        ? 'symbiote-horizontal-scroll-content'
-        : 'symbiote-scroll-content';
-    const scrollViewBaseStyle = isHorizontal
-        ? SCROLL_VIEW_BASE_HORIZONTAL
-        : SCROLL_VIEW_BASE_VERTICAL;
+        ? 'horizontal-scroll-content'
+        : 'scroll-content';
     const contentStyle = isHorizontal
         ? [contentContainerStyle, { flexDirection: 'row' }]
         : contentContainerStyle;
     return {
         scrollViewIntrinsic,
         contentIntrinsic,
-        scrollViewBaseStyle,
         contentStyle,
     };
 }
@@ -82,12 +37,20 @@ export function selectScrollIntrinsics(isHorizontal, contentContainerStyle) {
 // throttle passes through untouched. These two magic numbers were copied into all three adapters.
 const STICKY_NATIVE_SCROLL_THROTTLE = 1;
 const STICKY_JS_SCROLL_THROTTLE = 16;
+// maintainVisibleContentPosition (and Android snapToAlignment) anchor against MOUNTED cell views;
+// Android Fabric view-flattens layout-only cells away, so RN keeps them as real views with
+// collapsableChildren={false} on the content container (ScrollView.js:1731 `preserveChildren`).
+// No-op on iOS.
+//
+// Named and exported rather than inlined because the host behavior's slot fold needs the same
+// answer from a different place — it has the owner's raw props and none of the sticky inputs
+// `resolveScrollForwarding` also takes. One exported function is what keeps the two from drifting.
+export function preservesContentChildren(maintainVisibleContentPosition, snapToAlignment) {
+    return (maintainVisibleContentPosition !== undefined ||
+        snapToAlignment !== undefined);
+}
 export function resolveScrollForwarding(inputs) {
-    // maintainVisibleContentPosition (and Android snapToAlignment) anchor against MOUNTED cell views;
-    // Android Fabric view-flattens layout-only cells away, so RN keeps them as real views with
-    // collapsableChildren={false} on the content container (ScrollView.js preserveChildren). No-op on iOS.
-    const collapsableChildren = inputs.maintainVisibleContentPosition !== undefined ||
-        inputs.snapToAlignment !== undefined;
+    const collapsableChildren = preservesContentChildren(inputs.maintainVisibleContentPosition, inputs.snapToAlignment);
     if (!inputs.hasStickyHeaders) {
         return {
             mode: 'plain',

package/build/view/render-switch.d.ts

@@ -1,29 +1,18 @@
 import type { IStyleProp, IViewStyle, ISymbioteEvent } from '@symbiote-native/engine';
-import type { IDescriptor } from '../descriptor';
 import type { IAccessibilityProps, IAriaProps } from '../accessibility-props';
 export type ISwitchTrackColor = {
     false?: string;
     true?: string;
 };
+export type ISwitchChangeEvent = ISymbioteEvent & {
+    value: boolean;
+};
 export interface ISwitchProps extends IAccessibilityProps, IAriaProps {
     value?: boolean;
-    onValueChange?: (value: boolean, event: ISymbioteEvent) => void;
+    onValueChange?: (event: ISwitchChangeEvent) => void;
     disabled?: boolean;
     trackColor?: ISwitchTrackColor;
     thumbColor?: string;
     ios_backgroundColor?: string;
     style?: IStyleProp<IViewStyle>;
 }
-export type ISwitchPlatform = {
-    trackColorProps: (value: boolean, trackColor?: ISwitchTrackColor) => Record<string, unknown>;
-};
-export type ISwitchViewProps = {
-    value: boolean;
-    disabled?: boolean;
-    trackColor?: ISwitchTrackColor;
-    thumbColor?: string;
-    ios_backgroundColor?: string;
-    style?: IStyleProp<IViewStyle>;
-    passthrough: Record<string, unknown>;
-};
-export declare function renderSwitch(view: ISwitchViewProps, platform: ISwitchPlatform): IDescriptor;

package/build/view/render-switch.js

@@ -1,42 +1,4 @@
-// Switch: the render half (framework-agnostic). Maps the resolved props onto the single
-// `symbiote-switch` host node: the strict value fold lands as the `value` Fabric prop, the
-// track colors take platform-specific prop NAMES (iOS onTintColor/tintColor vs Android
-// trackColorFor*/trackTintColor, supplied via `platform`), thumbColor → thumbTintColor, and
-// ios_backgroundColor folds into the style as the pill that shows through the shrunken track.
-// Pure and prop-driven; no hooks, no events. The adapter owns those.
-import { dlog } from '@symbiote-native/engine';
-import { el } from '../descriptor.js';
-// RN rounds the iOS background pill to this radius when ios_backgroundColor is set.
-const IOS_BACKGROUND_BORDER_RADIUS = 16;
-// The `-managed` spelling, NOT the plain one the engine's Switch behavior registers under
-// (`core/components/src/behaviors/switch.ts`) — the wrapper still runs its own lifecycle
-// (lastNativeReport, the snap-back effect), so it may not share a tag the behavior registry would
-// also attach to; see that behavior's module header and `.claude/rules/host-primitive-tier.md`,
-// "A lowered element and its wrapper must not share an intrinsic tag" (the TextInput precedent).
-const SWITCH_MANAGED_INTRINSIC = 'symbiote-switch-managed';
-// Fold ios_backgroundColor into the style, matching RN's iOS branch: it paints the
-// background that shows through the shrunken track. Untouched when unset, so a caller's own
-// backgroundColor wins by simply not passing ios_backgroundColor.
-function foldIosBackground(style, color) {
-    if (color === undefined)
-        return style;
-    return [
-        style,
-        { backgroundColor: color, borderRadius: IOS_BACKGROUND_BORDER_RADIUS },
-    ];
-}
-export function renderSwitch(view, platform) {
-    dlog(`Switch render value=${view.value} disabled=${String(view.disabled)}`);
-    // These color props reach Fabric as ordinary props: the shared ViewConfig declares
-    // Switch's only event as `change`, so routeProp sends the on*-prefixed color names through
-    // setProp rather than mistaking them for listeners.
-    const props = {
-        ...view.passthrough,
-        value: view.value,
-        disabled: view.disabled,
-        ...platform.trackColorProps(view.value, view.trackColor),
-        thumbTintColor: view.thumbColor,
-        style: foldIosBackground(view.style, view.ios_backgroundColor),
-    };
-    return el(SWITCH_MANAGED_INTRINSIC, props);
-}
+// Switch: the framework-agnostic prop surface. The painting moved to the `switch` tag's own
+// behavior (`behaviors/switch.ts`) when the wrapper path was retired; what stays here is the
+// public prop type every adapter re-exports and the event shape it fires with.
+export {};

package/build/view/render-touchable-highlight.d.ts

@@ -8,5 +8,6 @@ export interface ITouchableHighlightUnderlayView {
     hasPressHandler: boolean;
     underlayColor?: string;
     activeOpacity?: number;
+    testOnly_pressed?: boolean;
 }
 export declare function resolveHighlightExtraStyles(view: ITouchableHighlightUnderlayView): ITouchableHighlightExtraStyles | undefined;

package/build/view/render-touchable-native-feedback.d.ts

@@ -14,4 +14,22 @@ export declare function canUseNativeForeground(): boolean;
 export declare function selectableBackground(rippleRadius?: number): IThemeAttrBackground;
 export declare function selectableBackgroundBorderless(rippleRadius?: number): IThemeAttrBackground;
 export declare function rippleBackground(color: string, borderless: boolean, rippleRadius?: number): IRippleBackground;
-export declare function backgroundProps(background: INativeFeedbackBackground, useForeground: boolean): Record<string, INativeFeedbackBackground>;
+/**
+ * RN's four statics, under RN's own spelling — `TouchableNativeFeedback.Ripple(color, borderless)`.
+ *
+ * A NAMESPACE OBJECT rather than a component value, and that is the whole of what survived the
+ * wrapper: the element is a tag now, and a tag is a string, which cannot carry properties. Shared
+ * rather than copied five times because every member is a pure dict producer with no framework in
+ * it; each adapter re-exports it verbatim, as it does the background types beside it.
+ *
+ * NOT the spelling for NEW code, and not redundant either. RN's docs point at `Pressable`'s
+ * declarative `android_ripple={{ color, borderless }}`, which the pressable behavior resolves
+ * (`behaviors/pressable.ts`, `asRippleConfig`). These four stay because the
+ * `touchable-native-feedback` tag folds `background` and nothing else produces that value.
+ */
+export declare const TouchableNativeFeedback: {
+    SelectableBackground: typeof selectableBackground;
+    SelectableBackgroundBorderless: typeof selectableBackgroundBorderless;
+    Ripple: typeof rippleBackground;
+    canUseNativeForeground: typeof canUseNativeForeground;
+};

package/build/view/render-touchable-native-feedback.js

@@ -32,12 +32,37 @@ export function selectableBackgroundBorderless(rippleRadius) {
 export function rippleBackground(color, borderless, rippleRadius) {
     return { type: 'RippleAndroid', color, borderless, rippleRadius };
 }
-// Maps the resolved background + useForeground onto the native prop Android reads. useForeground
-// only paints the foreground when the platform supports it (canUseNativeForeground); otherwise it
-// falls back to the background slot, matching RN. On iOS both props are inert.
-export function backgroundProps(background, useForeground) {
-    if (useForeground && canUseNativeForeground()) {
-        return { nativeForegroundAndroid: background };
-    }
-    return { nativeBackgroundAndroid: background };
-}
+// `backgroundProps` WAS HERE AND IS GONE (2026-09-18). It mapped the resolved background plus
+// `useForeground` onto the native slot Android reads, and that is the `#ifdef ANDROID` tail of
+// `foldCloneOntoChild` in `SymbioteFabricProps.cpp` — api-level gate included, since
+// `Platform.Version` on Android IS the api level and `androidApiLevel()` reads the same number.
+//
+// A JS COPY OF A RULE THAT RUNS IN C++, with no runtime caller and no test, reachable only through
+// the package barrel. Found by asking what each `Platform.OS` branch still left in
+// `core/components` is FOR. Its C++ twin is covered on both arms —
+// `android-rules.android.itest.ts` asserts the foreground slot and `clone-onto-child-payload.itest.ts`
+// asserts its absence off Android — and break-testing the gate fires exactly one of them.
+//
+// `canUseNativeForeground` below stays, and the distinction is the reusable half: it is a QUESTION
+// an app asks the platform (`TouchableNativeFeedback.canUseNativeForeground()` is RN's own public
+// static), not a rule that decides a payload. Same class as the slider reading a folded
+// `accessibilityState` — asking is not reimplementing.
+/**
+ * RN's four statics, under RN's own spelling — `TouchableNativeFeedback.Ripple(color, borderless)`.
+ *
+ * A NAMESPACE OBJECT rather than a component value, and that is the whole of what survived the
+ * wrapper: the element is a tag now, and a tag is a string, which cannot carry properties. Shared
+ * rather than copied five times because every member is a pure dict producer with no framework in
+ * it; each adapter re-exports it verbatim, as it does the background types beside it.
+ *
+ * NOT the spelling for NEW code, and not redundant either. RN's docs point at `Pressable`'s
+ * declarative `android_ripple={{ color, borderless }}`, which the pressable behavior resolves
+ * (`behaviors/pressable.ts`, `asRippleConfig`). These four stay because the
+ * `touchable-native-feedback` tag folds `background` and nothing else produces that value.
+ */
+export const TouchableNativeFeedback = {
+    SelectableBackground: selectableBackground,
+    SelectableBackgroundBorderless: selectableBackgroundBorderless,
+    Ripple: rippleBackground,
+    canUseNativeForeground,
+};