@symbiote-native/components 2.0.0 → 3.0.1

package/build/view/render-touchable-native-feedback.js

@@ -32,15 +32,21 @@ export function selectableBackgroundBorderless(rippleRadius) {
 export function rippleBackground(color, borderless, rippleRadius) {
     return { type: 'RippleAndroid', color, borderless, rippleRadius };
 }
-// Maps the resolved background + useForeground onto the native prop Android reads. useForeground
-// only paints the foreground when the platform supports it (canUseNativeForeground); otherwise it
-// falls back to the background slot, matching RN. On iOS both props are inert.
-export function backgroundProps(background, useForeground) {
-    if (useForeground && canUseNativeForeground()) {
-        return { nativeForegroundAndroid: background };
-    }
-    return { nativeBackgroundAndroid: background };
-}
+// `backgroundProps` WAS HERE AND IS GONE (2026-09-18). It mapped the resolved background plus
+// `useForeground` onto the native slot Android reads, and that is the `#ifdef ANDROID` tail of
+// `foldCloneOntoChild` in `SymbioteFabricProps.cpp` — api-level gate included, since
+// `Platform.Version` on Android IS the api level and `androidApiLevel()` reads the same number.
+//
+// A JS COPY OF A RULE THAT RUNS IN C++, with no runtime caller and no test, reachable only through
+// the package barrel. Found by asking what each `Platform.OS` branch still left in
+// `core/components` is FOR. Its C++ twin is covered on both arms —
+// `android-rules.android.itest.ts` asserts the foreground slot and `clone-onto-child-payload.itest.ts`
+// asserts its absence off Android — and break-testing the gate fires exactly one of them.
+//
+// `canUseNativeForeground` below stays, and the distinction is the reusable half: it is a QUESTION
+// an app asks the platform (`TouchableNativeFeedback.canUseNativeForeground()` is RN's own public
+// static), not a rule that decides a payload. Same class as the slider reading a folded
+// `accessibilityState` — asking is not reimplementing.
 /**
  * RN's four statics, under RN's own spelling — `TouchableNativeFeedback.Ripple(color, borderless)`.
  *

package/host-primitives.cjs

@@ -11,7 +11,7 @@
 // Vue and Solid apply the same fold in their renderers. Both are correct.
 //
 // Four transforms carried their own copy of this before it existed, and it had already produced a
-// real behaviour split — see `aliases` below.
+// real behaviour split — the `aliases` note below is what is left of it.
 
 // `intrinsicWhen` DECLARED AHEAD OF ITS FIRST ENTRY.
 //
@@ -35,60 +35,29 @@
 // (vitest does not typecheck). The reverse is worse and silent: a field in the `.d.cts` and not
 // here typechecks everywhere and arrives `undefined` in all five transforms. Change both, together.
 /**
- * @typedef {{ op: 'nullish', value: unknown } | { op: 'notFalse' }} IFoldOp
  * @typedef {{ prop: string, intrinsic: string }} IIntrinsicWhen
- * @typedef {{ intrinsic: string, aliases: Record<string, string>, defaults: Record<string, IFoldOp>, intrinsicWhen?: IIntrinsicWhen }} IHostPrimitive
+ * @typedef {{ intrinsic: string, intrinsicWhen?: IIntrinsicWhen }} IHostPrimitive
  */
 
-// `id` is RN's W3C-named alias for `nativeID` and it WINS when both are set. Verified against RN
-// 0.86 rather than against our own adapters, because the three that implemented it disagreed:
-//
-//   View.js:77-79   if (id !== undefined) processedProps.nativeID = id;
-//   Text.js:222     const _nativeID = id ?? nativeID;
-//
-// Same outcome on both tags: `nativeID = id ?? nativeID`, and the raw `id` key must NOT reach
-// Fabric (no ViewConfig declares it, so it is silently dropped). What the adapters actually did:
-// Solid folded it on both tags, Svelte on View only (its `else` branch skips Text), and Vue on
-// neither — not in either transform, not in its renderer, not in `routeProp`. Vue's gap is OLDER
-// than lowering (its `View` wrapper was always a bare pass-through), so it is a standing
-// <adapters_reach_full_feature_parity> miss, not a lowering regression.
-//
-// WHICH LAYER APPLIES IT IS THE ADAPTER'S CHOICE, exactly as for `defaults` below. Solid and
-// Svelte rename at COMPILE time inside the lowering transform; Vue applies it at RUNTIME
-// (`PROP_ALIASES` in `adapters/vue/src/renderer/index.ts`, in `patchProp`) because Vue has FOUR
-// paths to a node — lowered SFC, lowered TSX, the component wrapper, and a hand-written
-// `h('view', {id})` — and compile time only covers two of them. A transform reading this
-// spec must therefore not assume it owns the fold. Applying it at both layers happens to be
-// harmless here (the rename deletes `id`, so the second pass sees nothing), but that is a property
-// of THIS alias, not a licence.
-//
-// KNOWN DIVERGENCE FROM UPSTREAM, present in two adapters and not introduced by this file: when an
-// element carries BOTH `id` and `nativeID`, RN gives `id` unconditional priority, while a per-key
-// rename (Vue's runtime patchProp, Solid's compile-time rename producing two `nativeID`
-// attributes) lets the LAST one win. Honest parity needs per-node state; no example and no test
-// sets both today.
-const ID_ALIAS = { id: 'nativeID' };
+// `aliases` LEFT THIS SPEC ON 2026-09-18, and what it held was one pair — `id` -> `nativeID` —
+// repeated on all nineteen entries. It is `routeProp`'s now
+// (`core/engine/cpp/tests/js/id-alias-coverage.itest.ts`), which reaches every node rather than
+// every REGISTERED one, and resolves precedence the way upstream does instead of by write order.
 
 /** @type {Record<string, IHostPrimitive>} */
 const HOST_PRIMITIVES = {
   View: {
     intrinsic: 'view',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // The five-way switch, thrown 2026-08-23 once all three transforms carried the refusals
   // (`observesState` below). `pressable` resolves to the SAME `RCTView` a plain view does
   // — the tag exists only so the host-behavior registry, which is keyed by TAG and never by
   // resolved name, can find the press machine.
   //
-  // No defaults, and only the `id` -> `nativeID` alias every primitive carries: a lowered Pressable
-  // forwards its props otherwise untouched, and the machine reads them off `node.props` at event
-  // time. (This read "No aliases and no defaults" while the line below already said `ID_ALIAS`, and
-  // a Solid test injected a `Pressable` entry with `aliases: {}` on the strength of it.)
+  // No defaults: the tag forwards its props untouched, and the machine reads them off `node.props`
+  // at event time.
   Pressable: {
     intrinsic: 'pressable',
-    aliases: ID_ALIAS,
-    defaults: {},
     // Turns on `stateInTemplate` and `renderPropChild`. Without them a render-prop button becomes
     // a tag with no machine — the whole reason this entry landed last.
     observesState: true,
@@ -102,21 +71,11 @@ const HOST_PRIMITIVES = {
   // derives its element set from this table and both Vue compilers read it. Missing here, the tag
   // cost a dev-mode resolve warning per element plus the component codegen path — a slot closure
   // instead of `_createElementBlock`.
-  //
-  // `aliases: ID_ALIAS` even though each behavior's own `foldPayload` already renames `id`. The
-  // two COMPOSE: `foldHostBag` deletes the source key, so the behavior's fold finds no `id` and is
-  // a no-op. Measured on the committed payload rather than reasoned, both arms identical — the
-  // check `adapter-parity-audit.md` demands before declining a majority value, run in the
-  // direction of accepting one.
   TouchableOpacity: {
     intrinsic: 'touchable-opacity',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   TouchableHighlight: {
     intrinsic: 'touchable-highlight',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // The second primitive whose TAG depends on a prop, and the first where the prop is one RN's own
   // API takes (`<ScrollView horizontal>`): the axis is a SEPARATE native ViewManager, not a flag on
@@ -125,8 +84,6 @@ const HOST_PRIMITIVES = {
   // Vue's element set — a tag apps write directly and which would otherwise resolve as a component.
   ScrollView: {
     intrinsic: 'scroll-view',
-    aliases: ID_ALIAS,
-    defaults: {},
     intrinsicWhen: {
       prop: 'horizontal',
       intrinsic: 'horizontal-scroll-view',
@@ -137,18 +94,10 @@ const HOST_PRIMITIVES = {
   // kept because the SEQUENCE is the reusable part — an entry here is a switch for four transforms
   // at once, so it goes in after every side is ready, never to prove the transforms work.
   //
-  // 1. `registerTextInputBehavior()` is now called by `adapters/{vue,svelte,solid}/src/register.ts`,
-  //    the three that lower. React and Angular have no lowering transform, so no lowered node ever
-  //    exists there and neither carries a `register.ts` — the same reason they skip Pressable's.
-  //
-  // 2. The component path no longer shares these tags. It renders `text-input-managed`
-  //    (`component-names/shared.ts`), because the registry is keyed by TAG and the wrappers run the
-  //    same machine in their own lifecycle — one shared tag would have installed both copies on a
-  //    wrapper-built node and fired `setInputFocused` twice per focus.
+  // `registerTextInputBehavior()` is called by every adapter's `src/register.ts`: the tag is the
+  // only path an app has, so the machine has exactly one owner per node.
   TextInput: {
     intrinsic: 'text-input',
-    aliases: ID_ALIAS,
-    defaults: {},
     // `multiline` picks between two SEPARATE native views, not one view with a flag, so the tag is
     // decided at compile time and a runtime selector must refuse — a wrong view here is
     // uncorrectable by any later prop write.
@@ -158,25 +107,18 @@ const HOST_PRIMITIVES = {
     },
   },
   // Landed 2026-09-01, same order as TextInput and Image: runtime half built
-  // (`core/components/src/behaviors/switch.ts`), registered by the four lowering adapters, proven
+  // (`core/components/src/behaviors/switch.ts`), registered by every adapter, proven
   // against the wrapper's payload (positive + negative controls, a break-tested async-timing case)
   // before this key existed.
   //
-  // `-managed` twin, same reason as TextInput: the behavior carries a machine (mirrors the last
-  // value native reported, sends a platform snap-back command on disagreement), so a wrapper-built
-  // node — which already runs that same machine in its own lifecycle — must not also get the
-  // engine's copy. `render-switch.ts` emits `switch-managed`; this key's `intrinsic` is
-  // the bare tag the behavior registry attaches to.
+  // The behavior carries a machine: it mirrors the last value native reported and sends a platform
+  // snap-back command on disagreement.
   //
-  // IDEMPOTENCE OF THE FOLD IS MOOT HERE FOR A DIFFERENT REASON THAN IMAGE'S. Image's entry has no
-  // `-managed` twin, so its fold genuinely CAN run twice (component then lowered, same tag), and
-  // idempotence is what makes that safe — asserted, not assumed. Switch's fold is NOT trivial (it
-  // maps `trackColor`/`thumbColor`/`ios_backgroundColor` to native prop names, keyed on
-  // `Platform.OS`) and running it twice would NOT be a no-op — but the question never arises: the
-  // `-managed` split means only the bare `switch` tag ever carries this behavior, and the
-  // wrapper never emits that tag, so no node's payload ever passes through this fold more than
-  // once. Unreachable by construction, not idempotent by property — the same distinction
-  // TextInput's own entry draws for its fold.
+  // ITS FOLD IS NOT IDEMPOTENT, and that is safe for a reason Image's entry does not share. Switch
+  // maps `trackColor`/`thumbColor`/`ios_backgroundColor` onto native prop names keyed on
+  // `Platform.OS`, so running it twice would NOT be a no-op — the question never arises because a
+  // payload reaches this fold once, on the one tag that carries the behavior. Unreachable by
+  // construction, not idempotent by property.
   //
   // No `observesState`: nothing in Switch's public surface is a function-valued style or a
   // render-prop child (`style?: IStyleProp<IViewStyle>`, never a callback), so neither
@@ -184,8 +126,6 @@ const HOST_PRIMITIVES = {
   // forced that flag.
   Switch: {
     intrinsic: 'switch',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // Filed as NOT LOWERABLE for a week under `.claude/rules/host-primitive-tier.md`'s "SECOND
   // disqualifier" — its own node is a single element, but its POSITION is decided by the ScrollView
@@ -202,97 +142,59 @@ const HOST_PRIMITIVES = {
   // the five wrappers folded exactly `resolveAccessibilityProps`, which the engine already runs at
   // `fabricProps` on every path — the same reason SafeAreaView has no behavior file.
   //
-  // ID_ALIAS, and it is the SafeAreaView resolution rather than the SafeAreaView position: none of
-  // the five wrappers declared `id`, and upstream's RefreshControl spreads `...ViewProps`
-  // (RefreshControl.js:70), so that was a standing parity gap rather than a deliberate omission.
-  // The prop is declared on all five in the same change as this alias — half of it in either
-  // direction is broken (a fold for a key nobody can pass, or a raw `id` reaching a view whose
-  // ViewConfig declares none).
-  //
-  // No `-managed` twin: the behavior carries a machine, so it needs one owner per node, and it has
-  // one — the wrappers forward to this tag and none of them runs a mirror any more.
+  // `id` is declared on all five wrappers, which it was not until 2026-09-01: upstream's
+  // RefreshControl spreads `...ViewProps` (RefreshControl.js:70), so its absence was a parity gap
+  // rather than a decision. The rename itself is the engine's.
   RefreshControl: {
     intrinsic: 'refresh-control',
-    aliases: ID_ALIAS,
     // None. RN seeds nothing: `refreshing` is required, and every other prop is per-platform
     // styling the native view defaults itself.
-    defaults: {},
   },
+  // `defaults` LEFT THIS SPEC ON 2026-09-18, and Text was the last entry that had any — RN's
+  // `ellipsizeMode ?? 'tail'` and `allowFontScaling !== false` (`Text.js:289,291`). The other
+  // eighteen entries had declared `{}` for months.
+  //
+  // It was the THIRD copy of that one rule. `applyTextDefaults` (`core/engine/src/fabric-props.ts`)
+  // and its C++ twin apply both to every node committing as `RCTText`, whoever authored it and
+  // whatever tag it carries — strictly WIDER than this table, which reached only a registered
+  // primitive. Proven redundant rather than argued: emptying it turned ZERO itests red, and the
+  // itests are the side that reads a real committed payload.
   Text: {
     intrinsic: 'text',
-    aliases: ID_ALIAS,
-    // RN's Text.js applies both unconditionally on the non-virtual path. Each key below cites
-    // the upstream line verbatim, because THIS DATA is now the thing that must not drift from RN.
-    // The
-    // authority on what they MEAN is `src/text-props.ts`'s resolveTextProps, which every wrapper
-    // path already calls; this is the same fold expressed as data so a COMPILE-time transform can
-    // emit it too. `notFalse`, never `nullish` — RN treats an explicit `undefined` like a missing
-    // prop and only a literal `false` opts out. Emit both keys unconditionally: a fold whose two
-    // branches emit different key sets is the hazard `.claude/rules/solid-descriptor-bridge.md` §1
-    // exists for.
-    defaults: {
-      // Text.js:291  processedProps.ellipsizeMode = ellipsizeMode ?? 'tail';
-      ellipsizeMode: { op: 'nullish', value: 'tail' },
-      // Text.js:289  processedProps.allowFontScaling = allowFontScaling !== false;
-      allowFontScaling: { op: 'notFalse' },
-    },
   },
   // FOLD-ONLY: the behavior registered for this tag carries a prop fold and nothing else — no
-  // listeners, no commit hook, no per-node runtime (`core/components/src/behaviors/image.ts`). The
-  // whole of the wrapper's body was prop mapping, so the lowered form owes exactly that.
+  // listeners, no commit hook, no per-node runtime (`core/components/src/behaviors/image.ts`).
   //
-  // No `-managed` twin, unlike TextInput, and the reason is a measured PROPERTY rather than a
-  // precedent: `mapImageProps` is idempotent, so registering the fold on the tag `renderImage`
-  // already emits means a wrapper-built node simply folds a second time to no effect. Asserted in
-  // `behaviors/image.test.ts`; break-tested. TextInput's split is NOT about idempotence (its fold
-  // is idempotent too) — it is about one owner per node, because that behavior carries a machine.
+  // `mapImageProps` is idempotent, asserted in `behaviors/image.test.ts` and break-tested, so a bag
+  // that reaches the fold twice folds to no effect.
   //
-  // Entered LAST, after the runtime half was built, registered by all four lowering adapters and
-  // proven against the wrapper's payload. Adding this key is what makes every transform start
-  // lowering `Image` at once, so a fold that had not landed would surface as a raw `src` reaching
-  // Fabric — a key no ViewConfig declares, which throws nothing and paints nothing.
+  // The runtime half has to land before this key does: without the fold a raw `src` reaches Fabric,
+  // a key no ViewConfig declares, which throws nothing and paints nothing.
   // THE ENTRY IS NOT OPTIONAL HERE, and the reason has nothing to do with folds: this table is what
   // `adapters/vue/intrinsic-tags.cjs` derives element-vs-component from, and a hyphenated tag it
   // does not name compiles to `resolveComponent("image-background")` — children become a slot the
   // element path never reads, so the subtree renders BLANK with no error. `image`/`view`/`text` are
   // real SVG element names and survive that gap; this one is not.
-  //
-  // `aliases: ID_ALIAS` was MEASURED against the arm without it rather than reasoned about, because
-  // `behaviors/image-background.ts` folds `id` itself on the built image. Both arms commit
-  // `nativeID` on the image and no `id` anywhere, and the two compose because an alias DELETES its
-  // source key — so the second pass finds nothing. Kept for the property `foldHostBag` provides and
-  // the behavior cannot: the rename happens on the OWNER bag, before the redirect, so any adapter
-  // path that folds bags gets it whether or not the behavior ever runs.
   ImageBackground: {
     intrinsic: 'image-background',
-    aliases: ID_ALIAS,
     // None. The absolute-fill style, the box-dimension proxy and the Image mapping are all derived
     // from live props at commit, which a compile-time seed cannot express.
-    defaults: {},
   },
   Image: {
     intrinsic: 'image',
-    aliases: ID_ALIAS,
     // None. Every default RN's Image applies is already inside the shared mapping (the source
     // array shape, the width/height style fold, `alt` -> accessibilityLabel), which the behavior
     // runs at commit — so there is nothing left for a compile-time seed to do.
-    defaults: {},
   },
-  // Entered LAST, same order Image used: runtime half built, registered by the four lowering
-  // adapters, and proven against the wrapper's payload before this key existed.
-  //
   // The ONLY primitive so far whose intrinsic resolves to a different Fabric component per
   // platform — `RCTInputAccessoryView` on iOS, a plain `RCTView` on Android. The fold is
-  // platform-invariant on purpose (it reproduces the wrapper's mapping on both, so the lowered and
-  // wrapped paths cannot diverge per platform); what it does NOT do is repair what sits underneath,
-  // where upstream RN renders nothing at all off iOS. That divergence predates the lowering, is
-  // identical on both paths, and is with the owner as its own decision.
+  // platform-invariant on purpose; what it does NOT do is repair what sits underneath, where
+  // upstream RN renders nothing at all off iOS. That divergence is with the owner as its own
+  // decision.
   InputAccessoryView: {
     intrinsic: 'input-accessory-view',
-    aliases: ID_ALIAS,
     // None. The mapping has no aliasing and no derived value — every consumed name leaves under the
     // same name — so there is nothing for a compile-time seed to do.
-    defaults: {},
   },
   // The emptiest entry here, and deliberately so — the withholding protocol has nothing to protect
   // for this one. Every other primitive was held back until its runtime half existed and was proven
@@ -307,35 +209,8 @@ const HOST_PRIMITIVES = {
   // `safe-area-view` with children on its framework's own channel (React's third argument,
   // a Vue slot, a Solid JSX child, Angular's `<ng-content>`, a Svelte snippet). That clears the
   // disqualifier in `.claude/rules/host-primitive-tier.md`.
-  //
-  // NO `ID_ALIAS`, and this is the one place SafeAreaView departs from every entry above it. The
-  // alias exists to REPRODUCE a fold the wrapper performs; not one of the five SafeAreaView wrappers
-  // folds `id`, and none declares it. Adding the alias here would make the lowered element fold a
-  // prop its component spelling passes through untouched — a lowering that ADDS a capability, which
-  // `.claude/rules/adapter-parity-audit.md` records as a bug in the same way as one that drops it.
-  // That the five entries above all share `ID_ALIAS` is a property of those five primitives, not a
-  // house style to copy: the sixth is where "every case so far did X" stops being a rule.
-  //
-  // The `id` surface gap itself is real and PRE-EXISTING — upstream's SafeAreaView takes `ViewProps`,
-  // so RN accepts `id` where our wrappers do not. It predates lowering, is identical on both paths,
-  // and closing it means adding `id` to five wrappers AND this alias together, never one of the two.
   SafeAreaView: {
     intrinsic: 'safe-area-view',
-    // ID_ALIAS was deliberately ABSENT here until 2026-09-01, because none of the five wrappers
-    // declared `id` and aliasing on the lowered path alone would have made lowering ADD a fold the
-    // component spelling does not perform. That exposed a real divergence — Solid's renderer folds
-    // `id` from two string constants on the write path, so it aliased for a primitive whose spec
-    // said not to (`adapters/solid/src/renderer-alias-fold.test.ts`, whose header predicted exactly
-    // this the day a primitive stopped sharing the pair).
-    //
-    // Resolved by closing the gap rather than routing around it: `id` is now declared on all five
-    // wrappers and folded here. That keeps Solid's constant-pair fast path (32 001 writes on a
-    // benchmark create) and removes a real parity deficit — upstream's SafeAreaView takes the full
-    // ViewProps surface, so RN accepts `id` where none of ours did. Half of this is not an option
-    // in either direction: the alias without the prop folds a key nobody can pass, and the prop
-    // without the alias sends a raw `id` to a view whose ViewConfig declares no such key.
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // The one primitive that commits NO NODE: its intrinsic resolves to the engine's anchor, and the
   // behavior (`src/behaviors/touchable-native-feedback.ts`) clones the owner's props onto the single
@@ -343,22 +218,11 @@ const HOST_PRIMITIVES = {
   // that deletes the five wrappers, because the registry is keyed by TAG: a wrapper still emitting
   // its own `pressable` while the behavior is registered would put two press machines on one tree.
   //
-  // ID_ALIAS, and it was proposed WITHOUT one on the reasoning that the behavior already reads
-  // `id ?? nativeID` itself (:373) so the shared alias would double-fold. Measured instead of
-  // reasoned (`behaviors/touchable-native-feedback.test.ts`, "folds `id` the same whichever layer
-  // renamed it"): the two compose idempotently — the alias renames on the OWNER, whose props never
-  // reach Fabric, and the behavior's `??` then reads the renamed key to the same answer. Declining
-  // the pair would have bought nothing and broken Solid's constant-pair fast path, whose guard
-  // (`adapters/solid/src/renderer-alias-fold.test.ts`) is what makes one string compare legal on
-  // 32 001 prop writes.
-  //
   // No `defaults`: RN's TNF seeds nothing at all — every value it derives (`accessible`,
   // `focusable`, `accessibilityState`, the ripple background) depends on ANOTHER prop or on a
   // listener, which is a fold and not a default.
   TouchableNativeFeedback: {
     intrinsic: 'touchable-native-feedback',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // The SECOND primitive that commits no node, same anchor shape and same reason
   // (TouchableWithoutFeedback.js:229,286). Its clone list is not TNF's: the passthrough half is
@@ -366,16 +230,13 @@ const HOST_PRIMITIVES = {
   // drops them — read `src/behaviors/touchable-without-feedback.ts`'s header rather than inheriting
   // the neighbour's fold.
   //
-  // ID_ALIAS for the reason measured on TNF: the alias renames on the OWNER, whose props never reach
-  // Fabric, and the behavior's own `id ?? nativeID` then reads the renamed key to the same answer.
   // Upstream's passthrough loop lets an explicit `nativeID` win over `id` here (:280-284, unlike
-  // TNF's :373); NOT reproduced, because with the alias in place that quirk would depend on which
-  // adapter folds where. No `defaults` — every value TWF derives depends on another prop or on a
-  // listener, which is a fold and not a default.
+  // TNF's :373); NOT reproduced — the engine resolves that precedence once, on the way in, and a
+  // per-primitive exception to it would be invisible from anywhere the app can see. No `defaults`:
+  // every value TWF derives depends on another prop or on a listener, which is a fold and not a
+  // default.
   TouchableWithoutFeedback: {
     intrinsic: 'touchable-without-feedback',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // RN's Button is a touchable wrapping a View wrapping a Text and takes NO children — `title` is a
   // string prop (Button.js:363-388) — so the behavior owns the whole subtree and the tag is the
@@ -383,50 +244,35 @@ const HOST_PRIMITIVES = {
   // by TAG, and a wrapper still building its own View/Text under a registered `button` would give
   // every existing Button a second copy of the subtree.
   //
-  // ID_ALIAS, and here it is REQUIRED rather than inherited — the one entry so far where declining
-  // it would have shipped a PLATFORM-DEPENDENT bug. Button's touchable is swapped by platform
-  // (Button.js:281-284), and only one of the two arms renames `id` itself: `touchable-opacity`'s
-  // own `foldPayload` does (it has no spec entry to do it for it), the bare press behavior does not
-  // (`Pressable`'s entry does it instead). Measured on the committed payload, no entry here:
+  // `id` used to be PLATFORM-DEPENDENT here, and the record is worth keeping because it is what a
+  // per-primitive rename costs. Button's touchable is swapped by platform (Button.js:281-284), only
+  // the iOS arm renamed `id` itself, and with no entry in this table the committed payload read:
   //
   //   iOS      nativeID: 'from-id'   id: absent      the touchable-opacity fold
   //   Android  nativeID: undefined   id: 'from-id'   a key no ViewConfig declares -> dropped
   //
-  // So the alias is what makes the two platforms agree, and it composes idempotently with the
-  // iOS-side fold exactly as TNF's does: the rename happens on the bag, so `Object.hasOwn(next,
-  // 'id')` one layer down finds nothing left to do.
+  // A rename that runs once, for every node, on the way in cannot produce that shape at all.
   //
   // No `defaults`: every value RN's Button seeds is derived from another prop or from a listener
   // (`accessible`, `focusable`, the greyed label, the uppercased title), which is a fold, not a
   // default.
   Button: {
     intrinsic: 'button',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
   // RN wraps the native spinner in a centering `<View>` (ActivityIndicator.js:112), so this tag is
   // that View and the behavior builds `activity-indicator-spinner` under it. Entered in the same
   // commit that deletes the five wrappers: the registry is keyed by TAG, and a wrapper still
   // painting its own spinner while the behavior is registered would give every indicator two.
   //
-  // ID_ALIAS, and unlike Button's it is not platform-dependent — measured on the committed payload,
-  // both platform arms, with the entry absent:
-  //
-  //   iOS      spinner: id 'probe'   nativeID absent    ActivityIndicatorView declares no `id`
-  //   Android  spinner: id 'probe'   nativeID absent    AndroidProgressBar declares no `id`
-  //
-  // i.e. identically broken on both, because the platform half of this primitive is the spinner's
-  // COLOUR and native extras, and nothing about it touches the name fold. The alias renames on the
-  // OWNER's bag, before `slotPropsExcept` routes the survivor down — so the key that reaches the
-  // spinner is `nativeID`, which is where RN's `...restProps` puts it too (ActivityIndicator.js:99).
+  // `id` renames on the OWNER, before `slotPropsExcept` routes the survivor down — so the key that
+  // reaches the spinner is `nativeID`, which is where RN's `...restProps` puts it too
+  // (ActivityIndicator.js:99).
   //
   // No `defaults`: `animating` and `hidesWhenStopped` ARE `notFalse` folds, but they belong to the
   // SPINNER, and this table's ops are applied to the tag's own bag before any slot routing. They
   // live in the behavior's spinner fold instead, which is the only layer that can see that node.
   ActivityIndicator: {
     intrinsic: 'activity-indicator',
-    aliases: ID_ALIAS,
-    defaults: {},
   },
 };
 module.exports = { HOST_PRIMITIVES };

package/host-primitives.d.cts

@@ -6,7 +6,6 @@ export type IFoldOp = { op: 'nullish'; value: unknown } | { op: 'notFalse' };
 
 export interface IHostPrimitive {
   intrinsic: string;
-  aliases: Readonly<Record<string, string>>;
   defaults: Readonly<Record<string, IFoldOp>>;
   /**
    * The primitive's own state is observable from the TEMPLATE, so a call site that reads it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/components",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "description": "Framework-agnostic component logic (state machines + render functions) for SymbioteNative — written once, inherited by every adapter (React, Vue, Angular, ...).",
   "license": "MIT",
   "repository": {
@@ -40,10 +40,6 @@
       "types": "./host-primitives.d.cts",
       "default": "./host-primitives.cjs"
     },
-    "./fold-host-bag": {
-      "types": "./build/fold-host-bag.d.ts",
-      "default": "./build/fold-host-bag.js"
-    },
     "./resolve-intrinsic": {
       "types": "./build/resolve-intrinsic.d.ts",
       "default": "./build/resolve-intrinsic.js"
@@ -63,11 +59,11 @@
   },
   "peerDependencies": {
     "react-native": ">=0.86",
-    "@symbiote-native/engine": "^0.5.0"
+    "@symbiote-native/engine": "^1.2.0"
   },
   "devDependencies": {
     "@types/node": "^26.0.0",
-    "@symbiote-native/engine": "0.5.0"
+    "@symbiote-native/engine": "1.2.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/build/fold-host-bag.d.ts

@@ -1,15 +0,0 @@
-import { type IFoldOp } from '../host-primitives.cjs';
-export type IHostBag = Record<string, unknown>;
-interface IFoldPlan {
-    readonly aliases: ReadonlyArray<readonly [string, string]>;
-    readonly defaults: ReadonlyArray<readonly [string, IFoldOp]>;
-}
-export declare const FOLD_PLAN_BY_TAG: ReadonlyMap<string, IFoldPlan>;
-/**
- * Apply a primitive's aliases and defaults to a bag, copy-on-write.
- *
- * Never mutates the input: the bag belongs to whoever built it, and a framework may hand the same
- * object back on a re-render, so writing into it would leak a fold into the author's own state.
- */
-export declare function foldHostBag(tagName: string, bag: IHostBag): IHostBag;
-export {};

package/build/fold-host-bag.js

@@ -1,99 +0,0 @@
-// The RUNTIME half of `HOST_PRIMITIVES` — RN's prop folds applied to a props bag on its way into
-// the engine, keyed by intrinsic tag.
-//
-// Why it exists at all. A primitive's host node is produced by THREE paths, and the compile-time
-// fold in a lowering transform covers exactly one of them:
-//
-//   lowered `<View>`         the transform folded it     covered by the transform
-//   `<View>` it refused      the wrapper folds it        covered by the wrapper
-//   a hand-authored tag      nobody folds it             covered by NOTHING
-//
-// The third path is not hypothetical: Svelte's `components/button.svelte` writes `<text>`
-// directly rather than composing `Text.svelte`, so its title reached Fabric with no
-// `ellipsizeMode` and clipped mid-word where every other adapter ellipsised (2026-08-31). Angular
-// shipped the identical defect from the identical cause, and both fixed it the same way — a seed
-// in the layer every path crosses.
-//
-// Why it is SHARED rather than one copy per adapter: an adapter that lowers has a transform doing
-// this at compile time, an adapter that does not has only this, and a primitive with no wrapper at
-// all (a bare intrinsic tag) has only this everywhere. Three producers of one answer is the shape
-// `<adapters_stay_thin>` exists to stop. Both halves read the same spec, so they cannot drift into
-// two different answers — only into one answer applied twice, which every operation here is
-// idempotent under (`(x ?? 'tail') ?? 'tail'`, `(x !== false) !== false`).
-import { HOST_PRIMITIVES, } from '../host-primitives.cjs';
-const planFor = (primitive) => ({
-    aliases: Object.entries(primitive.aliases),
-    defaults: Object.entries(primitive.defaults),
-});
-// The wrapper's spelling of a tag whose behavior must attach to the LOWERED path only
-// (`component-names/shared.ts`). A suffix rather than a spec field because it cannot go stale: the
-// next primitive to grow a `-managed` twin is covered the day it is named, with no edit here.
-// `managed-tags-fold.test.ts` pins the convention against the platform tables, so a twin named some
-// other way fails rather than silently losing its folds.
-const managedSpellingOf = (tag) => `${tag}-managed`;
-// EVERY spelling a primitive commits under, and the two axes are independent.
-//
-// `intrinsicWhen` lets one primitive commit two different tags (`TextInput` ->
-// `text-input` / `…-multiline`). `-managed` is the wrapper's twin of each of those. A map
-// keyed on the lowered spellings alone folds the lowered path and silently skips the component one
-// — which is exactly what shipped: TextInput and Switch committed a raw `id`, a key no ViewConfig
-// declares, so Fabric dropped it and the nativeID was lost on device with nothing red. Found by
-// Svelte's equivalence arm, 2026-09-01, and it is the two paths of ONE adapter disagreeing.
-//
-// Folding a bag the wrapper already folded is a no-op — an alias deletes its source key, so the
-// second pass finds nothing to rename — which is what makes covering both paths from one plan safe.
-function tagsOf(primitive) {
-    const alternate = primitive.intrinsicWhen?.intrinsic;
-    const lowered = alternate === undefined
-        ? [primitive.intrinsic]
-        : [primitive.intrinsic, alternate];
-    return [...lowered, ...lowered.map(managedSpellingOf)];
-}
-export const FOLD_PLAN_BY_TAG = new Map(Object.values(HOST_PRIMITIVES).flatMap(primitive => {
-    const plan = planFor(primitive);
-    return tagsOf(primitive).map((tag) => [tag, plan]);
-}));
-// The runtime twin of a transform's `foldExpression`, which emits these same two operations as
-// SOURCE. `notFalse` is RN's own encoding (`allowFontScaling !== false`): an explicit `undefined`
-// reads as "not set" and only a literal `false` opts out, which is why it is not a `??`.
-function fold(op, authored) {
-    return op.op === 'notFalse' ? authored !== false : (authored ?? op.value);
-}
-/**
- * Apply a primitive's aliases and defaults to a bag, copy-on-write.
- *
- * Never mutates the input: the bag belongs to whoever built it, and a framework may hand the same
- * object back on a re-render, so writing into it would leak a fold into the author's own state.
- */
-export function foldHostBag(tagName, bag) {
-    const plan = FOLD_PLAN_BY_TAG.get(tagName);
-    if (plan === undefined)
-        return bag;
-    let next = bag;
-    for (const [from, to] of plan.aliases) {
-        if (!(from in next))
-            continue;
-        if (next === bag)
-            next = { ...bag };
-        // RN gives the alias unconditional priority when both are set (View.js:77-79,
-        // `processedProps.nativeID = id`), and the raw key must not survive — no ViewConfig declares
-        // `id`, so Fabric would drop it silently.
-        next[to] = next[from];
-        delete next[from];
-    }
-    // Seeded whether or not the key was authored: a default that only applies to a key already
-    // present is not a default.
-    //
-    // A bag a transform already folded takes the `continue` on every key and never reaches the copy —
-    // which is what keeps the compile-time fold worth having once this one exists. It is no longer
-    // the mechanism, but it does keep the hot path allocation-free.
-    for (const [key, op] of plan.defaults) {
-        const folded = fold(op, next[key]);
-        if (key in next && Object.is(next[key], folded))
-            continue;
-        if (next === bag)
-            next = { ...bag };
-        next[key] = folded;
-    }
-    return next;
-}