@blotch/angular-lynx 22.2.9 → 22.2.11

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

@@ -3,7 +3,7 @@ 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, PlatformType, ResourcePrefetchData, ResourcePrefetchResult, TextInfo, TextMetrics, TouchEvent, TransitionEvent } from "@lynx-js/types";
+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 { LocationChangeListener, LocationStrategy, PlatformLocation } from "@angular/common";
 import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy, RouterFeatures, Routes } from "@angular/router";
@@ -2150,7 +2150,7 @@ type LynxVideoEventMap = WithPrefixes<{
   bindfirstframe: LynxEvent<VideoFirstFrameDetail>;
   bindtimeupdate: LynxEvent<VideoTimeUpdateDetail>;
   bindbuffering: LynxEvent<VideoBufferingDetail>;
-  binderror: LynxEvent<VideoErrorDetail | undefined>;
+  binderror: LynxEvent<VideoErrorDetail>;
   bindplaying: LynxEvent;
   bindpaused: LynxEvent;
   bindstopped: LynxEvent;
@@ -3779,6 +3779,324 @@ type BaseLynxElement = Pick<Element$1, 'setAttribute'> & {
    */
   invoke(methodName: string, params?: Record<string, unknown>): 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.
+ */
+type PropagationState = {
+  stopped: boolean;
+  stoppedImmediately: boolean;
+};
+/**
+ * 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.
+ */
+declare const setEventProperty: (event: object, name: string, value: unknown) => void;
+/**
+ * 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`.
+ */
+declare class GlobalEventTarget {
+  #private;
+  constructor(owner?: object);
+  /**
+   * @internal Called whenever the set of types with listeners changes, so
+   * the events for them can be listened for (see global-events.ts).
+   */
+  set onTypesChange(callback: () => void);
+  addEventListener(type: string, callback: EventListenerLike | null | undefined, options?: ListenerOptionsLike): void;
+  removeEventListener(type: string, callback: EventListenerLike | null | undefined, options?: ListenerOptionsLike): void;
+  /**
+   * 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.
+   */
+  dispatchEvent(event: any): boolean;
+  /**
+   * The types that have a listener.
+   */
+  get types(): string[];
+  hasListeners(type: string): boolean;
+  /**
+   * The object listeners are added to, which they see as currentTarget.
+   */
+  get owner(): object;
+  /**
+   * @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`.
+   */
+  invoke(type: string, event: any, phase: number, state: PropagationState): void;
+}
+/**
+ * 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;
+  constructor(event: any, target: object, path: GlobalEventTarget[], type?: string);
+  /**
+   * Runs the capturing listeners of the objects around the target.
+   */
+  capture(): void;
+  /**
+   * 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.
+   */
+  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()`,
@@ -3812,6 +4130,12 @@ type LynxDOMRect = {
   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`). */
@@ -3834,6 +4158,18 @@ declare class LayoutTracker {
    */
   observe(observer: (rect: LayoutRect) => void): () => void;
 }
+/**
+ * Gives a new scroll-view or list a `scroll` handler on iOS, so that a
+ * listener added later hears its scroll events. iOS's scroll-view
+ * (LynxUIScroller) and list (LynxUIListScroll) hand their scroll event
+ * manager the element's event set the first time they're told of one, as the
+ * UI is made, and never a later one. So a scroll handler added after that is
+ * never called, even after a flush: an IntersectionObserver with options adds
+ * one once it has measured its element, which is laid out by then. The
+ * handler does nothing; the listeners added later share it (see
+ * #syncNativeHandler), and Android, which reads the set afresh, needs none.
+ */
+declare const listenForScrollsFromTheStart: (element: LynxElement) => void;
 declare class LynxElement implements BaseLynxElement {
   #private;
   get element(): ElementRef;
@@ -3854,14 +4190,49 @@ declare class LynxElement implements BaseLynxElement {
   _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.
+   * native ref is swapped (recreate-on-remount) for the STALE id, and when the
+   * element is released after Angular destroyed it (see #release), so the
+   * registry doesn't retain wrappers for dead native refs.
    */
   deregisterNative(): void;
+  /**
+   * @internal Angular destroyed this element: the renderer's destroyNode.
+   *
+   * Angular calls destroyNode only for a destroyed view's top-level nodes.
+   * `destroyLView` walks them with `applyView`, which never descends into an
+   * element's children, and the views nested in it (embedded views, child
+   * components' views) are cleaned up by `destroyViewTree` without the
+   * renderer. So this element releases its whole subtree (see #release),
+   * whatever views the elements under it belong to.
+   *
+   * It waits for the commit at the end of the cycle (see
+   * #commitPendingReleases), when the cycle's moves are done: an element
+   * moved out of the subtree in the meantime, as CDK's DomPortal hands its
+   * element back when it's destroyed, isn't under this one any more and
+   * stays registered. An element still in the tree then (a leave animation
+   * delays Angular's removal) is released when its removal commits.
+   */
+  markDestroyed(): void;
+  /**
+   * @internal The children this element keeps out of `#children`, which a
+   * release must reach too: a list's items (see LynxListElement). None here.
+   */
+  virtualChildren(): LynxElement[];
+  /**
+   * 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
@@ -3981,6 +4352,15 @@ declare class LynxElement implements BaseLynxElement {
    * 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
@@ -4025,6 +4405,24 @@ declare class LynxElement implements BaseLynxElement {
    * The box from the element's last layout, or null before the first.
    */
   get layoutRect(): LayoutRect | null;
+  /**
+   * Leaves the element's handler for `eventName` to a main-thread directive
+   * (`[mainThreadBindscroll]` and the like), which registers its own with
+   * `__AddEvent`. Lynx keeps one handler per event name (see nativeEventKey),
+   * so registering the element's own afterwards would replace the
+   * directive's: an IntersectionObserver with options, listening for a
+   * scroll-view's scroll events, would stop the app's main-thread scroll
+   * handler. Until releaseNativeEvent, the element's listeners for the event
+   * aren't registered natively, and don't hear it, as they didn't when the
+   * directive registered after them. Counted, as `mainThreadBindscroll` and
+   * `mainThreadCatchscroll` share one.
+   */
+  holdNativeEvent(eventName: string): void;
+  /**
+   * Hands `eventName` back once the directive has removed its handler, and
+   * registers the element's own for the listeners it has for it.
+   */
+  releaseNativeEvent(eventName: string): void;
 }
 /**
  * Commits all queued genuine element removals — a free-function wrapper over
@@ -5228,8 +5626,8 @@ declare class LynxCanvasElement extends LynxElement {
  *   then pointerout and pointerleave (a touch leaves when it lifts)
  * - touchcancel: pointercancel, lostpointercapture, pointerout, pointerleave
  *
- * Each finger is a pointer: `pointerId` is its touch's identifier, and
- * `isPrimary` marks the first one down. `offsetX`/`offsetY` are relative to
+ * 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.
@@ -5263,6 +5661,21 @@ type LynxTouchEvent = {
   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. */
@@ -5355,6 +5768,19 @@ declare class PointerEventSource {
   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;
@@ -5549,6 +5975,12 @@ declare class LynxListElement extends LynxElement {
    * for the general "never key a Set/Map on an element ref" constraint.
    */
   getUIChildren(): ElementRef[];
+  /**
+   * The items, anchors included: they live in this linked list, not in the
+   * `#children` a release walks, and a list in a destroyed view must let
+   * them go too (see LynxElement.virtualChildren).
+   */
+  virtualChildren(): LynxElement[];
   /**
    * The UI children list as of the last _processUpdate() call, pre-filtered
    * and cached — for componentAtIndex/componentAtIndexes (create-list-element.ts)
@@ -6069,6 +6501,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).
  */
@@ -6118,9 +6647,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>;
 }
@@ -6330,87 +6860,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.
@@ -6711,7 +7160,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)
@@ -7163,4 +7612,4 @@ declare global {
     _wkltId: string;
   }, ...args: unknown[]): Promise<unknown>;
 }
-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, 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 };
+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 };