@symbiote-native/angular 3.0.2 → 3.1.0

package/src/components/section-list/index.ts

@@ -177,6 +177,8 @@ export type ISectionListInputs<ItemT> = Omit<
       [scrollEventThrottle]="scrollEventThrottle"
       [keyboardShouldPersistTaps]="keyboardShouldPersistTaps"
       [keyboardDismissMode]="keyboardDismissMode"
+      [removeClippedSubviews]="removeClippedSubviews"
+      [nestedScrollEnabled]="nestedScrollEnabled"
       [style]="resolvedStyle"
       [contentContainerStyle]="contentContainerStyle"
       [testID]="testID"
@@ -343,6 +345,8 @@ export class SectionList<ItemT = unknown>
   @Input() scrollEventThrottle?: number;
   @Input() keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
   @Input() keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+  @Input() removeClippedSubviews?: boolean;
+  @Input() nestedScrollEnabled?: boolean;
   @Input() style?: IStyleProp<IViewStyle>;
   @Input() contentContainerStyle?: IStyleProp<IViewStyle>;
   @Input() testID?: string;

package/src/components/virtualized-list/directives.ts

@@ -35,7 +35,7 @@ import {
   type OnDestroy,
   type SimpleChanges,
 } from '@angular/core';
-import { dlog } from '@symbiote-native/engine';
+import { dlog, isDebug } from '@symbiote-native/engine';
 import { countAngular } from '../../diagnostics';
 import type { ISeparators } from '@symbiote-native/components';
 
