@symbiote-native/engine 0.3.0 → 0.5.0

package/build/debug.js

@@ -12,11 +12,17 @@
 // logging off. On a hot path (a getter Angular re-reads every change-detection
 // pass, an Animated reconcile, a scroll-driven apply) pass a THUNK instead:
 // `dlog(() => \`…\`)` - it is only called once the switch is on.
-function envEnabled() {
-    return typeof process !== 'undefined' && process.env.DEBUG === '1';
-}
+// Read ONCE, at module load. `process.env` is not a plain object in Node - each property read
+// crosses into the host environment - and isDebug() is called on the per-node commit path, so the
+// per-call read showed up as 17% of self time in a create-path CPU profile (headless; on a native
+// host `process` is a shim and the read is cheap, so treat that figure as a Node one).
+//
+// Safe to freeze because nothing toggles the ENV switch mid-process: every runtime toggle in the
+// repo goes through __SYMBIOTE_DEBUG__ below, which stays dynamic, and bootstrap mirrors the env
+// onto it at start anyway.
+const envDebug = typeof process !== 'undefined' && process.env.DEBUG === '1';
 export function isDebug() {
-    return globalThis.__SYMBIOTE_DEBUG__ === true || envEnabled();
+    return envDebug || globalThis.__SYMBIOTE_DEBUG__ === true;
 }
 export function dlog(message) {
     if (!isDebug())

package/build/events/index.js

@@ -8,7 +8,7 @@
 import { dlog } from '../debug.js';
 import { runWrapped } from '../dispatch.js';
 import { getSlot } from '../fabric.js';
-import { isAnchor, isSymbioteNode, } from '../node.js';
+import { committedOf, isAnchor, isSymbioteNode, } from '../node.js';
 import { registeredNativeEvent } from '../registry.js';
 import { attachTouchHistory, recordTouchTrack, resetTouchHistory, touchHistory, } from '../touch-history.js';
 import { isRecord } from '../type-guards.js';
@@ -92,32 +92,34 @@ const DEFAULT_LONG_PRESS_MS = 500;
 // points from where it started (Pressability.DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE).
 const LONG_PRESS_DEACTIVATION_DISTANCE = 10;
 let installed = false;
-// Target of the in-flight touch, remembered at topTouchStart and consumed (or
-// cleared) at topTouchEnd / topTouchCancel.
-let pressStart;
+// Each unrelated target owns an independent press. Additional fingers under the same owner join
+// that press, so one target still receives exactly one pressIn/press/pressOut lifecycle.
+const activePresses = new Set();
 // The node that claimed the responder for the in-flight touch (PanResponder), or
 // undefined when nobody claimed it. Receives move and release/terminate.
 let currentResponder;
-// Long-press synthesis: armed at touch start when some node in the press path listens
-// for it, fired once after the hold delay, disarmed on end/cancel; the same arm/clear
-// lifecycle Pressable runs in JS. Pressability ALSO cancels the timer when the touch
-// drifts past LONG_PRESS_DEACTIVATION_DISTANCE, so we record the start point at touch
-// start and clear the timer on a move that exceeds it.
-let longPressTimer;
-let longPressFired = false;
-// Touch coordinate at touch start (pageX/pageY), or undefined when the native event
-// carried no coords; then the move-distance cancel is simply skipped.
-let longPressStart;
-function clearLongPress() {
-    if (longPressTimer !== undefined) {
-        clearTimeout(longPressTimer);
-        longPressTimer = undefined;
+function clearLongPress(press) {
+    if (press.longPressTimer !== undefined) {
+        clearTimeout(press.longPressTimer);
+        press.longPressTimer = undefined;
     }
 }
-// Read the gesture's page coordinate from a raw native touch event, defensively: RN
-// puts pageX/pageY on the event for a single touch, or on the first entry of a
-// `touches` array for multi-touch. Returns undefined when neither shape carries
-// numbers, so callers skip any coordinate-dependent logic rather than guess.
+function takeAllPresses() {
+    const presses = [...activePresses];
+    activePresses.clear();
+    for (const press of presses)
+        clearLongPress(press);
+    return presses;
+}
+function findActivePress(target) {
+    for (const press of activePresses) {
+        if (endsWithin(target, press.owner))
+            return press;
+    }
+    return undefined;
+}
+// Read the changed finger's page coordinate from a raw native touch event, falling back to the
+// active-touch list and then undefined. Callers skip coordinate-dependent logic rather than guess.
 function readTouchPoint(nativeEvent) {
     const fromPair = (source) => {
         if (!source)
@@ -130,21 +132,27 @@ function readTouchPoint(nativeEvent) {
     const direct = fromPair(nativeEvent);
     if (direct)
         return direct;
-    const touches = nativeEvent.touches;
-    if (Array.isArray(touches)) {
-        const first = touches[0];
-        if (isRecord(first))
-            return fromPair(first);
+    // `changedTouches` identifies the finger for this frame. Read it before the full active-touch
+    // list, whose first entry may belong to another simultaneously pressed target.
+    for (const key of ['changedTouches', 'touches']) {
+        const touches = nativeEvent[key];
+        if (!Array.isArray(touches))
+            continue;
+        for (const touch of touches) {
+            if (!isRecord(touch))
+                continue;
+            const point = fromPair(touch);
+            if (point)
+                return point;
+        }
     }
     return undefined;
 }
-// Whether any touch still down started inside the responder (its target IS the
-// responder or a descendant). RN's noResponderTouches walks nativeEvent.touches and
-// returns false the moment one is found; a release fires only when none remain. The
-// headless smokes fire with an empty `{}` event (no `touches`) -> no remaining touch ->
-// release fires, preserving single-touch behavior. (ResponderEventPlugin.noResponder-
-// Touches + isAncestor.)
-function hasRemainingResponderTouch(responder, nativeEvent) {
+// Whether any touch still down started inside an owner (its target IS the owner or a descendant).
+// RN's noResponderTouches walks nativeEvent.touches and returns false the moment one is found; a
+// responder release and our synthesized press completion both wait until none remain. The headless
+// smokes fire with an empty `{}` event -> no remaining touch -> preserve single-touch behavior.
+function hasRemainingTouchWithin(owner, nativeEvent) {
     const touches = nativeEvent.touches;
     if (!Array.isArray(touches))
         return false;
@@ -152,7 +160,7 @@ function hasRemainingResponderTouch(responder, nativeEvent) {
         if (!isRecord(touch))
             continue;
         const target = touch.target;
-        if (isSymbioteNode(target) && endsWithin(target, responder))
+        if (isSymbioteNode(target) && endsWithin(target, owner))
             return true;
     }
     return false;
@@ -240,6 +248,34 @@ function findWantsResponder(path, captureName, bubbleName, nativeEvent, skip) {
     }
     return undefined;
 }
+// Tell native which node owns the gesture, RN's `injectGlobalResponderHandler`
+// (ReactFabric-dev.js:18862) — the OLD owner first, then the new one, both in one call so no
+// site can do half of it.
+//
+// WITHOUT THIS A JS RESPONDER LOSES TO ANY SCROLL VIEW ABOVE IT, and it is invisible from JS:
+// `onStartShouldSetResponder` returns true, the native UIScrollView never learns the gesture was
+// claimed, and every subsequent move arrives as `topScroll` instead of `topTouchMove` — so the
+// negotiation never even gets a move to grant on. Device-diagnosed 2026-09-08 on a PanResponder
+// drag box inside the canary's ScrollView: `startShouldSet -> true` followed by
+// `topScrollBeginDrag` and twenty `topScroll`, with no grant and no move.
+//
+// `blockNativeResponder` is the taker's own `onResponderGrant` return, exactly as RN reads it.
+function handOverNativeResponder(from, to, blockNativeResponder) {
+    const slot = getSlot();
+    const fromHandle = from === undefined ? undefined : committedOf(from)?.handle;
+    const toHandle = to === undefined ? undefined : committedOf(to)?.handle;
+    dlog(`setIsJSResponder from=${from === undefined ? 'none' : fromHandle === undefined ? 'UNCOMMITTED' : 'yes'} ` +
+        `to=${to === undefined ? 'none' : toHandle === undefined ? 'UNCOMMITTED' : 'yes'} block=${blockNativeResponder}`);
+    if (fromHandle !== undefined)
+        slot.setIsJSResponder(fromHandle, false, blockNativeResponder);
+    if (toHandle !== undefined)
+        slot.setIsJSResponder(toHandle, true, blockNativeResponder);
+}
+// Whether the taker asked native to stand down. RN reads this off the grant dispatch's return;
+// an absent listener means no claim, which is RN's `blockNativeResponder || false`.
+function blocksNative(result) {
+    return result === true;
+}
 // Negotiate (or re-negotiate) the responder for a touch start/move. If nobody holds
 // it, the winner is granted. If someone does, the incumbent is asked to relinquish
 // via onResponderTerminationRequest (absent listener = implicit yes); on yes it is
@@ -260,12 +296,21 @@ function negotiateResponder(target, phase, nativeEvent) {
     const wants = phase === 'start'
         ? findWantsResponder(path, START_SHOULD_SET_CAPTURE, START_SHOULD_SET, nativeEvent, skip)
         : findWantsResponder(path, MOVE_SHOULD_SET_CAPTURE, MOVE_SHOULD_SET, nativeEvent, skip);
-    if (!wants || wants === currentResponder)
+    // Every exit is logged: a negotiation that declines is indistinguishable from one that never
+    // ran, and the two have opposite causes.
+    if (!wants) {
+        dlog(`responder ${phase}: nobody wants it (path=${path.length}${skip === undefined ? '' : ', one skipped'})`);
         return;
+    }
+    if (wants === currentResponder) {
+        dlog(`responder ${phase}: ${wants.component} already holds it`);
+        return;
+    }
     if (currentResponder === undefined) {
         currentResponder = wants;
         dlog(`responder granted to ${wants.component}`);
-        callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
+        const granted = callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
+        handOverNativeResponder(undefined, wants, blocksNative(granted));
         return;
     }
     const incumbent = currentResponder;
@@ -284,9 +329,10 @@ function negotiateResponder(target, phase, nativeEvent) {
         // before terminate on the consent path (matching RN's grant<terminate ordering) and
         // omit it on reject; the consent OUTCOME is unchanged either way.
         dlog(`responder transferred ${incumbent.component} -> ${wants.component}`);
-        callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
+        const granted = callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
         callOwnListener(incumbent, RESPONDER_TERMINATE, nativeEvent);
         currentResponder = wants;
+        handOverNativeResponder(incumbent, wants, blocksNative(granted));
     }
     else {
         dlog(`responder takeover of ${incumbent.component} rejected`);
@@ -301,28 +347,46 @@ export function installEventHandler() {
         if (!isSymbioteNode(instanceHandle))
             return;
         if (topLevelType === TOUCH_START) {
-            dlog(`event ${TOUCH_START}`);
+            dlog(`event ${TOUCH_START} on ${isSymbioteNode(instanceHandle) ? instanceHandle.component : 'NON-NODE'}`);
             // Update the touch bank, then attach it so responder handlers (PanResponder)
             // read each touch's own previous->current delta; RN records before dispatch.
             recordTouchTrack('start', nativeEvent);
             attachTouchHistory(nativeEvent);
-            pressStart = instanceHandle;
-            // Arm long-press synthesis: only when a listener exists in the path, fired once
-            // after the hold delay, then suppresses the tap (longPressFired) on release.
-            longPressFired = false;
-            clearLongPress();
-            longPressStart = readTouchPoint(nativeEvent);
-            if (hasListenerInPath(instanceHandle, LONG_PRESS)) {
-                const longPressTarget = instanceHandle;
-                longPressTimer = setTimeout(() => {
-                    longPressTimer = undefined;
-                    longPressFired = true;
-                    dlog('synthesized longPress -> dispatch');
-                    runWrapped(() => bubble(longPressTarget, LONG_PRESS, nativeEvent));
-                }, DEFAULT_LONG_PRESS_MS);
+            const canJoinExistingPress = Array.isArray(nativeEvent.touches) && nativeEvent.touches.length > 1;
+            const joinedPress = canJoinExistingPress
+                ? findActivePress(instanceHandle)
+                : undefined;
+            // A one-touch or identifier-less frame starts a new physical gesture. Any surviving press
+            // is stale (its end/cancel was lost), so release it instead of letting it suppress this start.
+            const stalePresses = canJoinExistingPress ? [] : takeAllPresses();
+            let startedPress;
+            if (joinedPress === undefined) {
+                startedPress = {
+                    owner: instanceHandle,
+                    longPressTimer: undefined,
+                    longPressFired: false,
+                    longPressStart: readTouchPoint(nativeEvent),
+                };
+                activePresses.add(startedPress);
+                if (hasListenerInPath(instanceHandle, LONG_PRESS)) {
+                    const press = startedPress;
+                    press.longPressTimer = setTimeout(() => {
+                        if (!activePresses.has(press))
+                            return;
+                        press.longPressTimer = undefined;
+                        press.longPressFired = true;
+                        dlog('synthesized longPress -> dispatch');
+                        runWrapped(() => bubble(press.owner, LONG_PRESS, nativeEvent));
+                    }, DEFAULT_LONG_PRESS_MS);
+                }
             }
             runWrapped(() => {
-                bubble(instanceHandle, PRESS_IN, nativeEvent);
+                for (const stale of stalePresses)
+                    bubble(stale.owner, PRESS_OUT, nativeEvent);
+                if (startedPress)
+                    bubble(startedPress.owner, PRESS_IN, nativeEvent);
+                else
+                    dlog('pressIn retained (another touch joined the active press)');
                 // Responder negotiation runs alongside press synthesis: a View can be both
                 // a Pressable (press) and a PanResponder target (responder).
                 negotiateResponder(instanceHandle, 'start', nativeEvent);
@@ -335,16 +399,18 @@ export function installEventHandler() {
         if (topLevelType === TOUCH_MOVE) {
             recordTouchTrack('move', nativeEvent);
             attachTouchHistory(nativeEvent);
-            // Cancel the pending long press if the touch drifted too far (Pressability's
-            // deactivation-distance check). Skipped when either coord is unknown.
-            if (longPressTimer !== undefined && longPressStart) {
+            // Only the press owning this move can lose its long-press timer; movement on an unrelated
+            // simultaneously held Pressable must not disturb another target's clock.
+            const movedPress = findActivePress(instanceHandle);
+            if (movedPress?.longPressTimer !== undefined &&
+                movedPress.longPressStart) {
                 const here = readTouchPoint(nativeEvent);
                 if (here) {
-                    const dx = here.x - longPressStart.x;
-                    const dy = here.y - longPressStart.y;
+                    const dx = here.x - movedPress.longPressStart.x;
+                    const dy = here.y - movedPress.longPressStart.y;
                     if (Math.hypot(dx, dy) > LONG_PRESS_DEACTIVATION_DISTANCE) {
                         dlog('longPress cancelled (moved past deactivation distance)');
-                        clearLongPress();
+                        clearLongPress(movedPress);
                     }
                 }
             }
@@ -361,46 +427,53 @@ export function installEventHandler() {
         if (topLevelType === TOUCH_END) {
             recordTouchTrack('end', nativeEvent);
             attachTouchHistory(nativeEvent);
-            const start = pressStart;
-            pressStart = undefined;
+            const hadActivePress = activePresses.size > 0;
+            const completedPresses = [];
+            for (const press of activePresses) {
+                if (hasRemainingTouchWithin(press.owner, nativeEvent))
+                    continue;
+                activePresses.delete(press);
+                clearLongPress(press);
+                completedPresses.push(press);
+            }
             const responder = currentResponder;
             // RN releases (and clears) the responder only when no remaining touch still down
             // started inside it; lifting ONE finger in a multi-touch gesture must NOT release.
             // onResponderEnd still fires on every finger-up. (ResponderEventPlugin: responderEnd
             // is unconditional, responderRelease is gated on noResponderTouches.)
             const releases = responder !== undefined &&
-                !hasRemainingResponderTouch(responder, nativeEvent);
+                !hasRemainingTouchWithin(responder, nativeEvent);
             if (releases)
                 currentResponder = undefined;
-            // A completed long press eats the tap (RN), but pressOut still fires below.
-            const wasLongPress = longPressFired;
-            longPressFired = false;
-            longPressStart = undefined;
-            clearLongPress();
             runWrapped(() => {
-                if (start) {
-                    // press fires only on an honest tap (ended within the responder); pressOut
-                    // always fires on the responder so its pressed-state can release.
-                    if (endsWithin(instanceHandle, start)) {
-                        if (wasLongPress) {
+                for (const press of completedPresses) {
+                    // Each target completes independently. An honest tap ends inside that target; pressOut
+                    // always releases its pressed state, including a drag-away end.
+                    if (endsWithin(instanceHandle, press.owner)) {
+                        if (press.longPressFired) {
                             dlog('press suppressed (longPress already fired)');
                         }
                         else {
                             dlog('event press -> dispatch');
-                            bubble(start, PRESS, nativeEvent);
+                            bubble(press.owner, PRESS, nativeEvent);
                         }
                     }
-                    bubble(start, PRESS_OUT, nativeEvent);
+                    bubble(press.owner, PRESS_OUT, nativeEvent);
                 }
-                else {
+                if (!hadActivePress) {
                     dlog(`event ${TOUCH_END} ignored (no matching start)`);
                 }
+                else if (completedPresses.length === 0) {
+                    dlog('press retained (another touch remains inside its owner)');
+                }
                 // onResponderEnd fires on every finger-up; onResponderRelease (the final
                 // release) only when the last responder touch lifted.
                 if (responder) {
                     callOwnListener(responder, RESPONDER_END, nativeEvent);
-                    if (releases)
+                    if (releases) {
                         callOwnListener(responder, RESPONDER_RELEASE, nativeEvent);
+                        handOverNativeResponder(responder, undefined, false);
+                    }
                     else
                         dlog('responderEnd without release (touches remain inside responder)');
                 }
@@ -413,20 +486,32 @@ export function installEventHandler() {
         if (topLevelType === TOUCH_CANCEL) {
             recordTouchTrack('end', nativeEvent);
             attachTouchHistory(nativeEvent);
-            const start = pressStart;
-            pressStart = undefined;
+            // A cancel is scoped to the finger(s) removed from `touches`, just like an end. An unrelated
+            // Pressable—or another finger under the same owner—must keep its press and long-press state.
+            const cancelledPresses = [];
+            for (const press of activePresses) {
+                if (hasRemainingTouchWithin(press.owner, nativeEvent))
+                    continue;
+                activePresses.delete(press);
+                clearLongPress(press);
+                cancelledPresses.push(press);
+            }
             const responder = currentResponder;
-            currentResponder = undefined;
-            longPressFired = false;
-            longPressStart = undefined;
-            clearLongPress();
+            const terminatesResponder = responder !== undefined &&
+                !hasRemainingTouchWithin(responder, nativeEvent);
+            if (terminatesResponder)
+                currentResponder = undefined;
             runWrapped(() => {
-                if (start)
-                    bubble(start, PRESS_OUT, nativeEvent);
-                // A cancelled gesture ends then terminates (the responder was taken away).
+                for (const press of cancelledPresses)
+                    bubble(press.owner, PRESS_OUT, nativeEvent);
                 if (responder) {
+                    // Like touch-end, every finger leaving emits responderEnd. Termination is final only
+                    // when no touch remains inside the responder.
                     callOwnListener(responder, RESPONDER_END, nativeEvent);
-                    callOwnListener(responder, RESPONDER_TERMINATE, nativeEvent);
+                    if (terminatesResponder) {
+                        callOwnListener(responder, RESPONDER_TERMINATE, nativeEvent);
+                        handOverNativeResponder(responder, undefined, false);
+                    }
                 }
             });
             if (touchHistory.numberActiveTouches === 0)

package/build/fabric-props.js

@@ -4,8 +4,8 @@
 // responsibilities stop sharing one 300+ line file. Color processing itself lives in
 // ./platform-color (the stable leaf every color-touching module imports from); this file only
 // decides WHICH props are color props and wires the structured CSS-style processors.
+import { foldAriaProps } from './accessibility-props.js';
 import { RAW_TEXT_COMPONENT } from './node.js';
-import { flattenStyle } from './style/index.js';
 import { registeredProcessor } from './registry.js';
 import { isProcessableColor, processColor } from './platform-color/index.js';
 import { processBoxShadow } from './process-box-shadow/index.js';
@@ -164,29 +164,198 @@ function processValue(component, key, value) {
         return processColor(value);
     return value;
 }
+// A style object is SHARED, and that is the one place this file has a complexity problem rather
+// than a constant-factor one. StyleSheet.create hands out one frozen object per rule, and the CSS
+// class registry resolves a class name to one cached object - so 1 000 rows carry the SAME handful
+// of style objects, and resolving each one per node costs O(nodes x styleKeys) to compute an
+// answer that only varies with O(distinct styles). Cache it on the style object's identity.
+//
+// Keyed by component as well: processValue consults that component's ViewConfig processors, so one
+// style object can legitimately resolve differently under two view names.
+//
+// The cache assumes a style object is not MUTATED IN PLACE, which is already the engine's contract:
+// setProp compares with Object.is and skips a same-identity write, so an in-place style edit never
+// marks the node dirty and never reaches Fabric today either. What narrows slightly is the case
+// where some OTHER prop on the same node changed in the same commit - that used to pick the
+// mutation up as a side effect, and now does not.
+//
+// KEEPING undefined-valued keys is deliberate: the resolved object is a faithful picture of ONE
+// style entry, and addStyle below needs to see an explicit `undefined` to let a later entry clear
+// an earlier one. Dropping them here would silently turn `[{flex:1},{flex:undefined}]` into
+// `flex: 1`.
+const styleCache = new Map();
+function processedStyle(component, style) {
+    let perComponent = styleCache.get(component);
+    if (perComponent === undefined) {
+        perComponent = new WeakMap();
+        styleCache.set(component, perComponent);
+    }
+    const cached = perComponent.get(style);
+    if (cached !== undefined)
+        return cached;
+    const resolved = {};
+    for (const key of Object.keys(style)) {
+        const value = style[key];
+        resolved[key] =
+            value === undefined ? undefined : processValue(component, key, value);
+    }
+    perComponent.set(style, resolved);
+    return resolved;
+}
+/**
+ * Hoist one style slot's keys into the payload being built, recursing on POSITION only - the same
+ * rule flattenStyle follows, and for the same reason: `transform: [{translateX: 5}]` is an
+ * array-VALUED prop, not a nested style.
+ *
+ * The point is that there is no intermediate object. Every style entry's resolution is memoized on
+ * its own identity and its keys are written straight into `out`, so a thousand rows sharing one
+ * class-resolved style resolve it ONCE and each node pays a copy loop.
+ *
+ * This is also the shape React Native itself uses. `ReactNativeAttributePayload.addNestedProperty`
+ * (.vendors/react/packages/react-native-renderer/src/ReactNativeAttributePayload.js:208) recurses
+ * over the style array writing into a single `updatePayload`; upstream's `flattenStyle` appears
+ * ONLY in `diffNestedProperty`, i.e. the update path where an array meets an object - never on
+ * create. Our previous version flattened first and hoisted second, which allocated one merged
+ * object per node per commit that nothing else ever read.
+ *
+ * It also fixed a dead cache. `processedStyle` used to be reachable only when `props.style` was a
+ * bare object, and it never is: `commitClassStyle` (node.ts) always writes the two-element
+ * `[classStyle, explicitStyle]` array, by design. So the memo existed, was correct, and never ran.
+ *
+ * Later entries win, because a later write overwrites the same key on `out`. An explicit
+ * `undefined` CLEARS the key instead, matching the flatten path it replaces. One narrow
+ * divergence, recorded rather than hidden: the `delete` also clears a same-named TOP-LEVEL prop
+ * hoisted before the style pass, which flattening did not. Style keys and native prop keys do not
+ * overlap in practice (one is Yoga/visual, the other is testID/accessibility/source), so this is
+ * theoretical - but it is a difference, and `fabric-props.test.ts` pins both halves.
+ */
+function addStyle(out, component, style) {
+    if (Array.isArray(style)) {
+        for (const entry of style)
+            addStyle(out, component, entry);
+        return;
+    }
+    if (!isRecord(style))
+        return;
+    const resolved = processedStyle(component, style);
+    for (const key of Object.keys(resolved)) {
+        const value = resolved[key];
+        if (value === undefined)
+            delete out[key];
+        else
+            out[key] = value;
+    }
+}
 // Translate the retained node's logical props into the flat payload Fabric's C++
 // props expect: `style` keys are hoisted to the top level, event handlers and
 // undefined values are dropped.
+// RN HAS NO `value` FABRIC PROP. A TextInput's controlled value rides as the private `text` prop,
+// and the fold that produces it — `value ?? defaultValue` — lives in the component wrapper
+// (`core/components/src/view/render-text-input.ts`, whose own comment says "There is no `value`
+// Fabric prop; this is the whole controlled surface"). A LOWERED element has no wrapper, so a
+// transform printing the author's `value={x}` yields a key no ViewConfig declares: silently dropped,
+// `text` never set, and the field renders EMPTY. Nothing red anywhere — found 2026-08-31 by an agent
+// reading what the render function actually emits rather than trusting a header comment.
+//
+// So the fold moves to the layer every path goes through, exactly like the aria fold above it. This
+// is the third instance of one rule: a lowered element inherits NOTHING its wrapper did, and the
+// repair belongs below the fork, never in the transform.
+//
+// GATED ON THE COMPONENT, NOT ON THE PROP. `value` is also a prop of `Switch` and `Slider`; a fold
+// keyed on the prop name would write a bogus `text` onto both. Two string comparisons rather than a
+// Set lookup — this runs per node per commit, and the set has exactly two members.
+//
+// The engine may hold this because both views are in `BUILTIN_COMPONENTS`, whose hand-tuned tables
+// (`view-config.ts`'s TEXT_INPUT_EVENTS, commit's COLOR_PROPS) already live here for the same
+// reason. Routing it through `registerComponent` was tried first and is WRONG: `resolve()`
+// short-circuits every builtin to EMPTY, so the registration would have been accepted and never
+// applied.
+const SINGLELINE_TEXT_INPUT = 'RCTSinglelineTextInputView';
+const MULTILINE_TEXT_INPUT = 'RCTMultilineTextInputView';
+function foldTextInputValue(props) {
+    const hasValue = props.value !== undefined;
+    const hasDefault = props.defaultValue !== undefined;
+    if (!hasValue && !hasDefault)
+        return props;
+    const folded = { ...props };
+    // `value` WINS over `defaultValue` — `foldText`'s rule, kept identical rather than re-derived.
+    // An explicit `text` is left alone: that is the component path, where the wrapper already folded,
+    // and re-folding there would let a stale `value` overwrite what the wrapper computed.
+    if (folded.text === undefined) {
+        folded.text = hasValue ? props.value : props.defaultValue;
+    }
+    // Blanked, not deleted: `fabricProps` skips undefined, and neither name is a real Fabric prop.
+    folded.value = undefined;
+    folded.defaultValue = undefined;
+    return folded;
+}
 export function fabricProps(node) {
     if (node.component === RAW_TEXT_COMPONENT) {
-        return { text: node.props.text };
+        // A raw-text node gets its behavior's fold too — it TRANSFORMS the text that is already there
+        // (Button uppercases its label on Android) and may not SUPPLY one, which is narrower than this
+        // comment claimed when it landed. `isEmptyRawText` (node.ts) decides whether the node commits
+        // at all from `node.props.text`, before any fold runs, so a text that exists only as a fold
+        // result is dropped by `renderableChildren` and the fold never executes. Reported by the hook's
+        // first consumer, within the hour.
+        //
+        // Which is why the skip is NOT the thing to change: it runs for every raw-text node in every
+        // app, and consulting a fold there would put one on that walk. Get the value into `props.text`
+        // instead — Button routes the owner's `title` onto this node with `slotProps: {title: 'text'}`,
+        // so the skip and the fold read the same source and an empty title still commits nothing.
+        return {
+            text: node.payloadFold !== undefined
+                ? node.payloadFold(node.props).text
+                : node.props.text,
+        };
     }
+    // This runs once per node per commit - 9 000 times on one benchmark press - so the two loops
+    // below iterate with Object.keys rather than Object.entries: entries allocates a fresh
+    // two-element array PER KEY on top of the outer array, and the resulting garbage was 18% of the
+    // create path in a CPU profile.
+    //
+    // Do NOT "improve" this to `for...in`. It was tried and reverted 2026-08-23. On paper it is the
+    // strictly cheaper shape - Object.keys allocates one array per call, 10 007 of them on a
+    // 1 000-row create (counted), and for...in allocates none - and the headless V8 bench agreed,
+    // 12-13% off create/replace `min`. On DEVICE it lost: with the Fabric call counts and prop-key
+    // payload byte-identical either way (9000/5000/1009, 32001 keys), Release Create went 217.8 ->
+    // 243.2 ms while stock moved only inside its 4% noise floor. Hermes' for-in is not V8's enum
+    // cache. The general rule this bought: an allocation-count win measured on V8 is not a Hermes
+    // win, and only the on-device number decides (`perf-claims-need-numbers`).
     const out = {};
-    for (const [key, value] of Object.entries(node.props)) {
+    // THE ONE POINT WHERE THE WHOLE BAG IS KNOWN ON EVERY PATH, which is what the aria fold needs:
+    // `aria-checked` has to be folded against a sibling `accessibilityState`, and `routeProp` sees
+    // one key at a time. Both commit paths — create and update — reach here, so a lowered element
+    // gets the fold it has no wrapper to run.
+    //
+    // NOT memoised on `node.props` identity. That object is stable and mutated IN PLACE, so an
+    // identity-keyed cache (the `processedStyle` pattern below) would be stale forever. The gate is
+    // the node's sticky flag instead: one boolean read for a node with no alias, which is nearly all
+    // of them, and the fold's own fast path returns by identity for the rest.
+    const aliasFolded = node.hasAriaAlias
+        ? foldAriaProps(node.props)
+        : node.props;
+    // The behavior's own fold, for a LOWERED element only — the two folds above are keyed on the
+    // component name, which a wrapper and its lowered twin share, so neither could carry a
+    // per-primitive fold without running it twice on the wrapper. See IPayloadFold.
+    const behaviorFolded = node.payloadFold !== undefined
+        ? node.payloadFold(aliasFolded)
+        : aliasFolded;
+    const props = node.component === SINGLELINE_TEXT_INPUT ||
+        node.component === MULTILINE_TEXT_INPUT
+        ? foldTextInputValue(behaviorFolded)
+        : behaviorFolded;
+    for (const key of Object.keys(props)) {
         if (key === 'style')
             continue;
+        const value = props[key];
         if (typeof value === 'function')
             continue;
         if (value === undefined)
             continue;
         out[key] = processValue(node.component, key, value);
     }
-    // Collapse style (object | array | nested arrays) into one flat payload before
-    // hoisting: `style={[base, override]}` is RN's idiom and Fabric wants it flat.
-    const style = flattenStyle(node.props.style);
-    for (const [key, value] of Object.entries(style)) {
-        if (value !== undefined)
-            out[key] = processValue(node.component, key, value);
-    }
+    // Hoist the style slot (object | array | nested arrays) into the SAME payload object - no
+    // intermediate flatten. See addStyle for the shape and for the two things this fixed.
+    addStyle(out, node.component, props.style);
     return out;
 }