@symbiote-native/components 3.1.0 → 3.1.2

package/build/state/virtualized-list-reducer.js

@@ -1,22 +1,12 @@
 // VirtualizedList orchestration reducer: the framework-agnostic STATE MACHINE that folds every
-// per-adapter effect skeleton into one place. Before this, each adapter (React useEffect, Vue
-// watch, Angular ngAfterViewChecked) re-wrote the same sequence — recompute the window, gate
-// onEndReached on `last === count - 1`, dedup by content length, run viewability, apply MVCP — in
-// its own reactive dialect, and the predicates in that glue (`last === count - 1`, `first === 0`,
-// the batch-fill catch-up test, the viewability guards) lived THREE times and quietly drifted.
-//
-// Here the whole decision half is one pure `reduceList(state, action, inputs) -> {state, effects}`.
-// The adapter keeps only what is genuinely framework-bound: translate a native event into an
-// ACTION, hold ONE state cell, and EXECUTE the returned EFFECTS with its own primitives (a native
-// scrollTo, a callback/emit, a setTimeout, a re-render). The geometry leaves (buildOffsets /
-// computeWindow / computeMvcpAdjustment / …) still live in ./virtualized-list; this module composes
-// them into the ordered transition every adapter shares.
-//
-// Effect EXECUTION stays per-adapter by design: which framework hook fires the commit, how a
-// native scrollTo is dispatched, how a debounce timer is held — an effect-list DESCRIBES the work,
-// it does not run it. State TRANSITIONS (including the derived window metrics) are owned entirely
-// here, so a windowing / edge / viewability / MVCP bug — and the drift between three copies of it —
-// is fixed once for all adapters.
+// per-adapter effect skeleton into one place, so the same predicates no longer live in three
+// reactive dialects and quietly drift.
+// The whole decision half is one pure `reduceList(state, action, inputs) -> {state, effects}`. The
+// adapter keeps only what's genuinely framework-bound: translate a native event into an ACTION,
+// hold ONE state cell, and EXECUTE the returned EFFECTS with its own primitives.
+// Effect EXECUTION stays per-adapter by design — an effect list DESCRIBES the work, it doesn't run
+// it. State TRANSITIONS (including derived window metrics) are owned entirely here, so a
+// windowing/edge/viewability/MVCP bug is fixed once for all adapters.
 import { dlog } from '@symbiote-native/engine';
 import { EMPTY_OFFSET, FIRST_INDEX, NO_CONTENT_LENGTH_SENT, NO_INDEX, averageMeasuredStride, buildOffsets, computeEndReached, computeMvcpAdjustment, computeStartReached, computeViewableSet, computeWindow, decideEdgeReached, diffViewable, highestMeasuredIndex, indexOfItem, isSettledLayout, maxMinimumViewTime, offsetForEnd, offsetForIndex, resolveAverageLength, resolveItemKey, throttleWindow, initialRenderRegion, wrapFixedLayout, } from './virtualized-list.js';
 import { recordCellMove, recordListFrame, } from './virtualized-list-diagnostics.js';
