@symbiote-native/components 2.0.0 → 3.0.0

package/build/behaviors/image-background.js

@@ -3,8 +3,8 @@
 //
 // THE TWO-NODE SHAPE IS RN'S. `ImageBackground.js:74-103` opens a `<View>` carrying the app's
 // `style`, puts an absolutely-filled `<Image>` inside it, and lays the app's `{children}` AFTER
-// that image so they paint on top. The lowered form is the same two nodes — `image-background`
-// (an RCTView, the tag an app writes) with an RCTImageView built under it.
+// that image so they paint on top. The tag commits the same two nodes — `image-background` (an
+// RCTView, the tag an app writes) with an RCTImageView built under it.
 //
 // WHY THE SLOT TAKES NO CHILDREN, which is the one thing this primitive needed that ScrollView,
 // ActivityIndicator and Button did not. `childHost` answers two questions at once — which node an
@@ -18,10 +18,11 @@
 // importantForAccessibility, ...props` and spreads `...props` onto the Image
 // (`ImageBackground.js:62-81`), so the set that moves is OPEN — every event, every accessibility
 // prop, `testID`, `id`, whatever an app writes next — and only a complement can express it.
-// `IMAGE_BACKGROUND_HOST_PROPS` is the short list that stays behind, and it is shorter than RN's:
-// `importantForAccessibility` rides to the image alone, which is what all five wrappers did, so
-// the tag and the component it replaces commit the same payload. The divergence from RN predates
-// lowering and is unchanged by it.
+// `IMAGE_BACKGROUND_HOST_PROPS` is that complement, and `importantForAccessibility` is IN it despite
+// never being part of the spread: RN reapplies it explicitly to both nodes (`:76,82`), so it stays on
+// the owner here too and the image gets its own copy derived from `ownerProps` (FIXED 2026-09-20 —
+// it used to redirect to the image alone and never reach the owner at all, which the module's own
+// comment rationalized as "the divergence from RN predates all of it").
 //
 // WHAT THE IMAGE'S FOLD OWES. Everything on the image arrives as a real prop write, so its payload
 // is built by the shared `foldImagePayload` like any other `image`. Two things cannot arrive that
@@ -29,95 +30,84 @@
 // wrapper's width/height onto the image so it fills the box rather than collapsing to the source's
 // intrinsic size), and `id`, whose rename to `nativeID` is applied per adapter on the tag THEY
 // create and so never reaches a node a behavior built.
-import { appendChild, createElement, flattenStyle, registerHostBehavior, } from '@symbiote-native/engine';
+import { appendChild, createElement, registerHostBehavior, } from '@symbiote-native/engine';
 import { descriptorFor } from '../component-names';
-import { foldImagePayload, IMAGE_TAG } from './image.js';
+import { IMAGE_TAG, registerImageBehavior } from './image.js';
 export const IMAGE_BACKGROUND_TAG = 'image-background';
-// The inner Image's positioning: absolute-fill behind the box's children.
-const ABSOLUTE_FILL = {
-    position: 'absolute',
-    left: 0,
-    right: 0,
-    top: 0,
-    bottom: 0,
-};
+// The inner image's own tag. Distinct from `image` because the absolute fill must NOT reach a bare
+// `<image>`, and a tag is the only thing a per-node rule can branch on.
+export const IMAGE_BACKGROUND_IMAGE_TAG = 'image-background-image';
 // The props RN keeps on the wrapper View (`ImageBackground.js:74-78`), plus the two spellings of a
 // class name — `routeProp`'s slot redirect runs above its own class branch, so an unlisted `class`
