@symbiote-native/components 0.5.0 → 2.0.0

package/build/component-names/index.ios.js

@@ -2,25 +2,45 @@
 // (component-names.ts re-exports it) for headless tsx / tsc / web fallback.
 // Fabric names are the codegen spec's registered name (the new-arch name), not the legacy
 // paperComponentName (RCTSwitch, …).
+import { ANCHOR_COMPONENT } from '@symbiote-native/engine';
 import { buildDescriptors, makeDescriptorFor, } from './shared.js';
 const IOS_NAMES = {
-    'symbiote-view': 'RCTView',
-    'symbiote-text': 'RCTText',
-    'symbiote-image': 'RCTImageView',
-    'symbiote-scroll-view': 'RCTScrollView',
-    'symbiote-scroll-content': 'RCTScrollContentView',
+    view: 'RCTView',
+    pressable: 'RCTView',
+    'touchable-opacity': 'RCTView',
+    // NOT a view name — TNF commits nothing at all. See `shared.ts`. Platform-invariant, unlike
+    // every other entry here: RN's TNF renders no view on either platform, it only stops CLONING a
+    // background off Android (TouchableNativeFeedback.js:402).
+    'touchable-native-feedback': ANCHOR_COMPONENT,
+    'touchable-without-feedback': ANCHOR_COMPONENT,
+    'touchable-highlight': 'RCTView',
+    button: 'RCTView',
+    text: 'RCTText',
+    image: 'RCTImageView',
+    'image-background': 'RCTView',
+    'scroll-view': 'RCTScrollView',
+    'scroll-content': 'RCTScrollContentView',
     // iOS uses one scroll view for both axes; horizontal is RCTScrollView with the
     // `horizontal` prop set, so these resolve identically to the vertical pair.
-    'symbiote-horizontal-scroll-view': 'RCTScrollView',
-    'symbiote-horizontal-scroll-content': 'RCTScrollContentView',
-    'symbiote-text-input': 'RCTSinglelineTextInputView',
-    'symbiote-text-input-multiline': 'RCTMultilineTextInputView',
-    'symbiote-switch': 'Switch',
-    'symbiote-activity-indicator': 'ActivityIndicatorView',
-    'symbiote-safe-area-view': 'SafeAreaView',
-    'symbiote-modal': 'ModalHostView',
-    'symbiote-refresh-control': 'PullToRefreshView',
-    'symbiote-input-accessory-view': 'RCTInputAccessoryView',
+    'horizontal-scroll-view': 'RCTScrollView',
+    'horizontal-scroll-content': 'RCTScrollContentView',
+    'text-input': 'RCTSinglelineTextInputView',
+    'text-input-multiline': 'RCTMultilineTextInputView',
+    // The component path's pair — same native views, a tag the behavior registry does not
+    // carry. See `shared.ts` for why the wrapper may not share the lowered tag.
+    'text-input-managed': 'RCTSinglelineTextInputView',
+    'text-input-multiline-managed': 'RCTMultilineTextInputView',
+    switch: 'Switch',
+    // The wrapper's tag — same native view, a tag the behavior registry does not carry. See
+    // `shared.ts` for why the wrapper may not share the lowered tag.
+    'switch-managed': 'Switch',
+    'activity-indicator': 'RCTView',
+    'activity-indicator-spinner': 'ActivityIndicatorView',
+    'safe-area-view': 'SafeAreaView',
+    modal: 'ModalHostView',
+    'refresh-control': 'PullToRefreshView',
+    'sticky-header': 'RCTView',
+    'input-accessory-view': 'RCTInputAccessoryView',
 };
 export const COMPONENT_DESCRIPTORS = buildDescriptors(IOS_NAMES);
 export const descriptorFor = makeDescriptorFor(COMPONENT_DESCRIPTORS);

package/build/component-names/shared.d.ts