@@ -132,20 +122,12 @@ function deriveMetrics(state, inputs) {
 function keyForOf(inputs) {
     return (index) => resolveItemKey(inputs.getItem(inputs.data, index), index, inputs.keyExtractor);
 }
-// The after-render pass: every deferred effect, in the order 2 of 3 adapters already ran them
-// (batch-fill -> end -> start -> viewability -> initial-scroll -> MVCP). Each is guarded by its own
-// dedup state (sent*ForContentLength, lastViewable, appliedInitialScroll, firstVisibleKey), so
-// running commit on every render is safe — the guards prevent a redundant fire.
-// Reclassify the rendered cells and, if the viewable set changed, hand the adapter an info payload
-// to fire (after minimumViewTime, if any). lastViewable is folded back only when the fire actually
-// lands (the 'viewable-fired' action), so a debounce superseded mid-flight still diffs against the
-// last COMMITTED set.
-//
+// Reclassify the rendered cells and, if the viewable set changed, hand the adapter an info
+// payload to fire. lastViewable folds back only when the fire actually lands, so a debounce
+// superseded mid-flight still diffs against the last COMMITTED set.
 // Extracted from commitList because 'record-interaction' needs the same pass: RN's
-// recordInteraction() ungates waitForInteraction and calls _updateViewableItems immediately
-// (VirtualizedList.js ~288-296). Leaving the pass inline meant a list that fits its viewport and is
-// never scrolled reported nothing at all after the interaction — the next commit that would have
-// carried the report never came.
+// recordInteraction() ungates waitForInteraction immediately, and leaving this inline meant a
+// never-scrolled list reported nothing after the interaction.
 function viewabilityEffects(state, inputs) {
     const m = state.metrics;
     if (inputs.viewabilityPairs.length === EMPTY_OFFSET ||
@@ -266,15 +248,10 @@ function commitList(state, inputs) {
 // target is past the last measured cell (RN VirtualizedList.js), else scroll to the resolved offset.
 function resolveScrollToIndex(state, inputs, action) {
     const m = state.metrics;
-    // Range check FIRST, mirroring RN VirtualizedList.js (~165-178) invariant-for-invariant. Three
-    // separate messages rather than one, because an empty list and an index past the end are
-    // different diagnoses. It has to precede the onScrollToIndexFailed branch below, or an
-    // out-of-range index on a list without getItemLayout would be reported as a MEASUREMENT problem
-    // and send the reader to inspect cell layout for what is a caller bug.
-    //
-    // Note this is the one place the range is enforced: offsetForIndex() still CLAMPS, and must, since
-    // scrollToEnd and initialScrollIndex resolve through it with indices that are legitimately at or
-    // past the edge.
+    // Range check FIRST: it must precede the onScrollToIndexFailed branch below, or an out-of-range
+    // index would be reported as a MEASUREMENT problem instead of a caller bug.
+    // The one place the range is enforced: offsetForIndex() still CLAMPS, since scrollToEnd and
+    // initialScrollIndex resolve through it with indices legitimately at or past the edge.
     const itemCount = inputs.getItemCount(inputs.data);
     if (action.index < FIRST_INDEX) {
         throw new Error(`scrollToIndex out of range: requested index ${action.index} but minimum is 0`);
@@ -313,10 +290,8 @@ function resolveScrollToIndex(state, inputs, action) {
 // an action, calls this, stores the returned state, and executes the returned effects.
 export function reduceList(state, action, inputs) {
     switch (action.kind) {
-        // Scalar transitions never recompute the window — they set the input and ask for a render; the
-        // metrics derive runs exactly ONCE per render, in the 'refresh-metrics' the adapter fires from
-        // its render body. That single-derive-per-render invariant is what advances the throttled
-        // committedWindow one step per frame (deriving here too would advance it twice).
+        // Scalar transitions never recompute the window — metrics derive runs exactly ONCE per
+        // render, in 'refresh-metrics', or committedWindow would advance twice per frame.
         case 'scroll':
             // First scroll is the interaction that ungates waitForInteraction viewability configs.
             state.hasInteracted = true;
@@ -338,10 +313,8 @@ export function reduceList(state, action, inputs) {
             const lengthSettled = isSettledLayout(knownLength, action.length);
             const offsetSettled = action.offset === undefined ||
                 isSettledLayout(knownOffset, action.offset);
-            // Settled means "the same measurement, re-reported" — an idle onLayout, or the float noise a
-            // relayout leaves behind. Bail WITHOUT storing: keeping the settled value byte-identical is
-            // the half that matters, because the spacer derived from it then stops moving too and the
-            // relayout loop has nothing left to feed on (see LAYOUT_EPSILON).
+            // Settled means the same measurement, re-reported. Bail WITHOUT storing: keeping the value
+            // byte-identical is what stops the spacer moving and starves the relayout loop.
             if (lengthSettled && offsetSettled)
                 return { state, effects: [], changed: false };
             // Each half is stored only if IT moved: a cell that slid without resizing must not have its

package/build/state/virtualized-list.js

@@ -1,39 +1,20 @@
-// VirtualizedList logic: the framework-agnostic windowing engine. Every adapter
-// (React hooks, Vue reactivity) drives the SAME math from here, so a windowing /
-// viewability / edge-reached bug is fixed once for all adapters. The adapter
-// supplies only its lifecycle (refs/state/effects), the imperative handle
-// wiring, and the per-cell element creation (createElement / h) - never the
-// geometry.
-//
-// What lives here:
-//   - the RN-matching defaults + sentinels,
-//   - the nativeEvent payload readers (scroll offset / layout length),
-//   - offset table + window computation + batch throttling,
-//   - viewability classification, the viewable-set diff, and the minimumViewTime fold,
-//   - the edge-reached (onEndReached / onStartReached) distance + threshold compute,
-//   - the assembled child PLAN (spacer extents, in-window cell keys, sticky child
-//     positions) the adapter maps onto its host elements,
-//   - the shared data + imperative-handle types.
-//
-// What stays in the adapter (genuinely framework-bound): the cell CONTENT is the
-// framework's own children (renderItem -> ReactNode / VNode), so there is no
-// Descriptor render fn for a list - the shared layer for lists is this STATE/logic
-// module, not a view/render-*.ts.
+// VirtualizedList logic: the framework-agnostic windowing engine every adapter drives the same
+// math from, so a windowing/viewability/edge-reached bug is fixed once for all. The adapter
+// supplies only its lifecycle, the imperative handle wiring, and per-cell element creation.
+// What stays in the adapter: the cell CONTENT is the framework's own children (renderItem ->
+// ReactNode / VNode), so there is no Descriptor render fn for a list — this state/logic module is
+// the shared layer, not a view/render-*.ts.
 import { dlog, Platform } 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). initialNumToRender bounds the first
-// paint before any layout is measured. maxToRenderPerBatch / batching period mirror
-// RN's incremental fill defaults.
+// Defaults match RN. windowSize is in viewport-lengths (21 => ten screens of buffer each side).
+// initialNumToRender bounds the first paint before any layout is measured.
 export const DEFAULT_WINDOW_SIZE = 21;
 export const DEFAULT_INITIAL_NUM_TO_RENDER = 10;
 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;
-// `_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.
+// RN's own fallback for whether to actually FIRE onEndReached/onStartReached when the app gives no
+// threshold — a flat 2 PIXELS, distinct from the windowing-only `?? 2` MULTIPLE elsewhere in RN;
+// conflating the two fires the callback two whole screens early.
 export const DEFAULT_EDGE_REACHED_THRESHOLD_PX = 2;
 export const FIRST_INDEX = 0;
 export const EMPTY_OFFSET = 0;
@@ -45,10 +26,8 @@ export const ON_EDGE_REACHED_EPSILON = 0.001;
 // Sentinel for "onEndReached / onStartReached has not fired for any content length
 // yet". Real content lengths are >= 0, so -1 can never collide with one.
 export const NO_CONTENT_LENGTH_SENT = -1;
-// Inversion flips the content container along the scroll axis; each cell re-flips so
-// its own content stays upright. VirtualizedList.js `styles.verticallyInverted`: Android flips
-// with `scale: -1` because `scaleY: -1` can ANR on API 33+ (react-native#35350); the native side
-// then moves the scrollbar back via `isInvertedVirtualizedList`.
+// Inversion flips the content container along the scroll axis; each cell re-flips so its own
+// content stays upright. Android flips with `scale: -1` since `scaleY: -1` can ANR on API 33+.
 export function invertedYStyleFor(os) {
     return os === 'android'
         ? { transform: [{ scale: -1 }] }
@@ -74,10 +53,8 @@ export function readScrollOffset(event, horizontal) {
         return undefined;
     return readNumber(offset, horizontal ? 'x' : 'y');
 }
-// The cell's own position inside the scroll content, as the host reported it. Paired with
-// readLayoutLength at the same onLayout: this is the value buildOffsets stores VERBATIM, and it is
-// what lets the table describe where the content actually is rather than where a sum of heights
-// says it should be.
+// The cell's own position in the scroll content, as the host reported it — the value buildOffsets
+// stores VERBATIM, so the table describes where content actually is, not a sum of heights.
 export function readLayoutOffset(event, horizontal) {
     const native = asRecord(event.nativeEvent);
     if (native === undefined)
@@ -96,43 +73,19 @@ export function readLayoutLength(event, horizontal) {
         return undefined;
     return readNumber(layout, horizontal ? 'width' : 'height');
 }
-// Resolve every cell offset/length from the cache (or getItemLayout), filling gaps with
-// the running average so an unmeasured tail still has a plausible total. Returns the
-// per-index offset table plus the grand total extent.
-//
-// THE COORDINATE SPACE IS THE HOST'S, NOT A MODEL'S. `measuredOffsets` holds each cell's raw y (x
-// when horizontal) exactly as onLayout reported it — content-container relative, so it carries the
-// container's padding, the list header, and whatever spacer stood above the cell at the time. A
-// measured cell is placed at that value VERBATIM. It is never re-derived from a neighbour, never
-// rebased onto a running sum. This is react-native's ListMetricsAggregator: `getCellMetricsApprox`
-// returns a laid-out cell's real frame untouched and approximates only what has never been seen.
-//
-// That "verbatim" is the whole safety property, and it is not a stylistic preference — it is the
-// fix for the canary going blank mid-scroll (diagnosed on device 2026-08-19). The table is not
-// merely an output: buildListPlan sizes the leading spacer from it, the host lays the window's
-// cells out below that spacer, and their measured y — spacer included — comes straight back in
-// here. It is a closed loop. Combining two measurements arithmetically inside that loop feeds the
-// model's own error back to itself: with a Yoga `gap` on the content container (the canary's .grid
-// has one) a spacer is an extra flex child, so its presence shifts the layout by one more gap than
-// any pure-arithmetic model predicts, and differencing two cells measured either side of that
-// change banks the difference. Measured, at one gap per recompute, unbounded — onScroll fires per
-// frame, so the spacer walks thousands of pixels away from reality within a second of dragging and
-// the window lands nowhere near the viewport. Regression test:
-// core/components/src/state/virtualized-list-feedback.test.ts.
-//
-// Unmeasured cells are the only place an estimate lives, and they advance by the average STRIDE
-// (measured cell-origin to cell-origin) rather than by the average LENGTH. A height is not the
-// distance to the next cell: separators, section gaps and container `gap` all live in between, and
-// sizing an unmeasured region by heights alone leaves it short by exactly that chrome.
-//
-// A fixed getItemLayout skips all of it — authoritative by contract, and its offsets are exact.
+// Resolve every cell offset/length from the cache (or getItemLayout), filling gaps with the
+// running average so an unmeasured tail still has a plausible total.
+// The coordinate space is the HOST's, not a model's: a measured cell is placed at onLayout's raw
+// value VERBATIM, never rebased onto a running sum — differencing two measurements would compound
+// a Yoga `gap` shift unboundedly once buildListPlan feeds a sized spacer back through this table.
+// Unmeasured cells advance by the average STRIDE (origin to origin), not the average LENGTH —
+// separators/gaps live between cells, so heights alone fall short. A fixed getItemLayout skips
+// all of it, authoritative by contract.
 export function buildOffsets(count, measured, measuredOffsets, fixedLayout, averageLength, averageStride) {
     const offsets = new Array(count);
     const lengths = new Array(count);
-    // What the average stride has left over once the average cell is accounted for: the chrome drawn
-    // BETWEEN two cells. Estimating with this rather than the stride itself keeps a cell whose own
-    // length IS known from being overwritten by an average — the stride is only ever used for the
-    // part nobody measured.
+    // What the average stride leaves over once the average cell is accounted for: the chrome drawn
+    // BETWEEN two cells, used only for the part nobody measured.
     const interCellChrome = Math.max(EMPTY_OFFSET, averageStride - averageLength);
     // Where the next cell goes when its own position has never been reported.
     let cursor = EMPTY_OFFSET;
@@ -180,14 +133,10 @@ export function initialRenderRegion(count, initialScrollIndex, initialNumToRende
     return { first, last: Math.min(count, first + initialNumToRender) - 1 };
 }
 // Clamp a freshly computed window against the previously-committed one so at most
-// maxToRenderPerBatch new cells are added on each side per tick (RN's incremental fill).
-// The window grows toward the target over successive batch ticks rather than snapping in
-// one render: cheaper first paint on a big jump.
-//
-// With NO previous window - the list just received data - RN paints its initial region and grows
-// from there (`_createRenderMask` adds `_initialRenderRegion` to a window constrained from empty),
-// even when the viewport is already known. Snapping to the target instead mounted ~125 rows where
-// RN mounts 10 on a 420pt viewport (`stock-virtualized-suite.itest.tsx`).
+// maxToRenderPerBatch new cells are added on each side per tick — the window grows toward the
+// target over successive ticks rather than snapping in one render.
+// With NO previous window, RN paints its initial region and grows from there even when the
+// viewport is already known; snapping to the target instead mounts far more rows than RN would.
 export function throttleWindow(target, previous, maxToRenderPerBatch, initialRegion) {
     if (previous.last < previous.first)
         return initialRegion.last < initialRegion.first ? target : initialRegion;
@@ -198,12 +147,9 @@ export function throttleWindow(target, previous, maxToRenderPerBatch, initialReg
         return target;
     return { first, last };
 }
-// 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.
+// A cell is viewable when its visible fraction clears the configured threshold. Two percents exist
+// and are NOT interchangeable: viewAreaCoveragePercentThreshold is a fraction of the VIEWPORT,
+// itemVisiblePercentThreshold a fraction of the CELL's own length. Area wins whenever set.
 export function isCellViewable(cellOffset, cellLength, scrollOffset, viewportLength, config) {
     const top = cellOffset - scrollOffset;
     const bottom = top + cellLength;
@@ -212,10 +158,8 @@ export function isCellViewable(cellOffset, cellLength, scrollOffset, viewportLen
     // 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.
+    // Fully inside the viewport is viewable in EITHER mode, or an area threshold sized to the
+    // viewport could reject every fully-visible cell smaller than that share.
     if (top >= EMPTY_OFFSET && bottom <= viewportLength && bottom > top) {
         return true;
     }
@@ -242,18 +186,9 @@ export function offsetForIndex(index, viewPosition, viewOffset, count, offsets,
     const positioned = cellOffset - viewPosition * (viewportLength - cellLength);
     return Math.max(EMPTY_OFFSET, positioned - viewOffset);
 }
-// Two layout readings are the SAME measurement unless they differ by more than this.
-//
-// A relayout does not reproduce a float bit-for-bit: the cell positions are derived from a spacer
-// height that is itself a float, so an onLayout that changed nothing observable still comes back a
-// few ulps off. Compared with ===, every one of those counts as a change — the reducer stores it,
-// the spacer derived from it moves in its last bits, Fabric commits the new value, Yoga relays out,
-// and the fresh onLayout starts the next turn. A loop at frame rate, from a difference no screen
-// can show. Device-measured 2026-08-19: 1203 recomputes over one short drag, its log full of
-// `27.33 -> 27.33 (-0.00)`.
-//
-// The smallest change a host can actually express is one device pixel — a third of a point at @3x —
-// so this sits ~30x below any real move and ~1e11 above the noise.
+// Two layout readings are the SAME measurement unless they differ by more than this — a relayout
+// doesn't reproduce a float bit-for-bit, so comparing with === loops at frame rate on noise no
+// screen can show. One device pixel (a third of a point at @3x) sits far above that noise.
 export const LAYOUT_EPSILON = 0.01;
 // `known` is optional because a first measurement has nothing to settle against, and must count as
 // a change.
@@ -270,15 +205,12 @@ export function averageMeasuredLength(measured) {
         sum += length;
     return sum / measured.size;
 }
-// Average origin-to-origin distance between two ADJACENT measured cells — the length plus whatever
-// chrome the list draws in the gap (a separator, a section gap, the content container's Yoga
-// `gap`). Only adjacent pairs qualify: across a hole the distance covers cells nobody measured.
-//
-// This is what an unmeasured cell advances by, and it is deliberately not averageMeasuredLength.
-// Sizing an unmeasured region by heights alone makes the model shorter than the content, so the
-// spacer standing in for that region under-reserves and everything below it slides up — the
-// jump-and-return the canary showed before the offsets became host-absolute. Falls back to the
-// length average while no adjacent pair has been measured yet.
+// Average origin-to-origin distance between two ADJACENT measured cells — length plus whatever
+// chrome the list draws in the gap. Only adjacent pairs qualify: across a hole the distance
+// covers cells nobody measured.
+// Deliberately not averageMeasuredLength: sizing an unmeasured region by heights alone makes the
+// model shorter than the content, so its spacer under-reserves and everything below slides up.
+// Falls back to the length average while no adjacent pair has been measured yet.
 export function averageMeasuredStride(measuredOffsets, fallback) {
     let sum = EMPTY_OFFSET;
     let pairs = EMPTY_OFFSET;
@@ -301,13 +233,10 @@ export function highestMeasuredIndex(measured) {
     }
     return highest;
 }
-// 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.
+// onEndReached distance + threshold test. 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` undefined means the app gave no onEndReachedThreshold — RN's own answer
+// is a flat DEFAULT_EDGE_REACHED_THRESHOLD_PX, never a viewport-length multiple.
 export function computeEndReached(total, scrollOffset, viewportLength, thresholdMultiplier) {
     let distanceFromEnd = total - (scrollOffset + viewportLength);
     if (distanceFromEnd < ON_EDGE_REACHED_EPSILON)
@@ -368,10 +297,8 @@ export function computeViewableSet(params) {
     }
     return { tokens, map };
 }
-// The `changed` delta between two viewable sets: newly viewable (true) and newly hidden
-// (false). hasChanged is false when the viewable KEY set is identical, so the adapter can
-// skip firing (RN dedups the same way). Hidden tokens come straight from the previous map,
-// so no rescan of all N items.
+// The `changed` delta between two viewable sets: newly viewable (true) and newly hidden (false).
+// hasChanged is false when the viewable KEY set is identical, so the adapter can skip firing.
 export function diffViewable(previous, current, currentTokens) {
     let hasChanged = previous.size !== current.size;
     if (!hasChanged) {
@@ -416,11 +343,9 @@ function findClosestStickyIndexBelow(first, stickyIndices) {
     }
     return NO_INDEX;
 }
-// Compute the windowed child PLAN: the spacer extents, the in-window cells (index + key),
-// the force-mounted sticky cell (if any) ahead of the window, and the sticky child
-// positions. The adapter walks this plan and creates the host elements (createElement / h)
-// plus the framework cell content. This is the shared half of the render; only the element
-// creation and the user's renderItem stay per-adapter.
+// Compute the windowed child PLAN: spacer extents, in-window cells, the force-mounted sticky cell
+// (if any), and sticky child positions. The adapter walks this and creates the host elements;
+// only element creation and the user's renderItem stay per-adapter.
 export function buildListPlan(params) {
     const cells = [];
     const closestStickyIndex = params.stickyIndices !== undefined
@@ -429,14 +354,9 @@ export function buildListPlan(params) {
     const forcedStickyCell = closestStickyIndex === NO_INDEX
         ? undefined
         : { index: closestStickyIndex, key: params.keyFor(closestStickyIndex) };
-    // A spacer stands in for a contiguous run of cells, so its extent is the distance from the first
-    // of them to the far edge of the last — a difference between two positions the host itself
-    // reported, never a sum of heights. That is what carries the chrome BETWEEN those cells
-    // (separators, section gaps, the container's Yoga `gap`) without the model having to know it
-    // exists, and it is why the spacer lands the following cell exactly where it already was: the
-    // spacer occupies one child slot, precisely as the region it replaces began and ended on a cell
-    // boundary. Summing heights instead under-reserves by the chrome; rebasing onto a running model
-    // re-introduces the feedback loop buildOffsets exists to avoid.
+    // A spacer's extent is the distance from the first cell it replaces to the far edge of the
+    // last — a difference between two host-reported positions, never a sum of heights, so the next
+    // cell lands exactly where it was. Rebasing would reintroduce buildOffsets' feedback loop.
     const regionExtent = (from, to) => to < from
         ? EMPTY_OFFSET
         : params.offsets[to] + params.lengths[to] - params.offsets[from];
@@ -451,11 +371,9 @@ export function buildListPlan(params) {
         ? params.total - params.offsets[params.last + 1]
         : EMPTY_OFFSET;
     const stickyChildPositions = [];
-    // The header (when present) is child 0; the leading spacer (when non-empty) is the next
-    // child; the forced sticky cell (when present) plus its own gap spacer follow. Each cell is
-    // EXACTLY one child — an ItemSeparatorComponent rides INSIDE the cell's own measuring wrapper
-    // (RN VirtualizedListCellRenderer.js:218-221), so it neither shifts these positions nor shows
-    // up in the geometry as chrome the spacers would have to account for separately.
+    // The header (when present) is child 0; the leading spacer is the next child; the forced sticky
+    // cell plus its own gap spacer follow. Each cell is EXACTLY one child — an ItemSeparatorComponent
+    // rides INSIDE the cell's own measuring wrapper, so it never shifts these positions.
     let childPosition = (params.hasHeader ? 1 : 0) + (leadingExtent > EMPTY_OFFSET ? 1 : 0);
     if (forcedStickyCell !== undefined) {
         stickyChildPositions.push(childPosition);
@@ -526,10 +444,8 @@ export function computeMvcpAdjustment(params) {
         action: { kind: 'shift', offset: params.scrollOffset + insertedExtent },
     };
 }
-// 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.
+// RN's real default: an object item's own `key`, else its `id`, else the index. Most apps rely on
+// this to keep list identity stable across inserts/removes — the index alone breaks on a swap.
 export function defaultKeyExtractor(item, index) {
     if (typeof item === 'object' && item !== null) {
         const record = item;
@@ -564,10 +480,9 @@ export function offsetForEnd(total, viewportLength) {
 export function isSeparatorGapInRange(gapIndex, count) {
     return gapIndex >= FIRST_INDEX && gapIndex <= count - 2;
 }
-// onEndReached / onStartReached fire decision + content-length dedup (RN _maybeCallOnEdgeReached).
-// The geometry (withinThreshold) comes from computeEndReached/computeStartReached; this folds in the
-// "edge cell actually rendered" gate, the dedup against the last-fired content length, and the
-// re-arm once scrolled away from the edge. Returns whether to fire plus the next dedup sentinel.
+// onEndReached / onStartReached fire decision + content-length dedup. The geometry comes from
+// computeEndReached/computeStartReached; this folds in the "edge cell rendered" gate and the
+// dedup against the last-fired content length.
 export function decideEdgeReached(params) {
     const { withinThreshold, edgeCellRendered, total, sentForContentLength } = params;
     if (withinThreshold && edgeCellRendered && sentForContentLength !== total) {

package/build/text-props.js

@@ -1,14 +1,4 @@
-// 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.
+// The ellipsize modes a Text accepts. The defaults are the platform's — `foldTextDefaults` in
+// `SymbioteFabricProps.cpp` — reaching every `RCTText` whoever authored it. Declaring both props
+// with neither defaulted silently falls back to native's own `clip`: no error, just wrong text.
 export {};

package/build/view/render-button.js

@@ -4,63 +4,23 @@
 //
 // 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.
+// button with an uppercased label — lives entirely on that node.
 //
 // 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`.
+// `BUTTON_ACCESSIBILITY_ROLE`, `resolveButtonImportantForAccessibility`, and the Android style
+// constants are `foldButtonProps`/`foldButtonLabelStyle` in `SymbioteFabricProps.cpp` now — no JS
+// mirror is kept here to avoid a rule with no caller staying green for the wrong reason.
+// `foldButtonLabelStyle` reaches the label's style off its own tag via `IAncestorLookup` —
+// needed because the label is the button's GRANDCHILD on iOS but its CHILD on Android, so
+// `ownerProps` (nearest parent) can't reach it either way.
+// The Material look (`foldButtonProps`, `SymbioteFabricProps.cpp`, `#ifdef ANDROID`) — style,
+// `color` override, disabled greying — is asserted against the COMMITTED PAYLOAD in
+// `android-rules.itest.ts`, not a JS unit test mocking `Platform.OS`.
+// The uppercase-on-Android rule is `foldButtonLabel` in `SymbioteFabricProps.cpp`. Untested here
+// (this host isn't Android, and raw text has no view NAME for a rule to branch on). Deliberate
+// divergence: RN uppercases via full-Unicode `toUpperCase`, the C++ rule is ASCII-only.
 /**
  * Whether the button is disabled, which `aria-disabled` may decide on its own.
  *

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

@@ -4,28 +4,12 @@
 // the two by id. There is no JS-side translation — style / nativeID / backgroundColor map straight
 // onto the intrinsic.
 //
-// THE MAPPING FUNCTION IS GONE (2026-09-18) and only the type is left, which is the honest residue:
-// `mapInputAccessoryViewProps` took the bag apart and put it back together unchanged, so the
-// behavior stopped calling it and nothing else ever did. Angular still names the type for its
-// `@Input()` declarations (`adapters/angular/src/elements.ts`), so the shape stays; the fold does
-// not. Why it was never a rule, and the numeric `backgroundColor` it used to drop:
-// `core/components/src/behaviors/input-accessory-view.ts`.
+// THE MAPPING FUNCTION IS GONE — only the type is left: `mapInputAccessoryViewProps` took the bag
+// apart and put it back unchanged, so nothing calls it any more. Angular still names the type for
+// its `@Input()` declarations (`adapters/angular/src/elements.ts`); the fold does not exist.
 export {};
-// WHAT THE DELETED FOLD KNEW THAT THIS FILE NO LONGER HAS TO, kept because the trap is a property
-// of the engine and outlives the function that hit it. The `undefined` guards on `nativeID` /
-// `backgroundColor` were LOAD-BEARING, and not for the reason they look it:
-//
-//   authored <input-accessory-view id="p" testID="p">
-//   guarded    RCTInputAccessoryView{testID, nativeID:"p"}
-//   unguarded  RCTInputAccessoryView{testID}              <- the alias result, deleted
-//
-// `setProp` collapses an undefined value to an absent key, so a conditional write is normally
-// cosmetic (`.claude/rules/fabric-boolean-event-gates.md`) — it is destructive precisely when the
-// key has an ALIAS SOURCE. `id` arrives, something renames it to `nativeID`, and a
-// `nativeID: undefined` written afterwards deletes what the rename just produced. Removing the
-// guards on that reasoning cost a day on 2026-09-01.
-//
-// It cannot recur here, and that is the point: the rename is `foldIdAlias` in
-// `SymbioteFabricProps.cpp` now, one rule at the end of the payload build with nothing downstream
-// of it to overwrite the result. Anything that reintroduces a JS-side alias for this tag
-// reintroduces the trap with it.
+// WHAT THE DELETED FOLD KNEW: the `undefined` guards on `nativeID`/`backgroundColor` were
+// load-bearing because `nativeID` has an ALIAS SOURCE (`id`) — `setProp` collapsing undefined to
+// an absent key is normally cosmetic, but here it would delete what the alias fold just produced.
+// It cannot recur here: the rename is `foldIdAlias` in `SymbioteFabricProps.cpp`, the LAST rule
+// in the payload build with nothing downstream to overwrite it.

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

@@ -12,10 +12,9 @@ export function resolveDisabledAccessibilityState(accessibilityState, disabled)
         ? { ...accessibilityState, disabled }
         : accessibilityState;
 }
-// RN computes `focusable` in all five touchables and we computed it nowhere until 2026-09-09, so a
-// DISABLED control stayed focusable — a keyboard, a TV remote or switch control could land on
-// something that cannot be pressed. There are TWO formulas, split by primitive and not by platform;
-// do not collapse them.
+// RN computes `focusable` in all five touchables; without it a DISABLED control stays focusable —
+// a keyboard, TV remote or switch control could land on something that cannot be pressed. There
+// are TWO formulas, split by primitive and not by platform; do not collapse them.
 //
 // Pressable defaults it ON (Pressable.js:258). `!== false`, not `?? true`: only a literal `false`
 // opts out, the same shape `accessible` uses one file over.