-// would style the image instead of the box.
-const IMAGE_BACKGROUND_HOST_PROPS = ['style', 'class', 'className'];
-// The owner props the image's payload is derived from. Only `style`, because a class name is
-// published INTO `node.props.style` by `pushClassStyle` — so a `class` write arrives here spelled
-// `style` and the proxied width/height follow a class-declared box as well as an inline one.
-const IMAGE_BACKGROUND_SLOT_DERIVED = ['style'];
+// would style the image instead of the box. `importantForAccessibility` stays too: RN destructures
+// it out of `...props` and reapplies it explicitly to BOTH the wrapper (:76) and the image (:82), so
+// it is never part of the spread — the engine derives the image's own copy from this node
+// (`foldImageBackgroundImageProps` in `SymbioteFabricProps.cpp`), the same seam the box proxy uses.
+const IMAGE_BACKGROUND_HOST_PROPS = [
+    'style',
+    'class',
+    'className',
+    'importantForAccessibility',
+];
+// The owner props the image's payload is derived from. `importantForAccessibility` joins `style`
+// for the reason above: a late write to either must re-fold the image, not just the box.
+const IMAGE_BACKGROUND_SLOT_DERIVED = ['style', 'importantForAccessibility'];
 // `imageStyle` is the wrapper's own name for the image's `style`. A bare class NAME is a legal
 // value for it — every adapter's wrapper resolved one — and `routeProp` routes a string landing on
 // `style` as `class` instead, so the registry resolves it on the image with nothing needed here.
 const IMAGE_BACKGROUND_SLOT_PROPS = { imageStyle: 'style' };
-// A StyleProp is an object, an array of them, or a registered class array — all of which
-// `flattenStyle` already handles one layer down. The only thing to exclude is a scalar.
-function styleOf(value) {
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    if (Array.isArray(value))
-        return value;
-    return { ...value };
-}
-// RN opts the wrapper out of iOS's Smart Invert for its whole subtree (`ImageBackground.js:75`) —
-// a photograph inverted by accessibility settings is the case that prop exists for. None of the
-// five wrappers ever wrote it, so this closes a standing gap rather than reproducing one.
-const hostFold = props => ({
-    ...props,
-    accessibilityIgnoresInvertColors: true,
-});
-// Read one explicit dimension off the (already-flattened) box style. A dp number or a percentage
-// string is a valid IDimensionValue; anything else (auto / undefined) yields undefined.
-function readDimension(style, key) {
-    const value = Object.hasOwn(style, key) ? Reflect.get(style, key) : undefined;
-    if (typeof value === 'number' || typeof value === 'string')
-        return value;
-    return undefined;
-}
-function imageFold(owner) {
-    return props => {
-        // RN's own workaround, and its comment is worth reading before "simplifying" this
-        // (`ImageBackground.js:86-96`): an RN Image overwrites its own width/height from the source's
-        // intrinsic size, which fights the box's explicit dimensions, so they are proxied back on.
-        // Reads the OWNER's live style — a class name lands there too, published by `pushClassStyle`.
-        const box = flattenStyle(styleOf(owner.props.style));
-        const next = {
-            ...props,
-            // `imageStyle` last, so a caller still wins over the fill and the proxy.
-            style: [
-                ABSOLUTE_FILL,
-                {
-                    width: readDimension(box, 'width'),
-                    height: readDimension(box, 'height'),
-                },
-                styleOf(props.style),
-            ],
-        };
-        // Unconditional priority when both are set, matching RN (`View.js:77-79`) and `foldHostBag`.
-        // A raw `id` is a key no ViewConfig declares, so Fabric drops it and the nativeID is lost.
-        if (Object.hasOwn(next, 'id')) {
-            next.nativeID = next.id;
-            delete next.id;
-        }
-        return foldImagePayload(next);
-    };
-}
+// The owner's fold is GONE (2026-09-18), not moved into this file under another name: its whole
+// content was `accessibilityIgnoresInvertColors: true`, a function of the tag and nothing else, and
+// it is `foldImageBackgroundProps` in `SymbioteFabricProps.cpp` now. The owner therefore pays no
+// trip into JS at all, and a committed ImageBackground is down from two crossings to one — the
+// remaining one is the inner image's, below, which derives its style from THIS node and so cannot be
+// a per-node rule. Contract: `core/engine/cpp/tests/js/image-background-payload.itest.ts`.
+// THE IMAGE'S FOLD IS GONE TOO (2026-09-18) — `foldImageBackgroundImageProps` in
+// `SymbioteFabricProps.cpp`, and with it this primitive costs ZERO trips into JS on both nodes.
+//
+// It outlived every other fold in this file because both of its inputs live on the node ABOVE: the
+// app writes `style` on the `<image-background>` and `IMAGE_BACKGROUND_HOST_PROPS` keeps it there.
+// "A per-node rule cannot reach another node" is what this file used to say, and it was a fact about
+// the JS FOLD rather than the engine — the tree is in C++, so `fabricProps` takes `ownerProps` from
+// `node.parent` and the proxy reads it there.
+//
+// The `id -> nativeID` half went earlier still and was DEAD before this port: `foldIdAlias` applies
+// to every tagged node and runs ahead of any fold, so by the time this ran the key was already
+// renamed. Worth naming, because a fold that still spells a rule someone else now applies reads as
+// load-bearing and is not.
+//
+// Contract: `core/engine/cpp/tests/js/image-background-image-payload.itest.ts`.
 // Returns the image, so `slotProps` / `slotPropsExcept` / `slotDerived` all point at it — and the
 // app's children stay on the owner because of `slotTakesNoChildren`, not because of what this
 // returns. The image is appended FIRST and nothing else is ever placed in front of it, which is
 // what makes the children paint over it.
 //
