@symbiote-native/components 2.0.0 → 3.0.0

package/build/state/flat-list.d.ts

@@ -1,11 +1,11 @@
-import type { IViewableItemsChangedInfo, IViewToken } from './virtualized-list';
+import { type IViewableItemsChangedInfo, type IViewToken } from './virtualized-list';
 export declare const SINGLE_COLUMN = 1;
 export interface IRow<ItemT> {
     items: ItemT[];
     startIndex: number;
 }
 export declare function chunkIntoRows<ItemT>(data: readonly ItemT[], columns: number): IRow<ItemT>[];
-export declare function rowKeyExtractor<ItemT>(row: IRow<ItemT>): string;
+export declare function rowKeyExtractor<ItemT>(row: IRow<ItemT>, keyExtractor?: (item: ItemT, index: number) => string): string;
 export declare function expandRowToken<ItemT>(token: IViewToken<IRow<ItemT>>, keyExtractor?: (item: ItemT, index: number) => string): IViewToken<ItemT>[];
 export declare function expandRowViewability<ItemT>(info: IViewableItemsChangedInfo<IRow<ItemT>>, keyExtractor?: (item: ItemT, index: number) => string): IViewableItemsChangedInfo<ItemT>;
 export declare function lastItemOfRow<ItemT>(row: IRow<ItemT> | undefined): ItemT | undefined;

package/build/state/flat-list.js

@@ -4,6 +4,7 @@
 // back to per-item tokens, and the row separator unwraps to the flanking items. All of
 // this is pure transform — every adapter (React, Vue) reuses it; the adapter supplies
 // only the element creation (createElement / h) for a row and the ref wiring.
+import { defaultKeyExtractor, } from './virtualized-list.js';
 export const SINGLE_COLUMN = 1;
 export function chunkIntoRows(data, columns) {
     const rows = [];
@@ -12,8 +13,15 @@ export function chunkIntoRows(data, columns) {
     }
     return rows;
 }
