@ng-native/fabric 0.15.0 → 0.17.0

package/dist/engine.d.ts

@@ -9,13 +9,15 @@
  */
 import { type Conditions, type DeferredDeclaration, type StyleCache, type StyleSheet, type TokenValue } from './css.ts';
 import { type AnimationSpec, type Keyframe, type RunningAnimation, type Transition } from './transition.ts';
-import { type DrivenProperty, type EventFeed, type NativeAnimated, type ScrollAxis, type ScrollDrive, type ScrollRange, type StaticTransform } from './native-drive.ts';
+import { type ComposedDrive, type DrivenProperty, type EventFeed, type FollowingTransform, type NativeAnimated, type ScrollAxis, type ScrollDrive, type ScrollRange, type StaticTransform } from './native-drive.ts';
 import type { DrivenChannels } from './scroll-animation.ts';
 export type FabricNode = {
     readonly __fabricNode: unique symbol;
 } | object;
 /** Where a node is, in the window's coordinates. What `Engine.measure` reports. */
 import type { HostEngine, HostNode, Settling } from './host.ts';
+import { type GridLayout, type Rect } from './grid.ts';
+import { type FlowPlan } from './flow.ts';
 /** A node's scroll-driven animation: what it plays, what drives it, and the frame it commits. */
 interface ScrollAnimation {
     readonly spec: AnimationSpec;
@@ -48,11 +50,11 @@ export type FabricNodeSet = unknown;
 export interface FabricUIManager {
     createNode(reactTag: number, viewName: string, rootTag: number, props: object, instanceHandle: unknown): FabricNode;
     /** Clone with the *given* children (omitting the argument means none) and the same props. */
-    cloneNodeWithNewChildren(node: FabricNode): FabricNode;
+    cloneNodeWithNewChildren(node: FabricNode, children?: readonly FabricNode[]): FabricNode;
     /** Clone with the given props and the *same* children. */
     cloneNodeWithNewProps(node: FabricNode, newProps: object): FabricNode;
-    /** Clone with the given props and the given children (omitting them means none). */
-    cloneNodeWithNewChildrenAndProps(node: FabricNode, newProps: object): FabricNode;
+    /** Clone with the given children and the given props. */
+    cloneNodeWithNewChildrenAndProps(node: FabricNode, children: readonly FabricNode[], newProps: object): FabricNode;
     appendChild(parent: FabricNode, child: FabricNode): FabricNode;
     /**
      * Have native move each view whose frame the next commit changes to where it ends up, over a
@@ -80,6 +82,13 @@ export interface FabricUIManager {
      * overlay place itself in the same frame it was opened in.
      */
     measureInWindow?(node: FabricNode, onSuccess: (x: number, y: number, width: number, height: number) => void): void;
+    /**
+     * A node's box as the last commit laid it out: x, y, width, height. Fabric lays a commit out
+     * before `completeRoot` returns, so this answers for a commit made a line earlier, and what
+     * was read can be committed again before anything is drawn. That is how a grid is laid out.
+     * Optional because a test's fabric has no layout to read.
+     */
+    getBoundingClientRect?(node: FabricNode, includeTransform: boolean): readonly [number, number, number, number] | undefined;
 }
 /**
  * RN's `directEventTypes`: delivered to the target only, never up the tree. Everything else
@@ -184,20 +193,32 @@ interface Committed {
     viewName: string;
 }
 export interface EngineNode extends HostNode {
-    readonly kind: NodeKind;
+    readonly nodeKind: NodeKind;
     /** Lowercase template spelling, e.g. `view`. Never the native view name. */
     readonly tag: string;
     /** `tag` again, for Angular 22.0, which reads it on a component's host element. */
     readonly tagName: string;
+    /**
+     * The element's name as a stylesheet's type selector reads it, where it is not `tag`: a
+     * drawing's `text` is kept as `svg:text` and is still `text` to `.chart text`.
+     */
+    typeName?: string;
+    /**
+     * The namespace a renderer created the element in where an extension names elements in one,
+     * as Angular creates what is written inside an `<svg>`: a library's drawing, whose shapes are
+     * painted and given their font as a browser does. An icon's shapes are created by name alone
+     * and have none, and commit as they always have.
+     */
+    namespace?: string;
     props: Record<string, unknown>;
-    text: string;
-    children: EngineNode[];
+    nodeText: string;
+    childList: EngineNode[];
     parent: EngineNode | null;
     listeners: Map<string, Set<(event: unknown) => void>> | null;
     /** CSS classes on this node, for selector matching. */
     classes: Set<string> | null;
     /** The compiled stylesheet of the component that created this node, if any. */
-    sheet: StyleSheet | null;
+    templateSheet: StyleSheet | null;
     /** The sheet of the component this node hosts, if it hosts one. What `:host` matches against. */
     hostSheet: StyleSheet | null;
     /** Custom properties set on the node itself; see `StyleTarget.customProperties`. */
@@ -226,9 +247,14 @@ export interface EngineNode extends HostNode {
     touchWithin?: boolean;
     /**
      * The paragraph the engine makes around a run of text written straight into a view. It is in no
-     * template and in no node's `children`: it holds the text, and commits where the text would.
+     * template and in no node's `childList`: it holds the text, and commits where the text would.
      */
     box?: EngineNode;
+    /**
+     * The paragraphs of a run of text beside a box in a line, one a word: see `wordBoxes`. In no
+     * node's `childList` either, and kept on the text as its one paragraph is.
+     */
+    words?: EngineNode[];
     /** A node the engine made, which no rule matches: it only inherits. */
     anonymous?: true;
     /** See `StyleTarget.styled`. */
@@ -254,12 +280,116 @@ export interface EngineNode extends HostNode {
      * are worked out again when the direction or alignment changes. Unset on every other node.
      */
     fitContainer?: string;
+    /**
+     * Whether a browser lays this element out inline, with no display of its own: `always`, as a
+     * span is, which is what the box that holds it reads; or `unless-block`, as a custom element
+     * is, which the engine lays out as an inline-block or as a block by what it holds. Set with
+     * `setInline`. Unset on every other node.
+     */
+    inlineLevel?: 'always' | 'unless-block';
+    /** Set by `scrollsOverflow`: with `overflow: auto` or `scroll` this element is a scroll view. */
+    scrollsOverflow?: true;
+    /** Set while this element is one: see `Engine.settleScrolling`. */
+    scrollView?: true;
+    /** The view a scrolling element's children are in, as it was last committed. */
+    inside?: {
+        handle: FabricNode;
+        childHandles: FabricNode[];
+    };
+    /** Set while `settleLine` has given an always-inline element a line for the boxes it holds. */
+    lined?: true;
+    /** Set while an always-inline element is a flex box or a grid by its own style. */
+    boxed?: true;
+    /**
+     * How this node lays its children out as a block container, and which of them are in its flow:
+     * made on each reconcile from its children's styles, so a child added, removed or restyled is
+     * followed. Unset on every node that is not a block container. See `flow.ts`.
+     */
+    flow?: Flow;
+    /**
+     * What an out-of-flow box is committed with in place of what Yoga cannot resolve: its `auto`
+     * margins as lengths, or the place it would have had in the flow. A null takes the prop away.
+     * See `settleAbsolute`.
+     */
+    resolved?: Readonly<Record<string, number | null>>;
+    /** Where a `position: sticky` box sticks, and how far it is moved now. See `settleSticky`. */
+    sticky?: StickyState;
+    /**
+     * The node a `position: fixed` box is committed under in place of its parent: the page it is
+     * on, or the root. Unset on every node that is not fixed.
+     */
+    fixedTo?: EngineNode;
+    /**
+     * Set once a child of this node has had an `order`: its children are then committed in that
+     * order, which Yoga has no property for. Left set, since sorting children with none is nothing.
+     */
+    ordered?: boolean;
+    /**
+     * A box in a line of a block, which is as wide as its content: the width that came to, read
+     * back with the percentages inside it set aside, and whether it has to be read again. See
+     * `settleFits`.
+     */
+    fit?: {
+        dirty: boolean;
+        width?: number;
+        room?: number;
+        grown?: EngineNode[];
+    };
+    /**
+     * The least width a box is held to because a fitted box in it overflows its room: a browser's
+     * flex item is no narrower than its content, which Yoga's is. See `growAround`.
+     */
+    fitMin?: number;
+    /** Set on a box inside one being fitted, while its percentage width and zero basis are off. */
+    fitOff?: boolean;
+    /**
+     * The declarations of this node that are a percentage with a length added, `calc(100% - 2rem)`,
+     * what each came to against the box the percentage is of, and that box's size then. See
+     * `settleMixed`. Set on `mixedOff` while that box is measured with them set aside.
+     */
+    mixed?: MixedState;
+    mixedOff?: boolean;
+    /** The line box this node is the first box of, as it was last committed. See `inLines`. */
+    line?: LineBox;
+    /**
+     * Set on an item in a row whose automatic minimum width is read from what it holds: whether
+     * text in it has somewhere to wrap. Anything changing under it has it asked again.
+     */
+    autoMin?: boolean;
+    /**
+     * The narrowest an item that takes a share of its row goes, read from a commit of it at its
+     * content's width with its words a line each, or nothing until it is read: see
+     * `settleMinimums`. Set while `shareMin` says the item's minimum is to be measured.
+     */
+    shareMin?: {
+        width?: number;
+        share?: number;
+    };
+    /** Set while that commit is made: the item is as wide as its content, with no share. */
+    shareOff?: boolean;
+    /** Whether this node's children were last laid out along a row. See `autoMinimum`. */
+    row?: boolean;
+    /** How this node lays its children out as a grid. Unset on every node that is not one. */
+    grid?: GridState;
+    /** The grid this node was last an item of. Its `grid` says whether it still is. */
+    gridIn?: EngineNode;
+    /** The block container whose flow this node was last in. Its `flow` says whether it still is. */
+    flowIn?: EngineNode;
     /**
      * Whether this node had a height a percentage could be taken of, when a box beneath it with a
      * percentage height last asked, as `definiteHeight` says it. Compared on each reconcile so its
      * children are worked out again when it changes. Unset on every other node.
      */
     heightBasis?: boolean;
+    /**
+     * The height a box as tall as its content is committed at, so that a percentage height in it
+     * is of that height, and the width it had then. See `settleHeld`.
+     */
+    heldAt?: {
+        height: number;
+        width: number;
+        inner: number;
+    };
     /**
      * Per-property transition state, for every property this node has ever seen a `transition` for.
      * A finished entry stays, because its target is what the next change is measured against.
@@ -307,6 +437,8 @@ export interface EngineNode extends HostNode {
     nativeView?: true;
     /** Props kept for selectors to match and left out of what is committed. See `keepAsAttribute`. */
     attributeOnly?: Set<string>;
+    /** Attributes a package keeps apart from props, for selectors alone. See `keepAttribute`. */
+    keptAttributes: Record<string, string> | undefined;
     /**
      * Set by whoever needs to know which props have been written: each `setProp` with a value adds
      * its key, even one equal to the value already there, and one with `undefined` or `null` takes
@@ -332,7 +464,7 @@ export interface EngineNode extends HostNode {
     dormantHoists?: EngineNode[] | null;
     committed: Committed | null;
     /** The node this one was committed as a child of, which native holds it to for its life. */
-    committedUnder: EngineNode | null;
+    committedUnder: EngineNode | LineBox | null;
     /** The hoisted views this node keeps committed for, by element name. See `HoistOptions`. */
     kept?: Map<string, KeptHoist>;
     /** On a text field, the row aligned by baseline that takes a baseline from it: `lineBaseline`. */
@@ -369,6 +501,13 @@ export declare function declareNativeProps(elementName: string, props: Iterable<
  * host primitive's constructor; see `EngineNode.claimed`.
  */
 export declare function claimHost(node: HostNode): void;
+/**
+ * Say that an element scrolls what overflows it, as a browser's does: with `overflow: auto` or
+ * `scroll` it is committed as a scroll view, around one view that holds what it holds. For a
+ * package that gives elements a browser's behaviour. Any other element keeps the view it is,
+ * and its `overflow` is layout alone.
+ */
+export declare function scrollsOverflow(node: EngineNode): void;
 /**
  * Mark an element as the host of a component. The platform adapter calls this from
  * `RendererFactory2.createRenderer`, which Angular calls once for every component it mounts,
@@ -389,6 +528,141 @@ export declare function nativePlatform(): string;
  * only the mapping half is a no-op elsewhere.
  */
 export declare function registerPlatformComponents(platform: string): void;
+/** A sticky box: the scroll offsets it moves between, and what moves it. */
+interface StickyState {
+    scroll: EngineNode;
+    axis: ScrollAxis;
+    /** The offset it starts moving at, and the one it stops at: the end of its parent. */
+    start: number;
+    stop: number;
+    /** How far it is moved, as written on its transform. */
+    shift: number;
+    drive: ComposedDrive | null;
+    /** Its own transform as a transition native plays has it, which the drive applies after it. */
+    lent?: readonly FollowingTransform[];
+}
+/**
+ * A grid container between the commit that changed it and the commit that places its items.
+ *
+ * Yoga has no grid, so its items are taken out of the flow and placed by the engine, from sizes
+ * read back from Fabric. `measuring` commits each item with no size, to be read at the size its
+ * content wants; `sizing` commits the items whose height at a column's width is wanted, at that
+ * width; `placed` commits each where the grid puts it.
+ */
+interface GridState {
+    phase: 'measuring' | 'words' | 'sizing' | 'placed';
+    /** Laid out since it or anything in it last changed. */
+    settled: boolean;
+    members: readonly EngineNode[];
+    /** Each item's size with its content as wide as it wants. */
+    content: Map<EngineNode, {
+        width: number;
+        height: number;
+    }>;
+    /**
+     * Each item's width with its content as narrow as it goes, read where the layout asked: its
+     * text is committed one word to a line, `words`, and the widest of them is that width.
+     */
+    narrow: Map<EngineNode, number>;
+    /** Set by a layout that asked for a width `narrow` does not have yet. */
+    wantsNarrow: boolean;
+    /** Each item's height at a width, for the widths the layout asked about. */
+    heights: Map<EngineNode, Map<number, number>>;
+    /** The widths being asked about, while `sizing`. */
+    widths: Map<EngineNode, number>;
+    /** Where each item goes, against the container's padding box, once `placed`. */
+    rects: Map<EngineNode, Rect>;
+    /** The width of the box it was last laid out in, and the height it then came to, if its own. */
+    width?: number;
+    height?: number;
+    /** The width its tracks came to, where nothing else gives it one. */
+    ownWidth?: number;
+    /**
+     * How far down each item's baseline is at a width, read as Yoga lines items up in a row: see
+     * `gridWithHeights`. Set on `inRow` while the items are committed that way to be read.
+     */
+    baselines: Map<EngineNode, Map<number, number>>;
+    /** Each item whose baseline the last layout asked for, and the width it asked at. */
+    asked: Map<EngineNode, number>;
+    wantsBaseline?: boolean;
+    inRow?: boolean;
+    /** The grid lines a placement names, from the last layout: what an out-of-flow child is against. */
+    area?: GridLayout['area'];
+    stopListening?: () => void;
+    /** Its style and each item's as it was last laid out, and what each item held: see `follows`. */
+    styled?: string;
+    styles?: Map<EngineNode, string>;
+    shapes?: Map<EngineNode, string>;
+    /**
+     * The items changed in or beneath since it was laid out, with no cause yet to lay it out
+     * again, and how far the content of each reached before the change.
+     */
+    followed?: Map<EngineNode, Reach>;
+    /** How far each of those reached after the last such change, which is before the next. */
+    reached?: Map<EngineNode, Reach>;
+}
+/** How far down an item's content reaches in it, and whether it reaches past its right edge. */
+interface Reach {
+    bottom: number;
+    over: boolean;
+}
+interface MixedState {
+    /** Each declaration as its two parts: a percentage, and points added to it. */
+    parts: Record<string, {
+        percent: number;
+        points: number;
+    }>;
+    /** What each came to, or nothing before the box it is of has been read. */
+    values?: Record<string, number>;
+    /** The size of that box when they were worked out: a change in it works them out again. */
+    base?: readonly [number, number | undefined];
+    dirty: boolean;
+}
+/** A block container's plan, and the children it covers. */
+interface Flow {
+    readonly plan: FlowPlan<EngineNode>;
+    readonly members: ReadonlySet<EngineNode>;
+    /** The boxes in a line box among blocks, each named by the first box of its line. */
+    readonly lined: ReadonlyMap<EngineNode, EngineNode>;
+    /**
+     * The room its lines need under the baseline, as `hang` works it out: of a block of lines, and
+     * of each line among blocks by its first box.
+     */
+    under?: number;
+    unders?: ReadonlyMap<EngineNode, number>;
+    /** How far each box on a line sits over the bottom of it, as a margin: see `onBaseline`. */
+    lifts?: ReadonlyMap<EngineNode, number>;
+    /** How far each box of a known height is moved down its line, as a margin: see `liftLines`. */
+    rises?: ReadonlyMap<EngineNode, number>;
+    /** Whether a box of each line reaches as high as its strut, which then holds it no taller. */
+    risen?: boolean;
+}
+/**
+ * A line box as it was last committed, kept on the first box of its run. It is what its boxes
+ * are committed under: a box whose line box is another view is made again, since native never
+ * moves a view to another parent. No view yet, before the first commit of it.
+ */
+interface LineBox {
+    handle: FabricNode | null;
+    top: number;
+    /** Where its boxes sit along it, by the `text-align` its container has: see `alongLine`. */
+    along?: string;
+    /** How tall its strut holds it, and the room in that under the baseline: see `lineStrut`. */
+    strut?: LineStrut;
+    handles: readonly FabricNode[];
+    in: EngineNode;
+}
+/**
+ * A line box: the view a run of inline-level boxes among blocks is committed in, which no node
+ * of the app stands for. A row that wraps, with its boxes on the bottom of each line as empty
+ * boxes sit on a baseline. It is static and takes no touch, so what is placed or pressed inside
+ * it is placed against and reaches the same boxes as if it were not there.
+ */
+/** A line box's strut, as the props of the row it is: see `lineStrut`. */
+interface LineStrut {
+    minHeight: number;
+    alignContent: string;
+}
 /**
  * Register a codegen'd third-party Fabric component, e.g.
  * `registerViewName('rns-screen', 'RNSScreen')`, which is how the router reaches
@@ -399,7 +673,7 @@ export declare function registerPlatformComponents(platform: string): void;
  * and skipping it is not cosmetic: `RNSScreenStackHeaderConfig` without its `position: absolute`
  * joins the screen's flex layout and pushes every page down by the height of the header.
  */
-export declare function registerViewName(elementName: string, viewName: string | PlatformViewName, defaultProps?: Record<string, unknown>, options?: ViewNameOptions): void;
+export declare function registerViewName(elementName: string, viewName: string | PlatformViewName, defaultProps?: Record<string, unknown>, options?: ViewNameOptions): () => void;
 /** What else a registered view needs the engine to know about it. */
 export interface ViewNameOptions {
     /**
@@ -421,6 +695,12 @@ export interface ViewNameOptions {
      * element is the engine's own, as the paragraph a view is given for its loose text is.
      */
     readonly looseText?: string;
+    /**
+     * Whether the text content it takes as a prop keeps its spaces, as a span of an SVG text does:
+     * a run of them is one space, dropped only before the first words of what it is in and after
+     * the last, since the next span's words follow on the same line.
+     */
+    readonly spacedText?: boolean;
     /**
      * Where a view's own props name a font that must reach native by another name, as SwiftUI's
      * `font` modifier must name a face by its file's PostScript name: rewrites `props` in place,
@@ -440,6 +720,8 @@ export interface PlatformViewName {
     readonly ios: string;
     readonly android: string;
 }
+/** An element's registered view name, for the platform the host reported. */
+export declare function registeredViewName(elementName: string): string | undefined;
 /** Hear about faces registering with the platform, until the returned function is called. */
 export declare function onFontsRegistered(listener: (families: ReadonlySet<string>) => void): () => void;
 /**
@@ -470,8 +752,10 @@ export declare function fontsSettled(families: Iterable<string>): void;
  * just after the ancestor's child it was written in, or after all of them when it was written in
  * the ancestor itself, which keeps a page's scroll view ahead of its header as UIKit's large
  * title wants. A node with no such ancestor commits where it is.
+ *
+ * Answers what takes the registration away again, for a package that can be taken out.
  */
-export declare function registerHoist(elementName: string, ancestorName: string, options?: HoistOptions): void;
+export declare function registerHoist(elementName: string, ancestorName: string, options?: HoistOptions): () => void;
 export interface HoistOptions {
     /**
      * Props for a native view the ancestor keeps once the element has committed into it.
@@ -512,16 +796,20 @@ interface KeptHoist {
 }
 /** The part of a node `viewNameOf` reads: an engine node, or any host's mirror of one. */
 export interface ViewNameNode {
-    readonly kind: string;
+    readonly nodeKind: string;
     readonly tag: string;
     readonly parent: ViewNameNode | null;
     /** Whether a component is mounted on it, and whether that component is the native view. */
     readonly componentHost?: boolean;
     readonly nativeView?: boolean;
     /** What it holds, which decides whether one of HTML's text elements is text or a view. */
-    readonly children?: readonly ViewNameNode[];
+    readonly childList?: readonly ViewNameNode[];
     /** Set on the paragraph the engine makes for a run of text written straight into a view. */
     readonly anonymous?: boolean;
+    /** Set on a text element that lays out what it holds itself: see `Engine.settleBoxed`. */
+    readonly boxed?: boolean;
+    /** Its props, of which `horizontal` decides which scroll view a scroll view is on Android. */
+    readonly props?: Readonly<Record<string, unknown>>;
 }
 /**
  * The native view a node commits as: `Paragraph` for a `<text>`, `VirtualText` for one nested in
@@ -531,10 +819,24 @@ export interface ViewNameNode {
  * Exported for tools that show a template beside what it becomes, such as the X-ray in the
  * documentation's course, which labels `@ng-native/web`'s DOM with these names. It reads the same
  * table the commit does, so after `registerPlatformComponents('android')` it answers for Android.
+ *
+ * Exempt from the complexity limit as `mergeProps` is: asked of every element several times a
+ * commit, where a call more for the name of a plain view measured slower in `pnpm bench`.
  */
 export declare function viewNameOf(node: ViewNameNode): string;
 /** Whether a value is one of the engine's own nodes. */
 export declare function isEngineNode(value: unknown): value is EngineNode;
+/**
+ * Give every node members of a package's own, on the prototype they share: a getter, a method.
+ * Returns what takes them away again.
+ *
+ * For a package that presents nodes to code written against another API, as a web-compatibility
+ * layer answers `getAttribute` and `closest` from a node's name and props. A field the engine
+ * keeps on a node (`nodeKind`, `props`, `childList`) is refused. A member a node already has on the
+ * prototype (`classList`, `addEventListener`) is replaced, and put back when the extension is
+ * taken away: what replaces it has to do what the original did for Angular.
+ */
+export declare function extendNodes(members: PropertyDescriptorMap & ThisType<EngineNode>): () => void;
 /**
  * RN-specific helpers, injected rather than imported so the engine stays runnable under Node.
  */
@@ -575,6 +877,14 @@ export interface EngineOptions {
      * which nothing knows until a view has been laid out - come through `updateTokens` instead.
      */
     tokens?: Readonly<Record<string, TokenValue>>;
+    /**
+     * `strict` lays the app out without Yoga's legacy errata, as a browser would: a percentage
+     * inset or size of an out-of-flow box is of its container's padding box, and one with no inset
+     * starts inside the padding. `compatibility` keeps the errata and is the default, as it is in
+     * React Native, whose `experimental_LayoutConformance` takes the same two modes. Strict commits
+     * the app inside that view, which has no box of its own.
+     */
+    layoutConformance?: 'strict' | 'compatibility';
     /**
      * Report host primitives used without their component (see `claimHost`). Defaults to RN's
      * `__DEV__`, so a release build never looks.
@@ -627,6 +937,8 @@ export declare class Engine implements HostEngine {
     readonly root: EngineNode;
     private readonly fabric;
     private readonly rootTag;
+    /** Whether the app is laid out without Yoga's errata. See `EngineOptions`. */
+    private readonly strict;
     private readonly styles;
     /** Whether to run the development checks, which a release build skips. */
     readonly dev: boolean;
@@ -642,6 +954,11 @@ export declare class Engine implements HostEngine {
      * for them. Only those in the tree: see `releaseDetached`.
      */
     private readonly hoisted;
+    /**
+     * Whether a subtree that left the tree has ever held a hoisted node of its own: until one has,
+     * a node taken out has none to carry, and `carryHoists` does not walk up to look.
+     */
+    private hoistsHeld;
     /** The nodes taken out of a child list since the last commit. See `releaseDetached`. */
     private readonly removedSinceCommit;
     /**
@@ -671,8 +988,15 @@ export declare class Engine implements HostEngine {
     private readonly placeElsewhere;
     /** The sheets `watchStructure` has read, which it is asked about once an element. */
     private readonly watchedStructure;
-    /** Whether any sheet uses `:has()`. See `markBeneath`. */
+    /**
+     * The sheets in play that use `:has()`, each with whether it asks about what comes after a
+     * node, `:has(+ .x)`: see `hasBeside`. A sheet taken away asks no more.
+     */
+    private readonly hasWatched;
+    /** Whether any sheet in play uses `:has()`. See `markBeneath`. */
     private hasSheets;
+    /** Whether any asks about what comes after a node. See `markBefore`. */
+    private hasBesideSheets;
     private readonly resolveAssetSource;
     constructor(fabric: FabricUIManager, rootTag: number, options?: EngineOptions);
     /**
@@ -732,10 +1056,19 @@ export declare class Engine implements HostEngine {
      */
     addGlobalSheet(sheet: StyleSheet, replacing?: StyleSheet): boolean;
     /**
-     * Have styled again each node a sheet just added could match. The rest keep the style they
-     * have, which the resolver lets stand for a node none of the sheet's rules is written for,
-     * so a commit steps over them: the walk here is what finds the ones it must not step over.
+     * The sheets added since the last commit, whose nodes are not yet marked: see `markAdded`.
+     * Emptied by each commit. One taken away before it stays in the list, which only marks nodes
+     * it could have matched: taking a sheet away styles everything again in any case.
+     */
+    private readonly sheetsAdded;
+    /**
+     * Have styled again each node a sheet added since the last commit could match. The rest keep
+     * the style they have, which the resolver lets stand for a node none of the sheets' rules is
+     * written for, so a commit steps over them: the walk here is what finds the ones it must not
+     * step over. One walk for all of them: a screen of a component library adds a sheet for each
+     * component it renders for the first time.
      */
+    private markAdded;
     private markWrittenFor;
     /**
      * Stop matching a sheet `addGlobalSheet` added, and restyle everything; false, and nothing
@@ -801,6 +1134,11 @@ export declare class Engine implements HostEngine {
         visibleBottom?: number;
         margin?: number;
     }): void;
+    /**
+     * The view a scroll view's content is in: an element that scrolls its overflow holds its
+     * children in one of its own, and any other scroll view's first child is it.
+     */
+    private contentOf;
     /**
      * Commit one measured node again, cloned with its children, so Fabric measures it once more.
      *
@@ -829,10 +1167,23 @@ export declare class Engine implements HostEngine {
     private readonly viewportWatchers;
     /** Calls `listener` after each change of conditions, which is when `viewport` can change. */
     watchViewport(listener: () => void): () => void;
+    /**
+     * The conditions given to the constructor or to `updateConditions` last, or undefined before
+     * any, when the engine settles colours as light and has no size: what a package
+     * answering a media query from a script, `matchMedia`, reads the colour scheme and the motion
+     * preference from.
+     */
+    get conditions(): Conditions | undefined;
+    private lastConditions;
     updateConditions(next: Conditions): void;
     createElement(name: string, sheet?: StyleSheet | null): EngineNode;
     addClass(node: EngineNode, name: string): void;
     removeClass(node: EngineNode, name: string): void;
+    /**
+     * A node's classes as its `class` attribute is written, where a sheet reads the attribute as a
+     * whole: see `ClassChange`. Null where none does, and nothing is written.
+     */
+    private classAttribute;
     /**
      * Mark a node whose classes changed, by what the rules that name those classes can restyle.
      *
@@ -842,14 +1193,17 @@ export declare class Engine implements HostEngine {
      * or `.close:is(.animating *)`, the elements under the node that such rules are for. What is
      * under any of those is styled again from the rules it matched, for what it inherits: a `dark`
      * class on the root finds no rule again for an element no `dark` rule is for. One named in
-     * `:has()`, or answering a test of the class attribute there, has the boxes above the node
-     * asked again, and one named only in `:has(> )` the box right above it. Any other class has the node and everything under it matched again, as any
-     * other change to it does.
+     * `:has()`, or answering a test of the class attribute there, has the boxes above the node and
+     * those before it asked again, and one named only in `:has(> )` the box right above it. Any
+     * other class has the node and everything under it matched again, as any other change to it
+     * does.
      *
      * A sheet that names a class later restyles what it is for as it arrives, and a node not yet
      * committed is styled when it is, with the class as it is then.
      */
     private markClasses;
+    /** Mark the boxes whose `:has()` can ask of a node whose classes changed, by `reach`. */
+    private markHasAsking;
     /**
      * How many class changes have restyled what is under an element. `markUnder` walks the tree as
      * it is, so an element out of it then is not reached: one that comes back after any is matched
@@ -869,6 +1223,29 @@ export declare class Engine implements HostEngine {
      * under another is marked too: what is under an element marked this way keeps its rules.
      */
     private markUnder;
+    /** What the sheets in play give a generated box to, by the last thing their selectors name. */
+    private generated;
+    /** What each sheet in play gives a generated box to: `generated` is all of them together. */
+    private readonly generatedBySheet;
+    /**
+     * Note the elements a sheet's `::before` and `::after` rules are written for, and give the
+     * ones there already their boxes. Only a sheet compiled with them has any, which is a
+     * library's the build names as a browser's; for every other this reads the sheet once.
+     */
+    private watchGenerated;
+    /**
+     * A sheet has left play, by a hot swap or by being removed: the boxes only it gave go, from
+     * every element in the tree.
+     */
+    private unwatchGenerated;
+    /** `next` in play where `sheet` was: noted first, so a box both give is kept, not made again. */
+    private swapGenerated;
+    /** An attribute or the id a rule gives a generated box by came or went on an element. */
+    private generateFor;
+    private generateBeneath;
+    /** Keep a box first and last in an element a rule could draw one for, and nowhere else. */
+    private generate;
+    private keepGenerated;
     /**
      * The sheet of the component `node` hosts, whose `:host` rules it matches. Set again when a hot
      * swap replaces the component's sheet, which recreates the views inside but not the host, so the
@@ -881,6 +1258,19 @@ export declare class Engine implements HostEngine {
      * the web's mount point has, unless the app's `:host` sizes it otherwise.
      */
     setDefaultStyle(node: EngineNode, style: Readonly<Record<string, unknown>> | undefined): void;
+    /**
+     * What a default style asks for. The root component's host is given the surface's height as a
+     * percentage of it, and the surface's height is native's, which nothing is held at: an app of
+     * plain flex that `mount` gives that height is asked nothing for it. See `noteShare`.
+     */
+    private defaultAsks;
+    /**
+     * Say that a browser lays an element out inline, for a package that gives elements a
+     * browser's defaults. `unless-block` is an element with no display of its own, a custom
+     * element: its default display is the engine's from here, an inline-block while it holds only
+     * text and inline-level boxes and a block once it holds one, which cannot sit in a line.
+     */
+    setInline(node: EngineNode, how: 'always' | 'unless-block' | undefined): void;
     /**
      * `class="a b"` from a template. Replaces the set rather than adding to it. The same classes in
      * another order are a change too, to a selector that reads the class attribute, `[class^="a"]`.
@@ -910,8 +1300,20 @@ export declare class Engine implements HostEngine {
      * of the paragraph's outermost element, which is the view; any other change leaves it be.
      */
     private markWords;
+    /**
+     * A node taken out of a subtree that left the tree can take hoisted nodes of the subtree's with
+     * it, as content projected inside an element of an `@if` moves into the element made again when
+     * the block opens. All of the subtree's are woken, and the commit, which the removal makes
+     * release, puts each back with the subtree it is in.
+     */
+    private carryHoists;
     /** A subtree that went out of the tree is back in: its hoisted nodes commit again. */
     private wakeHoists;
+    /**
+     * Let go of what is placed from here, and of the pages fixed boxes are on, out of the tree: a
+     * box that comes back is placed again from the start.
+     */
+    private releasePlacements;
     /**
      * Let go of everything the engine holds for nodes that have left the tree.
      *
@@ -950,8 +1352,11 @@ export declare class Engine implements HostEngine {
     private topOf;
     /**
      * Angular calls this per node on view destroy, but only when `Renderer2.destroyNode` is
-     * non-null. Without it the listener sets on discarded nodes stay reachable from the
-     * closures Angular hands us, which is a slow leak on any screen that churns views.
+     * non-null. It is not always the end of the node: Angular calls it for the content an
+     * `<ng-content>` at the top of the view projects too, which belongs to the declaring view, and
+     * puts the same nodes back when the view is made again. So what is let go here comes back when
+     * the node does, and its listeners stay: each goes when the view or directive that added it
+     * tears it down, and Angular does not listen again for content it puts back.
      */
     destroyNode(node: EngineNode): void;
     parentNode(node: EngineNode): EngineNode | null;
@@ -966,8 +1371,15 @@ export declare class Engine implements HostEngine {
     private eased;
     /** Note a sheet any of whose rules transitions or animates: see `eases`. */
     private noteSheetEasing;
-    /** Note a prop, or a style set as one, that transitions or animates: see `eases`. */
+    /**
+     * Note a prop, or a style set as one, that transitions or animates: see `eases`. Asked of every
+     * prop and declaration set until one does, so it reads the keys where they are, copying none.
+     */
     private noteEasingProp;
+    /**
+     * Exempt from the complexity limit deliberately, as `mergeProps` is: run for every prop Angular
+     * writes, where a call more for what a value asks of the engine measured slower in `pnpm bench`.
+     */
     setProp(node: EngineNode, key: string, value: unknown): void;
     /**
      * Have the paragraph a run of text is in merged again: it is as tall as the tallest line of
@@ -999,6 +1411,13 @@ export declare class Engine implements HostEngine {
      * static attribute that is an input of the host's component.
      */
     keepAsAttribute(node: EngineNode, key: string): void;
+    /**
+     * Keep an attribute of a node apart from its props: matched by a selector, over a prop of the
+     * same name, and committed to nothing. For a package that keeps attributes a native view reads
+     * under other names, as `@ng-native/web-compat` keeps a drawing's `width`. What depends on it is
+     * restyled as it would be for a prop; `null` or `undefined` takes it away.
+     */
+    keepAttribute(node: EngineNode, name: string, value: string | null | undefined): void;
     /**
      * Whether a node's inline style can change what it or anything below it resolves to: it sets,
      * or until now set, a property its children inherit.
@@ -1006,6 +1425,8 @@ export declare class Engine implements HostEngine {
     private inlineReachesStyle;
     /** Whether a node's inline style sets `direction`, remembering that one has. */
     private noteInlineDirection;
+    /** Note what a prop just set asks for: a style, or one declaration of one. */
+    private askedBy;
     /**
      * The style object a node already holds has been changed in place.
      *
@@ -1014,7 +1435,7 @@ export declare class Engine implements HostEngine {
      * there and may write into it; this is how it says so, since nothing about the object's identity
      * has changed for the props diff to notice.
      */
-    styleChanged(node: EngineNode): void;
+    styleChanged(node: EngineNode, key?: string): void;
     /**
      * A bound declaration, `[style.color]`, whose value may be a `var()`, or a length in `em` or a
      * viewport unit. One that is, is kept as a declaration the cascade settles with the node's
@@ -1023,6 +1444,8 @@ export declare class Engine implements HostEngine {
      * answered too. Any other value forgets what was kept.
      */
     setBoundStyle(node: EngineNode, prop: string, value: unknown): boolean;
+    /** Keep a bound declaration for the cascade to settle, or forget the one kept, with `null`. */
+    private keepBound;
     /** Whether a bound value is one CSS has none of, which is dropped with a warning. */
     private refusedBound;
     /**
@@ -1039,13 +1462,44 @@ export declare class Engine implements HostEngine {
     private markProps;
     /** Start matching ancestors again on a change, once a sheet that uses `:has()` is in play. */
     private watchHas;
+    /** A sheet has left play: what it asked of `:has()` goes with it. */
+    private unwatchHas;
+    /**
+     * Have caches keep the rules each node matched while a sheet in play compares with them, and
+     * stop once none does. A sheet that asks about a place in a child list is never unset.
+     */
+    private trackMatched;
     /**
      * Something at or beneath `from` changed: every node from there up may match a `:has()` rule
-     * it did not, or stop matching one, up to `upTo` and not it. They are matched again rather than
-     * marked for restyling, which would restyle everything under them. Only sheets that use
-     * `:has()` pay.
+     * it did not, or stop matching one. They are matched again rather than marked for restyling,
+     * which would restyle everything under them. Only sheets that use `:has()` pay. `changed` is
+     * the child of `from` that changed, or `at` where in its list one came or went.
      */
     private markBeneath;
+    /** The boxes from `from` up, to `upTo` and not it, to ask `:has()` again: see `markBeneath`. */
+    private markAsked;
+    /** `markBefore` for a change to `changed` in `parent`'s list, or one coming or going at `at`. */
+    private markBeside;
+    /**
+     * By child list, how many of its first children `markBefore` has marked since the last commit,
+     * which marks no more of them again: a list that gains its items one at a time is not looked
+     * through once for each. A child coming or going before that many brings it down to where.
+     */
+    private readonly markedBefore;
+    /**
+     * By child list, how many of its first children `markRepositioned` has marked for their place
+     * from the end since the last commit: a list that gains its items one at a time at its end is
+     * not looked through once for each.
+     */
+    private readonly placesMarked;
+    /** By child list, the first of the children `markAllAfter` has marked with all after it. */
+    private readonly placesMarkedAfter;
+    /**
+     * `:has(+ .x)` and `:has(~ .x .y)`: a change in `parent`'s list at `at` can change what the
+     * elements before it match, and so can one beneath a box for the elements before that box.
+     * Each is matched again, as an ancestor is. Only sheets that ask about what comes after pay.
+     */
+    private markBefore;
     /**
      * The boxes rules ask `:has()` of above the node they style, `.card:has(.x) .title`, by the
      * sheet that asks: a sheet replaced or taken away asks no more.
@@ -1069,6 +1523,12 @@ export declare class Engine implements HostEngine {
      * together. What was walked under it and above it, which is `above` where it asks no more.
      */
     private markUnderBox;
+    /**
+     * Have matched again each element after `node` that one of `subjects`' rules could be for, and
+     * each under one of those: what `.card:has(.x) ~ .title` is for, where the card is `node`.
+     * One already reached for `subjects` in this pass had all after it reached with it.
+     */
+    private markAfter;
     /**
      * What `node` matches changed, which the elements after it can read: as many of them as a rule
      * steps along from one, every one for a `~`, and none where no sheet steps at all.
@@ -1090,6 +1550,12 @@ export declare class Engine implements HostEngine {
      * may have stopped or started being first. Nothing comes after the two at the end.
      */
     private markRepositioned;
+    /**
+     * Mark every element after a change at `at`, where a sheet asks about any element before
+     * (`~`). Those after the last change marked so since the commit are marked still, wherever they
+     * moved to: a list losing its rows first to last is not looked through once for each.
+     */
+    private markAllAfter;
     /**
      * A child's place in its list changed, which is all that changed about it. It is matched
      * again, and keeps its style and all that is under it unless it now matches other rules: its
@@ -1100,13 +1566,28 @@ export declare class Engine implements HostEngine {
      */
     private markPlace;
     /**
-     * Whether a rule could read this element's place from another element. By its classes alone,
-     * which every such compound it could be asks for: a compound with none could be any element.
+     * Whether a rule could read this element's place from another element. By its classes and its
+     * element name, which every such compound it could be asks for: one with neither could be any.
      */
     private placeReadFromUnder;
     /** Note what a sheet coming into play asks about a child list. None is unset: see `structural`. */
     private watchStructure;
     /** Walk up until we hit a node already known to have a dirty subtree. */
+    /**
+     * Whether anything has been marked since the last commit that could move layout: everything
+     * is, but a frame of an animation that only paints. A commit of such frames alone plans no
+     * layout and reads nothing back: a spinner turns on every frame for as long as its page is
+     * open, and the page's layout is the same on each of them.
+     */
+    private layoutStale;
+    /** Set while a frame of an animation marks a node whose animated props only paint. */
+    private paintTick;
+    /** Set for the length of a commit that nothing but such frames led to. */
+    private paintOnly;
+    /** Mark a node for a frame of its animation or transition, which moved these props. */
+    private tick;
+    /** Tell the host the tree is dirty: what its listener changes is no frame that only paints. */
+    private dirtied;
     private markPath;
     private isClean;
     /**
@@ -1116,6 +1597,8 @@ export declare class Engine implements HostEngine {
      * optimisation.
      */
     commit(): boolean;
+    /** Count a commit that reached native, and how long it took, in `stats`. */
+    private countCommit;
     /** A field went out of view focused, in the commit running: see `undisplayed`. */
     private blurAfterCommit;
     private blurHidden;
@@ -1157,6 +1640,8 @@ export declare class Engine implements HostEngine {
     driveByScroll(view: EngineNode, scroll: EngineNode, axis: ScrollAxis, range: ScrollRange, statics?: readonly StaticTransform[]): ScrollDrive | null;
     /** See `HostEngine.driveByEvent`. */
     driveByEvent(view: EngineNode, source: EngineNode, feed: EventFeed, property: DrivenProperty, range: ScrollRange, statics?: readonly StaticTransform[], shift?: number | null): ScrollDrive | null;
+    /** See `driveByEvent`: a drive whose transform after its move can change. */
+    private composedDrive;
     /**
      * `transitionstart` and `transitionend`, for anything listening.
      *
@@ -1190,6 +1675,613 @@ export declare class Engine implements HostEngine {
      */
     private readonly lettingGo;
     private letGo;
+    /** Everything the engine lays out in Yoga's place, from the commit just made. */
+    private settleLayout;
+    /** Note a node that is settled after layout: by a sum of a share and a length, or its least. */
+    private noteSettled;
+    /** The items whose minimum width is measured: see `shareMinimum`. */
+    private readonly minimums;
+    /** Those whose text is committed a word to a line, while how narrow they go is read. */
+    private narrowed;
+    private inWords;
+    /**
+     * Read how narrow each item that takes a share of its row goes, where that is not known or
+     * something in the item changed: all of them committed as wide as their content with their
+     * words a line each, read, and committed again with that as their minimum. Two commits for
+     * all of them together, and none where nothing in any of them moved.
+     */
+    private settleMinimums;
+    /** The boxes under a node whose width is capped at a share of what they are in. */
+    private noWiderThanRoom;
+    /** Share each row out again where its room or its items changed, with no minimum to read. */
+    private reshare;
+    /**
+     * Work out each item's share of its line again, for every row whose items all grow into it
+     * from nothing, and answer the items whose share is another than it was. A row with any other
+     * item in it, one with a width or as wide as its content, is left to Yoga with its items'
+     * minimums: what such an item takes of a line is not known until the line is laid out.
+     */
+    private sharedAgain;
+    /** An item of a row that is laid out in it: displayed, and not out of the flow. */
+    private inFlowOfRow;
+    /** An item as `lineShares` takes one, or nothing for one that does not grow from nothing. */
+    private sharerOf;
+    /**
+     * An item that takes no share of its row, as what it takes of a line: the width it was laid
+     * out at. Nothing for one that grows from its content, whose width is the line's to give.
+     */
+    private unsharing;
+    private gapOf;
+    private wrapsRow;
+    /** Whether an item's minimum is to be read: it never was, or something in it moved or grew. */
+    private minimumIsStale;
+    /** Reconcile what is dirty and hand the tree to Fabric, which lays it out before returning. */
+    private commitTree;
+    private commitWhole;
+    /** The fixed boxes each page, or the root, is committed with. */
+    private readonly fixedIn;
+    /** Boxes found to be fixed while they were being committed under their parent. */
+    private readonly fixedLate;
+    /** What a finger is on, while one is down. */
+    private fingerOn;
+    /** Boxes that became fixed or absolute with the finger on them, left under their parents. */
+    private readonly fixedUnderFinger;
+    /** Note what a finger comes down on, and once the last has lifted move what waited for it. */
+    private trackFinger;
+    /** The page a box is on: the nearest view that holds one, or the root. */
+    private pageOf;
+    /** Whether anything between a box and its page scrolls or clips what is inside it. */
+    private scrollsOrClips;
+    /**
+     * Note a node that has become `position: fixed` inside something that scrolls or clips, which
+     * a fixed box does neither with: it is committed under its page in place of its parent. It is
+     * being reconciled under its parent as this is asked, so it is committed there once more and
+     * moved straight after: see `moveFixed`. Anywhere else a fixed box stays where it is, and is
+     * placed against its page by `settleAbsolute`.
+     */
+    private refix;
+    /**
+     * The box an absolute box is placed against, where that is further up than its parent: one
+     * under a parent that is not positioned. A browser clips such a box by nothing between the
+     * two, where a native view is clipped by every view it is in, so where one of them clips it is
+     * committed under the box it is placed against, as a fixed box is under its page.
+     */
+    private placedAbove;
+    /**
+     * Whether a child is committed under its page, and not under its parent. On Android a fixed box
+     * is taken there before its parent commits it, so that it is never moved: Android mounts a
+     * view moved out of boxes of layout alone wrongly. See `clipsFixed`.
+     */
+    private onPage;
+    /** Whether a box committed under another still is to be: asked in place of committing it under its parent. */
+    private staysFixed;
+    /** The view each page's fixed boxes are committed in, and what it was last committed with. */
+    private readonly fixedLayers;
+    /**
+     * The fixed boxes pinned to `page`, committed after its own children so they draw over them,
+     * in a view over the whole page: Android's screen view clips each view in it to that view's
+     * bounds, and a fixed box draws past its own, as a toaster of no height draws its toasts.
+     */
+    private fixedHandles;
+    /** The view `fixedHandles` puts a page's fixed boxes in: the same view each commit. */
+    private fixedLayer;
+    /** The fixed boxes pinned to `page`, as they are committed. */
+    private fixedBoxes;
+    /** Whether anything between a node and `page` is `display: none`. */
+    private hiddenBelow;
+    /** Commit again with each box that has just become fixed under its page, in the same task. */
+    private moveFixed;
+    /**
+     * What the engine lays out in Yoga's place, for a node being reconciled: a block's flow, a
+     * grid, and a fixed, sticky or out-of-flow box. Its display and position are read once here,
+     * since this is asked of every node reconciled and most are none of these.
+     */
+    private relayout;
+    /**
+     * `replan` for an app nothing in which has asked for a layout of CSS's: what a box of plain
+     * flex can still need of the engine, a share of a box as wide as its content and a
+     * percentage with a length added. See `asked`.
+     */
+    private replanPlain;
+    /**
+     * What has been asked for that the engine works out in Yoga's place, as the bits of `asks`:
+     * by a sheet, a style or a package that gives elements a browser's defaults. Until something
+     * asks, a node is asked none of what that takes, which is most of what is asked of one: an
+     * app of native views and flex is laid out by Yoga alone. Nothing is taken back, as a sheet
+     * is never forgotten.
+     */
+    private asked;
+    private readonly checksAsks;
+    /** The boxes that asked for a layout of CSS's as they were merged: see `laidOut`. */
+    private readonly askedLate;
+    private want;
+    /** The sheets whose asks are in `asked` already: read once each, as a sheet does not change. */
+    private readonly askingSheets;
+    private watchLayout;
+    /**
+     * Commit the tree, and again where a box asked for a layout of CSS's as it was merged, by
+     * what it came to and no one declaration: it had been planned as a box of plain flex by
+     * then, so it is planned and merged again, now that it is asked what it was not.
+     */
+    private commitAsAsked;
+    /**
+     * A test run's check that nothing was left unasked: throw where a node being merged would
+     * be laid out by what no declaration has asked for, which a sheet or a style is not read for.
+     */
+    private checkAsked;
+    /** What a layout of CSS's would make of a node that no declaration asked for one of. */
+    private unaskedLayout;
+    /** Whether any element has been said to be inline: only then is any looked for. */
+    private inlines;
+    /**
+     * Settle the display of a box that is inline in a browser, and of each such box it holds:
+     * those first, since the plan about to be made for this one reads them, and each is reconciled
+     * after it.
+     */
+    private settleInlines;
+    /**
+     * Give an element that is text in a browser, a span or a label, a line to lay out what it
+     * holds in, once it holds a box: a label's words and the arrow after them are one line in a
+     * browser, and a view's children are a column. Nothing where it holds only text, which a text
+     * element lays out itself, or where it has a display of its own.
+     *
+     * ponytail: the elements that are text and nothing else. A button or a link with no display
+     * is inline too, and is left the flex box it has been: one as wide as an item that is as wide
+     * as its content, `width: 100%`, is as wide as the room where it sits in a line. Fit the item
+     * to its content first if a library leaves a button's display to the browser.
+     */
+    private settleLine;
+    /**
+     * A span that is a flex box or a grid by its own style is a view, and each span in it an item
+     * of it with a paragraph of its own: a toolbar's count, title and description, with a gap
+     * between them. Text all the way down is one paragraph otherwise, whatever its display.
+     */
+    private settleBoxed;
+    /** Give an element that is inline in a browser the display it has for what it holds now. */
+    private settleInline;
+    /** Whether a box holds a block-level box in its flow, through any box that is only inline. */
+    private holdsBlock;
+    /** Whether a box's display is the one the engine gave it for being inline in a browser. */
+    private inlineByDefault;
+    private replan;
+    /** Have a box fitted to its content again, and the item of a row it is a share of. */
+    private noteFits;
+    /** Whether a box is as wide as what it holds: an item of a row, or out of the flow. */
+    private fitsContent;
+    /**
+     * Whether a box with no width of its own is as wide as the box it is in: a block in the flow,
+     * or an item a column stretches. A share of it is then a share of that box.
+     */
+    private wideAsItsBox;
+    private refitted;
+    /**
+     * Whether a box is an item of a flex row with no width, share or basis of its own, which is
+     * as wide as its content: a dialog's pane, in a wrapper that centres it. A box in it that is
+     * `width: 100%` is as wide as the item, where to Yoga it is as wide as the room.
+     */
+    private itemOfRow;
+    /**
+     * Whether an item grows into its row from the width of what it holds, `flex: 1 1 auto`, and
+     * holds a text field as wide as it is. A browser starts it at the field's own width, its
+     * characters, and wraps the row on that; a native field holds nothing to be measured by, so
+     * the item is fitted as one with no share is, and grows from the width it comes to.
+     */
+    private growsFromField;
+    /**
+     * Ask an automatic minimum again: of this node when something under it changed, and of its
+     * children when it turns between a row and a column. See `autoMinimum`.
+     */
+    private reminimum;
+    /** The boxes that sit in a line of a block, and so are as wide as their content. */
+    private readonly fits;
+    /** Whether a box is an inline-level one in a block's flow: on a line, at its content's width. */
+    private sitsInLine;
+    /**
+     * Size each box that sits in a line from its content, where Yoga would size it from the room
+     * on offer: a box holding a row with a percentage width, or cells that share a row from a
+     * basis of nothing. The box is committed with those set aside, its width is read back, and it
+     * is committed at that width, which the percentages and the shares are then of.
+     */
+    private settleFits;
+    /** The boxes the commit being settled resized or moved, or moved others by: see `noteMoved`. */
+    private readonly movedBoxes;
+    /** Those that only came to hold more: words added to, a child more than there was. */
+    private readonly grownBoxes;
+    /** The nodes the commit being settled changed: their props, their style or their children. */
+    private readonly changed;
+    /**
+     * Those of them cloned with nothing that lays a box out: a colour, or what a screen reader
+     * is told, as a progress bar's value is each time it ticks. And those cloned with more.
+     */
+    private readonly quietly;
+    private readonly loudly;
+    /** Unset where a box went or the conditions changed, which can move any box: see `heldIn`. */
+    private changesHeld;
+    /** What `heldIn` answered, until something more is changed. */
+    private holders;
+    /** Asked only where a layout of the engine's reads it: see `want` for one asked in a commit. */
+    private noteChanged;
+    /**
+     * The boxes every change of the commit being settled is inside, where each is out of the flow
+     * with a width and a height of its own, or nothing where any change is not inside one. Yoga
+     * lays such a box out at the size it is given, so nothing in it moves a box outside it: a
+     * progress bar's indicator, in a track of a set size, can tick on a timer without anything
+     * else on the page being read back to see whether it has to be laid out again.
+     */
+    private heldIn;
+    /** The nearest box above a node that holds what changes in it, unchanged itself. */
+    private holderOf;
+    /** Note whether a node is cloned with more than how it is painted: see `heldIn`. */
+    private noteHow;
+    /** Whether a node was changed in the commit being settled by more than how it is painted. */
+    private movedItself;
+    private isFixedIn;
+    /**
+     * Whether a box can have moved in the commit being settled: see `heldIn`. One asked to be
+     * merged again is asked, too: a box read back at a new width is marked for nothing else.
+     */
+    private mayHaveMoved;
+    /**
+     * Leave each box that is fitted already as it is, where nothing in it or above it moved: a
+     * button pressed and painted another colour leaves the box around it the width it has. One
+     * as wide as its room is left as what it holds grows, too: an answer written a letter at a
+     * time wraps, and is no wider.
+     *
+     * ponytail: a word added that cannot wrap, and is wider than the room, is not reached past
+     * the room for until the box is next fitted. Read how far the content reaches if one is seen.
+     */
+    private standFitted;
+    /** The boxes whose own styles changed in this commit, while any box is fitted. */
+    private readonly restyled;
+    /**
+     * Have each fitted box under a box that was restyled fitted again. The room a box is in can
+     * come from far above it, through boxes that are each as wide as what they hold: an overlay's
+     * outer box is given the screen, and nothing between it and a calendar says so. The room
+     * read from the box's own parent is then the box's own width, and never changes.
+     */
+    private refitUnderRestyled;
+    /**
+     * Whether a box is to be fitted to its content again. One that is no longer fitted at all, or
+     * holds nothing sized by the room, is let go here, and one that stands as it is is left.
+     */
+    private toFit;
+    /**
+     * Fit boxes with nothing of each other in them: all committed with what is sized by the room
+     * set aside, read, and committed at the widths they came to. Two commits for all of them,
+     * where one at a time is two commits of the whole screen for each.
+     */
+    private fitTogether;
+    /**
+     * Lay out again each grid in a box whose content's share of the room was just set aside or
+     * given back. A grid keeps the width its tracks came to, which was worked out in whatever
+     * width it had then: a share of a pane not yet fitted is a share of nothing, and its columns
+     * are as narrow as a word.
+     */
+    private gridsAgain;
+    /**
+     * The width a box comes to from the commit just made of it, with what is sized by the room
+     * set aside. No wider than the room, and no narrower than what in it cannot get narrower:
+     * text wraps to the room, and a row of cells with a least width does not, so it reaches past
+     * the box's edge. A browser's box is that wide, and overflows the room it is in.
+     */
+    private fittedWidth;
+    /**
+     * Hold the boxes around a fitted box that overflows its room to its width: each one that is
+     * as wide as its content, out to the first with a width of its own or with room enough. A
+     * popover's panel around a calendar wider than the room the panel was given: in a browser a
+     * flex item is no narrower than its content, and the panel is drawn under all of the calendar.
+     */
+    private growAround;
+    /**
+     * Whether a box is as wide as its content and not as its room: out of the flow, on a line, an
+     * item of a row, or kept from stretching across a column. A block, and an item stretched
+     * across a column, is as wide as the room whatever it holds.
+     */
+    private sizedByWhatItHolds;
+    /** Let go of the boxes a fit was holding wider, and answer them, to be committed again. */
+    private ungrow;
+    /**
+     * Whether a box's fit still holds: nothing about it changed, and it was fitted in the room
+     * it is in now. A box is no wider than its room, so it is fitted again when that grows or
+     * shrinks, though nothing about the box did.
+     */
+    private fitStands;
+    /** How far right the boxes in a node reach, in the window: past its own edge where they overflow. */
+    private reachOf;
+    /** The room a fitted box is in now, as its parent was last laid out. */
+    private roomOf;
+    /** Stop fitting a box, and commit it again as written where it had been given a width. */
+    private unfit;
+    /**
+     * The boxes inside `node` that Yoga sizes from the room on offer and not from their content:
+     * one with a percentage width, and one that takes a share of a row from a basis of nothing.
+     * Nothing under a box with a width of its own in points is looked at: that width is its
+     * content's room whatever it holds.
+     */
+    private sizedByRoom;
+    /** The boxes a percentage height in them is of, or may be: see `settleHeld`. */
+    private readonly holds;
+    /** Note the box a node's percentage height or basis is of, which may be held for it. */
+    private noteShare;
+    /**
+     * Hold each box that a percentage height in it is of, and that is as tall as its content, at
+     * the height that came to: once the column it is in has sized it, a browser takes the
+     * percentage of that height (CSS Flexbox 9.8), where Yoga takes it of the space on offer. The
+     * box is read from a commit with each percentage in it set aside, as a browser sizes it, and
+     * committed at that height, which a percentage in it is then of and adds nothing to. It is read
+     * again when anything in it or beside it moves, and when its width changes.
+     */
+    private settleHeld;
+    /** A box's height as it was just committed, and the height of its content box then. */
+    private heldBox;
+    /** Whether a box is to be read again: not held yet, moved, or with something in it moved. */
+    private heldIsStale;
+    /** Whether a box is held: as tall as its content, sized by flex, and a percentage is of it. */
+    private holdsHeight;
+    /** The boxes with a declaration that is a percentage and a length: see `settleMixed`. */
+    private readonly mixeds;
+    /**
+     * Finish each `calc()` of a percentage and a length from the commit just made: read the box
+     * the percentage is of, and commit the box at what the sum comes to. A box in the flow is
+     * committed first with those declarations set aside, since the box it is in may be as wide as
+     * its content, and in a browser the percentage is of that width without them. It is worked out
+     * again when the box or anything in it changes, and when the box it is of changes size.
+     * Whether any was worked out.
+     */
+    private settleMixed;
+    /** Whether a box is to be worked out: it changed, or the box it is a share of did. */
+    private mixedIsStale;
+    /**
+     * Work out boxes that are not in one another with two commits between them: one with each
+     * set aside, to read what it is a share of, and one with each at what it comes to. A grid and
+     * a fitted box are sized from their content in commits of their own.
+     */
+    private settleMixedTogether;
+    /** What a node's sums come to against the box they are of, read now where none was given. */
+    private workOutMixed;
+    private commitTouched;
+    /** A translate moves nothing but the box itself: nothing is measured again for one. */
+    private mixedOnlyMoves;
+    private mixedInFlow;
+    /**
+     * Commit a node whose mixed declarations were set aside or worked out. A grid, and a box in
+     * a line, is sized from its content and keeps the width that came to, so it is sized again
+     * from the start: left as it was, it would be measured at the width its last limit gave it.
+     */
+    private commitMixed;
+    /**
+     * The box a node's percentages are of, with its mixed declarations set aside: a box in the
+     * flow can be what makes its container as wide as it is. One out of the flow makes nothing
+     * wider, so the box it is placed in is read as it stands.
+     */
+    private measuredBase;
+    /**
+     * The width and height a node's percentages are of: the padding box of what an out-of-flow
+     * box is placed in, and the content box of its parent for any other. The height is nothing
+     * where the parent was given none, as a percentage of an `auto` height is in a browser.
+     */
+    private mixedBase;
+    /** The out-of-flow boxes Yoga does not place as CSS does: see `settleAbsolute`. */
+    private readonly unplaced;
+    /**
+     * Note a fixed box, an out-of-flow one with an `auto` margin or no inset in a block, and one
+     * in a grid.
+     */
+    private reabsolute;
+    /**
+     * Resolve from the commit just made what Yoga leaves undone for an out-of-flow box, and commit
+     * again where anything changed: `auto` margins between two insets, which centre it, and the
+     * place in a block's flow it has with no inset. Both need its size and its container's.
+     */
+    private settleAbsolute;
+    /**
+     * Whether the commit being settled can have changed where an out-of-flow box is placed: it
+     * resized or moved something in the box it is placed against, or that box or one above it.
+     * A box is placed from its own size, its container's and what comes before it there, each
+     * read back from native, and a screen of buttons has one in each: read on every commit, a
+     * few hundred reads for a colour that changed somewhere else.
+     *
+     * A fixed box is asked every time: it is placed against its page, wherever it is written.
+     * So is one styled again itself, whose insets, margins or lines may be others while what it
+     * is committed with is the same.
+     */
+    /**
+     * The out-of-flow boxes found to need nothing resolved, placed as written: noted again each
+     * time one is reconciled, and placed again only for what concerns it, as one resolved is.
+     */
+    private readonly placedAsWritten;
+    /** The out-of-flow boxes whose own styles changed since they were last placed. */
+    private readonly restyledPlaced;
+    private concernedBy;
+    private resolveAbsolute;
+    /**
+     * An out-of-flow box, the box Yoga positions it by and the box CSS positions it against, each
+     * of the last two inside its border. They are one box unless it is fixed in place, where CSS
+     * means its page.
+     */
+    /** The area of a grid an out-of-flow item is placed in: none for a fixed one, on its page. */
+    private areaFor;
+    private boxesFor;
+    /**
+     * What an out-of-flow child of a grid is placed against: the area between the lines its
+     * placement names, in the window. A side it names no line for, or one the grid has not got,
+     * is the grid's padding edge. `by` is the grid's box inside its border.
+     */
+    private gridArea;
+    /** The box Yoga positions an out-of-flow node by: the nearest ancestor that is not static. */
+    private containingBlock;
+    /** A box inside its border, which insets are measured from. The root's is the window. */
+    private paddingBox;
+    /** A container's borders alone: an inset is measured from inside the border. */
+    private borderInsets;
+    /**
+     * Where a box with no vertical inset would have been in its block's flow: under the in-flow
+     * sibling before it and that sibling's bottom margin, which an out-of-flow box does not
+     * collapse with: Chrome has it under the margin, and its own margin under that. `origin` is the
+     * top of the container's padding box.
+     *
+     * ponytail: the sibling's own bottom margin, of points and over none. One its last child's
+     * margin collapses into, or a negative one, is a few points out; read the plan's margins if a
+     * box under a card's last paragraph is ever seen out.
+     */
+    private flowPlace;
+    /** The bottom of the line box `first` starts in `container`, from `origin`, once it is laid out. */
+    private lineBottom;
+    /** A box's own bottom margin, where it is points over none. */
+    private marginUnder;
+    /** Every `position: sticky` box in the tree. */
+    private readonly stickies;
+    /** Each scroll view with a sticky box in it: its offset, and what stops listening for it. */
+    private readonly stickyScrolls;
+    /**
+     * Work out where each sticky box sticks from the commit just made: its place in its scroll
+     * view, and the end of its parent, which it does not leave. Native moves it between the two
+     * where it can. A host with no layout to read leaves it where it is written.
+     */
+    private settleSticky;
+    /** The scroll view a box sticks in, or nothing once it is no longer sticky or in the tree. */
+    private stickyScroll;
+    private stick;
+    /** Have native move a sticky box between these offsets, of this scroll view on this axis. */
+    private redrive;
+    /**
+     * The scroll offsets a sticky box moves between, read from where the last commit laid it out:
+     * from its place in the scroll view less its inset, to the end of its parent.
+     */
+    private stickySpan;
+    private unstick;
+    /**
+     * Have native apply a sticky box's own transform after the move it drives: as a transition
+     * native plays has it while one does, and as it is committed otherwise.
+     */
+    private composeSticky;
+    /**
+     * Let a sticky box's move go: native stops driving it, and it is committed where it is. A
+     * transition of its transform native was easing in the drive is eased on from here.
+     */
+    private loosen;
+    /**
+     * Native goes on drawing what a drive set last once it is gone, which no commit changes (see
+     * `Touched`): a box's own transform is set there where it has one or the drive had moved it.
+     */
+    private undriven;
+    /** Write how far a sticky box is moved at its scroll view's offset, where that has changed. */
+    private shiftSticky;
+    /** Keep a scroll view's offset, and move its sticky boxes as it changes. */
+    private followScroll;
+    /** Every grid container in the tree, or once in it. */
+    private readonly grids;
+    /** Set while grids are laid out, when a node is reconciled for a phase and not for a change. */
+    private settling;
+    /** The children a grid places: elements in its flow, committed under it. */
+    private gridMembers;
+    /**
+     * Note a grid container reconciled for a change, in it or beneath it: its items are committed
+     * unsized in this commit, to be read and placed straight after it. Nothing is noted on a host
+     * with no layout to read back, where a grid stays the column it would otherwise be.
+     */
+    private regrid;
+    /**
+     * Whether a grid laid out already stays as it is for this commit: its own style and each
+     * item's are what it was laid out from, and its items are the same ones. What changed is then
+     * in an item or beneath one, and is committed as any change is; whether the grid has to be
+     * laid out again for it is asked once it has been, of what the change did: see `outgrown`.
+     *
+     * Laying a grid out is three commits, and most of what changes in one changes nothing it is
+     * sized from: a colour, a state, a bar a share of its track wide, a number as long as the last.
+     *
+     * ponytail: content that comes to want another width with no other sign of it (text of the
+     * same length in wider letters, a box beneath given a width) keeps the track it had until the
+     * grid is next laid out. Read each item's content width where a track is sized by it if a
+     * grid is seen a few points out.
+     */
+    private follows;
+    /** Whether a grid's style and its items, and each item's style, are what it was laid out from. */
+    private asLaidOut;
+    /** How far the content of a grid's item reaches, as it is laid out now. */
+    private reach;
+    /**
+     * Whether a change a grid was not laid out again for turns out to need it: an item holds
+     * more or less than it did, or its content reaches further down, or past its edge.
+     */
+    private outgrown;
+    /** Start a grid over: its items unsized, and nothing known about them. */
+    private restartGrid;
+    private ungrid;
+    private newGrid;
+    private regridIfResized;
+    private boxOf;
+    /** Have these nodes merged again in the next commit, without asking the host for one. */
+    private touch;
+    /**
+     * Lay out every grid that changed, or whose box did: read sizes from the commit just made,
+     * and commit again with each item placed. An inner grid is laid out once the outer one has
+     * given it a width, and the outer one again once the inner one has a height, so this repeats
+     * until nothing moves. All of it is in one task, so only the last commit is drawn.
+     */
+    private settleGrids;
+    private gridIsStale;
+    /**
+     * Whether a grid is another width than it was laid out at. Native answers in floats, and a
+     * box at a third of a point across is a hair off the width it was given.
+     */
+    private gridResized;
+    /** Those of some grids that are in another of them, or have another of them inside. */
+    private gridsNested;
+    /** Commit grids as stacks of their items, to read what each item holds: one commit for all. */
+    private measureGrids;
+    private settleGrid;
+    /** Note where a grid's layout puts it and its items, and answer how tall it came to. */
+    private placeGrid;
+    /** What a grid is laid out from, read from its style and from the commit that measured it. */
+    private gridRun;
+    /**
+     * A grid laid out in the width it has: its rows as tall as they come to, or held to its own
+     * least and most, or laid out in the row of the grid it is in where that stretches it. `rows`
+     * is set to what they came to, before any stretch.
+     */
+    private gridRows;
+    /**
+     * The width a grid gives itself, or nothing where something else gives it one. It was
+     * measured as a stack of its items at their content's width: wider than the widest of them,
+     * something gave it that width, and it is kept. As wide as the widest and no wider, nothing
+     * did, and it is as wide as its tracks come to, up to the width of what holds it, and within
+     * its own least and most.
+     */
+    private gridWidth;
+    /** The width inside a box's padding and border, which is the most a child of it is given. */
+    private roomIn;
+    private unsettleAbove;
+    /**
+     * The grid laid out, with each height it asks for read from a commit of those items at that
+     * width: a row is as tall as its items are at their columns' widths, which only laying them
+     * out there says.
+     */
+    private gridWithHeights;
+    /**
+     * Commit the items a layout asked the height of, each at the width it asked at, and read them.
+     * Baselines are read from a row of every item, lined up by them: see `gridContainer`. Each is
+     * counted from that row's baseline, so all that were asked for are read from the one row, and
+     * none is kept from a row before it.
+     */
+    private readSizes;
+    /** The grid whose items' text is committed one word to a line, while their words are read. */
+    private wordsOf;
+    /**
+     * Read how narrow each item's content goes, which Yoga has no way to say: commit the grid's
+     * text one word to a line, with each item at its content's width, and the widest line is the
+     * longest word. A box inside that has a width of its own keeps it, as it would in a browser.
+     */
+    private readNarrow;
+    /** One run of the grid layout, noting in `widths` each height it wanted and nothing has read. */
+    private layOutGrid;
+    /** What the root is committed with: the app's top views, or the strict view around them. */
+    private rootHandles;
+    /** The `LayoutConformance` view the app is committed in. See `EngineOptions`. */
+    private strictView;
+    private strictChildren;
+    /** The app's top views inside the strict view: the same view each commit, with these in it. */
+    private inStrictView;
     /** Anchors take part in sibling ordering but never reach Fabric. */
     private visibleChildren;
     /**
@@ -1205,7 +2297,101 @@ export declare class Engine implements HostEngine {
      */
     /** What a touch on an element that keeps a drag holds off, while it lasts: see `holdSwipe`. */
     private heldFor;
+    /**
+     * Exempt from the complexity limit deliberately, as `matchesCompound` is: a flat sequence of
+     * steps, each guarded by what it reads, run for every node merged. Moving the guards into calls
+     * of their own measured slower in `pnpm bench` and `pnpm bench:tailwind`.
+     */
     private mergeProps;
+    /** A run of text as it is committed: a word to a line while how narrow it goes is read. */
+    private textProps;
+    /** A node's part in a block's flow, where a layout of CSS's has been asked for. */
+    private flowed;
+    /** What the engine lays out in Yoga's place, of what has been asked for: see `asked`. */
+    private laidOut;
+    /** What a node's rules give it: for a generated box with no content, nothing but `display: none`. */
+    private ruleStyle;
+    /** Each node's layout styles while one container is planned, so each is merged once. */
+    private readonly flowStyles;
+    /** A node's own layout styles, in the order `mergeProps` applies them. */
+    private flowStyle;
+    /** The engine's nodes as `planFlow` reads them. A run of text is a box with no style. */
+    private readonly flowTree;
+    /**
+     * Whether a node is a block container, or was one when it was last planned. A text element
+     * lays out text, not boxes: it has no flow to plan, whatever its display.
+     */
+    private flows;
+    /**
+     * Plan a block container's flow again, and have merged again each child the plan lays out
+     * differently: one whose collapsed margins moved, one that joined the flow or left it. A child
+     * is planned from its siblings, so nothing about it need have changed for this to change.
+     */
+    private reflow;
+    /**
+     * Work out the room each line needs under its baseline, and how far over the bottom of it
+     * each box on it sits, and have merged again the container and each box where that changed:
+     * every one of them is placed by it. See `liftLines`.
+     */
+    private hang;
+    /**
+     * A browser sits each box on a line by its baseline, and the line has its strut's room under
+     * the baseline at least. The engine sits the boxes on the bottom of a row instead, so each is
+     * given a margin under it: the room under the line's baseline, the most any box or the strut
+     * needs, less the room under the box's own. An empty box's baseline is its bottom edge, and a
+     * box of text or of lines has its last line's under it, with its padding and border.
+     *
+     * ponytail: read from the sheets and the props, where a library's struts are. A shift bound on
+     * an element is not seen here until the inline form compiles to one.
+     */
+    private liftLines;
+    /**
+     * The room over a line's baseline, as its boxes keep it: a box whose height is known is moved
+     * down by a top margin to reach as high as the strut does, so the line is as tall over its
+     * baseline as a browser has it without a least height of the row it is in. That holds a line
+     * in a box with a height of its own, which the row's least height cannot, and lets a line
+     * taller than the box it is in reach down out of it, where the row's lines on its bottom
+     * would reach up.
+     */
+    private riseLines;
+    /**
+     * How high over the baseline an empty box on a line reaches, with its margins, where that
+     * is known before layout: a height in points, or a share of a box of lines held at its
+     * content's height, and its padding and border. Nothing for a box aligned another way.
+     */
+    private knownAbove;
+    /** Whether `vertical-align` sets a box to the top, the middle or the bottom of its line. */
+    private alignedOnLine;
+    /** The boxes in a block's lines: those in its flow, a run of text among them. */
+    private onLines;
+    /**
+     * How far under a line's baseline a box on it reaches: a run of text, of the line's font, as
+     * far as the strut's room, `below`. See `liftLines`.
+     */
+    private depthOnLine;
+    /** An inline-flex or inline-grid box with nothing in it: its baseline is its border box's bottom. */
+    private emptyFlexOnALine;
+    /**
+     * The room under a box's own baseline, inside its margin: none where it has no line in it,
+     * or clips what it holds, and its last line's room and its padding and border where it has.
+     *
+     * ponytail: a box of blocks with text in them is taken to end on a line of its own font.
+     */
+    private ownUnder;
+    /**
+     * How far under the baseline of its first line a box with a height in points reaches.
+     *
+     * ponytail: one line of its own font, as an input or a badge has. A box of a set height with
+     * lines of words in it ends lower; count the lines if one is seen.
+     */
+    private belowFirstLine;
+    /** Whether a block container holds lines: something in its flow, and nothing a block. */
+    private holdsLines;
+    /** The room under the baseline of a box's lines, as `liftLines` works it out for it. */
+    private lineUnder;
+    /** The room under the baseline of a node's strut, as native scales its text. */
+    private strutBelow;
+    private planFlow;
     /**
      * The z-index a view is drawn at for the boxes in it: the highest of theirs. A browser draws a
      * box with a z-index over what follows the boxes it is in, and a native view is ordered among
@@ -1393,19 +2579,6 @@ export declare class Engine implements HostEngine {
      * drawn where the animation left it until then.
      */
     private endedNatively;
-    /** A graph of native's was connected to a view: see `Touched`. */
-    private touchedNatively;
-    /**
-     * Set on native a change of a prop a graph of native's has set on the view before, while no
-     * graph of its holds it: the commit cannot change it (see `Touched`). The payload is committed
-     * as well, so the shadow node is as the view is drawn. A transform native cannot take as
-     * numbers, a matrix, is left committed alone.
-     */
-    private setOwned;
-    /** The size a view is laid out at, where it has been. */
-    private boxSize;
-    /** Forget the props native set on a node's view, which is gone or made again. */
-    private disown;
     /** Take an animation back from native, which stops it there. The caller plays it on, or not. */
     private stopNative;
     /**
@@ -1489,21 +2662,6 @@ export declare class Engine implements HostEngine {
      * that waits. Native has a colour node for the first; give the driver a channel for it.
      */
     private easeNatively;
-    /** The root's children as the views they are committed as, each reconciled. */
-    private rootHandles;
-    /** The transitions this commit lays out where they end, for native to move the views to. */
-    private laying;
-    /** Whether this commit resizes or moves a box that is in no such transition. */
-    private movesOthers;
-    /**
-     * Commit where it ends each transition of a size or a place that just started, for native to
-     * move the view there: a layout animation, which the commit asks for once it is known that
-     * nothing else in it moves. One still on its way is committed where it ends too. On a host
-     * with no layout animation they are eased from JavaScript, but for one sent on again and again.
-     *
-     * A width eased from JavaScript is a commit a frame, and a commit lays the whole screen out.
-     */
-    private layEased;
     /** When each size in transition was last started, and how many starts in a row came soon. */
     private readonly laidStarts;
     /**
@@ -1528,6 +2686,26 @@ export declare class Engine implements HostEngine {
     private playLaidHere;
     /** An animation native laid out has had its time: it is at its last frame, and says so. */
     private endLaidPlayed;
+    /** The transitions this commit lays out where they end, for native to move the views to. */
+    private laying;
+    /** Whether this commit resizes or moves a box that is in no such transition. */
+    private movesOthers;
+    /**
+     * Whether the boxes a commit moves or resizes are noted: for what the engine lays out in
+     * Yoga's place, which is laid out again around them, and for a transition native lays out,
+     * which is eased from JavaScript where anything else moves. An app with neither has no use
+     * for the note. Kept by `want`, as what is asked grows.
+     */
+    private notesMoves;
+    /**
+     * Commit where it ends each transition of a size or a place that just started, for native to
+     * move the view there: a layout animation, which the commit asks for once it is known that
+     * nothing else in it moves. One still on its way is committed where it ends too. On a host
+     * with no layout animation they are eased from JavaScript, but for one sent on again and again.
+     *
+     * A width eased from JavaScript is a commit a frame, and a commit lays the whole screen out.
+     */
+    private layEased;
     /**
      * Before a commit is handed over: ask native to move what it lays out, and take back to
      * ease from JavaScript whatever it cannot: all of it where the commit moves anything else,
@@ -1537,11 +2715,6 @@ export declare class Engine implements HostEngine {
     private layOut;
     /** Ask native to move what the commit lays out over `duration`, and end each when it is up. */
     private askLayout;
-    /**
-     * Note a commit that resizes or moves a box in no transition native lays out: a prop of one
-     * that moves boxes, children that came or went, text longer or shorter than it was.
-     */
-    private noteMoved;
     /** A transition native laid out has had its time: it is where it ends, and says so. */
     private endLaid;
     /**
@@ -1567,6 +2740,19 @@ export declare class Engine implements HostEngine {
     private takeBackEased;
     /** Stop a clock native runs, and go on from JavaScript with each transition it was playing. */
     private backToScriptEased;
+    /** A graph of native's was connected to a view: see `Touched`. */
+    private touchedNatively;
+    /**
+     * Set on native a change of a prop a graph of native's has set on the view before, while no
+     * graph of its holds it: the commit cannot change it (see `Touched`). The payload is committed
+     * as well, so the shadow node is as the view is drawn. A transform native cannot take as
+     * numbers, a matrix in depth, is left committed alone.
+     */
+    private setOwned;
+    /** The size a view is laid out at, where it has been. */
+    private boxSize;
+    /** Forget the props native set on a node's view, which is gone or made again. */
+    private disown;
     /** Let go of what native is easing on an element that is going, or gone. */
     private stopEased;
     /**
@@ -1647,6 +2833,30 @@ export declare class Engine implements HostEngine {
     private processGradients;
     private clearFlags;
     private reconcile;
+    /**
+     * Note a commit that resizes or moves a box in no transition native lays out: a prop of one
+     * that moves boxes, children that came or went, text longer or shorter than it was.
+     */
+    private noteMoved;
+    /** Note a clone that moves or resizes a box, where moves are noted: see `notesMoves`. */
+    private noteClone;
+    /** Where a box is noted that holds this many more children or letters: none is another change. */
+    private movedOrGrown;
+    /**
+     * Whether an element said to scroll its overflow is to: its style says `auto` or `scroll`. Noted
+     * on the node, for the view it is committed as, and answered.
+     */
+    private settleScrolling;
+    /**
+     * `reconcile` for an element that scrolls its overflow: a scroll view, and in it the one view
+     * its children are in. Each is created once and cloned for what changed of its own: the
+     * content for the children and for how they are laid out, the scroll view for its box and
+     * for a content that was cloned.
+     */
+    private reconcileScroller;
+    /** A view cloned for the props and the children that changed, or itself where neither did. */
+    private clonedFor;
+    private createScroller;
     /** What a clone sends: the props that changed, and a text input's font once it registered. */
     private propsPayload;
     /**
@@ -1667,6 +2877,48 @@ export declare class Engine implements HostEngine {
      * which, per child, was most of what a one-row update cost.
      */
     private reconcileChildren;
+    /** `reconcileChildren` for a block: its children, with each run of boxes in its line box. */
+    private reconcileInFlow;
+    /**
+     * A run of text beside a box in a line: its words are each a view, which are added to
+     * `handles` here, and it has no one view to answer with.
+     */
+    private reconcileWordsInto;
+    /** One child's view under `node`, or nothing for a child that has none there. */
+    private reconcileChild;
+    /**
+     * A block's children with each run of inline-level boxes in its line box: the view is where
+     * the first box of the run was, and holds the run. The same view is committed while its boxes
+     * and the margin over it are the same, so a commit that changes neither sends nothing for it.
+     */
+    private inLines;
+    private lineBox;
+    /**
+     * Where `text-align` puts the boxes of a line in `container`, as the row the line is places
+     * its items: a browser sets inline-level boxes where it would set the line's words. Nothing
+     * at the start, which is where a row has them.
+     *
+     * ponytail: `end` and `right` are both the row's end, which is the left in a right-to-left
+     * layout: right for `end` and wrong for `right`. Read the direction if that is ever seen.
+     */
+    private alongLine;
+    /**
+     * A box's part in that: the container of lines and nothing else is the row itself. A line
+     * among blocks is a line box, which `lineBox` sets its boxes along.
+     */
+    private alignLine;
+    /**
+     * The line box `first` starts in `container`: the one it has, or a new one with no view yet.
+     * A line box is a view of its container's, so in another container it is another one, and so
+     * is the one of a first box that has been made again.
+     */
+    private lineOf;
+    /**
+     * A flex container's children in the order their `order` gives, as written among equals. A
+     * block lays its children out as written whatever they say, and text in the container has no
+     * order of its own.
+     */
+    private inOrder;
     /**
      * The paragraph a run of text written straight into a view is drawn in, or nothing for a run of
      * whitespace, which a browser draws nothing for between the items of a flex box either.
@@ -1680,6 +2932,17 @@ export declare class Engine implements HostEngine {
      * prop (see `ViewNameOptions`) or the run is whitespace between a view's children.
      */
     private reconcileText;
+    /**
+     * A run of text beside a box in a line, as the paragraphs of its words: a browser breaks the
+     * line between any two of them, and what follows the run is where its last word ends. One
+     * paragraph is a box as wide as its longest line, with the next box under all of it.
+     */
+    private reconcileWords;
+    /** The paragraph of each word of a run, kept for the word in its place while there is one. */
+    private wordBoxes;
+    private wordBox;
+    /** The box a run of loose text is drawn by: the one it has, or one made for the element. */
+    private boxFor;
     private looseText;
     /** Remember an iOS modal host committed as showing, so hiding it waits for `topDismiss`. */
     private notePresented;
@@ -1707,6 +2970,19 @@ export declare class Engine implements HostEngine {
      * is: what its views held of their own, a scroll offset, is not kept.
      */
     private undisplayed;
+    /**
+     * Whether a generated box is one no rule draws, which has no view. A view that is not
+     * displayed would do for what is seen, but Yoga marks one as laid out each time it measures
+     * what holds it, as `undisplayed` says. An element holds two of these for every rule that could
+     * draw it one.
+     */
+    private undrawn;
+    /**
+     * The words a generated box's `content` writes, as the text the box holds: a label a library
+     * hangs on an element by its `::before`. Read as the box is about to be committed, which is
+     * when its rules are known, and before what it holds is.
+     */
+    private writeContent;
     /**
      * Whether a node hoisted into `target` is not displayed where it was written: it, or a box
      * between it and the child of `target` it was written in. That child is asked before this is.
@@ -1718,6 +2994,11 @@ export declare class Engine implements HostEngine {
      * keeps for hoisted nodes that are gone.
      */
     private reconcileHoistTarget;
+    /**
+     * What a hoist target takes of a child written in it: the child's handle, `direct` for one
+     * hoisted into it, which goes after its siblings, or null for none.
+     */
+    private takenByTarget;
     /**
      * `reconcileHoistTarget` for a node that commits only what is hoisted into it
      * (`HoistOptions.only`): those nodes, in the order they were written, and none of its own.
@@ -1744,6 +3025,8 @@ export declare class Engine implements HostEngine {
      * for hoisted names go too: they are children of the native view it is losing.
      */
     private forgetCommitted;
+    /** The paragraphs a run of text is drawn in, let go with it: see `paragraphsOf`. */
+    private forgetParagraphs;
     /** A hoisted node, which commits into an ancestor further up than the parent it is in. */
     private committedElsewhere;
     /**
@@ -1757,14 +3040,9 @@ export declare class Engine implements HostEngine {
      */
     private standIn;
     /**
-     * What a hoist target takes of a child written in it: the child's handle, `direct` for one
-     * hoisted into it, which goes after its siblings, or null for none.
-     */
-    private takenByTarget;
-    /**
-     * A clean element's handle under `parent`, before anything else is asked of it: one committed
-     * there and unchanged since was displayed and in its place, and is still. The siblings of what
-     * changed are most of what a commit steps over: a list one row of which ticks.
+     * A clean child's handle under `parent`, before anything else is asked of it: one committed
+     * there and unchanged since was displayed, in its place, and is still. The siblings of what
+     * changed are most of what a commit steps over: a page of examples one of which ticks.
      */
     private cleanUnder;
     /** A clean child's committed handle, when its style still holds under its parent's. */
@@ -1860,6 +3138,28 @@ export declare class Engine implements HostEngine {
      * nothing to receive it and the call is dropped.
      */
     dispatchCommand(node: EngineNode, name: string, args?: readonly unknown[]): void;
+    /**
+     * Where a node is, in window coordinates.
+     *
+     * `(layout)` reports a frame in the parent's coordinates, which sizes a view and says nothing
+     * about where it is relative to anything else. This is what an anchored overlay needs: a
+     * popover and its trigger live in different parts of the tree and can only be compared in the
+     * window's frame.
+     *
+     * The callback is the platform's own shape rather than a promise, and on the new architecture
+     * it fires before this returns - so a caller that needs the value immediately can capture it,
+     * and one that does not is unaffected if that ever changes.
+     *
+     * Silent when the node has never been committed, or when the host has no `measureInWindow`.
+     * Reporting zeroes would be worse than reporting nothing: a zero frame is a position, and an
+     * overlay would believe it and place itself in the corner.
+     */
+    /**
+     * A node's box as it is laid out, with no transform on it or above it: nothing where it has
+     * not been committed, or on a host that cannot say. `measure` answers where it is drawn,
+     * which is smaller for a panel scaling in.
+     */
+    layoutOf(node: EngineNode): WindowFrame | undefined;
     /**
      * Where a node is, in window coordinates.
      *
@@ -1877,6 +3177,8 @@ export declare class Engine implements HostEngine {
      * overlay would believe it and place itself in the corner.
      */
     measure(node: EngineNode, into: (frame: WindowFrame) => void): void;
+    /** `measure` for a committed view by its handle, which a node's own may not be. */
+    private measureHandle;
     /**
      * The react tag a node was committed with, or null if it has never reached a commit.
      *
@@ -1974,6 +3276,21 @@ export declare class Engine implements HostEngine {
      * bubble for the rest, as in the DOM.
      */
     dispatchEvent(instanceHandle: unknown, topLevelType: string, nativeEvent: unknown): void;
+    /**
+     * Where a touch is taken to be, by a package that finds it better than native's hit test: a
+     * drawing's shape a browser finds by its box, where native finds none. Asked as a touch
+     * starts, and kept for each finger until it lifts, as a touch stays on what it started on.
+     */
+    private retarget;
+    private readonly fingersOn;
+    /**
+     * The target a touch is dispatched to, where a package's retarget runs: nothing it throws may
+     * reach native, so a throw is reported and the touch goes to native's own target.
+     */
+    private guardedTarget;
+    /** Say where a touch that starts on a node is taken to be, or nothing to leave it to native. */
+    setTouchTarget(retarget: ((target: EngineNode, nativeEvent: unknown) => EngineNode) | null): void;
+    private touchTarget;
     /** The screen whose swipe back is held off while a finger is on what keeps a sideways drag. */
     private swipeHeld;
     /**
@@ -1992,12 +3309,22 @@ export declare class Engine implements HostEngine {
      */
     private drag;
     private holdFrom;
-    /** The scroll view whose scrolling is off while a drag over it is an element's own. */
-    private scrollHeld;
+    /** The scroll views whose scrolling is off while a drag over them is an element's own. */
+    private readonly scrollHeld;
+    /** Whether a package has kept the drag now under way from the page: see `keepDrag`. */
+    private dragKept;
+    /**
+     * Keep the drag now under way from the page, as a browser does for a `touchmove` a listener
+     * prevented the default of: the scroll view the node is in stops scrolling, and native is told
+     * that whoever holds the touch keeps it, until the last finger lifts. Told from a move, a
+     * frame or so after native saw it, so a scroll that had already begun stops where it is.
+     */
+    keepDrag(node: EngineNode): void;
     /**
-     * Stop the scroll view a node is in from scrolling, until the touch ends. Telling native who
-     * holds the touch does this on Android. On iOS a scroll view is held off only by a responder
-     * that is over it, never one inside it, so it is told not to scroll.
+     * Stop every scroll view a node is in from scrolling, until the touch ends: one held off hands
+     * the drag to the one around it. Telling native who holds the touch does this on Android. On
+     * iOS a scroll view is held off only by a responder that is over it, never one inside it, so
+     * each is told not to scroll.
      */
     private holdScroll;
     /** Settle which way a drag set off, and hold native's own off one that set off across. */
@@ -2047,11 +3374,11 @@ export declare class Engine implements HostEngine {
      * `children` is null when the child list is unchanged, in which case Fabric keeps the previous
      * revision's children and there is nothing to append.
      *
-     * Otherwise this clones the way React does: the no-children form, then `appendChild` per child.
-     * Omitting the child list gives the clone *empty* children, not the old ones, and whether a
-     * binding takes that argument cannot be feature-detected - `UIManagerBinding.cpp` registers
-     * both clone methods with a fixed `paramCount` and argument validation is commented out - so
-     * `fn.length` says nothing. One code path, no detection.
+     * Otherwise the clone is handed its children in the one call, as an array: a call into native
+     * for each of them is most of what cloning a box of hundreds costs, and each box over a change
+     * is cloned on every commit. React Native's binding (`UIManagerBinding.cpp`, the one on iOS
+     * and Android) reads an array there in every version the packages support, and takes it as the
+     * second argument of three where there are props as well.
      */
     private clone;
     private detach;