@symbiote-native/angular 0.6.2 → 0.8.0

package/src/components/modal/index.ts

@@ -13,11 +13,14 @@ import {
   ChangeDetectionStrategy,
   ChangeDetectorRef,
   Component,
+  computed,
   ElementRef,
   EventEmitter,
   inject,
   Input,
   Output,
+  signal,
+  type DoCheck,
   type OnChanges,
   type OnInit,
   type SimpleChanges,
@@ -33,7 +36,6 @@ import {
   type IAriaProps,
   type IModalAnimationType,
   type IModalOrientation,
-  type IModalOrientationChangeEvent,
   type IModalPresentationStyle,
   type IModalState,
 } from '@symbiote-native/components';
@@ -44,7 +46,13 @@ import {
   type ISymbioteEvent,
   type IViewStyle,
 } from '@symbiote-native/engine';
-import { anchorHostStyle, ModalHost, SymbioteHostPropsDirective, ViewHost } from '../../primitives';
+import {
+  anchorHostStyle,
+  ModalHost,
+  SymbioteHostPropsDirective,
+  SymbioteStyleInputDirective,
+  ViewHost,
+} from '../../primitives';
 
 export type {
   IModalAnimationType,
@@ -53,17 +61,6 @@ export type {
   IModalOrientationChangeEvent,
 } from '@symbiote-native/components';
 
-const ORIENTATIONS: ReadonlyArray<IModalOrientation> = ['portrait', 'landscape'];
-
-function readOrientation(event: ISymbioteEvent): IModalOrientationChangeEvent | undefined {
-  const native = event.nativeEvent;
-  if (typeof native !== 'object' || native === null || !('orientation' in native)) return undefined;
-  const orientation = native.orientation;
-  return ORIENTATIONS.some(value => value === orientation)
-    ? { orientation: orientation === 'landscape' ? 'landscape' : 'portrait' }
-    : undefined;
-}
-
 // Mirrors React's IModalProps minus children (Angular takes children via <ng-content>).
 export interface IAngularModalProps extends IAccessibilityProps, IAriaProps {
   visible?: boolean;
@@ -79,7 +76,9 @@ export interface IAngularModalProps extends IAccessibilityProps, IAriaProps {
   onShow?: () => void;
   onDismiss?: () => void;
   onRequestClose?: () => void;
-  onOrientationChange?: (event: IModalOrientationChangeEvent) => void;
+  // The engine hands every listener the ISymbioteEvent wrapper, so the orientation is read at
+  // event.nativeEvent.orientation (IModalOrientationChangeEvent describes that payload).
+  onOrientationChange?: (event: ISymbioteEvent) => void;
   style?: IStyleProp<IViewStyle>;
 }
 
@@ -102,17 +101,20 @@ export type IAngularModalInputs = Omit<
 @Component({
   selector: 'Modal',
   standalone: true,
+  hostDirectives: [
+    { directive: SymbioteStyleInputDirective, inputs: ['style'] },
+  ],
   schemas: [CUSTOM_ELEMENTS_SCHEMA],
   imports: [ModalHost, ViewHost, SymbioteHostPropsDirective],
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `
     @if (shouldRender) {
       <symbiote-modal
-        [symbioteHostProps]="hostProps"
+        [symbioteHostProps]="hostProps()"
         (show)="show.emit()"
         (dismiss)="dismiss.emit()"
         (requestClose)="requestClose.emit()"
-        (orientationChange)="emitOrientation($event)"
+        (orientationChange)="emit(orientationChange, $event)"
         (accessibilityAction)="emit(accessibilityAction, $event)"
         (accessibilityTap)="emit(accessibilityTap, $event)"
         (magicTap)="emit(magicTap, $event)"
@@ -125,11 +127,11 @@ export type IAngularModalInputs = Omit<
     }
   `,
 })
-export class Modal implements IAngularModalInputs, OnInit, OnChanges {
+export class Modal implements IAngularModalInputs, OnInit, OnChanges, DoCheck {
   @Output() readonly show = new EventEmitter<void>();
   @Output() readonly dismiss = new EventEmitter<void>();
   @Output() readonly requestClose = new EventEmitter<void>();
-  @Output() readonly orientationChange = new EventEmitter<IModalOrientationChangeEvent>();
+  @Output() readonly orientationChange = new EventEmitter<ISymbioteEvent>();
   @Output() readonly accessibilityAction = new EventEmitter<ISymbioteEvent>();
   @Output() readonly accessibilityTap = new EventEmitter<ISymbioteEvent>();
   @Output() readonly magicTap = new EventEmitter<ISymbioteEvent>();
@@ -154,8 +156,10 @@ export class Modal implements IAngularModalInputs, OnInit, OnChanges {
   @Input() accessibilityValue?: IAccessibilityProps['accessibilityValue'];
   @Input() accessibilityActions?: IAccessibilityProps['accessibilityActions'];
   @Input() accessibilityLabelledBy?: string | string[];
-  @Input() importantForAccessibility?: IAccessibilityProps['importantForAccessibility'];
-  @Input() accessibilityLiveRegion?: IAccessibilityProps['accessibilityLiveRegion'];
+  @Input()
+  importantForAccessibility?: IAccessibilityProps['importantForAccessibility'];
+  @Input()
+  accessibilityLiveRegion?: IAccessibilityProps['accessibilityLiveRegion'];
   @Input() screenReaderFocusable?: boolean;
   @Input() accessibilityViewIsModal?: boolean;
   @Input() accessibilityElementsHidden?: boolean;
@@ -195,7 +199,20 @@ export class Modal implements IAngularModalInputs, OnInit, OnChanges {
     this.state = createInitialModalState(this.visible === true);
   }
 
+  // Bridges the non-reactive @Input fields `hostProps` reads into the reactive graph, so it can
+  // memoize. Plain fields read inside a computed() are UNTRACKED - something must signal "a
+  // dependency changed" or the bag goes stale. Signal inputs would do this natively, but `input()`
+  // is visible only to the AOT compiler and this package's unit suite runs on JIT (see the
+  // `angular-adapter-change-detection` skill, §6); `signal()`/`computed()` are plain runtime APIs.
+  // The keep-alive `state` is deliberately NOT a dependency: it gates `shouldRender`, never the bag.
+  private readonly hostPropsRevision = signal(0);
+  // What the anchor's class-derived style was when the bag was last built (identity, not value).
+  private lastAnchorStyle: unknown;
+
   ngOnChanges(changes: SimpleChanges): void {
+    // Before the keep-alive early-return below: this is the single moment Angular has finished
+    // writing every changed @Input, and `hostProps` depends on far more than `visible`.
+    this.hostPropsRevision.update(revision => revision + 1);
     const visibleChange = changes.visible;
     // First change is reflected by the ngOnInit seed; only later toggles drive the keep-alive.
     if (visibleChange === undefined || visibleChange.firstChange) return;
@@ -203,7 +220,10 @@ export class Modal implements IAngularModalInputs, OnInit, OnChanges {
     // Queue on a microtask so the reducer runs AFTER this CD pass renders with the OLD state —
     // the keep-alive frame. A synchronous dispatch here would unmount in the same pass.
     queueMicrotask(() => {
-      this.state = modalReducer(this.state, isVisible ? { type: 'show' } : { type: 'hide' });
+      this.state = modalReducer(
+        this.state,
+        isVisible ? { type: 'show' } : { type: 'hide' },
+      );
       this.changeDetector.markForCheck();
     });
   }
@@ -233,13 +253,34 @@ export class Modal implements IAngularModalInputs, OnInit, OnChanges {
     });
   }
 
+  // The anchor's class-derived style is NOT an @Input: `class="..."`/`[ngClass]` at the use site
+  // resolves through the renderer's addClass onto this component's anchor host (see
+  // anchorHostStyle's doc comment), so it never shows up in SimpleChanges and ngOnChanges alone
+  // would leave a later class toggle stranded. ngDoCheck runs at exactly the cadence the old
+  // getter was re-read, and bumps only on a real identity change.
+  ngDoCheck(): void {
+    const anchorStyle = anchorHostStyle(this.elementRef);
+    if (anchorStyle === this.lastAnchorStyle) return;
+    this.lastAnchorStyle = anchorStyle;
+    this.hostPropsRevision.update(revision => revision + 1);
+  }
+
   // renderModal's own MODAL_HOST_STYLE (position:'absolute') is the outer symbiote-modal node's
   // style; the anchor's class-derived style goes FIRST, that resolved style SECOND —
   // flattenStyle's later-wins collapse keeps the modal's own style winning over its ambient class.
-  get hostProps(): Record<string, unknown> {
+  //
+  // A computed(), not a getter: Angular re-reads a template getter on every refresh of this view
+  // and `[symbioteHostProps]` compares by REFERENCE, so a freshly rebuilt (but identical) bag
+  // re-pushes every key through renderer.setProperty -> the engine's prop routing - and this one
+  // re-runs renderModal to build it.
+  readonly hostProps = computed<Record<string, unknown>>(() => {
+    this.hostPropsRevision();
     const descriptorProps = this.descriptor.props;
-    return { ...descriptorProps, style: [anchorHostStyle(this.elementRef), descriptorProps.style] };
-  }
+    return {
+      ...descriptorProps,
+      style: [anchorHostStyle(this.elementRef), descriptorProps.style],
+    };
+  });
 
   get containerStyle(): unknown {
     const container = this.descriptor.children[0];
@@ -250,15 +291,11 @@ export class Modal implements IAngularModalInputs, OnInit, OnChanges {
     if (isSymbioteEvent(event)) emitter.emit(event);
   }
 
-  emitOrientation(event: unknown): void {
-    if (!isSymbioteEvent(event)) return;
-    const change = readOrientation(event);
-    if (change !== undefined) this.orientationChange.emit(change);
-  }
-
   // Typed as the a11y intersection WITH the string index (the bag renderModal spreads into the
   // host props), so resolveAccessibilityProps's result stays assignable to passthrough.
-  private accessibilityInputs(): IAccessibilityProps & IAriaProps & Record<string, unknown> {
+  private accessibilityInputs(): IAccessibilityProps &
+    IAriaProps &
+    Record<string, unknown> {
     return {
       testID: this.testID,
       accessible: this.accessible,
@@ -276,8 +313,10 @@ export class Modal implements IAngularModalInputs, OnInit, OnChanges {
       accessibilityElementsHidden: this.accessibilityElementsHidden,
       accessibilityIgnoresInvertColors: this.accessibilityIgnoresInvertColors,
       accessibilityLanguage: this.accessibilityLanguage,
-      accessibilityRespondsToUserInteraction: this.accessibilityRespondsToUserInteraction,
-      accessibilityShowsLargeContentViewer: this.accessibilityShowsLargeContentViewer,
+      accessibilityRespondsToUserInteraction:
+        this.accessibilityRespondsToUserInteraction,
+      accessibilityShowsLargeContentViewer:
+        this.accessibilityShowsLargeContentViewer,
       accessibilityLargeContentTitle: this.accessibilityLargeContentTitle,
       role: this.role,
       'aria-label': this.ariaLabel,

package/src/components/pressable/index.ts

@@ -5,10 +5,14 @@ import {
   Component,
   ElementRef,
   EventEmitter,
+  computed,
   inject,
   Input,
   Output,
+  signal,
   ViewChild,
+  type DoCheck,
+  type OnChanges,
 } from '@angular/core';
 import {
   createPressHandlers,
@@ -40,15 +44,24 @@ import {
   type IStyleProp,
   type IViewStyle,
 } from '@symbiote-native/engine';
-import { anchorHostStyle, SymbioteHostPropsDirective, ViewHost } from '../../primitives';
+import {
+  anchorHostStyle,
+  SymbioteHostPropsDirective,
+  SymbioteStyleInputDirective,
+  ViewHost,
+} from '../../primitives';
 
-export type { IPressState, IPressableAndroidRippleConfig } from '@symbiote-native/components';
+export type {
+  IPressState,
+  IPressableAndroidRippleConfig,
+} from '@symbiote-native/components';
 
 // The full logical Pressable surface, callback-shaped press/hover events included. Touchable* and
 // TouchableNativeFeedback still take their OWN onPress/onPressIn/... as @Input() callbacks (that is
 // a separate, not-yet-converted decision) and derive their public prop types from this - so it keeps
 // the callback fields even though the Pressable component below no longer implements them directly.
-export interface IAngularPressableProps extends IAccessibilityProps, IAriaProps {
+export interface IAngularPressableProps
+  extends IAccessibilityProps, IAriaProps {
   onPress?: IPressHandler;
   onPressIn?: IPressHandler;
   onPressOut?: IPressHandler;
@@ -74,7 +87,8 @@ export interface IAngularPressableProps extends IAccessibilityProps, IAriaProps
   nextFocusLeft?: number;
   nextFocusRight?: number;
   nextFocusUp?: number;
-  style?: IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
+  style?:
+    IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
 }
 
 // What the Pressable component itself takes as plain @Input()s: the full surface minus the press/
@@ -96,7 +110,9 @@ export type IAngularPressableInputs = Omit<
   | 'onAccessibilityEscape'
 >;
 
-function isStyleFn(value: unknown): value is (state: IPressState) => IStyleProp<IViewStyle> {
+function isStyleFn(
+  value: unknown,
+): value is (state: IPressState) => IStyleProp<IViewStyle> {
   return typeof value === 'function';
 }
 
@@ -109,12 +125,15 @@ function asSymbioteEvent(event: unknown): ISymbioteEvent | undefined {
 @Component({
   selector: 'Pressable, symbiote-pressable',
   standalone: true,
+  hostDirectives: [
+    { directive: SymbioteStyleInputDirective, inputs: ['style'] },
+  ],
   schemas: [CUSTOM_ELEMENTS_SCHEMA],
   imports: [ViewHost, SymbioteHostPropsDirective],
   template: `
     <symbiote-view
       #host
-      [symbioteHostProps]="hostProps"
+      [symbioteHostProps]="hostProps()"
       (accessibilityAction)="emit(accessibilityAction, $event)"
       (accessibilityTap)="emit(accessibilityTap, $event)"
       (magicTap)="emit(magicTap, $event)"
@@ -131,7 +150,7 @@ function asSymbioteEvent(event: unknown): ISymbioteEvent | undefined {
   `,
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class Pressable implements IAngularPressableInputs {
+export class Pressable implements IAngularPressableInputs, OnChanges, DoCheck {
   // The press/hover lifecycle as real Angular events: `(press)="onTap($event)"`, not
   // `[onPress]="onTap"`. createPressHandlers still wants plain IPressHandler callbacks, so
   // emitterHandler() below adapts each EventEmitter into one - only while something is actually
@@ -176,10 +195,13 @@ export class Pressable implements IAngularPressableInputs {
   @Input() accessibilityRole?: IAngularPressableProps['accessibilityRole'];
   @Input() accessibilityState?: IAccessibilityStateValue;
   @Input() accessibilityValue?: IAngularPressableProps['accessibilityValue'];
-  @Input() accessibilityActions?: IAngularPressableProps['accessibilityActions'];
+  @Input()
+  accessibilityActions?: IAngularPressableProps['accessibilityActions'];
   @Input() accessibilityLabelledBy?: string | string[];
-  @Input() importantForAccessibility?: IAccessibilityProps['importantForAccessibility'];
-  @Input() accessibilityLiveRegion?: IAccessibilityProps['accessibilityLiveRegion'];
+  @Input()
+  importantForAccessibility?: IAccessibilityProps['importantForAccessibility'];
+  @Input()
+  accessibilityLiveRegion?: IAccessibilityProps['accessibilityLiveRegion'];
   @Input() screenReaderFocusable?: boolean;
   @Input() accessibilityViewIsModal?: boolean;
   @Input() accessibilityElementsHidden?: boolean;
@@ -205,13 +227,23 @@ export class Pressable implements IAngularPressableInputs {
   @Input() id?: string;
   @Input() role?: IAngularPressableProps['role'];
 
-  @ViewChild('host', { read: ElementRef }) private hostElement?: ElementRef<unknown>;
+  @ViewChild('host', { read: ElementRef })
+  private hostElement?: ElementRef<unknown>;
+
+  // INTERNAL mutable state, driven by the press machine rather than by an @Input, so ngOnChanges
+  // can never cover it - it carries its OWN signal, which is what lets the memoized bag below stay
+  // correct across a press. Exposed as a plain boolean getter so a use site's `#ref.pressed` keeps
+  // reading a boolean and the public surface is unchanged.
+  private readonly pressedState = signal(false);
+
+  get pressed(): boolean {
+    return this.pressedState();
+  }
 
-  pressed = false;
   private readonly runtime: IPressRuntime = createPressRuntime();
   private readonly host: IPressHost = {
     setPressed: pressed => {
-      this.pressed = pressed;
+      this.pressedState.set(pressed);
       this.changeDetector.detectChanges();
     },
     getMeasureFn: () => {
@@ -231,6 +263,39 @@ export class Pressable implements IAngularPressableInputs {
   // inner `symbiote-view` one level down.
   private readonly elementRef = inject(ElementRef);
 
+  // Bridges the non-reactive @Input fields above into the reactive graph, so the computed() bag
+  // below can memoize a value derived from them. Signal inputs would make this unnecessary, but
+  // `input()` is visible only to the AOT compiler and this package's unit suite runs on JIT - see
+  // the `angular-adapter-change-detection` skill, §6. Mirrors ScrollView's identical bridge
+  // (components/scroll-view/shared.ts), including its constraint: ONLY safe for a bag whose every
+  // dependency is an @Input or carries its own signal, never for plain internal mutable state.
+  private readonly inputsRevision = signal(0);
+
+  // The anchor's class-derived style is the one hostProps dependency that is NOT an @Input:
+  // `class="..."`/`[class.x]`/`[ngClass]` at the use site resolves through the renderer's
+  // addClass/removeClass onto the anchor node (anchorHostStyle's doc comment), so it never appears
+  // in SimpleChanges and ngOnChanges cannot cover it. The engine's commitClassStyle allocates a
+  // fresh [classStyle, explicitStyle] array on exactly the passes where a class token actually
+  // moved, so signal.set's own Object.is check makes an unchanged poll a no-op that dirties nothing.
+  private readonly anchorStyle = signal<unknown>(undefined);
+
+  // ngDoCheck is the only hook that observes the anchor AFTER the parent wrote it. Angular flushes
+  // a node's pre-order hooks at the next `advance` PAST it (hooks.ts callHooks runs "until that
+  // node index exclusive") or in refreshView's post-template flush - both strictly after the
+  // parent's classProp on this element, and strictly before this component's own view refreshes.
+  // Angular also nulls the active consumer around lifecycle hooks (render3/hooks.ts), so this
+  // write registers no dependency on the caller's view and cannot throw NG0600.
+  ngDoCheck(): void {
+    this.anchorStyle.set(anchorHostStyle(this.elementRef));
+  }
+
+  ngOnChanges(): void {
+    // Tells the computed bag below that an @Input moved - plain class fields are not reactive on
+    // their own. Must stay in ngOnChanges: that is the single moment Angular has finished writing
+    // every changed input for this pass.
+    this.inputsRevision.update(revision => revision + 1);
+  }
+
   get resolvedStyle(): IStyleProp<IViewStyle> | undefined {
     const state: IPressState = { pressed: this.pressed };
     return isStyleFn(this.style) ? this.style(state) : this.style;
@@ -241,7 +306,10 @@ export class Pressable implements IAngularPressableInputs {
       accessibilityLabel: this.accessibilityLabel,
       accessibilityHint: this.accessibilityHint,
       accessibilityRole: this.accessibilityRole,
-      accessibilityState: resolveDisabledAccessibilityState(this.accessibilityState, this.disabled),
+      accessibilityState: resolveDisabledAccessibilityState(
+        this.accessibilityState,
+        this.disabled,
+      ),
       accessibilityValue: this.accessibilityValue,
       accessibilityActions: this.accessibilityActions,
       accessibilityLabelledBy: this.accessibilityLabelledBy,
@@ -252,8 +320,10 @@ export class Pressable implements IAngularPressableInputs {
       accessibilityElementsHidden: this.accessibilityElementsHidden,
       accessibilityIgnoresInvertColors: this.accessibilityIgnoresInvertColors,
       accessibilityLanguage: this.accessibilityLanguage,
-      accessibilityRespondsToUserInteraction: this.accessibilityRespondsToUserInteraction,
-      accessibilityShowsLargeContentViewer: this.accessibilityShowsLargeContentViewer,
+      accessibilityRespondsToUserInteraction:
+        this.accessibilityRespondsToUserInteraction,
+      accessibilityShowsLargeContentViewer:
+        this.accessibilityShowsLargeContentViewer,
       accessibilityLargeContentTitle: this.accessibilityLargeContentTitle,
       'aria-label': this.ariaLabel,
       'aria-busy': this.ariaBusy,
@@ -275,11 +345,20 @@ export class Pressable implements IAngularPressableInputs {
   }
 
   get resolvedRippleProps(): Record<string, unknown> | undefined {
-    return this.android_ripple === undefined ? undefined : rippleProps(this.android_ripple);
+    return this.android_ripple === undefined
+      ? undefined
+      : rippleProps(this.android_ripple);
   }
 
   // Flat bag for `[symbioteHostProps]` (Renderer2.setProperty per key) - see primitives/shared.ts.
-  get hostProps(): Record<string, unknown> {
+  //
+  // MEASURED 2026-08-16: as a getter this rebuilt the bag on every refresh of this view, and a
+  // press dirties this very view (SymbioteHostPropsDirective wraps each flat-bag onX with
+  // markForCheck, and setPressed calls detectChanges outright), so `[symbioteHostProps]`'s
+  // reference check failed every time and re-pushed every key through Renderer2.setProperty ->
+  // routeProp for an identical bag. Memoized, an unchanged bag costs one reference compare.
+  readonly hostProps = computed<Record<string, unknown>>(() => {
+    this.inputsRevision();
     return {
       testID: this.testID,
       nativeID: this.nativeID,
@@ -289,36 +368,42 @@ export class Pressable implements IAngularPressableInputs {
       nextFocusLeft: this.nextFocusLeft,
       nextFocusRight: this.nextFocusRight,
       nextFocusUp: this.nextFocusUp,
-      style: [anchorHostStyle(this.elementRef), this.resolvedStyle],
+      style: [this.anchorStyle(), this.resolvedStyle],
       accessible: this.accessible,
       ...this.foldedAccessibility,
       android_disableSound: this.android_disableSound,
-      nativeBackgroundAndroid: this.resolvedRippleProps?.nativeBackgroundAndroid,
-      nativeForegroundAndroid: this.resolvedRippleProps?.nativeForegroundAndroid,
+      nativeBackgroundAndroid:
+        this.resolvedRippleProps?.nativeBackgroundAndroid,
+      nativeForegroundAndroid:
+        this.resolvedRippleProps?.nativeForegroundAndroid,
     };
-  }
+  });
 
   handlePressIn(event: unknown): void {
     const symbioteEvent = asSymbioteEvent(event);
-    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined) return;
+    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined)
+      return;
     this.handlers.handlePressIn(symbioteEvent);
   }
 
   handlePressOut(event: unknown): void {
     const symbioteEvent = asSymbioteEvent(event);
-    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined) return;
+    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined)
+      return;
     this.handlers.handlePressOut(symbioteEvent);
   }
 
   handlePress(event: unknown): void {
     const symbioteEvent = asSymbioteEvent(event);
-    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined) return;
+    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined)
+      return;
     this.handlers.handlePress(symbioteEvent);
   }
 
   handleResponderMove(event: unknown): void {
     const symbioteEvent = asSymbioteEvent(event);
-    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined) return;
+    if (shouldSuppressPress(this.disabled) || symbioteEvent === undefined)
+      return;
     this.handlers.handleResponderMove(symbioteEvent);
   }
 
@@ -339,14 +424,18 @@ export class Pressable implements IAngularPressableInputs {
   // is listening anyway, mirroring core's noteHoverNoop but off `.observed` instead of an @Input.
   private noteHoverNoop(): void {
     if (this.hoverIn.observed || this.hoverOut.observed) {
-      dlog('Pressable hover is a no-op on this host (no pointer-enter/leave event)');
+      dlog(
+        'Pressable hover is a no-op on this host (no pointer-enter/leave event)',
+      );
     }
   }
 
   // Wraps an @Output() as an IPressHandler only while it has a subscriber, so an unbound
   // (longPress) still skips arming the timer, matching createPressHandlers' "undefined means
   // nobody cares" contract.
-  private emitterHandler(emitter: EventEmitter<ISymbioteEvent>): IPressHandler | undefined {
+  private emitterHandler(
+    emitter: EventEmitter<ISymbioteEvent>,
+  ): IPressHandler | undefined {
     return emitter.observed ? event => emitter.emit(event) : undefined;
   }