-// Built WITHOUT handing `IMAGE_TAG` to `createElement`, deliberately: that would attach Image's own
-// behavior and set `payloadFold` to `foldImagePayload` alone, and this node's style has to be
-// derived from the owner. `payloadFold` is a single slot, so the composition is spelled here — and
-// it still calls the one shared mapping rather than restating it.
+// Built WITH `IMAGE_TAG` since 2026-09-18, which is the reverse of what it used to do and for a
+// reason that reversed with it. It used to withhold the tag so the node would not get Image's
+// `payloadFold` — a single slot this primitive needed for its own derived style — and call the
+// shared mapping by hand at the end. The mapping is the ENGINE's now, reached off the tag, so the
+// tag is how this node gets the platform half at all; the JS slot is free for the composition.
+//
+// ONE ORDERING DIFFERENCE FALLS OUT, and it is deliberate rather than overlooked. The image rule
+// folds the image's own `width`/`height` PROPS under its style, and the background rule then layers
+// the box's dimensions over that — where RN nests it the other way (`ImageBackground.js:83-98` puts
+// the props under the proxied box size). So when an app sets BOTH a `width` prop on the
+// ImageBackground and a conflicting width in its `style`, RN gives the style's and we give the
+// prop's.
+//
+// It is left this way rather than reproduced: RN's own comment calls that nesting a "Temporary
+// Workaround" for an Image that overwrites its own dimensions, and an explicit prop winning over an
+// inherited box is the less surprising of the two. Pinned in
+// `core/components/src/behaviors/image-background.test.ts` so it stays a decision.
+//
+// THE TAG IS ITS OWN, and that is what the C++ port needed. The node used to carry plain `image`,
+// which is right for everything the ordinary image rule does and wrong for the fill — a bare
+// `<image>` must NOT be absolutely positioned. `image-background-image` is served by BOTH rules, the
+// ordinary one first, the same shape `usesPressableRule` gives `button` and the touchables. The
+// COMPONENT still resolves through `IMAGE_TAG`, because the native view is an ordinary RCTImageView.
 function buildBackgroundImage(node) {
     const descriptor = descriptorFor(IMAGE_TAG);
-    const image = createElement(descriptor.component, descriptor.isText);
-    image.payloadFold = imageFold(node);
+    const image = createElement(descriptor.component, descriptor.isText, IMAGE_BACKGROUND_IMAGE_TAG);
     appendChild(node, image);
     return image;
 }
@@ -127,13 +117,39 @@ const imageBackgroundBehavior = {
     slotDerived: IMAGE_BACKGROUND_SLOT_DERIVED,
     slotTakesNoChildren: true,
     buildStructure: buildBackgroundImage,
-    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.
     attach() { },
     detach() { },
 };
