@symbiote-native/components 1.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, 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,6 +14,13 @@ export interface IButtonProps extends IAccessibilityProps, IAriaProps {
     nextFocusRight?: number;
     nextFocusUp?: number;
 }
-export declare const BUTTON_ACCESSIBILITY_ROLE = "button";
-export declare const buttonTextStyle: ITextStyle;
-export declare function resolveButtonTextStyle(color: string | undefined, disabled: boolean | undefined): ITextStyle;
+/**
+ * Whether the button is disabled, which `aria-disabled` may decide on its own.
+ *
+ * Button.js:337-338 — `props.disabled != null ? props.disabled : accessibilityState.disabled`. The
+ * engine already folds `aria-disabled` into the committed `accessibilityState`, but that fold is a
+ * PAYLOAD fold: it cannot suppress the press or grey the label, which is what this is for.
+ */
+export declare function resolveButtonDisabled(disabled: boolean | undefined, ariaDisabled: boolean | undefined, accessibilityState: {
+    disabled?: boolean;
+} | undefined): boolean | undefined;

package/build/view/render-button.js

@@ -1,23 +1,75 @@
-// Button: shared render half (framework-agnostic), matching RN's iOS shape (Button.js): a
-// TouchableOpacity wrapping a Text. Each adapter composes its own TouchableOpacity + Text
-// around the pieces below.
-const IOS_BUTTON_BLUE = '#007AFF';
-const IOS_DISABLED_GREY = '#cdcdcd';
-// RN's Button is accessibilityRole="button"; the role string is a native accessibility enum value.
-export const BUTTON_ACCESSIBILITY_ROLE = 'button';
-export const buttonTextStyle = {
-    color: IOS_BUTTON_BLUE,
-    textAlign: 'center',
-    padding: 8,
-    fontSize: 18,
-};
-// The label text style with the color folded in: an explicit `color` tints the label (iOS), and
-// `disabled` greys it out (disabled wins over color, matching RN's Button.js).
-export function resolveButtonTextStyle(color, disabled) {
-    const style = { ...buttonTextStyle };
-    if (color !== undefined)
-        style.color = color;
-    if (disabled === true)
-        style.color = IOS_DISABLED_GREY;
-    return style;
+// Button: shared render half (framework-agnostic). Ported against RN's own
+// `Libraries/Components/Button.js` — a touchable wrapping a `View` wrapping a `Text`, where the
+// VIEW is what carries the look on Android and is empty on iOS.
+//
+// The inner view is not optional chrome. RN's Button is the one control in the library that ships
+// a finished appearance, and on Android that appearance — a filled, elevated, rounded Material
+// button with an uppercased label — lives entirely on that node. A port that renders only the
+// touchable and the text is an iOS port, which is what this file was until 2026-09-09: blue text on
+// nothing, wherever Android was.
+//
+// What is NOT here, because a layer below already does it: the `aria-*` -> `accessibilityState`
+// 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. 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_ELEVATION = 4;
+const ANDROID_DISABLED_ELEVATION = 0;
+const ANDROID_BORDER_RADIUS = 2;
+// `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.
+ *
+ * Button.js:337-338 — `props.disabled != null ? props.disabled : accessibilityState.disabled`. The
+ * engine already folds `aria-disabled` into the committed `accessibilityState`, but that fold is a
+ * PAYLOAD fold: it cannot suppress the press or grey the label, which is what this is for.
+ */
+export function resolveButtonDisabled(disabled, ariaDisabled, accessibilityState) {
+    if (disabled !== undefined)
+        return disabled;
+    return ariaDisabled ?? accessibilityState?.disabled;
 }

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;

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

@@ -1,117 +1,5 @@
-import { dlog, flattenStyle, resolveImageSource, } from '@symbiote-native/engine';
+import { dlog, } from '@symbiote-native/engine';
 import { el } from '../../descriptor.js';
-// Resolve the source, then normalize to the array shape native expects. A single
-// object/number becomes a one-element array; an already-array source passes through.
-function normalizeSource(source) {
-    const resolved = resolveImageSource(source);
-    const sources = Array.isArray(resolved) ? resolved : [resolved];
-    dlog(`Image source resolved to ${JSON.stringify(sources)}`);
-    return sources;
-}
-// The HTTP headers the W3C aliases (crossOrigin / referrerPolicy) contribute to
-// every folded source, mirroring ImageSourceUtils.js getImageSourcesFromImageProps:
-// 'use-credentials' adds the credentials header; referrerPolicy adds Referrer-Policy.
-function headersFromAliases(view) {
-    const headers = {};
-    if (view.crossOrigin === 'use-credentials') {
-        headers['Access-Control-Allow-Credentials'] = 'true';
-    }
-    if (view.referrerPolicy !== undefined) {
-        headers['Referrer-Policy'] = view.referrerPolicy;
-    }
-    return headers;
-}
-// Expand a `srcSet` descriptor list into scaled sources, falling back to `src` for
-// the 1x slot when srcSet omits it. Direct port of getImageSourcesFromImageProps'
-// srcSet branch (ImageSourceUtils.js:48). Invalid scale tokens are skipped, matching
-// RN's parse-and-warn behavior.
-function expandSrcSet(srcSet, view, headers) {
-    const sources = [];
-    let useSrcForDefaultScale = true;
-    for (const entry of srcSet.split(', ')) {
-        const [uri, xScale = '1x'] = entry.split(' ');
-        if (!xScale.endsWith('x')) {
-            dlog(`Image srcSet: unsupported scale token "${xScale}", skipping`);
-            continue;
-        }
-        const scale = parseInt(xScale.slice(0, -1), 10);
-        if (Number.isNaN(scale))
-            continue;
-        if (scale === 1)
-            useSrcForDefaultScale = false;
-        sources.push({
-            uri,
-            scale,
-            width: view.width,
-            height: view.height,
-            ...{ headers },
-        });
-    }
-    if (useSrcForDefaultScale && view.src !== undefined) {
-        sources.push({
-            uri: view.src,
-            scale: 1,
-            width: view.width,
-            height: view.height,
-            ...{ headers },
-        });
-    }
-    if (sources.length === 0)
-        dlog('Image srcSet: produced no valid sources');
-    return sources;
-}
-// Resolve the native `source` array from whichever of source / src / srcSet the
-// caller provided. Mirrors ImageSourceUtils.js getImageSourcesFromImageProps:
-// srcSet wins, then src, then a header-decorated source, then the plain source.
-// Always returns the array shape native expects (the same contract normalizeSource
-// guarantees), so the component never sends a bare object.
-function resolveSourceArray(view) {
-    const headers = headersFromAliases(view);
-    if (view.srcSet !== undefined) {
-        return expandSrcSet(view.srcSet, view, headers);
-    }
-    if (view.src !== undefined) {
-        return [
-            { uri: view.src, width: view.width, height: view.height, ...{ headers } },
-        ];
-    }
-    if (view.source === undefined) {
-        dlog('Image: no source / src / srcSet provided');
-        return [];
-    }
-    const sources = normalizeSource(view.source);
-    // A header-decorated single object source gets the headers merged in, per RN's
-    // `source.uri && headers` branch; the array/number shapes pass through untouched.
-    if (Object.keys(headers).length > 0 && sources.length === 1) {
-        const [only] = sources;
-        if (typeof only === 'object' &&
-            only !== null &&
-            typeof Reflect.get(only, 'uri') === 'string') {
-            return [{ ...only, headers }];
-        }
-    }
-    return sources;
-}
-function readStyleString(style, key) {
-    if (style === undefined)
-        return undefined;
-    // style is a StyleProp (possibly a nested array), so flatten before reading a key.
-    const flat = flattenStyle(style);
-    const value = Object.hasOwn(flat, key) ? flat[key] : undefined;
-    return typeof value === 'string' ? value : undefined;
-}
-// Resolve an asset source and read its single uri. RN forwards the Android
-// loading indicator as a bare uri string (`loadingIndicatorSrc`), not the
-// array shape the main source uses, so we resolve and pluck the uri.
-function readSourceUri(source) {
-    const [resolved] = normalizeSource(source);
-    if (typeof resolved === 'object' && resolved !== null) {
-        const uri = Reflect.get(resolved, 'uri');
-        if (typeof uri === 'string')
-            return uri;
-    }
-    return undefined;
-}
 // The names `renderImage` CONSUMES rather than forwards — the fold's input list, and the reason it
 // is exported: an adapter that splits props before calling renderImage was copying this list by
 // hand, and a name added here reached the copy only if someone remembered. The Image behavior's
@@ -131,40 +19,27 @@ export const IMAGE_VIEW_PROP_NAMES = [
     'crossOrigin',
     'referrerPolicy',
 ];
-// The whole of Image's prop mapping, with the `el()` wrap taken off. Split out because a LOWERED
-// `<symbiote-image>` has no component body to run it in: its behavior's `foldPayload` needs the same
-// bag at commit time, and a second implementation of this is the exact drift this file already paid
-// for once (`adapters/svelte/src/components/image/image-logic.ts` reproduces it by hand, with a
-// comment saying it had to because nothing here was exported).
-export function mapImageProps(view) {
-    // `width` / `height` aliases fold into style (ImageProps.js:195,202); explicit
-    // style keys win, matching RN's `{width, height}, ...style` ordering.
-    const foldedStyle = view.width === undefined && view.height === undefined
-        ? view.style
-        : [{ width: view.width, height: view.height }, view.style];
-    const mapped = {
-        ...view.passthrough,
-        style: foldedStyle,
-        source: resolveSourceArray(view),
-        resizeMode: view.resizeMode ?? readStyleString(view.style, 'resizeMode'),
-        tintColor: view.tintColor ?? readStyleString(view.style, 'tintColor'),
-    };
-    // `alt` is the accessibility text: it sets accessibilityLabel and marks the image
-    // accessible (Image.ios.js / Image.android.js: alt -> accessibilityLabel + accessible).
-    // An explicit accessibilityLabel (already folded into passthrough) still wins.
-    if (view.alt !== undefined) {
-        if (mapped.accessibilityLabel === undefined)
-            mapped.accessibilityLabel = view.alt;
-        mapped.accessible = true;
-    }
-    if (view.defaultSource !== undefined)
-        mapped.defaultSource = normalizeSource(view.defaultSource);
-    if (view.loadingIndicatorSource !== undefined) {
-        mapped.loadingIndicatorSrc = readSourceUri(view.loadingIndicatorSource);
-    }
-    return mapped;
-}
+/**
+ * `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 function renderImage(view) {
     dlog('Image -> RCTImageView');
-    return el('symbiote-image', mapImageProps(view));
+    const props = { ...view.passthrough };
+    for (const name of IMAGE_VIEW_PROP_NAMES) {
+        const value = view[name];
+        if (value !== undefined)
+            props[name] = value;
+    }
+    return el('image', props);
 }

package/build/view/render-input-accessory-view.d.ts

@@ -1,11 +1,7 @@
-import { type IStyleProp, type IViewStyle } from '@symbiote-native/engine';
-import { type IDescriptor } from '../descriptor';
+import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
 export type IInputAccessoryViewViewProps = {
     nativeID?: string;
     backgroundColor?: string;
     style?: IStyleProp<IViewStyle>;
     passthrough: Record<string, unknown>;
 };
-export declare const INPUT_ACCESSORY_VIEW_PROP_NAMES: readonly ["nativeID", "backgroundColor", "style"];
-export declare function mapInputAccessoryViewProps(view: IInputAccessoryViewViewProps): Record<string, unknown>;
-export declare function renderInputAccessoryView(view: IInputAccessoryViewViewProps): IDescriptor;