-export function rowKeyExtractor(row) {
-    return `row-${row.startIndex}`;
+// RN's own multi-column row key (`FlatList.js`'s `_keyExtractor`): each item's own key, joined
+// with `:`, never a synthetic position string — an app's `keyExtractor` (or the object's own
+// `key`/`id`) is what keeps a row's identity stable across inserts/removes, and a `row-${index}`
+// key defeats that as surely as no key at all.
+export function rowKeyExtractor(row, keyExtractor) {
+    const resolve = keyExtractor ?? defaultKeyExtractor;
+    return row.items
+        .map((item, column) => resolve(item, row.startIndex + column))
+        .join(':');
 }
 // Expand a row's viewable token to one token per item in that row, all sharing the row's
 // isViewable flag, so the caller sees item-level visibility rather than row-level.

package/build/state/pressable.d.ts

@@ -1,5 +1,6 @@
 import { type ISymbioteEvent } from '@symbiote-native/engine';
 export declare const DEFAULT_DELAY_LONG_PRESS_MS = 500;
+export declare const LONG_PRESS_DEACTIVATION_DISTANCE = 10;
 export declare const DEFAULT_MIN_PRESS_DURATION_MS = 130;
 export declare const DEFAULT_PRESS_RECT_OFFSETS: {
     top: number;
@@ -52,7 +53,6 @@ export declare function readPoint(event: ISymbioteEvent): {
     y: number;
 } | undefined;
 export declare function computeRegion(width: number, height: number, pageX: number, pageY: number): IResponderRegion | undefined;
-export declare function rippleProps(config: IPressableAndroidRippleConfig): Record<string, IRippleBackground> | undefined;
 export interface IPressRuntime {
     longPressCancel: (() => void) | undefined;
     longPressFired: boolean;
@@ -62,6 +62,10 @@ export interface IPressRuntime {
         x: number;
         y: number;
     } | undefined;
+    activatePosition: {
+        x: number;
+        y: number;
+    } | undefined;
     driftedOut: boolean;
     region: IResponderRegion | undefined;
     active: boolean;
@@ -89,6 +93,7 @@ export interface IPressMachineConfig {
     minPressDuration?: number;
     hitSlop?: IRectOffset;
     pressRetentionOffset?: IRectOffset;
+    android_disableSound?: boolean;
 }
 export interface IPressHandlers {
     handlePressIn: IPressHandler;

package/build/state/pressable.js

@@ -9,8 +9,15 @@
 // re-render, so each framework owns its reactive primitive) and the raw frame-measure (the host
 // node plus its measure call). The rest (the timers, the geometry, the suppression flags,
 // the decision of when each callback fires) is here, shared by every adapter.
-import { dlog, Platform } from '@symbiote-native/engine';
+import { dlog, Platform, SoundManager, } from '@symbiote-native/engine';
 export const DEFAULT_DELAY_LONG_PRESS_MS = 500;
+// Pressability.js's DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE. A SEPARATE, smaller radius than
+// `pressRetentionOffset`/`hitSlop`: any move past it cancels a pending long press even while the
+// finger is still well inside the retention rect — real presses jitter a few px, long-press must
+// not fire mid-scroll. Vendor exposes it only as a rare static override
+// (`Pressability.setLongPressDeactivationDistance`, used by e.g. gesture libraries), never as a
+// per-component prop, so it stays a plain constant here rather than a config field.
+export const LONG_PRESS_DEACTIVATION_DISTANCE = 10;
 // Pressability's default active-visual floor for a plain Pressable. Touchable* overrides this to 0.
 export const DEFAULT_MIN_PRESS_DURATION_MS = 130;
 // RN's default extra slop kept around a press once it is active, before a drift fires pressOut.
@@ -72,22 +79,6 @@ export function computeRegion(width, height, pageX, pageY) {
         bottom: pageY + height,
     };
 }
-// Build the Android native-feedback prop the inner View carries from the ripple config. RN runs
-// the color through processColor → a native int; we have no native bridge in JS, so we keep the
-// string and let Android resolve it (a null color is the documented "no tint"). Inert on iOS.
-export function rippleProps(config) {
-    if (Platform.OS !== 'android')
-        return undefined;
-    const background = {
-        type: 'RippleAndroid',
-        color: config.color ?? null,
-        borderless: config.borderless === true,
-        rippleRadius: config.radius,
-    };
-    return config.foreground === true
-        ? { nativeForegroundAndroid: background }
-        : { nativeBackgroundAndroid: background };
-}
 export function createPressRuntime() {
     return {
         longPressCancel: undefined,
@@ -95,6 +86,7 @@ export function createPressRuntime() {
         pressDelayCancel: undefined,
         pressOutCancel: undefined,
         pressOrigin: undefined,
+        activatePosition: undefined,
         driftedOut: false,
         region: undefined,
         active: false,
@@ -154,7 +146,7 @@ function measureRegion(runtime, measureFn) {
 // (the React adapter's useMemo body) lives here, shared by every adapter. The adapter rebuilds
 // these per render (the closures capture the live config) while the runtime persists across them.
 export function createPressHandlers(config, runtime, host) {
-    const { onPress, onPressIn, onPressOut, onPressMove, onLongPress, delayLongPress, unstable_pressDelay, minPressDuration = DEFAULT_MIN_PRESS_DURATION_MS, } = config;
+    const { onPress, onPressIn, onPressOut, onPressMove, onLongPress, delayLongPress, unstable_pressDelay, minPressDuration = DEFAULT_MIN_PRESS_DURATION_MS, android_disableSound, } = config;
     // Per-edge offsets for the measured-rect retention test (RN's hitSlop + pressRectOffset).
     // pressRetentionOffset defaults to RN's DEFAULT_PRESS_RECT_OFFSETS when unset; hitSlop to zero.
     const hitSlopRect = normalizeRect(config.hitSlop);
@@ -165,6 +157,18 @@ export function createPressHandlers(config, runtime, host) {
     const fallbackThreshold = maxEdge(hitSlopRect) + maxEdge(pressRectOffset);
     // True iff the touch still belongs to the active press: against the measured rect when we have
     // one (the RN-faithful path), else the symmetric radius fallback.
+    //
+    // TODO(rn-parity): `Pressability.js`'s `onResponderMove` (:489-493) returns right after the
+    // app's `onPressMove`, before any drift/long-press-jitter check, whenever the region is not yet
+    // measured — vendor treats "no measurement yet" as "do nothing until one arrives." The radius
+    // fallback below diverges: it judges drift/jitter on synthetic geometry instead of waiting.
+    // Confirmed unreachable on a real device (`Tree::measure` in `SymbioteTree.cpp` is a synchronous
+    // JSI call, so the region is always populated before `handleResponderMove` can fire), so the
+    // fallback only ever fires in this codebase's own test harness, which wires
+    // `getMeasureFn: () => undefined` everywhere (`state/pressable.test.ts:84` and every touchable
+    // test built on it). A real fix needs a synchronous mock-measure harness under 11+ existing
+    // drift/retention/long-press call sites across `pressable.test.ts`, `touchable-opacity.test.ts`
+    // and `render-pressable.test.ts`, not a one-line guard — see the audit skill for the finding.
     function isWithinRetention(point) {
         const region = runtime.region;
         if (region !== undefined) {
@@ -184,6 +188,24 @@ export function createPressHandlers(config, runtime, host) {
     function clearPressOut() {
         cancelRuntimeTimer(runtime, 'pressOutCancel');
     }
+    // Pressability.js arms this ONCE, at RESPONDER_GRANT, and a drift out/back-in never re-arms it
+    // (`onResponderMove` only ever CANCELS via `_cancelLongPressDelayTimeout`, permanently, for the
+    // rest of the gesture). Splitting it out of `activate()` is what makes that possible: `activate`
+    // itself runs again on every drift-back-in, and used to re-arm a fresh full-duration timer each
+    // time, which is wrong on two counts — it can resurrect a long press the finger already
+    // disqualified, and if it never left, it's simply the same timer restarted for no reason.
+    function armLongPress(event) {
+        if (!onLongPress)
+            return;
+        runtime.longPressCancel = host.schedule(() => {
+            runtime.longPressCancel = undefined;
+            if (runtime.disposed || !runtime.active || runtime.driftedOut)
+                return;
+            runtime.longPressFired = true;
+            dlog('Pressable longPress timer fired');
+            onLongPress(event);
+        }, delayLongPress + unstable_pressDelay);
+    }
     function activate(event) {
         if (runtime.disposed || runtime.active || runtime.driftedOut)
             return;
@@ -191,18 +213,11 @@ export function createPressHandlers(config, runtime, host) {
         clearPressOut();
         runtime.active = true;
         runtime.activatedAt = host.now();
+        // Pressability.js's `_activate`: the jitter check below reads from here, re-set on every
+        // (re)activation — including a drift-back-in re-arm, matching vendor exactly.
+        runtime.activatePosition = readPoint(event);
         dlog('Pressable pressIn');
         host.setPressed(true);
-        if (!runtime.longPressFired && onLongPress) {
-            runtime.longPressCancel = host.schedule(() => {
-                runtime.longPressCancel = undefined;
-                if (runtime.disposed || !runtime.active || runtime.driftedOut)
-                    return;
-                runtime.longPressFired = true;
-                dlog('Pressable longPress timer fired');
-                onLongPress(event);
-            }, delayLongPress);
-        }
         onPressIn?.(event);
     }
     function deactivate(event) {
@@ -262,6 +277,11 @@ export function createPressHandlers(config, runtime, host) {
             runtime.pressOrigin = readPoint(event);
             runtime.driftedOut = false;
             measureRegion(runtime, host.getMeasureFn());
+            // Armed at GRANT, unconditionally — before the `unstable_pressDelay` branch below, which only
+            // defers the PRESSED VISUAL. `delayLongPress` already has `unstable_pressDelay` baked out of
+            // its default (`configFor`), so adding it back here is what keeps the long-press threshold at
+            // a constant time-from-touch-down regardless of how long the visual is deferred.
+            armLongPress(event);
             if (unstable_pressDelay > 0) {
                 dlog(`Pressable pressIn deferred ${unstable_pressDelay}ms`);
                 runtime.pressDelayCancel = host.schedule(() => {
@@ -303,6 +323,12 @@ export function createPressHandlers(config, runtime, host) {
                 dlog('Pressable press suppressed by prior longPress');
                 return;
             }
+            // Pressability.js:754-756 — Android only, and only when onPress is actually about to fire.
+            if (onPress !== undefined &&
+                Platform.OS === 'android' &&
+                android_disableSound !== true) {
+                SoundManager.playTouchSound();
+            }
             onPress?.(event);
         },
         handleResponderMove(event) {
@@ -312,6 +338,15 @@ export function createPressHandlers(config, runtime, host) {
             const here = readPoint(event);
             if (!here)
                 return;
+            // Pressability.js:502-508 — checked BEFORE the retention-region branch below, and
+            // independent of it: a long press must not fire on a jitter, even one well inside the
+            // broader retention rect that keeps the press itself alive.
+            const activatePosition = runtime.activatePosition;
+            if (activatePosition !== undefined) {
+                const distance = Math.hypot(activatePosition.x - here.x, activatePosition.y - here.y);
+                if (distance > LONG_PRESS_DEACTIVATION_DISTANCE)
+                    clearLongPress();
+            }
             if (!isWithinRetention(here)) {
                 if (!runtime.driftedOut) {
                     dlog('Pressable drifted past retention region — deactivating');

package/build/state/section-list.d.ts

@@ -2,6 +2,8 @@ import type { IScrollRoutingHandle } from './scroll-routing-handle';
 export interface ISection<ItemT> {
     title: string;
     data: readonly ItemT[];
+    key?: string;
+    keyExtractor?(item: ItemT, index: number): string;
 }
 export type ISectionEntry<ItemT> = {
     kind: 'header';

package/build/state/section-list.js

@@ -4,6 +4,7 @@
 // stream, so headers, items, and footers are windowed by the same machinery. All of this
 // is pure transform - every adapter reuses it; the adapter supplies only the per-entry
 // element creation (renderSectionHeader / renderItem / etc.) and the ref wiring.
+import { defaultKeyExtractor } from './virtualized-list.js';
 // Flatten sections into entries AND record where each section header lands in the flat
 // stream, so scrollToLocation can map (sectionIndex, itemIndex) -> flat index without
 // re-deriving the layout. withSeparators inserts a section separator between adjacent
@@ -30,16 +31,22 @@ export function flattenSections(sections, withSeparators) {
 export function unwrapEntryItem(entry) {
     return entry !== undefined && entry.kind === 'item' ? entry.item : undefined;
 }
+// RN's own section-relative key (`VirtualizedSectionList.js`'s `_subExtractor`): the section's
+// own `key` when given, else its position — never the flat entry index, which is `entry`'s own
+// but is not the SECTION's identity.
+function sectionKeyPart(section, sectionIndex) {
+    return section.key ?? String(sectionIndex);
+}
 export function sectionEntryKey(entry, index, keyExtractor) {
-    if (entry.kind === 'header')
-        return `section-${entry.sectionIndex}`;
-    if (entry.kind === 'footer')
-        return `section-${entry.sectionIndex}:footer`;
     if (entry.kind === 'section-separator')
         return `section-${entry.sectionIndex}:separator`;
-    if (keyExtractor)
-        return keyExtractor(entry.item, entry.itemIndex);
-    return `entry-${index}`;
+    const sectionKey = sectionKeyPart(entry.section, entry.sectionIndex);
+    if (entry.kind === 'header')
+        return `${sectionKey}:header`;
+    if (entry.kind === 'footer')
+        return `${sectionKey}:footer`;
+    const resolve = entry.section.keyExtractor ?? keyExtractor ?? defaultKeyExtractor;
+    return `${sectionKey}:${resolve(entry.item, entry.itemIndex)}`;
 }
 // RN's itemIndex is offset by 1 so itemIndex 0 targets the header and itemIndex >= 1
 // targets that section's items. Returns undefined when the section is out of range.

package/build/state/text-input.d.ts

@@ -1,5 +1,6 @@
-import type { IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, ISymbioteNode, IPlatformOSType, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
+import type { IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, ISymbioteNode, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
 import type { IAccessibilityProps, IAriaProps } from '../accessibility-props';
+import type { IRectOffset } from './pressable';
 export type IInputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
 export type IEnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
 export type ISubmitBehavior = 'submit' | 'blurAndSubmit' | 'newline';
@@ -10,49 +11,10 @@ export type ITextInputSelection = {
 export type ITextInputEventHandler = (event: ISymbioteEvent) => void;
 export declare const INITIAL_EVENT_COUNT = 0;
 export declare const SELECTION_NONE = -1;
-export declare function keyboardTypeForInputMode(inputMode: string, os: IPlatformOSType): string | undefined;
-export declare function mapAutoComplete(map: Record<string, string>, token: string): string | undefined;
-export declare function foldAutoComplete(token: string | undefined): {
-    autoComplete: string | undefined;
-    textContentType: string | undefined;
-};
-export declare function foldSubmitBehavior(submitBehavior: string | undefined, blurOnSubmit: boolean | undefined, multiline: boolean): string;
 export declare function foldText(value: string | undefined, defaultValue: string | undefined): string | undefined;
 export declare function textFromChange(event: ISymbioteEvent): string | undefined;
 export declare function eventCountFromChange(event: ISymbioteEvent): number | undefined;
 export declare function shouldCommandText(lastNativeText: string | undefined, value: string | undefined): value is string;
-export type ITextInputFoldInput = {
-    inputMode?: string;
-    keyboardType?: string;
-    enterKeyHint?: string;
-    returnKeyType?: string;
-    readOnly?: boolean;
-    editable?: boolean;
-    submitBehavior?: string;
-    blurOnSubmit?: boolean;
-    multiline: boolean;
-    cursorColor?: string;
-    selectionColor?: string;
-    selectionHandleColor?: string;
-    autoComplete?: string;
-    textContentType?: string;
-    showSoftInputOnFocus?: boolean;
-    underlineColorAndroid?: string;
-};
-export type IFoldedTextInputProps = {
-    keyboardType: string | undefined;
-    returnKeyType: string | undefined;
-    editable: boolean | undefined;
-    submitBehavior: string;
-    selectionColor: string | undefined;
-    cursorColor: string | undefined;
-    selectionHandleColor: string | undefined;
-    underlineColorAndroid: string;
-    autoComplete: string | undefined;
-    textContentType: string | undefined;
-    showSoftInputOnFocus: boolean | undefined;
-};
-export declare function resolveTextInputProps(input: ITextInputFoldInput): IFoldedTextInputProps;
 export type ITextInputChangeEvent = ISymbioteEvent & {
     text: string;
 };
@@ -89,7 +51,12 @@ export type ITextInputProps = IAccessibilityProps & IAriaProps & {
     underlineColorAndroid?: string;
     inputAccessoryViewID?: string;
     style?: ITextStyle;
+    hitSlop?: IRectOffset;
+    onPress?: ITextInputEventHandler;
+    onPressIn?: ITextInputEventHandler;
+    onPressOut?: ITextInputEventHandler;
     onValueChange?: (event: ITextInputChangeEvent) => void;
+    onChangeText?: (event: ITextInputChangeEvent) => void;
     onFocus?: ITextInputEventHandler;
     onBlur?: ITextInputEventHandler;
     onEndEditing?: ITextInputEventHandler;

package/build/state/text-input.js

@@ -11,7 +11,6 @@
 // latest count, while `lastNativeText` is bookkeeping the controlled-write effect mutates
 // without a render. So the logic layer is the pure folds/maps + the controlled-write predicate;
 // each adapter holds the two pieces in ITS own primitives (React useState/useRef, Vue ref/let).
-import { Platform } from '@symbiote-native/engine';
 // The acknowledged count starts at 0, native has reported nothing yet, so the first
 // controlled write echoes 0 and lands on eventLag 0.
 export const INITIAL_EVENT_COUNT = 0;
@@ -19,156 +18,20 @@ export const INITIAL_EVENT_COUNT = 0;
 // leave the caret where it is rather than move it (used on a controlled write with no
 // explicit selection).
 export const SELECTION_NONE = -1;
-// The W3C/alias → native lookup tables. Typed Record<string, string> (not Record<IInputMode,
-// string>) so the one safe-lookup helper (mapAutoComplete) serves every map without a cast;
-// the union types above still guard the app-facing prop contract.
-// RN's inputMode -> keyboardType map (TextInput.js:815). `search` is platform-split (iOS
-// 'web-search', else 'default'); we use the Android/default branch since the folded prop is
-// forwarded verbatim and the safe default avoids an unknown keyboardType on Android.
-const inputModeToKeyboardType = {
-    decimal: 'decimal-pad',
-    email: 'email-address',
-    none: 'default',
-    numeric: 'number-pad',
-    tel: 'phone-pad',
-    text: 'default',
-    url: 'url',
-};
-// `search` is the ONE inputMode token RN resolves per platform (TextInput.js:815-825):
-//   search: Platform.OS === 'ios' ? 'web-search' : 'default'
-// iOS has a dedicated search keyboard whose return key is a magnifier; every other host falls back
-// to the default one. It is deliberately absent from the map above, so there is one source for it
-// rather than a map entry and an override that can drift apart.
+// THE FOUR W3C->NATIVE LOOKUP TABLES AND THE FOLDS OVER THEM STOOD HERE, and they are the engine's
+// now: `foldTextInputAliases` in `SymbioteFabricProps.cpp`, with
+// `core/engine/cpp/tests/js/text-input-payload.itest.ts` as their contract.
 //
-// The host is an ARGUMENT rather than a `Platform.OS` read inside the body, because the headless
-// Platform module always resolves to iOS (platform/index.ts re-exports index.ios) — a direct read
-// would leave the android branch permanently unprovable. resolveTextInputProps supplies the real
-// value. This costs the callers nothing: the exported fold signature is unchanged.
-export function keyboardTypeForInputMode(inputMode, os) {
-    if (inputMode === 'search')
-        return os === 'ios' ? 'web-search' : 'default';
-    return mapAutoComplete(inputModeToKeyboardType, inputMode);
-}
-// RN's enterKeyHint -> returnKeyType map (TextInput.js:805). Note `enter` -> 'default'.
-const enterKeyHintToReturnKeyType = {
-    done: 'done',
-    enter: 'default',
-    go: 'go',
-    next: 'next',
-    previous: 'previous',
-    search: 'search',
-    send: 'send',
-};
-// RN's W3C autocomplete -> Android `autoComplete` map (TextInput.js:828). A token with no
-// native equivalent passes through unchanged (RN's `?? autoComplete`).
-const autoCompleteWebToAndroid = {
-    'additional-name': 'name-middle',
-    'address-line1': 'postal-address-region',
-    'address-line2': 'postal-address-locality',
-    bday: 'birthdate-full',
-    'bday-day': 'birthdate-day',
-    'bday-month': 'birthdate-month',
-    'bday-year': 'birthdate-year',
-    'cc-csc': 'cc-csc',
-    'cc-exp': 'cc-exp',
-    'cc-exp-month': 'cc-exp-month',
-    'cc-exp-year': 'cc-exp-year',
-    'cc-number': 'cc-number',
-    country: 'postal-address-country',
-    'current-password': 'password',
-    email: 'email',
-    'family-name': 'name-family',
-    'given-name': 'name-given',
-    'honorific-prefix': 'name-prefix',
-    'honorific-suffix': 'name-suffix',
-    name: 'name',
-    'new-password': 'password-new',
-    off: 'off',
-    'one-time-code': 'sms-otp',
-    'postal-code': 'postal-code',
-    sex: 'gender',
-    'street-address': 'street-address',
-    tel: 'tel',
-    'tel-country-code': 'tel-country-code',
-    'tel-national': 'tel-national',
-    username: 'username',
-};
-// RN's W3C autocomplete -> iOS `textContentType` map (TextInput.js:862). A token absent here
-// leaves textContentType undefined on iOS (RN's `autoComplete in map` guard).
-const autoCompleteWebToTextContentType = {
-    'additional-name': 'middleName',
-    'address-line1': 'streetAddressLine1',
-    'address-line2': 'streetAddressLine2',
-    bday: 'birthdate',
-    'bday-day': 'birthdateDay',
-    'bday-month': 'birthdateMonth',
-    'bday-year': 'birthdateYear',
-    'cc-additional-name': 'creditCardMiddleName',
-    'cc-csc': 'creditCardSecurityCode',
-    'cc-exp': 'creditCardExpiration',
-    'cc-exp-month': 'creditCardExpirationMonth',
-    'cc-exp-year': 'creditCardExpirationYear',
-    'cc-family-name': 'creditCardFamilyName',
-    'cc-given-name': 'creditCardGivenName',
-    'cc-name': 'creditCardName',
-    'cc-number': 'creditCardNumber',
-    'cc-type': 'creditCardType',
-    country: 'countryName',
-    'current-password': 'password',
-    email: 'emailAddress',
-    'family-name': 'familyName',
-    'given-name': 'givenName',
-    'honorific-prefix': 'namePrefix',
-    'honorific-suffix': 'nameSuffix',
-    name: 'name',
-    'new-password': 'newPassword',
-    nickname: 'nickname',
-    off: 'none',
-    'one-time-code': 'oneTimeCode',
-    organization: 'organizationName',
-    'organization-title': 'jobTitle',
-    'postal-code': 'postalCode',
-    'street-address': 'fullStreetAddress',
-    tel: 'telephoneNumber',
-    url: 'URL',
-    username: 'username',
-};
-// Safe lookup into a W3C->native / alias->native map (no `as`): own-property guard, undefined
-// if the token has no native equivalent. The caller decides the per-platform fallback. Named
-// for its first user (autoComplete), but it is the one generic safe lookup every map shares.
-export function mapAutoComplete(map, token) {
-    return Object.prototype.hasOwnProperty.call(map, token)
-        ? map[token]
-        : undefined;
-}
-// RN folds W3C `autoComplete` per platform (TextInput.js:938): Android takes the mapped
-// `autoComplete` token (falling back to the raw token), iOS takes the mapped `textContentType`
-// (only when the token is in the map, else leaves it untouched). Symbiote is Metro-built per
-// platform but folds platform-agnostically, resolving BOTH native props from the one token:
-// the iOS-only `textContentType` is inert on Android and the Android `autoComplete` token is
-// inert on iOS, so emitting both is safe: same shape as the dual-keyed events.
-export function foldAutoComplete(token) {
-    if (token === undefined)
-        return { autoComplete: undefined, textContentType: undefined };
-    return {
-        autoComplete: mapAutoComplete(autoCompleteWebToAndroid, token) ?? token,
-        textContentType: mapAutoComplete(autoCompleteWebToTextContentType, token),
-    };
-}
-// RN's submitBehavior reconciliation (TextInput.js:559). Explicit submitBehavior wins (with
-// single-line 'newline' coerced to 'blurAndSubmit'); else it is derived from the legacy
-// blurOnSubmit per multiline. Input/output are plain strings: the result is forwarded to the
-// native prop verbatim, so no ISubmitBehavior union is needed at the seam.
-export function foldSubmitBehavior(submitBehavior, blurOnSubmit, multiline) {
-    if (submitBehavior !== undefined) {
-        if (!multiline && submitBehavior === 'newline')
-            return 'blurAndSubmit';
-        return submitBehavior;
-    }
-    if (multiline)
-        return blurOnSubmit === true ? 'blurAndSubmit' : 'newline';
-    return blurOnSubmit !== false ? 'blurAndSubmit' : 'submit';
-}
+// Deleted in the same pass as `rippleProps` next door, for the same reason. Nothing called them
+// after the port — only this file's own tests and the barrel — and a rule that lives in two places
+// has two behaviours the day one of them is edited. An exported twin kept alive by its own test is
+// the shape the "no mirrors" rule exists to catch.
+//
+// Gone with them: `inputModeToKeyboardType`, `enterKeyHintToReturnKeyType`,
+// `autoCompleteWebToAndroid`, `autoCompleteWebToTextContentType`, `keyboardTypeForInputMode`,
+// `mapAutoComplete`, `foldAutoComplete`, `foldSubmitBehavior`, `resolveTextInputProps` and its two
+// types. What STAYS below is the machine — `foldText`, the change-event readers, and the
+// controlled-write decision — which runs at gesture rate and calls back into app code.
 // RN's fold: value wins, else defaultValue, else leave undefined (uncontrolled).
 export function foldText(value, defaultValue) {
     if (typeof value === 'string')
@@ -194,44 +57,9 @@ export function eventCountFromChange(event) {
 export function shouldCommandText(lastNativeText, value) {
     return typeof value === 'string' && lastNativeText !== value;
 }
-// The whole per-platform-agnostic prop fold in one place (TextInput.js:928-946), shared by every
-// adapter: inputMode wins over keyboardType, enterKeyHint over returnKeyType, readOnly over
-// editable (inverted), the cursor/selection-handle colors default from selectionColor, the W3C
-// autoComplete token folds to the per-platform native prop (an explicit textContentType still
-// wins), inputMode forces softInput visibility, and underlineColorAndroid defaults to
-// 'transparent' to hide the Material EditText bar.
-export function resolveTextInputProps(input) {
-    const folded = foldAutoComplete(input.autoComplete);
-    return {
-        keyboardType: input.inputMode !== undefined
-            ? keyboardTypeForInputMode(input.inputMode, Platform.OS)
-            : input.keyboardType,
-        returnKeyType: input.enterKeyHint !== undefined
-            ? mapAutoComplete(enterKeyHintToReturnKeyType, input.enterKeyHint)
-            : input.returnKeyType,
-        editable: input.readOnly !== undefined ? !input.readOnly : input.editable,
-        submitBehavior: foldSubmitBehavior(input.submitBehavior, input.blurOnSubmit, input.multiline),
-        selectionColor: input.selectionColor,
-        cursorColor: input.cursorColor !== undefined
-            ? input.cursorColor
-            : input.selectionColor,
-        selectionHandleColor: input.selectionHandleColor !== undefined
-            ? input.selectionHandleColor
-            : input.selectionColor,
-        underlineColorAndroid: input.underlineColorAndroid !== undefined
-            ? input.underlineColorAndroid
-            : 'transparent',
-        autoComplete: folded.autoComplete,
-        textContentType: input.textContentType !== undefined
-            ? input.textContentType
-            : folded.textContentType,
-        showSoftInputOnFocus: input.inputMode !== undefined
-            ? input.inputMode !== 'none'
-            : input.showSoftInputOnFocus,
-    };
-}
 const TEXT_INPUT_CALLBACKS = {
     onValueChange: true,
+    onChangeText: true,
     onFocus: true,
     onBlur: true,
     onEndEditing: true,
@@ -239,5 +67,8 @@ const TEXT_INPUT_CALLBACKS = {
     onKeyPress: true,
     onSelectionChange: true,
     onContentSizeChange: true,
+    onPress: true,
+    onPressIn: true,
+    onPressOut: true,
 };
 export const TEXT_INPUT_CALLBACK_NAMES = Object.keys(TEXT_INPUT_CALLBACKS);

package/build/state/touchable.d.ts

@@ -50,6 +50,7 @@ export declare function createHighlightUnderlayRuntime(): IHighlightUnderlayRunt
 export interface IHighlightUnderlayConfig {
     delayPressOut: number;
     hasPressHandler: boolean;
+    testOnlyPressed: boolean;
     schedule: (callback: () => void, ms: number) => () => void;
 }
 export interface IHighlightUnderlayCallbacks {

package/build/state/touchable.js

@@ -18,14 +18,15 @@ export const DEFAULT_ACTIVE_OPACITY = 0.2;
 // finger drifted outside and came back (RESPONDER_INACTIVE_PRESS_OUT -> RESPONDER_ACTIVE_PRESS_IN,
 // driven by onResponderMove).
 //
-// Our engine dispatches pressIn from exactly ONE place — `core/engine/src/events/index.ts:391`,
-// on topTouchStart, ahead of negotiateResponder — and has no drift-back-in re-activation at all.
-// So every pressIn we produce is the grant-equivalent, and 0 is the duration that applies. Using
-// 150 (which all five adapters did until 2026-08-19) makes every tap fade in visibly slower than
-// RN.
+// Our engine's `state/pressable.ts` DOES reproduce that reactivation — `handleResponderMove`
+// re-`activate()`s on a drift-back-in — and `touchable-opacity.ts`'s own `activate` callback picks
+// between the two constants below by checking `event.type === 'responderMove'`, our engine's own
+// dispatch-name equivalent (`core/engine/src/events/index.ts`'s `bubble`/`callOwnListener` both set
+// `type: listenerName`). A prior version of this comment claimed "no drift-back-in re-activation at
+// all" — that was true only until the drift/retention mechanism was added to `state/pressable.ts`
+// and was never re-checked against it; every reactivation was snapping to the active opacity
+// instantly instead of easing over 150ms until this was caught.
 export const OPACITY_ACTIVE_GRANT_DURATION_MS = 0;
-// The re-activation branch. Unreachable today — kept so the constant exists when the press
-// machine grows drift-back-in, and because it is the value RN uses there.
 export const OPACITY_ACTIVE_DURATION_MS = 150;
 export const OPACITY_INACTIVE_DURATION_MS = 250;
 export const RESTING_OPACITY = 1;
@@ -128,7 +129,7 @@ export function createHighlightUnderlayRuntime() {
     return { hideTimerCancel: undefined };
 }
 export function createHighlightUnderlayHandlers(config, runtime, callbacks) {
-    const { delayPressOut, hasPressHandler, schedule } = config;
+    const { delayPressOut, hasPressHandler, testOnlyPressed, schedule } = config;
     const { setShown, onShowUnderlay, onHideUnderlay } = callbacks;
     function clearHideTimer() {
         if (runtime.hideTimerCancel !== undefined) {
@@ -144,6 +145,8 @@ export function createHighlightUnderlayHandlers(config, runtime, callbacks) {
     }
     function hide() {
         clearHideTimer();
+        if (testOnlyPressed)
+            return;
         if (!hasPressHandler)
             return;
         setShown(false);

package/build/state/virtualized-list-reducer.d.ts

@@ -57,8 +57,8 @@ export interface IListReducerInputs<ItemT> {
     initialNumToRender: number;
     maxToRenderPerBatch: number;
     updateCellsBatchingPeriod: number;
-    onEndReachedThreshold: number;
-    onStartReachedThreshold: number;
+    onEndReachedThreshold: number | undefined;
+    onStartReachedThreshold: number | undefined;
     onEndReachedActive: boolean;
     onStartReachedActive: boolean;
     viewabilityPairs: IViewabilityConfigCallbackPair<ItemT>[];