+// The inner image's registration, and it is NOT a formality twice over.
+//
+// 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 reason the ActivityIndicator spinner and the scroll content nodes carry one.
+//
+// And `resolvesImageSources` has to be repeated here rather than inherited from `image`: the lookup
+// is by TAG, this node's tag is its own, and the flag is what makes `routeProp` run
+// `require('./photo.png')` through Metro's asset registry on the way in. Without it an
+// ImageBackground would commit the raw asset NUMBER and paint nothing — headless included, since
+// the resolution is JS-side by necessity.
+const backgroundImageBehavior = {
+    resolvesImageSources: true,
+    attach() { },
+    detach() { },
+};
 export function registerImageBackgroundBehavior() {
+    // A REAL DEPENDENCY, declared rather than assumed. The inner node is a TAG now, so it gets its
+    // platform half — the engine's two rules, and the write-time source resolution — only through
+    // these registrations. It used to need nothing, because the fold was a function this file called
+    // directly.
+    //
+    // `register.ts` registers everything anyway, so nothing in an app depended on this; what depended
+    // on it was every test that registers one behavior and not the whole set, and a silent inner
+    // image with no rule is precisely the failure that would reach a device before it reached a
+    // suite. Idempotent, like every `register*` here.
+    registerImageBehavior();
+    registerHostBehavior(IMAGE_BACKGROUND_IMAGE_TAG, backgroundImageBehavior);
     registerHostBehavior(IMAGE_BACKGROUND_TAG, imageBackgroundBehavior);
 }

package/build/behaviors/image.d.ts

@@ -1,3 +1,2 @@
 export declare const IMAGE_TAG = "image";
-export declare function foldImagePayload(props: Readonly<Record<string, unknown>>): Record<string, unknown>;
 export declare function registerImageBehavior(): void;

package/build/behaviors/image.js

@@ -1,111 +1,30 @@
-// Image's host behavior, and it carries NOTHING but a prop fold — no listeners, no timers, no
-// commit hook. That is what a "fold-only" primitive means: the wrapper's whole body was prop
-// mapping, so its lowered form owes exactly that and nothing else.
+// Image's host behavior, and it carries no runtime at all — no listeners, no timers, no commit
+// hook, and since 2026-09-18 no fold either. What is left is ONE declaration: that this tag's three
+// source props are resolved on the way in.
 //
-// The fold itself is not written here. `mapImageProps` in `../view/render-image` is the one
-// implementation, and this file only narrows a flat prop bag into the typed view it takes — the
-// same shape `behaviors/text-input.ts` uses (`stringOf` / `booleanOf` guards, then hand the shared
-// resolver a typed object). A second copy of the mapping is the exact drift this primitive has
-// already paid for once: `adapters/svelte/src/components/image/image-logic.ts` reproduces it by
-// hand and says so in its own header, because nothing was exported to call.
+// WHERE THE FOLD WENT: `foldImageProps` in `SymbioteFabricProps.cpp`, with
+// `core/engine/cpp/tests/js/image-payload.itest.ts` as its contract. The `srcSet`/`src`/`source`
+// precedence, the W3C header decoration, the `width`/`height` fold into style, `alt` becoming
+// `accessibilityLabel` + `accessible`, `resizeMode`/`tintColor` falling back to style keys, and
+// `loadingIndicatorSource` being plucked down to a bare uri — all of it is a function of the tag,
+// which is what makes it the platform's.
 //
-// WHY THIS MAY SHARE THE WRAPPER'S TAG, where TextInput needed `-managed`. A behavior fold is keyed
-// on the tag, and `renderImage` emits `image` too — so on a wrapper-built node this fold
-// runs on ALREADY-FOLDED props. That is safe here and only here, because the mapping is idempotent:
-// every alias it consumes (`src`, `srcSet`, `alt`, `width`, `height`, …) is absent from its own
-// output, `source` comes back in the array shape `normalizeSource` guarantees, and
-// `loadingIndicatorSource` leaves under a DIFFERENT name (`loadingIndicatorSrc`), so a second pass
-// finds nothing left to fold. Idempotence is asserted in `image.test.ts` rather than assumed — the
-// audit rule's point is that a double fold is invisible precisely when it happens to be harmless,
-// so the property has to be pinned or it is an accident waiting to be broken.
+// WHY THIS ONE DID NOT MOVE WHOLE, and it is the first that did not. `resolveAssetSource` turns the
+// number `require('./logo.png')` returns into a `{uri, width, height, scale}` by asking METRO'S
+// ASSET REGISTRY — a JS module populated at bundle time. There is no such table in C++ and there
+// should not be: it belongs to the bundler, not to the platform.
+//
+// So the lookup moved EARLIER rather than across. `resolvesImageSources` tells `routeProp` to run
+// the three source props through the resolver on the way IN, exactly as it already resolves
+// `boxShadow`/`filter`/`transform` (`structured-style.ts`), and for the identical reason: a value
+// resolved at payload-build time is resolved HEADLESS ONLY, because the C++ builder has no JS to
+// call, and the device then commits the raw input for Fabric to drop in silence.
+//
+// The idempotence this file used to pin is GONE as a question rather than as a property. It
+// mattered because `renderImage` folded too and a re-render could hand the fold its own output;
+// there is one implementation now, at one point in the commit, so a bag cannot be folded twice.
 import { registerHostBehavior, } from '@symbiote-native/engine';
