@symbiote-native/components 0.5.0 → 1.0.0

package/build/state/pressable.d.ts

@@ -1,5 +1,6 @@
 import { type ISymbioteEvent } from '@symbiote-native/engine';
 export declare const DEFAULT_DELAY_LONG_PRESS_MS = 500;
+export declare const DEFAULT_MIN_PRESS_DURATION_MS = 130;
 export declare const DEFAULT_PRESS_RECT_OFFSETS: {
     top: number;
     left: number;
@@ -56,19 +57,26 @@ export interface IPressRuntime {
     longPressCancel: (() => void) | undefined;
     longPressFired: boolean;
     pressDelayCancel: (() => void) | undefined;
+    pressOutCancel: (() => void) | undefined;
     pressOrigin: {
         x: number;
         y: number;
     } | undefined;
     driftedOut: boolean;
     region: IResponderRegion | undefined;
+    active: boolean;
+    activatedAt: number | undefined;
+    delayElapsed: boolean;
+    disposed: boolean;
 }
 export declare function createPressRuntime(): IPressRuntime;
+export declare function disposePressRuntime(runtime: IPressRuntime): void;
 export type IFrameCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
 export interface IPressHost {
     setPressed: (pressed: boolean) => void;
     getMeasureFn: () => ((callback: IFrameCallback) => void) | undefined;
     schedule: (callback: () => void, ms: number) => () => void;
+    now: () => number;
 }
 export interface IPressMachineConfig {
     onPress?: IPressHandler;
@@ -78,6 +86,7 @@ export interface IPressMachineConfig {
     onLongPress?: IPressHandler;
     delayLongPress: number;
     unstable_pressDelay: number;
+    minPressDuration?: number;
     hitSlop?: IRectOffset;
     pressRetentionOffset?: IRectOffset;
 }

package/build/state/pressable.js

@@ -11,6 +11,8 @@
 // the decision of when each callback fires) is here, shared by every adapter.
 import { dlog, Platform } from '@symbiote-native/engine';
 export const DEFAULT_DELAY_LONG_PRESS_MS = 500;
+// Pressability's default active-visual floor for a plain Pressable. Touchable* overrides this to 0.
+export const DEFAULT_MIN_PRESS_DURATION_MS = 130;
 // RN's default extra slop kept around a press once it is active, before a drift fires pressOut.
 // The PressRect extension (Pressability.js DEFAULT_PRESS_RECT_OFFSETS). Per-edge, deeper bottom.
 export const DEFAULT_PRESS_RECT_OFFSETS = {
@@ -91,11 +93,40 @@ export function createPressRuntime() {
         longPressCancel: undefined,
         longPressFired: false,
         pressDelayCancel: undefined,
+        pressOutCancel: undefined,
         pressOrigin: undefined,
         driftedOut: false,
         region: undefined,
+        active: false,
+        activatedAt: undefined,
+        delayElapsed: false,
+        disposed: false,
     };
 }
+function cancelRuntimeTimer(runtime, key) {
+    const cancel = runtime[key];
+    if (cancel === undefined)
+        return;
+    cancel();
+    runtime[key] = undefined;
+}
+// RN Pressability.reset(): cancel every timer and make any already-queued callback inert. The
+// adapter invokes this exactly once from its own unmount/destroy hook.
+export function disposePressRuntime(runtime) {
+    if (runtime.disposed)
+        return;
+    runtime.disposed = true;
+    cancelRuntimeTimer(runtime, 'longPressCancel');
+    cancelRuntimeTimer(runtime, 'pressDelayCancel');
+    cancelRuntimeTimer(runtime, 'pressOutCancel');
+    runtime.longPressFired = false;
+    runtime.pressOrigin = undefined;
+    runtime.driftedOut = false;
+    runtime.region = undefined;
+    runtime.active = false;
+    runtime.activatedAt = undefined;
+    runtime.delayElapsed = false;
+}
 // Measure the responder's on-screen frame and cache it as the retention region for the life of
 // the press (RN measures on responder grant, _measureResponderRegion). When measure is
 // unavailable (no node yet, an uncommitted node, or a host slot without a measure method,
@@ -123,7 +154,7 @@ function measureRegion(runtime, measureFn) {
 // (the React adapter's useMemo body) lives here, shared by every adapter. The adapter rebuilds
 // these per render (the closures capture the live config) while the runtime persists across them.
 export function createPressHandlers(config, runtime, host) {
-    const { onPress, onPressIn, onPressOut, onPressMove, onLongPress, delayLongPress, unstable_pressDelay, } = config;
+    const { onPress, onPressIn, onPressOut, onPressMove, onLongPress, delayLongPress, unstable_pressDelay, minPressDuration = DEFAULT_MIN_PRESS_DURATION_MS, } = config;
     // Per-edge offsets for the measured-rect retention test (RN's hitSlop + pressRectOffset).
     // pressRetentionOffset defaults to RN's DEFAULT_PRESS_RECT_OFFSETS when unset; hitSlop to zero.
     const hitSlopRect = normalizeRect(config.hitSlop);
@@ -145,20 +176,28 @@ export function createPressHandlers(config, runtime, host) {
         return (Math.hypot(point.x - origin.x, point.y - origin.y) <= fallbackThreshold);
     }
     function clearLongPress() {
-        if (runtime.longPressCancel !== undefined) {
-            runtime.longPressCancel();
-            runtime.longPressCancel = undefined;
-        }
+        cancelRuntimeTimer(runtime, 'longPressCancel');
+    }
+    function clearPressDelay() {
+        cancelRuntimeTimer(runtime, 'pressDelayCancel');
+    }
+    function clearPressOut() {
+        cancelRuntimeTimer(runtime, 'pressOutCancel');
     }
-    // The real activation: flip pressed-state on, arm the long-press timer, fire onPressIn. Split
-    // out so unstable_pressDelay can defer it behind a timer while an early release flushes it.
     function activate(event) {
+        if (runtime.disposed || runtime.active || runtime.driftedOut)
+            return;
+        // A new grant or drift-back-in supersedes a delayed out from the previous active interval.
+        clearPressOut();
+        runtime.active = true;
+        runtime.activatedAt = host.now();
         dlog('Pressable pressIn');
         host.setPressed(true);
-        runtime.longPressFired = false;
-        if (onLongPress) {
+        if (!runtime.longPressFired && onLongPress) {
             runtime.longPressCancel = host.schedule(() => {
                 runtime.longPressCancel = undefined;
+                if (runtime.disposed || !runtime.active || runtime.driftedOut)
+                    return;
                 runtime.longPressFired = true;
                 dlog('Pressable longPress timer fired');
                 onLongPress(event);
@@ -166,51 +205,99 @@ export function createPressHandlers(config, runtime, host) {
         }
         onPressIn?.(event);
     }
-    // Flush a still-pending pressDelay timer immediately, so a pressOut/press that arrives before
-    // the delay elapsed still sees an activated press.
-    function flushPressDelay(event) {
-        if (runtime.pressDelayCancel !== undefined) {
-            runtime.pressDelayCancel();
-            runtime.pressDelayCancel = undefined;
-            activate(event);
+    function deactivate(event) {
+        if (runtime.disposed || !runtime.active)
+            return;
+        runtime.active = false;
+        clearLongPress();
+        const activatedAt = runtime.activatedAt ?? host.now();
+        runtime.activatedAt = undefined;
+        const heldFor = Math.max(0, host.now() - activatedAt);
+        const wait = Math.max(minPressDuration - heldFor, 0);
+        const finish = () => {
+            runtime.pressOutCancel = undefined;
+            if (runtime.disposed)
+                return;
+            host.setPressed(false);
+            onPressOut?.(event);
+        };
+        if (wait > 0) {
+            dlog(`Pressable pressOut deferred ${wait}ms`);
+            runtime.pressOutCancel = host.schedule(finish, wait);
+        }
+        else {
+            finish();
         }
     }
+    // An honest release arrives as press then pressOut. If it beat delayPressIn, activate now so the
+    // tap still flashes and calls onPressIn; a cancelled/out-of-bounds gesture never calls this path.
+    function completePressDelay(event) {
+        if (runtime.pressDelayCancel !== undefined)
+            clearPressDelay();
+        if (!runtime.delayElapsed)
+            runtime.delayElapsed = true;
+        if (!runtime.driftedOut)
+            activate(event);
+    }
+    function resetGesture() {
+        runtime.pressOrigin = undefined;
+        runtime.region = undefined;
+        runtime.driftedOut = false;
+        runtime.delayElapsed = false;
+        runtime.longPressFired = false;
+    }
     return {
         handlePressIn(event) {
+            if (runtime.disposed)
+                return;
+            // A new grant cancels a delayed out from the prior gesture, matching Pressability's
+            // onResponderGrant -> _cancelPressOutDelayTimeout.
+            clearPressDelay();
+            clearLongPress();
+            clearPressOut();
+            runtime.active = false;
+            runtime.activatedAt = undefined;
+            runtime.longPressFired = false;
+            runtime.delayElapsed = false;
             runtime.pressOrigin = readPoint(event);
             runtime.driftedOut = false;
-            // Measure now so the move stream tests against the real frame, not a press-start radius.
             measureRegion(runtime, host.getMeasureFn());
             if (unstable_pressDelay > 0) {
                 dlog(`Pressable pressIn deferred ${unstable_pressDelay}ms`);
                 runtime.pressDelayCancel = host.schedule(() => {
                     runtime.pressDelayCancel = undefined;
-                    activate(event);
+                    if (runtime.disposed)
+                        return;
+                    runtime.delayElapsed = true;
+                    if (!runtime.driftedOut)
+                        activate(event);
                 }, unstable_pressDelay);
                 return;
             }
+            runtime.delayElapsed = true;
             activate(event);
         },
         handlePressOut(event) {
+            if (runtime.disposed)
+                return;
             dlog('Pressable pressOut');
-            flushPressDelay(event);
+            // A cancellation before delayPressIn must stay inert. An honest release already flushed the
+            // delay in handlePress, because the engine emits press immediately before pressOut.
+            clearPressDelay();
             clearLongPress();
-            runtime.pressOrigin = undefined;
-            runtime.region = undefined;
-            host.setPressed(false);
-            onPressOut?.(event);
+            deactivate(event);
+            resetGesture();
         },
         handlePress(event) {
+            if (runtime.disposed)
+                return;
             dlog('Pressable press');
-            flushPressDelay(event);
+            completePressDelay(event);
             clearLongPress();
-            // A drift past the retention region cancels the tap (RN); reset and suppress.
             if (runtime.driftedOut) {
-                runtime.driftedOut = false;
                 dlog('Pressable press suppressed by drift past retention region');
                 return;
             }
-            // A fired long press cancels the tap: reset the flag and suppress onPress.
             if (runtime.longPressFired) {
                 runtime.longPressFired = false;
                 dlog('Pressable press suppressed by prior longPress');
@@ -218,11 +305,9 @@ export function createPressHandlers(config, runtime, host) {
             }
             onPress?.(event);
         },
-        // Responder-move stream of the Pressable's own View. onPressMove fires on every move while
-        // the press is live (RN). Then the retention test: a move outside the measured region
-        // (expanded by hitSlop+pressRectOffset) fires an early pressOut and marks the tap suppressed;
-        // a move back inside re-activates.
         handleResponderMove(event) {
+            if (runtime.disposed)
+                return;
             onPressMove?.(event);
             const here = readPoint(event);
             if (!here)
@@ -232,14 +317,15 @@ export function createPressHandlers(config, runtime, host) {
                     dlog('Pressable drifted past retention region — deactivating');
                     runtime.driftedOut = true;
                     clearLongPress();
-                    host.setPressed(false);
-                    onPressOut?.(event);
+                    // Before delayPressIn there was no activation, so there is no onPressOut to emit.
+                    deactivate(event);
                 }
             }
             else if (runtime.driftedOut) {
                 dlog('Pressable returned inside retention region — reactivating');
                 runtime.driftedOut = false;
-                activate(event);
+                if (runtime.delayElapsed)
+                    activate(event);
             }
         },
     };

package/build/state/text-input.d.ts

@@ -1,4 +1,4 @@
-import type { IPlatformOSType, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
+import type { IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, ISymbioteNode, IPlatformOSType, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
 import type { IAccessibilityProps, IAriaProps } from '../accessibility-props';
 export type IInputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
 export type IEnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
@@ -95,10 +95,15 @@ export type ITextInputProps = IAccessibilityProps & IAriaProps & {
     onSelectionChange?: ITextInputEventHandler;
     onContentSizeChange?: ITextInputEventHandler;
 };
+export declare const TEXT_INPUT_CALLBACK_NAMES: readonly string[];
 export type ITextInputHandle = {
     focus(): void;
     blur(): void;
     clear(): void;
     isFocused(): boolean;
     setSelection(start: number, end: number): void;
+    measure(callback: IMeasureOnSuccess): void;
+    measureInWindow(callback: IMeasureInWindowOnSuccess): void;
+    measureLayout(relativeToNativeNode: ISymbioteNode | number, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void): void;
+    setNativeProps(nativeProps: Record<string, unknown>): void;
 };

package/build/state/text-input.js

@@ -230,3 +230,14 @@ export function resolveTextInputProps(input) {
             : input.showSoftInputOnFocus,
     };
 }
+const TEXT_INPUT_CALLBACKS = {
+    onValueChange: true,
+    onFocus: true,
+    onBlur: true,
+    onEndEditing: true,
+    onSubmitEditing: true,
+    onKeyPress: true,
+    onSelectionChange: true,
+    onContentSizeChange: true,
+};
+export const TEXT_INPUT_CALLBACK_NAMES = Object.keys(TEXT_INPUT_CALLBACKS);

package/build/state-style.d.ts

@@ -0,0 +1,15 @@
+export interface IPressStateArgument {
+    pressed: boolean;
+}
+export interface IResolvedStateStyle {
+    style: unknown;
+    activeStyle: unknown;
+}
+/**
+ * Splits an authored `style` into its resting and pressed halves, reading the value once.
+ *
+ * A non-callback passes through untouched with no active variant, which the engine reads as "leave
+ * slot 1 alone" — that is what makes one emission safe for an expression whose value cannot be
+ * known at compile time.
+ */
+export declare function resolveStateStyle(value: unknown): IResolvedStateStyle;

package/build/state-style.js

@@ -0,0 +1,47 @@
+// The runtime half of state-style lowering: splits an authored `style` into its resting and pressed
+// halves. Referenced by the code every lowering transform EMITS, never by app code.
+//
+// SHARED for the same reason `HOST_PRIMITIVES` and `specializeStateStyle` are — two adapters had
+// written byte-identical copies within an hour of each other, which is the duplication
+// `<adapters_stay_thin>` exists to stop. Each adapter re-exports it from its own `./state-style`
+// subpath so the emitted import specifier stays inside the package the app already depends on.
+//
+// WHY A HELPER EXISTS BESIDE THE INLINE GUARD, since a transform may emit either. Building the pair
+// needs the authored `style` expression, and the two emissions are NOT equivalent:
+//
+//   inline    typeof e === 'function' ? e({pressed:false}) : e   prints `e` on both props, so a
+//             `getStyle()` runs twice and a `flag ? a : b` can take DIFFERENT branches
+//   helper    resolveStateStyle(e)                               prints `e` once and calls its
+//             RESULT twice
+//
+// The rule the two must satisfy is `REFUSAL_CATEGORIES.emitStyleExpressionOnce`, and it is about
+// the output rather than the input: **an expression capable of DOING WORK is printed once.** A bare
+// name or a non-computed dotted path is a read, not work, so the inline form is legitimate there —
+// and it matters, because a helper returns one object, which a framework must spread, and a spread
+// costs the element its patch flag (Vue measured `12 /* STYLE, PROPS */` becoming
+// `16 /* FULL_PROPS */` plus a `mergeProps` per render on the hottest element in the tree).
+//
+// So the VERDICT is identical across adapters — every shape lowers — and only the cost differs,
+// exactly as compile-time substitution differs between a JSX path and an SFC one. The verdicts are
+// what `@symbiote-native/components/lowering-fixtures` pins.
+//
+// THE CONTRACT THIS IMPOSES ON APP CODE: a style callback must be PURE in `pressed`. Its result is
+// invoked twice under every emission, so a side-effecting body is observable now.
+function isStyleCallback(value) {
+    return typeof value === 'function';
+}
+/**
+ * Splits an authored `style` into its resting and pressed halves, reading the value once.
+ *
+ * A non-callback passes through untouched with no active variant, which the engine reads as "leave
+ * slot 1 alone" — that is what makes one emission safe for an expression whose value cannot be
+ * known at compile time.
+ */
+export function resolveStateStyle(value) {
+    if (!isStyleCallback(value))
+        return { style: value, activeStyle: undefined };
+    return {
+        style: value({ pressed: false }),
+        activeStyle: value({ pressed: true }),
+    };
+}

package/build/text-props.js

@@ -1,6 +1,7 @@
 // The defaults RN's Text.js applies before handing props to native, folded once for every adapter.
 //
-// RN does this unconditionally on the outer (non-virtual) path, Text.js:288-291:
+// RN does this unconditionally on the outer (non-virtual) path, Text.js:289 and :291 (the two
+// lines between them, 288 and 290, are `accessible` and `disabled` — not part of this fold):
 //
 //   processedProps.allowFontScaling = allowFontScaling !== false;
 //   processedProps.ellipsizeMode = ellipsizeMode ?? 'tail';

package/build/view/render-activity-indicator.js

@@ -1,3 +1,29 @@
+// ACTIVITYINDICATOR IS NOT A LOWERABLE PRIMITIVE, AND WILL NOT BECOME ONE. Decided 2026-09-01.
+// It stays a component in every adapter; do not add it to `HOST_PRIMITIVES`.
+//
+// The reason is the `el('symbiote-view', wrapperProps, [el('symbiote-activity-indicator', …)])` at
+// the bottom of this file: the render SYNTHESIZES a node that is not the primitive itself. A lowered
+// tag is ONE engine node, and a host behavior's `foldPayload` maps props to props on that node — it
+// cannot create a child. Lowering would therefore drop the centering container and change layout,
+// which is an optimisation moving the observable surface, the one thing this design may not do.
+//
+// The wrapper is not over-building: RN's own `ActivityIndicator.js:112` renders a `<View>` around
+// the native spinner too, so the two nodes are inherent. And the container cannot be folded INTO the
+// spinner — it carries `alignItems`/`justifyContent`, which centre the spinner inside the space it
+// was given; moved onto the spinner they would centre its children, of which it has none.
+//
+// The two alternatives were priced and both cost more than the primitive is worth. A behavior that
+// CREATES a node needs a commit hook, i.e. a machine, i.e. a `-managed` tag split — a new category,
+// not a fold. Synthesising the container inside the engine's commit walk is NOT the `RCTVirtualText`
+// precedent it resembles: `viewNameFor` changes what one node IS and never ADDS one, so adding one
+// would make the retained and committed trees disagree on node count — which every counter, census
+// probe and benchmark in this repo assumes. Spinners are rare on a screen, so the per-instance cost
+// lowering removes is not measurably paid here; the objection to leaving it is uniformity, not speed.
+//
+// Under half A this costs an app NOTHING: `View` and `ActivityIndicator` are both ordinary imports
+// from the adapter barrel, so which one is internally a tag and which a component is invisible at
+// the call site. The general rule is in `.claude/rules/host-primitive-tier.md`.
+//
 // ActivityIndicator: the render half (framework-agnostic). RN wraps the native spinner
 // in a centering View and translates `size` in JS: 'small'/'large' map to a native size
 // enum AND a fixed box style; a numeric size never reaches native (it sizes the spinner

package/build/view/render-image/index.d.ts

@@ -53,4 +53,6 @@ export type IImageViewProps = {
     referrerPolicy?: string;
     passthrough: Record<string, unknown>;
 };
+export declare const IMAGE_VIEW_PROP_NAMES: readonly ["source", "defaultSource", "loadingIndicatorSource", "style", "resizeMode", "tintColor", "src", "srcSet", "alt", "width", "height", "crossOrigin", "referrerPolicy"];
+export declare function mapImageProps(view: IImageViewProps): Record<string, unknown>;
 export declare function renderImage(view: IImageViewProps): IDescriptor;

package/build/view/render-image/index.js

@@ -112,7 +112,31 @@ function readSourceUri(source) {
     }
     return undefined;
 }
-export function renderImage(view) {
+// The names `renderImage` CONSUMES rather than forwards — the fold's input list, and the reason it
+// is exported: an adapter that splits props before calling renderImage was copying this list by
+// hand, and a name added here reached the copy only if someone remembered. The Image behavior's
+// `foldPayload` reads it too, so the flat path and the view path cannot drift apart.
+export const IMAGE_VIEW_PROP_NAMES = [
+    'source',
+    'defaultSource',
+    'loadingIndicatorSource',
+    'style',
+    'resizeMode',
+    'tintColor',
+    'src',
+    'srcSet',
+    'alt',
+    'width',
+    'height',
+    'crossOrigin',
+    'referrerPolicy',
+];
+// The whole of Image's prop mapping, with the `el()` wrap taken off. Split out because a LOWERED
+// `<symbiote-image>` has no component body to run it in: its behavior's `foldPayload` needs the same
+// bag at commit time, and a second implementation of this is the exact drift this file already paid
+// for once (`adapters/svelte/src/components/image/image-logic.ts` reproduces it by hand, with a
+// comment saying it had to because nothing here was exported).
+export function mapImageProps(view) {
     // `width` / `height` aliases fold into style (ImageProps.js:195,202); explicit
     // style keys win, matching RN's `{width, height}, ...style` ordering.
     const foldedStyle = view.width === undefined && view.height === undefined
@@ -138,6 +162,9 @@ export function renderImage(view) {
     if (view.loadingIndicatorSource !== undefined) {
         mapped.loadingIndicatorSrc = readSourceUri(view.loadingIndicatorSource);
     }
+    return mapped;
+}
+export function renderImage(view) {
     dlog('Image -> RCTImageView');
-    return el('symbiote-image', mapped);
+    return el('symbiote-image', mapImageProps(view));
 }

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

@@ -6,4 +6,6 @@ export type IInputAccessoryViewViewProps = {
     style?: IStyleProp<IViewStyle>;
     passthrough: Record<string, unknown>;
 };
+export declare const INPUT_ACCESSORY_VIEW_PROP_NAMES: readonly ["nativeID", "backgroundColor", "style"];
+export declare function mapInputAccessoryViewProps(view: IInputAccessoryViewViewProps): Record<string, unknown>;
 export declare function renderInputAccessoryView(view: IInputAccessoryViewViewProps): IDescriptor;

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

@@ -6,16 +6,48 @@
 // verbatim across adapters: React and Vue both bridge this Descriptor.
 import { dlog, } from '@symbiote-native/engine';
 import { el } from '../descriptor.js';
-export function renderInputAccessoryView(view) {
-    const props = {
+// The names this fold CONSUMES, exported so an adapter splitting props before calling the render fn
+// reads the list instead of copying it — the drift `render-image.ts` records paying for once.
+export const INPUT_ACCESSORY_VIEW_PROP_NAMES = [
+    'nativeID',
+    'backgroundColor',
+    'style',
+];
+// The whole mapping, so the wrapper path and the lowered path share ONE implementation. There is no
+// aliasing here at all: every consumed name leaves under the same name, which is what makes the
+// fold idempotent by construction (asserted in `behaviors/input-accessory-view.test.ts`, not
+// assumed).
+//
+// The `undefined` guards on `nativeID` / `backgroundColor` are LOAD-BEARING, and the asymmetry with
+// the unguarded `style` above is not the tell it looks like.
+//
+// They were removed on 2026-09-01 on the reasoning `.claude/rules/fabric-boolean-event-gates.md`
+// states — `setProp` collapses an undefined value to an absent key, so a conditional write in a
+// shared render fn is cosmetic — and that reasoning was checked against a payload carrying no `id`,
+// which is exactly the case where it holds. The equivalence oracle caught it on its first run:
+//
+//   authored <InputAccessoryView id="p" testID="p" />
+//   guarded    RCTInputAccessoryView{testID, nativeID:"p"}
+//   unguarded  RCTInputAccessoryView{testID}              <- the alias result, deleted
+//
+// `nativeID` has an ALIAS SOURCE. The wrapper leaves `id` in `passthrough`, the renderer's
+// PROP_ALIASES renames it to `nativeID`, and a `nativeID: undefined` written afterwards deletes what
+// the rename just produced — last write wins, and `undefined` collapsing to "absent" is precisely
+// what makes it destructive rather than inert. So the guard is cosmetic for a key nothing else can
+// produce, and required for a key an alias also targets.
+export function mapInputAccessoryViewProps(view) {
+    const out = {
         ...view.passthrough,
         style: view.style,
     };
     if (view.nativeID !== undefined)
-        props.nativeID = view.nativeID;
+        out.nativeID = view.nativeID;
     if (view.backgroundColor !== undefined)
-        props.backgroundColor = view.backgroundColor;
+        out.backgroundColor = view.backgroundColor;
+    return out;
+}
+export function renderInputAccessoryView(view) {
     dlog('InputAccessoryView -> RCTInputAccessoryView');
     // Empty structural children: the adapter appends the user children directly under the host.
-    return el('symbiote-input-accessory-view', props, []);
+    return el('symbiote-input-accessory-view', mapInputAccessoryViewProps(view), []);
 }

package/build/view/render-switch.js

@@ -8,6 +8,12 @@ import { dlog } from '@symbiote-native/engine';
 import { el } from '../descriptor.js';
 // RN rounds the iOS background pill to this radius when ios_backgroundColor is set.
 const IOS_BACKGROUND_BORDER_RADIUS = 16;
+// The `-managed` spelling, NOT the plain one the engine's Switch behavior registers under
+// (`core/components/src/behaviors/switch.ts`) — the wrapper still runs its own lifecycle
+// (lastNativeReport, the snap-back effect), so it may not share a tag the behavior registry would
+// also attach to; see that behavior's module header and `.claude/rules/host-primitive-tier.md`,
+// "A lowered element and its wrapper must not share an intrinsic tag" (the TextInput precedent).
+const SWITCH_MANAGED_INTRINSIC = 'symbiote-switch-managed';
 // Fold ios_backgroundColor into the style, matching RN's iOS branch: it paints the
 // background that shows through the shrunken track. Untouched when unset, so a caller's own
 // backgroundColor wins by simply not passing ios_backgroundColor.
@@ -32,5 +38,5 @@ export function renderSwitch(view, platform) {
         thumbTintColor: view.thumbColor,
         style: foldIosBackground(view.style, view.ios_backgroundColor),
     };
-    return el('symbiote-switch', props);
+    return el(SWITCH_MANAGED_INTRINSIC, props);
 }

package/build/view/render-text-input.js

@@ -8,8 +8,12 @@ import { dlog } from '@symbiote-native/engine';
 import { el } from '../descriptor.js';
 // One host element per native input class. Text carries the only non-trivial nesting elsewhere;
 // here the choice is binary and runtime (the `multiline` prop), so the module stays flat.
-const SINGLELINE_INTRINSIC = 'symbiote-text-input';
-const MULTILINE_INTRINSIC = 'symbiote-text-input-multiline';
+// The `-managed` spelling, NOT the plain one the lowering transforms emit. Both resolve to the
+// same native view; the tag is what decides whether the engine's TextInput machine attaches, and
+// on this path the adapter's own lifecycle already owns that state. Sharing the tag would run both
+// copies at once. Full reasoning in `component-names/shared.ts`.
+const SINGLELINE_INTRINSIC = 'symbiote-text-input-managed';
+const MULTILINE_INTRINSIC = 'symbiote-text-input-multiline-managed';
 export function renderTextInput(view) {
     const intrinsic = view.multiline ? MULTILINE_INTRINSIC : SINGLELINE_INTRINSIC;
     dlog(`TextInput render multiline=${String(view.multiline)} ` +