@blotch/angular-lynx 22.2.2 → 22.2.4

package/types/blotch-angular-lynx.d.ts

@@ -1,11 +1,13 @@
 import * as i0 from "@angular/core";
-import { ApplicationConfig, ApplicationRef, ComponentRef, EmbeddedViewRef, EnvironmentInjector, EnvironmentProviders, ErrorDetails, ErrorHandler, Injector, OnChanges, OnDestroy, SimpleChanges, TemplateRef, Type, ViewContainerRef, signal } from "@angular/core";
-import { Animation, AnimationEvent, AnimationOptions, Element, KeyEvent, LayoutChangeEvent, MouseEvent, TouchEvent, TransitionEvent, UIAppearanceEvent, WheelEvent } from "@lynx-js/types/main-thread";
+import { ApplicationConfig, ApplicationRef, ComponentRef, EmbeddedViewRef, EnvironmentInjector, EnvironmentProviders, ErrorDetails, ErrorHandler, InjectionToken, Injector, OnChanges, OnDestroy, OutputRef, Signal, SimpleChanges, TemplateRef, Type, ViewContainerRef, signal } from "@angular/core";
+import { Animation, AnimationOptions, Element as Element$1 } from "@lynx-js/types/main-thread";
 import { AnyObject } from "@lynx-js/types/common";
 import { ControlValueAccessor } from "@angular/forms";
-import { PlatformType, ResourcePrefetchData, ResourcePrefetchResult, TextInfo, TextMetrics, TouchEvent as TouchEvent$1 } from "@lynx-js/types";
+import { BaseAnimationEvent, BaseKeyEvent, BaseMouseEvent, BaseTouchEvent, BaseTransitionEvent, BaseWheelEvent, LayoutChangeDetailEvent, UIAppearanceDetailEvent } from "@lynx-js/types/events";
+import { MouseEvent, PlatformType, ResourcePrefetchData, ResourcePrefetchResult, TextInfo, TextMetrics, TouchEvent } from "@lynx-js/types";
 import { LocationChangeListener, LocationStrategy, PlatformLocation } from "@angular/common";
 import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy, RouterFeatures, Routes } from "@angular/router";