@@ -1,4 +1,5 @@
-export type ISymbioteIntrinsic = 'symbiote-view' | 'symbiote-text' | 'symbiote-image' | 'symbiote-scroll-view' | 'symbiote-scroll-content' | 'symbiote-horizontal-scroll-view' | 'symbiote-horizontal-scroll-content' | 'symbiote-text-input' | 'symbiote-text-input-multiline' | 'symbiote-switch' | 'symbiote-activity-indicator' | 'symbiote-safe-area-view' | 'symbiote-modal' | 'symbiote-refresh-control' | 'symbiote-input-accessory-view';
+export type ISymbioteIntrinsic = 'view' | 'pressable' | 'touchable-opacity' | 'touchable-native-feedback' | 'touchable-without-feedback' | 'touchable-highlight' | 'button' | 'text' | 'image' | 'image-background' | 'scroll-view' | 'scroll-content' | 'horizontal-scroll-view' | 'horizontal-scroll-content' | 'text-input' | 'text-input-multiline' | 'text-input-managed' | 'text-input-multiline-managed' | 'switch' | 'switch-managed' | 'activity-indicator' | 'activity-indicator-spinner' | 'safe-area-view' | 'modal' | 'refresh-control' | 'sticky-header' | 'input-accessory-view';
+export type ICrossTypedIntrinsics<LooseProps, Crossed extends Partial<Record<ISymbioteIntrinsic, unknown>>> = Omit<Record<ISymbioteIntrinsic, LooseProps>, keyof Crossed> & Crossed;
 export interface IComponentDescriptor {
     component: string;
     isText: boolean;

package/build/component-names/shared.js

@@ -7,7 +7,7 @@
 // The only text-laying intrinsic; drives the RCTText / RCTVirtualText nesting choice
 // (a <Text> inside another <Text> becomes a virtual span). Platform-invariant, so it is
 // not part of the per-platform name table.
-const TEXT_INTRINSICS = new Set(['symbiote-text']);
+const TEXT_INTRINSICS = new Set(['text']);
 // Assemble the descriptor map a platform file exports: each intrinsic's Fabric name from
 // the platform table, paired with its invariant isText flag.
 export function buildDescriptors(names) {
@@ -27,13 +27,59 @@ export function buildDescriptors(names) {
 // is a raw Fabric view name from a library's codegen component and flows through untouched
 // (the engine derives its events/processors from the view's ViewConfig, no per-library glue).
 export function makeDescriptorFor(descriptors) {
+    const unrewritten = publicNamesThatAreNotViewNames(descriptors);
     return type => {
         const descriptor = descriptors[type];
         if (descriptor !== undefined)
             return descriptor;
-        if (type.startsWith('symbiote-')) {
-            throw new Error(`Unknown symbiote component type: ${type}`);
+        // NO "unknown tag of ours" throw any more, and the reason is the whole cost of dropping the
+        // prefix: `symbiote-*` was a MARKER, so a miss carrying it could only be our own typo. Without
+        // it this namespace holds three populations that a string cannot tell apart —
+        //
+        //   view · scroll-view          ours
+        //   counter-child · app-root    an Angular app's OWN component selectors, kebab by convention
+        //   RCTView · RNCSlider         a Fabric view name, resolving through the fallthrough below
+        //
+        // — and the first attempt at a replacement ("lowercase is ours") threw on the second row, which
+        // is most of an Angular app. Measured: 222 tests, the primary failure being `counter-child`.
+        //
+        // What replaces it is stronger and is not runtime at all: `ISymbioteIntrinsic` is a closed
+        // union, so a misspelled tag in our own source is a compile error at every call site that names
+        // one. The guard was only ever a backstop for a name built dynamically.
+        if (unrewritten.has(type)) {
+            throw new Error(`"${type}" is a primitive's PUBLIC name, not a Fabric view name — a rewrite was missed. ` +
+                `Expected the intrinsic tag (e.g. "view"). Falling through would have committed ` +
+                `a Fabric view literally named "${type}", which fails on device only.`);
         }
         return { component: type, isText: false };
     };
 }
+// A primitive's public name reaching here means an adapter's rewrite missed a call site. Without
+// this the name falls through as a raw Fabric view name and commits a view literally called `View`
+// — no error at any layer, wrong only on a device.
+//
+// Both halves are DERIVED, because a hand-written list of either would be wrong within a release.
+// The names come from the intrinsic union (kebab -> Pascal); the exclusions come from the platform's
+// own table, and deriving them is not tidiness — two public names ARE real Fabric view names, so a
+// hand-written block list would break an adapter's thin wrapper over a third-party native view,
+// which resolves by view name through this same function.
+//
+// AND THE EXCLUSION IS PER PLATFORM, which is why it must be computed from the table rather than
+// stated. `Switch` and `SafeAreaView` are iOS view names; Android spells them `AndroidSwitch` and
+// `RCTSafeAreaView`, so the same public name is EXCLUDED on iOS and BLOCKED on Android. That
+// asymmetry is correct — nothing legitimate resolves by the bare name on Android — but a reader who
+// takes "these two are real view names" as platform-invariant will conclude the guard is broken on
+// one side or the other.
+function publicNamesThatAreNotViewNames(descriptors) {
+    const viewNames = new Set(Object.values(descriptors).map(descriptor => descriptor.component));
+    const names = new Set();
+    for (const intrinsic of Object.keys(descriptors)) {
+        const publicName = intrinsic
+            .split('-')
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+        if (!viewNames.has(publicName))
+            names.add(publicName);
+    }
+    return names;
+}

package/build/descriptor.js

@@ -4,14 +4,14 @@
 // adapter's host element then flows on through its reconciler → engine → Fabric.
 //
 // `type` is an open host-component string, not a closed two-member union, because
-// symbiote paints one host element PER native component (`symbiote-activity-indicator`,
-// `symbiote-switch`, …), not just a generic box/text pair.
-// el(): a host element of any type. txt(): shorthand for the `symbiote-text` primitive.
+// symbiote paints one host element PER native component (`activity-indicator`,
+// `switch`, …), not just a generic box/text pair.
+// el(): a host element of any type. txt(): shorthand for the `text` primitive.
 export function el(type, props = {}, children = [], key) {
     return { type, props, children, key };
 }
 export function txt(props = {}, children = []) {
-    return { type: 'symbiote-text', props, children };
+    return { type: 'text', props, children };
 }
 // `bridge` names the caller (`descriptorToSolid`, `descriptorToSvelte`) so a device log says which
 // one tripped without a stack to read.

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,99 @@
+// 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;
+}

package/build/index.d.ts

@@ -8,17 +8,15 @@ export type { IEllipsizeMode, ITextDefaultableProps } from './text-props';
 export type { IAccessibilityProps, IAriaProps, IAccessibilityRole, IRole, IAccessibilityStateValue, IAccessibilityValue, IAccessibilityActionInfo, } from './accessibility-props';
 export { descriptorFor, COMPONENT_DESCRIPTORS } from './component-names';
 export { buildDescriptors, makeDescriptorFor } from './component-names/shared';
-export type { ISymbioteIntrinsic, IComponentDescriptor, } from './component-names/shared';
-export { renderActivityIndicator } from './view/render-activity-indicator';
-export type { IActivityIndicatorProps, IActivityIndicatorViewProps, IActivityIndicatorPlatform, IActivityIndicatorSize, } from './view/render-activity-indicator';
+export type { ISymbioteIntrinsic, IComponentDescriptor, ICrossTypedIntrinsics, } from './component-names/shared';
 export { renderSwitch } from './view/render-switch';
-export type { ISwitchProps, ISwitchViewProps, ISwitchPlatform, ISwitchTrackColor, } from './view/render-switch';
+export type { ISwitchProps, ISwitchViewProps, ISwitchPlatform, ISwitchTrackColor, ISwitchChangeEvent, } from './view/render-switch';
 export type { IResponderProps } from './responder-props';
 export { switchReducer, createInitialSwitchState, shouldSnapBack, valueFromChange, } from './state/switch';
 export type { ISwitchState, ISwitchAction } from './state/switch';
 export { resolveDecelerationRate, selectScrollIntrinsics, readLayoutDimension, didContentSizeChange, resolveScrollForwarding, SCROLL_VIEW_BASE_HORIZONTAL, SCROLL_VIEW_BASE_VERTICAL, } from './view/render-scroll-view';
 export type { IScrollIntrinsics, IContentSize, IScrollForwarding, IScrollForwardingInputs, IScrollForwardMode, } from './view/render-scroll-view';
-export { buildScrollViewHandle, splitLayoutProps, attachStickyScroll, isSymbioteEvent, forwardScrollEvent, } from './scroll-view-commands';
+export { buildScrollViewHandle, splitLayoutProps, splitScrollViewStyle, attachStickyScroll, isSymbioteEvent, forwardScrollEvent, } from './scroll-view-commands';
 export type { IScrollViewHandle } from './scroll-view-commands';
 export { computeStickyInterpolation, nextStickyHeaderY, stickyDebounceMs, readLayoutNumber, STICKY_HEADER_Z_INDEX, } from './view/render-scroll-sticky';
 export type { IStickyHeaderProps, IStickyInterpolationParams, } from './view/render-scroll-sticky';
@@ -28,8 +26,6 @@ export type { IImageSource, IImageSourceProp, IResizeMode, IImageProps, IImageVi
 export { renderImage } from './view/render-image';
 export type { IImageStatics, IImageSize, IImageCacheStatus, } from '@symbiote-native/engine';
 export { imageStatics, setImageSourceResolver } from '@symbiote-native/engine';
-export { renderImageBackground } from './view/render-image-background';
-export type { IImageBackgroundViewProps } from './view/render-image-background';
 export { renderInputAccessoryView } from './view/render-input-accessory-view';
 export type { IInputAccessoryViewViewProps } from './view/render-input-accessory-view';
 export { renderModal } from './view/render-modal';
@@ -38,19 +34,19 @@ export { modalReducer, createInitialModalState, shouldRenderModal, } from './sta
 export type { IModalState, IModalAction } from './state/modal';
 export { computeInset, keyboardAvoidingEventNamesFor, readPrefersCrossFadeTransitions, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from './view/render-keyboard-avoiding-view';
 export type { IComputeInsetOptions, IKeyboardAvoidingBehavior, IKeyboardAvoidingEventNames, IMeasuredFrame, IKeyboardFrame, IKeyboardAvoidingLayout, IResolveKeyboardAvoidingLayoutParams, } from './view/render-keyboard-avoiding-view';
-export { createPressHandlers, createPressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable';
+export { createPressHandlers, createPressRuntime, disposePressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable';
 export type { IPressState, IPressHandler, IPressHandlers, IPressHost, IPressRuntime, IPressMachineConfig, IFrameCallback, IRectOffset, IEdgeInsets, IResponderRegion, IPressableAndroidRippleConfig, IRippleBackground as IPressableRippleBackground, } from './state/pressable';
-export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, } from './view/render-pressable';
+export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, resolvePressableFocusable, resolveTouchableFocusable, } from './view/render-pressable';
 export { computePressOutWait, createTouchableFeedbackRuntime, createTouchableFeedbackHandlers, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_ACTIVE_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, DEFAULT_HIGHLIGHT_CHILD_OPACITY, DEFAULT_UNDERLAY_COLOR, TOUCHABLE_MIN_PRESS_DURATION_MS, restingOpacityFromStyle, hasTouchablePressHandler, createHighlightUnderlayRuntime, createHighlightUnderlayHandlers, } from './state/touchable';
 export type { IPressTimingProps, ITouchableHandler, ITouchableFeedbackRuntime, ITouchableFeedbackConfig, ITouchableFeedbackCallbacks, ITouchableFeedbackHandlers, ITouchablePressHandlerProps, IHighlightUnderlayRuntime, IHighlightUnderlayConfig, IHighlightUnderlayCallbacks, IHighlightUnderlayHandlers, } from './state/touchable';
 export { resolveHighlightExtraStyles } from './view/render-touchable-highlight';
 export type { ITouchableHighlightExtraStyles, ITouchableHighlightUnderlayView, } from './view/render-touchable-highlight';
-export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, } from './view/render-touchable-native-feedback';
+export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, TouchableNativeFeedback, } from './view/render-touchable-native-feedback';
 export type { INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from './view/render-touchable-native-feedback';
-export { BUTTON_ACCESSIBILITY_ROLE, buttonTextStyle, resolveButtonTextStyle, } from './view/render-button';
+export { BUTTON_ACCESSIBILITY_ROLE, buttonTextStyle, buttonViewStyle, resolveButtonDisabled, resolveButtonImportantForAccessibility, resolveButtonTextStyle, resolveButtonTitle, resolveButtonViewStyle, } from './view/render-button';
 export type { IButtonProps } from './view/render-button';
 export { resolveTextInputProps, foldText, foldAutoComplete, foldSubmitBehavior, mapAutoComplete, textFromChange, eventCountFromChange, shouldCommandText, INITIAL_EVENT_COUNT, SELECTION_NONE, } from './state/text-input';
-export type { ITextInputProps, ITextInputHandle, ITextInputSelection, ITextInputEventHandler, ITextInputFoldInput, IFoldedTextInputProps, IInputMode, IEnterKeyHint, ISubmitBehavior, } from './state/text-input';
+export type { ITextInputProps, ITextInputHandle, ITextInputSelection, ITextInputEventHandler, ITextInputFoldInput, IFoldedTextInputProps, IInputMode, IEnterKeyHint, ISubmitBehavior, ITextInputChangeEvent, } from './state/text-input';
 export { keyboardTypeForInputMode } from './state/text-input';
 export { renderTextInput } from './view/render-text-input';
 export type { ITextInputViewProps } from './view/render-text-input';
@@ -64,3 +60,18 @@ export { SINGLE_COLUMN, chunkIntoRows, rowKeyExtractor, expandRowToken, expandRo
 export type { IRow } from './state/flat-list';
 export { flattenSections, unwrapEntryItem, sectionEntryKey, scrollLocationToFlatIndex, } from './state/section-list';
 export type { ISection, ISectionEntry, IVirtualizedSectionListHandle, } from './state/section-list';
+export { registerPressableBehavior, PRESSABLE_TAG, } from './behaviors/pressable';
+export { registerTouchableOpacityBehavior, TOUCHABLE_OPACITY_TAG, } from './behaviors/touchable-opacity';
+export { registerTouchableHighlightBehavior, TOUCHABLE_HIGHLIGHT_TAG, } from './behaviors/touchable-highlight';
+export { registerButtonBehavior, BUTTON_TAG } from './behaviors/button';
+export { registerTouchableNativeFeedbackBehavior, TOUCHABLE_NATIVE_FEEDBACK_TAG, } from './behaviors/touchable-native-feedback';
+export { registerTouchableWithoutFeedbackBehavior, TOUCHABLE_WITHOUT_FEEDBACK_TAG, } from './behaviors/touchable-without-feedback';
+export { ACTIVITY_INDICATOR_SPINNER_TAG, ACTIVITY_INDICATOR_TAG, registerActivityIndicatorBehavior, } from './behaviors/activity-indicator';
+export type { IActivityIndicatorProps, IActivityIndicatorSize, } from './behaviors/activity-indicator';
+export { foldImagePayload, IMAGE_TAG, registerImageBehavior, } from './behaviors/image';
+export { IMAGE_BACKGROUND_TAG, registerImageBackgroundBehavior, } from './behaviors/image-background';
+export { foldInputAccessoryViewPayload, INPUT_ACCESSORY_VIEW_TAG, registerInputAccessoryViewBehavior, } from './behaviors/input-accessory-view';
+export { registerTextInputBehavior, buildTextInputHandle, TEXT_INPUT_TAG, TEXT_INPUT_MULTILINE_TAG, } from './behaviors/text-input';
+export { registerSwitchBehavior, SWITCH_TAG } from './behaviors/switch';
+export { registerRefreshControlBehavior, REFRESH_CONTROL_TAG, } from './behaviors/refresh-control';
+export { HORIZONTAL_SCROLL_VIEW_TAG, registerScrollViewBehavior, SCROLL_VIEW_TAG, } from './behaviors/scroll-view';

package/build/index.js

@@ -18,7 +18,6 @@ export { resolveTextProps } from './text-props.js';
 // re-exports iOS for headless. descriptorFor is the per-platform-bound resolver.
 export { descriptorFor, COMPONENT_DESCRIPTORS } from './component-names';
 export { buildDescriptors, makeDescriptorFor } from './component-names/shared.js';
-export { renderActivityIndicator } from './view/render-activity-indicator.js';
 export { renderSwitch } from './view/render-switch.js';
 // Switch is the first STATE machine off this layer (ActivityIndicator was render-only):
 // the reducer + the two pure predicates are the logic half, the adapter supplies the hook.
@@ -27,7 +26,7 @@ export { switchReducer, createInitialSwitchState, shouldSnapBack, valueFromChang
 // owns the refs/effects/element assembly and the sticky-header component; these supply the
 // platform-invariant math and plumbing every adapter shares.
 export { resolveDecelerationRate, selectScrollIntrinsics, readLayoutDimension, didContentSizeChange, resolveScrollForwarding, SCROLL_VIEW_BASE_HORIZONTAL, SCROLL_VIEW_BASE_VERTICAL, } from './view/render-scroll-view.js';
-export { buildScrollViewHandle, splitLayoutProps, attachStickyScroll, isSymbioteEvent, forwardScrollEvent, } from './scroll-view-commands.js';
+export { buildScrollViewHandle, splitLayoutProps, splitScrollViewStyle, attachStickyScroll, isSymbioteEvent, forwardScrollEvent, } from './scroll-view-commands.js';
 export { computeStickyInterpolation, nextStickyHeaderY, stickyDebounceMs, readLayoutNumber, STICKY_HEADER_Z_INDEX, } from './view/render-scroll-sticky.js';
 // The per-header sticky effect machine: the one pure state machine every sticky-header consumer drives
 // (React/Vue header component, Angular header component, Angular projection wrapper), folding the
@@ -37,7 +36,8 @@ export { reduceSticky, createInitialStickyState, stickyEffectSignature, } from '
 export { renderImage } from './view/render-image/index.js';
 export { imageStatics, setImageSourceResolver } from '@symbiote-native/engine';
 // ImageBackground: render-only composition (absolute-fill image behind, children on top).
-export { renderImageBackground } from './view/render-image-background.js';
+// No render fn: the only composition this primitive had is the two nodes the behavior builds, so
+// `view/render-image-background.ts` went with the wrappers — same as ActivityIndicator's.
 // InputAccessoryView: render-only host assembly (nativeID/backgroundColor).
 export { renderInputAccessoryView } from './view/render-input-accessory-view.js';
 // Modal: full 3-layer split (state machine gates the iOS keep-alive frame).
@@ -49,16 +49,20 @@ export { computeInset, keyboardAvoidingEventNamesFor, readPrefersCrossFadeTransi
 // geometry, drift test, suppression flags) lives in state/pressable; the responder-listener +
 // accessibilityState + ripple render decisions in view/render-pressable. Every adapter supplies
 // only its reactive `pressed` cell + the View's measure handle (see the 3-layer split).
-export { createPressHandlers, createPressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable.js';
-export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, } from './view/render-pressable/index.js';
+export { createPressHandlers, createPressRuntime, disposePressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable.js';
+export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, resolvePressableFocusable, resolveTouchableFocusable, } from './view/render-pressable/index.js';
 // Touchable*: shared press-timing constants + the deactivation-floor math (the Animated feedback
 // itself stays per-adapter), and TouchableNativeFeedback's pure static factories + background map.
 export { computePressOutWait, createTouchableFeedbackRuntime, createTouchableFeedbackHandlers, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_ACTIVE_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, DEFAULT_HIGHLIGHT_CHILD_OPACITY, DEFAULT_UNDERLAY_COLOR, TOUCHABLE_MIN_PRESS_DURATION_MS, restingOpacityFromStyle, hasTouchablePressHandler, createHighlightUnderlayRuntime, createHighlightUnderlayHandlers, } from './state/touchable.js';
 export { resolveHighlightExtraStyles } from './view/render-touchable-highlight.js';
-export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, } from './view/render-touchable-native-feedback.js';
-// Button: shared base text style, role constant, and color fold (the adapter composes its own
-// TouchableOpacity + Text).
-export { BUTTON_ACCESSIBILITY_ROLE, buttonTextStyle, resolveButtonTextStyle, } from './view/render-button.js';
+export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, 
+// RN's own static namespace, the only part of the deleted wrappers with nowhere else to go: the
+// element is a tag now, and a tag is a string that cannot carry `.Ripple`.
+TouchableNativeFeedback, } from './view/render-touchable-native-feedback.js';
+// Button: the role constant plus every platform fold RN's Button.js performs (the adapter composes
+// its own touchable + view + text around them). The VIEW style is the half that was missing until
+// 2026-09-09 and it is the whole Android look.
+export { BUTTON_ACCESSIBILITY_ROLE, buttonTextStyle, buttonViewStyle, resolveButtonDisabled, resolveButtonImportantForAccessibility, resolveButtonTextStyle, resolveButtonTitle, resolveButtonViewStyle, } from './view/render-button.js';
 // TextInput: the controlled-value / event-count handshake. The logic half is the pure
 // folds/maps + the controlled-write predicate (not a single reducer: count must re-render the
 // imperative handle, lastNativeText must not); the view half picks the intrinsic and maps the
@@ -79,3 +83,40 @@ export { reduceList, createInitialListState, listEffectSignature, } from './stat
 export { subscribeListDiagnostics } from './state/virtualized-list-diagnostics.js';
 export { SINGLE_COLUMN, chunkIntoRows, rowKeyExtractor, expandRowToken, expandRowViewability, lastItemOfRow, firstItemOfRow, } from './state/flat-list.js';
 export { flattenSections, unwrapEntryItem, sectionEntryKey, scrollLocationToFlatIndex, } from './state/section-list.js';
+export { registerPressableBehavior, PRESSABLE_TAG, } from './behaviors/pressable.js';
+export { registerTouchableOpacityBehavior, TOUCHABLE_OPACITY_TAG, } from './behaviors/touchable-opacity.js';
+export { registerTouchableHighlightBehavior, TOUCHABLE_HIGHLIGHT_TAG, } from './behaviors/touchable-highlight.js';
+export { registerButtonBehavior, BUTTON_TAG } from './behaviors/button.js';
+// Registered by ALL FIVE adapters since 2026-09-09, in the same commit that deleted the five
+// wrappers — which is what makes it safe. While those wrappers still rendered a `Pressable` around
+// a feedback `View`, registering would have put a second responder on every existing
+// TouchableNativeFeedback. The ActivityIndicator and ScrollView blocks below are still in the
+// withheld state this one just left.
+export { registerTouchableNativeFeedbackBehavior, TOUCHABLE_NATIVE_FEEDBACK_TAG, } from './behaviors/touchable-native-feedback.js';
+// The second tag that commits no node, and registered by all five adapters in the same commit that
+// deleted their five wrappers — while those wrappers still rendered a `Pressable` around the app's
+// children, registering would have put a second responder on every TouchableWithoutFeedback.
+export { registerTouchableWithoutFeedbackBehavior, TOUCHABLE_WITHOUT_FEEDBACK_TAG, } from './behaviors/touchable-without-feedback.js';
+// Registered by all five adapters since 2026-09-09, in the same commit that deleted the five
+// wrappers — the tag builds its own spinner, so a surviving wrapper would have painted a second one.
+// The prop type rides along: there is no `view/render-activity-indicator.ts` any more, because the
+// only render this primitive had was the two nodes the behavior now builds.
+export { ACTIVITY_INDICATOR_SPINNER_TAG, ACTIVITY_INDICATOR_TAG, registerActivityIndicatorBehavior, } from './behaviors/activity-indicator';
+export { foldImagePayload, IMAGE_TAG, registerImageBehavior, } from './behaviors/image.js';
+// Registered by all five adapters since 2026-09-09, in the same commit that deleted the five
+// wrappers — the tag builds the background image itself, so a surviving wrapper would have
+// committed a second one under it.
+export { IMAGE_BACKGROUND_TAG, registerImageBackgroundBehavior, } from './behaviors/image-background.js';
+export { foldInputAccessoryViewPayload, INPUT_ACCESSORY_VIEW_TAG, registerInputAccessoryViewBehavior, } from './behaviors/input-accessory-view.js';
+export { registerTextInputBehavior, buildTextInputHandle, TEXT_INPUT_TAG, TEXT_INPUT_MULTILINE_TAG, } from './behaviors/text-input.js';
+export { registerSwitchBehavior, SWITCH_TAG } from './behaviors/switch.js';
+export { registerRefreshControlBehavior, REFRESH_CONTROL_TAG, } from './behaviors/refresh-control.js';
+// Exported as a FUNCTION, not as a side-effect module, which is what keeps it safe on a barrel:
+// Metro's inlineRequires only defers a re-export until its binding is named as a VALUE, and a
+// caller of `registerScrollViewBehavior()` names it. The shape CLAUDE.md forbids is a module whose
+// evaluation alone registers.
+//
+// EVERY ADAPTER CALLS IT since 2026-09-11, through `@symbiote-native/components/register`. It was
+// withheld while the wrappers built their own content node — registering then would have
+// double-nested every ScrollView. They are gone; the engine is the single owner.
+export { HORIZONTAL_SCROLL_VIEW_TAG, registerScrollViewBehavior, SCROLL_VIEW_TAG, } from './behaviors/scroll-view';

package/build/register.d.ts

@@ -0,0 +1 @@
+export {};

package/build/register.js

@@ -0,0 +1,55 @@
+// Side-effect ONLY. Exports nothing, and must never be re-exported from any barrel.
+//
+// The engine's host-behavior registry is what makes a bare `<pressable>` / `<text-input>` /
+// `<switch>` carry its machine; an unregistered tag commits inert. Every adapter needs the same
+// fourteen calls, so they live here once — an adapter's own `src/register.ts` is a single bare
+// `import '@symbiote-native/components/register';`.
+//
+// WHY A SIDE-EFFECT MODULE AND NOT A BARREL EXPORT. Metro turns on `inlineRequires` for PRODUCTION
+// only: it moves a `require` down to the first place its binding is used as a VALUE, and
+// `export { X } from './x'` compiles to a lazy getter. A registration reached only through a
+// re-export therefore never evaluates in a Release build — invisible to tsc, to vitest, and to
+// grepping the bundle. A bare `import` placed NEXT TO a re-export of the same specifier does not
+// help either: Babel merges the two into one dependency and the merged dependency stays lazy.
+// `register.test.ts` is what stops a later tidy-up from turning this back into an export.
+import { registerActivityIndicatorBehavior } from './behaviors/activity-indicator';
+import { registerButtonBehavior } from './behaviors/button.js';
+import { registerImageBackgroundBehavior } from './behaviors/image-background.js';
+import { registerImageBehavior } from './behaviors/image.js';
+import { registerInputAccessoryViewBehavior } from './behaviors/input-accessory-view.js';
+import { registerPressableBehavior } from './behaviors/pressable.js';
+import { registerRefreshControlBehavior } from './behaviors/refresh-control.js';
+import { registerScrollViewBehavior } from './behaviors/scroll-view';
+import { registerSwitchBehavior } from './behaviors/switch.js';
+import { registerTextInputBehavior } from './behaviors/text-input.js';
+import { registerTouchableHighlightBehavior } from './behaviors/touchable-highlight.js';
+import { registerTouchableNativeFeedbackBehavior } from './behaviors/touchable-native-feedback.js';
+import { registerTouchableOpacityBehavior } from './behaviors/touchable-opacity.js';
+import { registerTouchableWithoutFeedbackBehavior } from './behaviors/touchable-without-feedback.js';
+registerPressableBehavior();
+registerTouchableNativeFeedbackBehavior();
+registerTouchableWithoutFeedbackBehavior();
+// Their own tags rather than `pressable`: one node holds exactly one press machine, and each of
+// these is a pressable PLUS a second machine — the opacity fade, the underlay show/hide.
+registerTouchableOpacityBehavior();
+registerTouchableHighlightBehavior();
+// The whole subtree is the behavior's — RN's Button takes no children and builds
+// touchable > view > text > raw text itself (Button.js:363-388).
+registerButtonBehavior();
+// Two nodes, both the behavior's: RN wraps its native spinner in a centering View
+// (ActivityIndicator.js:112), so the tag is that View and `buildStructure` builds the spinner.
+registerActivityIndicatorBehavior();
+registerTextInputBehavior();
+registerSwitchBehavior();
+registerRefreshControlBehavior();
+// Fold-only, both of them: no node of their own, just the prop fold the wrapper used to run.
+registerImageBehavior();
+registerInputAccessoryViewBehavior();
+registerImageBackgroundBehavior();
+// The ENGINE is the single owner of a ScrollView's content node: `buildStructure` builds the
+// `RCTScrollContentView`, `slotProps` carries `contentContainerStyle` onto it, the claim on a
+// `refresh-control` child places it per platform, and the sticky seam is
+// `behaviors/scroll-view/sticky.ts`. EXACTLY ONE THING MAY BUILD THAT NODE — a second owner is a
+// silent `RCTScrollContentView` inside the first, which each adapter's
+// `scroll-view-content-owner` test is what guards.
+registerScrollViewBehavior();

package/build/resolve-intrinsic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve a primitive tag to the intrinsic it should actually commit, given its creation props.
+ *
+ * A tag with no `intrinsicWhen` — every primitive but `TextInput` today — passes through by
+ * identity, so a renderer may call this unconditionally without paying a lookup per prop.
+ */
+export declare function resolveIntrinsicTag(tag: string, props: Readonly<Record<string, unknown>> | undefined): string;

package/build/resolve-intrinsic.js

@@ -0,0 +1,49 @@
+// The RUNTIME half of `HOST_PRIMITIVES.intrinsicWhen` — choosing WHICH native view a primitive
+// commits, from the props it was created with.
+//
+// Why this has to exist at runtime at all. `intrinsicWhen` lets one primitive map to two native
+// views (`TextInput` -> `RCTSinglelineTextInputView` / `RCTMultilineTextInputView`), and until now
+// only the lowering transforms read it — so the choice was made at COMPILE time, from the source
+// text. That is why `dynamicIntrinsicChoice` had to be a refusal category: a transform seeing
+// `multiline={isLong}` cannot know the value, so it refused to lower the element at all.
+//
+// A public primitive TAG has no transform in front of it on three of the five adapters, so the
+// choice has to be made where the value is actually known — here, at element creation. That is a
+// capability the compiler never had, and it is why the refusal category disappears WITH the
+// transform rather than migrating into it.
+//
+// WHAT THIS DELIBERATELY DOES NOT DO: react to the prop CHANGING later. A node's native view is
+// fixed at `createNode` and no prop write moves a node between view types, so flipping `multiline`
+// on a mounted input needs the node re-created — exactly as a browser re-initialises on an
+// `<input type>` change. Re-creation is the renderer's business, not this function's; until a
+// renderer implements it, a runtime flip keeps the view it was created with.
+import { HOST_PRIMITIVES } from '../host-primitives.cjs';
+const CHOICE_BY_BASE_TAG = new Map(Object.values(HOST_PRIMITIVES).flatMap((primitive) => primitive.intrinsicWhen === undefined
+    ? []
+    : [
+        [
+            primitive.intrinsic,
+            {
+                prop: primitive.intrinsicWhen.prop,
+                alternate: primitive.intrinsicWhen.intrinsic,
+            },
+        ],
+    ]));
+/**
+ * Resolve a primitive tag to the intrinsic it should actually commit, given its creation props.
+ *
+ * A tag with no `intrinsicWhen` — every primitive but `TextInput` today — passes through by
+ * identity, so a renderer may call this unconditionally without paying a lookup per prop.
+ */
+export function resolveIntrinsicTag(tag, props) {
+    const choice = CHOICE_BY_BASE_TAG.get(tag);
+    if (choice === undefined || props === undefined)
+        return tag;
+    // Explicit rather than truthy, and the string form is not decoration: a template-driven adapter
+    // can deliver `multiline="true"` as an ATTRIBUTE STRING (Angular's `multiline="true"` vs
+    // `[multiline]="true"`), and plain truthiness would then read `multiline="false"` — also a
+    // non-empty string — as multiline. An absent prop keeps the base tag.
+    return props[choice.prop] === true || props[choice.prop] === 'true'
+        ? choice.alternate
+        : tag;
+}

package/build/scroll-view-commands.d.ts

@@ -16,6 +16,10 @@ export declare function splitLayoutProps(style: IStyleProp<IViewStyle> | undefin
     outer: Record<string, unknown>;
     inner: Record<string, unknown>;
 };
+export declare function splitScrollViewStyle(base: IStyleProp<IViewStyle> | undefined, style: unknown): {
+    outer: IStyleProp<IViewStyle>;
+    inner: IStyleProp<IViewStyle>;
+};
 export { isSymbioteEvent };
 export declare function forwardScrollEvent(handler: IScrollHandler, args: readonly unknown[]): void;
 export declare function buildScrollViewHandle(getNode: () => ISymbioteNode | null): IScrollViewHandle;