@symbiote-native/components 2.0.0 → 3.0.1

package/README.md

@@ -91,7 +91,7 @@ host node untouched — the render function never names a framework type.
   (`createPressHandlers` / `createPressRuntime` in `state/pressable`) plus its render-decision
   helpers (`buildPressableListeners`, `resolveDisabledAccessibilityState`, `shouldClaimResponder`,
   … in `view/render-pressable`), the `Touchable*` timing constants, `Button`'s shared text-style
-  fold, `TextInput`'s controlled-value/event-count handshake (`resolveTextInputProps`, `foldText`,
+  fold, `TextInput`'s controlled-value/event-count handshake (`foldText`, `shouldCommandText`,
   `eventCountFromChange`, …), `KeyboardAvoidingView`'s inset math, `ScrollView`'s
   intrinsics/sticky-header math (no full 3-layer split — the adapter owns the element assembly).
 - **Two more shared reducers, driven by every adapter's reactive glue**: the sticky-header effect
@@ -104,14 +104,13 @@ host node untouched — the render function never names a framework type.
   row/section folding helpers. Lists have no `view/render-*.ts` (a cell's content is the
   framework's own children) — the shared layer here is pure state/logic, reused verbatim by every
   adapter.
-- **Host behaviors (`src/behaviors/*.ts`)** — tier-2 host-primitive lowering: a primitive's state
-  machine and prop folds registered directly on the engine node (`registerPressableBehavior`,
-  `registerSwitchBehavior`, `registerImageBehavior`, `registerTextInputBehavior`,
-  `registerInputAccessoryViewBehavior`, plus the folds a lowered element still needs —
-  `foldImagePayload`, `foldInputAccessoryViewPayload`, `buildTextInputHandle`) so a
-  `Pressable`/`Switch`/`TextInput`/`Image`/`InputAccessoryView` can compile to a bare intrinsic tag
-  instead of a framework component. Built on `@symbiote-native/engine`'s `registerHostBehavior`
-  seam; see `.claude/rules/host-primitive-tier.md`.
+- **Host behaviors (`src/behaviors/*.ts`)** — a primitive's state machine and prop folds registered
+  directly on the engine node (`registerPressableBehavior`, `registerSwitchBehavior`,
+  `registerImageBehavior`, `registerTextInputBehavior`, `registerInputAccessoryViewBehavior`, plus
+  the folds a tag still needs — `foldImagePayload`, `foldInputAccessoryViewPayload`,
+  `buildTextInputHandle`), so `pressable`/`switch`/`text-input`/`image`/`input-accessory-view` are
+  bare intrinsic tags rather than framework components. Built on `@symbiote-native/engine`'s
+  `registerHostBehavior` seam.
 
 ## What it does NOT do
 

package/build/accessibility-props.d.ts

@@ -64,7 +64,7 @@ export interface IAriaProps {
 /**
  * The typed entry point adapters import. The FOLD itself now lives in `@symbiote-native/engine`
  * (`core/engine/src/accessibility-props.ts`) so it runs at the layer every path goes through —
- * including a LOWERED element, which has no component wrapper to run it. This function stays here
+ * including a bare tag, which has no component wrapper to run it. This function stays here
  * because the public types do, and because it keeps the typed gate: `hasAnyAriaKey` is checked
  * before anything is allocated, so the ~99% of nodes carrying no alias cost the same as before.
  *

package/build/accessibility-props.js

@@ -10,7 +10,7 @@
 // Vue, and the next) folds aria/role into accessibility* identically.
 import { foldAriaProps } from '@symbiote-native/engine';
 // The gate's key list, typed against `IAriaProps` so a new alias added to that interface and
-// forgotten here is a type error. The engine carries its own untyped copy for the lowered path;
+// forgotten here is a type error. The engine carries its own untyped copy;
 // `core/engine/src/accessibility-props.ts` is the single implementation of the FOLD, this is only
 // the cheap probe that decides whether to call it.
 const ARIA_KEYS = [
@@ -44,7 +44,7 @@ function hasAnyAriaKey(props) {
 /**
  * The typed entry point adapters import. The FOLD itself now lives in `@symbiote-native/engine`
  * (`core/engine/src/accessibility-props.ts`) so it runs at the layer every path goes through —
- * including a LOWERED element, which has no component wrapper to run it. This function stays here
+ * including a bare tag, which has no component wrapper to run it. This function stays here
  * because the public types do, and because it keeps the typed gate: `hasAnyAriaKey` is checked
  * before anything is allocated, so the ~99% of nodes carrying no alias cost the same as before.
  *

package/build/behaviors/activity-indicator/shared.js

@@ -26,22 +26,17 @@
 // Registered by all five adapters since 2026-09-09, in the same commit that deleted the five
 // wrappers — the registry is keyed by TAG, so registering while a wrapper still painted its own
 // spinner would have given every indicator two.
-import { appendChild, createElement, registerHostBehavior, } from '@symbiote-native/engine';
+import { appendChild, createElement, registerHostBehavior, setProp, } from '@symbiote-native/engine';
 import { descriptorFor } from '../../component-names';
 export const ACTIVITY_INDICATOR_TAG = 'activity-indicator';
 // The NATIVE spinner — `ActivityIndicatorView` on iOS, `AndroidProgressBar` on Android. Built by
 // `buildStructure` below and by nothing else; no app writes it.
 export const ACTIVITY_INDICATOR_SPINNER_TAG = 'activity-indicator-spinner';
-// Fixed pixel boxes RN gives the two named sizes (styles.sizeSmall/sizeLarge).
-const SIZE_SMALL_PX = 20;
-const SIZE_LARGE_PX = 36;
-// RN's own default when the app writes no `size` (ActivityIndicator.js:72).
-const DEFAULT_SIZE = 'small';
-// Centering wrapper RN puts around the spinner (styles.container).
-const CONTAINER_STYLE = {
-    alignItems: 'center',
-    justifyContent: 'center',
-};
+// The two size boxes, the default size and the centering style are NOT here any more: they are
+// literals inside `foldActivityIndicatorProps` / `foldActivityIndicatorSpinnerProps`
+// (`SymbioteFabricProps.cpp`). Keeping a JS copy of a value only C++ reads is the mirror this port
+// exists to remove — it would compile, export and test cleanly while nothing on a device consulted
+// it.
 // The props that stay on the centering host instead of travelling to the spinner: RN's own two
 // (`ActivityIndicator.js:113`) plus the spellings the ENGINE resolves against a node's own style.
 const ACTIVITY_INDICATOR_HOST_PROPS = [
@@ -55,62 +50,21 @@ const ACTIVITY_INDICATOR_HOST_PROPS = [
     'class',
     'className',
 ];
-function resolveSize(size) {
-    if (size === 'small') {
-        return {
-            sizeStyle: { width: SIZE_SMALL_PX, height: SIZE_SMALL_PX },
-            sizeProp: 'small',
-        };
-    }
-    if (size === 'large') {
-        return {
-            sizeStyle: { width: SIZE_LARGE_PX, height: SIZE_LARGE_PX },
-            sizeProp: 'large',
-        };
-    }
-    return { sizeStyle: { width: size, height: size } };
-}
-// The HOST's fold: RN's `StyleSheet.compose(styles.container, style)` (ActivityIndicator.js:114).
-// Base first, so an app style still wins.
-const hostFold = props => ({
-    ...props,
-    style: [CONTAINER_STYLE, props.style],
-});
-function isActivityIndicatorSize(value) {
-    return value === 'small' || value === 'large' || typeof value === 'number';
-}
-// The SPINNER's fold — RN's own body (`ActivityIndicator.js:99-118`) applied to the node the app
-// never names.
-function spinnerFold(platform) {
-    return props => {
-        const size = isActivityIndicatorSize(props.size)
-            ? props.size
-            : DEFAULT_SIZE;
-        const { sizeStyle, sizeProp } = resolveSize(size);
-        const next = {
-            ...props,
-            // RN defaults both to true and every wrapper spelled that `!== false`. A tag has no
-            // destructuring default, so the fold is where the default has to live.
-            animating: props.animating !== false,
-            hidesWhenStopped: props.hidesWhenStopped !== false,
-            style: sizeStyle,
-        };
-        // A NUMBER never reaches native: it sizes the spinner through style alone, and the native enum
-        // takes 'small'/'large' only. So the key has to leave, not merely go unwritten.
-        if (sizeProp === undefined)
-            delete next.size;
-        else
-            next.size = sizeProp;
-        const color = typeof props.color === 'string' ? props.color : platform.defaultColor;
-        // Omitted rather than sent as null — Android's theme default is null and Fabric's colour parser
-        // rejects one.
-        if (color === null)
-            delete next.color;
-        else
-            next.color = color;
-        return next;
-    };
-}
+// `activeStyle` is deliberately NOT here. It looked like it belonged — it is slot 1 of the same
+// `pushClassStyle` merge `style` and `class` feed — but this primitive has no pressed state, so
+// `routeProp` consumes the key on whichever node it lands on and it never reaches Fabric either
+// way. An entry no test can make fail is an entry that was never wired in.
+// BOTH FOLDS LEFT THIS FILE on 2026-09-18 and neither was replaced by anything here: they are
+// `foldActivityIndicatorProps` and `foldActivityIndicatorSpinnerProps` in `SymbioteFabricProps.cpp`.
+// Every input either read was the node's own bag — no owner, no listener, no live state — which is
+// what made them tag rules rather than composition, and it is why both nodes now cost ZERO trips
+// into JS instead of one each. Contract:
+// `core/engine/cpp/tests/js/activity-indicator-payload.itest.ts`.
+//
+// The size constants, the container style and the default colour went WITH them rather than staying
+// as a second copy for the tests to assert. `platform.defaultColor` survives as the last field of
+// `IActivityIndicatorPlatform` only because the rule's Android half is chosen by COMPONENT NAME in
+// C++, so the JS value would have no reader — see the type's own note.
 // The composition. Returns the spinner as the slot because the prop redirect is gated on
 // `childHost` being set — the redirect is what this slot is FOR, and NOT where children go: RN's
 // ActivityIndicator renders only the spinner (`ActivityIndicator.js:112-118`) and takes no children
@@ -124,8 +78,8 @@ function buildSpinner(platform) {
         // Constants of the platform, never a function of a prop, so they are seeded at build time the
         // way ScrollView seeds `collapsable: false` — empty on iOS, AndroidProgressBar's two
         // requirements on Android.
-        spinner.props = { ...platform.nativeExtras };
-        spinner.payloadFold = spinnerFold(platform);
+        for (const [key, value] of Object.entries(platform.nativeExtras))
+            setProp(spinner, key, value);
         appendChild(node, spinner);
         return spinner;
     };
@@ -135,7 +89,6 @@ function activityIndicatorBehavior(platform) {
         slotPropsExcept: ACTIVITY_INDICATOR_HOST_PROPS,
         slotTakesNoChildren: true,
         buildStructure: buildSpinner(platform),
-        foldPayload: hostFold,
         // Required by the interface and deliberately empty: this primitive owns no timer, no listener
         // and no native handshake. Written out rather than shared with a `noop` so the emptiness reads
         // as a decision.
@@ -146,4 +99,22 @@ function activityIndicatorBehavior(platform) {
 // Called by the platform files; nothing else should.
 export function registerActivityIndicatorBehaviors(platform) {
     registerHostBehavior(ACTIVITY_INDICATOR_TAG, activityIndicatorBehavior(platform));
+    // A REGISTRATION WITH NO RUNTIME, and it is what hands the spinner's tag to the host.
+    //
+    // A tag crosses only through `recordSetTag`, which `attachHostBehavior` emits and nothing else
+    // does — so a tag with no behavior registered carries an EMPTY `tagName` in C++ and no rule can
+    // fire for it. The spinner is built by `buildStructure` and no app ever names it, so it had a tag,
+    // had platform semantics, and the host could not see either. Its rule lives in
+    // `SymbioteFabricProps.cpp` now (the size translation, RN's two `!== false` defaults, the
+    // platform's default colour), which is why this registration has to exist even though there is no
+    // JS left to run.
+    //
+    // Not a workaround for the seam: a registration is how this codebase declares that a tag HAS
+    // platform semantics, which is exactly the claim. Emitting the tag from `createElement` for every
+    // node was the alternative and is rejected where `attachHostBehavior` explains itself — an app's
+    // own `<div>`-equivalent would pay an intern and an op to name something the host has no rule for.
+    registerHostBehavior(ACTIVITY_INDICATOR_SPINNER_TAG, {
+        attach() { },
+        detach() { },
+    });
 }

package/build/behaviors/button.d.ts

@@ -1,2 +1,13 @@
 export declare const BUTTON_TAG = "button";
+/**
+ * NO MEMO, and the earlier version's memo is deliberately gone. It guarded `setProp`'s `Object.is`,
+ * which a FRESH style object per call can never satisfy — so pushing unconditionally would have
+ * dirtied a node on every commit and re-committed forever
+ * (`.claude/rules/list-geometry-feedback-loop.md`). A payload fold does not go through `setProp`:
+ * its result reaches `reconcile`, which compares against the mirror with a recursive `propsEqual`
+ * (commit.ts) and reuses the committed handle when nothing moved. An equal-but-fresh style is
+ * therefore not a change, and there is nothing to feed back.
+ */
+export declare const BUTTON_LABEL_TEXT_TAG = "button-label-text";
+export declare const BUTTON_LABEL_TAG = "button-label";
 export declare function registerButtonBehavior(): void;

package/build/behaviors/button.js

@@ -12,17 +12,23 @@
 // Android Button's own `<View style={buttonStyles}>` IS the responder:
 //
 //   iOS      button   RCTView      TouchableOpacity's Animated.View — the responder + the fade
-//            └ view   RCTView      resolveButtonViewStyle(color, disabled) — `{}` here
-//              └ text RCTText      resolveButtonTextStyle(color, disabled) + RN's Text defaults
-//                └ raw RCTRawText  resolveButtonTitle(title)                       FOUR nodes
+//            └ view   RCTView      no style at all, and no fold
+//              └ text RCTText      `button-label-text` — foldButtonLabelStyle + RN's Text defaults
+//                └ raw RCTRawText  `button-label`    — foldButtonLabel            FOUR nodes
 //
 //   Android  button   RCTView      the styled button view, CLONED onto: the responder, the ripple
 //            │                     background, the whole a11y fold. No fade, no wrapper.
 //            └ text   RCTText
 //              └ raw  RCTRawText   UPPERCASED (Button.js:352-353)                 THREE nodes
 //
-// EVERY FOLD IS ALREADY WRITTEN AND TESTED in `../view/render-button`; nothing here re-derives one.
-// What is new is only WHERE they run: on engine nodes, instead of in a component body.
+// EVERY RULE IS IN THE ENGINE AS OF 2026-09-18, and off Android this primitive binds no
+// `payloadFold` on any of its four nodes — it costs ZERO trips into JS, down from five. The one that
+// survives is the OWNER's on Android, for the view style and the ripple background.
+//
+// The last to move was the label text's, and it needed a seam none of the others did: its style is a
+// function of the BUTTON's `color` and `disabled`, and the button is its GRANDPARENT here and its
+// parent on Android. `IAncestorLookup` asks for the nearest ancestor carrying a tag — a CSS ancestor
+// selector — so one rule is correct on both trees.
 //
 // ---------------------------------------------------------------------------------------------
 // HOW THE PROJECTION REACHES ITS NODES, given that each `payloadFold` MUST be pure:
@@ -105,12 +111,9 @@
 // since 2026-09-09, in the same commit that deleted the five wrappers, which is what makes it safe:
 // while a wrapper still built its own view and text under this tag, registering would have given
 // every Button a second copy of the subtree.
-import { addDerivedNode, appendChild, appListenerFor, createElement, createRawText, markPropsDirty, Platform, registerHostBehavior, requestCommitFor, } from '@symbiote-native/engine';
+import { addDerivedNode, appendChild, createElement, createRawText, markPropsDirty, Platform, registerHostBehavior, requestCommitFor, setProp, } from '@symbiote-native/engine';
 import { descriptorFor } from '../component-names';
-import { resolveTextProps } from '../text-props.js';
-import { BUTTON_ACCESSIBILITY_ROLE, resolveButtonDisabled, resolveButtonImportantForAccessibility, resolveButtonTextStyle, resolveButtonTitle, resolveButtonViewStyle, } from '../view/render-button.js';
-import { backgroundProps, selectableBackground, } from '../view/render-touchable-native-feedback.js';
-import { resolveTouchableFocusable } from '../view/render-pressable/index.js';
+import { resolveButtonDisabled } from '../view/render-button.js';
 import { booleanOr, createPressBehavior, } from './pressable.js';
 import { nativeFeedbackRefinement } from './touchable-native-feedback.js';
 import { createTouchableOpacityBehavior } from './touchable-opacity.js';
@@ -166,29 +169,39 @@ const buttonDisabled = props => projectionOf(props).disabled;
  * (commit.ts) and reuses the committed handle when nothing moved. An equal-but-fresh style is
  * therefore not a change, and there is nothing to feed back.
  */
-function viewFold(owner) {
-    return props => {
-        const { color, disabled } = projectionOf(owner.props);
-        return { ...props, style: resolveButtonViewStyle(color, disabled) };
-    };
-}
-function textFold(owner) {
-    return props => {
-        const { color, disabled } = projectionOf(owner.props);
-        return {
-            ...props,
-            style: resolveButtonTextStyle(color, disabled),
-            // RN puts `disabled` on the Text as well (Button.js:386) — a real RCTText prop read by
-            // Android's accessibility layer, and not the same thing as the greyed colour above.
-            disabled,
-        };
-    };
-}
-// Reads its OWN `text`, which `SLOT_PROPS` redirected the app's `title` into — no owner closure, so
-// the fold is shared by every button. `fabricProps` reads only `.text` off a raw-text fold.
-const labelFold = props => ({
-    text: resolveButtonTitle(stringOr(props.text) ?? ''),
-});
+// THE VIEW'S FOLD IS GONE AND WAS NOT PORTED — it was doing nothing, on the only platform where it
+// ran. It wrote `style: resolveButtonViewStyle(color, disabled)`, and that function returns the
+// constant `buttonViewStyle` on every platform but Android while the view node is built ONLY in the
+// non-Android branch of `buildStructure`. `buttonViewStyle` off Android is `{}`. So it read two
+// props off its owner, discarded both, and spent a JSI round trip per button per commit to write an
+// empty style.
+//
+// This is the `input-accessory-view` shape again, and the second time this migration has found one:
+// a fold's price is the TRIP, not the body, so a fold that does nothing is the worst value in the
+// file and deleting it is worth as much as porting one that does a lot.
+//
+// Proven not to move the payload rather than argued: `button-derived-payload.itest.ts` pins the
+// view's committed keys, including with an app-set `color` — which lands on the LABEL here and must
+// not reach this node.
+// THE LABEL TEXT'S TAG. Its style is a function of the BUTTON's `color` and `disabled`, and the
+// button is this node's grandparent on iOS (`button -> view -> text`) and its parent on Android —
+// so the rule asks for the NEAREST BUTTON ancestor rather than for a fixed number of hops, which is
+// the same question a CSS ancestor selector asks and is true on both trees.
+//
+// `foldButtonLabelStyle` in `SymbioteFabricProps.cpp`, reached through `IAncestorLookup`. That seam
+// was the thing this fold was waiting for: `ownerProps` answers "my parent" and this node's parent
+// is the wrapping view, which knows none of it.
+export const BUTTON_LABEL_TEXT_TAG = 'button-label-text';
+// The label's own tag. A raw text carrying one looks odd and is not: it has no props an app can
+// write, but its CONTENT is the platform's decision here — RN renders a button's title uppercased on
+// Android and verbatim elsewhere (`Button.js:352-353`), which is a user-agent choice about a control
+// rather than anything the app asked for.
+//
+// That is what the fold here used to do, and it is `foldButtonLabel` in `SymbioteFabricProps.cpp`
+// now, reached off this tag. `button-payload.itest.ts` recorded "a raw text carries no tag at all,
+// so there is nothing for a tag-keyed rule to key on" — true of `createRawText`'s old signature, not
+// of raw texts, and it takes a tag now for exactly this.
+export const BUTTON_LABEL_TAG = 'button-label';
 // ---- the Android touchable -------------------------------------------------------------------
 // Button.js:281-284. Not two variants of one component: see the tree diagram at the top for what
 // wrapping instead of cloning costs. The Android arm composes the bare press machine, so no
@@ -212,48 +225,37 @@ const touchable = IS_ANDROID
  *                       fold then merges `props.disabled` over it, which composes to RN's
  *                       `props.disabled ?? aria ?? state.disabled` — the same value, with
  *                       busy/checked/expanded/selected preserved, without a Button-specific fold.
+ *
+ * THE TOUCHABLE'S HALF IS NO LONGER A FUNCTION ON EITHER PLATFORM, and the absence is the design
+ * rather than a gap: neither `createPressBehavior` nor `createTouchableOpacityBehavior` has a
+ * `foldPayload` any more, because both rules moved into the engine (`foldPressableProps` and
+ * `foldIdAlias`, `SymbioteFabricProps.cpp`), which names `button` among the tags it serves. So the
+ * same work happens, one layer down and before this fold runs — the order is unchanged, the trip
+ * into JS is gone.
+ *
+ * The composition used to be spelled `touchable.foldPayload === undefined ? props : ...`, and that
+ * shape is deleted rather than left standing at its `undefined` branch: a conditional call through
+ * a field nothing assigns any more is a whole rule that vanishes silently the day the field is
+ * removed, which is exactly how it would have gone unnoticed here.
  */
-function ownerFold(node) {
-    return props => {
-        const next = {
-            ...(touchable.foldPayload === undefined
-                ? props
-                : touchable.foldPayload(props)),
-        };
-        next.accessibilityRole = BUTTON_ACCESSIBILITY_ROLE;
-        // 'no' is the only value the resolver moves (Button.js:356), so checking for it IS the
-        // narrowing this bag needs — the shared resolver still owns what 'no' becomes.
-        if (next.importantForAccessibility === 'no')
-            next.importantForAccessibility =
-                resolveButtonImportantForAccessibility('no');
-        // Re-mapped, so the raw name must not also reach Fabric. Where the wrappers put it too — the
-        // pressable owns sound suppression (Button.js:377 hands `touchSoundDisabled` to the touchable).
-        if (Object.hasOwn(next, 'touchSoundDisabled')) {
-            next.android_disableSound = next.touchSoundDisabled;
-            delete next.touchSoundDisabled;
-        }
-        const { color, disabled } = projectionOf(props);
-        // TouchableOpacity.js:336 and TouchableNativeFeedback.js:369 — the SAME expression, so the tag
-        // owes it on both platforms. `onPress` is an owned name, so it is in the stash and never in
-        // `props`; a flip of it dirties nothing by itself, which `onOwnedListenerChange` answers.
-        next.focusable = resolveTouchableFocusable(booleanOr(props.focusable), appListenerFor(node, 'press') !== undefined, disabled);
-        if (IS_ANDROID) {
-            // TNF renders no view, it CLONES onto Button's `<View style={buttonStyles}>`
-            // (TouchableNativeFeedback.js:339), so this host IS that view. Overwritten rather than merged
-            // because RN's Button declares no `style` prop at all — there is nothing to compose with.
-            next.style = resolveButtonViewStyle(color, disabled);
-            // Button passes no `background` and no `useForeground`, so TNF resolves the theme's
-            // selectable background onto the background slot (TouchableNativeFeedback.js:343-348,
-            // :402). The dicts are the shared factories', never restated here.
-            Object.assign(next, backgroundProps(selectableBackground(), false));
-        }
-        // Read by the folds above and declared by no ViewConfig. A key Fabric does not know throws
-        // nothing, logs nothing and paints nothing, so the strip has to be here or it is never noticed.
-        // `title` needs none — `SLOT_PROPS` redirects it before it can land on this node.
-        delete next.color;
-        return next;
-    };
-}
+// `focusable` LEFT THIS FOLD ON 2026-09-18, and with it the whole fold off Android.
+//
+// It was the last thing here that ran on both platforms, and it stayed because its middle leg is
+// `onPress !== undefined` — an owned listener, stashed in JS. That bit crosses now
+// (`OP_SET_OWNED_LISTENER`), and Button's three-way `disabled` was only ever three PROPS, so
+// `foldButtonProps` resolves the expression itself. It reads the AUTHORED bag rather than the folded
+// one, which is the same Trap A correction this fold carried as `projectionOf(propsOf(node))`.
+//
+// The ANDROID half went the same day, once the test host grew an arm that compiles `#ifdef ANDROID`
+// (`tests/CMakeLists.txt`, `SYMBIOTE_PLATFORM_ANDROID`). It is inside `foldButtonProps` now: the
+// Material view style and the theme's selectable background, which TNF clones onto this very node
+// (`TouchableNativeFeedback.js:339`) because it renders no view of its own.
+//
+// SO BUTTON BINDS NO FOLD ON EITHER PLATFORM, and it is the first primitive to reach that with a
+// subtree — four nodes, four crossings per commit when this migration started.
+//
+// Contract: `core/engine/cpp/tests/js/button-payload.itest.ts` for the platform-invariant half and
+// `android-rules.itest.ts` for the style, the colour override and the disabled greying.
 /**
  * Builds the whole subtree, once, at `attachHostBehavior`.
  *
@@ -265,18 +267,18 @@ function ownerFold(node) {
  */
 function buildStructure(node) {
     const textDescriptor = descriptorFor('text');
-    const text = createElement(textDescriptor.component, textDescriptor.isText, 'text');
-    // RN's Text.js applies these to every non-virtual Text on its way to native, and a hand-written
-    // host tag inherits nothing a `<Text>` component did — Svelte's Button clipped long labels
-    // mid-word for exactly this reason (`.claude/rules/host-primitive-tier.md`, "The THIRD path").
-    // Constants, because the app cannot reach this node to override them.
-    text.props = resolveTextProps({});
+    const text = createElement(textDescriptor.component, textDescriptor.isText, BUTTON_LABEL_TEXT_TAG);
+    // RN's two Text defaults are NOT written here, and that is deliberate as of 2026-09-18: they are
+    // the platform's, applied by the payload builder to every `RCTText` (`foldTextDefaults`), so this
+    // node inherits them for being a text rather than for being handed them. Seeding them was two
+    // writes per button per commit producing the payload the builder already produces — the shape
+    // `seedTextDefaults` had in three adapters. `button-derived-payload.itest.ts` reads them off the
+    // committed payload and is what proves the node still gets them.
+    //
     // Empty until the redirected `title` arrives. The commit walk drops an empty raw text
     // (`isEmptyRawText`, node.ts), so no Fabric node exists for it until it has a label — and that
     // check reads `props.text`, which the redirect writes, not the fold's uppercased output.
-    const label = createRawText('');
-    text.payloadFold = textFold(node);
-    label.payloadFold = labelFold;
+    const label = createRawText('', BUTTON_LABEL_TAG);
     // The hop `slotDerived` alone does not make: it marks the slot (the label), and this is past it.
     addDerivedNode(node, text);
     appendChild(text, label);
@@ -288,7 +290,8 @@ function buildStructure(node) {
     else {
         const viewDescriptor = descriptorFor('view');
         const view = createElement(viewDescriptor.component, viewDescriptor.isText, 'view');
-        view.payloadFold = viewFold(node);
+        // No fold: see the note where `viewFold` was. Off Android this node's style was `{}` and this
+        // branch is the only one that builds it, so the fold was a crossing bought for an empty object.
         addDerivedNode(node, view);
         appendChild(view, text);
         // Lands on the owner, because `node.childHost` is still undefined here — the engine assigns it
@@ -296,9 +299,10 @@ function buildStructure(node) {
         // setting the field itself.
         appendChild(node, view);
     }
-    // See the header: the owner's fold needs its own node, and this runs after
-    // `attachHostBehavior` has already written `behavior.foldPayload` into the field.
-    node.payloadFold = ownerFold(node);
+    // ANDROID ONLY since 2026-09-18. See the header: the owner's fold needs its own node, and this
+    // NOTHING IS BOUND HERE ON EITHER PLATFORM as of 2026-09-18, which is the point — a fold with an
+    // empty body still costs a full JSI round trip per commit, so leaving one that returns its input
+    // is the worst value available (`input-accessory-view`, and Button's own `viewFold`).
     return label;
 }
 // `focusable` is a function of a LISTENER, and a listener flip changes no payload by itself — so
@@ -315,14 +319,22 @@ export function registerButtonBehavior() {
     // that leave with the sweep, and each carries only a pure fold, so this behavior owns no per-node
     // runtime of its own to release.
     //
-    // No `foldPayload` here on purpose — `buildStructure` binds the owner's fold to its node.
     const behavior = {
         ...touchable,
-        foldPayload: undefined,
         buildStructure,
         onOwnedListenerChange,
         slotProps: SLOT_PROPS,
         slotDerived: SLOT_DERIVED,
     };
+    // The two DERIVED nodes' tags, registered with no runtime at all. A tag reaches C++ only through
+    // `recordSetTag`, which `attachHostBehavior` emits, so a tag nobody registered carries an empty
+    // `tagName` in the host and no rule fires for it — however the rule is written. Same shape as the
+    // ActivityIndicator spinner's and ImageBackground's inner image.
+    //
+    // A registration is how this codebase declares a tag HAS platform semantics, which is exactly the
+    // claim: the label's style is RN's, not the app's.
+    const derived = { attach() { }, detach() { } };
+    registerHostBehavior(BUTTON_LABEL_TEXT_TAG, derived);
+    registerHostBehavior(BUTTON_LABEL_TAG, derived);
     registerHostBehavior(BUTTON_TAG, behavior);
 }

package/build/behaviors/image-background.d.ts

@@ -1,2 +1,3 @@
 export declare const IMAGE_BACKGROUND_TAG = "image-background";
+export declare const IMAGE_BACKGROUND_IMAGE_TAG = "image-background-image";
 export declare function registerImageBackgroundBehavior(): void;