@symbiote-native/angular 1.0.0 → 2.0.1

package/src/host-instance/index.ts

@@ -2,7 +2,7 @@
 // adapters/vue/src/host-instance/index.ts. RN's "ref/instance -> native reactTag" lookup,
 // the seam imperative-interop libraries reach through.
 //
-// Angular template refs on a primitive host (`<View #myView>`) receive the component instance,
+// Angular template refs on a primitive host (`<view #myView>`) receive the component instance,
 // not the raw engine node. SymbiotePrimitiveHost exposes `nativeElement`, which holds the
 // engine host node that `getNativeTag` is keyed on. This adapter accepts:
 //   - a bare number (idempotent)

package/src/index.ts

@@ -8,34 +8,20 @@
 import './register';
 
 export {
-  ActivityIndicator,
   anchorHostStyle,
-  Button,
   FlatList,
   HorizontalScrollContentView,
   HorizontalScrollView,
   Image,
-  ImageBackground,
-  InputAccessoryView,
   KeyboardAvoidingView,
   Modal,
-  Pressable,
-  RefreshControl,
-  SafeAreaView,
   ScrollContentView,
-  ScrollView,
-  ScrollViewStickyHeader,
   SectionList,
   stableAnchorStyle,
-  Switch,
   SymbioteHostPropsDirective,
   SymbioteStyleInputDirective,
   Text,
-  TextInput,
-  TouchableHighlight,
   TouchableNativeFeedback,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
   View,
   VirtualizedList,
   VirtualizedSectionList,
@@ -75,6 +61,7 @@ export {
 export { createAnimatedComponent } from './modules/animated';
 export type {
   IActivityIndicatorProps,
+  IAngularPressableInputs,
   IAngularImageBackgroundProps,
   IAngularInputAccessoryViewProps,
   IAngularKeyboardAvoidingViewProps,
@@ -112,7 +99,6 @@ export type {
   ISectionListProps,
   ISeparatorProps,
   ISeparators,
-  IStickyHeaderComponentType,
   ISubmitBehavior,
   IThemeAttrBackground,
   IViewabilityConfig,
@@ -130,10 +116,61 @@ export type {
   ISection,
   ISwitchProps,
   ISwitchTrackColor,
+  ISwitchChangeEvent,
   ITextInputHandle,
   ITextInputSelection,
+  ITextInputChangeEvent,
 } from './components';
 export { setImageSourceResolver } from './components';
+// The element directives that make a HAND-WRITTEN intrinsic tag (`<view>`, `<text-input>`, ...)
+// compile under ngtsc with no schema, and with a real type on every declared prop. `imports:
+// [SYMBIOTE_ELEMENTS]` is the whole app-facing surface; the individual classes are exported for an
+// app that wants a narrower import. See `elements.ts`'s header for why a directive rather than
+// `CUSTOM_ELEMENTS_SCHEMA`/`NO_ERRORS_SCHEMA`.
+export {
+  SYMBIOTE_ELEMENTS,
+  SymbioteElement,
+  ActivityIndicatorElement,
+  ActivityIndicatorSpinnerElement,
+  ButtonElement,
+  HorizontalScrollContentElement,
+  HorizontalScrollViewElement,
+  ImageBackgroundElement,
+  ImageElement,
+  InputAccessoryViewElement,
+  ManagedMultilineTextInputElement,
+  ManagedSwitchElement,
+  ManagedTextInputElement,
+  ModalElement,
+  MultilineTextInputElement,
+  PressableElement,
+  RefreshControlElement,
+  SafeAreaViewElement,
+  ScrollContentElement,
+  ScrollViewElement,
+  StickyHeaderElement,
+  SwitchElement,
+  TextElement,
+  TextInputElement,
+  // The `[(ngModel)]` / `formControl*` accessors for the two controlled tags — where the deleted
+  // wrappers' `NG_VALUE_ACCESSOR` went. Both ride `SYMBIOTE_ELEMENTS`; named separately for an app
+  // that imports narrowly.
+  SwitchValueAccessor,
+  TextInputValueAccessor,
+  // The three the list omitted while their components still existed. These are now the ONLY
+  // replacements for their deleted components in an app's `imports`, so a narrower import has to be
+  // able to name them.
+  TouchableHighlightElement,
+  TouchableNativeFeedbackElement,
+  TouchableOpacityElement,
+  TouchableWithoutFeedbackElement,
+  ViewElement,
+} from './elements';
+export type {
+  IElementProps,
+  IStickyHeaderElementProps,
+  ITextElementProps,
+} from './element-props';
 export { mount, unmount } from './render';
 // The generic Descriptor→Angular bridge, the twin of descriptorToReact/descriptorToVue.
 // Exported so a component defined OUTSIDE this package (e.g.

package/src/modules/animated/create-animated-component.ts

@@ -37,12 +37,10 @@ import {
   resolveHostNode,
   type ISymbioteNode,
 } from '@symbiote-native/engine';
-import { selectScrollIntrinsics } from '@symbiote-native/components';
-import { Image, ScrollView, Text, View } from '../../components';
+import { Text, View } from '../../components';
 import {
   anchorHostStyle,
   ImageHost,
-  ScrollViewHost,
   SymbioteHostPropsDirective,
   SymbioteStyleInputDirective,
   TextHost,
@@ -55,11 +53,17 @@ import {
   ImageBase,
   isImageEventCallback,
   resolveImageProps,
-} from '../../components/image/shared';
+} from '../../components/image-shared';
 import type { IGatedAccessibilityEvent } from '../../gate-demand';
 import { SectionList } from '../../components/section-list';
 import { AnimatedLeafBinder } from './animated-leaf-binder';
 
+// The intrinsic `createAnimatedComponent` accepts in place of the deleted `Image` component.
+const IMAGE_TAG = 'image';
+// Same move for the deleted `ScrollView` component — the vertical axis's own tag stands in for
+// the class identity the generic dispatcher used to compare against.
+const SCROLL_VIEW_TAG = 'scroll-view';
+
 // RN's prop carrying explicit (already-rasterized) values that override the animated prop in
 // the COMMITTED props (sticky-header passthrough). Named once so the directive input and the
 // reconcile agree.
@@ -70,7 +74,17 @@ const PASSTHROUGH_PROP = 'passthroughAnimatedPropExplicitValues';
 // escape hatch for any OTHER prop that may hold an AnimatedNode or an Animated.event handler,
 // plus static host props to forward (the React/Vue `rest`). Each concrete @Component re-lists
 // these (Angular's inputs-on-base convention, mirroring Switch/Image).
-export const ANIMATED_INPUTS = ['style', 'animatedProps', PASSTHROUGH_PROP];
+// `testID` is listed alongside them rather than left to `animatedProps`, which is the documented
+// escape hatch for everything else. Every other component in this adapter takes it as an ordinary
+// input, and React's `createAnimatedComponent` spreads `...props`, so `<AnimatedView testID="x">`
+// is what an app writes — it compiled (a static attribute on a component tag is never checked),
+// landed on the non-painting anchor host and committed nowhere.
+export const ANIMATED_INPUTS = [
+  'style',
+  'testID',
+  'animatedProps',
+  PASSTHROUGH_PROP,
+];
 export const ANIMATED_IMAGE_INPUTS = [
   ...IMAGE_INPUTS,
   'animatedProps',
@@ -87,6 +101,7 @@ export abstract class AnimatedComponentBase
   implements AfterViewInit, DoCheck, OnChanges, OnDestroy
 {
   style: unknown;
+  testID: string | undefined;
   animatedProps: Record<string, unknown> | undefined;
   passthroughAnimatedPropExplicitValues: unknown;
 
@@ -183,9 +198,11 @@ export abstract class AnimatedComponentBase
   // never disagree.
   private mergedProps(): Record<string, unknown> {
     const base = this.animatedProps ?? {};
-    return this.style === undefined
-      ? { ...base }
-      : { ...base, style: this.style };
+    const merged: Record<string, unknown> =
+      this.style === undefined ? { ...base } : { ...base, style: this.style };
+    // Only when set, so an unset input cannot clear a `testID` the app put in `animatedProps`.
+    if (this.testID !== undefined) merged.testID = this.testID;
+    return merged;
   }
 
   // The committed host node held by IDENTITY. resolveHostNode unwraps an imperative scroll
@@ -207,9 +224,9 @@ export abstract class AnimatedComponentBase
   imports: [SymbioteHostPropsDirective, ViewHost],
   inputs: ANIMATED_INPUTS,
   template: `
-    <symbiote-view [symbioteHostProps]="reducedProps">
+    <view [symbioteHostProps]="reducedProps">
       <ng-content></ng-content>
-    </symbiote-view>
+    </view>
   `,
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
@@ -225,9 +242,9 @@ export class AnimatedView extends AnimatedComponentBase {}
   imports: [SymbioteHostPropsDirective, TextHost],
   inputs: ANIMATED_INPUTS,
   template: `
-    <symbiote-text [symbioteHostProps]="reducedProps">
+    <text [symbioteHostProps]="reducedProps">
       <ng-content></ng-content>
-    </symbiote-text>
+    </text>
   `,
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
@@ -244,7 +261,7 @@ export class AnimatedText extends AnimatedComponentBase {}
   inputs: ANIMATED_IMAGE_INPUTS,
   outputs: IMAGE_OUTPUTS,
   template: `
-    <symbiote-image
+    <image
       [symbioteHostProps]="animatedImageProps"
       (loadStart)="handleLoadStart($event)"
       (load)="handleLoad($event)"
@@ -254,7 +271,7 @@ export class AnimatedText extends AnimatedComponentBase {}
       (partialLoad)="handlePartialLoad($event)"
     >
       <ng-content></ng-content>
-    </symbiote-image>
+    </image>
   `,
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
@@ -382,49 +399,23 @@ export class AnimatedImage
     { directive: SymbioteStyleInputDirective, inputs: ['style'] },
   ],
   schemas: [CUSTOM_ELEMENTS_SCHEMA],
-  imports: [SymbioteHostPropsDirective, ScrollViewHost],
+  imports: [SymbioteHostPropsDirective],
   inputs: ANIMATED_INPUTS,
   template: `
-    <symbiote-scroll-view [symbioteHostProps]="reducedProps">
-      <symbiote-scroll-content [symbioteHostProps]="contentProps">
-        <ng-content></ng-content>
-      </symbiote-scroll-content>
-    </symbiote-scroll-view>
+    <scroll-view [symbioteHostProps]="reducedProps">
+      <ng-content></ng-content>
+    </scroll-view>
   `,
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class AnimatedScrollView extends AnimatedComponentBase {
-  // RN defaults nested scrolling ON (ScrollView.js `nestedScrollEnabled ?? true`) — Android
-  // needs it explicit or a nested ScrollView never receives touch (swallowed by the outer one;
-  // iOS doesn't gate on this). The real ScrollView component already defaults this
-  // (scroll-view/shared.ts), but AnimatedScrollView talks to the raw primitive directly and
-  // must apply it too.
-  //
-  // scrollViewBaseStyle (overflow: 'scroll' + the per-axis flexDirection) is the other thing the
-  // real ScrollView applies that this bespoke template used to skip — without it, iOS Fabric
-  // never clips content to the scroll view's frame (invisible on Android, whose native ViewGroup
-  // clips regardless of style). This wrapper has no `horizontal` input and its template is
-  // hardcoded to the vertical intrinsics, so selectScrollIntrinsics is always called with
-  // isHorizontal=false here, matching what the template can actually render.
-  override get reducedProps(): Record<string, unknown> {
-    const reduced = super.reducedProps;
-    const { scrollViewBaseStyle } = selectScrollIntrinsics(false, undefined);
-    const withScrollBase: Record<string, unknown> = {
-      ...reduced,
-      style: [scrollViewBaseStyle, reduced.style],
-    };
-    return withScrollBase.nestedScrollEnabled === undefined
-      ? { ...withScrollBase, nestedScrollEnabled: true }
-      : withScrollBase;
-  }
-
-  // The content (inner) view's props: contentStyle from the same intrinsics selection, plus
-  // `collapsable: false` (the Android multi-child fix this file's tests already cover) — mirrors
-  // the real ScrollView's own `contentProps` getter (scroll-view/shared.ts).
-  get contentProps(): Record<string, unknown> {
-    const { contentStyle } = selectScrollIntrinsics(false, undefined);
-    return { style: contentStyle, collapsable: false };
-  }
+  // Nothing left to override: `registerScrollViewBehavior()` (`../../register.ts`) now owns the
+  // content node, `scrollViewBaseStyle`/`nestedScrollEnabled` defaults, and the sticky seam for
+  // this SAME `scroll-view` tag. This class used to build its own `<scroll-content>` child by
+  // hand — deleted 2026-09-11, since that made TWO owners of the content node the moment the
+  // behavior registered on this tag: the engine's own `buildStructure` and this template both
+  // creating one. `<ng-content>` now lands directly under the owner and the behavior redirects it
+  // into the content node it builds, same as every other `<scroll-view>` in the app.
 }
 
 // List components are already explicit AOT-compiled Angular components with their own full input
@@ -441,12 +432,16 @@ export const AnimatedSectionList = SectionList;
 export function createAnimatedComponent(base: unknown): Type<unknown> {
   if (base === View) return AnimatedView;
   if (base === Text) return AnimatedText;
-  if (base === Image) return AnimatedImage;
-  if (base === ScrollView) return AnimatedScrollView;
+  // The TAG, not a component identity: `ScrollView`/`Image` are gone as classes now
+  // (`components/scroll-view-props.ts`, `modules/image`), so there is no class to compare
+  // against — the same move React made (`createAnimatedComponent('image')`). A tag string is also
+  // what portable app code can pass on every adapter.
+  if (base === SCROLL_VIEW_TAG) return AnimatedScrollView;
+  if (base === IMAGE_TAG) return AnimatedImage;
   throw new Error(
     'createAnimatedComponent: Angular cannot synthesize a component at runtime (no JIT compiler ' +
       'under AOT/Metro). Author an explicit standalone @Component extending AnimatedComponentBase ' +
-      'instead. The built-in primitives View / Text / Image / ScrollView map to ' +
-      'AnimatedView / AnimatedText / AnimatedImage / AnimatedScrollView.',
+      "instead. The built-in primitives View / Text and the tags 'scroll-view' / 'image' map to " +
+      'AnimatedView / AnimatedText / AnimatedScrollView / AnimatedImage.',
   );
 }

package/src/modules/animated/index.ts

@@ -55,7 +55,7 @@ export {
 // getter only exists to defer a RUNTIME createAnimatedComponent(ScrollView) past module init so
 // it cannot read ScrollView inside its own TDZ during an import cycle. AnimatedScrollView here is
 // a statically-declared component that never reads the ScrollView class at init (it targets the
-// `symbiote-scroll-view` host by string), so there is no cycle to defer.
+// `scroll-view` host by string), so there is no cycle to defer.
 //
 // FlatList / SectionList are exposed as explicit AOT-safe list entries now that the Angular list
 // components exist. Angular still cannot synthesize arbitrary animated wrappers at runtime; custom

package/src/modules/image/index.ts

@@ -0,0 +1,18 @@
+// RN's Image STATICS — `getSize`, `getSizeWithHeaders`, `prefetch`, `abortPrefetch`, `queryCache`,
+// `resolveAssetSource`.
+//
+// IN `modules/`, NOT `components/`. The primitive is the `<image>` tag matched by `ImageElement`,
+// and its fold runs in the engine (`behaviors/image.ts`); what is left under the name `Image` is an
+// imperative API with no view, which is what this bucket is for
+// (<adapter_src_follows_framework_idioms>). Sitting in `components/` was what made a statics object
+// read as a component.
+//
+// A NAMESPACE OBJECT rather than six bare functions, deliberately: `Alert`, `Share`, `Linking` and
+// `AppState` all take that shape, and an app porting from RN writes `Image.getSize(...)` verbatim.
+//
+// Shared verbatim via `imageStatics`, the same source every other adapter's Image uses.
+import { imageStatics, type IImageStatics } from '@symbiote-native/components';
+
+export type { IImageStatics };
+
+export const Image: IImageStatics = imageStatics;

package/src/primitives/index.ts

@@ -24,7 +24,7 @@ export {
 } from './shared';
 
 @Component({
-  selector: 'symbiote-view, View',
+  selector: 'view',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
@@ -41,7 +41,7 @@ export class ViewHost extends SymbiotePrimitiveHost {}
  * 'tail' would silently overwrite an explicit `ellipsizeMode="clip"`.
  */
 @Component({
-  selector: 'symbiote-text, Text',
+  selector: 'text',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
@@ -73,35 +73,35 @@ export class TextHost extends SymbiotePrimitiveHost implements OnInit {
 }
 
 @Component({
-  selector: 'symbiote-image',
+  selector: 'image',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ImageHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-scroll-view',
+  selector: 'scroll-view',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ScrollViewHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-scroll-content',
+  selector: 'scroll-content',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ScrollContentView extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-horizontal-scroll-view',
+  selector: 'horizontal-scroll-view',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class HorizontalScrollView extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-horizontal-scroll-content',
+  selector: 'horizontal-scroll-content',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
@@ -111,35 +111,35 @@ export class HorizontalScrollContentView extends SymbiotePrimitiveHost {}
 // Angular template renders them: this adapter has no lowering transform. The `-managed` pair below
 // is what its own TextInput renders.
 @Component({
-  selector: 'symbiote-text-input',
+  selector: 'text-input',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class TextInputHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-text-input-multiline',
+  selector: 'text-input-multiline',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class MultilineTextInputHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-text-input-managed',
+  selector: 'text-input-managed',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ManagedTextInputHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-text-input-multiline-managed',
+  selector: 'text-input-multiline-managed',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ManagedMultilineTextInputHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-switch',
+  selector: 'switch',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
@@ -149,42 +149,46 @@ export class SwitchHost extends SymbiotePrimitiveHost {}
 // behavior does not carry. See `component-names/shared.ts` for why the wrapper may not share the
 // lowered tag; mirrors `ManagedTextInputHost` above.
 @Component({
-  selector: 'symbiote-switch-managed',
+  selector: 'switch-managed',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ManagedSwitchHost extends SymbiotePrimitiveHost {}
 
+// The centering RCTView RN wraps the spinner in (ActivityIndicator.js:112), not the spinner —
+// which is what this tag resolved to until 2026-09-09. The native view moved to
+// `activity-indicator-spinner`, built by the engine's ActivityIndicator behavior, so nothing writes
+// it in a template and it needs no host here.
 @Component({
-  selector: 'symbiote-activity-indicator',
+  selector: 'activity-indicator',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ActivityIndicatorHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-safe-area-view',
+  selector: 'safe-area-view',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class SafeAreaViewHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-modal',
+  selector: 'modal',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class ModalHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-refresh-control',
+  selector: 'refresh-control',
   standalone: true,
   template: '<ng-content></ng-content>',
 })
 export class RefreshControlHost extends SymbiotePrimitiveHost {}
 
 @Component({
-  selector: 'symbiote-input-accessory-view',
+  selector: 'input-accessory-view',
   standalone: true,
   template: '<ng-content></ng-content>',
 })

package/src/primitives/shared.ts

@@ -10,6 +10,7 @@ import {
   type SimpleChanges,
 } from '@angular/core';
 import { countAngular } from '../diagnostics';
+import { createCallbackWrapper } from '../change-detection-flush';
 import {
   flattenStyle,
   isSymbioteNode,
@@ -108,18 +109,6 @@ export function stableAnchorStyle(
     : next;
 }
 
-const ON_PREFIX = /^on[A-Z]/;
-
-// The one `onX` that fires per FRAME rather than per gesture, and with sticky headers RN pins
-// `scrollEventThrottle` to 1 (ScrollView.js), so 60 times a second. Since markForCheck walks
-// RefreshView|Dirty to the ROOT, wrapping it cost one full ancestor-screen template execution per
-// frame - the canary's ~37fps scroll (components/virtualized-list/scroll-cost.test.ts).
-//
-// Nothing lost its refresh: VirtualizedList marks itself when the window moves, sticky rides the
-// native driver, and a caller's own handler is typically an Animated.event touching no Angular
-// state. Drag/momentum begin/end stay wrapped - once per gesture is not a hot path.
-const PER_FRAME_CALLBACK = 'onScroll';
-
 /**
  * Restores the OnPush dirty-marking Angular skips for a `[style]` binding that a directive
  * declares as an input. Attach it to any component declaring a `style` input:
@@ -194,7 +183,7 @@ function isAnchorStyleUnchanged(previous: unknown, next: unknown): boolean {
 }
 
 /**
- * Base for all Angular primitive host components (`symbiote-view`, `symbiote-text`, ...).
+ * Base for all Angular primitive host components (`view`, `text`, ...).
  * RN's `StyleProp` can be an object, an array, nested arrays, falsy entries, and Animated
  * values. Angular's raw `[style]` binding on a custom element routes through the CSS style
  * engine (`setStyle` per key), which crashes on numeric array keys. By declaring `style` as
@@ -265,20 +254,15 @@ export class SymbioteHostPropsDirective {
   // The directive lives in its HOST component's template, so its injected ChangeDetectorRef IS
   // that component's own view detector — the one thing that can refresh it (see wrapCallback).
   private readonly cdr = inject(ChangeDetectorRef);
-  // One wrapper per ORIGINAL handler, for the lifetime of this directive. Without it every push
-  // of the props bag allocated a brand-new closure for every `onX` key, and the engine stored it
-  // as a new listener (`setEventListener` allocates its own closure on top) - per key, per push,
-  // on a path a scroll frame reaches 60 times a second. The wrapper body closes over nothing but
-  // `value` and this instance's `cdr`, so the handler alone is a complete cache key; `key` is
-  // read only by the ON_PREFIX guard above and never enters the wrapper.
-  //
-  // Reference stability is the point, not just the allocation: a fresh function on every push
-  // defeats every downstream identity check on the bag, so nothing upstream could ever conclude
-  // "this bag is unchanged" while a callback prop was in it.
-  private readonly wrappers = new WeakMap<
-    object,
-    (...args: unknown[]) => unknown
-  >();
+  // A flat-bag `onX` callback (responder negotiation, onLongPress, …) is invoked by the engine's
+  // event dispatch — a plain JS call, entirely outside Angular — so nothing dirties the view that
+  // binds its result: the "pan does nothing" bug. Shared with the TAG path's `SymbioteElement`,
+  // which has the identical deficit; the mechanism, the `onScroll` exemption and why the wrapper
+  // is cached per original handler live in `createCallbackWrapper`.
+  private readonly wrapCallback = createCallbackWrapper(
+    this.cdr,
+    this.elementRef.nativeElement,
+  );
 
   // Values pushed by the previous bag, so a push writes only what actually moved. Copied rather
   // than aliased: a component is free to hand back the same object with mutated fields.
@@ -330,21 +314,4 @@ export class SymbioteHostPropsDirective {
   // (`_cdRefInjectingView`, i.e. the host component), unlike `detectChanges()` which acts on a
   // resolved `_lView` that is NOT the host component here. The Angular twin of what React/Vue get
   // for free (setState / proxy reactivity).
-  private wrapCallback(key: string, value: unknown): unknown {
-    if (!ON_PREFIX.test(key) || typeof value !== 'function') return value;
-    if (key === PER_FRAME_CALLBACK) return value;
-    const cached = this.wrappers.get(value);
-    if (cached !== undefined) return cached;
-    // Reflect.apply rather than calling a cast-to-signature local: `typeof value === 'function'`
-    // narrows to `Function`, which has no call signature TypeScript will accept, and this repo
-    // does not use `as` to paper over that. `undefined` as the receiver preserves the previous
-    // unbound call.
-    const wrapper = (...args: unknown[]): unknown => {
-      const result: unknown = Reflect.apply(value, undefined, args);
-      this.cdr.markForCheck();
-      return result;
-    };
-    this.wrappers.set(value, wrapper);
-    return wrapper;
-  }
 }

package/src/register.ts

@@ -1,43 +1,15 @@
 // Side-effect ONLY. Exports nothing, and must never be re-exported from the barrel.
 //
-// A lowered `<symbiote-pressable>`/`<symbiote-text-input>` is a bare custom element with no
-// component behind it, so the press machine and the controlled-input machine have to live on the
-// engine node itself — reached by `registerPressableBehavior()`/`registerTextInputBehavior()`
-// having run before the first node of that tag is created.
+// The fourteen calls live once, in `@symbiote-native/components/register` — they were identical in
+// all five adapters, and each copy carried a migration ledger justifying a call against a wrapper
+// that no longer exists. What is per-adapter is only the SPELLING of the import below: every
+// `*-tag.test.*` here reaches the registry through `import './register';`, and this adapter's own
+// barrel guard pins that line.
 //
-// Metro turns on `inlineRequires` for PRODUCTION only, moving a `require()` down to the first place
-// its binding is used as a VALUE; a barrel's `export { X } from './x'` compiles to a lazy getter,
-// so a module reached only that way never evaluates unless something names it as a value — silent
-// in Release builds alone, invisible to tsc, to vitest, and to grepping the bundle (see CLAUDE.md,
-// "Never make correctness depend on a module's load-time side effect"). A bare
-// `import './register';` placed NEXT TO a re-export of the same specifier does not help either —
-// Babel merges the two into one dependency and the merged one stays lazy. This is the shape that
-// survives both traps, matching `adapters/{vue,svelte,solid}/src/register.ts` and
-// `packages/slider/src/{react,vue,svelte,angular}/index.ts`.
-import {
-  registerImageBehavior,
-  registerInputAccessoryViewBehavior,
-  registerPressableBehavior,
-  registerSwitchBehavior,
-  registerTextInputBehavior,
-} from '@symbiote-native/components';
-
-registerPressableBehavior();
-// Only the LOWERED tags carry this — the wrapper renders `symbiote-text-input-managed` /
-// `symbiote-text-input-multiline-managed` and keeps running its own lifecycle. One owner per node;
-// see `component-names/shared.ts`.
-registerTextInputBehavior();
-// Same reason as TextInput: the wrapper renders `symbiote-switch-managed` and runs its own
-// lastNativeReport/snap-back lifecycle, so the engine's copy attaches only to the bare tag.
-registerSwitchBehavior();
-
-// Image owns no runtime — its behavior is a prop FOLD and nothing else, and it is registered on the
-// same `symbiote-image` the wrapper already emits rather than on a `-managed` twin. That is safe
-// only because the mapping is idempotent, which `core/components/src/behaviors/image.test.ts`
-// asserts rather than assumes; a wrapper-built node simply folds a second time and nothing moves.
-registerImageBehavior();
-
-// Fold-only, and it shares the wrapper's tag for the same reason Image does: the mapping has no
-// aliasing at all, so a wrapper-built node folding a second time moves nothing.
-// `core/components/src/behaviors/input-accessory-view.test.ts` asserts that rather than assuming it.
-registerInputAccessoryViewBehavior();
+// WHY A SIDE-EFFECT SUBPATH 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 that way 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.
+import '@symbiote-native/components/register';