-import { IMAGE_VIEW_PROP_NAMES, mapImageProps, } from '../view/render-image/index.js';
 export const IMAGE_TAG = 'image';
-const RESIZE_MODES = new Set([
-    'cover',
-    'contain',
-    'stretch',
-    'repeat',
-    'center',
-]);
-const CROSS_ORIGINS = new Set([
-    'anonymous',
-    'use-credentials',
-]);
-const CONSUMED = new Set(IMAGE_VIEW_PROP_NAMES);
-function stringOf(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function numberOf(value) {
-    return typeof value === 'number' ? value : undefined;
-}
-function resizeModeOf(value) {
-    if (typeof value !== 'string' || !RESIZE_MODES.has(value))
-        return undefined;
-    // Narrowed by the set membership above, then re-stated as the union through a switch rather than
-    // a cast: the set and the type are two declarations of one list, and only this makes them agree.
-    switch (value) {
-        case 'cover':
-        case 'contain':
-        case 'stretch':
-        case 'repeat':
-        case 'center':
-            return value;
-        default:
-            return undefined;
-    }
-}
-function crossOriginOf(value) {
-    if (typeof value !== 'string' || !CROSS_ORIGINS.has(value))
-        return undefined;
-    return value === 'anonymous' ? 'anonymous' : 'use-credentials';
-}
-// A source is an asset id (number), a `{uri}` object, or an array of those. Anything else cannot be
-// resolved and is dropped rather than forwarded — a malformed source reaching Fabric paints nothing
-// and reports nothing, which is worse than an image that is simply absent.
-function sourceOf(value) {
-    if (typeof value === 'number')
-        return value;
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    if (Array.isArray(value))
-        return value;
-    if (typeof Reflect.get(value, 'uri') === 'string')
-        return { ...value };
-    return undefined;
-}
-// A StyleProp is an object, an array of them, or a registered class array — all of which
-// `flattenStyle` already handles. The only thing to exclude is a scalar.
-function styleOf(value) {
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    if (Array.isArray(value))
-        return value;
-    return { ...value };
-}
-export function foldImagePayload(props) {
-    const passthrough = {};
-    for (const key of Object.keys(props)) {
-        if (!CONSUMED.has(key))
-            passthrough[key] = props[key];
-    }
-    return mapImageProps({
-        source: sourceOf(props.source),
-        defaultSource: sourceOf(props.defaultSource),
-        loadingIndicatorSource: sourceOf(props.loadingIndicatorSource),
-        style: styleOf(props.style),
-        resizeMode: resizeModeOf(props.resizeMode),
-        tintColor: stringOf(props.tintColor),
-        src: stringOf(props.src),
-        srcSet: stringOf(props.srcSet),
-        alt: stringOf(props.alt),
-        width: numberOf(props.width),
-        height: numberOf(props.height),
-        crossOrigin: crossOriginOf(props.crossOrigin),
-        referrerPolicy: stringOf(props.referrerPolicy),
-        passthrough,
-    });
-}
 // Required by IHostBehavior and deliberately empty: Image owns no per-node runtime. Written out
 // rather than shared with a `noop` helper so the emptiness reads as a decision.
 function attach(_node) {
@@ -118,6 +37,6 @@ export function registerImageBehavior() {
     registerHostBehavior(IMAGE_TAG, {
         attach,
         detach,
-        foldPayload: foldImagePayload,
+        resolvesImageSources: true,
     });
 }

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

@@ -1,3 +1,2 @@
 export declare const INPUT_ACCESSORY_VIEW_TAG = "input-accessory-view";
-export declare function foldInputAccessoryViewPayload(props: Readonly<Record<string, unknown>>): Record<string, unknown>;
 export declare function registerInputAccessoryViewBehavior(): void;

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

@@ -1,58 +1,56 @@
-// InputAccessoryView's host behavior — a prop fold and nothing else. No listeners, no timers, no
-// commit hook: the wrapper's whole body was prop mapping, so its lowered form owes exactly that.
+// InputAccessoryView's host behavior. This file itself still owns no per-node runtime — the
+// primitive's real rule lives in `foldInputAccessoryViewProps` (`SymbioteFabricProps.cpp`) now.
 //
-// The fold is NOT written here. `mapInputAccessoryViewProps` in
-// `../view/render-input-accessory-view` is the one implementation and this file only narrows a flat
-// bag into the typed view it takes, the `stringOf` / `styleOf` guard idiom `behaviors/image.ts`
-// uses. Counted before starting, which is step one of the fold-only recipe: unlike Image, which had
-// THREE implementations, all five adapters already call the shared render fn and Svelte's
-// `input-accessory-view-props.ts` is a type declaration rather than a second mapping. So there was
-// one implementation to extract, not three to collapse.
+// THE OLD FOLD WAS GONE, not moved (2026-09-18): read end to end it split the bag into
+// consumed/passthrough and reassembled it — there was no aliasing at all, every consumed name left
+// under the same name, and the one thing it actually changed was dropping a `nativeID` or
+// `backgroundColor` that was not a `string`. That is defensive narrowing of a typed view object,
+// not a rule native cares about — and it was WRONG on `backgroundColor`, whose validAttributes
+// entry carries `processColor` and therefore accepts a number.
 //
-// SHARES THE WRAPPER'S TAG, no `-managed` twin. The two questions the recipe separates both answer
-// no: the fold is idempotent (there is no aliasing at all — every consumed name leaves under the
-// same name, so a second pass rewrites the same values), and the behavior carries no machine, so
-// nothing can end up with two owners on one node. Idempotence is asserted rather than reasoned.
+// A REAL RULE WAS FOUND WHILE READING VENDOR FOR THE PORT (2026-09-20):
+// `InputAccessoryView.js`'s `styles.container = {position: 'absolute'}`, composed AFTER the app's
+// own style (`[props.style, styles.container]`) so it wins over any `position` an app authors.
+// Every InputAccessoryView is positioned absolutely; nothing about it is per-instance, so it is
+// `foldInputAccessoryViewProps` now rather than anything here. Contract:
+// `core/engine/cpp/tests/js/touchable-payload.itest.ts`.
+//
+// NOT YET PORTED, and recorded honestly rather than silently skipped: vendor also wraps the app's
+// children in an inner `SafeAreaView` sized to `useWindowDimensions().width` (`InputAccessoryView.js`
+// render body) and returns nothing at all when it has zero children. Both are real structural gaps
+// — a composed child node plus a live window-dimension binding — genuinely larger than a tag-only
+// rule, and are NOT covered by this pass.
+//
+// TODO(rn-parity): port both. Needs (a) a `buildStructure` composing an inner wrapper node styled
+// `{flex: 1, width}` around the app's children, with `width` read from a live window-dimensions
+// subscription (no `SafeAreaView` primitive exists in this codebase yet — it would need building),
+// and (b) suppressing the whole node (both platforms, not just Android's void case already fixed
+// here) when it has zero children, matching `React.Children.count(props.children) === 0`.
+//
+// The `id -> nativeID` alias — is `foldIdAlias` in `SymbioteFabricProps.cpp`, applied to every
+// tagged node rather than per primitive.
 //
 // PLATFORM. This is the only primitive in its group that is not platform-invariant in what it
 // COMMITS TO: `input-accessory-view` resolves to `RCTInputAccessoryView` on iOS and to a
-// plain `RCTView` on Android. The fold itself is platform-invariant on purpose — it reproduces the
-// wrapper's mapping exactly, on both platforms, so the lowered and wrapped paths cannot diverge
-// per-platform. What it does NOT do is fix the pre-existing Android divergence underneath it:
-// upstream RN renders NOTHING there (`InputAccessoryView.js` — `console.warn('<InputAccessoryView>
-// is only supported on iOS.'); return null`), while we commit an RCTView, and `backgroundColor` is
-// a declared prop of the iOS view but a style key on RCTView. Both predate this behavior and are
-// identical on both paths; neither is in scope here, and a fold that "fixed" one silently would
-// make the two paths disagree.
+// plain `RCTView` on Android. The fold itself is platform-invariant on purpose.
+//
+// FIXED (2026-09-20). `InputAccessoryView.js` on Android does `console.warn('<InputAccessoryView>
+// is only supported on iOS.'); return null` — the WHOLE component, children included, renders
+// NOTHING. We used to commit a real `RCTView` and its whole children subtree (the toolbar content
+// an app wrapped in it) — an extra, laid-out, potentially visible view where a real device shows
+// none. `backgroundColor` being a declared iOS prop vs an Android style key is the SAME already-
+// narrow gap, unaffected by this.
+//
+// The fix needed a new engine primitive, because every existing "commits no node of its own"
+// tier-2 primitive (`touchable-native-feedback`, `touchable-without-feedback`) is an ANCHOR — it
+// hoists its single child up in its own place, which is the opposite of what this tag needs: its
+// whole subtree must vanish. `VOID_COMPONENT` (`core/engine/src/node.ts`, `OP_CREATE_VOID` in
+// `mutation-buffer.ts`) is that primitive — a node the commit walk stops at, recursively,
+// contributing neither itself nor its children. Wired purely through
+// `core/components/src/component-names/index.android.ts`'s per-platform table, the same seam
+// `ANCHOR_COMPONENT` already used — this behavior file needed no change at all.
 import { registerHostBehavior, } from '@symbiote-native/engine';
-import { INPUT_ACCESSORY_VIEW_PROP_NAMES, mapInputAccessoryViewProps, } from '../view/render-input-accessory-view.js';
 export const INPUT_ACCESSORY_VIEW_TAG = 'input-accessory-view';
-const CONSUMED = new Set(INPUT_ACCESSORY_VIEW_PROP_NAMES);
-function stringOf(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-// A StyleProp is an object, an array of them, or a registered class array — all shapes
-// `flattenStyle` already handles. Only a scalar has to be excluded.
-function styleOf(value) {
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    if (Array.isArray(value))
-        return value;
-    return { ...value };
-}
-export function foldInputAccessoryViewPayload(props) {
-    const passthrough = {};
-    for (const key of Object.keys(props)) {
-        if (!CONSUMED.has(key))
-            passthrough[key] = props[key];
-    }
-    return mapInputAccessoryViewProps({
-        nativeID: stringOf(props.nativeID),
-        backgroundColor: stringOf(props.backgroundColor),
-        style: styleOf(props.style),
-        passthrough,
-    });
-}
 // Required by IHostBehavior and deliberately empty: this primitive owns no per-node runtime.
 // Written out rather than shared with a `noop` so the emptiness reads as a decision.
 function attach(_node) {
@@ -62,9 +60,5 @@ function detach(_node) {
     // nothing to release
 }
 export function registerInputAccessoryViewBehavior() {
-    registerHostBehavior(INPUT_ACCESSORY_VIEW_TAG, {
-        attach,
-        detach,
-        foldPayload: foldInputAccessoryViewPayload,
-    });
+    registerHostBehavior(INPUT_ACCESSORY_VIEW_TAG, { attach, detach });
 }

package/build/behaviors/pressable.d.ts

@@ -56,5 +56,5 @@ export declare function detachPressMachine(node: ISymbioteNode): void;
  * WeakMap holding the machine's own state is keyed by node, so one node may hold exactly one of
  * these; a tag composing it therefore must not also register the plain `pressable` behavior.
  */
-export declare function createPressBehavior(refine?: IPressConfigRefinement, disabledOf?: IDisabledResolver): Pick<IHostBehavior, 'attach' | 'detach' | 'foldPayload' | 'ownedListeners'>;
+export declare function createPressBehavior(refine?: IPressConfigRefinement, disabledOf?: IDisabledResolver): Pick<IHostBehavior, 'attach' | 'detach' | 'ownedListeners'>;
 export declare function registerPressableBehavior(): void;