@@ -129,9 +129,10 @@ export class VListOutletDirective<C = unknown> implements OnChanges, OnDestroy {
 
   ngOnChanges(changes: SimpleChanges): void {
     if (changes['templateRef'] !== undefined) {
-      dlog(
-        `Angular VListOutlet#${this.instanceId} templateRef CHANGED (was=${changes['templateRef'].previousValue !== undefined} now=${this.templateRef !== undefined}) -> clear + recreate`,
-      );
+      if (isDebug())
+        dlog(
+          `Angular VListOutlet#${this.instanceId} templateRef CHANGED (was=${changes['templateRef'].previousValue !== undefined} now=${this.templateRef !== undefined}) -> clear + recreate`,
+        );
       this.viewContainer.clear();
       countAngular('outletCreates');
       this.viewRef =
@@ -145,9 +146,10 @@ export class VListOutletDirective<C = unknown> implements OnChanges, OnDestroy {
     }
     if (this.viewRef !== null && this.context !== undefined) {
       countAngular('outletUpdates');
-      dlog(
-        `Angular VListOutlet#${this.instanceId} context updated, markForCheck`,
-      );
+      if (isDebug())
+        dlog(
+          `Angular VListOutlet#${this.instanceId} context updated, markForCheck`,
+        );
       this.updateContext(this.viewRef.context, this.context);
       this.viewRef.markForCheck();
     }
@@ -155,7 +157,7 @@ export class VListOutletDirective<C = unknown> implements OnChanges, OnDestroy {
 
   ngOnDestroy(): void {
     countAngular('outletDestroys');
-    dlog(`Angular VListOutlet#${this.instanceId} destroyed`);
+    if (isDebug()) dlog(`Angular VListOutlet#${this.instanceId} destroyed`);
     this.viewContainer.clear();
   }
 

package/src/components/virtualized-list/index.ts

@@ -34,6 +34,7 @@ import {
   EventEmitter,
   Input,
   Output,
+  TemplateRef,
   ViewChild,
   computed,
   inject,
@@ -183,6 +184,8 @@ export interface IVirtualizedListProps<ItemT>
   scrollEventThrottle?: number;
   keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
   keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+  removeClippedSubviews?: boolean;
+  nestedScrollEnabled?: boolean;
   style?: IStyleProp<IViewStyle>;
   contentContainerStyle?: IStyleProp<IViewStyle>;
 }
@@ -267,7 +270,7 @@ interface IWindowCell<ItemT> {
               [style]="cellStyle"
             >
               <ng-container
-                [vListOutlet]="itemDir?.templateRef"
+                [vListOutlet]="cellTemplate"
                 [vListOutletContext]="forcedStickyCell.context"
               ></ng-container>
             </sticky-header>
@@ -282,12 +285,12 @@ interface IWindowCell<ItemT> {
                 [style]="cellStyle"
               >
                 <ng-container
-                  [vListOutlet]="itemDir?.templateRef"
+                  [vListOutlet]="cellTemplate"
                   [vListOutletContext]="cell.context"
                 ></ng-container>
                 @if (cell.separatorContext !== undefined) {
                   <ng-container
-                    [vListOutlet]="separatorDir?.templateRef"
+                    [vListOutlet]="separatorTemplate"
                     [vListOutletContext]="cell.separatorContext"
                   ></ng-container>
                 }
@@ -298,12 +301,12 @@ interface IWindowCell<ItemT> {
                 [style]="cellStyle"
               >
                 <ng-container
-                  [vListOutlet]="itemDir?.templateRef"
+                  [vListOutlet]="cellTemplate"
                   [vListOutletContext]="cell.context"
                 ></ng-container>
                 @if (cell.separatorContext !== undefined) {
                   <ng-container
-                    [vListOutlet]="separatorDir?.templateRef"
+                    [vListOutlet]="separatorTemplate"
                     [vListOutletContext]="cell.separatorContext"
                   ></ng-container>
                 }
@@ -351,7 +354,7 @@ interface IWindowCell<ItemT> {
               [style]="cellStyle"
             >
               <ng-container
-                [vListOutlet]="itemDir?.templateRef"
+                [vListOutlet]="cellTemplate"
                 [vListOutletContext]="forcedStickyCell.context"
               ></ng-container>
             </sticky-header>
@@ -373,12 +376,12 @@ interface IWindowCell<ItemT> {
                 [style]="cellStyle"
               >
                 <ng-container
-                  [vListOutlet]="itemDir?.templateRef"
+                  [vListOutlet]="cellTemplate"
                   [vListOutletContext]="cell.context"
                 ></ng-container>
                 @if (cell.separatorContext !== undefined) {
                   <ng-container
-                    [vListOutlet]="separatorDir?.templateRef"
+                    [vListOutlet]="separatorTemplate"
                     [vListOutletContext]="cell.separatorContext"
                   ></ng-container>
                 }
@@ -389,12 +392,12 @@ interface IWindowCell<ItemT> {
                 [style]="cellStyle"
               >
                 <ng-container
-                  [vListOutlet]="itemDir?.templateRef"
+                  [vListOutlet]="cellTemplate"
                   [vListOutletContext]="cell.context"
                 ></ng-container>
                 @if (cell.separatorContext !== undefined) {
                   <ng-container
-                    [vListOutlet]="separatorDir?.templateRef"
+                    [vListOutlet]="separatorTemplate"
                     [vListOutletContext]="cell.separatorContext"
                   ></ng-container>
                 }
@@ -500,6 +503,8 @@ export class VirtualizedList<ItemT = unknown>
   @Input() scrollEventThrottle?: number;
   @Input() keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
   @Input() keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+  @Input() removeClippedSubviews?: boolean;
+  @Input() nestedScrollEnabled?: boolean;
   @Input() style?: IStyleProp<IViewStyle>;
   @Input() contentContainerStyle?: IStyleProp<IViewStyle>;
   @Input() testID?: string;
@@ -550,6 +555,20 @@ export class VirtualizedList<ItemT = unknown>
   @ContentChild(VListSeparatorDirective)
   separatorDir?: VListSeparatorDirective<ItemT>;
 
+  // A wrapping list (FlatList) hands its app's cell/separator templates straight in, so a cell is
+  // one outlet deep instead of a wrapper outlet around the app's own; each wins over projection.
+  @Input() itemTemplate?: TemplateRef<IVListItemContext<ItemT>>;
+  @Input() itemSeparatorTemplate?: TemplateRef<IVListSeparatorContext<ItemT>>;
+
+  get cellTemplate(): TemplateRef<IVListItemContext<ItemT>> | undefined {
+    return this.itemTemplate ?? this.itemDir?.templateRef;
+  }
+
+  get separatorTemplate():
+    TemplateRef<IVListSeparatorContext<ItemT>> | undefined {
+    return this.itemSeparatorTemplate ?? this.separatorDir?.templateRef;
+  }
+
   // The inner scroll TAG's own engine node — a template ref on a bare intrinsic hands back the
   // host node directly (`isSymbioteNode(elementRef.nativeElement)`, matching `anchorHostStyle`'s
   // own reader below), so there is no wrapper component left to read a handle off. Present from
@@ -739,6 +758,11 @@ export class VirtualizedList<ItemT = unknown>
       scrollEventThrottle: this.scrollEventThrottle,
       keyboardShouldPersistTaps: this.keyboardShouldPersistTaps,
       keyboardDismissMode: this.keyboardDismissMode,
+      // RN's VirtualizedList spreads its props onto the ScrollView, this one included.
+      removeClippedSubviews: this.removeClippedSubviews,
+      nestedScrollEnabled: this.nestedScrollEnabled,
+      // VirtualizedList.js:1111 — Android moves the scrollbar back after the `scale: -1` flip.
+      isInvertedVirtualizedList: this.isInverted ? true : undefined,
       contentOffset: this.commandedOffset,
       // `stickyHeaderIndices` is deliberately NOT forwarded — it numbers the scroll view's PAINT
       // children, and a windowed list paints a header, a spacer and a slice, so the positions move
@@ -1041,7 +1065,7 @@ export class VirtualizedList<ItemT = unknown>
       this.headerDir !== undefined,
       this.footerDir !== undefined,
       this.emptyDir !== undefined,
-      this.separatorDir !== undefined,
+      this.separatorTemplate !== undefined,
     ];
     const previous = this.lastRecompute;
     this.lastRecompute = recomputeInputs;
@@ -1076,7 +1100,7 @@ export class VirtualizedList<ItemT = unknown>
     const m = this.listState.metrics;
     this.itemCount = m.count;
     const hasHeader = this.headerDir !== undefined;
-    const hasSeparators = this.separatorDir !== undefined;
+    const hasSeparators = this.separatorTemplate !== undefined;
     const stickySet =
       this.stickyHeaderIndices !== undefined
         ? new Set(this.stickyHeaderIndices)
@@ -1087,8 +1111,9 @@ export class VirtualizedList<ItemT = unknown>
       : this.contentContainerStyle;
     this.resolvedStyle = flattenStyle([
       anchorHostStyle(this.elementRef),
+      // VirtualizedList.js: `[inversionStyle, style]` — the app's style can override the flip.
       this.isInverted
-        ? [this.style, this.isHorizontal ? INVERTED_X_STYLE : INVERTED_Y_STYLE]
+        ? [this.isHorizontal ? INVERTED_X_STYLE : INVERTED_Y_STYLE, this.style]
         : this.style,
     ]);
     this.cellStyle = this.isInverted

package/src/components/virtualized-section-list/index.ts

@@ -146,6 +146,8 @@ export interface IVirtualizedSectionListProps<ItemT>
   scrollEventThrottle?: number;
   keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
   keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+  removeClippedSubviews?: boolean;
+  nestedScrollEnabled?: boolean;
   style?: IStyleProp<IViewStyle>;
   contentContainerStyle?: IStyleProp<IViewStyle>;
 }
@@ -213,6 +215,8 @@ export type IVirtualizedSectionListInputs<ItemT> = Omit<
       [scrollEventThrottle]="scrollEventThrottle"
       [keyboardShouldPersistTaps]="keyboardShouldPersistTaps"
       [keyboardDismissMode]="keyboardDismissMode"
+      [removeClippedSubviews]="removeClippedSubviews"
+      [nestedScrollEnabled]="nestedScrollEnabled"
       [style]="resolvedStyle"
       [contentContainerStyle]="contentContainerStyle"
       [testID]="testID"
@@ -375,6 +379,8 @@ export class VirtualizedSectionList<ItemT = unknown>
   @Input() scrollEventThrottle?: number;
   @Input() keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
   @Input() keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+  @Input() removeClippedSubviews?: boolean;
+  @Input() nestedScrollEnabled?: boolean;
   @Input() style?: IStyleProp<IViewStyle>;
   @Input() contentContainerStyle?: IStyleProp<IViewStyle>;
   @Input() testID?: string;

package/src/element-props.ts

@@ -8,13 +8,9 @@
 // differ, since a bare tag takes children from the template and a handle from `#ref`, so neither
 // `children` nor `ref` appears here.
 //
-// `style` IS declared, reversing what this comment said until 2026-09-11. Leaving it to Angular's
-// styling engine was not the conservative choice it reads as: an array decomposes into
-// numeric-index keys there and a press-state CALLBACK throws out of `toStylingKeyValueArray`,
-// aborting the enclosing template update — which is what an app writes, and what every deleted
-// wrapper component accepted. The claim that a directive can reclaim it "solely by executing a
-// linked AOT artifact" was answered rather than assumed: `elements.test.ts` compiles the binding
-// through real ngtsc and runs the LINKED output. See `SymbioteElement.style`.
+// `style` and `styleProp` are TWO bindings. `[style]` is Angular's styling binding: an object or CSS
+// string, as on a DOM element, unclaimed because a claim is a directive instance per element. An RN
+// array or press-state callback throws in that engine, so it travels as `[styleProp]`.
 import type {
   IAccessibilityProps,
   IAriaProps,
@@ -31,6 +27,17 @@ import type {
 
 type IEventHandler = (event: ISymbioteEvent) => void;
 
+/**
+ * What `[style]` carries on a tag: Angular's own styling binding, decomposed key by key into
+ * `Renderer2.setStyle` exactly as on a DOM element. A style OBJECT or a CSS string - never an array
+ * or a function, which that engine cannot represent. Those are `[styleProp]`.
+ */
+export type IAngularStyleBinding<TStyle> = TStyle | string | null | undefined;
+
+/** RN's full StyleProp, press-state callback included: the `[styleProp]` binding. */
+export type IElementStyleProp =
+  IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
+
 export interface IElementProps
   extends IAccessibilityProps, IAriaProps, IResponderProps {
   /** RN's modern W3C-named alias for `nativeID`; the renderer folds it (`PROP_ALIASES`). */
@@ -43,13 +50,14 @@ export interface IElementProps
   renderToHardwareTextureAndroid?: boolean;
   shouldRasterizeIOS?: boolean;
   needsOffscreenAlphaCompositing?: boolean;
+  style?: IAngularStyleBinding<IViewStyle>;
   /**
-   * The press-state callback is in the union because a subclass cannot widen an
-   * inherited property and `<pressable>`/`<touchable-*>` are the tags that take one; on every other
-   * tag the engine resolves it at `pressed: false`.
+   * An RN StyleProp as ONE property binding: arrays, falsy entries, and the press-state callback.
+   * The callback is in the union because a subclass cannot widen an inherited property and
+   * `<pressable>`/`<touchable-*>` are the tags that take one; on every other tag the engine resolves
+   * it at `pressed: false`.
    */
-  style?:
-    IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
+  styleProp?: IElementStyleProp;
   onPress?: IEventHandler;
   onPressIn?: IEventHandler;
   onPressOut?: IEventHandler;
@@ -63,7 +71,8 @@ export interface IElementProps
 /** Text's own surface on top of the shared one. `onTextLayout` is an event, so it is not here. */
 export interface ITextElementProps {
   /** Narrows the shared `style` so `fontSize` / `fontWeight` type-check on a `<text>`. */
-  style?: IStyleProp<ITextStyle>;
+  style?: IAngularStyleBinding<ITextStyle>;
+  styleProp?: IStyleProp<ITextStyle>;
   numberOfLines?: number;
   ellipsizeMode?: 'head' | 'middle' | 'tail' | 'clip';
   selectable?: boolean;

package/src/elements.ts

@@ -58,7 +58,6 @@ import {
 } from './change-detection-flush';
 import { SymbioteCallbackHost } from './callback-host';
 import { withholdFromRuntimeMatching } from './runtime-matching';
-import { SymbioteStyleHost } from './style-host';
 import type {
   IActivityIndicatorProps,
   IImageProps,
@@ -190,44 +189,21 @@ export abstract class SymbioteElement implements OnChanges {
   @Input() shouldRasterizeIOS?: IElementProps['shouldRasterizeIOS'];
   @Input()
   needsOffscreenAlphaCompositing?: IElementProps['needsOffscreenAlphaCompositing'];
-  // Declared, and the reason is the one `element-props.ts` used to give for NOT declaring it —
-  // reversed by measurement. `[style]` on an element with no directive input reaches Angular's own
-  // CSS styling engine (`ɵɵstyleMap`), which cannot represent an RN StyleProp: an ARRAY decomposes
-  // into numeric-index keys and a FUNCTION — the press-state callback this ecosystem writes — dies
-  // in `toStylingKeyValueArray` as "ASSERTION ERROR: Unsupported styling type: function", taking
-  // the whole enclosing template update with it. Device-reported 2026-09-11: every `ActionButton`
-  // in examples/angular painted as an empty bordered box, because the throw aborted the update
-  // before its `<text>` child was ever reached.
-  //
-  // A declared input CLAIMS the binding at compile time, so it never reaches the styling engine —
-  // the same mechanism the primitive host COMPONENTS have always relied on
-  // (`primitives/shared.ts`), which is why `<Pressable [style]>` worked and its replacement tag did
-  // not. `[style.borderWidth.px]` is a different instruction (`ɵɵstyleProp`) and is untouched: it
-  // still reaches `Renderer2.setStyle`, which merges per key.
+  // `[style]` and `[class]` are declared for the TYPE CHECK only. Withheld from run-time matching, no
+  // input claims them, so Angular's own styling engine decomposes them into `setStyle`/`addClass`
+  // exactly as on a DOM element - which is why `style` is typed as the object/string that engine can
+  // hold. An RN style ARRAY or press-state FUNCTION throws in there ("indexOf is not a function",
+  // "Unsupported styling type: function"), so it is `[styleProp]`: an ordinary property binding the
+  // renderer routes to `style` whole. A claim would cost a directive instance per element.
   //
   // The press-state callback rides the BASE type rather than `PressableElement` alone: a subclass
   // cannot widen an inherited property, and only the pressables have a `pressed` to read — so on
-  // any other tag the engine resolves it at `pressed: false` and the looseness is in the type, not
-  // in what commits.
+  // any other tag the engine resolves it at `pressed: false`.
   @Input() style?: IElementProps['style'];
+  @Input() styleProp?: IElementProps['styleProp'];
 
-  /**
-   * Declared so Angular SHADOWS the `[class]` binding into it instead of decomposing the string.
-   *
-   * A styling binding goes to a directive input when the directive declares that exact public name
-   * — `setShadowStylingInputFlags` sets `hasClassInput`/`hasStyleInput` off the input map, and
-   * `checkStylingMap` then hands the whole value over and never calls the renderer per key
-   * (`view/directives.ts`, `instructions/styling.ts`). `style` has been declared here all along and
-   * is shadowed; `class` was not, so every `[class]` reached the renderer one TOKEN at a time — on
-   * the element-directive path as much as the bare one. Measured at ~3.3 us per class binding
-   * (`adapter-create-cost.itest.ts`, "prices the class channel"), on the channel every example app
-   * uses for its static look.
-   *
-   * `[class.foo]` and `[ngClass]` are NOT shadowed and keep arriving as `addClass`, so a node can
-   * now be told its classes both ways at once; the renderer unions the two sources
-   * (`classStringFor`). Typed as a string rather than RN's `className`, because that is what
-   * `ɵɵclassMap` hands over after it concatenates any static `class=` prefix.
-   */
+  // `ɵɵclassMap` hands over a string after joining any static `class=` prefix; `[class.foo]` and
+  // `[ngClass]` arrive as `addClass`. The renderer unions both sources (`classStringFor`).
   @Input() class?: string;
 
   // The flat-bag spelling of the events below. `(press)` and `[onPress]` are both supported and
@@ -422,6 +398,7 @@ export class TextElement extends SymbioteElement {
   // initializer is what TS2612 asks for to accept a redeclaration as deliberate; `declare` would
   // be the other answer and cannot carry a decorator.
   @Input() override style?: ITextElementProps['style'] = undefined;
+  @Input() override styleProp?: ITextElementProps['styleProp'] = undefined;
   @Input() numberOfLines?: ITextElementProps['numberOfLines'];
   @Input() ellipsizeMode?: ITextElementProps['ellipsizeMode'];
   @Input() selectable?: ITextElementProps['selectable'];
@@ -927,39 +904,27 @@ export const SYMBIOTE_ELEMENTS = [
   // bind one and carries the `ChangeDetectorRef` their wrapper needs. It rides this list for the same
   // reason the accessors do, and `elements.test.ts` subtracts it from the tag-coverage check by name.
   SymbioteCallbackHost,
-  // The other attribute-matched one: it claims `[style]` and `[class]` so an RN style ARRAY never
-  // reaches Angular's styling engine, which cannot represent one and throws. See `style-host.ts`.
-  SymbioteStyleHost,
 ] as const;
 
 // THE DIRECTIVES THAT GO ON MATCHING, and the list is the exceptions rather than the rule.
 //
-// A tag directive here is, with four exceptions, nothing but `@Input()` declarations over one
-// inherited `ngOnChanges` that forwards each of them to the renderer — which is the call
-// `ɵɵproperty` makes directly on an element nothing claimed. So the instance buys a compile-time
-// check at ~8.5-9.4 us of run time per element, and `./runtime-matching` keeps the check while
-// dropping the instance.
-//
-// These four cannot go, because they DO something when they are built:
+// EVERY TAG DIRECTIVE IS WITHHELD. Each is `@Input()` declarations over one inherited `ngOnChanges`
+// forwarding to the renderer (the call `ɵɵproperty` makes directly on an unclaimed element), so the
+// instance bought a compile-time check at ~8 us of run time per element.
 //
-//   text-input, text-input-multiline, switch   `ValueChangeElement` — listens for the engine's value
-//                                              event and registers a view flush, which is what stops
-//                                              a controlled value being undone inside one microtask
-//   refresh-control                            `ReadBackElement`, the same flush for the same reason
+// The read-back tags (text-input, text-input-multiline, switch, refresh-control) need a synchronous
+// view flush; the renderer marks them at creation and the flush finds their view lazily
+// (`change-detection-flush.ts`). `[(value)]` reaches the renderer's `listen('valueChange')` bridge.
 //
-// The two form accessors and `SymbioteCallbackHost` are absent from both lists deliberately: they
-// match on an ATTRIBUTE rather than a tag, so they already land only where they are needed.
+// `[style]`/`[class]` stay unclaimed as on a DOM element (see `SymbioteElement.style`). What still
+// matches is selected on an ATTRIBUTE an app writes: the two form accessors and
+// `SymbioteCallbackHost`.
 withholdFromRuntimeMatching(
   SYMBIOTE_ELEMENTS.filter(
     directive =>
-      directive !== TextInputElement &&
-      directive !== MultilineTextInputElement &&
-      directive !== SwitchElement &&
-      directive !== RefreshControlElement &&
       directive !== TextInputValueAccessor &&
       directive !== SwitchValueAccessor &&
-      directive !== SymbioteCallbackHost &&
-      directive !== SymbioteStyleHost,
+      directive !== SymbioteCallbackHost,
   ),
 );
 

package/src/index.ts

@@ -9,8 +9,8 @@
 // `@Component`s on the `view` and `text` SELECTORS — a second mechanism on the same tags
 // `SYMBIOTE_ELEMENTS` covers, kept for one stated reason their own header gives: "Declaring `style`
 // as a real Angular input prevents Angular's CSS style engine from decomposing RN `StyleProp`
-// arrays". `SymbioteStyleHost` does exactly that now, for every tag, at a directive's cost rather
-// than a component's.
+// arrays". A tag takes an array or press-state callback as `[styleProp]`, a plain property binding
+// with no instance behind it.
 //
 // An app loses nothing it cannot spell better: `@ViewChild('ref')` on a template reference returns
 // Angular's own `ElementRef<IHostInstance>`, whose `nativeElement` IS the engine host node — the same
@@ -146,10 +146,9 @@ export { setImageSourceResolver } from './components';
 //
 // They were removed on 2026-09-18 and put back the same hour. The reason to remove them is real: a
 // withheld tag directive (`./runtime-matching`) is a compile-time declaration and nothing else, so
-// what makes `<view [style]="[a, b]">` work at RUN time is `SymbioteStyleHost`, and what makes
-// `<view [onPress]="fn">` work at all is `SymbioteCallbackHost` claiming the name before
-// `setDomProperty` throws NG0306. Both ride this array. A narrow `imports: [ViewElement]` type-checks
-// and then fails on a device the first time the app writes an array style.
+// what makes `<view [onPress]="fn">` work at all is `SymbioteCallbackHost` claiming the name before
+// `setDomProperty` throws NG0306. It rides this array, so a narrow `imports: [ViewElement]`
+// type-checks and then fails on a device the first time the app binds an `on*` prop.
 //
 // WHAT PUTS THEM BACK is NG3004: `Unable to import directive ViewElement — the symbol is not
 // exported from index.d.ts`. ngtsc resolves every directive reachable through an imported array to an
@@ -198,7 +197,6 @@ export {
   CALLBACK_ATTRIBUTE_SELECTOR,
   SymbioteCallbackHost,
 } from './callback-host';
-export { STYLE_HOST_SELECTOR, SymbioteStyleHost } from './style-host';
 export type {
   IElementProps,
   IStickyHeaderElementProps,