@symbiote-native/components 2.0.0 → 3.0.0

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

@@ -3,11 +3,10 @@ import type { ISymbioteEvent } from '@symbiote-native/engine';
 import type { IScrollRoutingHandle } from './scroll-routing-handle';
 export declare const DEFAULT_WINDOW_SIZE = 21;
 export declare const DEFAULT_INITIAL_NUM_TO_RENDER = 10;
-export declare const DEFAULT_END_REACHED_THRESHOLD = 2;
 export declare const DEFAULT_MAX_TO_RENDER_PER_BATCH = 10;
 export declare const DEFAULT_UPDATE_CELLS_BATCHING_PERIOD = 50;
 export declare const DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD = 0;
-export declare const DEFAULT_START_REACHED_THRESHOLD = 2;
+export declare const DEFAULT_EDGE_REACHED_THRESHOLD_PX = 2;
 export declare const FIRST_INDEX = 0;
 export declare const EMPTY_OFFSET = 0;
 export declare const NO_INDEX = -1;
@@ -41,6 +40,7 @@ export interface IViewToken<ItemT> {
 export interface IViewableItemsChangedInfo<ItemT> {
     viewableItems: IViewToken<ItemT>[];
     changed: IViewToken<ItemT>[];
+    viewabilityConfig?: IViewabilityConfig;
 }
 export interface IViewabilityConfig {
     minimumViewTime?: number;
@@ -94,19 +94,18 @@ export declare function throttleWindow(target: {
     first: number;
     last: number;
 };
-export declare function visiblePercent(cellOffset: number, cellLength: number, scrollOffset: number, viewportLength: number): number;
-export declare function isCellViewable(percent: number, config: IViewabilityConfig): boolean;
+export declare function isCellViewable(cellOffset: number, cellLength: number, scrollOffset: number, viewportLength: number, config: IViewabilityConfig): boolean;
 export declare function offsetForIndex(index: number, viewPosition: number, viewOffset: number, count: number, offsets: number[], lengths: number[], viewportLength: number): number;
 export declare const LAYOUT_EPSILON = 0.01;
 export declare function isSettledLayout(known: number | undefined, reported: number): boolean;
 export declare function averageMeasuredLength(measured: Map<number, number>): number;
 export declare function averageMeasuredStride(measuredOffsets: Map<number, number>, fallback: number): number;
 export declare function highestMeasuredIndex(measured: Map<number, number>): number;
-export declare function computeEndReached(total: number, scrollOffset: number, viewportLength: number, thresholdMultiplier: number): {
+export declare function computeEndReached(total: number, scrollOffset: number, viewportLength: number, thresholdMultiplier: number | undefined): {
     distanceFromEnd: number;
     withinThreshold: boolean;
 };
-export declare function computeStartReached(scrollOffset: number, viewportLength: number, thresholdMultiplier: number): {
+export declare function computeStartReached(scrollOffset: number, viewportLength: number, thresholdMultiplier: number | undefined): {
     distanceFromStart: number;
     withinThreshold: boolean;
 };
@@ -181,6 +180,7 @@ export interface IMvcpAdjustmentResult {
     action: IMvcpAction;
 }
 export declare function computeMvcpAdjustment(params: IMvcpAdjustmentParams): IMvcpAdjustmentResult;
+export declare function defaultKeyExtractor<ItemT>(item: ItemT, index: number): string;
 export declare function resolveItemKey<ItemT>(item: ItemT, index: number, keyExtractor: ((item: ItemT, index: number) => string) | undefined): string;
 export declare function indexOfItem(data: unknown, getItem: (data: unknown, index: number) => unknown, count: number, item: unknown): number;
 export declare function offsetForEnd(total: number, viewportLength: number): number;

package/build/state/virtualized-list.js

@@ -21,18 +21,20 @@
 // module, not a view/render-*.ts.
 import { dlog } from '@symbiote-native/engine';
 // Defaults match RN. windowSize is measured in viewport-lengths (21 => ten screens
-// of buffer on each side of the visible region). onEndReachedThreshold is a multiple
-// of the visible length (RN's onEndReachedThresholdOrDefault returns `?? 2`).
-// initialNumToRender bounds the first paint before any layout is measured.
-// maxToRenderPerBatch / batching period mirror RN's incremental fill defaults.
+// of buffer on each side of the visible region). initialNumToRender bounds the first
+// paint before any layout is measured. maxToRenderPerBatch / batching period mirror
+// RN's incremental fill defaults.
 export const DEFAULT_WINDOW_SIZE = 21;
 export const DEFAULT_INITIAL_NUM_TO_RENDER = 10;
-export const DEFAULT_END_REACHED_THRESHOLD = 2;
 export const DEFAULT_MAX_TO_RENDER_PER_BATCH = 10;
 export const DEFAULT_UPDATE_CELLS_BATCHING_PERIOD = 50;
 export const DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD = 0;
-// onStartReachedThreshold default, mirroring RN's onStartReachedThresholdOrDefault.
-export const DEFAULT_START_REACHED_THRESHOLD = 2;
+// `_maybeCallOnEdgeReached`'s OWN fallback (`VirtualizedList.js:1567`) for whether to actually
+// FIRE onEndReached/onStartReached when the app gives no threshold — a flat 2 PIXELS. This is a
+// different RN default from `onEndReachedThresholdOrDefault`'s `?? 2`, which is a MULTIPLE of the
+// visible length used only for internal render-ahead windowing (a concern this engine does not
+// separate out); conflating the two here used to fire the callback two whole screens early.
+export const DEFAULT_EDGE_REACHED_THRESHOLD_PX = 2;
 export const FIRST_INDEX = 0;
 export const EMPTY_OFFSET = 0;
 export const NO_INDEX = -1;
@@ -178,26 +180,39 @@ export function throttleWindow(target, previous, maxToRenderPerBatch) {
         return target;
     return { first, last };
 }
-// Fraction (0..100) of a cell's box that lies inside the viewport.
-export function visiblePercent(cellOffset, cellLength, scrollOffset, viewportLength) {
-    if (cellLength <= EMPTY_OFFSET)
-        return EMPTY_OFFSET;
-    const top = Math.max(cellOffset, scrollOffset);
-    const bottom = Math.min(cellOffset + cellLength, scrollOffset + viewportLength);
-    const visible = Math.max(EMPTY_OFFSET, bottom - top);
-    return (visible / cellLength) * FULLY_VISIBLE_PERCENT;
-}
-// A cell is viewable when its visible fraction clears the configured threshold.
-// itemVisiblePercentThreshold compares against the cell's own size;
-// viewAreaCoveragePercentThreshold compares against the viewport. The former wins when
-// set, else the latter, matching RN's precedence.
-export function isCellViewable(percent, config) {
-    const itemThreshold = config.itemVisiblePercentThreshold;
-    if (itemThreshold !== undefined)
-        return percent >= itemThreshold;
-    const areaThreshold = config.viewAreaCoveragePercentThreshold ??
-        DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD;
-    return percent > areaThreshold || percent >= FULLY_VISIBLE_PERCENT;
+// A cell is viewable when its visible fraction clears the configured threshold
+// (`ViewabilityHelper.js`'s `_isViewable` + `computeViewableItems`). Two percents exist and they
+// are NOT interchangeable: `viewAreaCoveragePercentThreshold` is a fraction of the VIEWPORT,
+// `itemVisiblePercentThreshold` a fraction of the CELL's own length — a short cell mostly visible
+// in a tall viewport clears the second easily while failing the first. Area wins whenever it is
+// set (vendor checks `viewAreaCoveragePercentThreshold != null` first); item only when it is not.
+export function isCellViewable(cellOffset, cellLength, scrollOffset, viewportLength, config) {
+    const top = cellOffset - scrollOffset;
+    const bottom = top + cellLength;
+    // No overlap at all: RN's own caller loop never reaches `_isViewable` for such a cell
+    // (`top < viewportHeight && bottom > 0` gates the whole scan), so this is exclusion by
+    // construction, not a zero percent happening to clear a zero threshold.
+    if (bottom <= EMPTY_OFFSET || top >= viewportLength)
+        return false;
+    // RN's own `_isEntirelyVisible` shortcut: viewable in EITHER mode regardless of the cell's
+    // share of the viewport, since an area threshold sized to the viewport could otherwise reject
+    // every fully-visible cell smaller than that share. `bottom > top` excludes a zero-length cell
+    // (no measurement yet), which vendor falls through to the percent math instead.
+    if (top >= EMPTY_OFFSET && bottom <= viewportLength && bottom > top) {
+        return true;
+    }
+    const visiblePixels = Math.min(bottom, viewportLength) - Math.max(top, EMPTY_OFFSET);
+    const areaThreshold = config.viewAreaCoveragePercentThreshold;
+    const areaMode = areaThreshold !== undefined;
+    const threshold = areaMode
+        ? areaThreshold
+        : (config.itemVisiblePercentThreshold ??
+            DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD);
+    const denominator = areaMode ? viewportLength : cellLength;
+    if (denominator <= EMPTY_OFFSET)
+        return false;
+    const percent = (visiblePixels / denominator) * FULLY_VISIBLE_PERCENT;
+    return percent >= threshold;
 }
 // Resolve an index to a pixel offset, optionally biasing where in the viewport the item
 // lands (viewPosition 0=top, 1=bottom, 0.5=center) and an absolute viewOffset nudge,
@@ -271,11 +286,17 @@ export function highestMeasuredIndex(measured) {
 // onEndReached distance + threshold test (RN _maybeCallOnEdgeReached). The adapter still
 // gates on "the last cell is actually rendered" and dedups by content length via its own
 // ref; this returns only the pure geometry.
+//
+// `thresholdMultiplier` is `undefined` for "the app gave no onEndReachedThreshold" — RN's own
+// unset-case answer is a flat `DEFAULT_EDGE_REACHED_THRESHOLD_PX`, never a viewport-length
+// multiple, so `undefined` must NOT be defaulted to a multiplier at the call site.
 export function computeEndReached(total, scrollOffset, viewportLength, thresholdMultiplier) {
     let distanceFromEnd = total - (scrollOffset + viewportLength);
     if (distanceFromEnd < ON_EDGE_REACHED_EPSILON)
         distanceFromEnd = EMPTY_OFFSET;
-    const threshold = thresholdMultiplier * viewportLength;
+    const threshold = thresholdMultiplier != null
+        ? thresholdMultiplier * viewportLength
+        : DEFAULT_EDGE_REACHED_THRESHOLD_PX;
     return { distanceFromEnd, withinThreshold: distanceFromEnd <= threshold };
 }
 // onStartReached twin of computeEndReached. distanceFromStart is just the scroll offset.
@@ -283,7 +304,9 @@ export function computeStartReached(scrollOffset, viewportLength, thresholdMulti
     let distanceFromStart = scrollOffset;
     if (distanceFromStart < ON_EDGE_REACHED_EPSILON)
         distanceFromStart = EMPTY_OFFSET;
-    const threshold = thresholdMultiplier * viewportLength;
+    const threshold = thresholdMultiplier != null
+        ? thresholdMultiplier * viewportLength
+        : DEFAULT_EDGE_REACHED_THRESHOLD_PX;
     return { distanceFromStart, withinThreshold: distanceFromStart <= threshold };
 }
 // Fold the single-config and pairs forms into one list (RN supports either, not both).
@@ -306,18 +329,15 @@ export function computeViewableSet(params) {
     const tokens = [];
     const map = new Map();
     for (let index = params.first; index <= params.last && index < params.count; index += 1) {
-        const percent = visiblePercent(params.offsets[index], params.lengths[index], params.scrollOffset, params.viewportLength);
         const item = params.getItem(params.data, index);
-        const key = params.keyExtractor
-            ? params.keyExtractor(item, index)
-            : String(index);
+        const key = resolveItemKey(item, index, params.keyExtractor);
         let anyViewable = false;
         for (const pair of params.pairs) {
             if (pair.viewabilityConfig.waitForInteraction === true &&
                 !params.hasInteracted) {
                 continue;
             }
-            if (isCellViewable(percent, pair.viewabilityConfig)) {
+            if (isCellViewable(params.offsets[index], params.lengths[index], params.scrollOffset, params.viewportLength, pair.viewabilityConfig)) {
                 anyViewable = true;
                 break;
             }
@@ -488,10 +508,24 @@ export function computeMvcpAdjustment(params) {
         action: { kind: 'shift', offset: params.scrollOffset + insertedExtent },
     };
 }
-// The default key extractor: the caller's keyExtractor when set, else the index as a string (RN's
-// default). Centralized so every adapter's keyForIndex resolves keys identically.
+// RN's real default (`VirtualizeUtils.js`'s `keyExtractor`): an object item's own `key`, else its
+// `id`, else the index. Most apps never pass `keyExtractor` at all and rely on this to keep list
+// identity stable across inserts/removes — falling straight to the index (what this used to do)
+// silently breaks that the moment two items swap position.
+export function defaultKeyExtractor(item, index) {
+    if (typeof item === 'object' && item !== null) {
+        const record = item;
+        if (record.key !== undefined && record.key !== null)
+            return String(record.key);
+        if (record.id !== undefined && record.id !== null)
+            return String(record.id);
+    }
+    return String(index);
+}
+// The default key extractor: the caller's keyExtractor when set, else `defaultKeyExtractor`.
+// Centralized so every adapter's keyForIndex resolves keys identically.
 export function resolveItemKey(item, index, keyExtractor) {
-    return keyExtractor ? keyExtractor(item, index) : String(index);
+    return (keyExtractor ?? defaultKeyExtractor)(item, index);
 }
 // Linear item -> index lookup for scrollToItem (RN scans by reference identity). NO_INDEX when the
 // item is not in data.

package/build/text-props.d.ts

@@ -1,9 +1 @@
 export type IEllipsizeMode = 'head' | 'middle' | 'tail' | 'clip';
-export interface ITextDefaultableProps {
-    ellipsizeMode?: IEllipsizeMode;
-    allowFontScaling?: boolean;
-}
-export declare function resolveTextProps<T extends ITextDefaultableProps>(props: T): T & {
-    ellipsizeMode: IEllipsizeMode;
-    allowFontScaling: boolean;
-};

package/build/text-props.js

@@ -1,25 +1,14 @@
-// The defaults RN's Text.js applies before handing props to native, folded once for every adapter.
-//
-// RN does this unconditionally on the outer (non-virtual) path, Text.js:289 and :291 (the two
-// lines between them, 288 and 290, are `accessible` and `disabled` — not part of this fold):
-//
-//   processedProps.allowFontScaling = allowFontScaling !== false;
-//   processedProps.ellipsizeMode = ellipsizeMode ?? 'tail';
-//
-// We declared both props in all four adapters and applied NEITHER default, so native fell back to
-// its own: `clip` instead of `tail`. Device-observed 2026-08-19 on examples/svelte — a Text with
-// numberOfLines={1} cut mid-word with no ellipsis at all. Nothing failed; the text was simply
-// wrong, which is why four adapters carried it.
-//
-// Both keys are emitted UNCONDITIONALLY, matching RN and — separately — keeping the key set
-// stable. A fold with two branches that emit different key sets is the exact hazard
-// .claude/rules/solid-descriptor-bridge.md §1 exists for, and Svelte's shim diffs the same way.
-export function resolveTextProps(props) {
-    return {
-        ...props,
-        ellipsizeMode: props.ellipsizeMode ?? 'tail',
-        // `!== false`, not `?? true`: RN treats an explicit `undefined` and a missing prop alike, and
-        // only a literal `false` opts out.
-        allowFontScaling: props.allowFontScaling !== false,
-    };
-}
+// The ellipsize modes a Text accepts. THE DEFAULTS THAT USED TO BE APPLIED HERE ARE GONE (2026-09-18)
+// — they are the platform's, so they live in the engine's payload builder and reach every `RCTText`
+// whoever authored it: `foldTextDefaults`, `SymbioteFabricProps.cpp`.
+//
+// `resolveTextProps` was the third implementation of a two-line rule. Its one runtime caller was
+// Button's label, which wrote both keys onto a node the builder was about to default anyway — the
+// same seed shape `seedTextDefaults` had in three adapters, at a smaller scale. The rule reaches
+// that node by being keyed on the COMPONENT, so nothing has to hand it down.
+//
+// Why the original fold existed at all, kept because the bug is easy to reintroduce: we declared both
+// props in all four adapters and applied NEITHER default, so native fell back to its own `clip`.
+// Device-observed 2026-08-19 on examples/svelte — a Text with `numberOfLines={1}` cut mid-word with
+// no ellipsis. Nothing failed; the text was simply wrong.
+export {};

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

@@ -1,4 +1,4 @@
-import type { ITextStyle, IViewStyle, ISymbioteEvent } from '@symbiote-native/engine';
+import type { ISymbioteEvent } from '@symbiote-native/engine';
 import type { IAccessibilityProps, IAriaProps } from '../accessibility-props';
 export interface IButtonProps extends IAccessibilityProps, IAriaProps {
     title: string;
@@ -14,29 +14,6 @@ export interface IButtonProps extends IAccessibilityProps, IAriaProps {
     nextFocusRight?: number;
     nextFocusUp?: number;
 }
-export declare const BUTTON_ACCESSIBILITY_ROLE = "button";
-export declare const buttonTextStyle: ITextStyle;
-export declare const buttonViewStyle: IViewStyle;
-/**
- * The label style with `color` and `disabled` folded in.
- *
- * `color` tints the TEXT on iOS and the BUTTON on Android (Button.js:318-324), so on Android this
- * ignores it — see `resolveButtonViewStyle`, which is where it lands there. `disabled` wins over
- * `color` on both, because RN pushes `textDisabled` after the tint.
- */
-export declare function resolveButtonTextStyle(color: string | undefined, disabled: boolean | undefined): ITextStyle;
-/**
- * The inner view's style with `color` and `disabled` folded in — `{}` on iOS in every combination,
- * which is RN's own answer there and the reason the node looked droppable.
- */
-export declare function resolveButtonViewStyle(color: string | undefined, disabled: boolean | undefined): IViewStyle;
-/**
- * The label as it is rendered: UPPERCASE on Android (Button.js:352-353).
- *
- * RN also asserts the title is a string one line above. Not reproduced: the assert is a dev-only
- * `invariant`, and every adapter here types `title: string`.
- */
-export declare function resolveButtonTitle(title: string): string;
 /**
  * Whether the button is disabled, which `aria-disabled` may decide on its own.
  *
@@ -47,8 +24,3 @@ export declare function resolveButtonTitle(title: string): string;
 export declare function resolveButtonDisabled(disabled: boolean | undefined, ariaDisabled: boolean | undefined, accessibilityState: {
     disabled?: boolean;
 } | undefined): boolean | undefined;
-/**
- * Button.js:356-359 — `'no'` becomes `'no-hide-descendants'`, so the label inside cannot take
- * focus separately from the button that contains it.
- */
-export declare function resolveButtonImportantForAccessibility(value: IAccessibilityProps['importantForAccessibility']): IAccessibilityProps['importantForAccessibility'];

package/build/view/render-button.js

@@ -12,85 +12,55 @@
 // fold RN performs in `Button.js:326-331`. The engine folds those for every node
 // (`core/engine/src/accessibility-props.ts`), so repeating it here would fold twice.
 import { Platform } from '@symbiote-native/engine';
-// Button.js:394-437, one constant per literal so a value cannot drift silently.
-const IOS_BUTTON_BLUE = '#007AFF';
-const IOS_DISABLED_TEXT = '#cdcdcd';
+// Button.js:394-437, one constant per literal so a value cannot drift silently. The LABEL's seven
+// went with `resolveButtonTextStyle` on 2026-09-18 — they live in `SymbioteFabricProps.cpp` beside
+// the rule that reads them and are deliberately not duplicated here.
 const ANDROID_BUTTON_BLUE = '#2196F3';
 const ANDROID_DISABLED_BACKGROUND = '#dfdfdf';
-const ANDROID_DISABLED_TEXT = '#a1a1a1';
-const ANDROID_TEXT = 'white';
 const ANDROID_ELEVATION = 4;
 const ANDROID_DISABLED_ELEVATION = 0;
 const ANDROID_BORDER_RADIUS = 2;
-const TEXT_MARGIN = 8;
-const IOS_FONT_SIZE = 18;
-const ANDROID_FONT_WEIGHT = '500';
-// RN's Button is accessibilityRole="button"; the role string is a native accessibility enum value.
-export const BUTTON_ACCESSIBILITY_ROLE = 'button';
-// `styles.text` — the platform-invariant half plus the platform's own. RN spells the margin as
-// MARGIN, not padding: the label pushes the button's edges outward rather than insetting itself,
-// so a background (Android) or a tap target (both) is 16pt taller than the glyphs.
-export const buttonTextStyle = {
-    textAlign: 'center',
-    margin: TEXT_MARGIN,
-    ...Platform.select({
-        ios: { color: IOS_BUTTON_BLUE, fontSize: IOS_FONT_SIZE },
-        android: { color: ANDROID_TEXT, fontWeight: ANDROID_FONT_WEIGHT },
-        default: { color: IOS_BUTTON_BLUE, fontSize: IOS_FONT_SIZE },
-    }),
-};
-// `styles.button` — empty on iOS, the whole Material look on Android.
-export const buttonViewStyle = Platform.select({
-    ios: {},
-    android: {
-        elevation: ANDROID_ELEVATION,
-        backgroundColor: ANDROID_BUTTON_BLUE,
-        borderRadius: ANDROID_BORDER_RADIUS,
-    },
-    default: {},
-}) ?? {};
-/**
- * The label style with `color` and `disabled` folded in.
- *
- * `color` tints the TEXT on iOS and the BUTTON on Android (Button.js:318-324), so on Android this
- * ignores it — see `resolveButtonViewStyle`, which is where it lands there. `disabled` wins over
- * `color` on both, because RN pushes `textDisabled` after the tint.
- */
-export function resolveButtonTextStyle(color, disabled) {
-    const style = { ...buttonTextStyle };
-    if (color !== undefined && Platform.OS !== 'android')
-        style.color = color;
-    if (disabled === true) {
-        style.color =
-            Platform.OS === 'android' ? ANDROID_DISABLED_TEXT : IOS_DISABLED_TEXT;
-    }
-    return style;
-}
-/**
- * The inner view's style with `color` and `disabled` folded in — `{}` on iOS in every combination,
- * which is RN's own answer there and the reason the node looked droppable.
- */
-export function resolveButtonViewStyle(color, disabled) {
-    if (Platform.OS !== 'android')
-        return buttonViewStyle;
-    const style = { ...buttonViewStyle };
-    if (color !== undefined)
-        style.backgroundColor = color;
-    if (disabled === true) {
-        style.elevation = ANDROID_DISABLED_ELEVATION;
-        style.backgroundColor = ANDROID_DISABLED_BACKGROUND;
-    }
-    return style;
-}
-/**
- * The label as it is rendered: UPPERCASE on Android (Button.js:352-353).
- *
- * RN also asserts the title is a string one line above. Not reproduced: the assert is a dev-only
- * `invariant`, and every adapter here types `title: string`.
- */
-export function resolveButtonTitle(title) {
-    return Platform.OS === 'android' ? title.toUpperCase() : title;
-}
+// `BUTTON_ACCESSIBILITY_ROLE` and `resolveButtonImportantForAccessibility` WERE HERE and are gone
+// (2026-09-18). Both are `foldButtonProps` in `SymbioteFabricProps.cpp` now, and neither had a
+// caller left afterwards — only its own unit test, which is the shape this project calls a mirror:
+// a JS copy of a rule that runs elsewhere, kept alive by the test that asserts it. It would have
+// stayed green forever while meaning nothing.
+// `buttonTextStyle` AND `resolveButtonTextStyle` ARE GONE (2026-09-18) — the label's style is
+// `foldButtonLabelStyle` in `SymbioteFabricProps.cpp`, reached off the label text's own tag. Its
+// constants live THERE now and are not mirrored here; this file keeps only what Android's own fold
+// still needs.
+//
+// It was the last rule in this primitive to move and it needed a seam none of the others did. Its
+// inputs are the BUTTON's `color` and `disabled`, and the node it hangs on is the button's
+// GRANDCHILD on iOS (`button -> view -> text`) and its child on Android — so `ownerProps`, which
+// answers "my parent", could not reach it. `IAncestorLookup` asks for the nearest ancestor carrying
+// a tag instead, which is a CSS ancestor selector and makes one rule right on both trees.
+// `buttonViewStyle` AND `resolveButtonViewStyle` ARE GONE (2026-09-18), and with them the last of
+// Button's folds. The Material look is inside `foldButtonProps` in `SymbioteFabricProps.cpp`, behind
+// `#ifdef ANDROID` — where it belongs, since `{}` on iOS was the whole of its other branch.
+//
+// Its five constants went too rather than staying as a copy nothing reads.
+//
+// WHAT MADE THIS ONE DIFFERENT from the four ports before it: the Android branch is no longer
+// untestable. The test host grew an arm that compiles `#ifdef ANDROID`
+// (`core/engine/cpp/tests/CMakeLists.txt`, `SYMBIOTE_PLATFORM_ANDROID`), so the style, the `color`
+// override and the disabled greying are asserted against the COMMITTED PAYLOAD in
+// `core/engine/cpp/tests/js/android-rules.itest.ts` — strictly better than the mocked-`Platform.OS`
+// unit test that went with them, which asserted a JS function rather than what Fabric receives.
+// `resolveButtonTitle` IS GONE (2026-09-18) — the uppercase-on-Android rule is `foldButtonLabel` in
+// `SymbioteFabricProps.cpp`, reached off the label's own tag. It had no caller left but its own two
+// unit tests, which is the orphan shape this migration keeps turning up: a JS copy of a rule that
+// runs elsewhere, kept alive by the test asserting it, green forever and proving nothing.
+//
+// A COVERAGE GAP WENT WITH IT, recorded rather than hidden. The C++ rule is `#ifdef ANDROID` — a raw
+// text commits as `RCTRawText` on both platforms, so unlike `Switch`/`AndroidSwitch` there is no view
+// NAME for a rule to branch on — and this host is not Android. The deleted Android test reached the
+// branch by mocking `Platform.OS`; what it mocked was a JS function that no longer exists. Same
+// class as `android_ripple` and `decelerationRate`'s constants, and closing it means an Android arm
+// of the test host, not a mock.
+//
+// One behaviour difference shipped with the move and is deliberate: RN uppercases through
+// JavaScript's full-Unicode `toUpperCase`, and the C++ rule is ASCII-only. See `foldButtonLabel`.
 /**
  * Whether the button is disabled, which `aria-disabled` may decide on its own.
  *
@@ -103,10 +73,3 @@ export function resolveButtonDisabled(disabled, ariaDisabled, accessibilityState
         return disabled;
     return ariaDisabled ?? accessibilityState?.disabled;
 }
-/**
- * Button.js:356-359 — `'no'` becomes `'no-hide-descendants'`, so the label inside cannot take
- * focus separately from the button that contains it.
- */
-export function resolveButtonImportantForAccessibility(value) {
-    return value === 'no' ? 'no-hide-descendants' : value;
-}

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

@@ -54,5 +54,18 @@ export type IImageViewProps = {
     passthrough: Record<string, unknown>;
 };
 export declare const IMAGE_VIEW_PROP_NAMES: readonly ["source", "defaultSource", "loadingIndicatorSource", "style", "resizeMode", "tintColor", "src", "srcSet", "alt", "width", "height", "crossOrigin", "referrerPolicy"];
-export declare function mapImageProps(view: IImageViewProps): Record<string, unknown>;
+/**
+ * `mapImageProps` STOOD HERE and is now the engine's — `foldImageProps` in
+ * `SymbioteFabricProps.cpp`, with `core/engine/cpp/tests/js/image-payload.itest.ts` as its contract.
+ *
+ * WHAT IS LEFT IS A GATHER, NOT A FOLD, and the distinction is the whole change. This flattens a
+ * typed view object back into the bag an app authored — the `<image>` tag then receives those names
+ * verbatim and the engine resolves them at commit, once, for every adapter. Angular is the caller
+ * that kept this path alive (its `<Image>` component has typed `@Input()`s rather than a prop bag);
+ * it now hands the tag raw props like every other adapter does.
+ *
+ * So the aliases (`src`, `srcSet`, `alt`, `width`, `height`, `crossOrigin`, `referrerPolicy`) leave
+ * here UNRESOLVED on purpose. Resolving them would be the second implementation this file's own
+ * header spent four lines warning about.
+ */
 export declare function renderImage(view: IImageViewProps): IDescriptor;