+import { Subject } from "rxjs";
 /**
  * Programmatic accessibility control for screen readers on Lynx.
  *
@@ -32,7 +34,9 @@ export declare class LynxAccessibility {
    * operation results that aren't reflected by focus movement alone
    * (e.g. toast messages, background task completion, live counters).
    *
-   * Wraps `lynx.accessibilityAnnounce()`.
+   * Wraps `lynx.accessibilityAnnounce()`. Only the background thread's `lynx`
+   * has it, and event handlers run on the main thread, so the call goes
+   * through the background thread (see background-call.ts).
    */
   announce(content: string): Promise<void>;
   /**
@@ -43,11 +47,69 @@ export declare class LynxAccessibility {
    * Only ID selectors are reliably supported (e.g. `'#myElement'`).
    *
    * Wraps `lynx.createSelectorQuery().select(selector).invoke({ method: 'requestAccessibilityFocus' }).exec()`.
+   * The main thread's `lynx` has no createSelectorQuery, but it's where event
+   * handlers run and where the native elements live, so there the element is
+   * found and called directly.
    */
   requestFocus(selector: string): Promise<void>;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxAccessibility, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+/**
+ * The user's accessibility display settings, as signals: Reduce Motion,
+ * Reduce Transparency and Increase Contrast.
+ *
+ * Lynx has no API for them on any platform, so they come from the host app,
+ * in its global props, like the theme does: `reduceMotion`,
+ * `reduceTransparency` and `increaseContrast`, each `true` when on. The apps
+ * `ng build --platform` makes send them, and send them again when the user
+ * changes one:
+ *
+ * - **iOS:** `UIAccessibility.isReduceMotionEnabled`,
+ *   `isReduceTransparencyEnabled` and `isDarkerSystemColorsEnabled`
+ *   (Increase Contrast).
+ * - **Android:** Remove animations (an animator duration scale of 0) for
+ *   Reduce Motion, and contrast above standard (Android 14) or high contrast
+ *   text (Android 16) for Increase Contrast. Android has no Reduce
+ *   Transparency setting.
+ *
+ * In the web preview they follow the browser's `prefers-reduced-motion`,
+ * `prefers-reduced-transparency` and `prefers-contrast: more` too. Lynx
+ * Explorer sends none of them, so they're off there, unless you add them to
+ * the bundle URL: `?reduceMotion=true`.
+ *
+ * iOS 27's Liquid Glass appearance setting (clear or tinted glass) has no
+ * public API, so it isn't here. UIKit's glass follows it, and Reduce
+ * Transparency and Increase Contrast, by itself.
+ *
+ * @usageNotes
+ * ```typescript
+ * const settings = inject(LynxAccessibilitySettings);
+ *
+ * // Jump instead of sliding when the user asked for less motion.
+ * const duration = computed(() => (settings.reduceMotion() ? 0 : 250));
+ * ```
+ */
+export declare class LynxAccessibilitySettings {
+  #private;
+  /**
+   * The user asked for less motion. Replace movement, such as a slide or a
+   * bounce, with a fade or an instant change.
+   */
+  readonly reduceMotion: Signal<boolean>;
+  /**
+   * The user asked for less transparency. Draw blurred and translucent
+   * surfaces opaque.
+   */
+  readonly reduceTransparency: Signal<boolean>;
+  /**
+   * The user asked for more contrast: iOS's Increase Contrast. Strengthen
+   * borders and use full-strength text colors.
+   */
+  readonly increaseContrast: Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxAccessibilitySettings, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * Phantom brand symbol — makes each ElementRef variant nominally distinct at
  * the type level even though Lynx PAPI handles have no runtime structure.
@@ -247,19 +309,17 @@ type LynxAnimationOptions = AnimationOptions & {
   timingFunction?: string;
 };
 /**
- * Shared interface for all animation implementations (real and no-op).
- * Used by `BaseLynxElement.animate()` return type so both `LynxAnimation`
- * (main thread) and `NoopLynxAnimation` (background thread) are valid.
- * Required because LynxAnimation uses ES private fields (#element, #count)
- * which brand the class — TypeScript's structural typing won't accept
- * NoopLynxAnimation as assignable to LynxAnimation. This shared Pick type
- * extracts only the public API both implementations satisfy.
+ * The public API of an animation, which `BaseLynxElement.animate()` returns.
+ * LynxAnimation uses ES private fields (#element, #count), which brand the
+ * class, so a structural type lets other implementations, such as a test
+ * double, satisfy it.
  */
 type BaseLynxAnimation = Pick<Animation, 'id' | 'cancel' | 'pause' | 'play'>;
 /**
  * Represents a running animation on a Lynx element.
  * Created by calling `element.animate()` on a LynxElement.
- * Mirrors the Animation class from React Lynx's worklet-runtime.
+ * Mirrors the Animation class from React Lynx's worklet-runtime, except for
+ * the key a named animation is controlled by (see the constructor).
  */
 export declare class LynxAnimation implements Pick<Animation, 'id' | 'cancel' | 'pause' | 'play'> {
   #private;
@@ -269,21 +329,49 @@ export declare class LynxAnimation implements Pick<Animation, 'id' | 'cancel' |
   pause(): void;
   cancel(): void;
 }
+/**
+ * Profiling counters collected by the renderer during a session.
+ * Only populated in development builds, where `__PROFILE__` is true — in
+ * production, instrumentation is dead-code-eliminated and all values stay 0.
+ */
+type DevToolsStats = {
+  cdCycles: number;
+  elementCreated: number;
+  elementRemoved: number;
+  flushCount: number;
+  lastCdDurationMs: number;
+};
+/**
+ * Options for `LynxPerformance.profileStart()` and `profileMark()`. The same
+ * shape as Lynx's own `TraceOption`; `performance.ts` passes it to Lynx as
+ * one, so the compiler keeps the two in step.
+ */
+type LynxTraceOptions = {
+  flowId?: number;
+  flowIds?: number[];
+  args?: Record<string, string>;
+};
 /**
  * Wraps Lynx's native performance tracing APIs (`lynx.performance`).
  *
  * All methods are no-ops when `lynx.performance` is unavailable (e.g. in tests
  * or non-Lynx environments) or when profiling is not actively recording.
  *
+ * Unlike the `LynxDevTools` counters, the calls aren't gated by `__PROFILE__`,
+ * so they stay in production builds. A trace is worth recording from the build
+ * you ship, without development mode's extra work in it. They cost little
+ * there: release builds of the Lynx engine compile tracing out, so each call
+ * returns at once.
+ *
  * @usageNotes
  * ```typescript
  * const perf = inject(LynxPerformance);
  *
- * perf.profileStart('MyComponent::render', { itemCount: 42 });
+ * perf.profileStart('MyComponent::render', { args: { itemCount: '42' } });
  * // ... do work ...
  * perf.profileEnd();
  *
- * perf.profileMark('dataLoaded', { source: 'cache' });
+ * perf.profileMark('dataLoaded', { args: { source: 'cache' } });
  * ```
  */
 export declare class LynxPerformance {
@@ -297,10 +385,7 @@ export declare class LynxPerformance {
    * Begin a named trace. Must be paired with `profileEnd()`.
    * Traces nest — multiple `profileStart` calls create a stack.
    */
-  profileStart(name: string, options?: {
-    flowId?: number;
-    args?: Record<string, unknown>;
-  }): void;
+  profileStart(name: string, options?: LynxTraceOptions): void;
   /**
    * End the current trace (top of the trace stack).
    */
@@ -308,9 +393,7 @@ export declare class LynxPerformance {
   /**
    * Emit a discrete mark event in the trace timeline.
    */
-  profileMark(name: string, options?: {
-    args?: Record<string, unknown>;
-  }): void;
+  profileMark(name: string, options?: LynxTraceOptions): void;
   /**
    * Generate a unique flow ID for correlating multi-threaded traces.
    */
@@ -318,24 +401,13 @@ export declare class LynxPerformance {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxPerformance, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-/**
- * Profiling counters collected by the renderer during a session.
- * Only populated when the app is built with `__PROFILE__` enabled —
- * in production, instrumentation is dead-code-eliminated and all values stay 0.
- */
-type DevToolsStats = {
-  cdCycles: number;
-  elementCreated: number;
-  elementRemoved: number;
-  flushCount: number;
-  lastCdDurationMs: number;
-};
 /**
  * High-level DevTools service exposing performance stats as Angular signals.
  *
- * Stats are only meaningful when the app is built with `__PROFILE__` enabled.
- * In production builds, counters are never incremented (the instrumentation
- * code is dead-code-eliminated), so all values remain zero.
+ * Stats are only meaningful in development builds, where the build plugin sets
+ * `__PROFILE__` to true. In production builds, counters are never incremented
+ * (the instrumentation code is dead-code-eliminated), so all values remain
+ * zero.
  *
  * @usageNotes
  * ```typescript
@@ -382,10 +454,24 @@ export declare class LynxDevTools {
 declare const devStats: DevToolsStats & {
   reset(): void;
 };
+/**
+ * Starts timing a change-detection cycle. The renderer factory calls it from
+ * `begin()`, and `endCdTiming()` from `end()`.
+ */
+declare const startCdTiming: () => void;
+/**
+ * Stops timing the innermost change-detection cycle in progress, and records
+ * its duration in `devStats.lastCdDurationMs`.
+ */
+declare const endCdTiming: () => void;
 /**
  * Extend this interface to type the raw data passed from native before processing.
  *
  * @example
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
  * declare module '@blotch/angular-lynx' {
  *   interface InitDataRaw { userId: string; }
  * }
@@ -395,6 +481,10 @@ interface InitDataRaw extends Record<string, unknown> {}
  * Extend this interface to type the processed init data used throughout the app.
  *
  * @example
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
  * declare module '@blotch/angular-lynx' {
  *   interface InitData { userId: string; }
  * }
@@ -404,6 +494,10 @@ interface InitData extends Record<string, unknown> {}
  * Extend this interface to type the global data passed from the native host.
  *
  * @example
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
  * declare module '@blotch/angular-lynx' {
  *   interface GlobalData { theme: 'light' | 'dark'; }
  * }
@@ -423,8 +517,9 @@ type DataProcessorDefinition = {
  * Register data processor functions that the native Lynx runtime calls before
  * delivering init data to the app. Maps to the global `processData` callback.
  *
- * Call this before bootstrapApplication so that native data is transformed
- * before LynxInitData receives the first onDataChanged event.
+ * Call this before bootstrapApplication. The engine runs the default processor
+ * on the InitData before passing it to renderPage, so its result is what
+ * LynxInitData starts with.
  *
  * @example
  * registerDataProcessors({
@@ -487,7 +582,11 @@ type ExposureEventDetail = {
   'exposure-scene': string;
   exposureID: string;
   exposureScene: string;
-  'unique-id': number;
+  /**
+   * Identifies the native element. Lynx documents it as a string, which iOS
+   * and Android send; the web sends the element's numeric unique ID.
+   */
+  'unique-id': string | number;
 };
 /**
  * The Lynx engine batches element visibility changes at ~20fps and dispatches
@@ -499,6 +598,7 @@ type ObserverFrameRateOptions = {
   forExposureCheck?: number;
 };
 export declare class LynxGlobalExposure {
+  #private;
   readonly exposures: import("@angular/core").WritableSignal<GlobalExposureEvent>;
   readonly disexposures: import("@angular/core").WritableSignal<GlobalExposureEvent>;
   readonly active: import("@angular/core").WritableSignal<boolean>;
@@ -512,7 +612,13 @@ export declare class LynxGlobalExposure {
     sendEvent: boolean;
   }): void;
   resumeExposure(): void;
-  setObserverFrameRate(options?: ObserverFrameRateOptions): void;
+  /**
+   * Sets how often Lynx checks for exposure. Only the background thread's
+   * `lynx` has setObserverFrameRate, so a call from an event handler, which
+   * runs on the main thread, goes through the background thread (see
+   * background-call.ts). Resolves once it's applied.
+   */
+  setObserverFrameRate(options?: ObserverFrameRateOptions): Promise<void>;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxGlobalExposure, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
@@ -535,6 +641,9 @@ type LynxFontEntry = {
 };
 /**
  * Wraps `lynx.addFont()` with a Promise-based API and reactive signal state.
+ * Only the background thread's `lynx` has addFont, so a call from an event
+ * handler, which runs on the main thread, goes through the background thread
+ * (see background-call.ts).
  *
  * Use CSS `@font-face` in stylesheets for fonts known at build time (the
  * standard Angular approach). Use this service only for fonts that must be
@@ -569,6 +678,55 @@ export declare class LynxFont {
  * built with `experimental_isLazyBundle: true` in the rsbuild plugin.
  */
 export declare const loadLazyBundle: (source: string) => Promise<Type<unknown>>;
+/**
+ * The parts of webpack's `module.hot` API that {@link ɵhmrAccept} uses.
+ */
+type HotModule = {
+  accept(): void;
+  dispose(callback: (data: Record<string, unknown>) => void): void;
+  invalidate(): void;
+  /** What the module's previous version passed to its dispose handlers. */
+  data?: Record<string, unknown>;
+};
+/**
+ * Takes a hot update of a module that defines components. The build plugin
+ * adds a call to the end of each such module in a development build, which
+ * reassigns the module's component classes to what it returns.
+ *
+ * On the main thread, where the app runs, a new version of the module either
+ * updates the running app in place or passes the update on:
+ *
+ * - **Only a template or stylesheet changed** (the source `signature`, which
+ *   leaves those out, is the same, and the compiled `code` isn't): each
+ *   component's new definition replaces the old one with Angular's
+ *   `ɵɵreplaceMetadata()`, which Angular's own dev server uses for the same
+ *   edits. It re-renders every view of the component in place and keeps the
+ *   component instances, so their state survives. The module's bindings are
+ *   pointed back at the old classes, so every module keeps using the one
+ *   class the app's instances and injectors know.
+ * - **Anything else changed**, such as the class, an import, or a module this
+ *   one imports: the update can't be applied to the running instances, so
+ *   `hot.invalidate()` passes it on to the modules that import this one, up
+ *   to the app's entry, which bootstraps the app again (see
+ *   `bootstrapApplication`).
+ *
+ * The background thread runs no Angular, only the module-level code that
+ * registers background functions. It accepts every version, which re-runs
+ * the module and registers them again.
+ *
+ * @param hot - The module's `import.meta.webpackHot`.
+ * @param components - The component classes this version of the module defines.
+ * @param signature - A hash of the module's source without its components'
+ *   templates and styles.
+ * @param code - A hash of the module's compiled code.
+ * @returns The classes the module should use from now on.
+ */
+export declare const ɵhmrAccept: (hot: HotModule, components: Type<unknown>[], signature: string, code: string) => Type<unknown>[];
+/**
+ * The app's own locale: `sourceLocale` from angular.json, which the build
+ * injects as `__LYNX_SOURCE_LOCALE__`, or `'en-US'` without one.
+ */
+declare const getSourceLocale: () => string;
 /**
  * Reads `lynx.__globalProps.appLocale` directly, without Angular DI.
  *
@@ -622,6 +780,12 @@ export declare class LynxLocale {
  * Angular's locale-aware features (pipes, i18n) with the locale from
  * `lynx.__globalProps.appLocale`.
  *
+ * The apps that `ng build --platform` makes send the phone's language, which
+ * the app may not support. When Angular has no locale data for it (see
+ * `registerLocaleData()`), `LOCALE_ID` is the app's source locale instead, as
+ * a native app shows its own language on a phone set to one it lacks.
+ * Otherwise Angular's date and number pipes would throw.
+ *
  * @usageNotes
  * ```typescript
  * bootstrapApplication(App, {
@@ -755,6 +919,12 @@ export declare abstract class BaseGesture<TEvent extends GestureEvent = GestureE
   _callbacks: Record<string, GestureCallback<any>>;
   /**
    * @internal
+   *
+   * Starts as `{ enabled: true }`, like React Lynx's gesture-runtime, so every
+   * gesture sends a config, even one with no options of its own (Fling, Pinch,
+   * Rotation). Gestures whose native handler reads options seed the rest of
+   * their defaults too: once a config is present, iOS reads each key it leaves
+   * out as `0` (see ./const).
    */
   _config: Record<string, unknown>;
   /**
@@ -769,6 +939,15 @@ export declare abstract class BaseGesture<TEvent extends GestureEvent = GestureE
    * @internal
    */
   _continueWith: BaseGesture[];
+  /**
+   * Fires when the gesture starts tracking a touch, before it's recognized:
+   * at touch-down for most gestures, and when the finger lifts for a fling.
+   *
+   * A continuous gesture doesn't need one for its `onStart` and `onEnd` to
+   * fire. LynxGestureDetector registers an empty `onBegin` when you don't, since
+   * Lynx's native handlers skip those callbacks without it. See
+   * gesture-detector.ts.
+   */
   onBegin(cb: GestureCallbackWithState<TEvent>): TSelf;
   /**
    * Fires when the gesture is RECOGNIZED (transitions to active). For a tap this
@@ -805,6 +984,12 @@ export declare abstract class BaseGesture<TEvent extends GestureEvent = GestureE
    * Useful for chaining: e.g. a long-press followed by a drag.
    */
   continueWith(...gestures: BaseGesture[]): TSelf;
+  /**
+   * ⚠️ Not read by Lynx's native gesture handlers yet (as of Lynx 4.1, no
+   * handler looks up `enabled`), so a disabled gesture still fires on a
+   * device. Unbind the gesture from `[lynxGesture]` to turn it off. Kept for
+   * API parity with Lynx's gesture-runtime.
+   */
   enabled(value: boolean): TSelf;
 }
 /**
@@ -825,16 +1010,31 @@ export declare const Gesture: {
   Exclusive(...gestures: AnyGesture$1[]): ComposedGesture;
   Race(...gestures: AnyGesture$1[]): ComposedGesture;
 };
+/**
+ * Lynx's fling follows the momentum of a drag after the finger lifts: `onBegin`
+ * fires on release, `onUpdate` on every frame (with `deltaX`/`deltaY` in the
+ * params), and `onEnd` when it stops. Lynx starts that fling in its BEGAN
+ * state and never activates it, so `onStart` doesn't fire
+ * (LynxFlingGestureHandler.m / FlingGestureHandler.java). Lynx also flings only
+ * the element that won the touch, and a fling ignores the touch until the
+ * finger lifts, so it needs a pan on the same element (`Gesture.Simultaneous`).
+ */
 export declare class FlingGesture extends ContinuousGesture<FlingGestureEvent, FlingGesture> {
   readonly type = GestureType.FLING;
   /**
    * FlingDirection is a bitmask — combine values with | for multi-direction:
    * e.g. FlingDirection.LEFT | FlingDirection.RIGHT recognizes horizontal flings.
+   *
+   * ⚠️ Not read by Lynx's native fling handlers yet: as of Lynx 4.1, iOS's
+   * `handleConfigMap` is a TODO and Android's is empty, so every fling fires,
+   * in any direction. Kept for API parity with Lynx's gesture-runtime.
    */
   direction(dir: FlingDirection): this;
   /**
    * The gesture only recognizes when exactly `count` fingers are involved.
    * Defaults to 1 if not set.
+   *
+   * ⚠️ Not read by Lynx's native fling handlers yet (see `direction`).
    */
   numberOfPointers(count: number): this;
 }
@@ -856,6 +1056,7 @@ type GestureInput = AnyGesture | AnyGesture[] | ComposedGesture;
 export declare class LynxGestureDetector implements OnChanges, OnDestroy {
   #private;
   lynxGesture: GestureInput;
+  constructor();
   /**
    * Full teardown + re-register on every input change. This is safe because
    * gesture IDs are stable (assigned once in BaseGesture constructor), so
@@ -906,6 +1107,11 @@ export declare class PanGesture extends ContinuousGesture<PanGestureEvent, PanGe
    * threshold. A number means "any direction" (symmetrical); a tuple [min, max]
    * means the offset must be within that range. Example: activeOffsetX(20)
    * activates after 20px of horizontal movement.
+   *
+   * ⚠️ Not read by Lynx's native pan handlers yet: as of Lynx 4.1 they read
+   * only `minDistance` (LynxPanGestureHandler.m / PanGestureHandler.java
+   * `handleConfigMap`). The same goes for activeOffsetY, failOffsetX/Y and
+   * min/maxPointers. Kept for API parity with Lynx's gesture-runtime.
    */
   activeOffsetX(offset: number | [number, number]): this;
   activeOffsetY(offset: number | [number, number]): this;
@@ -914,6 +1120,9 @@ export declare class PanGesture extends ContinuousGesture<PanGestureEvent, PanGe
    * direction, the gesture fails (ceding to a competing gesture). Example:
    * failOffsetY(10) on a horizontal pan: if the user moves >10px vertically
    * before activating, the gesture fails and a vertical scroll can take over.
+   *
+   * ⚠️ Not read by Lynx's native pan handlers yet (see `activeOffsetX`). Call
+   * the state manager's `fail()` from `onUpdate` instead.
    */
   failOffsetX(offset: number | [number, number]): this;
   failOffsetY(offset: number | [number, number]): this;
@@ -958,6 +1167,16 @@ export declare class TapGesture extends BaseGesture<TapGestureEvent, TapGesture>
    */
   maxDistance(px: number): this;
 }
+/**
+ * A length Lynx's exposure detection parses, such as `'20px'` or `'-10rpx'`.
+ * Lynx reads the margins as strings, so a bare number has no effect.
+ */
+type ExposureMargin = `${number}px` | `${number}rpx`;
+/**
+ * One trait of `accessibility-traits`, each of which iOS turns into a
+ * UIAccessibilityTraits flag (`LynxConverter+UI.m`).
+ */
+type AccessibilityTrait = 'text' | 'image' | 'button' | 'link' | 'header' | 'search' | 'selected' | 'playable' | 'keyboard' | 'summary' | 'disabled' | 'updating' | 'adjustable' | 'tabbar' | 'none';
 /**
  * @Directive() is required so that ng-packagr's Angular partial compiler
  * recognizes this base class as an Angular artifact. The selector is left
@@ -1002,9 +1221,17 @@ declare class LynxElementBase implements OnChanges {
    * Text read aloud by screen readers.
    */
   'accessibility-label'?: string;
-  'accessibility-trait'?: 'none' | 'button' | 'image' | 'text';
   /**
-   * Comma-separated list of child element names that are accessibility nodes.
+   * The kind of element a screen reader announces. Plural, as Lynx reads it:
+   * iOS, Android and Harmony ignore `accessibility-trait`. iOS also reads a
+   * comma-separated list with no spaces, such as `button,selected`, which
+   * is what LynxRouterLinkActive writes; Android and Harmony read a single
+   * trait. @default 'none'
+   */
+  'accessibility-traits'?: AccessibilityTrait | `${AccessibilityTrait},${string}`;
+  /**
+   * Comma-separated `id`s of the child elements a screen reader visits, in
+   * order. iOS and Android look each one up as an `id` selector.
    */
   'accessibility-elements'?: string;
   'accessibility-elements-hidden'?: boolean;
@@ -1044,6 +1271,32 @@ declare class LynxElementBase implements OnChanges {
    * Allow simultaneous touch recognition (iOS).
    */
   'ios-enable-simultaneous-touch'?: boolean;
+  /**
+   * Lets Lynx draw the element into its parent's native view instead of
+   * creating its own (Android). `false` gives it its own view, which sticky
+   * positioning, text selection and reliable clipping need. @default true
+   */
+  flatten?: boolean;
+  /**
+   * Direction in which the element takes pan gestures from native views
+   * outside Lynx: 0 = horizontal, 1 = vertical.
+   */
+  'pan-intercept-direction'?: 0 | 1;
+  /**
+   * Which views `pan-intercept-direction` takes pans from: 0 = self,
+   * 1 = ancestors, 2 = descendants, 3 = self and ancestors, 4 = self and
+   * descendants, 5 = all.
+   */
+  'pan-intercept-scope'?: 0 | 1 | 2 | 3 | 4 | 5;
+  /**
+   * Swipe angle ranges, `[start, end]` in degrees, that the element keeps
+   * from platform gestures.
+   */
+  'consume-slide-event'?: [number, number][];
+  /**
+   * Whether `:active` also applies to the ancestors on the touch's event path.
+   */
+  'enable-touch-pseudo-propagation'?: boolean;
   /**
    * Unique ID used for impression/exposure analytics.
    */
@@ -1053,41 +1306,52 @@ declare class LynxElementBase implements OnChanges {
    */
   'exposure-scene'?: string;
   /**
-   * Percentage of the element that must be visible (0–100) to trigger exposure.
+   * How much of the element must be visible to count as exposed, as a
+   * percentage string such as `'50%'`. @default '0%'
    */
-  'exposure-area'?: number;
+  'exposure-area'?: `${number}%`;
   /**
-   * Extends/shrinks the viewport detection zone (top edge, in px).
+   * Extends/shrinks the viewport detection zone (top edge).
    */
-  'exposure-screen-margin-top'?: number | string;
+  'exposure-screen-margin-top'?: ExposureMargin;
   /**
-   * Extends/shrinks the viewport detection zone (bottom edge, in px).
+   * Extends/shrinks the viewport detection zone (bottom edge).
    */
-  'exposure-screen-margin-bottom'?: number | string;
+  'exposure-screen-margin-bottom'?: ExposureMargin;
   /**
-   * Extends/shrinks the viewport detection zone (left edge, in px).
+   * Extends/shrinks the viewport detection zone (left edge).
    */
-  'exposure-screen-margin-left'?: number | string;
+  'exposure-screen-margin-left'?: ExposureMargin;
   /**
-   * Extends/shrinks the viewport detection zone (right edge, in px).
+   * Extends/shrinks the viewport detection zone (right edge).
    */
-  'exposure-screen-margin-right'?: number | string;
+  'exposure-screen-margin-right'?: ExposureMargin;
   /**
-   * Adjusts the element's own bounding rect for exposure detection (top, in px).
+   * Adjusts the element's own bounding rect for exposure detection (top).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
    */
-  'exposure-ui-margin-top'?: number | string;
+  'exposure-ui-margin-top'?: ExposureMargin;
   /**
-   * Adjusts the element's own bounding rect for exposure detection (bottom, in px).
+   * Adjusts the element's own bounding rect for exposure detection (bottom).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
    */
-  'exposure-ui-margin-bottom'?: number | string;
+  'exposure-ui-margin-bottom'?: ExposureMargin;
   /**
-   * Adjusts the element's own bounding rect for exposure detection (left, in px).
+   * Adjusts the element's own bounding rect for exposure detection (left).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
    */
-  'exposure-ui-margin-left'?: number | string;
+  'exposure-ui-margin-left'?: ExposureMargin;
   /**
-   * Adjusts the element's own bounding rect for exposure detection (right, in px).
+   * Adjusts the element's own bounding rect for exposure detection (right).
+   * iOS and Android apply it only with `enable-exposure-ui-margin`.
    */
-  'exposure-ui-margin-right'?: number | string;
+  'exposure-ui-margin-right'?: ExposureMargin;
+  /**
+   * Turns on `exposure-ui-margin-*` on iOS and Android (always on for Harmony
+   * and the web). It also changes how they apply `exposure-screen-margin-*`.
+   * @default false
+   */
+  'enable-exposure-ui-margin'?: boolean;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxElementBase, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<LynxElementBase, never, never, {
     "id": {
@@ -1106,8 +1370,16 @@ declare class LynxElementBase implements OnChanges {
       "alias": "accessibility-label";
       "required": false;
     };
-    "accessibility-trait": {
-      "alias": "accessibility-trait";
+    "accessibility-value": {
+      "alias": "accessibility-value";
+      "required": false;
+    };
+    "accessibility-actions": {
+      "alias": "accessibility-actions";
+      "required": false;
+    };
+    "accessibility-traits": {
+      "alias": "accessibility-traits";
       "required": false;
     };
     "accessibility-elements": {
@@ -1154,6 +1426,26 @@ declare class LynxElementBase implements OnChanges {
       "alias": "ios-enable-simultaneous-touch";
       "required": false;
     };
+    "flatten": {
+      "alias": "flatten";
+      "required": false;
+    };
+    "pan-intercept-direction": {
+      "alias": "pan-intercept-direction";
+      "required": false;
+    };
+    "pan-intercept-scope": {
+      "alias": "pan-intercept-scope";
+      "required": false;
+    };
+    "consume-slide-event": {
+      "alias": "consume-slide-event";
+      "required": false;
+    };
+    "enable-touch-pseudo-propagation": {
+      "alias": "enable-touch-pseudo-propagation";
+      "required": false;
+    };
     "exposure-id": {
       "alias": "exposure-id";
       "required": false;
@@ -1198,12 +1490,36 @@ declare class LynxElementBase implements OnChanges {
       "alias": "exposure-ui-margin-right";
       "required": false;
     };
+    "enable-exposure-ui-margin": {
+      "alias": "enable-exposure-ui-margin";
+      "required": false;
+    };
   }, {}, never, never, true, never>;
+  static "ngAcceptInputType_accessibility-element": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_accessibility-elements-hidden": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_accessibility-exclusive-focus": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_user-interaction-enabled": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_native-interaction-enabled": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_event-through": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_block-native-event": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_ignore-focus": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_ios-enable-simultaneous-touch": boolean | "" | "true" | "false" | undefined;
+  static ngAcceptInputType_flatten: boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_pan-intercept-direction": 0 | 1 | "0" | "1" | undefined;
+  static "ngAcceptInputType_pan-intercept-scope": 0 | 1 | 2 | 3 | 4 | 5 | "0" | "1" | "2" | "3" | "4" | "5" | undefined;
+  static "ngAcceptInputType_enable-touch-pseudo-propagation": boolean | "" | "true" | "false" | undefined;
+  static "ngAcceptInputType_enable-exposure-ui-margin": boolean | "" | "true" | "false" | undefined;
 }
 /**
  * Backdrop blur: blurs the content rendered behind the element, like CSS
  * `backdrop-filter: blur()`. On iOS, `blur-effect="glass"` renders the
  * Liquid Glass material.
+ *
+ * Android only has the plain blur, a Gaussian blur of `blur-radius`. There
+ * the runtime approximates `blur-effect`, `glass-style` and
+ * `glass-tint-color` with a translucent background and rim over the blur,
+ * which a background, background image or shadow the app sets replaces.
+ * Nothing refracts, and `glass-interactive` and `spacing` do nothing.
  */
 export declare class LynxBlurView extends LynxElementBase {
   /**
@@ -1219,7 +1535,10 @@ export declare class LynxBlurView extends LynxElementBase {
    */
   'enable-auto-blur'?: boolean;
   /**
-   * Raw id of the view to capture and blur; it must have `flatten="false"` (Android).
+   * Raw id of the view to capture and blur; it must have `flatten="false"`
+   * (Android). The runtime points it at the page, so a blur-view inside
+   * another blur-view still blurs what's behind it; an empty string restores
+   * Android's own choice, the nearest ancestor that clips or contains it.
    */
   'android-capture-target'?: string;
   /**
@@ -1228,7 +1547,8 @@ export declare class LynxBlurView extends LynxElementBase {
   'experimental-update-blur-radius'?: boolean;
   /**
    * Blur material (iOS). `glass` renders Liquid Glass; `glass-container`
-   * merges nested glass `<blur-view>`s into one combined effect. @default 'light'
+   * merges nested glass `<blur-view>`s into one combined effect. Android
+   * gets a tint that approximates it. @default 'light'
    */
   'blur-effect'?: 'light' | 'extra-light' | 'dark' | 'glass' | 'glass-container';
   /**
@@ -1240,11 +1560,11 @@ export declare class LynxBlurView extends LynxElementBase {
    */
   'glass-interactive'?: boolean;
   /**
-   * Tint color applied to the glass (iOS). @default 'transparent'
+   * Tint color applied to the glass (iOS; approximated on Android). @default 'transparent'
    */
   'glass-tint-color'?: string;
   /**
-   * Glass variant (iOS). @default 'regular'
+   * Glass variant (iOS; approximated on Android). @default 'regular'
    */
   'glass-style'?: 'regular' | 'clear';
   /**
@@ -1758,6 +2078,10 @@ export declare class LynxTextarea extends LynxElementBase {
 }
 /**
  * High-performance virtualized list, equivalent to RecyclerView / UITableView.
+ *
+ * Gaps between items aren't attributes: `list-main-axis-gap` and
+ * `list-cross-axis-gap` are CSS properties, which Lynx's list reads from its
+ * computed style, so set them in `style` (`[style.list-main-axis-gap]`).
  */
 export declare class LynxList extends LynxElementBase {
   /**
@@ -1823,14 +2147,6 @@ export declare class LynxList extends LynxElementBase {
    * Insert/remove animation style.
    */
   'update-animation'?: 'default' | 'none';
-  /**
-   * Gap between items on the main axis (CSS length).
-   */
-  'list-main-axis-gap'?: string;
-  /**
-   * Gap between columns/rows on the cross axis (CSS length).
-   */
-  'list-cross-axis-gap'?: string;
   /**
    * Required by Lynx's native list UI whenever the app uses the standard
    * dual-thread engine strategy (always true for AngularLynx) — without it
@@ -1929,14 +2245,6 @@ export declare class LynxList extends LynxElementBase {
       "alias": "update-animation";
       "required": false;
     };
-    "list-main-axis-gap": {
-      "alias": "list-main-axis-gap";
-      "required": false;
-    };
-    "list-cross-axis-gap": {
-      "alias": "list-cross-axis-gap";
-      "required": false;
-    };
     "enable-async-list": {
       "alias": "enable-async-list";
       "required": false;
@@ -1988,13 +2296,6 @@ export declare class LynxListItem extends LynxElementBase {
    * Estimated item size in px for layout pre-calculation.
    */
   'estimated-main-axis-size-px'?: number;
-  /**
-   * Deferred rendering. Pass `true` to defer, or an object to control
-   * whether the item unmounts when recycled.
-   */
-  defer?: boolean | {
-    unmountRecycled?: boolean;
-  };
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxListItem, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<LynxListItem, "list-item", never, {
     "item-key": {
@@ -2025,10 +2326,6 @@ export declare class LynxListItem extends LynxElementBase {
       "alias": "estimated-main-axis-size-px";
       "required": false;
     };
-    "defer": {
-      "alias": "defer";
-      "required": false;
-    };
   }, {}, never, never, true, never>;
 }
 /**
@@ -2063,8 +2360,9 @@ export declare class LynxOverlay extends LynxElementBase {
    */
   visible?: boolean;
   /**
-   * Z-order layer (higher = above other overlays).
-   * 1 = default, 2 = status bar level, 3 = keyboard level, 4 = top.
+   * The layer the overlay sits in when several are open: 1 is the top layer
+   * and 4 the lowest. Within a layer the last one shown is on top. Lynx reads
+   * it only while the overlay is hidden. @default 1
    */
   level?: 1 | 2 | 3 | 4;
   /**
@@ -2386,7 +2684,10 @@ export declare class LynxSvg extends LynxElementBase {
  */
 export declare class LynxText extends LynxElementBase {
   /**
-   * Maximum number of lines before truncation with ellipsis.
+   * Maximum number of lines the text is laid out in. The text box ends after
+   * that many lines, but the ellipsis needs `text-overflow: ellipsis`
+   * (Tailwind's `text-ellipsis`). Without it, iOS cuts the text off at the
+   * last line, and Android draws the remaining lines past the box.
    */
   'text-maxline'?: number;
   /**
@@ -2558,45 +2859,13 @@ export declare class LynxVideo extends LynxElementBase {
   }, {}, never, never, true, never>;
 }
 /**
- * General-purpose container element, equivalent to HTML `<div>`.
+ * General-purpose container element, equivalent to HTML `<div>`. Its
+ * attributes (`flatten`, the pan-intercept ones, …) work on every element, so
+ * they live on {@link LynxElementBase}.
  */
 export declare class LynxView extends LynxElementBase {
-  /**
-   * Flatten the view into its parent's layer (Android only).
-   * Improves performance for non-interactive views.
-   */
-  flatten?: boolean;
-  /**
-   * Direction of pan-gesture interception.
-   * 0 = horizontal, 1 = vertical, 2 = none.
-   */
-  'pan-intercept-direction'?: 0 | 1 | 2;
-  'pan-intercept-scope'?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
-  'consume-slide-event'?: [number, number][];
-  'enable-touch-pseudo-propagation'?: boolean;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxView, never>;
-  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxView, "view", never, {
-    "flatten": {
-      "alias": "flatten";
-      "required": false;
-    };
-    "pan-intercept-direction": {
-      "alias": "pan-intercept-direction";
-      "required": false;
-    };
-    "pan-intercept-scope": {
-      "alias": "pan-intercept-scope";
-      "required": false;
-    };
-    "consume-slide-event": {
-      "alias": "consume-slide-event";
-      "required": false;
-    };
-    "enable-touch-pseudo-propagation": {
-      "alias": "enable-touch-pseudo-propagation";
-      "required": false;
-    };
-  }, {}, never, never, true, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxView, "view", never, {}, {}, never, never, true, never>;
 }
 /**
  * Horizontally swipeable paging container.
@@ -2790,14 +3059,61 @@ export declare class LynxWebView extends LynxElementBase {
     };
   }, {}, never, never, true, never>;
 }
+/**
+ * Finds the `isActiveChange` output of Angular's `RouterLinkActive` on the
+ * element being created, or null if it has none. Called in the injection
+ * context of that element's LynxRouterLinkActive.
+ *
+ * `provideRouter()` provides it, rather than LynxRouterLinkActive importing
+ * `RouterLinkActive` itself, because LynxRouterLinkActive is part of
+ * LYNX_ELEMENTS, which every component imports: referring to the router from
+ * there would put the whole router in the bundle of an app without routes.
+ * Without `provideRouter()` there's no router to follow, and the token is
+ * missing.
+ */
+declare const ROUTER_LINK_ACTIVE_CHANGE: InjectionToken<() => OutputRef<boolean> | null>;
+/**
+ * Tells screen readers which router link is the current one: while Angular's
+ * `RouterLinkActive` on the same element says its route is active, the
+ * element has the `selected` accessibility trait, as the selected tab of a
+ * native tab bar does. On the web, `routerLinkActive` only changes classes, or
+ * `aria-current` with `ariaCurrentWhenActive`; Lynx elements have no ARIA,
+ * and `accessibility-traits` is how they say this.
+ *
+ * It keeps the element's own traits: `accessibility-traits="button"` becomes
+ * `button,selected` while the link is active. On Android, which reads one
+ * trait and has no selected trait, the element keeps its own traits as they
+ * are.
+ *
+ * It's part of LYNX_ELEMENTS, so a component that imports LYNX_ELEMENTS and
+ * Angular's `RouterLinkActive` gets it on every `routerLinkActive` element.
+ * To add it to a component's host instead, list it in `hostDirectives` next
+ * to `RouterLinkActive`.
+ *
+ * @usageNotes
+ * ```ts
+ * @Component({
+ *   imports: [LYNX_ELEMENTS, RouterLink, RouterLinkActive],
+ *   template: `
+ *     <view routerLink="/settings" routerLinkActive="active">
+ *       <text>Settings</text>
+ *     </view>
+ *   `,
+ * })
+ * ```
+ */
+export declare class LynxRouterLinkActive {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxRouterLinkActive, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxRouterLinkActive, "[routerLinkActive]", never, {}, {}, never, never, true, never>;
+}
 /**
  * All Lynx native element directives as a single importable array.
  * Add to the `imports` of any component whose template uses Lynx elements.
  */
-export declare const LYNX_ELEMENTS: readonly [typeof LynxView, typeof LynxText, typeof LynxInlineTruncation, typeof LynxImage, typeof LynxScrollView, typeof LynxList, typeof LynxListItem, typeof LynxBlock, typeof LynxIf, typeof LynxFor, typeof LynxFrame, typeof LynxInput, typeof LynxTextarea, typeof import("@blotch/angular-lynx").LynxInputValueAccessor, typeof import("@blotch/angular-lynx").LynxTextareaValueAccessor, typeof LynxOverlay, typeof LynxRefresh, typeof LynxRefreshHeader, typeof LynxScrollCoordinator, typeof LynxScrollCoordinatorHeader, typeof LynxScrollCoordinatorSlot, typeof LynxScrollCoordinatorSlotDrag, typeof LynxScrollCoordinatorToolbar, typeof LynxSvg, typeof LynxViewPager, typeof LynxViewPagerItem, typeof LynxBlurView, typeof LynxVideo, typeof LynxWebView, typeof LynxCoverView, typeof LynxTitleBarView];
+export declare const LYNX_ELEMENTS: readonly [typeof LynxView, typeof LynxText, typeof LynxInlineTruncation, typeof LynxImage, typeof LynxScrollView, typeof LynxList, typeof LynxListItem, typeof LynxBlock, typeof LynxIf, typeof LynxFor, typeof LynxFrame, typeof LynxInput, typeof LynxTextarea, typeof LynxInputValueAccessor, typeof LynxTextareaValueAccessor, typeof LynxOverlay, typeof LynxRefresh, typeof LynxRefreshHeader, typeof LynxScrollCoordinator, typeof LynxScrollCoordinatorHeader, typeof LynxScrollCoordinatorSlot, typeof LynxScrollCoordinatorSlotDrag, typeof LynxScrollCoordinatorToolbar, typeof LynxSvg, typeof LynxViewPager, typeof LynxViewPagerItem, typeof LynxBlurView, typeof LynxVideo, typeof LynxWebView, typeof LynxCoverView, typeof LynxTitleBarView, typeof LynxRouterLinkActive];
 export declare class LynxLogger {
   #private;
-  constructor();
   log(...args: unknown[]): void;
   warn(...args: unknown[]): void;
   error(...args: unknown[]): void;
@@ -2810,9 +3126,15 @@ export declare class LynxLogger {
  * Extensible map of custom native modules declared by the host app.
  *
  * App developers augment this interface to get type-safe access
- * via {@link LynxNativeModule.getNativeModule}:
+ * via {@link LynxNativeModule.getNativeModule}. Describe each module's
+ * methods as the host implements them; `getNativeModule()` turns their
+ * return values into promises (see {@link NativeModuleProxy}):
  *
  * ```typescript
+ * // This export makes the file a module, so the block below adds to
+ * // @blotch/angular-lynx's types instead of replacing them.
+ * export {};
+ *
  * declare module '@blotch/angular-lynx' {
  *   interface NativeModuleMap {
  *     NativeLocalStorageModule: {
@@ -2824,7 +3146,17 @@ export declare class LynxLogger {
  * }
  * ```
  */
-type NativeModuleMap = {};
+interface NativeModuleMap {}
+/**
+ * A native module as {@link LynxNativeModule.getNativeModule} returns it on
+ * the main thread, where Angular runs.
+ *
+ * Native modules exist only on the background thread, so each method call is
+ * relayed there: the method returns a promise of its result (copied as JSON),
+ * and function arguments are called back on the main thread. Only methods
+ * cross; other properties of the module aren't reachable.
+ */
+type NativeModuleProxy<T> = { [K in keyof T as T[K] extends ((...args: any[]) => unknown) ? K : never]: T[K] extends ((...args: infer A) => infer R) ? (...args: A) => Promise<Awaited<R>> : never; };
 /**
  * Wraps the Lynx native module bridge and JS module registry as an Angular injectable.
  *
@@ -2836,6 +3168,12 @@ type NativeModuleMap = {};
  * values within a single LynxView. This is the same API used internally by
  * `LynxInitData` and `LynxGlobalData` (via `GlobalEventEmitter`).
  *
+ * Lynx provides both only on the background thread, while Angular runs on the
+ * main thread. So on the main thread every method goes through the background
+ * call relay (background-call.ts): calls run on the background thread, their
+ * results and callbacks come back as JSON, and a module is a proxy whose
+ * methods return promises.
+ *
  * @usageNotes
  * ```typescript
  * const modules = inject(LynxNativeModule);
@@ -2863,13 +3201,14 @@ export declare class LynxNativeModule {
    * The native callback API is wrapped in a Promise for ergonomic
    * use with `async`/`await`.
    *
-   * Returns `undefined` when `NativeModules` is unavailable (web preview, tests).
+   * Resolves `undefined` when there is no bridge (web preview, tests).
    */
   call<T = unknown>(name: string, params?: Record<string, unknown>): Promise<T | undefined>;
   /**
-   * Subscribes to a native event via `NativeModules.bridge.on()`.
+   * Subscribes to a native event via `NativeModules.bridge.on()`. From the
+   * main thread, the callback gets the event's arguments copied as JSON.
    *
-   * No-op when `NativeModules` is unavailable.
+   * No-op when there is no bridge.
    */
   on(name: string, callback: (...args: unknown[]) => void): void;
   /**
@@ -2878,6 +3217,8 @@ export declare class LynxNativeModule {
    * Augment the {@link NativeModuleMap} interface for type-safe access:
    *
    * ```typescript
+   * export {};
+   *
    * declare module '@blotch/angular-lynx' {
    *   interface NativeModuleMap {
    *     NativeLocalStorageModule: { ... };
@@ -2887,25 +3228,35 @@ export declare class LynxNativeModule {
    * const storage = modules.getNativeModule('NativeLocalStorageModule');
    * ```
    *
-   * Returns `undefined` when `NativeModules` is unavailable or the module
-   * is not registered.
+   * On the main thread, which can't reach native modules, it returns a proxy:
+   * each method call runs on the background thread and returns a promise of
+   * its result, and a call to a module or method the host doesn't have
+   * rejects. The return type says so: a module in {@link NativeModuleMap}
+   * comes back as a {@link NativeModuleProxy} of it, and any other name as
+   * `unknown`.
+   *
+   * Returns `undefined` outside Lynx, or on the background thread when the
+   * module is not registered.
    */
-  getNativeModule<K extends string>(name: K): K extends keyof NativeModuleMap ? NativeModuleMap[K] : unknown;
+  getNativeModule<K extends string>(name: K): K extends keyof NativeModuleMap ? NativeModuleProxy<NativeModuleMap[K]> | undefined : unknown;
   /**
    * Retrieves a JS module registered within this LynxView.
    *
    * This wraps `lynx.getJSModule()` — the same API used internally
-   * for `GlobalEventEmitter`.
+   * for `GlobalEventEmitter`. On the main thread it returns a proxy, as
+   * getNativeModule() does.
    *
-   * Returns `undefined` when `lynx` is unavailable or the module
-   * is not registered.
+   * Returns `undefined` when `lynx` is unavailable or, on the background
+   * thread, when the module is not registered.
    */
   getJSModule<T = unknown>(name: string): T | undefined;
   /**
    * Registers a JS module for sharing within this LynxView.
    *
    * Other code (including native callbacks) can retrieve it via
-   * `getJSModule()` or `lynx.getJSModule()`.
+   * `getJSModule()` or `lynx.getJSModule()`. From the main thread, the
+   * background thread registers a copy whose methods call this module's, with
+   * their arguments copied as JSON and their return values dropped.
    *
    * No-op when `lynx` is unavailable.
    */
@@ -2913,40 +3264,18 @@ export declare class LynxNativeModule {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxNativeModule, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-/**
- * A no-op animation returned when `animate()` is called on the background
- * thread where `__ElementAnimate` is unavailable. Provides the same API
- * surface as `LynxAnimation` so callers can call `.cancel()`, `.pause()`,
- * `.play()` without crashing — the calls simply do nothing.
- *
- * Fixes: "Uncaught Error: animate() is only available on the main thread"
- * in the Go web preview (and any background-thread context).
- *
- * Why needed: In the Lynx dual-thread model, Angular runs on the background
- * thread where __ElementAnimate doesn't exist. Previously, calling
- * element.animate() from a component (e.g. the animations example's "Tap to
- * pulse" button) would throw, crashing the Go web preview on the docs site.
- *
- * Approach: Return a silent no-op instead of throwing. This matches how
- * @lynx-js/web-core itself handles __ElementAnimate on the server — it's
- * defined as `() => {}` (a no-op). We mirror that graceful degradation here.
- * Alternatives considered:
- *   - Cross-thread bridge via lynx.getCoreContext().dispatchEvent() — correct
- *     long-term but complex; LynxBackgroundElement doesn't hold a native ref.
- *   - Removing animate() from the example — wrong because it's the primary
- *     demonstration of the JS animate API.
- */
-declare class NoopLynxAnimation implements Pick<Animation, 'id' | 'cancel' | 'pause' | 'play'> {
-  #private;
-  readonly id: string;
-  constructor();
-  play(): void;
-  pause(): void;
-  cancel(): void;
-}
 type LynxEventType = 'bindEvent' | 'catchEvent' | 'capture-bindEvent' | 'capture-catchEvent' | 'global-bindEvent';
 declare const EVENT_PREFIXES: [string, LynxEventType][];
-type BaseLynxElement = Pick<Element, 'setAttribute'> & {
+/**
+ * DOM event names whose Lynx event has another name. A listener for one of
+ * them hears the Lynx event, bubbling, as if it were bound with `bind`: a
+ * `(click)` listener runs on a tap. This is the mapping Lynx for Web makes
+ * between the two (web-core's `W3cEventNameToLynx` turns a DOM `click` into
+ * `tap`), and it's what lets Angular's own directives that listen for
+ * `click`, such as `RouterLink`, work on Lynx elements.
+ */
+declare const DOM_EVENT_ALIASES: ReadonlyMap<string, string>;
+type BaseLynxElement = Pick<Element$1, 'setAttribute'> & {
   tagName: string;
   setProperty(name: string, value: any): void;
   getAttribute(name: string): string | null;
@@ -2957,7 +3286,18 @@ type BaseLynxElement = Pick<Element, 'setAttribute'> & {
   insertBefore(newChild: BaseLynxElement, refChild: BaseLynxElement | null): void;
   appendChild(newChild: BaseLynxElement): void;
   addClass(name: string): void;
+  /**
+   * Adds a class that stays when the whole class list is replaced, for
+   * ViewEncapsulation.Emulated's scope classes (see EmulatedLynxRenderer).
+   */
+  addScopeClass(name: string): void;
   removeClass(name: string): void;
+  /**
+   * Adds a trait to the element's own `accessibility-traits`, or takes it
+   * away, keeping the traits the app sets. For state the runtime tracks, such
+   * as `selected` on an active router link (see LynxRouterLinkActive).
+   */
+  setAccessibilityTrait(trait: string, on: boolean): void;
   remove(): void;
   parentNode(): BaseLynxElement | null;
   nextSibling(): BaseLynxElement | null;
@@ -2967,58 +3307,10 @@ type BaseLynxElement = Pick<Element, 'setAttribute'> & {
   animate(keyframes: Record<string, string | number>[], options?: number | LynxAnimationOptions): BaseLynxAnimation;
   /**
    * Invokes a native UI method on this element (e.g. setValue, scrollTo).
-   *
-   * Marked optional because it only exists on the main thread: LynxElement
-   * implements it via __InvokeUIMethod, while LynxBackgroundElement (used in
-   * tests and the background-thread context) does not — UIMethod calls have no
-   * meaning outside the native render thread. Callers should use invoke?.() so
-   * they become no-ops in test/background environments rather than crashing.
+   * LynxElement implements it via __InvokeUIMethod.
    */
-  invoke?(methodName: string, params?: Record<string, unknown>): void;
+  invoke(methodName: string, params?: Record<string, unknown>): void;
 };
-/**
- * Virtual element for the background thread where no native PAPI functions exist.
- * Maintains an in-memory linked-list tree (parent/child/sibling pointers) that
- * mirrors what LynxDocument builds on the main thread. Used by:
- * - Angular's change detection (reads parentNode/nextSibling for view insertion)
- * - querySelector/querySelectorAll (for testing and background-thread lookups)
- * - LynxBackgroundDocument (creates these instead of native elements)
- *
- * Props, styles, classes, and events are stored in Maps/Sets but never sent to
- * native — they exist so component code can read back what it set without
- * crashing, and so the testing library can inspect element state.
- */
-declare class LynxBackgroundElement implements BaseLynxElement {
-  #private;
-  isRootPageElement: boolean;
-  tagName: string;
-  setProperty(name: string, value: any): void;
-  setAttribute(name: string, value: any): void;
-  getAttribute(name: string): string | null;
-  removeAttribute(name: string): void;
-  setStyle(key: string, value: unknown): void;
-  removeStyle(key: string): void;
-  setInlineStyles(inlineStyle: string): void;
-  insertBefore(newChild: LynxBackgroundElement, refChild: LynxBackgroundElement | null): void;
-  appendChild(newChild: LynxBackgroundElement): void;
-  addClass(name: string): void;
-  removeClass(name: string): void;
-  remove(): void;
-  parentNode(): BaseLynxElement | null;
-  nextSibling(): BaseLynxElement | null;
-  querySelector(selector: string): BaseLynxElement | null;
-  querySelectorAll(selector: string): BaseLynxElement[];
-  /**
-   * Previously threw: `throw new Error('animate() is only available on the
-   * main thread')`. This crashed the Go web preview on the docs site because
-   * the animations example's (bindtap) handler calls el.nativeElement.animate()
-   * which lands here on the background thread. Returning a no-op is safe —
-   * the animation won't visually play, but the caller's code (including
-   * .cancel() / .pause() / .play() chains) continues without error.
-   */
-  animate(_keyframes: Record<string, string | number>[], _options?: number | LynxAnimationOptions): NoopLynxAnimation;
-  addEventListener(name: string, cb: (event: any) => any): () => void;
-}
 declare class LynxElement implements BaseLynxElement {
   #private;
   get element(): ElementRef;
@@ -3056,6 +3348,18 @@ declare class LynxElement implements BaseLynxElement {
    */
   setInitialText(text: string): void;
   setAttribute(name: string, value: any): void;
+  /**
+   * On Android, gives a blur-view the CSS variables that approximate its iOS
+   * material (see android-blur-material). LynxDocument calls it when it
+   * creates one, and setAttribute whenever an attribute it depends on changes.
+   */
+  updateBlurMaterial(): void;
+  /**
+   * Adds `trait` to the app's own `accessibility-traits`, or takes it away.
+   * The app can still set its traits at any time: setAttribute merges the two
+   * (see withAddedTraits), so neither undoes the other.
+   */
+  setAccessibilityTrait(trait: string, on: boolean): void;
   getAttribute(name: string): string;
   removeAttribute(name: string): void;
   setStyle(key: string, value: unknown): void;
@@ -3064,6 +3368,7 @@ declare class LynxElement implements BaseLynxElement {
   insertBefore(newChild: LynxElement, refChild: LynxElement | null): void;
   appendChild(newChild: LynxElement): void;
   addClass(name: string): void;
+  addScopeClass(name: string): void;
   /**
    * Lynx has no __RemoveClass PAPI — we must get current classes, filter,
    * and set back. This is O(n) per class removal but class lists on Lynx
@@ -3135,11 +3440,26 @@ declare class LynxElement implements BaseLynxElement {
    * Angular's renderer.listen() calls this with event names like 'bindtap',
    * 'catchtouchstart', 'bindscroll', etc. We strip the Lynx event prefix
    * (bind/catch/capture-bind/capture-catch) to extract the native event name
-   * and determine the event type for __AddEvent.
-   * Events that don't match any prefix (e.g. DOM-style 'click') are silently
-   * ignored — Lynx has no equivalent event system for arbitrary names.
+   * and determine the event type for __AddEvent. A DOM name Lynx calls
+   * something else (see DOM_EVENT_ALIASES) listens for the Lynx event, so
+   * `(click)`, and Angular's RouterLink with it, runs on a tap.
+   * Other names (e.g. `mouseover`) are ignored: Lynx has no event for them.
+   *
+   * An element can have any number of listeners for one event, as on the
+   * web: a template's `(bindtap)` next to a directive's host listener for
+   * `click`, say. Native Lynx keeps one handler per event name, so each name
+   * gets one native handler that runs all of them (see #syncNativeHandler).
    */
   addEventListener(name: string, cb: (event: any) => any): () => void;
+  /**
+   * Removes a listener added with addEventListener, as the DOM method does,
+   * for code that pairs the two on the element itself rather than going
+   * through the renderer's cleanup function. Angular's `@defer` interaction
+   * and hover triggers do, for their `click`, `keydown` and `mouseenter`
+   * listeners; without it, their cleanup would throw. A name Lynx has no
+   * event for was never added, so removing it does nothing.
+   */
+  removeEventListener(name: string, cb: (event: any) => any): void;
 }
 /**
  * Commits all queued genuine element removals — a free-function wrapper over
@@ -3169,9 +3489,9 @@ declare const processPendingTextNormalization: () => void;
  * flush.) This mirrors the `<list>` path's own guard for the exact same case —
  * see `LynxListElement.#scheduleUpdate`.
  *
- * Called from `LynxDocument`'s element creators — which only ever run on the
- * main thread (the background thread uses LynxBackgroundDocument, which does not
- * touch the native tree), so no thread guard is needed here. It schedules ONE
+ * Called from `LynxDocument`'s element creators, which only run on the main
+ * thread (Angular doesn't run on the background thread), so no thread guard is
+ * needed here. It schedules ONE
  * coalesced microtask (matching the list guard's `queueMicrotask`, not
  * `setTimeout` — flushing from a macrotask crashes the native engine), and is a
  * no-op while:
@@ -3263,9 +3583,10 @@ declare class LynxListElement extends LynxElement {
  */
 type PortalConfig = {
   /**
-   * Overlay z-level (1–4). Higher levels render above lower ones.
+   * The overlay's layer, from 1 (the top) to 4 (the lowest), as on
+   * `<overlay>`. Lynx's default is 1.
    */
-  level?: number;
+  level?: 1 | 2 | 3 | 4;
   /**
    * Custom injector for the component's dependency injection context.
    */
@@ -3363,10 +3684,6 @@ type MainThreadFnHandle<TArgs extends unknown[] = unknown[], TReturn = unknown>
   readonly __return?: TReturn;
 };
 export declare const mainThreadFn: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn) => MainThreadFnHandle<TArgs, TReturn>;
-/**
- * Reset counter on HMR — called from runtime.ts before modules re-evaluate.
- */
-declare const __resetWorkletCounter: () => void;
 /**
  * Type definition for background function handles used by {@link backgroundFn}.
  */
@@ -3377,32 +3694,78 @@ type BackgroundFnHandle<TArgs extends unknown[] = unknown[], TReturn = unknown>
   readonly __args?: TArgs;
   readonly __return?: TReturn;
 };
-export declare const backgroundFn: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn) => BackgroundFnHandle<TArgs, TReturn>;
 /**
- * Reset counter on HMR.
+ * Registers `fn` on the background thread and returns a handle that
+ * `runOnBackground()` calls it with from the main thread.
+ *
+ * @param fn - The function to run on the background thread.
+ * @param id - Set by the build for a module-level call, so the handle has the
+ *   same ID on both threads. Don't pass it yourself.
+ * @returns The handle.
  */
-declare const __resetBgWorkletCounter: () => void;
+export declare const backgroundFn: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, id?: string) => BackgroundFnHandle<TArgs, TReturn>;
 export declare class MainThreadRef<T> {
   #private;
-  readonly _wvid: number;
-  constructor(initValue: T);
+  readonly _wvid: number | string;
+  /**
+   * @param initValue - The ref's starting value.
+   * @param id - Set by the build for a ref created at module level, so the
+   *   ref has the same ID on both threads. Don't pass it yourself.
+   */
+  constructor(initValue: T, id?: string);
   get current(): T;
   set current(value: T);
   /**
    * Serialization hook for cross-thread transfer. JSON.stringify calls this
    * when the ref is passed as a param to dispatchEvent (MTS/background RPC).
-   * The receiving thread's transformParams() resolves { _wvid } back to the
-   * registered MainThreadRef instance.
+   * The receiving thread resolves { _wvid } back to its own registered
+   * MainThreadRef instance.
    */
   toJSON(): {
-    _wvid: number;
+    _wvid: number | string;
   };
 }
-export declare const createMainThreadRef: <T>(initValue: T) => MainThreadRef<T>;
 /**
- * Reset counter on HMR.
+ * Creates a {@link MainThreadRef}.
+ *
+ * @param initValue - The ref's starting value.
+ * @param id - Set by the build for a ref created at module level. Don't pass
+ *   it yourself.
+ * @returns The new ref.
  */
-declare const __resetRefCounter: () => void;
+export declare const createMainThreadRef: <T>(initValue: T, id?: string) => MainThreadRef<T>;
+declare namespace MainThread {
+  /**
+   * An element's layout box, from `getBoundingClientRect()`, in pixels.
+   */
+  type BoundingClientRect = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+  };
+  /**
+   * Lynx's main-thread element, plus the `getBoundingClientRect()` that
+   * AngularLynx's MainThreadElement adds. The events below are Lynx's, built on
+   * this element type, so `event.currentTarget.getBoundingClientRect()` type
+   * checks without a cast.
+   */
+  type Element = Element$1 & {
+    getBoundingClientRect(options?: {
+      relativeTo?: string;
+    }): Promise<BoundingClientRect>;
+  };
+  type TouchEvent = BaseTouchEvent<Element>;
+  type MouseEvent = BaseMouseEvent<Element>;
+  type WheelEvent = BaseWheelEvent<Element>;
+  type KeyEvent = BaseKeyEvent<Element>;
+  type AnimationEvent = BaseAnimationEvent<Element>;
+  type TransitionEvent = BaseTransitionEvent<Element>;
+  type LayoutChangeEvent = LayoutChangeDetailEvent<Element>;
+  type UIAppearanceEvent = UIAppearanceDetailEvent<Element>;
+}
 /**
  * Wraps a native ElementRef (elementRefptr) with the @lynx-js/types
  * MainThread.Element API surface. Created by runWorklet's param transformation
@@ -3428,21 +3791,24 @@ export declare class MainThreadElement {
   invoke(methodName: string, params?: Record<string, unknown>): Promise<unknown>;
   animate(keyframes: Record<string, number | string>[], options?: number | LynxAnimationOptions): LynxAnimation;
   /**
+   * Measures the element's layout box, by default from the top-left corner of
+   * the LynxView. `relativeTo` takes 'screen', or another element's `id`.
+   *
    * Not part of the official @lynx-js/types Element interface, but useful for
-   * touch-tracking calculations. Uses __GetComputedStyleByKey when available.
-   */
-  getBoundingClientRect(): {
-    left: number;
-    top: number;
-    right: number;
-    bottom: number;
-    width: number;
-    height: number;
-  };
+   * touch tracking. Unlike the DOM's, it's asynchronous: native Lynx gives a
+   * main-thread script the layout position only through the
+   * `boundingClientRect` UI method. The computed `left` and `top` styles are
+   * CSS offsets, often 0, not where the element is.
+   */
+  getBoundingClientRect(options?: {
+    relativeTo?: string;
+  }): Promise<MainThread.BoundingClientRect>;
 }
 /**
- * Plain functions are also accepted because the worklet build plugin transforms
- * them into MainThreadFnHandle objects at compile time.
+ * Plain functions are also accepted: the worklet build plugin turns one with
+ * the 'main thread' directive into a MainThreadFnHandle at compile time, so
+ * TypeScript only sees the function, and the directive registers any other
+ * function itself.
  */
 type MaybeHandle = MainThreadFnHandle | ((...args: any[]) => any) | undefined | null;
 /**
@@ -3450,14 +3816,16 @@ type MaybeHandle = MainThreadFnHandle | ((...args: any[]) => any) | undefined |
  * Lynx's main-thread (Lepus) event dispatch.
  *
  * Why a dedicated directive and not the renderer's listen() path:
- * - Normal `(bindtap)` events are delivered to the background JS thread and
- *   incur a thread hop on every dispatch — fine for one-shot taps, but too
- *   slow for gesture-driven UI (scroll-tracking, drag, pinch) where the
- *   handler needs to mutate styles at native frame rate.
- * - The `mainThreadBind*` / `mainThreadCatch*` family registers the handler
- *   as a *worklet* with `_workletType: 'main-thread'`, so Lynx invokes it
- *   directly on the Lepus thread where __AddInlineStyle / __SetAttribute are
- *   synchronous. There is no thread hop and no background JS involvement.
+ * - Normal `(bindtap)` handlers run on the main thread too (listen() registers
+ *   them as worklets), but each one goes through Angular's listener wrapper,
+ *   which marks the view for change detection on every dispatch: too much for
+ *   gesture-driven UI (scroll-tracking, drag, pinch) that mutates styles at
+ *   native frame rate. Their event's targets are also plain data.
+ * - The `mainThreadBind*` / `mainThreadCatch*` family registers the function
+ *   itself as a *worklet* with `_workletType: 'main-thread'`, so Lynx invokes
+ *   it directly, and runWorklet hands it MainThreadElement targets, whose
+ *   __AddInlineStyle / __SetAttribute calls are synchronous. Angular does no
+ *   work per event.
  * - These inputs cannot be expressed as @Output() because Angular would route
  *   them through its own event subscription system and the underlying
  *   worklet handle would never be passed to __AddEvent.
@@ -3476,6 +3844,12 @@ export declare class LynxMainThreadEvent implements OnChanges, OnDestroy {
   mainThreadCatchtouchmove?: MaybeHandle;
   mainThreadBindtouchend?: MaybeHandle;
   mainThreadCatchtouchend?: MaybeHandle;
+  mainThreadBindmousedown?: MaybeHandle;
+  mainThreadCatchmousedown?: MaybeHandle;
+  mainThreadBindmousemove?: MaybeHandle;
+  mainThreadCatchmousemove?: MaybeHandle;
+  mainThreadBindmouseup?: MaybeHandle;
+  mainThreadCatchmouseup?: MaybeHandle;
   mainThreadBindlongpress?: MaybeHandle;
   mainThreadCatchlongpress?: MaybeHandle;
   mainThreadBindscroll?: MaybeHandle;
@@ -3487,7 +3861,7 @@ export declare class LynxMainThreadEvent implements OnChanges, OnDestroy {
   ngOnChanges(changes: SimpleChanges): void;
   ngOnDestroy(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxMainThreadEvent, never>;
-  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxMainThreadEvent, "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]", never, {
+  static ɵdir: i0.ɵɵDirectiveDeclaration<LynxMainThreadEvent, "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindmousedown],[mainThreadCatchmousedown],[mainThreadBindmousemove],[mainThreadCatchmousemove],[mainThreadBindmouseup],[mainThreadCatchmouseup],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]", never, {
     "mainThreadBindtap": {
       "alias": "mainThreadBindtap";
       "required": false;
@@ -3520,6 +3894,30 @@ export declare class LynxMainThreadEvent implements OnChanges, OnDestroy {
       "alias": "mainThreadCatchtouchend";
       "required": false;
     };
+    "mainThreadBindmousedown": {
+      "alias": "mainThreadBindmousedown";
+      "required": false;
+    };
+    "mainThreadCatchmousedown": {
+      "alias": "mainThreadCatchmousedown";
+      "required": false;
+    };
+    "mainThreadBindmousemove": {
+      "alias": "mainThreadBindmousemove";
+      "required": false;
+    };
+    "mainThreadCatchmousemove": {
+      "alias": "mainThreadCatchmousemove";
+      "required": false;
+    };
+    "mainThreadBindmouseup": {
+      "alias": "mainThreadBindmouseup";
+      "required": false;
+    };
+    "mainThreadCatchmouseup": {
+      "alias": "mainThreadCatchmouseup";
+      "required": false;
+    };
     "mainThreadBindlongpress": {
       "alias": "mainThreadBindlongpress";
       "required": false;
@@ -3555,43 +3953,23 @@ export declare class LynxMainThreadEvent implements OnChanges, OnDestroy {
   }, {}, never, never, true, never>;
 }
 /**
- * Injectable service for calling main-thread (Lepus) functions. From the
- * background thread it uses Lynx's cross-thread RPC via JSContext events:
- *
- *   background calls runOnMainThread(handle, ...args)
- *   → dispatches 'Lynx.Worklet.runWorkletCtx' with { worklet, params, resolveId }
- *   → main thread's listener (in runtime.ts) invokes the registered worklet fn
- *   → dispatches 'Lynx.Worklet.FunctionCallRet' with { resolveId, returnValue }
- *   → background thread's listener resolves the Promise
+ * Injectable service for calling main-thread (Lepus) functions from Angular
+ * code, and getting their return values.
  *
- * This enables background-thread Angular code (services, effects) to trigger
- * main-thread imperative operations (animate, measure, invoke UI methods)
- * with proper async/await ergonomics.
+ * Angular runs on the main thread only (see bootstrapApplication), so the
+ * call never crosses threads: it invokes the registered worklet in place,
+ * with the arguments as they are, and resolves with its result. Non-
+ * serializable values (element handles, MainThreadRefs) pass through intact.
  *
- * It is also safe to call from code already running on the main thread. The
- * renderer registers Angular `(bind*)`/`(catch*)` event handlers as main-thread
- * worklets, so a handler like `(bindtap)="flash()"` executes on the Lepus thread
- * — and any runOnMainThread() call it makes originates there too. Rather than
- * fail (there is no other thread to be "called from"), we detect that case and
- * invoke the target worklet in-place, so the same call site works regardless of
- * which thread reaches it.
+ * It used to send the call across threads when it ran on the background
+ * thread, for the copy of the app that booted there too. That copy is gone
+ * (issue #81), and with it the background-to-main call channel.
  */
 export declare class LynxMainThread {
   runOnMainThread<TArgs extends unknown[], TReturn>(handle: MainThreadFnHandle<TArgs, TReturn>, ...args: TArgs): Promise<TReturn>;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxMainThread, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-declare namespace MainThread {
-  type Element = Element;
-  type TouchEvent = TouchEvent;
-  type MouseEvent = MouseEvent;
-  type WheelEvent = WheelEvent;
-  type KeyEvent = KeyEvent;
-  type AnimationEvent = AnimationEvent;
-  type TransitionEvent = TransitionEvent;
-  type LayoutChangeEvent = LayoutChangeEvent;
-  type UIAppearanceEvent = UIAppearanceEvent;
-}
 /**
  * Resource priority hint for the native prefetch engine.
  */
@@ -3645,8 +4023,9 @@ type PrefetchResultDetail = {
  * with a Promise-based API for preloading images and videos into the native
  * cache before they're needed for display.
  *
- * Only available on the background thread — these APIs are not exposed on
- * the main thread.
+ * Lynx has these APIs only on the background thread, while Angular runs on
+ * the main thread, so the calls go through the background call relay
+ * (background-call.ts).
  *
  * @usageNotes
  * ```typescript
@@ -3768,7 +4147,8 @@ type SessionStorageSubscription = {
  *   subscribe/unsubscribe at all — and `getSessionStorageItem` is
  *   *synchronous*, taking just the key and returning the value directly.
  *   Calling it with a callback (the background-thread shape) throws a native
- *   "GetSessionStorageItem param size should be 1" fatal error.
+ *   "GetSessionStorageItem param size should be 1" fatal error. Subscriptions
+ *   made there go through the background thread (see background-call.ts).
  *
  * @usageNotes
  * ```typescript
@@ -3858,6 +4238,11 @@ export declare class LynxSessionStorage {
  * `SystemInfo` is populated once when the Lynx view initializes and
  * is read-only for the lifetime of the app — the values never change.
  *
+ * On iOS and Android (Lynx 4.1), the main thread has no global `SystemInfo`,
+ * only `lynx.SystemInfo`, so that's read first. The background thread and the
+ * web have the global. The main thread's copy has no `osVersion` either: see
+ * {@link LynxSystemInfo.osVersion} for where that comes from instead.
+ *
  * @usageNotes
  * ```typescript
  * const systemInfo = inject(LynxSystemInfo);
@@ -3887,7 +4272,13 @@ export declare class LynxSystemInfo {
    */
   get engineVersion(): string;
   /**
-   * The current operating system version.
+   * The current operating system version, such as `'26.1'` on iOS or `'15'`
+   * on Android. Empty while it isn't known.
+   *
+   * The native main thread's SystemInfo lacks it, so there it comes from the
+   * host app's `osVersion` global prop, or else from the background thread,
+   * which answers shortly after the first frame. It reads a signal, so a
+   * `computed()` that reads it updates when the answer arrives.
    */
   get osVersion(): string;
   /**
@@ -4119,13 +4510,25 @@ export declare class LynxTransitionGroup<T> {
 /**
  * Central DI configuration for the Lynx renderer. Must be included in every
  * Lynx Angular app's providers (typically via app.config.ts). Sets up:
- * 1. Thread-aware document (LynxDocument vs LynxBackgroundDocument)
+ * 1. The document (LynxDocument, or LynxHydrateDocument for SSR)
  * 2. DOCUMENT stub (Angular requires this token but Lynx has no DOM Document)
  * 3. APP_BASE_HREF (prevents BrowserPlatformLocation from crashing)
  * 4. Renderer factory (creates LynxRenderer / EmulatedLynxRenderer)
  * 5. Error handler (routes to _ReportError + __lynxLastError)
  */
 export declare const provideRenderer: () => EnvironmentProviders;
+/**
+ * Keeps the app on the screen it was showing when a hot update re-bootstraps
+ * it. Called with the old app's injector before it's destroyed, it saves the
+ * old strategy's history, and the next strategy created starts from it. The
+ * router's initial navigation then goes to the current URL instead of `/`,
+ * and Back still has the screens before it.
+ *
+ * Does nothing for an app without the router, or with another strategy.
+ *
+ * @param injector - The injector of the app that's about to be destroyed.
+ */
+declare const carryOverLocation: (injector: Injector | undefined) => void;
 /**
  * In-memory LocationStrategy for Lynx — equivalent to React Router's MemoryRouter.
  *
@@ -4141,6 +4544,13 @@ export declare const provideRenderer: () => EnvironmentProviders;
  */
 export declare class LynxLocationStrategy extends LocationStrategy {
   #private;
+  constructor();
+  /**
+   * Whether there's an entry before the current one, so `back()` goes
+   * somewhere. The Android back button follows it (see lynx-back-button.ts):
+   * while it's false, back leaves the app, as on any root screen.
+   */
+  readonly canGoBack: import("@angular/core").Signal<boolean>;
   path(): string;
   prepareExternalUrl(internal: string): string;
   getBaseHref(): string;
@@ -4193,25 +4603,32 @@ export declare class LynxPlatformLocation extends PlatformLocation {
 /**
  * Route reuse strategy that keeps component views alive across navigations.
  *
- * ## Why this is required on Lynx
+ * Opt-in: `provideRouter()` doesn't install it, so leaving a route destroys
+ * its components, as Angular does on the web. Provide it yourself to keep
+ * every visited route's component, and its state, alive:
+ *
+ * ```typescript
+ * providers: [
+ *   provideRouter(routes),
+ *   { provide: RouteReuseStrategy, useClass: LynxRouteReuseStrategy },
+ * ]
+ * ```
  *
- * Lynx's native element APIs (`__CreateView`, `__CreateText`, etc.) allocate
- * elements in a fixed-size native pool. `__RemoveElement` detaches an element
- * from the tree but does NOT free its pool slot — there is no `__ReleaseElement`
- * API in Lynx's public surface. Angular's default `RouteReuseStrategy` destroys
- * components on every navigation, creating fresh native elements each time. Those
- * freed elements accumulate in the pool until it overflows (~256 slots on device),
- * causing a hard native crash on the 9th navigation in a back-and-forth pattern.
+ * Nothing is ever evicted, and `ngOnDestroy()` doesn't run when you leave a
+ * route.
  *
- * ## What this strategy does
+ * ## Why it exists
  *
- * Instead of destroying a component when navigating away, Angular calls
- * `ViewContainerRef.detach()`. The component's DOM elements are removed from the
- * native tree (the slots are occupied but unused). When navigating back,
- * `ViewContainerRef.insert()` re-adds those same native elements to the tree —
- * reusing their existing pool slots with no new allocations. The pool stays bounded
- * by (initial elements) + (max elements for any single route), regardless of how
- * many times the user navigates.
+ * `provideRouter()` used to install it. A crash investigation in May 2026
+ * blamed a ~256-slot native element pool that `__RemoveElement` never freed,
+ * and detaching views was meant to reuse their elements. Neither holds on
+ * Lynx 4.1 (measured October 2026 on the iOS Simulator and an Android
+ * emulator, issue #68): 400 navigations between two 300-element routes
+ * created 121,527 native elements without a crash, with this strategy and
+ * with Angular's default alike. A re-attached view's native elements were
+ * destroyed when it was detached, so `LynxElement` rebuilds them from cache
+ * (`#recreateSubtree`), and a revisit creates as many elements as a fresh
+ * route.
  */
 export declare class LynxRouteReuseStrategy implements RouteReuseStrategy {
   #private;
@@ -4252,10 +4669,193 @@ export declare const provideRouter: (routes: Routes, ...features: RouterFeatures
  * convention). No-op off-device where `_ReportError` is absent.
  */
 declare const reportToNative: (err: Error) => void;
+type GlobalExposureBatch = {
+  type: 'exposure' | 'disexposure';
+  events: GlobalExposureEvent;
+};
+/**
+ * Every batch of global exposure events, on whichever thread this module runs.
+ * LynxGlobalExposure subscribes.
+ */
+declare const globalExposureBatches: Subject<GlobalExposureBatch>;
+/**
+ * The background thread's half of the main thread's `fetch` (see fetch.ts).
+ * Lynx has `fetch` on the background thread only, and Angular runs on the
+ * main thread, so the main thread's `fetch` sends each request here, where
+ * background-call.ts's relay runs it, and this sends the response back.
+ *
+ * Everything crosses as JSON. A body is text when it can be, and base64
+ * otherwise, since JSON can't carry bytes.
+ */
+/** A request or response body as it crosses threads. */
+type RelayedBody = {
+  text: string;
+} | {
+  base64: string;
+} | null;
+/** A request as the main thread sends it. */
+type RelayedRequest = {
+  url: string;
+  method: string;
+  /** Unique names, since the main thread's Headers joins repeated ones. */
+  headers: [string, string][];
+  body: RelayedBody;
+  /** The rest of `RequestInit`, for hosts that use it (Lynx for Web's worker). */
+  options: {
+    cache?: string;
+    credentials?: string;
+    integrity?: string;
+    keepalive?: boolean;
+    mode?: string;
+    priority?: string;
+    redirect?: string;
+    referrer?: string;
+    referrerPolicy?: string;
+  };
+};
+/** A response as the background thread sends it back. */
+type RelayedResponse = {
+  status: number;
+  statusText: string;
+  url: string;
+  redirected: boolean;
+  headers: [string, string][];
+  body: RelayedBody;
+};
+/**
+ * Runs a request for the main thread and resolves with the response, body
+ * included. It rejects with a TypeError when the request fails, as `fetch`
+ * does.
+ *
+ * @param id - The main thread's ID for the request, to abort it by.
+ * @param request - The request.
+ * @returns The response.
+ */
+declare const fetchForMainThread: (id: number, request: RelayedRequest) => Promise<RelayedResponse>;
+/**
+ * Aborts a request the main thread sent, when its signal aborts. The main
+ * thread has already rejected its own promise; this stops the work here.
+ *
+ * @param id - The main thread's ID for the request.
+ */
+declare const abortFetchForMainThread: (id: number) => void;
+/**
+ * `__MAIN_THREAD__` is a build-time define. Unit tests don't define it, and run
+ * as the background thread unless they stub it.
+ *
+ * @returns Whether this code runs on the main thread.
+ */
+declare const isMainThread: () => boolean;
+/**
+ * Prepares a relayed call's arguments: on the main thread, each function in
+ * them, or in a plain object or array in them, becomes a marker that the
+ * background thread calls back. Elsewhere the call runs in place, so the
+ * arguments are left alone.
+ *
+ * @param value - The arguments, or one of them.
+ * @returns The value to send.
+ */
+declare const relayFunctions: (value: unknown) => unknown;
+/**
+ * Prepares a JS module for registering from the main thread: its methods,
+ * including ones on its prototype such as a class's, become markers bound to
+ * it, and its other fields are copied.
+ *
+ * @param module - The module to register.
+ * @returns The value to send.
+ */
+declare const relayModuleObject: (module: object) => unknown;
+/** Which registry a relayed module comes from. */
+type ModuleKind = 'native' | 'js';
+declare const handlers: {
+  accessibilityAnnounce: (content: string) => Promise<void>;
+  addFont: (fontFamily: string, src: string) => Promise<void>;
+  setObserverFrameRate: (options?: ObserverFrameRateOptions) => void;
+  stopExposure: (options?: {
+    sendEvent: boolean;
+  }) => void;
+  resumeExposure: () => void;
+  /**
+   * Subscribes on the background thread and sends each change to the main
+   * thread, where subscribeSessionStorageFromMainThread() delivers it.
+   */
+  subscribeSessionStorage: (key: string, relayId: number) => void;
+  unsubscribeSessionStorage: (relayId: number) => void;
+  requestResourcePrefetch: (data: unknown) => Promise<unknown>;
+  cancelResourcePrefetch: (data: unknown) => Promise<unknown>;
+  /**
+   * Calls the host's bridge method and resolves with the first value it
+   * passes back. Without a bridge, such as in the web preview, it resolves
+   * `undefined`, as LynxNativeModule.call() always has.
+   */
+  nativeBridgeCall: (name: string, params: unknown) => Promise<unknown>;
+  nativeBridgeOn: (name: string, callback: unknown) => void;
+  /**
+   * Calls a method of a native module or a JS module. The main thread's
+   * module proxies (relayedModule() below) send their calls here.
+   */
+  callModule: (kind: ModuleKind, name: string, method: string, args: unknown[]) => unknown;
+  registerJSModule: (name: string, module: unknown) => void;
+  /**
+   * The OS version, for LynxSystemInfo on the main thread: native Lynx builds
+   * that thread's SystemInfo without one, and the background thread's global
+   * has it.
+   */
+  osVersion: () => string | undefined;
+  /** The main thread's `fetch` (network/fetch.ts) sends its requests here. */
+  fetch: (id: number, request: RelayedRequest) => Promise<RelayedResponse>;
+  abortFetch: (id: number) => void;
+};
+type Handlers = typeof handlers;
+type HandlerName = keyof Handlers;
+/**
+ * Runs a background-only Lynx API, directly on the background thread or relayed
+ * from the main thread.
+ */
+declare const callOnBackground: <N extends HandlerName>(name: N, ...args: Parameters<Handlers[N]>) => Promise<Awaited<ReturnType<Handlers[N]>>>;
+/**
+ * Main thread: a stand-in for a native module or JS module, which only the
+ * background thread can reach. Each method call runs there and returns a
+ * promise of its result, and function arguments are called back here. Reading
+ * `then` gives `undefined`, so the proxy isn't mistaken for a promise.
+ *
+ * @param kind - `'native'` for `NativeModules`, `'js'` for `lynx.getJSModule`.
+ * @param name - The module's name.
+ * @returns The proxy.
+ */
+declare const relayedModule: (kind: ModuleKind, name: string) => object;
+/**
+ * Main thread only. Subscribes to a session storage key through the background
+ * thread, the only thread that can, and returns the ID to unsubscribe with.
+ */
+declare const subscribeSessionStorageFromMainThread: (key: string, listener: (value: unknown) => void) => number;
+declare const unsubscribeSessionStorageFromMainThread: (relayId: number) => void;
+/**
+ * Starts the background thread. The build calls it from the background
+ * thread's entry, a module it generates in place of the app's `main.ts`
+ * (background-entry.ts in the build plugin): Angular runs on the main thread
+ * only, so the background thread loads just this runtime and the modules that
+ * define a background function or a `MainThreadRef`.
+ *
+ * Loading the runtime installs the background half of each bridge (the imports
+ * above). This installs `lynx.loadLazyBundle`, for an `import()` in a
+ * background function. Importing it is also what keeps the runtime in the
+ * background bundle: the package is marked `"sideEffects": false`, so a bare
+ * `import '@blotch/angular-lynx'` would be dropped.
+ */
+export declare const ɵstartBackgroundThread: () => void;
 /**
  * Bootstrap Angular application on the Lynx runtime. Waits for the main thread to
  * signal it's ready before initializing the framework, then registers global
  * callbacks for page updates and worklet invocations.
+ *
+ * Angular runs on the main thread only. The background thread starts from an
+ * entry the build generates instead of `main.ts` (see
+ * {@link ɵstartBackgroundThread}), so it doesn't reach this function, unless a
+ * module it loads also bootstraps, such as a `main.ts` that defines a
+ * `backgroundFn()` itself. Then it gets no app: the returned promise never
+ * settles on that thread. Booting a second copy there ran every constructor,
+ * `ngOnInit` and `effect()` twice, and its views went nowhere (issue #81).
  */
 export declare const bootstrapApplication: (rootComponent: Type<unknown>, options?: ApplicationConfig) => Promise<ApplicationRef>;
 declare global {
@@ -4303,25 +4903,15 @@ declare global {
   var __LYNX_SOURCE_LOCALE__: string;
   interface Window {
     registerWorklet: (type: string, id: string, fn: Function) => void;
-    __workletRefMap: Record<number, {
+    __workletRefMap: Record<number | string, {
       current: unknown;
     }>;
-    __lynxMtsPendingResolvers: Record<number, {
-      resolve: (v: unknown) => void;
-      reject: (e: unknown) => void;
-    }>;
-    __lynxMtsNextResolveId: () => number;
     __lynxRunMainThreadWorklet: (wkltId: string, args: unknown[]) => unknown;
   }
   var registerWorklet: (type: string, id: string, fn: Function) => void;
-  var __workletRefMap: Record<number, {
+  var __workletRefMap: Record<number | string, {
     current: unknown;
   }>;
-  var __lynxMtsPendingResolvers: Record<number, {
-    resolve: (v: unknown) => void;
-    reject: (e: unknown) => void;
-  }>;
-  var __lynxMtsNextResolveId: () => number;
   var __lynxRunMainThreadWorklet: (wkltId: string, args: unknown[]) => unknown;
   function runOnBackground(handle: {
     _wkltId: string;
@@ -4329,21 +4919,31 @@ declare global {
 }
 declare global {
   interface HTMLElementEventMap {
-    bindtap: TouchEvent$1;
-    catchtap: TouchEvent$1;
-    'capture-bindtap': TouchEvent$1;
-    'capture-catchtap': TouchEvent$1;
-    'global-bindtap': TouchEvent$1;
-    bindtouchstart: TouchEvent$1;
-    bindtouchend: TouchEvent$1;
-    bindtouchmove: TouchEvent$1;
-    bindtouchcancel: TouchEvent$1;
-    bindlongpress: TouchEvent$1;
-    catchtouchstart: TouchEvent$1;
-    catchtouchend: TouchEvent$1;
-    catchtouchmove: TouchEvent$1;
-    catchtouchcancel: TouchEvent$1;
-    catchlongpress: TouchEvent$1;
+    bindtap: TouchEvent;
+    catchtap: TouchEvent;
+    'capture-bindtap': TouchEvent;
+    'capture-catchtap': TouchEvent;
+    'global-bindtap': TouchEvent;
+    bindtouchstart: TouchEvent;
+    bindtouchend: TouchEvent;
+    bindtouchmove: TouchEvent;
+    bindtouchcancel: TouchEvent;
+    bindlongpress: TouchEvent;
+    catchtouchstart: TouchEvent;
+    catchtouchend: TouchEvent;
+    catchtouchmove: TouchEvent;
+    catchtouchcancel: TouchEvent;
+    catchlongpress: TouchEvent;
+    bindmousedown: MouseEvent;
+    bindmouseup: MouseEvent;
+    bindmousemove: MouseEvent;
+    bindmouseenter: MouseEvent;
+    bindmouseleave: MouseEvent;
+    catchmousedown: MouseEvent;
+    catchmouseup: MouseEvent;
+    catchmousemove: MouseEvent;
+    catchmouseenter: MouseEvent;
+    catchmouseleave: MouseEvent;
   }
 }
-export type { BackgroundFnHandle, BaseLynxAnimation, DataProcessorDefinition, DevToolsStats, ExposureEventDetail, FlingGestureEvent, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, InitData, InitDataRaw, LongPressGestureEvent, LynxAnimationOptions, LynxFontEntry, LynxFontFaceConfig, LynxFontStatus, MainThread, MainThreadFnHandle, NativeModuleMap, ObserverFrameRateOptions, PanGestureEvent, PinchGestureEvent, PortalConfig, PrefetchCacheTarget, PrefetchPriority, PrefetchRequest, PrefetchResultDetail, RotationGestureEvent, SessionStorageSubscription, TapGestureEvent };
+export type { BackgroundFnHandle, BaseLynxAnimation, DataProcessorDefinition, DevToolsStats, ExposureEventDetail, FlingGestureEvent, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, InitData, InitDataRaw, LongPressGestureEvent, LynxAnimationOptions, LynxFontEntry, LynxFontFaceConfig, LynxFontStatus, LynxTraceOptions, MainThread, MainThreadFnHandle, NativeModuleMap, NativeModuleProxy, ObserverFrameRateOptions, PanGestureEvent, PinchGestureEvent, PortalConfig, PrefetchCacheTarget, PrefetchPriority, PrefetchRequest, PrefetchResultDetail, ResourcePrefetchData, ResourcePrefetchResult, RotationGestureEvent, SessionStorageSubscription, TapGestureEvent };