@blotch/angular-lynx 22.2.8 → 22.2.10

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

@@ -3,8 +3,8 @@ import { ApplicationConfig, ApplicationRef, ComponentRef, EmbeddedViewRef, Envir
 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 { AnimationEvent, MouseEvent, ResourcePrefetchData, ResourcePrefetchResult, TextInfo, TextMetrics, TouchEvent, TransitionEvent } 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";
@@ -1252,9 +1252,12 @@ type ExposureMargin = `${number}px` | `${number}rpx`;
  *    endpoint that renderer.setProperty() would reach.
  *
  * 3. Events (bindtap, catchtap, bindinput, bindscroll, …) are NOT declared as
- *    @Output() because Angular would intercept them and skip the renderer's
- *    listen() call, breaking native Lynx event delivery. They continue to work
- *    via renderer.listen() which handles all unrecognized event names.
+ *    outputs. Angular would still add the native listener with
+ *    renderer.listen(), but it would also subscribe the handler to the output,
+ *    so DebugElement.triggerEventHandler() would run it twice, and every
+ *    binding would hold a subscription to an output that never emits. Their
+ *    `$event` types come from each tag's element type instead (see
+ *    types/element-events.ts), which Angular's template checker reads.
  */
 declare class LynxElementBase implements OnChanges {
   #private;
@@ -1692,6 +1695,546 @@ export declare class LynxCoverView extends LynxElementBase {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxCoverView, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<LynxCoverView, "cover-view", never, {}, {}, never, never, true, never>;
 }
+/**
+ * The element an event started on (`target`), or the one whose handler is
+ * running (`currentTarget`). Lynx sends plain data, not the element, so it
+ * has no methods. To call an element method, use a template reference.
+ */
+type LynxEventTarget = {
+  /** The element's `id` attribute. */
+  readonly id: string;
+  /** Lynx's internal number for the element. */
+  readonly uid: number;
+  /**
+   * The element's `data-*` attributes, keyed without the `data-` prefix.
+   * Values aren't always strings: a property binding such as
+   * `[data-item]="item"` keeps its value as it is.
+   */
+  readonly dataset: Readonly<Record<string, unknown>>;
+};
+/**
+ * The object a Lynx element event hands its handler, as `$event`. Every
+ * element event has this shape; `Detail` is the event's own data, such as
+ * `ImageLoadDetail` for an `<image>`'s `bindload`.
+ *
+ * Angular types `$event` from the element and the event, so a template
+ * handler needs no annotation. Write the type out for a handler declared
+ * apart from the template:
+ *
+ * ```ts
+ * template: `<image [src]="url" (bindload)="loaded($event)" />`,
+ *
+ * protected loaded({ detail }: LynxEvent<ImageLoadDetail>): void {
+ *   this.#size.set(detail);
+ * }
+ * ```
+ *
+ * It isn't a DOM `Event`: Lynx's event has none of the DOM's other fields
+ * (`timeStamp`, `bubbles`, `composedPath()`…), so they don't type-check.
+ * Tap, long-press and touch events are Lynx's `TouchEvent`, which has this
+ * shape plus `touches` and `changedTouches`.
+ */
+type LynxEvent<Detail = unknown> = {
+  /** The event's name without its prefix, such as `'load'` for `bindload`. */
+  readonly type: string;
+  /** When the event fired, in milliseconds. */
+  readonly timestamp: number;
+  /** The element the event started on. */
+  readonly target: LynxEventTarget;
+  /** The element whose handler is running. */
+  readonly currentTarget: LynxEventTarget;
+  /** The event's own data. */
+  readonly detail: Detail;
+  /**
+   * Does nothing to native events: the `catch` prefix (`catchtap`) stops an
+   * event. AngularLynx adds it where Lynx doesn't, so web-style code runs.
+   */
+  stopPropagation(): void;
+  /**
+   * There's no default action to prevent. AngularLynx adds it where Lynx
+   * doesn't, as Angular calls it when a handler returns `false`.
+   */
+  preventDefault(): void;
+};
+/** `bindlayoutchange`'s detail: the element's new size and position. */
+type LayoutChangeDetail = {
+  /** The element's `id` attribute. */
+  readonly id: string;
+  readonly width: number;
+  readonly height: number;
+  /** Positions are relative to the Lynx view, in px. */
+  readonly top: number;
+  readonly right: number;
+  readonly bottom: number;
+  readonly left: number;
+  /** The element's `data-*` attributes (see `LynxEventTarget.dataset`). */
+  readonly dataset: Readonly<Record<string, unknown>>;
+};
+/**
+ * `binduiappear` and `binduidisappear`'s detail: which element came on or
+ * went off the screen.
+ */
+type UIAppearanceDetail = {
+  readonly 'exposure-id': string;
+  readonly 'exposure-scene': string;
+  /**
+   * Identifies the native element. iOS and Android send a string; the web
+   * sends the element's numeric unique ID.
+   */
+  readonly 'unique-id': string | number;
+  /** The element's `data-*` attributes (see `LynxEventTarget.dataset`). */
+  readonly dataset: Readonly<Record<string, unknown>>;
+};
+/**
+ * `bindaccessibilityaction`'s detail: the custom action, from the element's
+ * `accessibility-actions`, that a screen reader user picked.
+ */
+type AccessibilityActionDetail = {
+  readonly name: string;
+};
+/**
+ * Names each event, keyed by its `bind` name as the docs write it, under
+ * every prefix Lynx binds it with, all of which hand the handler the same
+ * event: `bind` lets it bubble, `catch` stops it, the `capture-` forms run on
+ * the way down, and `global-bind` runs for the event on any element. Only
+ * touch events bubble, so for the others `catch` and the `capture-` forms
+ * change nothing. `{ bindtap: E }` gives `bindtap`, `catchtap`…
+ */
+type WithPrefixes<Events> = { [Name in keyof Events & string as Name extends `bind${infer Event}` ? `bind${Event}` | `catch${Event}` | `capture-bind${Event}` | `capture-catch${Event}` | `global-bind${Event}` : never]: Events[Name]; };
+/**
+ * The events every element fires, with the type of each one's `$event`. The
+ * events only some elements fire are in element-events.ts.
+ */
+type LynxCommonEventMap = WithPrefixes<{
+  bindtap: TouchEvent;
+  bindlongpress: TouchEvent;
+  bindtouchstart: TouchEvent;
+  bindtouchmove: TouchEvent;
+  bindtouchend: TouchEvent;
+  bindtouchcancel: TouchEvent;
+  bindmousedown: MouseEvent;
+  bindmouseup: MouseEvent;
+  bindmousemove: MouseEvent;
+  bindmouseenter: MouseEvent;
+  bindmouseleave: MouseEvent;
+  bindlayoutchange: LynxEvent<LayoutChangeDetail>;
+  binduiappear: LynxEvent<UIAppearanceDetail>;
+  binduidisappear: LynxEvent<UIAppearanceDetail>;
+  bindanimationstart: AnimationEvent;
+  bindanimationiteration: AnimationEvent;
+  bindanimationend: AnimationEvent;
+  bindanimationcancel: AnimationEvent;
+  bindtransitionstart: TransitionEvent;
+  bindtransitionend: TransitionEvent;
+  bindtransitioncancel: TransitionEvent;
+  bindaccessibilityaction: LynxEvent<AccessibilityActionDetail>;
+}>;
+declare global {
+  /**
+   * Angular types `$event` on an element's event from the element's
+   * `addEventListener`: its type-check code calls
+   * `document.createElement(tag).addEventListener(event, handler)`. An
+   * element with no type of its own is an `HTMLElement`, which looks the
+   * event up here, so these entries type the events every element fires.
+   * Without them `$event` is a DOM `Event`, with no `detail`.
+   */
+  interface HTMLElementEventMap extends LynxCommonEventMap {}
+}
+/** `<image>` and `<svg>`'s `bindload` detail: the image's own size, in px. */
+type ImageLoadDetail = {
+  readonly width: number;
+  readonly height: number;
+};
+/** `<image>`'s `binderror` detail. */
+type ImageErrorDetail = {
+  readonly errMsg: string;
+  readonly error_code: number;
+  readonly lynx_categorized_code: number;
+};
+type LynxImageEventMap = WithPrefixes<{
+  bindload: LynxEvent<ImageLoadDetail>;
+  binderror: LynxEvent<ImageErrorDetail>;
+  bindstartplay: LynxEvent;
+  bindcurrentloopcomplete: LynxEvent;
+  bindfinalloopcomplete: LynxEvent;
+}>;
+type LynxSvgEventMap = WithPrefixes<{
+  bindload: LynxEvent<ImageLoadDetail>;
+}>;
+/** `<text>`'s `bindlayout` detail. */
+type TextLayoutDetail = {
+  readonly lineCount: number;
+  /** A line with `ellipsisCount` above 0 was truncated. */
+  readonly lines: readonly {
+    readonly start: number;
+    readonly end: number;
+    readonly ellipsisCount: number;
+  }[];
+  readonly size: {
+    readonly width: number;
+    readonly height: number;
+  };
+};
+/** `<text>`'s `bindselectionchange` detail (iOS and Android). */
+type TextSelectionChangeDetail = {
+  readonly start: number;
+  readonly end: number;
+  readonly direction: 'forward' | 'backward';
+};
+type LynxTextEventMap = WithPrefixes<{
+  bindlayout: LynxEvent<TextLayoutDetail>;
+  bindselectionchange: LynxEvent<TextSelectionChangeDetail>;
+}>;
+/** `<input>` and `<textarea>`'s `bindinput` detail. */
+type InputDetail = {
+  readonly value: string;
+  readonly selectionStart: number;
+  readonly selectionEnd: number;
+  /**
+   * `true` while a keyboard that builds characters from several keystrokes,
+   * such as a Chinese or Japanese one, is mid-character.
+   */
+  readonly isComposing?: boolean;
+};
+/**
+ * `<input>` and `<textarea>`'s `bindfocus`, `bindblur` and `bindconfirm`
+ * detail: the field's text.
+ */
+type InputValueDetail = {
+  readonly value: string;
+};
+/** `<input>` and `<textarea>`'s `bindselection` detail. */
+type InputSelectionDetail = {
+  readonly selectionStart: number;
+  readonly selectionEnd: number;
+};
+/**
+ * `<input>` and `<textarea>`'s `bindbeforeinput` detail (iOS): an edit about
+ * to be applied, which replaces `length` characters from `cursor` with
+ * `replace`.
+ */
+type BeforeInputDetail = {
+  /** The text before the edit. */
+  readonly value: string;
+  readonly cursor: number;
+  readonly length: number;
+  readonly replace: string;
+  readonly isComposing?: boolean;
+};
+/**
+ * `<input>` and `<textarea>`'s `bindkeyboardheightchange` detail, sent while
+ * the field has focus: as the keyboard shows, when it changes size, and with
+ * `0` as it hides.
+ */
+type KeyboardHeightDetail = {
+  /**
+   * iOS sends points, measured up from the bottom of the window. Android
+   * sends physical pixels, measured up from the bottom of the Lynx view.
+   */
+  readonly height: number;
+};
+/** `<input>` and `<textarea>`'s `bindkeyboard` detail (iOS). */
+type KeyboardDetail = {
+  /** Whether the keyboard is showing or hiding. */
+  readonly show: boolean;
+  /** As it shows, its height, in points. */
+  readonly keyboardHeight?: number;
+  /** As it shows, the window's bottom safe-area inset, in points. */
+  readonly safeAreaBottom?: number;
+};
+type LynxInputEventMap = WithPrefixes<{
+  bindinput: LynxEvent<InputDetail>;
+  bindfocus: LynxEvent<InputValueDetail>;
+  bindblur: LynxEvent<InputValueDetail>;
+  bindconfirm: LynxEvent<InputValueDetail>;
+  bindselection: LynxEvent<InputSelectionDetail>;
+  bindbeforeinput: LynxEvent<BeforeInputDetail>;
+  bindkeyboardheightchange: LynxEvent<KeyboardHeightDetail>;
+  bindkeyboard: LynxEvent<KeyboardDetail>;
+}>;
+/** `<textarea>`'s `bindline` detail. */
+type TextareaLineDetail = {
+  /**
+   * The number of lines. On iOS and Android, `-1` means an edit would have
+   * gone over `maxlines`.
+   */
+  readonly line: number;
+};
+type LynxTextareaEventMap = LynxInputEventMap & WithPrefixes<{
+  bindline: LynxEvent<TextareaLineDetail>;
+}>;
+/** `<scroll-view>`'s scroll events' detail, in px. */
+type ScrollDetail = {
+  readonly scrollTop: number;
+  readonly scrollLeft: number;
+  readonly scrollHeight: number;
+  readonly scrollWidth: number;
+  /** The change since the last event. */
+  readonly deltaX: number;
+  readonly deltaY: number;
+};
+type LynxScrollViewEventMap = WithPrefixes<{
+  bindscroll: LynxEvent<ScrollDetail>;
+  bindscrollend: LynxEvent<ScrollDetail>;
+  bindscrolltoupper: LynxEvent<ScrollDetail>;
+  bindscrolltolower: LynxEvent<ScrollDetail>;
+  bindscrolltoupperedge: LynxEvent<ScrollDetail>;
+  bindscrolltoloweredge: LynxEvent<ScrollDetail>;
+  bindscrolltonormalstate: LynxEvent<ScrollDetail>;
+  bindcontentsizechanged: LynxEvent<ScrollDetail>;
+}>;
+/** A rendered `<list-item>`'s position, relative to the list, in px. */
+type ListAttachedCell = {
+  readonly id: number;
+  readonly itemKey: string;
+  readonly index: number;
+  readonly left: number;
+  readonly top: number;
+  readonly right: number;
+  readonly bottom: number;
+};
+/** `<list>`'s `bindscroll`, `bindscrolltoupper` and `bindscrolltolower` detail. */
+type ListScrollDetail = ScrollDetail & {
+  readonly listWidth: number;
+  readonly listHeight: number;
+  /** What scrolled the list: `0` a data update, `1` layout, `2` scrolling. */
+  readonly eventSource: 0 | 1 | 2;
+  /** The rendered items. Only with `need-visible-item-info`. */
+  readonly attachedCells?: readonly ListAttachedCell[];
+};
+/** `<list>`'s `bindscrollstatechange` detail (iOS and Android). */
+type ListScrollStateChangeDetail = {
+  /** `1` stopped, `2` dragging, `3` slowing down, `4` animating. */
+  readonly state: 1 | 2 | 3 | 4;
+};
+/** An item in `<list>`'s `bindlayoutcomplete` detail. */
+type ListItemInfo = {
+  readonly width: number;
+  readonly height: number;
+  readonly itemKey: string;
+  /** Whether the item is rendered. */
+  readonly isBinding: boolean;
+  /** The item's position in the whole scroll area, in px. */
+  readonly originX: number;
+  readonly originY: number;
+  readonly updated: boolean;
+};
+/**
+ * `<list>`'s `bindlayoutcomplete` detail. Every field but `layout-id` needs
+ * `need-layout-complete-info`.
+ */
+type ListLayoutCompleteDetail = {
+  /** The list's `layout-id` attribute, or `-1`. */
+  readonly 'layout-id': number;
+  readonly scrollInfo?: ListScrollDetail;
+  /** The indexes the data update inserted, moved, removed and updated. */
+  readonly diffResult?: {
+    readonly insertions: readonly number[];
+    readonly move_from: readonly number[];
+    readonly move_to: readonly number[];
+    readonly removals: readonly number[];
+    readonly update_from: readonly number[];
+    readonly update_to: readonly number[];
+  };
+  readonly visibleItemBeforeUpdate?: readonly ListItemInfo[];
+  readonly visibleItemAfterUpdate?: readonly ListItemInfo[];
+};
+/** `<list>`'s `bindsnap` detail, with `item-snap`: where it's about to snap. */
+type ListSnapDetail = {
+  /** The index of the item it snaps to. */
+  readonly position: number;
+  readonly currentScrollTop: number;
+  readonly currentScrollLeft: number;
+  readonly targetScrollTop: number;
+  readonly targetScrollLeft: number;
+};
+type LynxListEventMap = WithPrefixes<{
+  bindscroll: LynxEvent<ListScrollDetail>;
+  bindscrolltoupper: LynxEvent<ListScrollDetail>;
+  bindscrolltolower: LynxEvent<ListScrollDetail>;
+  bindscrollstatechange: LynxEvent<ListScrollStateChangeDetail>;
+  bindlayoutcomplete: LynxEvent<ListLayoutCompleteDetail>;
+  bindsnap: LynxEvent<ListSnapDetail>;
+}>;
+/** `<frame>`'s `bindload` detail: how loading the embedded bundle went. */
+type FrameLoadDetail = {
+  readonly url: string;
+  readonly statusCode: number;
+  readonly statusMessage: string;
+};
+/**
+ * `<frame>`'s `bindloadmetrics` detail: load timings the embedded page
+ * reports (iOS and Android, Lynx 3.9 and later).
+ */
+type FrameLoadMetricsDetail = {
+  readonly url: string;
+  readonly mode: string;
+  readonly entry: Readonly<Record<string, unknown>>;
+};
+type LynxFrameEventMap = WithPrefixes<{
+  bindload: LynxEvent<FrameLoadDetail>;
+  bindloadmetrics: LynxEvent<FrameLoadMetricsDetail>;
+}>;
+/** `<overlay>`'s `bindoverlaytouch` detail (iOS and Android). */
+type OverlayTouchDetail = {
+  /** Relative to the window. */
+  readonly x: number;
+  readonly y: number;
+  /** `0` down, `1` move, `2` up, `3` cancel. */
+  readonly state: 0 | 1 | 2 | 3;
+};
+/** `<overlay>`'s `binderror` detail (Android). */
+type OverlayErrorDetail = {
+  readonly errorCode: string;
+  readonly errorMsg: string;
+};
+type LynxOverlayEventMap = WithPrefixes<{
+  bindshowoverlay: LynxEvent;
+  binddismissoverlay: LynxEvent;
+  bindrequestclose: LynxEvent;
+  bindoverlaytouch: LynxEvent<OverlayTouchDetail>;
+  binderror: LynxEvent<OverlayErrorDetail>;
+}>;
+/** `<refresh>`'s `bindstartrefresh` detail. */
+type RefreshStartDetail = {
+  /** `true` when the user pulled. */
+  readonly isManual: boolean;
+};
+/** `<refresh>`'s `bindheaderoffset` detail. */
+type RefreshHeaderOffsetDetail = {
+  readonly isDragging: boolean;
+  /** The pull distance divided by the header's height. */
+  readonly offsetPercent: number;
+};
+/** `<refresh>`'s `bindrefreshstatechange` detail. */
+type RefreshStateChangeDetail = {
+  /** `0` idle, `1` pulled far enough to release, `2` refreshing. */
+  readonly state: 0 | 1 | 2;
+};
+type LynxRefreshEventMap = WithPrefixes<{
+  bindstartrefresh: LynxEvent<RefreshStartDetail>;
+  bindheaderoffset: LynxEvent<RefreshHeaderOffsetDetail>;
+  bindrefreshstatechange: LynxEvent<RefreshStateChangeDetail>;
+}>;
+/** `<scroll-coordinator>`'s `bindoffset` detail, in px. */
+type ScrollCoordinatorOffsetDetail = {
+  /** How far the header has folded. */
+  readonly offset: number;
+  /** How far it can fold: the header's height minus the toolbar's. */
+  readonly height: number;
+};
+type LynxScrollCoordinatorEventMap = WithPrefixes<{
+  bindoffset: LynxEvent<ScrollCoordinatorOffsetDetail>;
+}>;
+/** `<video>`'s `bindfirstframe` detail. */
+type VideoFirstFrameDetail = {
+  /** In seconds. */
+  readonly duration: number;
+};
+/** `<video>`'s `bindtimeupdate` detail, in seconds. */
+type VideoTimeUpdateDetail = {
+  readonly current: number;
+  readonly duration: number;
+};
+/** `<video>`'s `bindbuffering` detail. */
+type VideoBufferingDetail = {
+  /** How far the video has loaded, in seconds. */
+  readonly buffering: number;
+};
+/** `<video>`'s `binderror` detail. */
+type VideoErrorDetail = {
+  readonly errorCode: number;
+  readonly errorMsg: string;
+};
+type LynxVideoEventMap = WithPrefixes<{
+  bindfirstframe: LynxEvent<VideoFirstFrameDetail>;
+  bindtimeupdate: LynxEvent<VideoTimeUpdateDetail>;
+  bindbuffering: LynxEvent<VideoBufferingDetail>;
+  binderror: LynxEvent<VideoErrorDetail>;
+  bindplaying: LynxEvent;
+  bindpaused: LynxEvent;
+  bindstopped: LynxEvent;
+  bindended: LynxEvent;
+  bindlooped: LynxEvent;
+}>;
+/** `<viewpager>`'s `bindchange` and `bindwillchange` detail. */
+type ViewPagerChangeDetail = {
+  readonly index: number;
+  /** `true` when the user swiped there. */
+  readonly isDragged: boolean;
+};
+/** `<viewpager>`'s `bindoffsetchange` detail. */
+type ViewPagerOffsetChangeDetail = {
+  /** The position in pages: `0.5` is halfway between pages 0 and 1. */
+  readonly offset: number;
+};
+type LynxViewPagerEventMap = WithPrefixes<{
+  bindchange: LynxEvent<ViewPagerChangeDetail>;
+  bindwillchange: LynxEvent<ViewPagerChangeDetail>;
+  bindoffsetchange: LynxEvent<ViewPagerOffsetChangeDetail>;
+}>;
+/** `<webview>`'s `binderror` detail. */
+type WebViewErrorDetail = {
+  readonly errorCode: number;
+  readonly errorMsg: string;
+};
+/** `<webview>`'s `bindmessage` detail: what the page sent. */
+type WebViewMessageDetail = {
+  readonly msg: string;
+};
+/** `<webview>`'s `bindopenwindow` and `bindlocationchange` detail (Clay). */
+type WebViewUrlDetail = {
+  readonly url: string;
+};
+type LynxWebViewEventMap = WithPrefixes<{
+  bindload: LynxEvent;
+  binderror: LynxEvent<WebViewErrorDetail>;
+  bindmessage: LynxEvent<WebViewMessageDetail>;
+  bindopenwindow: LynxEvent<WebViewUrlDetail>;
+  bindlocationchange: LynxEvent<WebViewUrlDetail>;
+}>;
+/**
+ * A Lynx-only tag, such as `image`, as Angular's template checker sees it:
+ * an `HTMLElement` whose listeners also know the tag's own events. It's an
+ * interface so that these overloads come before `HTMLElement`'s, whose
+ * `string` overload would otherwise match first and type `$event` as `Event`.
+ */
+interface LynxTagElement<Events> extends HTMLElement {
+  addEventListener<Name extends keyof (Events & HTMLElementEventMap)>(type: Name, listener: (this: LynxTagElement<Events>, event: (Events & HTMLElementEventMap)[Name]) => unknown, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener<Name extends keyof (Events & HTMLElementEventMap)>(type: Name, listener: (this: LynxTagElement<Events>, event: (Events & HTMLElementEventMap)[Name]) => unknown, options?: boolean | EventListenerOptions): void;
+  removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    image: LynxTagElement<LynxImageEventMap>;
+    text: LynxTagElement<LynxTextEventMap>;
+    'scroll-view': LynxTagElement<LynxScrollViewEventMap>;
+    list: LynxTagElement<LynxListEventMap>;
+    overlay: LynxTagElement<LynxOverlayEventMap>;
+    refresh: LynxTagElement<LynxRefreshEventMap>;
+    'scroll-coordinator': LynxTagElement<LynxScrollCoordinatorEventMap>;
+    viewpager: LynxTagElement<LynxViewPagerEventMap>;
+    webview: LynxTagElement<LynxWebViewEventMap>;
+    ':svg:svg': LynxTagElement<LynxSvgEventMap>;
+  }
+  interface HTMLInputElement {
+    addEventListener<Name extends keyof LynxInputEventMap>(type: Name, listener: (this: HTMLInputElement, event: LynxInputEventMap[Name]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<Name extends keyof LynxInputEventMap>(type: Name, listener: (this: HTMLInputElement, event: LynxInputEventMap[Name]) => unknown, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLTextAreaElement {
+    addEventListener<Name extends keyof LynxTextareaEventMap>(type: Name, listener: (this: HTMLTextAreaElement, event: LynxTextareaEventMap[Name]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<Name extends keyof LynxTextareaEventMap>(type: Name, listener: (this: HTMLTextAreaElement, event: LynxTextareaEventMap[Name]) => unknown, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLVideoElement {
+    addEventListener<Name extends keyof LynxVideoEventMap>(type: Name, listener: (this: HTMLVideoElement, event: LynxVideoEventMap[Name]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<Name extends keyof LynxVideoEventMap>(type: Name, listener: (this: HTMLVideoElement, event: LynxVideoEventMap[Name]) => unknown, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLFrameElement {
+    addEventListener<Name extends keyof LynxFrameEventMap>(type: Name, listener: (this: HTMLFrameElement, event: LynxFrameEventMap[Name]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<Name extends keyof LynxFrameEventMap>(type: Name, listener: (this: HTMLFrameElement, event: LynxFrameEventMap[Name]) => unknown, options?: boolean | EventListenerOptions): void;
+  }
+}
 /**
  * ControlValueAccessor for <input> elements. Bridges Angular's form model
  * (reactive forms, template-driven NgModel, Signal Forms [formField]) to Lynx's
@@ -1702,7 +2245,7 @@ export declare class LynxCoverView extends LynxElementBase {
  */
 export declare class LynxInputValueAccessor implements ControlValueAccessor {
   #private;
-  onInput(event: Event): void;
+  onInput(event: LynxEvent<InputDetail>): void;
   onBlur(): void;
   writeValue(value: string): void;
   registerOnChange(fn: (value: string) => void): void;
@@ -1721,7 +2264,7 @@ export declare class LynxInputValueAccessor implements ControlValueAccessor {
  */
 export declare class LynxTextareaValueAccessor implements ControlValueAccessor {
   #private;
-  onInput(event: Event): void;
+  onInput(event: LynxEvent<InputDetail>): void;
   onBlur(): void;
   writeValue(value: string): void;
   registerOnChange(fn: (value: string) => void): void;
@@ -3236,186 +3779,425 @@ type BaseLynxElement = Pick<Element$1, 'setAttribute'> & {
    */
   invoke(methodName: string, params?: Record<string, unknown>): void;
 };
-export declare class LynxLogger {
-  #private;
-  log(...args: unknown[]): void;
-  warn(...args: unknown[]): void;
-  error(...args: unknown[]): void;
-  info(...args: unknown[]): void;
-  debug(...args: unknown[]): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<LynxLogger, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
 /**
- * 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}. 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: {
- *       setStorageItem(key: string, value: string): void;
- *       getStorageItem(key: string, callback: (value: string) => void): void;
- *       clearStorage(): void;
- *     };
- *   }
- * }
- * ```
+ * The listener registry behind the `document` and `window` stand-ins (see
+ * global-events.ts): `addEventListener()`, `removeEventListener()` and
+ * `dispatchEvent()` as a DOM EventTarget has them, for Lynx's main thread,
+ * which has no EventTarget.
+ *
+ * Code written for the browser listens on these two objects without checking
+ * they can be listened on: Angular's `document:`/`window:` host listeners,
+ * RxJS's `fromEvent(document, …)`, and libraries that close a menu on a
+ * `click` anywhere. So the registry keeps the DOM's rules, which such code
+ * relies on: a listener added twice runs once, `once` and `signal` remove
+ * it, an object's `handleEvent()` is called, a listener removed by an
+ * earlier one doesn't run, and one that throws doesn't stop the others.
+ */
+/** A listener, as addEventListener takes it. */
+type EventListenerLike = ((event: any) => unknown) | {
+  handleEvent(event: any): unknown;
+};
+/** The third argument of addEventListener and removeEventListener. */
+type ListenerOptionsLike = boolean | {
+  capture?: boolean;
+  once?: boolean;
+  passive?: boolean;
+  signal?: AbortSignalLike;
+};
+type AbortSignalLike = {
+  readonly aborted: boolean;
+  addEventListener(type: 'abort', listener: () => void): void;
+  removeEventListener?(type: 'abort', listener: () => void): void;
+};
+/** `Event.eventPhase`'s values. */
+declare const CAPTURING_PHASE = 1;
+declare const AT_TARGET = 2;
+declare const BUBBLING_PHASE = 3;
+/**
+ * What the listeners of one dispatch did to it, across the targets it goes
+ * through.
  */
-interface NativeModuleMap {}
+type PropagationState = {
+  stopped: boolean;
+  stoppedImmediately: boolean;
+};
 /**
- * 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.
+ * Sets a property of an event object, whatever kind it is: a DOM Event's
+ * `target` and `currentTarget` are getters on its prototype, which an own
+ * property shadows.
  */
-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; };
+declare const setEventProperty: (event: object, name: string, value: unknown) => void;
 /**
- * Wraps the Lynx native module bridge and JS module registry as an Angular injectable.
- *
- * **Native modules** (`NativeModules` global) let JS code call native platform
- * functions (iOS / Android / HarmonyOS). The host app registers modules on the
- * native side; this service provides typed access from Angular.
- *
- * **JS modules** (`lynx.getJSModule` / `lynx.registerModule`) share JavaScript
- * 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);
- *
- * // Call a native method (Promise-based wrapper over bridge.call)
- * const result = await modules.call<string>('getDeviceId', {});
- *
- * // Listen for native events
- * modules.on('onDeepLink', (url) => console.log(url));
- *
- * // Access a typed custom native module
- * const storage = modules.getNativeModule('NativeLocalStorageModule');
- * storage?.setStorageItem('key', 'value');
- *
- * // JS module sharing within the LynxView
- * modules.registerJSModule('mySharedState', { count: 0 });
- * const state = modules.getJSModule<{ count: number }>('mySharedState');
- * ```
+ * One object's listeners. `owner` is the object they're added to, which
+ * listeners see as the event's `currentTarget`: the document stand-in is its
+ * own, and the window's is `globalThis`.
  */
-export declare class LynxNativeModule {
+declare class GlobalEventTarget {
   #private;
+  constructor(owner?: object);
   /**
-   * Calls a native method via `NativeModules.bridge.call()`.
-   *
-   * The native callback API is wrapped in a Promise for ergonomic
-   * use with `async`/`await`.
-   *
-   * Resolves `undefined` when there is no bridge (web preview, tests).
+   * @internal Called whenever the set of types with listeners changes, so
+   * the events for them can be listened for (see global-events.ts).
    */
-  call<T = unknown>(name: string, params?: Record<string, unknown>): Promise<T | undefined>;
+  set onTypesChange(callback: () => void);
+  addEventListener(type: string, callback: EventListenerLike | null | undefined, options?: ListenerOptionsLike): void;
+  removeEventListener(type: string, callback: EventListenerLike | null | undefined, options?: ListenerOptionsLike): void;
   /**
-   * 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 there is no bridge.
+   * Dispatches `event` to this object's own listeners, as the DOM does for
+   * an object with no parent. The document stand-in overrides it, since the
+   * window is its parent.
    */
-  on(name: string, callback: (...args: unknown[]) => void): void;
+  dispatchEvent(event: any): boolean;
   /**
-   * Retrieves a custom native module by name from the `NativeModules` global.
-   *
-   * Augment the {@link NativeModuleMap} interface for type-safe access:
-   *
-   * ```typescript
-   * export {};
-   *
-   * declare module '@blotch/angular-lynx' {
-   *   interface NativeModuleMap {
-   *     NativeLocalStorageModule: { ... };
-   *   }
-   * }
-   *
-   * const storage = modules.getNativeModule('NativeLocalStorageModule');
-   * ```
-   *
-   * 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.
+   * The types that have a listener.
    */
-  getNativeModule<K extends string>(name: K): K extends keyof NativeModuleMap ? NativeModuleProxy<NativeModuleMap[K]> | undefined : unknown;
+  get types(): string[];
+  hasListeners(type: string): boolean;
   /**
-   * Retrieves a JS module registered within this LynxView.
-   *
-   * This wraps `lynx.getJSModule()` — the same API used internally
-   * for `GlobalEventEmitter`. On the main thread it returns a proxy, as
-   * getNativeModule() does.
-   *
-   * Returns `undefined` when `lynx` is unavailable or, on the background
-   * thread, when the module is not registered.
+   * The object listeners are added to, which they see as currentTarget.
    */
-  getJSModule<T = unknown>(name: string): T | undefined;
+  get owner(): object;
   /**
-   * Registers a JS module for sharing within this LynxView.
-   *
-   * Other code (including native callbacks) can retrieve it via
-   * `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.
+   * @internal Runs this object's listeners for `type` in `phase`: the
+   * capturing ones in the capturing phase, the others in the bubbling one,
+   * and both at the target, capturing first, as Chrome and Firefox do.
+   * `type` is passed apart from the event, since a Lynx `tap` reaches the
+   * listeners for `click`.
    */
-  registerJSModule<T extends object>(name: string, module: T): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<LynxNativeModule, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+  invoke(type: string, event: any, phase: number, state: PropagationState): void;
 }
-declare class LynxElement implements BaseLynxElement {
+/**
+ * One event's dispatch at `target` through `path`, the listening objects
+ * from the target's side out (document, then window): capturing listeners
+ * from the outside in, then the others from the inside out, if the event
+ * bubbles. When the target is the first object of the path, as for
+ * `dispatchEvent()`, its listeners run at the target, in the bubbling half.
+ *
+ * Otherwise the target is an element, and the event a screen event (see
+ * global-events.ts), whose two halves run apart: the capturing one before
+ * the elements' own listeners, and the bubbling one after them, as a
+ * browser runs a document's listeners.
+ *
+ * `type` is the listeners' type, which defaults to the event's own.
+ */
+declare class PathDispatch {
   #private;
-  get element(): ElementRef;
-  tagName: string;
+  constructor(event: any, target: object, path: GlobalEventTarget[], type?: string);
   /**
-   * When true, this element is the root page element and must not be
-   * re-parented (appendChild/insertBefore) or removed from the tree.
-   * Angular calls appendChild/remove as part of normal component lifecycle,
-   * but the page element is the immutable root — moving or removing it
-   * would corrupt the native element tree.
+   * Runs the capturing listeners of the objects around the target.
    */
-  isRootPageElement: boolean;
+  capture(): void;
   /**
-   * Virtual tree tracking — used when parent manages children outside the
-   * native element tree (e.g., list manages children via componentAtIndex
-   * callbacks rather than __AppendElement)
+   * Runs the target's listeners, if it's in the path, then the bubbling
+   * listeners around it. Returns false if a listener canceled the event, as
+   * dispatchEvent does.
    */
-  _virtualParent: LynxElement | null;
-  _virtualPrev: LynxElement | null;
-  _virtualNext: LynxElement | null;
-  constructor(element: ElementRef);
-  /**
-   * Drops this wrapper's current native id from the registry. Called when the
+  bubble(): boolean;
+}
+/**
+ * Dispatches `event` at `target` through `path` at once (see PathDispatch).
+ */
+declare const dispatchThrough: (event: any, target: object, path: GlobalEventTarget[]) => boolean;
+/**
+ * `document` and `window` as event targets, for Lynx's main thread.
+ *
+ * Angular resolves a `document:` or `body:` host listener's target from the
+ * host element's `ownerDocument`, and a `window:` one from its
+ * `ownerDocument.defaultView`. Lynx elements had no `ownerDocument`, so a
+ * component with a global listener threw "not a function" as it was created.
+ * Now a LynxElement's `ownerDocument` is the LynxGlobalDocument below, which
+ * is also the `DOCUMENT` token's value and, on iOS and Android, the
+ * `document` global. Its `defaultView` is `globalThis`, the `window` global
+ * on Lynx, whose listeners are this hub's `window` (see window.ts).
+ *
+ * Both hear what a browser's document and window do: the events of a touch
+ * anywhere on screen (see native-source.ts, and web-source.ts for Lynx for
+ * Web), and on the window, `resize` when the LynxView changes size.
+ *
+ * A browser runs a document's capturing listeners before the touched
+ * element's, and its other listeners after them. Lynx runs a `global-bind`
+ * listener, which hears a touch wherever it lands, before every other
+ * (see "A popover that leaves the screen usable" in
+ * investigations/lynx-vs-web-differences.md). So a screen event's dispatch
+ * runs in two halves (see PathDispatch): `early()` runs the capturing
+ * listeners when the event begins, and `late()` the others when it reaches
+ * the page element, the last of the elements it goes through, after the
+ * page's own listeners. An event an
+ * element's `catch` listener stopped never reaches the page, so its second
+ * half runs on the next timer, after every listener of that event.
+ */
+/** What the hub needs of the page element: its LynxElement. */
+type GlobalEventsPage = {
+  /** The native element: a DOM element on Lynx for Web. */
+  readonly element: unknown;
+  addEventListener(name: string, listener: (event: any) => unknown): () => void;
+  /** Adds a listener that runs after the page's others for the event. */
+  addTrailingEventListener(name: string, listener: (event: any) => unknown): () => void;
+};
+/** The element wrapper with a unique id, for a screen event's target. */
+type ElementLookup = (uniqueId: number) => object | undefined;
+type ViewportSize = {
+  readonly width: number;
+  readonly height: number;
+};
+/** An event to dispatch through the document and window. */
+type Delivery = {
+  /** The listeners' type: a Lynx `tap` reaches the ones for `click`. */
+  readonly type: string;
+  readonly event: any;
+  /** The element the event happened on. */
+  readonly target: object;
+};
+/** Where a platform's screen events come from. */
+type ScreenSource = {
+  /**
+   * Listens on `page` for the events of `types`, and stops listening for
+   * the others, or on a page that's gone.
+   */
+  sync(page: GlobalEventsPage | null, types: ReadonlySet<string>): void;
+  /**
+   * The LynxView's size now, where it can be read at any time (the web
+   * preview). Otherwise it's the last `resized()` one.
+   */
+  viewport?(): ViewportSize | null;
+};
+/**
+ * The `document` stand-in. Only what code written for the browser reaches
+ * for on a document it can't do without: listening, `defaultView`, `body`,
+ * and the queries Angular makes of it, which find nothing, as Lynx's
+ * elements come from templates.
+ */
+declare class LynxGlobalDocument extends GlobalEventTarget {
+  #private;
+  constructor(events: GlobalEvents);
+  /**
+   * The window, as a document's is: `globalThis` on Lynx.
+   */
+  get defaultView(): any;
+  /**
+   * The page element, which every element is in, as a browser's body is, so
+   * a `body:` listener hears the events that bubble up to it. Null until
+   * the app's root element is made, as `document.body` is before a page's
+   * body is parsed.
+   */
+  get body(): GlobalEventsPage | null;
+  /**
+   * TransferState's root factory calls
+   * `inject(DOCUMENT).getElementById(APP_ID + '-state')` to restore the
+   * `<script>` Angular SSR inlines. `resource()` and `httpResource()` inject
+   * TransferState on construction. Lynx never has that script (AngularLynx
+   * SSR hydrates from its own element snapshot), so `null`, "no transferred
+   * state", is the right answer, not just a stub.
+   */
+  getElementById(_id: string): null;
+  /**
+   * Angular's getBaseHrefFromDOM() calls `document.querySelector('base')`.
+   * Null makes it fall back to APP_BASE_HREF (see provideRenderer).
+   */
+  querySelector(_selector: string): null;
+  querySelectorAll(_selector: string): never[];
+  /**
+   * A document's event bubbles to its window, as in the DOM.
+   */
+  dispatchEvent(event: any): boolean;
+}
+/**
+ * The screen's size in CSS pixels, from SystemInfo's physical pixels: what
+ * `innerWidth` and `innerHeight` are until the LynxView's first layout
+ * reports its own.
+ */
+declare const screenViewport: () => ViewportSize;
+declare class GlobalEvents {
+  #private;
+  readonly window: GlobalEventTarget;
+  readonly document: LynxGlobalDocument;
+  /**
+   * @param windowObject The window, which listeners see as currentTarget:
+   *   `globalThis`.
+   * @param createSource Makes the platform's ScreenSource.
+   */
+  constructor(windowObject: object, createSource: (events: GlobalEvents) => ScreenSource);
+  /**
+   * Makes `page` the one screen events come from: the root element of the
+   * app that was bootstrapped last (see LynxDocument.createRootElement).
+   * `lookup` finds the element a touch landed on.
+   */
+  attach(page: GlobalEventsPage, lookup: ElementLookup): void;
+  get page(): GlobalEventsPage | null;
+  /**
+   * The LynxView's size, for `innerWidth` and `innerHeight`.
+   */
+  get viewport(): ViewportSize | null;
+  /**
+   * Whether the document or the window has a listener for `type`.
+   */
+  hasListeners(type: string): boolean;
+  /**
+   * The wrapper of the element with this unique id: a screen event's
+   * target. Every touch is on the page, so it's the page when the element
+   * has no wrapper, and the document only before there's a page.
+   */
+  targetFor(uniqueId: number | undefined): object;
+  /**
+   * A screen event begins: runs the capturing listeners of each delivery,
+   * and keeps the others for late(), or the next timer. `key` names the
+   * event for late(): its name natively, where each event has its own
+   * objects per listener, and the DOM event on the web.
+   */
+  early(key: unknown, deliveries: Delivery[]): void;
+  /**
+   * The screen event `key` reached the page: runs its other listeners.
+   */
+  late(key: unknown): void;
+  /**
+   * Runs the second halves of the screen events still pending. Natively,
+   * one event's listeners all run before the next event begins, so one still
+   * pending when the next begins was stopped on its way to the page, and its
+   * listeners run before the next one's, in the order the events happened.
+   */
+  finishPending(): void;
+  /**
+   * The LynxView changed size: fires `resize` on the window. Lynx also
+   * reports the size after the first layout, which a browser has no event
+   * for, so the size `innerWidth` and `innerHeight` already said, the
+   * screen's until then, fires nothing.
+   */
+  resized(size: ViewportSize): void;
+}
+/**
+ * The window's half of global-events.ts, on `globalThis`, which is the
+ * window on Lynx's main thread: the polyfills make `window` point to it, and
+ * the document's `defaultView` is it.
+ *
+ * On iOS and Android it has no `addEventListener` of its own (only the
+ * polyfills' no-op), so all its listeners are the hub's. Where it's a
+ * browser's window, which it is in the web preview (a hidden iframe's) and
+ * in jsdom tests, the hub takes the screen's events (SCREEN_EVENTS) and the
+ * window keeps the others, such as `message`.
+ *
+ * `innerWidth` and `innerHeight` are the LynxView's size (see
+ * GlobalEvents.viewport): before the first layout reports it, the screen's,
+ * from SystemInfo. jsdom keeps its own.
+ */
+/** The events of the screen, which the hub's window hears. */
+declare const SCREEN_EVENTS: ReadonlySet<string>;
+/**
+ * Makes `events.window` the window's listeners on `target` (`globalThis`),
+ * and its `innerWidth` and `innerHeight` the LynxView's.
+ */
+declare const installGlobalWindow: (target: Record<string | symbol, any>, events: GlobalEvents) => void;
+/**
+ * Makes `events.document` the `document` global where there isn't a DOM
+ * one: on iOS and Android, where the polyfills give it a placeholder. In
+ * the web preview and in jsdom tests, `document` stays the browser's, and
+ * only `ownerDocument` and `DOCUMENT` are the hub's.
+ */
+declare const installGlobalDocument: (target: Record<string, any>, events: GlobalEvents) => void;
+/**
+ * The app's `document` and `window` events (see global-events.ts).
+ */
+declare const globalEvents: () => GlobalEvents;
+/**
+ * An element's layout, kept from its `layoutchange` events, so code written
+ * for the DOM can read it synchronously: `getBoundingClientRect()`,
+ * `clientWidth` and friends, and `ResizeObserver`.
+ *
+ * Lynx lays elements out on its own and has no synchronous layout read on
+ * the main thread: the `boundingClientRect` UI method answers later. What it
+ * does have is `layoutchange`, which an element with a listener for it fires
+ * after each layout that moved or resized it, with its box relative to the
+ * LynxView. An element starts listening when something first needs its
+ * layout; until the first event arrives (or the UI method answers), the box
+ * is empty, as a DOM element's is before it's rendered.
+ */
+/** An element's box, relative to the LynxView, in px. */
+type LayoutRect = {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+};
+/** The DOMRect `getBoundingClientRect()` returns. */
+type LynxDOMRect = {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+  readonly top: number;
+  readonly right: number;
+  readonly bottom: number;
+  readonly left: number;
+  toJSON(): Omit<LynxDOMRect, 'toJSON'>;
+};
+declare const toDOMRect: (rect: LayoutRect | null) => LynxDOMRect;
+/**
+ * Asks native for a native element's box now, relative to the LynxView: the
+ * `boundingClientRect` UI method. It answers later, with null if the element
+ * has no UI to measure (it was never flushed, or it's gone).
+ */
+declare const measureLayout: (element: unknown, callback: (rect: LayoutRect | null) => void) => void;
+/** What the tracker needs from its element. */
+type LayoutHost = {
+  /** Adds a listener for one of the element's Lynx events (`bindlayoutchange`). */
+  listen(name: string, listener: (event: any) => void): () => void;
+  /** Asks native for the element's box now (the `boundingClientRect` UI method). */
+  measure(callback: (rect: LayoutRect | null) => void): void;
+};
+declare class LayoutTracker {
+  #private;
+  rect: LayoutRect | null;
+  constructor(host: LayoutHost);
+  /**
+   * Listens for the element's layouts from now on. An element already laid
+   * out before this won't fire `layoutchange` again until it changes, so the
+   * box it has now is asked for too.
+   */
+  start(): void;
+  /**
+   * Calls `observer` with each new box, from the next layout on.
+   */
+  observe(observer: (rect: LayoutRect) => void): () => void;
+}
+declare class LynxElement implements BaseLynxElement {
+  #private;
+  get element(): ElementRef;
+  tagName: string;
+  /**
+   * When true, this element is the root page element and must not be
+   * re-parented (appendChild/insertBefore) or removed from the tree.
+   * Angular calls appendChild/remove as part of normal component lifecycle,
+   * but the page element is the immutable root — moving or removing it
+   * would corrupt the native element tree.
+   */
+  isRootPageElement: boolean;
+  /**
+   * Virtual tree tracking — used when parent manages children outside the
+   * native element tree (e.g., list manages children via componentAtIndex
+   * callbacks rather than __AppendElement)
+   */
+  _virtualParent: LynxElement | null;
+  _virtualPrev: LynxElement | null;
+  _virtualNext: LynxElement | null;
+  /**
+   * @internal The canonical wrapper of the element with this unique id, if
+   * it has one: the target of a touch the document heard (see
+   * global-events/native-source.ts), which names the element by its id.
+   */
+  static byUniqueId(uniqueId: number): LynxElement | undefined;
+  constructor(element: ElementRef);
+  /**
+   * Drops this wrapper's current native id from the registry. Called when the
    * native ref is swapped (recreate-on-remount) for the STALE id, and by the
    * renderer's destroyNode when Angular tears the element down, so the registry
    * doesn't retain wrappers for dead native refs.
    */
   deregisterNative(): void;
+  /**
+   * The document stand-in (see global-events), as a DOM element's is its
+   * document. Angular resolves a `document:` or `body:` host listener's
+   * target from it, and a `window:` one from its `defaultView`.
+   */
+  get ownerDocument(): LynxGlobalDocument;
   setProperty(name: string, value: any): void;
   /**
    * Seeds the cached text for a raw-text element so #recreateSubtree() can
@@ -3521,79 +4303,1583 @@ declare class LynxElement implements BaseLynxElement {
   invoke(methodName: string, params?: Record<string, unknown>): void;
   animate(keyframes: Record<string, string | number>[], options?: number | LynxAnimationOptions): LynxAnimation;
   /**
-   * 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. 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.
+   * 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. 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;
+  /**
+   * @internal Adds a listener for a Lynx event name (`bindtap`, …) that runs
+   * after the element's other listeners for the event, whenever they were
+   * added. The document's listeners hear the end of a touch from the page
+   * element this way (see global-events/native-source.ts), so they run after
+   * the page's own, the root component's host listeners and `body:` ones,
+   * as a browser runs a document's listeners after its body's.
+   */
+  addTrailingEventListener(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;
+  /**
+   * Makes `pointerId`'s events this element's until it lifts, as a DOM
+   * element's method does. A Lynx touch always goes to the element it
+   * started on, so this changes only `hasPointerCapture()` and fires
+   * `gotpointercapture` (see pointer-events.ts).
+   */
+  setPointerCapture(pointerId: number): void;
+  releasePointerCapture(pointerId: number): void;
+  hasPointerCapture(pointerId: number): boolean;
+  /**
+   * The element's box relative to the LynxView, now, as a DOM element's
+   * method answers. Lynx has no synchronous layout read, so this is the box
+   * from the element's last `layoutchange` (see layout.ts): the first call
+   * starts listening, and the box is empty until the element's next layout.
+   * Code that needs it from the start can call `observeLayout()`, or use
+   * `ResizeObserver`. On Lynx for Web it's the DOM element's own.
+   */
+  getBoundingClientRect(): LynxDOMRect;
+  /**
+   * The element's width, from its last layout (see getBoundingClientRect).
+   */
+  get clientWidth(): number;
+  get clientHeight(): number;
+  get offsetWidth(): number;
+  get offsetHeight(): number;
+  /**
+   * Calls `observer` with the element's box after each layout that moves or
+   * resizes it, from the next one on. What `ResizeObserver` is built on.
+   * Returns a function that stops it.
+   */
+  observeLayout(observer: (rect: LayoutRect) => void): () => void;
+  /**
+   * The box from the element's last layout, or null before the first.
+   */
+  get layoutRect(): LayoutRect | null;
+}
+/**
+ * Commits all queued genuine element removals — a free-function wrapper over
+ * `LynxElement.commitPendingRemovals()` so `LynxRendererFactory2.end()` can
+ * drain them (via the lynx-element barrel) right before `__FlushElementTree()`,
+ * keeping removals in the same flush as the cycle's other mutations.
+ */
+declare const processPendingRemovals: () => void;
+/**
+ * Commits this cycle's attribute removals (see LynxElement's
+ * `#removedAttributes`). A free-function wrapper over
+ * `LynxElement.commitPendingAttributeRemovals()` so
+ * `LynxRendererFactory2.end()` can drain them (via the lynx-element barrel)
+ * right after element removals and before `__FlushElementTree()`.
+ */
+declare const processPendingAttributeRemovals: () => void;
+/**
+ * Re-derives positional edge whitespace for every text touched this cycle — a
+ * free-function wrapper over `LynxElement.commitPendingTextNormalization()` so
+ * `LynxRendererFactory2.end()` can drain it (via the lynx-element barrel) right
+ * after removals and before `__FlushElementTree()`, keeping the corrected text in
+ * the same flush as the cycle's other mutations. See #pendingTextNormalization.
+ */
+declare const processPendingTextNormalization: () => void;
+/**
+ * Safety-net flush for native mutations made OUTSIDE a begin()/end() change-
+ * detection cycle. `LynxRendererFactory2.end()` calls `__FlushElementTree()`
+ * once per CD tick, which is what commits (lays out + paints) the cycle's
+ * element mutations. But a lazy-loaded route component is instantiated by
+ * `RouterOutlet` DURING navigation — outside any such cycle — so its freshly
+ * created elements land in the fiber tree yet are never flushed. On-device
+ * symptom: the route's static shell renders, but its `@if`/`@for`/interpolation
+ * content stays invisible until an unrelated CD (e.g. a tap) triggers the next
+ * end() flush. (Bootstrap sidesteps this via native's implicit post-renderPage
+ * 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 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:
+ *  - inside a CD cycle — end() will flush;
+ *  - the first render is pending — native flushes after renderPage, and any
+ *    `<list>` defers its own first flush (see isFirstRenderPending()).
+ * The near-no-op cost when nothing is layout-dirty (the core's `need_layout_`
+ * gate) keeps the steady-state overhead negligible.
+ */
+declare const scheduleSettleFlush: () => void;
+/**
+ * Bytes as Lynx's native-module bridge carries them, which has no binary
+ * type: an `ArrayBuffer` arrives as an empty map, a returned `NSData` crashes
+ * the main thread's PrimJS, and a string ends at its first NUL (measured on
+ * Lynx 4.1). So bytes cross as an array of their 32-bit little-endian words,
+ * zero-padded, with the byte count last: `Array.from(new Uint32Array(...))`
+ * builds it at C speed, and every device Lynx runs on is little-endian, so the
+ * words land in memory as the bytes were. The WebGL bridge
+ * (canvas/webgl-bridge.ts) and the bundled-asset reader (bundled-asset.ts)
+ * use it, and the shells' modules read and write it.
+ */
+/** Bytes to send. The count goes last because appending is O(1). */
+declare const toWords: (bytes: Uint8Array) => number[];
+/**
+ * A list a native module returned, as a plain array of numbers. On iOS, Lynx
+ * hands native arrays back as array-likes that `.map()` reads but a typed
+ * array's constructor sees as empty.
+ */
+declare const numbersFrom: (value: unknown) => number[];
+/** Bytes back from words. */
+declare const fromWords: (words: unknown) => Uint8Array;
+/**
+ * The native side of `<canvas>`'s WebGL2 context: the `AngularLynxWebGL`
+ * module that the iOS and Android shells register (`AngularLynxWebGL.m`,
+ * `WebGLModule.kt`), which runs the calls on OpenGL ES 3.0.
+ *
+ * Angular runs on Lynx's main thread, and WebGL is synchronous: a program's
+ * link status, a uniform's location and the like are return values. Lynx's
+ * background-thread `NativeModules` can't answer those, and the relay to them
+ * (background-call.ts) is asynchronous. So the shells turn on Lynx's
+ * main-thread modules (`enableMTSModule`), which main-thread code calls as
+ * `lynx.module(name).invoke(method, ...args)`, synchronously, on the UI
+ * thread, where GL runs.
+ *
+ * A call costs a few microseconds on Android and about 80 on iOS, where Lynx
+ * logs every module call. So the context doesn't make one per GL call: it
+ * records the calls into an array of commands and sends them in one `run`,
+ * once a frame or when a call needs an answer (see LynxWebGL2RenderingContext).
+ *
+ * What crosses the bridge, as measured on Lynx 4.1: numbers, strings, arrays
+ * and plain objects. An `ArrayBuffer` or typed array arrives as an empty map,
+ * a returned `NSData` crashes the main thread's PrimJS, and a string ends at
+ * its first NUL. So bytes (buffer data, pixels, image files) cross as arrays
+ * of 32-bit words, which `Array.from(new Uint32Array(buffer))` builds at C
+ * speed and the native side reads back into memory (see toWords()).
+ */
+/** The module's name in both shells. */
+declare const WEBGL_MODULE_NAME = "AngularLynxWebGL";
+/** What `create` returns: the drawing buffer the shell made, or why not. */
+type WebGLCreateResult = {
+  /** The GL context was made: OpenGL ES 3.0 is available. */
+  ok: boolean;
+  /** Why it wasn't, when `ok` is false. */
+  error?: string;
+};
+/** What `decodeImage` returns. */
+type DecodedImage = {
+  width: number;
+  height: number;
+  /** Set instead of the size when the bytes aren't an image the OS decodes. */
+  error?: string;
+};
+/**
+ * The module's methods. `run` returns one result per query command in the
+ * batch, in order; void commands return nothing.
+ */
+type WebGLBridge = {
+  create(contextId: number, canvasId: string, attributes: Record<string, unknown>): WebGLCreateResult;
+  run(contextId: number, commands: unknown[]): unknown[];
+  destroy(contextId: number): void;
+  decodeImage(imageId: number, bytes: number[], options: Record<string, unknown>): DecodedImage;
+  releaseImage(imageId: number): void;
+};
+/**
+ * Replaces the native bridge, for tests: a fake GL that records commands.
+ * `undefined` restores the real one.
+ */
+declare const setWebGLBridgeForTesting: (bridge: WebGLBridge | null | undefined) => void;
+/**
+ * The bridge, or null where there's no WebGL: a host without the module (Lynx
+ * Explorer, an app built before this shell), the web preview (which draws in
+ * the browser's own canvas), and tests.
+ */
+declare const getWebGLBridge: () => WebGLBridge | null;
+/** The bytes a typed array or buffer views, as a Uint8Array over them. */
+declare const bytesOf: (data: ArrayBufferView | ArrayBuffer, elementOffset?: number, elementLength?: number) => Uint8Array;
+/**
+ * The WebGL 1 and 2 constants, as WebGL2RenderingContext has them: on the
+ * context, its prototype and the constructor. Taken from TypeScript's
+ * lib.dom.d.ts (WebGLRenderingContextBase and WebGL2RenderingContextBase), the
+ * spec's IDL; regenerate it from there rather than editing by hand.
+ */
+declare const WEBGL2_CONSTANTS: {
+  readonly DEPTH_BUFFER_BIT: 256;
+  readonly STENCIL_BUFFER_BIT: 1024;
+  readonly COLOR_BUFFER_BIT: 16384;
+  readonly POINTS: 0;
+  readonly LINES: 1;
+  readonly LINE_LOOP: 2;
+  readonly LINE_STRIP: 3;
+  readonly TRIANGLES: 4;
+  readonly TRIANGLE_STRIP: 5;
+  readonly TRIANGLE_FAN: 6;
+  readonly ZERO: 0;
+  readonly ONE: 1;
+  readonly SRC_COLOR: 768;
+  readonly ONE_MINUS_SRC_COLOR: 769;
+  readonly SRC_ALPHA: 770;
+  readonly ONE_MINUS_SRC_ALPHA: 771;
+  readonly DST_ALPHA: 772;
+  readonly ONE_MINUS_DST_ALPHA: 773;
+  readonly DST_COLOR: 774;
+  readonly ONE_MINUS_DST_COLOR: 775;
+  readonly SRC_ALPHA_SATURATE: 776;
+  readonly FUNC_ADD: 32774;
+  readonly BLEND_EQUATION: 32777;
+  readonly BLEND_EQUATION_RGB: 32777;
+  readonly BLEND_EQUATION_ALPHA: 34877;
+  readonly FUNC_SUBTRACT: 32778;
+  readonly FUNC_REVERSE_SUBTRACT: 32779;
+  readonly BLEND_DST_RGB: 32968;
+  readonly BLEND_SRC_RGB: 32969;
+  readonly BLEND_DST_ALPHA: 32970;
+  readonly BLEND_SRC_ALPHA: 32971;
+  readonly CONSTANT_COLOR: 32769;
+  readonly ONE_MINUS_CONSTANT_COLOR: 32770;
+  readonly CONSTANT_ALPHA: 32771;
+  readonly ONE_MINUS_CONSTANT_ALPHA: 32772;
+  readonly BLEND_COLOR: 32773;
+  readonly ARRAY_BUFFER: 34962;
+  readonly ELEMENT_ARRAY_BUFFER: 34963;
+  readonly ARRAY_BUFFER_BINDING: 34964;
+  readonly ELEMENT_ARRAY_BUFFER_BINDING: 34965;
+  readonly STREAM_DRAW: 35040;
+  readonly STATIC_DRAW: 35044;
+  readonly DYNAMIC_DRAW: 35048;
+  readonly BUFFER_SIZE: 34660;
+  readonly BUFFER_USAGE: 34661;
+  readonly CURRENT_VERTEX_ATTRIB: 34342;
+  readonly FRONT: 1028;
+  readonly BACK: 1029;
+  readonly FRONT_AND_BACK: 1032;
+  readonly CULL_FACE: 2884;
+  readonly BLEND: 3042;
+  readonly DITHER: 3024;
+  readonly STENCIL_TEST: 2960;
+  readonly DEPTH_TEST: 2929;
+  readonly SCISSOR_TEST: 3089;
+  readonly POLYGON_OFFSET_FILL: 32823;
+  readonly SAMPLE_ALPHA_TO_COVERAGE: 32926;
+  readonly SAMPLE_COVERAGE: 32928;
+  readonly NO_ERROR: 0;
+  readonly INVALID_ENUM: 1280;
+  readonly INVALID_VALUE: 1281;
+  readonly INVALID_OPERATION: 1282;
+  readonly OUT_OF_MEMORY: 1285;
+  readonly CW: 2304;
+  readonly CCW: 2305;
+  readonly LINE_WIDTH: 2849;
+  readonly ALIASED_POINT_SIZE_RANGE: 33901;
+  readonly ALIASED_LINE_WIDTH_RANGE: 33902;
+  readonly CULL_FACE_MODE: 2885;
+  readonly FRONT_FACE: 2886;
+  readonly DEPTH_RANGE: 2928;
+  readonly DEPTH_WRITEMASK: 2930;
+  readonly DEPTH_CLEAR_VALUE: 2931;
+  readonly DEPTH_FUNC: 2932;
+  readonly STENCIL_CLEAR_VALUE: 2961;
+  readonly STENCIL_FUNC: 2962;
+  readonly STENCIL_FAIL: 2964;
+  readonly STENCIL_PASS_DEPTH_FAIL: 2965;
+  readonly STENCIL_PASS_DEPTH_PASS: 2966;
+  readonly STENCIL_REF: 2967;
+  readonly STENCIL_VALUE_MASK: 2963;
+  readonly STENCIL_WRITEMASK: 2968;
+  readonly STENCIL_BACK_FUNC: 34816;
+  readonly STENCIL_BACK_FAIL: 34817;
+  readonly STENCIL_BACK_PASS_DEPTH_FAIL: 34818;
+  readonly STENCIL_BACK_PASS_DEPTH_PASS: 34819;
+  readonly STENCIL_BACK_REF: 36003;
+  readonly STENCIL_BACK_VALUE_MASK: 36004;
+  readonly STENCIL_BACK_WRITEMASK: 36005;
+  readonly VIEWPORT: 2978;
+  readonly SCISSOR_BOX: 3088;
+  readonly COLOR_CLEAR_VALUE: 3106;
+  readonly COLOR_WRITEMASK: 3107;
+  readonly UNPACK_ALIGNMENT: 3317;
+  readonly PACK_ALIGNMENT: 3333;
+  readonly MAX_TEXTURE_SIZE: 3379;
+  readonly MAX_VIEWPORT_DIMS: 3386;
+  readonly SUBPIXEL_BITS: 3408;
+  readonly RED_BITS: 3410;
+  readonly GREEN_BITS: 3411;
+  readonly BLUE_BITS: 3412;
+  readonly ALPHA_BITS: 3413;
+  readonly DEPTH_BITS: 3414;
+  readonly STENCIL_BITS: 3415;
+  readonly POLYGON_OFFSET_UNITS: 10752;
+  readonly POLYGON_OFFSET_FACTOR: 32824;
+  readonly TEXTURE_BINDING_2D: 32873;
+  readonly SAMPLE_BUFFERS: 32936;
+  readonly SAMPLES: 32937;
+  readonly SAMPLE_COVERAGE_VALUE: 32938;
+  readonly SAMPLE_COVERAGE_INVERT: 32939;
+  readonly COMPRESSED_TEXTURE_FORMATS: 34467;
+  readonly DONT_CARE: 4352;
+  readonly FASTEST: 4353;
+  readonly NICEST: 4354;
+  readonly GENERATE_MIPMAP_HINT: 33170;
+  readonly BYTE: 5120;
+  readonly UNSIGNED_BYTE: 5121;
+  readonly SHORT: 5122;
+  readonly UNSIGNED_SHORT: 5123;
+  readonly INT: 5124;
+  readonly UNSIGNED_INT: 5125;
+  readonly FLOAT: 5126;
+  readonly DEPTH_COMPONENT: 6402;
+  readonly ALPHA: 6406;
+  readonly RGB: 6407;
+  readonly RGBA: 6408;
+  readonly LUMINANCE: 6409;
+  readonly LUMINANCE_ALPHA: 6410;
+  readonly UNSIGNED_SHORT_4_4_4_4: 32819;
+  readonly UNSIGNED_SHORT_5_5_5_1: 32820;
+  readonly UNSIGNED_SHORT_5_6_5: 33635;
+  readonly FRAGMENT_SHADER: 35632;
+  readonly VERTEX_SHADER: 35633;
+  readonly MAX_VERTEX_ATTRIBS: 34921;
+  readonly MAX_VERTEX_UNIFORM_VECTORS: 36347;
+  readonly MAX_VARYING_VECTORS: 36348;
+  readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661;
+  readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660;
+  readonly MAX_TEXTURE_IMAGE_UNITS: 34930;
+  readonly MAX_FRAGMENT_UNIFORM_VECTORS: 36349;
+  readonly SHADER_TYPE: 35663;
+  readonly DELETE_STATUS: 35712;
+  readonly LINK_STATUS: 35714;
+  readonly VALIDATE_STATUS: 35715;
+  readonly ATTACHED_SHADERS: 35717;
+  readonly ACTIVE_UNIFORMS: 35718;
+  readonly ACTIVE_ATTRIBUTES: 35721;
+  readonly SHADING_LANGUAGE_VERSION: 35724;
+  readonly CURRENT_PROGRAM: 35725;
+  readonly NEVER: 512;
+  readonly LESS: 513;
+  readonly EQUAL: 514;
+  readonly LEQUAL: 515;
+  readonly GREATER: 516;
+  readonly NOTEQUAL: 517;
+  readonly GEQUAL: 518;
+  readonly ALWAYS: 519;
+  readonly KEEP: 7680;
+  readonly REPLACE: 7681;
+  readonly INCR: 7682;
+  readonly DECR: 7683;
+  readonly INVERT: 5386;
+  readonly INCR_WRAP: 34055;
+  readonly DECR_WRAP: 34056;
+  readonly VENDOR: 7936;
+  readonly RENDERER: 7937;
+  readonly VERSION: 7938;
+  readonly NEAREST: 9728;
+  readonly LINEAR: 9729;
+  readonly NEAREST_MIPMAP_NEAREST: 9984;
+  readonly LINEAR_MIPMAP_NEAREST: 9985;
+  readonly NEAREST_MIPMAP_LINEAR: 9986;
+  readonly LINEAR_MIPMAP_LINEAR: 9987;
+  readonly TEXTURE_MAG_FILTER: 10240;
+  readonly TEXTURE_MIN_FILTER: 10241;
+  readonly TEXTURE_WRAP_S: 10242;
+  readonly TEXTURE_WRAP_T: 10243;
+  readonly TEXTURE_2D: 3553;
+  readonly TEXTURE: 5890;
+  readonly TEXTURE_CUBE_MAP: 34067;
+  readonly TEXTURE_BINDING_CUBE_MAP: 34068;
+  readonly TEXTURE_CUBE_MAP_POSITIVE_X: 34069;
+  readonly TEXTURE_CUBE_MAP_NEGATIVE_X: 34070;
+  readonly TEXTURE_CUBE_MAP_POSITIVE_Y: 34071;
+  readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072;
+  readonly TEXTURE_CUBE_MAP_POSITIVE_Z: 34073;
+  readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074;
+  readonly MAX_CUBE_MAP_TEXTURE_SIZE: 34076;
+  readonly TEXTURE0: 33984;
+  readonly TEXTURE1: 33985;
+  readonly TEXTURE2: 33986;
+  readonly TEXTURE3: 33987;
+  readonly TEXTURE4: 33988;
+  readonly TEXTURE5: 33989;
+  readonly TEXTURE6: 33990;
+  readonly TEXTURE7: 33991;
+  readonly TEXTURE8: 33992;
+  readonly TEXTURE9: 33993;
+  readonly TEXTURE10: 33994;
+  readonly TEXTURE11: 33995;
+  readonly TEXTURE12: 33996;
+  readonly TEXTURE13: 33997;
+  readonly TEXTURE14: 33998;
+  readonly TEXTURE15: 33999;
+  readonly TEXTURE16: 34000;
+  readonly TEXTURE17: 34001;
+  readonly TEXTURE18: 34002;
+  readonly TEXTURE19: 34003;
+  readonly TEXTURE20: 34004;
+  readonly TEXTURE21: 34005;
+  readonly TEXTURE22: 34006;
+  readonly TEXTURE23: 34007;
+  readonly TEXTURE24: 34008;
+  readonly TEXTURE25: 34009;
+  readonly TEXTURE26: 34010;
+  readonly TEXTURE27: 34011;
+  readonly TEXTURE28: 34012;
+  readonly TEXTURE29: 34013;
+  readonly TEXTURE30: 34014;
+  readonly TEXTURE31: 34015;
+  readonly ACTIVE_TEXTURE: 34016;
+  readonly REPEAT: 10497;
+  readonly CLAMP_TO_EDGE: 33071;
+  readonly MIRRORED_REPEAT: 33648;
+  readonly FLOAT_VEC2: 35664;
+  readonly FLOAT_VEC3: 35665;
+  readonly FLOAT_VEC4: 35666;
+  readonly INT_VEC2: 35667;
+  readonly INT_VEC3: 35668;
+  readonly INT_VEC4: 35669;
+  readonly BOOL: 35670;
+  readonly BOOL_VEC2: 35671;
+  readonly BOOL_VEC3: 35672;
+  readonly BOOL_VEC4: 35673;
+  readonly FLOAT_MAT2: 35674;
+  readonly FLOAT_MAT3: 35675;
+  readonly FLOAT_MAT4: 35676;
+  readonly SAMPLER_2D: 35678;
+  readonly SAMPLER_CUBE: 35680;
+  readonly VERTEX_ATTRIB_ARRAY_ENABLED: 34338;
+  readonly VERTEX_ATTRIB_ARRAY_SIZE: 34339;
+  readonly VERTEX_ATTRIB_ARRAY_STRIDE: 34340;
+  readonly VERTEX_ATTRIB_ARRAY_TYPE: 34341;
+  readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922;
+  readonly VERTEX_ATTRIB_ARRAY_POINTER: 34373;
+  readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975;
+  readonly IMPLEMENTATION_COLOR_READ_TYPE: 35738;
+  readonly IMPLEMENTATION_COLOR_READ_FORMAT: 35739;
+  readonly COMPILE_STATUS: 35713;
+  readonly LOW_FLOAT: 36336;
+  readonly MEDIUM_FLOAT: 36337;
+  readonly HIGH_FLOAT: 36338;
+  readonly LOW_INT: 36339;
+  readonly MEDIUM_INT: 36340;
+  readonly HIGH_INT: 36341;
+  readonly FRAMEBUFFER: 36160;
+  readonly RENDERBUFFER: 36161;
+  readonly RGBA4: 32854;
+  readonly RGB5_A1: 32855;
+  readonly RGBA8: 32856;
+  readonly RGB565: 36194;
+  readonly DEPTH_COMPONENT16: 33189;
+  readonly STENCIL_INDEX8: 36168;
+  readonly DEPTH_STENCIL: 34041;
+  readonly RENDERBUFFER_WIDTH: 36162;
+  readonly RENDERBUFFER_HEIGHT: 36163;
+  readonly RENDERBUFFER_INTERNAL_FORMAT: 36164;
+  readonly RENDERBUFFER_RED_SIZE: 36176;
+  readonly RENDERBUFFER_GREEN_SIZE: 36177;
+  readonly RENDERBUFFER_BLUE_SIZE: 36178;
+  readonly RENDERBUFFER_ALPHA_SIZE: 36179;
+  readonly RENDERBUFFER_DEPTH_SIZE: 36180;
+  readonly RENDERBUFFER_STENCIL_SIZE: 36181;
+  readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048;
+  readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049;
+  readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050;
+  readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051;
+  readonly COLOR_ATTACHMENT0: 36064;
+  readonly DEPTH_ATTACHMENT: 36096;
+  readonly STENCIL_ATTACHMENT: 36128;
+  readonly DEPTH_STENCIL_ATTACHMENT: 33306;
+  readonly NONE: 0;
+  readonly FRAMEBUFFER_COMPLETE: 36053;
+  readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054;
+  readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055;
+  readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057;
+  readonly FRAMEBUFFER_UNSUPPORTED: 36061;
+  readonly FRAMEBUFFER_BINDING: 36006;
+  readonly RENDERBUFFER_BINDING: 36007;
+  readonly MAX_RENDERBUFFER_SIZE: 34024;
+  readonly INVALID_FRAMEBUFFER_OPERATION: 1286;
+  readonly UNPACK_FLIP_Y_WEBGL: 37440;
+  readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441;
+  readonly CONTEXT_LOST_WEBGL: 37442;
+  readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443;
+  readonly BROWSER_DEFAULT_WEBGL: 37444;
+  readonly READ_BUFFER: 3074;
+  readonly UNPACK_ROW_LENGTH: 3314;
+  readonly UNPACK_SKIP_ROWS: 3315;
+  readonly UNPACK_SKIP_PIXELS: 3316;
+  readonly PACK_ROW_LENGTH: 3330;
+  readonly PACK_SKIP_ROWS: 3331;
+  readonly PACK_SKIP_PIXELS: 3332;
+  readonly COLOR: 6144;
+  readonly DEPTH: 6145;
+  readonly STENCIL: 6146;
+  readonly RED: 6403;
+  readonly RGB8: 32849;
+  readonly RGB10_A2: 32857;
+  readonly TEXTURE_BINDING_3D: 32874;
+  readonly UNPACK_SKIP_IMAGES: 32877;
+  readonly UNPACK_IMAGE_HEIGHT: 32878;
+  readonly TEXTURE_3D: 32879;
+  readonly TEXTURE_WRAP_R: 32882;
+  readonly MAX_3D_TEXTURE_SIZE: 32883;
+  readonly UNSIGNED_INT_2_10_10_10_REV: 33640;
+  readonly MAX_ELEMENTS_VERTICES: 33000;
+  readonly MAX_ELEMENTS_INDICES: 33001;
+  readonly TEXTURE_MIN_LOD: 33082;
+  readonly TEXTURE_MAX_LOD: 33083;
+  readonly TEXTURE_BASE_LEVEL: 33084;
+  readonly TEXTURE_MAX_LEVEL: 33085;
+  readonly MIN: 32775;
+  readonly MAX: 32776;
+  readonly DEPTH_COMPONENT24: 33190;
+  readonly MAX_TEXTURE_LOD_BIAS: 34045;
+  readonly TEXTURE_COMPARE_MODE: 34892;
+  readonly TEXTURE_COMPARE_FUNC: 34893;
+  readonly CURRENT_QUERY: 34917;
+  readonly QUERY_RESULT: 34918;
+  readonly QUERY_RESULT_AVAILABLE: 34919;
+  readonly STREAM_READ: 35041;
+  readonly STREAM_COPY: 35042;
+  readonly STATIC_READ: 35045;
+  readonly STATIC_COPY: 35046;
+  readonly DYNAMIC_READ: 35049;
+  readonly DYNAMIC_COPY: 35050;
+  readonly MAX_DRAW_BUFFERS: 34852;
+  readonly DRAW_BUFFER0: 34853;
+  readonly DRAW_BUFFER1: 34854;
+  readonly DRAW_BUFFER2: 34855;
+  readonly DRAW_BUFFER3: 34856;
+  readonly DRAW_BUFFER4: 34857;
+  readonly DRAW_BUFFER5: 34858;
+  readonly DRAW_BUFFER6: 34859;
+  readonly DRAW_BUFFER7: 34860;
+  readonly DRAW_BUFFER8: 34861;
+  readonly DRAW_BUFFER9: 34862;
+  readonly DRAW_BUFFER10: 34863;
+  readonly DRAW_BUFFER11: 34864;
+  readonly DRAW_BUFFER12: 34865;
+  readonly DRAW_BUFFER13: 34866;
+  readonly DRAW_BUFFER14: 34867;
+  readonly DRAW_BUFFER15: 34868;
+  readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657;
+  readonly MAX_VERTEX_UNIFORM_COMPONENTS: 35658;
+  readonly SAMPLER_3D: 35679;
+  readonly SAMPLER_2D_SHADOW: 35682;
+  readonly FRAGMENT_SHADER_DERIVATIVE_HINT: 35723;
+  readonly PIXEL_PACK_BUFFER: 35051;
+  readonly PIXEL_UNPACK_BUFFER: 35052;
+  readonly PIXEL_PACK_BUFFER_BINDING: 35053;
+  readonly PIXEL_UNPACK_BUFFER_BINDING: 35055;
+  readonly SRGB: 35904;
+  readonly SRGB8: 35905;
+  readonly SRGB8_ALPHA8: 35907;
+  readonly COMPARE_REF_TO_TEXTURE: 34894;
+  readonly RGBA32F: 34836;
+  readonly RGB32F: 34837;
+  readonly RGBA16F: 34842;
+  readonly RGB16F: 34843;
+  readonly VERTEX_ATTRIB_ARRAY_INTEGER: 35069;
+  readonly MAX_ARRAY_TEXTURE_LAYERS: 35071;
+  readonly MIN_PROGRAM_TEXEL_OFFSET: 35076;
+  readonly MAX_PROGRAM_TEXEL_OFFSET: 35077;
+  readonly MAX_VARYING_COMPONENTS: 35659;
+  readonly TEXTURE_2D_ARRAY: 35866;
+  readonly TEXTURE_BINDING_2D_ARRAY: 35869;
+  readonly R11F_G11F_B10F: 35898;
+  readonly UNSIGNED_INT_10F_11F_11F_REV: 35899;
+  readonly RGB9_E5: 35901;
+  readonly UNSIGNED_INT_5_9_9_9_REV: 35902;
+  readonly TRANSFORM_FEEDBACK_BUFFER_MODE: 35967;
+  readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968;
+  readonly TRANSFORM_FEEDBACK_VARYINGS: 35971;
+  readonly TRANSFORM_FEEDBACK_BUFFER_START: 35972;
+  readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973;
+  readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976;
+  readonly RASTERIZER_DISCARD: 35977;
+  readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978;
+  readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979;
+  readonly INTERLEAVED_ATTRIBS: 35980;
+  readonly SEPARATE_ATTRIBS: 35981;
+  readonly TRANSFORM_FEEDBACK_BUFFER: 35982;
+  readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983;
+  readonly RGBA32UI: 36208;
+  readonly RGB32UI: 36209;
+  readonly RGBA16UI: 36214;
+  readonly RGB16UI: 36215;
+  readonly RGBA8UI: 36220;
+  readonly RGB8UI: 36221;
+  readonly RGBA32I: 36226;
+  readonly RGB32I: 36227;
+  readonly RGBA16I: 36232;
+  readonly RGB16I: 36233;
+  readonly RGBA8I: 36238;
+  readonly RGB8I: 36239;
+  readonly RED_INTEGER: 36244;
+  readonly RGB_INTEGER: 36248;
+  readonly RGBA_INTEGER: 36249;
+  readonly SAMPLER_2D_ARRAY: 36289;
+  readonly SAMPLER_2D_ARRAY_SHADOW: 36292;
+  readonly SAMPLER_CUBE_SHADOW: 36293;
+  readonly UNSIGNED_INT_VEC2: 36294;
+  readonly UNSIGNED_INT_VEC3: 36295;
+  readonly UNSIGNED_INT_VEC4: 36296;
+  readonly INT_SAMPLER_2D: 36298;
+  readonly INT_SAMPLER_3D: 36299;
+  readonly INT_SAMPLER_CUBE: 36300;
+  readonly INT_SAMPLER_2D_ARRAY: 36303;
+  readonly UNSIGNED_INT_SAMPLER_2D: 36306;
+  readonly UNSIGNED_INT_SAMPLER_3D: 36307;
+  readonly UNSIGNED_INT_SAMPLER_CUBE: 36308;
+  readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311;
+  readonly DEPTH_COMPONENT32F: 36012;
+  readonly DEPTH32F_STENCIL8: 36013;
+  readonly FLOAT_32_UNSIGNED_INT_24_8_REV: 36269;
+  readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296;
+  readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297;
+  readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298;
+  readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299;
+  readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300;
+  readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301;
+  readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302;
+  readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303;
+  readonly FRAMEBUFFER_DEFAULT: 33304;
+  readonly UNSIGNED_INT_24_8: 34042;
+  readonly DEPTH24_STENCIL8: 35056;
+  readonly UNSIGNED_NORMALIZED: 35863;
+  readonly DRAW_FRAMEBUFFER_BINDING: 36006;
+  readonly READ_FRAMEBUFFER: 36008;
+  readonly DRAW_FRAMEBUFFER: 36009;
+  readonly READ_FRAMEBUFFER_BINDING: 36010;
+  readonly RENDERBUFFER_SAMPLES: 36011;
+  readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052;
+  readonly MAX_COLOR_ATTACHMENTS: 36063;
+  readonly COLOR_ATTACHMENT1: 36065;
+  readonly COLOR_ATTACHMENT2: 36066;
+  readonly COLOR_ATTACHMENT3: 36067;
+  readonly COLOR_ATTACHMENT4: 36068;
+  readonly COLOR_ATTACHMENT5: 36069;
+  readonly COLOR_ATTACHMENT6: 36070;
+  readonly COLOR_ATTACHMENT7: 36071;
+  readonly COLOR_ATTACHMENT8: 36072;
+  readonly COLOR_ATTACHMENT9: 36073;
+  readonly COLOR_ATTACHMENT10: 36074;
+  readonly COLOR_ATTACHMENT11: 36075;
+  readonly COLOR_ATTACHMENT12: 36076;
+  readonly COLOR_ATTACHMENT13: 36077;
+  readonly COLOR_ATTACHMENT14: 36078;
+  readonly COLOR_ATTACHMENT15: 36079;
+  readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182;
+  readonly MAX_SAMPLES: 36183;
+  readonly HALF_FLOAT: 5131;
+  readonly RG: 33319;
+  readonly RG_INTEGER: 33320;
+  readonly R8: 33321;
+  readonly RG8: 33323;
+  readonly R16F: 33325;
+  readonly R32F: 33326;
+  readonly RG16F: 33327;
+  readonly RG32F: 33328;
+  readonly R8I: 33329;
+  readonly R8UI: 33330;
+  readonly R16I: 33331;
+  readonly R16UI: 33332;
+  readonly R32I: 33333;
+  readonly R32UI: 33334;
+  readonly RG8I: 33335;
+  readonly RG8UI: 33336;
+  readonly RG16I: 33337;
+  readonly RG16UI: 33338;
+  readonly RG32I: 33339;
+  readonly RG32UI: 33340;
+  readonly VERTEX_ARRAY_BINDING: 34229;
+  readonly R8_SNORM: 36756;
+  readonly RG8_SNORM: 36757;
+  readonly RGB8_SNORM: 36758;
+  readonly RGBA8_SNORM: 36759;
+  readonly SIGNED_NORMALIZED: 36764;
+  readonly COPY_READ_BUFFER: 36662;
+  readonly COPY_WRITE_BUFFER: 36663;
+  readonly COPY_READ_BUFFER_BINDING: 36662;
+  readonly COPY_WRITE_BUFFER_BINDING: 36663;
+  readonly UNIFORM_BUFFER: 35345;
+  readonly UNIFORM_BUFFER_BINDING: 35368;
+  readonly UNIFORM_BUFFER_START: 35369;
+  readonly UNIFORM_BUFFER_SIZE: 35370;
+  readonly MAX_VERTEX_UNIFORM_BLOCKS: 35371;
+  readonly MAX_FRAGMENT_UNIFORM_BLOCKS: 35373;
+  readonly MAX_COMBINED_UNIFORM_BLOCKS: 35374;
+  readonly MAX_UNIFORM_BUFFER_BINDINGS: 35375;
+  readonly MAX_UNIFORM_BLOCK_SIZE: 35376;
+  readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377;
+  readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379;
+  readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380;
+  readonly ACTIVE_UNIFORM_BLOCKS: 35382;
+  readonly UNIFORM_TYPE: 35383;
+  readonly UNIFORM_SIZE: 35384;
+  readonly UNIFORM_BLOCK_INDEX: 35386;
+  readonly UNIFORM_OFFSET: 35387;
+  readonly UNIFORM_ARRAY_STRIDE: 35388;
+  readonly UNIFORM_MATRIX_STRIDE: 35389;
+  readonly UNIFORM_IS_ROW_MAJOR: 35390;
+  readonly UNIFORM_BLOCK_BINDING: 35391;
+  readonly UNIFORM_BLOCK_DATA_SIZE: 35392;
+  readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394;
+  readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395;
+  readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396;
+  readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398;
+  readonly INVALID_INDEX: 4294967295;
+  readonly MAX_VERTEX_OUTPUT_COMPONENTS: 37154;
+  readonly MAX_FRAGMENT_INPUT_COMPONENTS: 37157;
+  readonly MAX_SERVER_WAIT_TIMEOUT: 37137;
+  readonly OBJECT_TYPE: 37138;
+  readonly SYNC_CONDITION: 37139;
+  readonly SYNC_STATUS: 37140;
+  readonly SYNC_FLAGS: 37141;
+  readonly SYNC_FENCE: 37142;
+  readonly SYNC_GPU_COMMANDS_COMPLETE: 37143;
+  readonly UNSIGNALED: 37144;
+  readonly SIGNALED: 37145;
+  readonly ALREADY_SIGNALED: 37146;
+  readonly TIMEOUT_EXPIRED: 37147;
+  readonly CONDITION_SATISFIED: 37148;
+  readonly WAIT_FAILED: 37149;
+  readonly SYNC_FLUSH_COMMANDS_BIT: 1;
+  readonly VERTEX_ATTRIB_ARRAY_DIVISOR: 35070;
+  readonly ANY_SAMPLES_PASSED: 35887;
+  readonly ANY_SAMPLES_PASSED_CONSERVATIVE: 36202;
+  readonly SAMPLER_BINDING: 35097;
+  readonly RGB10_A2UI: 36975;
+  readonly INT_2_10_10_10_REV: 36255;
+  readonly TRANSFORM_FEEDBACK: 36386;
+  readonly TRANSFORM_FEEDBACK_PAUSED: 36387;
+  readonly TRANSFORM_FEEDBACK_ACTIVE: 36388;
+  readonly TRANSFORM_FEEDBACK_BINDING: 36389;
+  readonly TEXTURE_IMMUTABLE_FORMAT: 37167;
+  readonly MAX_ELEMENT_INDEX: 36203;
+  readonly TEXTURE_IMMUTABLE_LEVELS: 33503;
+  readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 37447;
+};
+/**
+ * WebGL's object types, as the native context hands them out. Each is a
+ * handle: an id the JavaScript side picks when the object is created, which
+ * the shell maps to the GL name it made. Picking ids here means `createBuffer()`
+ * and friends return at once, with no round trip to native.
+ *
+ * Ids are unique across every kind of object in a context, and never reused,
+ * so a stale handle can't reach a newer object.
+ */
+declare class WebGLObjectHandle {
+  /** @internal */ readonly id: number;
+  /** @internal The context that made it, which alone may use it. */
+  readonly owner: object;
+  /** Set by delete*(): WebGL ignores a deleted object, and is*() is false. */
+  deleted: boolean;
+  constructor( /** @internal */ id: number,
+  /** @internal The context that made it, which alone may use it. */
+  owner: object);
+}
+declare class LynxWebGLBuffer extends WebGLObjectHandle {}
+declare class LynxWebGLFramebuffer extends WebGLObjectHandle {}
+declare class LynxWebGLRenderbuffer extends WebGLObjectHandle {}
+declare class LynxWebGLTexture extends WebGLObjectHandle {}
+declare class LynxWebGLVertexArrayObject extends WebGLObjectHandle {
+  /**
+   * The ELEMENT_ARRAY_BUFFER binding is part of a vertex array, so
+   * `getParameter(ELEMENT_ARRAY_BUFFER_BINDING)` answers from the bound one.
+   */
+  elementArrayBuffer: LynxWebGLBuffer | null;
+}
+declare class LynxWebGLQuery extends WebGLObjectHandle {}
+declare class LynxWebGLSampler extends WebGLObjectHandle {}
+declare class LynxWebGLSync extends WebGLObjectHandle {}
+declare class LynxWebGLTransformFeedback extends WebGLObjectHandle {}
+declare class LynxWebGLShader extends WebGLObjectHandle {
+  readonly type: number;
+  source: string;
+  /**
+   * The compile status and log, fetched from native once after each
+   * `compileShader` (see LynxWebGL2RenderingContext.#shaderInfo).
+   */
+  info: {
+    compiled: boolean;
+    log: string;
+  } | null;
+  constructor(id: number, owner: object, type: number);
+}
+/** One of `getProgramInfo`'s active uniforms or attributes. */
+type ActiveVariable = [name: string, size: number, type: number, location: number];
+/**
+ * A program's link results and reflection, fetched in one call after each
+ * `linkProgram` instead of one call per `getActiveUniform` and
+ * `getUniformLocation`: three.js asks for every uniform of every program.
+ */
+type ProgramInfo = {
+  linked: boolean;
+  log: string;
+  uniforms: ActiveVariable[];
+  attributes: ActiveVariable[];
+  uniformBlocks: number;
+  transformFeedbackVaryings: number;
+};
+declare class LynxWebGLProgram extends WebGLObjectHandle {
+  shaders: LynxWebGLShader[];
+  info: ProgramInfo | null;
+  /** Validation's result, which only validateProgram() updates. */
+  validated: boolean;
+  /** Uniform locations by name, for names reflection didn't list. */
+  locations: Map<string, LynxWebGLUniformLocation | null>;
+  /** Bumped by each link, which invalidates the old locations. */
+  linkCount: number;
+}
+/** A uniform's location: opaque to the app, the GL location to native. */
+declare class LynxWebGLUniformLocation {
+  /** @internal */ readonly program: LynxWebGLProgram;
+  /** @internal */ readonly location: number;
+  /** @internal */ readonly linkCount: number;
+  constructor( /** @internal */ program: LynxWebGLProgram, /** @internal */ location: number, /** @internal */ linkCount: number);
+}
+declare class LynxWebGLActiveInfo {
+  readonly name: string;
+  readonly size: number;
+  readonly type: number;
+  constructor(name: string, size: number, type: number);
+}
+declare class LynxWebGLShaderPrecisionFormat {
+  readonly rangeMin: number;
+  readonly rangeMax: number;
+  readonly precision: number;
+  constructor(rangeMin: number, rangeMax: number, precision: number);
+}
+/** The `<canvas>` a context draws into, as the context needs it. */
+type WebGLCanvasHost = {
+  readonly width: number;
+  readonly height: number;
+  /** Fires `webglcontextlost` and the like, which three.js listens for. */
+  dispatchContextEvent(type: string): boolean;
+};
+/** WebGLContextAttributes, with WebGL's defaults filled in. */
+type LynxWebGLContextAttributes = {
+  alpha: boolean;
+  antialias: boolean;
+  depth: boolean;
+  desynchronized: boolean;
+  failIfMajorPerformanceCaveat: boolean;
+  powerPreference: 'default' | 'high-performance' | 'low-power';
+  premultipliedAlpha: boolean;
+  preserveDrawingBuffer: boolean;
+  stencil: boolean;
+};
+declare const contextAttributesFrom: (requested: Partial<LynxWebGLContextAttributes> | undefined) => LynxWebGLContextAttributes;
+type NumberList = ArrayLike<number> & {
+  slice?: unknown;
+  subarray?: unknown;
+};
+/** Bytes per pixel of a format and type. */
+declare const pixelSize: (format: number, type: number) => number;
+/**
+ * `<canvas>`'s `getContext('webgl2')` on Lynx: the WebGL2RenderingContext API
+ * three.js and other WebGL libraries draw with, run on the shell's OpenGL ES
+ * 3.0 through the `AngularLynxWebGL` module (see webgl-bridge.ts).
+ *
+ * Calls that return nothing are recorded, not sent: `run` sends them all at
+ * once at the end of the task (a microtask), when a call needs an answer from
+ * the driver, or when many have piled up. So a frame of three.js, a few
+ * hundred calls, costs one bridge call. Calls that need an answer send the
+ * recorded ones first, so the driver sees everything in order.
+ *
+ * Most answers don't need the driver at all:
+ * - The limits (every `MAX_*` parameter and the like), the shader precisions
+ *   and the extensions are fetched in one call when the context is made.
+ * - Bindings (`getParameter(ARRAY_BUFFER_BINDING)` and the rest) are kept
+ *   here, as the objects the app passed, which the driver can't give back.
+ * - A program's link status, log, active uniforms and attributes and their
+ *   locations come in one call after each link (`programInfo`): three.js asks
+ *   for each of them for every program it builds.
+ *
+ * What WebGL adds to GLES, the context or the shell adds:
+ * - The default framebuffer (`bindFramebuffer(FRAMEBUFFER, null)`) is an
+ *   offscreen framebuffer the shell made at the canvas's `width` and
+ *   `height`, which it copies to the screen after each frame that drew to it
+ *   (the `present` command, sent when a task drew to it).
+ * - UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL: the shell flips
+ *   and premultiplies an image's pixels as it uploads them, and the context
+ *   does it to typed-array data before sending it.
+ * - Images: `texImage2D` with an ImageBitmap or an `<img>` uploads pixels the
+ *   shell decoded and kept (see image.ts), by id.
+ *
+ * Not there: context loss and restore (only `WEBGL_lose_context`'s loss,
+ * which three.js calls on dispose), a `<canvas>` or video as a texture
+ * source, and object answers from `getVertexAttrib` and `getIndexedParameter`
+ * (they return null).
+ */
+declare class LynxWebGL2RenderingContext {
+  #private;
+  readonly canvas: WebGLCanvasHost;
+  /** three.js sets these from `outputColorSpace`; the shell draws in sRGB. */
+  drawingBufferColorSpace: string;
+  unpackColorSpace: string;
+  constructor(bridge: WebGLBridge, contextId: number, canvas: WebGLCanvasHost, attributes: LynxWebGLContextAttributes);
+  /**
+   * --- The context ---------------------------------------------------------
+   */
+  get drawingBufferWidth(): number;
+  get drawingBufferHeight(): number;
+  /**
+   * @internal The canvas's width or height changed.
+   */
+  resize(width: number, height: number): void;
+  /**
+   * @internal The canvas left the page for good: free the GL context.
+   */
+  destroy(): void;
+  getContextAttributes(): LynxWebGLContextAttributes | null;
+  isContextLost(): boolean;
+  makeXRCompatible(): Promise<void>;
+  getSupportedExtensions(): string[] | null;
+  getExtension(name: string): object | null;
+  getError(): number;
+  /**
+   * --- State ---------------------------------------------------------------
+   */
+  getParameter(pname: number): unknown;
+  isEnabled(cap: number): boolean;
+  enable(cap: number): void;
+  disable(cap: number): void;
+  activeTexture(texture: number): void;
+  blendColor(red: number, green: number, blue: number, alpha: number): void;
+  blendEquation(mode: number): void;
+  blendEquationSeparate(modeRGB: number, modeAlpha: number): void;
+  blendFunc(sfactor: number, dfactor: number): void;
+  blendFuncSeparate(srcRGB: number, dstRGB: number, srcAlpha: number, dstAlpha: number): void;
+  clearColor(red: number, green: number, blue: number, alpha: number): void;
+  clearDepth(depth: number): void;
+  clearStencil(s: number): void;
+  colorMask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void;
+  cullFace(mode: number): void;
+  depthFunc(func: number): void;
+  depthMask(flag: boolean): void;
+  depthRange(zNear: number, zFar: number): void;
+  frontFace(mode: number): void;
+  hint(target: number, mode: number): void;
+  lineWidth(width: number): void;
+  pixelStorei(pname: number, param: number | boolean): void;
+  polygonOffset(factor: number, units: number): void;
+  sampleCoverage(value: number, invert: boolean): void;
+  scissor(x: number, y: number, width: number, height: number): void;
+  stencilFunc(func: number, ref: number, mask: number): void;
+  stencilFuncSeparate(face: number, func: number, ref: number, mask: number): void;
+  stencilMask(mask: number): void;
+  stencilMaskSeparate(face: number, mask: number): void;
+  stencilOp(fail: number, zfail: number, zpass: number): void;
+  stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void;
+  viewport(x: number, y: number, width: number, height: number): void;
+  getShaderPrecisionFormat(shadertype: number, precisiontype: number): LynxWebGLShaderPrecisionFormat | null;
+  /**
+   * --- Buffers -------------------------------------------------------------
+   */
+  createBuffer(): LynxWebGLBuffer;
+  deleteBuffer(buffer: LynxWebGLBuffer | null): void;
+  isBuffer(buffer: LynxWebGLBuffer | null): boolean;
+  bindBuffer(target: number, buffer: LynxWebGLBuffer | null): void;
+  bindBufferBase(target: number, index: number, buffer: LynxWebGLBuffer | null): void;
+  bindBufferRange(target: number, index: number, buffer: LynxWebGLBuffer | null, offset: number, size: number): void;
+  bufferData(target: number, sizeOrData: number | ArrayBufferView | ArrayBuffer | null, usage: number, srcOffset?: number, length?: number): void;
+  bufferSubData(target: number, dstByteOffset: number, srcData: ArrayBufferView | ArrayBuffer, srcOffset?: number, length?: number): void;
+  copyBufferSubData(readTarget: number, writeTarget: number, readOffset: number, writeOffset: number, size: number): void;
+  getBufferParameter(target: number, pname: number): unknown;
+  getBufferSubData(target: number, srcByteOffset: number, dstBuffer: ArrayBufferView, dstOffset?: number, length?: number): void;
+  /**
+   * --- Vertex arrays and attributes ---------------------------------------
+   */
+  createVertexArray(): LynxWebGLVertexArrayObject;
+  deleteVertexArray(vertexArray: LynxWebGLVertexArrayObject | null): void;
+  isVertexArray(vertexArray: LynxWebGLVertexArrayObject | null): boolean;
+  bindVertexArray(vertexArray: LynxWebGLVertexArrayObject | null): void;
+  enableVertexAttribArray(index: number): void;
+  disableVertexAttribArray(index: number): void;
+  vertexAttribPointer(index: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void;
+  vertexAttribIPointer(index: number, size: number, type: number, stride: number, offset: number): void;
+  vertexAttribDivisor(index: number, divisor: number): void;
+  vertexAttrib1f(index: number, x: number): void;
+  vertexAttrib2f(index: number, x: number, y: number): void;
+  vertexAttrib3f(index: number, x: number, y: number, z: number): void;
+  vertexAttrib4f(index: number, x: number, y: number, z: number, w: number): void;
+  vertexAttrib1fv(index: number, values: ArrayLike<number>): void;
+  vertexAttrib2fv(index: number, values: ArrayLike<number>): void;
+  vertexAttrib3fv(index: number, values: ArrayLike<number>): void;
+  vertexAttrib4fv(index: number, values: ArrayLike<number>): void;
+  vertexAttribI4i(index: number, x: number, y: number, z: number, w: number): void;
+  vertexAttribI4iv(index: number, values: ArrayLike<number>): void;
+  vertexAttribI4ui(index: number, x: number, y: number, z: number, w: number): void;
+  vertexAttribI4uiv(index: number, values: ArrayLike<number>): void;
+  getVertexAttrib(index: number, pname: number): unknown;
+  getVertexAttribOffset(index: number, pname: number): number;
+  /**
+   * --- Drawing -------------------------------------------------------------
+   */
+  clear(mask: number): void;
+  clearBufferfv(buffer: number, drawbuffer: number, values: NumberList, srcOffset?: number): void;
+  clearBufferiv(buffer: number, drawbuffer: number, values: NumberList, srcOffset?: number): void;
+  clearBufferuiv(buffer: number, drawbuffer: number, values: NumberList, srcOffset?: number): void;
+  clearBufferfi(buffer: number, drawbuffer: number, depth: number, stencil: number): void;
+  drawArrays(mode: number, first: number, count: number): void;
+  drawArraysInstanced(mode: number, first: number, count: number, instanceCount: number): void;
+  drawElements(mode: number, count: number, type: number, offset: number): void;
+  drawElementsInstanced(mode: number, count: number, type: number, offset: number, instanceCount: number): void;
+  drawRangeElements(mode: number, start: number, end: number, count: number, type: number, offset: number): void;
+  drawBuffers(buffers: ArrayLike<number>): void;
+  readBuffer(src: number): void;
+  finish(): void;
+  flush(): void;
+  /**
+   * --- Framebuffers and renderbuffers -------------------------------------
+   */
+  createFramebuffer(): LynxWebGLFramebuffer;
+  deleteFramebuffer(framebuffer: LynxWebGLFramebuffer | null): void;
+  isFramebuffer(framebuffer: LynxWebGLFramebuffer | null): boolean;
+  bindFramebuffer(target: number, framebuffer: LynxWebGLFramebuffer | null): void;
+  framebufferRenderbuffer(target: number, attachment: number, renderbuffertarget: number, renderbuffer: LynxWebGLRenderbuffer | null): void;
+  framebufferTexture2D(target: number, attachment: number, textarget: number, texture: LynxWebGLTexture | null, level: number): void;
+  framebufferTextureLayer(target: number, attachment: number, texture: LynxWebGLTexture | null, level: number, layer: number): void;
+  checkFramebufferStatus(target: number): number;
+  getFramebufferAttachmentParameter(target: number, attachment: number, pname: number): unknown;
+  blitFramebuffer(srcX0: number, srcY0: number, srcX1: number, srcY1: number, dstX0: number, dstY0: number, dstX1: number, dstY1: number, mask: number, filter: number): void;
+  invalidateFramebuffer(target: number, attachments: ArrayLike<number>): void;
+  invalidateSubFramebuffer(target: number, attachments: ArrayLike<number>, x: number, y: number, width: number, height: number): void;
+  createRenderbuffer(): LynxWebGLRenderbuffer;
+  deleteRenderbuffer(renderbuffer: LynxWebGLRenderbuffer | null): void;
+  isRenderbuffer(renderbuffer: LynxWebGLRenderbuffer | null): boolean;
+  bindRenderbuffer(target: number, renderbuffer: LynxWebGLRenderbuffer | null): void;
+  renderbufferStorage(target: number, internalformat: number, width: number, height: number): void;
+  renderbufferStorageMultisample(target: number, samples: number, internalformat: number, width: number, height: number): void;
+  getRenderbufferParameter(target: number, pname: number): unknown;
+  getInternalformatParameter(target: number, internalformat: number, pname: number): Int32Array | null;
+  readPixels(x: number, y: number, width: number, height: number, format: number, type: number, destination: ArrayBufferView | number | null, dstOffset?: number): void;
+  /**
+   * --- Textures and samplers ----------------------------------------------
+   */
+  createTexture(): LynxWebGLTexture;
+  deleteTexture(texture: LynxWebGLTexture | null): void;
+  isTexture(texture: LynxWebGLTexture | null): boolean;
+  bindTexture(target: number, texture: LynxWebGLTexture | null): void;
+  texParameterf(target: number, pname: number, param: number): void;
+  texParameteri(target: number, pname: number, param: number): void;
+  getTexParameter(target: number, pname: number): unknown;
+  texStorage2D(target: number, levels: number, internalformat: number, width: number, height: number): void;
+  texStorage3D(target: number, levels: number, internalformat: number, width: number, height: number, depth: number): void;
+  generateMipmap(target: number): void;
+  /**
+   * WebGL2's texImage2D overloads:
+   *   (target, level, internalformat, format, type, source)
+   *   (target, level, internalformat, width, height, border, format, type,
+   *    pixels | pboOffset | source [, srcOffset])
+   */
+  texImage2D(...args: unknown[]): void;
+  /**
+   *   (target, level, xoffset, yoffset, format, type, source)
+   *   (target, level, xoffset, yoffset, width, height, format, type,
+   *    pixels | pboOffset | source [, srcOffset])
+   */
+  texSubImage2D(...args: unknown[]): void;
+  texImage3D(target: number, level: number, internalformat: number, width: number, height: number, depth: number, border: number, format: number, type: number, source: unknown, srcOffset?: number): void;
+  texSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, width: number, height: number, depth: number, format: number, type: number, source: unknown, srcOffset?: number): void;
+  /**
+   * (…, border, imageSize, pboOffset) with a PIXEL_UNPACK_BUFFER bound, else
+   * (…, border, srcData [, srcOffset [, srcLengthOverride]]).
+   */
+  compressedTexImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, ...rest: unknown[]): void;
+  compressedTexImage3D(target: number, level: number, internalformat: number, width: number, height: number, depth: number, border: number, ...rest: unknown[]): void;
+  compressedTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, ...rest: unknown[]): void;
+  compressedTexSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, width: number, height: number, depth: number, format: number, ...rest: unknown[]): void;
+  copyTexImage2D(target: number, level: number, internalformat: number, x: number, y: number, width: number, height: number, border: number): void;
+  copyTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, x: number, y: number, width: number, height: number): void;
+  copyTexSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, x: number, y: number, width: number, height: number): void;
+  createSampler(): LynxWebGLSampler;
+  deleteSampler(sampler: LynxWebGLSampler | null): void;
+  isSampler(sampler: LynxWebGLSampler | null): boolean;
+  bindSampler(unit: number, sampler: LynxWebGLSampler | null): void;
+  samplerParameteri(sampler: LynxWebGLSampler, pname: number, param: number): void;
+  samplerParameterf(sampler: LynxWebGLSampler, pname: number, param: number): void;
+  getSamplerParameter(sampler: LynxWebGLSampler, pname: number): unknown;
+  /**
+   * --- Shaders and programs -----------------------------------------------
+   */
+  createShader(type: number): LynxWebGLShader | null;
+  deleteShader(shader: LynxWebGLShader | null): void;
+  isShader(shader: LynxWebGLShader | null): boolean;
+  shaderSource(shader: LynxWebGLShader, source: string): void;
+  getShaderSource(shader: LynxWebGLShader): string | null;
+  compileShader(shader: LynxWebGLShader): void;
+  getShaderParameter(shader: LynxWebGLShader, pname: number): unknown;
+  getShaderInfoLog(shader: LynxWebGLShader): string | null;
+  createProgram(): LynxWebGLProgram;
+  deleteProgram(program: LynxWebGLProgram | null): void;
+  isProgram(program: LynxWebGLProgram | null): boolean;
+  attachShader(program: LynxWebGLProgram, shader: LynxWebGLShader): void;
+  detachShader(program: LynxWebGLProgram, shader: LynxWebGLShader): void;
+  getAttachedShaders(program: LynxWebGLProgram): LynxWebGLShader[] | null;
+  bindAttribLocation(program: LynxWebGLProgram, index: number, name: string): void;
+  linkProgram(program: LynxWebGLProgram): void;
+  validateProgram(program: LynxWebGLProgram): void;
+  useProgram(program: LynxWebGLProgram | null): void;
+  getProgramParameter(program: LynxWebGLProgram, pname: number): unknown;
+  getProgramInfoLog(program: LynxWebGLProgram): string | null;
+  getActiveUniform(program: LynxWebGLProgram, index: number): LynxWebGLActiveInfo | null;
+  getActiveAttrib(program: LynxWebGLProgram, index: number): LynxWebGLActiveInfo | null;
+  getUniformLocation(program: LynxWebGLProgram, name: string): LynxWebGLUniformLocation | null;
+  getAttribLocation(program: LynxWebGLProgram, name: string): number;
+  getFragDataLocation(program: LynxWebGLProgram, name: string): number;
+  getUniform(program: LynxWebGLProgram, location: LynxWebGLUniformLocation): unknown;
+  getUniformBlockIndex(program: LynxWebGLProgram, uniformBlockName: string): number;
+  uniformBlockBinding(program: LynxWebGLProgram, uniformBlockIndex: number, uniformBlockBinding: number): void;
+  getActiveUniformBlockName(program: LynxWebGLProgram, uniformBlockIndex: number): string | null;
+  getActiveUniformBlockParameter(program: LynxWebGLProgram, uniformBlockIndex: number, pname: number): unknown;
+  getActiveUniforms(program: LynxWebGLProgram, uniformIndices: ArrayLike<number>, pname: number): unknown;
+  getUniformIndices(program: LynxWebGLProgram, uniformNames: string[]): number[] | null;
+  transformFeedbackVaryings(program: LynxWebGLProgram, varyings: string[], bufferMode: number): void;
+  getTransformFeedbackVarying(program: LynxWebGLProgram, index: number): LynxWebGLActiveInfo | null;
+  uniform1f(location: LynxWebGLUniformLocation | null, x: number): void;
+  uniform2f(location: LynxWebGLUniformLocation | null, x: number, y: number): void;
+  uniform3f(location: LynxWebGLUniformLocation | null, x: number, y: number, z: number): void;
+  uniform4f(location: LynxWebGLUniformLocation | null, x: number, y: number, z: number, w: number): void;
+  uniform1i(location: LynxWebGLUniformLocation | null, x: number): void;
+  uniform2i(location: LynxWebGLUniformLocation | null, x: number, y: number): void;
+  uniform3i(location: LynxWebGLUniformLocation | null, x: number, y: number, z: number): void;
+  uniform4i(location: LynxWebGLUniformLocation | null, x: number, y: number, z: number, w: number): void;
+  uniform1ui(location: LynxWebGLUniformLocation | null, x: number): void;
+  uniform2ui(location: LynxWebGLUniformLocation | null, x: number, y: number): void;
+  uniform3ui(location: LynxWebGLUniformLocation | null, x: number, y: number, z: number): void;
+  uniform4ui(location: LynxWebGLUniformLocation | null, x: number, y: number, z: number, w: number): void;
+  uniform1fv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform2fv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform3fv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform4fv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform1iv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform2iv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform3iv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform4iv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform1uiv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform2uiv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform3uiv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniform4uiv(location: LynxWebGLUniformLocation | null, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix2fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix3fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix4fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix2x3fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix3x2fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix2x4fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix4x2fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix3x4fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  uniformMatrix4x3fv(location: LynxWebGLUniformLocation | null, transpose: boolean, data: NumberList, srcOffset?: number, srcLength?: number): void;
+  /**
+   * --- Queries, syncs and transform feedback ------------------------------
+   */
+  createQuery(): LynxWebGLQuery;
+  deleteQuery(query: LynxWebGLQuery | null): void;
+  isQuery(query: LynxWebGLQuery | null): boolean;
+  beginQuery(target: number, query: LynxWebGLQuery): void;
+  endQuery(target: number): void;
+  getQuery(target: number, pname: number): LynxWebGLQuery | null;
+  getQueryParameter(query: LynxWebGLQuery, pname: number): unknown;
+  fenceSync(condition: number, flags: number): LynxWebGLSync;
+  deleteSync(sync: LynxWebGLSync | null): void;
+  isSync(sync: LynxWebGLSync | null): boolean;
+  clientWaitSync(sync: LynxWebGLSync, flags: number, timeout: number): number;
+  waitSync(sync: LynxWebGLSync, flags: number, timeout: number): void;
+  getSyncParameter(sync: LynxWebGLSync, pname: number): unknown;
+  createTransformFeedback(): LynxWebGLTransformFeedback;
+  deleteTransformFeedback(transformFeedback: LynxWebGLTransformFeedback | null): void;
+  isTransformFeedback(transformFeedback: LynxWebGLTransformFeedback | null): boolean;
+  bindTransformFeedback(target: number, transformFeedback: LynxWebGLTransformFeedback | null): void;
+  beginTransformFeedback(primitiveMode: number): void;
+  endTransformFeedback(): void;
+  pauseTransformFeedback(): void;
+  resumeTransformFeedback(): void;
+  getIndexedParameter(target: number, index: number): unknown;
+}
+interface LynxWebGL2RenderingContext extends Readonly<typeof WEBGL2_CONSTANTS> {}
+/**
+ * `<canvas>`: a drawing surface with a WebGL2 context, as HTMLCanvasElement
+ * has, for three.js and other WebGL libraries.
+ *
+ * - `width` and `height` are the drawing buffer's size in pixels (300 by 150
+ *   to start, as on the web); the element's CSS size is how big it's shown.
+ * - `getContext('webgl2')` returns a WebGL2RenderingContext: on iOS and
+ *   Android, the runtime's (see webgl2-context.ts), drawing with the shell's
+ *   OpenGL ES 3.0; on Lynx for Web, the browser's own, since the element is a
+ *   real `<canvas>` there. It returns null where there's no WebGL: a host
+ *   without the shell's `AngularLynxWebGL` module, such as Lynx Explorer.
+ *   There's no `'2d'` context, and `'webgl'` (WebGL 1) is null too.
+ * - Pointer events (see pointer-events.ts) and `getBoundingClientRect()`
+ *   (see layout.ts) work on every element; a canvas keeps its layout from
+ *   the start, so `clientWidth` and `clientHeight` are right after its first
+ *   layout.
+ * - `webglcontextlost` fires when `WEBGL_lose_context` loses the context,
+ *   which three.js does when it's disposed.
+ */
+declare class LynxCanvasElement extends LynxElement {
+  #private;
+  readonly style: Record<string, string>;
+  constructor(element: ElementRef);
+  get width(): number;
+  set width(value: number);
+  get height(): number;
+  set height(value: number);
+  /**
+   * `width="600"` in a template, or a `[width]` binding, sizes the drawing
+   * buffer, as on an HTML canvas; it's not an attribute Lynx knows.
+   */
+  setAttribute(name: string, value: any): void;
+  setProperty(name: string, value: any): void;
+  /**
+   * The id that pairs this canvas with its native view and GL context.
+   */
+  get canvasId(): string;
+  getContext(type: string, attributes?: Partial<LynxWebGLContextAttributes>): unknown;
+  addEventListener(name: string, cb: (event: any) => any): () => void;
+  removeEventListener(name: string, cb: (event: any) => any): void;
+  /**
+   * @internal Fires one of the context's events; false if one prevented it.
+   */
+  dispatchContextEvent(type: string): boolean;
+  /**
+   * @internal Angular destroyed the element: the GL context goes with it.
+   */
+  releaseContext(): void;
+  toDataURL(): string;
+  toBlob(): void;
+}
+/**
+ * Pointer events on Lynx elements.
+ *
+ * Lynx sends touch events (touchstart, touchmove, touchend, touchcancel), and
+ * no pointer events. Libraries written for the web listen for pointer events
+ * instead: angular-three's event system (pointerdown, pointermove, pointerup,
+ * pointercancel, pointerleave, lostpointercapture), gesture libraries, and
+ * any template's `(pointerdown)`. So an element with a pointer listener
+ * listens for its touches, and turns each into the pointer events a browser
+ * fires for a touch, in a browser's order:
+ *
+ * - touchstart: pointerover, pointerenter, pointerdown
+ * - touchmove: pointermove
+ * - touchend: pointerup, then lostpointercapture if the pointer was captured,
+ *   then pointerout and pointerleave (a touch leaves when it lifts)
+ * - touchcancel: pointercancel, lostpointercapture, pointerout, pointerleave
+ *
+ * Each finger is a pointer, whose `pointerId` stays the same until it lifts
+ * (see pointerIdOf), and `isPrimary` marks the first one down. `offsetX`/`offsetY` are relative to
+ * the element, from the touch's `x`/`y` when the element itself was touched
+ * and from its last layout otherwise; `clientX`/`clientY` and
+ * `pageX`/`pageY` are in the LynxView's coordinates.
+ *
+ * A touch's events go to the element it started on wherever the finger
+ * moves, as if every pointer were captured: Lynx targets touchmove and
+ * touchend at touchstart's target. So `setPointerCapture()` changes nothing
+ * but `hasPointerCapture()` and the capture events.
+ *
+ * On Lynx for Web the element is a DOM element with real pointer events
+ * (and a mouse's), so the listeners go straight to it.
+ */
+/** The pointer events an element can listen for. */
+declare const POINTER_EVENT_NAMES: ReadonlySet<string>;
+/** A Lynx touch, as its touch events carry it. */
+type LynxTouch = {
+  identifier: number;
+  x?: number;
+  y?: number;
+  pageX?: number;
+  pageY?: number;
+  clientX?: number;
+  clientY?: number;
+};
+type LynxTouchEvent = {
+  type?: string;
+  timestamp?: number;
+  target?: {
+    uid?: number;
+  };
+  touches?: LynxTouch[];
+  changedTouches?: LynxTouch[];
+};
+/**
+ * A touch's pointerId, the same in each of its events, at an element and at
+ * the document.
+ *
+ * With multi-touch on, Lynx numbers each finger from 0 and keeps its number
+ * until it lifts (`touches_map_` in iOS's LynxTouchHandler.mm, and Android's
+ * `MotionEvent.getPointerId()`). With it off, which is the LynxView's
+ * default, there's one touch at a time, and its `identifier` is the address
+ * of the dictionary Lynx builds the touch in (`reinterpret_cast<int64_t>(&touch)`
+ * in TouchEventHandler::GetTouchEventParam), which changes from one event to
+ * the next: on the iOS 27 Simulator, a drag's touchmove events had one and its
+ * touchend another. So a touch with such an identifier is the one touch, and
+ * gets the number multi-touch gives the first finger.
+ */
+declare const pointerIdOf: (touch: LynxTouch) => number;
+/** What the source needs from its element. */
+type PointerEventHost = {
+  /** The element's unique id, which a touch event's `target.uid` names. */
+  readonly uid: number;
+  /** The element's last layout, relative to the LynxView. */
+  layoutOrigin(): {
+    left: number;
+    top: number;
+  } | null;
+  /** Adds a touch listener to the element itself (`bindtouchstart`, …). */
+  listen(name: string, listener: (event: LynxTouchEvent) => void): () => void;
+  /** The object to set as the events' `target` and `currentTarget`. */
+  readonly eventTarget: object;
+};
+type PointerListener = (event: LynxPointerEvent) => unknown;
+/**
+ * A pointer event made from a touch: the PointerEvent fields a library reads,
+ * with `preventDefault()` and the propagation methods (which change nothing,
+ * as Lynx decides a touch's propagation when it's bound).
+ */
+declare class LynxPointerEvent {
+  #private;
+  readonly type: string;
+  readonly pointerId: number;
+  readonly isPrimary: boolean;
+  readonly clientX: number;
+  readonly clientY: number;
+  readonly pageX: number;
+  readonly pageY: number;
+  readonly offsetX: number;
+  readonly offsetY: number;
+  readonly button: number;
+  readonly buttons: number;
+  readonly pressure: number;
+  readonly timeStamp: number;
+  readonly bubbles: boolean;
+  readonly cancelable: boolean;
+  readonly composed = true;
+  readonly pointerType = "touch";
+  readonly width = 1;
+  readonly height = 1;
+  readonly tiltX = 0;
+  readonly tiltY = 0;
+  readonly twist = 0;
+  readonly tangentialPressure = 0;
+  readonly altKey = false;
+  readonly ctrlKey = false;
+  readonly metaKey = false;
+  readonly shiftKey = false;
+  readonly detail = 0;
+  readonly eventPhase = 2;
+  readonly isTrusted = true;
+  readonly target: object;
+  readonly currentTarget: object;
+  readonly srcElement: object;
+  readonly relatedTarget: null;
+  readonly x: number;
+  readonly y: number;
+  readonly screenX: number;
+  readonly screenY: number;
+  readonly movementX = 0;
+  readonly movementY = 0;
+  defaultPrevented: boolean;
+  constructor(type: string, pointerId: number, isPrimary: boolean, clientX: number, clientY: number, pageX: number, pageY: number, offsetX: number, offsetY: number, button: number, buttons: number, pressure: number, timeStamp: number, target: object);
+  preventDefault(): void;
+  stopPropagation(): void;
+  stopImmediatePropagation(): void;
+  /**
+   * @internal Whether a listener stopped the others.
+   */
+  get immediatePropagationStopped(): boolean;
+  getCoalescedEvents(): LynxPointerEvent[];
+  getPredictedEvents(): LynxPointerEvent[];
+}
+/**
+ * One element's pointer events: its listeners, by event name, and the touch
+ * listeners it adds to the element while it has any.
+ */
+declare class PointerEventSource {
+  #private;
+  /** Where the last pointer was on the element, for the click that follows. */
+  lastOffset: {
+    offsetX: number;
+    offsetY: number;
+  } | null;
+  constructor(host: PointerEventHost);
+  add(type: string, listener: PointerListener): () => void;
+  remove(type: string, listener: PointerListener): void;
+  setPointerCapture(pointerId: number): void;
+  releasePointerCapture(pointerId: number): void;
+  hasPointerCapture(pointerId: number): boolean;
+}
+/**
+ * The pointer event a browser fires for `touch`: the one an element makes
+ * (see PointerEventSource), and the one the document gets for a touch
+ * anywhere (see global-events/native-source.ts). `pointer` says which finger
+ * it is and where it is on the target; a capture event, which no touch
+ * causes, has no `touch`.
+ */
+declare const pointerEventFor: (type: string, pointer: {
+  pointerId: number;
+  isPrimary: boolean;
+  offsetX: number;
+  offsetY: number;
+}, touch: LynxTouch | null, timeStamp: number | undefined, target: object) => LynxPointerEvent;
+export declare class LynxLogger {
+  #private;
+  log(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxLogger, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * 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}. 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: {
+ *       setStorageItem(key: string, value: string): void;
+ *       getStorageItem(key: string, callback: (value: string) => void): void;
+ *       clearStorage(): void;
+ *     };
+ *   }
+ * }
+ * ```
+ */
+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.
+ *
+ * **Native modules** (`NativeModules` global) let JS code call native platform
+ * functions (iOS / Android / HarmonyOS). The host app registers modules on the
+ * native side; this service provides typed access from Angular.
+ *
+ * **JS modules** (`lynx.getJSModule` / `lynx.registerModule`) share JavaScript
+ * 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);
+ *
+ * // Call a native method (Promise-based wrapper over bridge.call)
+ * const result = await modules.call<string>('getDeviceId', {});
+ *
+ * // Listen for native events
+ * modules.on('onDeepLink', (url) => console.log(url));
+ *
+ * // Access a typed custom native module
+ * const storage = modules.getNativeModule('NativeLocalStorageModule');
+ * storage?.setStorageItem('key', 'value');
+ *
+ * // JS module sharing within the LynxView
+ * modules.registerJSModule('mySharedState', { count: 0 });
+ * const state = modules.getJSModule<{ count: number }>('mySharedState');
+ * ```
+ */
+export declare class LynxNativeModule {
+  #private;
+  /**
+   * Calls a native method via `NativeModules.bridge.call()`.
+   *
+   * The native callback API is wrapped in a Promise for ergonomic
+   * use with `async`/`await`.
+   *
+   * 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()`. From the
+   * main thread, the callback gets the event's arguments copied as JSON.
+   *
+   * No-op when there is no bridge.
+   */
+  on(name: string, callback: (...args: unknown[]) => void): void;
+  /**
+   * Retrieves a custom native module by name from the `NativeModules` global.
+   *
+   * Augment the {@link NativeModuleMap} interface for type-safe access:
+   *
+   * ```typescript
+   * export {};
+   *
+   * declare module '@blotch/angular-lynx' {
+   *   interface NativeModuleMap {
+   *     NativeLocalStorageModule: { ... };
+   *   }
+   * }
+   *
+   * const storage = modules.getNativeModule('NativeLocalStorageModule');
+   * ```
+   *
+   * 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 ? NativeModuleProxy<NativeModuleMap[K]> | undefined : unknown;
+  /**
+   * Retrieves a JS module registered within this LynxView.
    *
-   * 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).
+   * This wraps `lynx.getJSModule()` — the same API used internally
+   * for `GlobalEventEmitter`. On the main thread it returns a proxy, as
+   * getNativeModule() does.
+   *
+   * Returns `undefined` when `lynx` is unavailable or, on the background
+   * thread, when the module is not registered.
    */
-  addEventListener(name: string, cb: (event: any) => any): () => void;
+  getJSModule<T = unknown>(name: string): T | undefined;
   /**
-   * 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.
+   * Registers a JS module for sharing within this LynxView.
+   *
+   * Other code (including native callbacks) can retrieve it via
+   * `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.
    */
-  removeEventListener(name: string, cb: (event: any) => any): void;
+  registerJSModule<T extends object>(name: string, module: T): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxNativeModule, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-/**
- * Commits all queued genuine element removals — a free-function wrapper over
- * `LynxElement.commitPendingRemovals()` so `LynxRendererFactory2.end()` can
- * drain them (via the lynx-element barrel) right before `__FlushElementTree()`,
- * keeping removals in the same flush as the cycle's other mutations.
- */
-declare const processPendingRemovals: () => void;
-/**
- * Commits this cycle's attribute removals (see LynxElement's
- * `#removedAttributes`). A free-function wrapper over
- * `LynxElement.commitPendingAttributeRemovals()` so
- * `LynxRendererFactory2.end()` can drain them (via the lynx-element barrel)
- * right after element removals and before `__FlushElementTree()`.
- */
-declare const processPendingAttributeRemovals: () => void;
-/**
- * Re-derives positional edge whitespace for every text touched this cycle — a
- * free-function wrapper over `LynxElement.commitPendingTextNormalization()` so
- * `LynxRendererFactory2.end()` can drain it (via the lynx-element barrel) right
- * after removals and before `__FlushElementTree()`, keeping the corrected text in
- * the same flush as the cycle's other mutations. See #pendingTextNormalization.
- */
-declare const processPendingTextNormalization: () => void;
-/**
- * Safety-net flush for native mutations made OUTSIDE a begin()/end() change-
- * detection cycle. `LynxRendererFactory2.end()` calls `__FlushElementTree()`
- * once per CD tick, which is what commits (lays out + paints) the cycle's
- * element mutations. But a lazy-loaded route component is instantiated by
- * `RouterOutlet` DURING navigation — outside any such cycle — so its freshly
- * created elements land in the fiber tree yet are never flushed. On-device
- * symptom: the route's static shell renders, but its `@if`/`@for`/interpolation
- * content stays invisible until an unrelated CD (e.g. a tap) triggers the next
- * end() flush. (Bootstrap sidesteps this via native's implicit post-renderPage
- * 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 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:
- *  - inside a CD cycle — end() will flush;
- *  - the first render is pending — native flushes after renderPage, and any
- *    `<list>` defers its own first flush (see isFirstRenderPending()).
- * The near-no-op cost when nothing is layout-dirty (the core's `need_layout_`
- * gate) keeps the steady-state overhead negligible.
- */
-declare const scheduleSettleFlush: () => void;
 /**
  * Process all pending list updates. Called from LynxRendererFactory2.end()
  * before __FlushElementTree() so list updates are flushed as part of the
@@ -4156,6 +6442,103 @@ export declare class LynxResourcePrefetch {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxResourcePrefetch, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+/**
+ * The platform the app runs on, spelled exactly as Lynx reports it. Compare
+ * with these strings as written: `'iOS'`, not `'ios'`.
+ *
+ * The casing is uneven because each platform's Lynx code names itself (Lynx
+ * core's desktop code returns `'windows'` but `'macOS'`), so it can't be
+ * normalized without breaking comparisons against what Lynx reports.
+ *
+ * It differs from `@lynx-js/types`' `PlatformType` in two places:
+ * - It adds `'web'`, which web-core (Lynx for Web, the docs' live previews)
+ *   reports. Without it, code that checks for the web needs a cast.
+ * - It drops `'pc'`, the name desktop Lynx used before 3.3, which no Lynx
+ *   that AngularLynx supports reports.
+ */
+type PlatformType = 'Android' | 'iOS' | 'Harmony' | 'windows' | 'macOS' | 'web';
+/**
+ * Wraps the global `SystemInfo` object as an Angular injectable,
+ * providing device and platform information from the Lynx runtime.
+ *
+ * `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);
+ *
+ * // Device dimensions in physical pixels
+ * const { pixelWidth, pixelHeight, pixelRatio } = systemInfo;
+ *
+ * // Logical screen dimensions (CSS pixels)
+ * const cssWidth = systemInfo.screenWidth;
+ * const cssHeight = systemInfo.screenHeight;
+ *
+ * // Platform detection
+ * if (systemInfo.platform === 'iOS') {
+ *   // iOS-specific logic
+ * }
+ * ```
+ */
+export declare class LynxSystemInfo {
+  #private;
+  constructor();
+  /**
+   * The platform of the current device (e.g. `'iOS'`, `'Android'`, or
+   * `'web'` in Lynx for Web). See {@link PlatformType}.
+   */
+  get platform(): PlatformType;
+  /**
+   * The Lynx engine version (e.g. `'3.2'`).
+   */
+  get engineVersion(): string;
+  /**
+   * 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;
+  /**
+   * Physical pixel width of the device screen.
+   */
+  get pixelWidth(): number;
+  /**
+   * Physical pixel height of the device screen.
+   */
+  get pixelHeight(): number;
+  /**
+   * Device pixel ratio (physical pixels per CSS pixel).
+   */
+  get pixelRatio(): number;
+  /**
+   * The JavaScript engine in use (`'v8'`, `'jsc'`, or `'quickjs'`). Only available on the background thread.
+   */
+  get runtimeType(): 'v8' | 'jsc' | 'quickjs';
+  /**
+   * Screen width in logical/CSS pixels (`pixelWidth / pixelRatio`).
+   */
+  get screenWidth(): number;
+  /**
+   * Screen height in logical/CSS pixels (`pixelHeight / pixelRatio`).
+   */
+  get screenHeight(): number;
+  /**
+   * The theme object, if provided by the host application.
+   */
+  get theme(): object | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LynxSystemInfo, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /**
  * CSS `env()` value for the top safe area inset (notch / status bar).
  */
@@ -4205,9 +6588,10 @@ export declare class LynxSafeArea {
    */
   readonly isNotchScreen: import("@angular/core").Signal<boolean>;
   /**
-   * The current platform (`'iOS'`, `'Android'`, `'Harmony'`, etc.).
+   * The current platform (`'iOS'`, `'Android'`, `'web'`, etc.). Same as
+   * {@link LynxSystemInfo.platform}.
    */
-  get platform(): import("@lynx-js/types").PlatformType;
+  get platform(): PlatformType;
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxSafeArea, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
@@ -4417,87 +6801,6 @@ export declare class LynxSecureStorage extends PersistentStorage {
   static ɵfac: i0.ɵɵFactoryDeclaration<LynxSecureStorage, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-/**
- * Wraps the global `SystemInfo` object as an Angular injectable,
- * providing device and platform information from the Lynx runtime.
- *
- * `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);
- *
- * // Device dimensions in physical pixels
- * const { pixelWidth, pixelHeight, pixelRatio } = systemInfo;
- *
- * // Logical screen dimensions (CSS pixels)
- * const cssWidth = systemInfo.screenWidth;
- * const cssHeight = systemInfo.screenHeight;
- *
- * // Platform detection
- * if (systemInfo.platform === 'iOS') {
- *   // iOS-specific logic
- * }
- * ```
- */
-export declare class LynxSystemInfo {
-  #private;
-  constructor();
-  /**
-   * The platform of the current device (e.g. `'iOS'`, `'Android'`).
-   */
-  get platform(): PlatformType;
-  /**
-   * The Lynx engine version (e.g. `'3.2'`).
-   */
-  get engineVersion(): string;
-  /**
-   * 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;
-  /**
-   * Physical pixel width of the device screen.
-   */
-  get pixelWidth(): number;
-  /**
-   * Physical pixel height of the device screen.
-   */
-  get pixelHeight(): number;
-  /**
-   * Device pixel ratio (physical pixels per CSS pixel).
-   */
-  get pixelRatio(): number;
-  /**
-   * The JavaScript engine in use (`'v8'`, `'jsc'`, or `'quickjs'`). Only available on the background thread.
-   */
-  get runtimeType(): 'v8' | 'jsc' | 'quickjs';
-  /**
-   * Screen width in logical/CSS pixels (`pixelWidth / pixelRatio`).
-   */
-  get screenWidth(): number;
-  /**
-   * Screen height in logical/CSS pixels (`pixelHeight / pixelRatio`).
-   */
-  get screenHeight(): number;
-  /**
-   * The theme object, if provided by the host application.
-   */
-  get theme(): object | undefined;
-  static ɵfac: i0.ɵɵFactoryDeclaration<LynxSystemInfo, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
 /**
  * Wraps `lynx.getTextInfo()` for measuring text dimensions and
  * performing line-breaking calculations.
@@ -4798,7 +7101,7 @@ export declare class LynxWebAuthSession {
  * 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. The document (LynxDocument, or LynxHydrateDocument for SSR)
- * 2. DOCUMENT stub (Angular requires this token but Lynx has no DOM Document)
+ * 2. DOCUMENT: the document stand-in elements' ownerDocument is (global-events)
  * 3. APP_BASE_HREF (prevents BrowserPlatformLocation from crashing)
  * 4. Renderer factory (creates LynxRenderer / EmulatedLynxRenderer)
  * 5. Error handler (routes to _ReportError + __lynxLastError)
@@ -5250,33 +7553,4 @@ declare global {
     _wkltId: string;
   }, ...args: unknown[]): Promise<unknown>;
 }
-declare global {
-  interface HTMLElementEventMap {
-    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 { AccessibilityTrait, AccessibilityTraitStates, BackgroundFnHandle, BaseLynxAnimation, BaseLynxElement, DataProcessorDefinition, DevToolsStats, DynamicColorRole, DynamicColorScheme, DynamicColors, ExposureEventDetail, FlingGestureEvent, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, HostElementTag, 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, WebAuthSessionErrorCode, WebAuthSessionOptions };
+export type { AccessibilityActionDetail, AccessibilityTrait, AccessibilityTraitStates, BackgroundFnHandle, BaseLynxAnimation, BaseLynxElement, DataProcessorDefinition, DevToolsStats, DynamicColorRole, DynamicColorScheme, DynamicColors, ExposureEventDetail, FlingGestureEvent, FrameLoadDetail, FrameLoadMetricsDetail, GestureCallback, GestureCallbackWithState, GestureEvent, GlobalData, GlobalExposureEvent, HostElementTag, ImageErrorDetail, ImageLoadDetail, InitData, InitDataRaw, InputDetail, InputSelectionDetail, InputValueDetail, LayoutChangeDetail, ListAttachedCell, ListItemInfo, ListLayoutCompleteDetail, ListScrollDetail, ListScrollStateChangeDetail, ListSnapDetail, LongPressGestureEvent, LynxAnimationOptions, LynxCanvasElement, LynxDOMRect, LynxEvent, LynxEventTarget, LynxFontEntry, LynxFontFaceConfig, LynxFontStatus, LynxPointerEvent, LynxTraceOptions, LynxWebGL2RenderingContext, MainThread, MainThreadFnHandle, NativeModuleMap, NativeModuleProxy, ObserverFrameRateOptions, OverlayErrorDetail, OverlayTouchDetail, PanGestureEvent, PinchGestureEvent, PlatformType, PortalConfig, PrefetchCacheTarget, PrefetchPriority, PrefetchRequest, PrefetchResultDetail, RefreshHeaderOffsetDetail, RefreshStartDetail, RefreshStateChangeDetail, ResourcePrefetchData, ResourcePrefetchResult, RotationGestureEvent, ScrollCoordinatorOffsetDetail, ScrollDetail, SessionStorageSubscription, TapGestureEvent, TextLayoutDetail, TextSelectionChangeDetail, UIAppearanceDetail, VideoBufferingDetail, VideoErrorDetail, VideoFirstFrameDetail, VideoTimeUpdateDetail, ViewPagerChangeDetail, ViewPagerOffsetChangeDetail, WebAuthSessionErrorCode, WebAuthSessionOptions, WebViewErrorDetail, WebViewMessageDetail, WebViewUrlDetail };