@ng-native/fabric 0.0.1 → 0.1.0

package/dist/engine.d.ts

@@ -0,0 +1,1066 @@
+/**
+ * Framework-agnostic retained tree + incremental Fabric commit.
+ * Nothing Angular-specific may enter this file; lint bans the import (see ARCHITECTURE.md).
+ *
+ * Angular mutates; Fabric is persistent. A committed node is never mutated, it is cloned with
+ * new props and/or a new child set. Cloning a leaf therefore forces every ancestor to re-clone,
+ * because a persistent parent holds references to specific child handles. That bubble is
+ * inherent and is what React's own Fabric renderer does.
+ */
+import { type Conditions, type StyleCache, type StyleSheet, type TokenValue } from './css.ts';
+import { type AnimationSpec, 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 { 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';
+/** A node's scroll-driven animation: what it plays, what drives it, and the frame it commits. */
+interface ScrollAnimation {
+    readonly spec: AnimationSpec;
+    readonly tracks: ReadonlyMap<string, readonly {
+        offset: number;
+        value: unknown;
+    }[]>;
+    readonly resting: Record<string, unknown>;
+    readonly first: Record<string, unknown>;
+    readonly source: EngineNode | null;
+    readonly drive: {
+        update(channels: DrivenChannels): void;
+        stop(): void;
+    } | null;
+}
+export interface WindowFrame {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export type FabricNodeSet = unknown;
+/** The slice of `global.nativeFabricUIManager` we actually use. */
+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;
+    /** 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;
+    appendChild(parent: FabricNode, child: FabricNode): FabricNode;
+    createChildSet(rootTag: number): FabricNodeSet;
+    appendChildToSet(set: FabricNodeSet, child: FabricNode): void;
+    completeRoot(rootTag: number, set: FabricNodeSet): void;
+    registerEventHandler?(handler: (instanceHandle: unknown, topLevelType: string, nativeEvent: unknown) => void): void;
+    /** Tells the native side that JS owns the gesture, and whether to stop its own. */
+    setIsJSResponder?(node: FabricNode, isResponder: boolean, blockNativeResponder: boolean): void;
+    /** A view command: `focus` on a text input, `scrollTo` on a scroll view. */
+    dispatchCommand?(node: FabricNode, name: string, args: readonly unknown[]): void;
+    /**
+     * A node's frame in window coordinates, which is the only frame two nodes can be compared in.
+     *
+     * Optional because an older host may not have it, and because the callback is the platform's
+     * own shape: on the new architecture it fires before this returns, which is what lets an
+     * 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;
+}
+/**
+ * What a listener receives. RN's synthetic event carries more, but `nativeEvent` is the part
+ * every RN API is documented against, and `stopPropagation` is the part a nested control needs.
+ *
+ * `stopPropagation` ends the walk to the root after the current node, as it does in the DOM and
+ * on RN's `SyntheticEvent`: the other listeners on the node that called it still run. It does not
+ * touch the responder negotiation, which has already finished by the time a listener sees the
+ * event, so it cannot take a press away from a pressable; the negotiation already keeps an inner
+ * pressable's press from reaching the one around it.
+ */
+export interface NativeSyntheticEvent<T = unknown> {
+    readonly nativeEvent: T;
+    stopPropagation(): void;
+    isPropagationStopped(): boolean;
+}
+/**
+ * The event object a dispatch hands every listener along the path. Exported so another host can
+ * hand its listeners the same shape rather than a bare `{ nativeEvent }` that lacks the methods
+ * the type promises.
+ */
+export declare class SyntheticEvent<T = unknown> implements NativeSyntheticEvent<T> {
+    readonly nativeEvent: T;
+    private stopped;
+    constructor(nativeEvent: T);
+    stopPropagation(): void;
+    isPropagationStopped(): boolean;
+}
+/**
+ * The JS responder system: RN's second touch layer, and the renderer's job rather than the app's.
+ *
+ * Fabric delivers raw touches to whichever node was hit. On top of that, React runs a negotiation
+ * deciding *who owns the gesture*: a capture pass from the root down, then a bubble pass from the
+ * target up, electing a single responder that alone receives grant/move/release/terminate. When
+ * ownership changes the renderer tells native through `setIsJSResponder`, which is how a JS
+ * control stops a native scroll view from also scrolling.
+ *
+ * All of RN's `Pressability` sits on this, never on raw touch events. Without it there is no way
+ * for a button and an enclosing scroll view to agree on who owns a drag.
+ */
+/**
+ * What a touch event carries. The responder system is touch-only, so its handlers are typed
+ * against this rather than `unknown`: every consumer wants the coordinates and would otherwise
+ * cast to get at them.
+ */
+export interface TouchPayload {
+    readonly pageX?: number;
+    readonly pageY?: number;
+    readonly locationX?: number;
+    readonly locationY?: number;
+    readonly identifier?: number;
+    readonly target?: number;
+    readonly timestamp?: number;
+}
+export type ResponderEvent = NativeSyntheticEvent<TouchPayload>;
+export interface ResponderHandlers {
+    /** The `target` is the node the touch landed on, which a capturing ancestor may inspect. */
+    onStartShouldSetResponderCapture?(event: ResponderEvent, target: EngineNode): boolean;
+    onStartShouldSetResponder?(event: ResponderEvent, target: EngineNode): boolean;
+    onMoveShouldSetResponderCapture?(event: ResponderEvent, target: EngineNode): boolean;
+    onMoveShouldSetResponder?(event: ResponderEvent, target: EngineNode): boolean;
+    onResponderGrant?(event: ResponderEvent): void;
+    onResponderMove?(event: ResponderEvent): void;
+    onResponderRelease?(event: ResponderEvent): void;
+    onResponderTerminate?(event: ResponderEvent): void;
+    /** Return false to keep the gesture when something else asks for it. Defaults to allowing. */
+    onResponderTerminationRequest?(event: ResponderEvent): boolean;
+    /** Ask native to stop its own gesture while we hold the responder (a slider inside a list). */
+    blockNativeResponder?: boolean;
+}
+export type NodeKind = 'element' | 'text' | 'anchor';
+/** What Fabric currently holds for a node. `null` until the node has been committed once. */
+interface Committed {
+    handle: FabricNode;
+    /**
+     * The react tag this node was created with. Kept because the native animation driver addresses
+     * a view by tag and has no other way to find one of ours: `findNodeHandle` returns a number it
+     * is given unchanged, so a tag is all an animated graph needs to point here.
+     */
+    tag: number;
+    props: Record<string, unknown>;
+    /** The child handles this node was committed with, in order. */
+    childHandles: FabricNode[];
+}
+export interface EngineNode extends HostNode {
+    readonly kind: NodeKind;
+    /** Lowercase template spelling, e.g. `view`. Never the native view name. */
+    readonly name: string;
+    /** `name` again, for Angular 22.0, which reads it on a component's host element. */
+    readonly tagName: string;
+    props: Record<string, unknown>;
+    text: string;
+    children: 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;
+    /** 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`. */
+    customProperties: Record<string, TokenValue> | null;
+    /** Resolved style, memoised across commits. Owned by the CSS resolver. */
+    styleCache: StyleCache | null;
+    /** Set when something that could change what this node matches has changed. */
+    styleDirty: boolean;
+    /** `:focus`, from the native focus and blur events. */
+    focused?: boolean;
+    /** `:active`, set on the responder and every ancestor of it. */
+    active?: boolean;
+    /**
+     * The style object the platform adapter made for this node, and may therefore write into.
+     *
+     * Angular sets style properties one at a time, so building a fresh object per property means a
+     * style of ten properties costs ten copies of a growing object, for every element that has one.
+     * An object the adapter created is its to mutate; one that arrived any other way is copied,
+     * once. A field rather than a `WeakSet` of such objects, which Hermes makes slow to consult.
+     */
+    ownStyle?: object;
+    /** The resolved style this node was last committed with, for the skip check in `reconcile`. */
+    styleCommitted: StyleCache | null;
+    /**
+     * 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.
+     */
+    transitions?: Map<string, Transition>;
+    /** The `@keyframes` animation this node is playing, if any. One at a time. */
+    playing?: RunningAnimation;
+    /** An animation played by a scroll view's offset rather than the clock. See `scrollAnimated`. */
+    scrolled?: ScrollAnimation;
+    /**
+     * The last `transform` built from the individual transform properties, and what it was built
+     * from. Reused while the parts are the same objects, so an unrelated change does not re-send it.
+     */
+    composedTransform?: {
+        parts: readonly unknown[];
+        value: unknown[];
+    };
+    /**
+     * Set by the component that owns this element. A host primitive that reaches a commit without it
+     * was written in a template that never imported the component, which is reported in dev.
+     */
+    claimed?: true;
+    /**
+     * Set by the platform adapter when Angular mounts a component on this element. What makes an
+     * `<x-card>` host legitimate where a `<veiw>` typo is not, since both are names no view table
+     * knows. See `markComponentHost`.
+     */
+    componentHost?: true;
+    /**
+     * Hoisted nodes (`registerHoist`) inside this subtree while it is out of the tree, held here
+     * rather than by the engine. See `Engine.releaseDetached`.
+     */
+    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;
+    /** The hoisted views this node keeps committed for, by element name. See `HoistOptions`. */
+    kept?: Map<string, KeptHoist>;
+    /** Commit this node again with its children so Fabric measures it again. `remeasureText`. */
+    remeasure?: true;
+    /**
+     * A modal host committed as visible on iOS whose dismissal native has not yet reported. It
+     * stays committed after `visible` goes false until `topDismiss`, as React Native's Modal.js
+     * keeps it for the dismissal animation. See `Engine.withheld`.
+     */
+    presented?: true;
+    /** This node's own props changed. */
+    propsDirty: boolean;
+    /** This node's child list changed. */
+    structureDirty: boolean;
+    /** Something below this node is dirty, so the walk must descend. */
+    subtreeDirty: boolean;
+}
+/**
+ * Declare props the native view behind an element accepts. `@ng-native/components` calls this
+ * once per host primitive with the component's inputs; an app driving a primitive's native view
+ * with a prop the component has no input for can declare that prop too.
+ */
+export declare function declareNativeProps(elementName: string, props: Iterable<string>): void;
+/**
+ * Mark a host element as owned by its component. The components package calls this from each
+ * host primitive's constructor; see `EngineNode.claimed`.
+ */
+export declare function claimHost(node: HostNode): 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,
+ * with the host element in hand, whatever the component's selector.
+ */
+export declare function markComponentHost(node: HostNode): void;
+/** Names Android registers differently. */
+export declare const ANDROID_VIEW_NAMES: Record<string, string>;
+export declare function nativePlatform(): string;
+/**
+ * Call once at startup with `Platform.OS`. The view names above are the iOS/canonical ones, so
+ * only the mapping half is a no-op elsewhere.
+ */
+export declare function registerPlatformComponents(platform: string): void;
+/**
+ * Register a codegen'd third-party Fabric component, e.g.
+ * `registerViewName('rns-screen', 'RNSScreen')`, which is how the router reaches
+ * react-native-screens.
+ *
+ * `defaultProps` is for a component whose React wrapper supplies a base style in JS, the way
+ * `ScrollView` and `Modal` do below. Driving the native component directly skips that wrapper,
+ * 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>): void;
+/**
+ * A view whose native name differs by platform. Chosen when the view is looked up rather than when
+ * it is registered, so it does not matter which ran first: an app's imports register the router's
+ * views before its `main.ts` gets to report the platform.
+ */
+export interface PlatformViewName {
+    readonly ios: string;
+    readonly android: string;
+}
+/**
+ * Commit every `elementName` as a direct child of its nearest `ancestorName`, wherever the
+ * template put it, e.g. `registerHoist('native-header', 'screen')`.
+ *
+ * For a native component that reads a configuration node from its own direct children and
+ * nowhere else. `RNSScreen.mm` finds its header that way, so a header written inside a
+ * `safe-area-view`, or inside any component a page wraps itself in, was never found: no title,
+ * no back button, and nothing said why. The retained tree keeps the node where Angular put it,
+ * so styles, `@if` and removal all behave as written; only what reaches Fabric moves. It lands
+ * 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.
+ */
+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.
+     *
+     * For a configuration node the native side reads when it arrives but never forgets when it
+     * leaves. `RNSScreen` hides its navigation bar when a header config it holds says `hidden`, and
+     * does nothing at all when the config is taken away, so the last bar it was told about stays on
+     * screen. With a stand-in, removing the element commits these props onto the same native view,
+     * children dropped, and the next element of that name adopts the view rather than creating
+     * another, so what the native side sees is one config that is updated, never one that goes.
+     */
+    standIn?: Record<string, unknown>;
+}
+/** A native view an ancestor keeps for a hoisted name with a stand-in, and who it is for now. */
+interface KeptHoist {
+    /** The element committed as this view, or null while the stand-in props are. */
+    node: EngineNode | null;
+    committed: Committed;
+}
+/** The part of a node `viewNameOf` reads: an engine node, or any host's mirror of one. */
+export interface ViewNameNode {
+    readonly kind: string;
+    readonly name: string;
+    readonly parent: {
+        readonly name: string;
+    } | null;
+}
+/**
+ * The native view a node commits as: `Paragraph` for a `<text>`, `VirtualText` for one nested in
+ * another, `RawText` for a run of text, and `View` for anything unregistered, which is what an
+ * Angular component's host element is.
+ *
+ * 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.
+ */
+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;
+/**
+ * RN-specific helpers, injected rather than imported so the engine stays runnable under Node.
+ */
+export interface EngineOptions {
+    /**
+     * React Native's `NativeAnimatedHelper`, which lets native move a view by a scroll with no
+     * JavaScript in between: how sticky headers stay pinned on a fast fling. The platform supplies it
+     * on a device; without it, the components move those views from JavaScript as before.
+     */
+    nativeAnimated?: NativeAnimated | null;
+    /**
+     * RN's `processColor`. Narrower than `unknown` on purpose: it is only ever handed the value of
+     * a `*color` prop, and typing it that way is what lets an app pass RN's function straight in
+     * rather than casting at every call site.
+     */
+    processColor?: (value: string | number) => unknown;
+    /**
+     * RN's `resolveAssetSource`. `require('./x.png')` compiles to an asset *id*, and only this
+     * turns it into `{uri, width, height, scale}`. Without it local images cannot work at all,
+     * while remote `{uri}` objects pass through and appear to prove the prop is fine.
+     */
+    resolveAssetSource?: (value: unknown) => unknown;
+    /**
+     * The application-level sheet, compiled at build time. The one set of rules allowed to match a
+     * node whatever component created it, which is what resets, utility classes and `:root` tokens
+     * all need.
+     */
+    globalStyles?: StyleSheet | null;
+    /**
+     * What media queries are evaluated against. Pushed in rather than read, because the engine
+     * imports nothing from React Native and a host may have its own idea of the viewport.
+     */
+    conditions?: Conditions;
+    /**
+     * Custom properties the device knows and the stylesheet cannot: the hairline width, and
+     * whatever else is settled before the first frame. Seeded on the root, below `:root`, so an
+     * app's own sheet still overrides them. Values that only arrive later - the safe-area insets,
+     * which nothing knows until a view has been laid out - come through `updateTokens` instead.
+     */
+    tokens?: Readonly<Record<string, TokenValue>>;
+    /**
+     * Report host primitives used without their component (see `claimHost`). Defaults to RN's
+     * `__DEV__`, so a release build never looks.
+     */
+    dev?: boolean;
+    /**
+     * The clock CSS transitions run on. Pushed in for the same reason everything else is: the
+     * engine imports nothing, and a test drives time rather than waiting for it.
+     */
+    now?: () => number;
+    /**
+     * Called when the tree goes from clean to dirty. The host uses it to schedule a commit for a
+     * change that arrives outside change detection, which is where Angular's animation queue puts
+     * the classes for `animate.enter` and `animate.leave`.
+     */
+    onDirty?: () => void;
+    /**
+     * Where an error thrown while a native event is being dispatched goes, with the event's name.
+     * The platform adapter points it at the app's `ErrorHandler`. Without one it is logged, and
+     * either way it is never rethrown: see `dispatchEvent` for why.
+     */
+    onError?: (error: unknown, topLevelType: string) => void;
+}
+/** Dev-time commit accounting, so a slow frame can be attributed rather than guessed at. */
+export interface EngineStats {
+    commits: number;
+    lastCommitMs: number;
+    /** The initial mount, which is a different animal from a steady-state update. */
+    firstCommitMs: number;
+    /** Worst commit *after* the mount. This is the number that matters for frame rate. */
+    worstCommitMs: number;
+    /** Commits that blew a 60fps frame budget, excluding the mount. */
+    slowCommits: number;
+    /**
+     * Worst `begin()`..`end()` span, excluding the mount. This brackets Angular's whole render
+     * pass - template execution, bindings, the commit - so comparing it against `worstCommitMs`
+     * says whether time is going into the renderer or into change detection around it.
+     */
+    worstRenderMs: number;
+    createdNodes: number;
+    clonedNodes: number;
+}
+export declare class Engine implements HostEngine {
+    /** Scopes the CSS resolver's memo. Bumped once per commit. */
+    private styleEpoch;
+    /** The node `:focus` currently applies to. */
+    private focusedNode;
+    readonly stats: EngineStats;
+    private eventsRegistered;
+    readonly root: EngineNode;
+    private readonly fabric;
+    private readonly rootTag;
+    private readonly styles;
+    /** Whether to run the development checks, which a release build skips. */
+    readonly dev: boolean;
+    private readonly now;
+    private onDirty;
+    private onError;
+    /** Nodes with at least one transition in flight, so a frame walks those and nothing else. */
+    private readonly running;
+    /** Nodes playing a `@keyframes` animation. */
+    private readonly playing;
+    /**
+     * Elements of a hoisted name (`registerHoist`) that are in the tree, so a commit need not search
+     * for them. Only those in the tree: see `releaseDetached`.
+     */
+    private readonly hoisted;
+    /** Whether a child list has lost a member since the last commit. See `releaseDetached`. */
+    private removedSinceCommit;
+    /**
+     * `@keyframes` by name, across every sheet seen so far. One registry rather than one per sheet,
+     * because that is the scope CSS gives them: a name defined in a global stylesheet is usable
+     * from a component's. The cost is that two components defining the same name collide, last one
+     * in wins, exactly as two stylesheets in a document would.
+     */
+    private readonly keyframes;
+    /** Element names already reported as unclaimed, so a list of a thousand rows reports once. */
+    private readonly reported;
+    private readonly processColor;
+    /**
+     * Whether any sheet seen so far asks about a node's position among its siblings. Until one
+     * does, a child list can move without anything else needing to be looked at again.
+     */
+    private structuralSheets;
+    private readonly resolveAssetSource;
+    constructor(fabric: FabricUIManager, rootTag: number, options?: EngineOptions);
+    /**
+     * A rotation, a window resize, or the system switching to dark mode.
+     *
+     * None of those change a single node, so nothing would be dirty and nothing would re-render.
+     * Marking the root is what gets the tree walked again; every cached style is already invalid,
+     * because each carries the conditions version it was resolved under.
+     */
+    /**
+     * Move `:focus`, invalidating only the two nodes involved.
+     *
+     * Precise rather than by generation: unlike a rotation, the engine knows exactly which nodes
+     * changed, and a keystroke's worth of focus movement should not invalidate the tree.
+     */
+    private setFocused;
+    /**
+     * Set or clear `:active` along a responder chain, marking each node so its style re-resolves.
+     *
+     * Returns whether anything moved, because the caller has to commit: a gesture changes no
+     * binding, so nothing marks an Angular view dirty and no change-detection pass would follow.
+     */
+    private setActiveChain;
+    /**
+     * Custom properties the device knows and the stylesheet cannot, once they change.
+     *
+     * Merged rather than replaced: the insets come from a view and the hairline from the device, so
+     * a caller owns the properties it names and nothing else. Each owner writes all of its own at
+     * once - four insets together, never one - so nothing is left over from a previous rotation.
+     */
+    updateTokens(next: Readonly<Record<string, TokenValue>>): void;
+    /**
+     * The system text size changed: measure every text and text input again, and commit.
+     *
+     * React Native's surface re-measures its text when the content size category changes, on a
+     * commit of its own. The next commit from here is built from the handles the engine holds,
+     * which are the nodes from before that, laid out at the old size, and Yoga keeps a clean node's
+     * layout: every text whose content had not changed kept its old box, with its glyphs drawn at
+     * the new size inside it, clipped. So each one is committed again, cloned with its children,
+     * which is what makes Fabric dirty a measured node and measure it at the size now in effect.
+     */
+    remeasureText(): void;
+    /**
+     * Put the cursor in a text input; bring anything else on screen, in the scroll view it is in.
+     * A form sends the user to the first field that needs fixing this way, and a toggle or a picker
+     * has no cursor to take, so it is scrolled to instead.
+     */
+    focus(node: EngineNode): void;
+    /**
+     * Scroll the nearest scroll view the node is in by as little as brings the node fully on
+     * screen, with `margin` to spare - UIKit's `scrollRectToVisible`. `visibleBottom` is where in
+     * the window the visible area ends when something covers the bottom of the scroll view: the
+     * keyboard's top edge, for a field the keyboard would otherwise hide.
+     *
+     * Measured in the window, all of it, so the scroll view's offset needs no tracking: it is how
+     * far its content's top edge is above its own.
+     */
+    reveal(node: EngineNode, options?: {
+        visibleBottom?: number;
+        margin?: number;
+    }): void;
+    /**
+     * Commit one measured node again, cloned with its children, so Fabric measures it once more.
+     *
+     * A text input is measured from its native state, and a text set from JavaScript reaches that
+     * state only in the layout after the measurement, so the commit carrying the text sizes the
+     * field for the text it had before. This is the commit that sizes it for the new one: one of
+     * the exceptions to a commit per pass, because waiting for the next pass would leave the field
+     * the wrong height until something else changed.
+     */
+    remeasure(node: EngineNode): void;
+    /** The window's size, from the conditions media queries use. Zero until the platform says. */
+    get viewport(): {
+        readonly width: number;
+        readonly height: number;
+    };
+    private viewportSize;
+    updateConditions(next: Conditions): void;
+    createElement(name: string, sheet?: StyleSheet | null): EngineNode;
+    addClass(node: EngineNode, name: string): void;
+    removeClass(node: EngineNode, name: string): void;
+    /** `class="a b"` from a template. Replaces the set rather than adding to it. */
+    setClasses(node: EngineNode, value: string): void;
+    /** Angular's `@if`/`@for`/`ViewContainerRef` markers. Ordered, never committed. */
+    createAnchor(): EngineNode;
+    createText(value: string): EngineNode;
+    appendChild(parent: EngineNode, child: EngineNode): void;
+    insertBefore(parent: EngineNode, child: EngineNode, ref: EngineNode | null): void;
+    removeChild(parent: EngineNode | null, child: EngineNode): void;
+    /** A subtree that went out of the tree is back in: its hoisted nodes commit again. */
+    private wakeHoists;
+    /**
+     * Let go of everything the engine holds for nodes that have left the tree.
+     *
+     * Removal is the only signal a destroyed subtree reliably sends. Angular calls `destroyNode` for
+     * the top-level nodes of the view it destroys and not for anything inside a child component's
+     * view, so a screen's own template is never told it is gone. A reference the engine keeps to any
+     * one node of such a subtree keeps all of it, because a node reaches every other node of its
+     * subtree through its parent and children, and each of those holds its committed Fabric handle,
+     * which keeps its native shadow node alive. A screen with a header was retained in full that way,
+     * every native node of it, for as long as the app ran.
+     *
+     * Removal is not destruction, though: a detached screen can be put back, and must come back
+     * whole. So a hoisted node moves to the root of the subtree it left with, which is garbage along
+     * with it if the subtree never returns, and is handed back when it does. An animation on a node
+     * out of the tree stops rather than running a frame loop for something nobody can see, and
+     * starts again if the node returns.
+     *
+     * Once per commit, and only after a removal: the walks are the depth of a handful of nodes.
+     */
+    private releaseDetached;
+    /** The root of the tree a node is in: the engine's root while it is attached. */
+    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.
+     */
+    destroyNode(node: EngineNode): void;
+    parentNode(node: EngineNode): EngineNode | null;
+    nextSibling(node: EngineNode): EngineNode | null;
+    setProp(node: EngineNode, key: string, value: unknown): void;
+    /** Whether a node's inline style sets `direction`, remembering that one has. */
+    private noteInlineDirection;
+    /**
+     * The style object a node already holds has been changed in place.
+     *
+     * Angular's styling instructions set one property at a time, so a style of ten properties would
+     * otherwise mean ten copies of a growing object per element. The adapter owns the object it put
+     * 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;
+    /**
+     * Set a custom property on a node, `--tint` from `[style.--tint]`, or remove it with `null`.
+     *
+     * Not a prop: Fabric has no such thing, and would be sent one. It is a token for the cascade,
+     * converted from the value here because nothing built it ahead of time (`inline-token.ts`), and
+     * changing it re-resolves the node and so everything under it.
+     */
+    setCustomProperty(node: EngineNode, name: string, value: unknown): void;
+    setText(node: EngineNode, value: string): void;
+    setEventListener(node: EngineNode, topLevelType: string, fn: (event: unknown) => void): () => void;
+    private markProps;
+    private markLaterSiblings;
+    private markStructure;
+    /** Walk up until we hit a node already known to have a dirty subtree. */
+    private markPath;
+    private isClean;
+    /**
+     * Incremental: clone only what changed and reuse untouched subtrees by reference. A full
+     * rebuild would mint fresh shadow nodes for every node on every tick, which drops scroll
+     * offset, text cursor and keyboard focus. That is a correctness requirement, not an
+     * optimisation.
+     */
+    commit(): boolean;
+    private readonly scrollDriver;
+    /** Whether native can move a view by a scroll with no JavaScript in between. */
+    get drivesScroll(): boolean;
+    /** See `HostEngine.driveByScroll`. The connection waits for a commit of both views. */
+    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;
+    /**
+     * `transitionstart` and `transitionend`, for anything listening.
+     *
+     * Angular's `animate.enter` and `animate.leave` are built on these: they add a class, wait for
+     * the transition it starts, and clean up when it ends. Nothing native emits them - there is no
+     * CSS animation in React Native to emit them - so the engine that runs the transition is what
+     * says when one began and ended.
+     */
+    /** Created since the last commit and waiting to settle. See `HostEngine.settle`. */
+    private unsettled;
+    settle(target: Settling): void;
+    /**
+     * Let every element created since the last commit write what its inputs say. One that was
+     * checked already has, and answers at once; one whose view is detached writes its props here,
+     * so the commit that first mounts it carries them.
+     */
+    private settleCreated;
+    private readonly transitionEvents;
+    private emitTransition;
+    /**
+     * After the commit, never during it: a listener is free to add a class or drop an element, and
+     * a tree that changes halfway through being walked is the one thing a commit cannot survive.
+     */
+    private flushTransitionEvents;
+    /** Anchors take part in sibling ordering but never reach Fabric. */
+    private visibleChildren;
+    /**
+     * Everything a node renders with, unprocessed. Precedence, weakest first: native defaults,
+     * matched CSS, explicit props, inline style, a component's `styleOverride`. Inline wins over CSS for the same reason it does
+     * on the web.
+     *
+     * Raw, because this is what the next commit diffs against. Colours and asset ids are converted
+     * on the way out instead (`processed`), and only for the keys that changed: the converters
+     * return fresh objects, so diffing their output would re-send every image and shadow on every
+     * unrelated change.
+     */
+    private mergeProps;
+    /** Set once any node has had a `direction` in its inline style. See `directionOf`. */
+    private inlineDirection;
+    /**
+     * The direction a paragraph is laid out in, where the app wrote one: its own, or the nearest
+     * ancestor's. Undefined when nothing above it says, which leaves the platform's own.
+     *
+     * A stylesheet's `direction` is inherited through the cascade, so it is already in `props`. An
+     * inline one is not, and is found by walking up, which only happens once some node has had one.
+     */
+    private directionOf;
+    /**
+     * Hold back what a transition is meant to ease into.
+     *
+     * Called with everything the node would otherwise commit with, so a property is compared
+     * against the last value aimed at rather than the last one painted: a transition redirected
+     * halfway carries on from where it had got to instead of snapping.
+     *
+     * A property seen for the first time is recorded and left alone. That is CSS's own rule, and
+     * without it every element would fade in from whatever the previous value happened to be.
+     */
+    /** Take a sheet's `@keyframes` into the registry. Cheap and idempotent; sheets are few. */
+    private registerKeyframes;
+    private readonly knownSheets;
+    /**
+     * Start, advance or stop the `@keyframes` animation a node's style asks for.
+     *
+     * Unlike a transition this does not need anything to have changed: an animation plays from its
+     * own frames, which is what lets an element animate in without differing from anything.
+     */
+    private animated;
+    /** Start the clock on an animation, unless the node is already playing this one. */
+    private startPlaying;
+    /**
+     * `animation-play-state` changed on an animation already playing: pausing holds the frame it
+     * has reached, and running again carries on from there, the paused time left out of its clock.
+     * Neither starts it over, as a change of play state does not in CSS.
+     */
+    private playOrPause;
+    /** Every node playing a scroll-driven animation, by the scroll view that plays it. */
+    private readonly scrollTimelines;
+    /** How far each such scroll view scrolls, along each axis, once one of its events has said. */
+    private readonly scrollExtents;
+    /**
+     * An animation played by the nearest scroll view's offset: `animation-timeline: scroll()`.
+     *
+     * Its keyframes are laid along the offset and handed to native, which plays them as the view
+     * scrolls, with no JavaScript between (`scroll-animation.ts`, `NativeScrollDriver.animate`).
+     * The frame at the offset the view starts at is committed once and then left alone: a prop that
+     * changed on a later commit would reset what native is animating.
+     */
+    private scrollAnimated;
+    /** Hand a scroll-driven animation's channels to native, fed by `source`'s scroll events. */
+    private driveScrolled;
+    /** The scroll view a scroll-driven animation on `node` follows: the nearest one it is inside. */
+    private scrollSourceOf;
+    private stopScrolled;
+    /**
+     * A scroll view has said how far it scrolls. Every animation on it with a range that depends on
+     * that - none written, or a percentage - is laid out again along the new extent.
+     */
+    private measuredScroll;
+    private reportUnscrolled;
+    private reportHeld;
+    private reportMissingKeyframes;
+    private transitioned;
+    /** One `@keyframes` player, one frame on. */
+    private advancePlayer;
+    /**
+     * Late-bound because the host that wants the callback is usually built from this engine, so
+     * neither can be constructed with the other in hand.
+     */
+    setOnDirty(fn: () => void): void;
+    /** Late-bound for the same reason: the app's `ErrorHandler` lives in an injector built later. */
+    setOnError(fn: (error: unknown, topLevelType: string) => void): void;
+    /** Whether any transition or animation still has frames left to run. */
+    get animating(): boolean;
+    /**
+     * Whether anything has changed since the last commit.
+     *
+     * The frame loop reads this because a `transitionend` listener runs after its commit has
+     * finished, and what it does is often to remove the element that just finished leaving. That
+     * change needs a commit of its own or the view stays on screen, fully transparent, forever.
+     */
+    get pending(): boolean;
+    /**
+     * Advance every transition to `now` and mark what changed. The caller commits afterwards; on a
+     * device the platform pumps this from `requestAnimationFrame` for as long as it returns true.
+     */
+    advanceAnimations(now?: number): boolean;
+    /** The host's conversions, applied to a copy. A removed prop travels as null and stays null. */
+    private processed;
+    /** Copy a list of shadow-like objects, running each `color` through the host's converter. */
+    private processNestedColors;
+    /**
+     * Copy a filter list, running a drop shadow's colour through the host's converter. Android reads
+     * that colour as a number and throws on a string, taking the whole surface down with it.
+     */
+    private processFilters;
+    /**
+     * Copy a list of gradients, running every stop's colour through the host's converter.
+     *
+     * A stop's colour is a colour like any other, but it is two levels down and nothing else looks
+     * there: without this the device is handed the string `rgb(255, 0, 0)` where it wants a number,
+     * and paints nothing.
+     */
+    private processGradients;
+    private clearFlags;
+    private reconcile;
+    /**
+     * Whether a node has to be committed with its children again.
+     *
+     * A child that re-cloned has a new handle, so the parent must re-clone too. This is the bubble
+     * that persistent trees force, and it is why dirty marking propagates upwards. A node to be
+     * measured again is cloned with its children even when they are the same ones: new children
+     * is what makes Fabric dirty a measured node (`remeasureText`).
+     */
+    private childrenMoved;
+    /**
+     * The handles of a node's children, reconciling only the ones that can have changed.
+     *
+     * One changed row in a list of a thousand makes the list re-clone, and the other 999 are asked
+     * for their handle. A clean child whose style still holds under this node's is its committed
+     * handle as it stands, so it is answered here without the call, the resolve and the walk -
+     * which, per child, was most of what a one-row update cost.
+     */
+    private reconcileChildren;
+    /**
+     * Whether a child is left out of its parent's commit: a modal host whose `visible` is false.
+     *
+     * The native host covers the screen and takes every touch whether or not it presents anything,
+     * which is why React Native's Modal.js renders null while hidden. This is the same thing, so a
+     * hidden `<modal>` leaves the screen under it usable. On iOS a modal that was showing stays
+     * committed, with `visible` false, until native reports `topDismiss`: Modal.js keeps it that
+     * long so the dismissal animates and `(dismiss)` fires. Android drops it at once, as Modal.js
+     * does there.
+     */
+    /** Remember an iOS modal host committed as showing, so hiding it waits for `topDismiss`. */
+    private notePresented;
+    private withheld;
+    /**
+     * `reconcileChildren` for a node other nodes hoist into: its own children, each followed by
+     * the hoisted nodes written inside it, then those written in it directly, then the views it
+     * keeps for hoisted nodes that are gone.
+     */
+    private reconcileHoistTarget;
+    /**
+     * A child's handle as a child of `parent`, created again when it was committed under another.
+     *
+     * Native gives a view one parent for as long as it lives: `ShadowNodeFamily::setParent`
+     * asserts it in a debug build, and a release build keeps the first parent and measures and lays
+     * the view out against the wrong ancestry. A node Angular moves - content projected into a
+     * container that was mounted again, a scroll view Android wraps in its swipe layout - is
+     * therefore created afresh, with everything under it, as React creates an element that moves.
+     * Its native state goes with it, as it would there.
+     */
+    private reconcileUnder;
+    /** Let a node and everything under it be created again at the next commit. */
+    private forgetCommitted;
+    /** A hoisted node, which commits into an ancestor further up than the parent it is in. */
+    private committedElsewhere;
+    /**
+     * Reconcile a hoisted element committing into `target`, into the native view `target` already
+     * keeps for its name when it has one (`HoistOptions.standIn`), and keep the view it commits as.
+     */
+    private land;
+    /**
+     * Commit the stand-in props onto every view `target` keeps whose element is gone, on the view
+     * itself so the native side sees an update rather than a removal.
+     */
+    private standIn;
+    /** A clean child's committed handle, when its style still holds under its parent's. */
+    private stillCommitted;
+    /**
+     * The hoisted nodes that commit as direct children of `node`, keyed by the child of `node` each
+     * was written inside. Null when there are none, which is nearly always.
+     */
+    private hoistedInto;
+    /** Whether a hoisted node commits further up than the parent it was written in. */
+    private hoistsAbove;
+    private create;
+    /**
+     * Angular's own unknown-element check does not run in this pipeline, so a `<text>` in a
+     * template that never imported `Text` compiles, renders as a plain view, and looks like a
+     * layout bug. On the first commit of any known element with no component behind it, say so.
+     */
+    private checkClaimed;
+    /**
+     * The misspelt-prop check. Angular's own "Can't bind to" check needs a DOM to run, so a
+     * `[numberofLines]` on a `<text>`, or a static `iosBackgroundColor` on a `<switch>`, went to
+     * native as a prop no view reads, and nothing said so. A prop on a host primitive that its
+     * component did not declare is reported once per element name and prop, with the declared name
+     * it most likely meant when there is one.
+     */
+    private readonly undefinedTokens;
+    /** Said once per name: a phone has no inspector to show the declaration struck out. */
+    private reportUndefinedToken;
+    private checkProps;
+    private isDeclared;
+    /**
+     * Element names some template's directives select by tag: every component with an element
+     * selector, and directives such as Angular's `router-outlet` that own an element without
+     * hosting a component. Declared by the platform adapter, which sees each template's directive
+     * registry as the component is created.
+     */
+    private readonly declaredElements;
+    /** An element name a directive or component selects, and so is not a typo. */
+    declareElement(name: string): void;
+    /**
+     * Attribute names that belong to Angular rather than to a native view: what a directive selects
+     * on or takes as an input, and what a component's `<ng-content select>` projects by. Angular
+     * writes a static attribute to the node whatever consumes it, so without these a
+     * `nativeRouterLink` or a `listHeader` marker would read as a misspelt prop. See `checkProps`.
+     */
+    private readonly declaredAttributes;
+    declareAttribute(name: string): void;
+    /**
+     * The typo check. The set a name is looked up in is app-wide rather than per template, so a
+     * directive imported in one template also quiets its name in another that forgot it. That is
+     * the trade for not holding a registry per component, and the typo is the case that matters.
+     */
+    private checkKnown;
+    private readonly responders;
+    private currentResponder;
+    /** Register a node as a candidate responder. Returns an unsubscribe. */
+    setResponder(node: EngineNode, handlers: ResponderHandlers): () => void;
+    /**
+     * Keep a native view for this node, or stop keeping one.
+     *
+     * Fabric flattens a view whose props say nothing visual and nothing interactive: no native view
+     * is created and its layout is folded into the parent. Responders live here, in JavaScript, and
+     * Fabric cannot see them - so a transparent touch-catcher looks exactly like a view worth
+     * flattening, and gets flattened, and never receives the touch it exists to catch.
+     *
+     * That is a popover that will not close. The full-screen catcher over the app has no background
+     * and nothing else on it; the dialog's backdrop survived the same treatment only because
+     * `bg-black/50` happened to make it visual.
+     *
+     * Only plain views: flattening is `ViewShadowNode`'s, so a paragraph, a scroll view or a text
+     * input is already a native view and marking it would be a prop on every text node in the tree
+     * that buys nothing.
+     *
+     * A floor rather than an override: `collapsable="true"` written on an element is left alone,
+     * because someone who writes it means it.
+     */
+    private keepNative;
+    /**
+     * A view command, by name: `focus` and `blur` on a text input, `scrollTo` on a scroll view.
+     * Fabric addresses the committed shadow node, so a node that has not reached a commit yet has
+     * 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.
+     */
+    measure(node: EngineNode, into: (frame: WindowFrame) => void): void;
+    /**
+     * The react tag a node was committed with, or null if it has never reached a commit.
+     *
+     * This is what the native animation driver writes to: `connectAnimatedNodeToView` takes a tag,
+     * and `findNodeHandle` hands a number straight back, so an animated graph can point at one of
+     * our nodes without a React instance existing anywhere.
+     */
+    tagOf(node: EngineNode): number | null;
+    /**
+     * The shadow node Fabric currently holds for a node, or null before its first commit.
+     *
+     * A clone-on-write tree hands back a different object every time a node's props change, so
+     * this is not an identity. What is stable is the family behind it, which is what native keys a
+     * node by, and is why a UI-thread animation given one of these keeps writing to the right view
+     * however many times the node is cloned afterwards.
+     */
+    shadowNodeOf(node: EngineNode): FabricNode | null;
+    /** The node currently owning the gesture, if any. */
+    get responder(): EngineNode | null;
+    /**
+     * The node native last reported focused, if any: the text input the keyboard belongs to.
+     *
+     * Checked against the tree rather than trusted, because a focused node that outlives its view
+     * is not a stale style - it is every tap in the application being swallowed. Every scroll view
+     * reads this on every touch to decide whether the touch means "dismiss the keyboard", and one
+     * that decides yes *captures* the touch before any child sees it. So a field left focused after
+     * its view is gone makes the whole app untappable until it is restarted.
+     *
+     * Neither teardown hook can be relied on to clear it. `removeChild` unlinks the subtree's root
+     * and leaves everything under it pointing at its own parent, so a focused descendant still looks
+     * attached; and Angular calls `destroyNode` for the nodes it tracks, not for every node in a
+     * removed subtree. An overlay closing with a field inside it misses both.
+     *
+     * So it is answered by looking: a node still in the tree reaches the root by walking up. That
+     * costs the depth of one node, on a touch, and only while something is focused.
+     */
+    get focused(): EngineNode | null;
+    /** Whether a node is still part of the tree, rather than in a subtree that was removed. */
+    private isAttached;
+    /** The host's `resolveAssetSource`, for a component that needs an asset's size up front. */
+    resolveAsset(value: unknown): unknown;
+    /**
+     * The host's `processColor`, and the one place a platform colour becomes one.
+     *
+     * Props are processed by name - anything ending in `color` - which covers every colour that is
+     * a prop. A colour *nested* inside a prop native parses itself is invisible to that rule: a tab
+     * bar's appearance carries eight of them, and unprocessed they arrive as strings native reads
+     * as nothing at all. So this is public, and the commit walk uses it too.
+     *
+     * `platform-color(label)` cannot be resolved at build time - the same declaration is
+     * `{semantic}` on iOS and `{resource_paths}` on Android - so the names travel and the shape is
+     * put on here. `processColor` understands both, exactly as it does for RN's own `PlatformColor`.
+     */
+    color(value: unknown): unknown;
+    /** Root-first, so a capture pass reads forwards and a bubble pass reads backwards. */
+    private pathTo;
+    private negotiate;
+    private grant;
+    private release;
+    private tellNative;
+    /** Runs before listener propagation, as React's responder plugin does. */
+    private runResponder;
+    private registerEventHandler;
+    /**
+     * Fabric's `(instanceHandle, topLevelType, nativeEvent)` callback.
+     *
+     * **Events propagate up the retained tree.** Fabric hands JS only the hit target; React
+     * implements two-phase propagation itself by walking the fiber tree, and so must we. Without
+     * it a tap on a `<text>` label inside a `<pressable>` reaches the text node and stops, so the
+     * button only responds on its padding. That reads as "taps sometimes do not register".
+     *
+     * ponytail: event priority (`unstable_getCurrentEventPriority` and the
+     * `unstable_*EventPriority` constants) is read into the facade but not acted on. Angular's
+     * zoneless scheduler already flushes on a microtask, which is soon enough for taps. It stops
+     * being soon enough for a controlled TextInput, where the echo has to beat the next
+     * keystroke. `mostRecentEventCount` covers that today by letting native reject a stale write;
+     * a synchronous flush for discrete priority is the fix if it ever stops being enough.
+     *
+     * **Nothing thrown here may escape.** Fabric calls this synchronously from C++
+     * (`UIManagerBinding::dispatchEventToJS`), often from inside a mounting transaction, and a throw
+     * unwinds through that transaction: for a screen push the next commit then reads props freed on
+     * the way out and the process dies with no JS stack at all. Angular
+     * already catches what its own template listeners throw; everything else on this path - the
+     * responder handlers, listeners registered on the engine directly, a commit started by a focus
+     * change - is caught here and handed to `onError`, which the platform points at the app's
+     * `ErrorHandler`. Each listener is guarded on its own, so one that throws does not stop the
+     * bubble for the rest, as in the DOM.
+     */
+    dispatchEvent(instanceHandle: unknown, topLevelType: string, nativeEvent: unknown): void;
+    /** A presented modal host has finished leaving, so a hidden one can come out of the tree. */
+    private dismissed;
+    private reportEventError;
+    /**
+     * A list that scrolls under a finger takes the touch away from whatever it started on.
+     *
+     * Distance alone cannot tell a scroll from a tap. The press rect is the control's own bounds
+     * plus a retention offset, which is right - a 15pt threshold cancels an ordinary thumb tap on a
+     * full-width button - but on a 72pt list row it means a 72pt drag still counts as a tap, and a
+     * 72pt drag is unmistakably a scroll. So the list is asked instead of the arithmetic: it knows
+     * it is scrolling, and every platform cancels the touch at that moment.
+     *
+     * Only a responder *inside* the thing that scrolled, so a scroll view moving does not cancel a
+     * press somewhere else on screen. And only while a touch is in progress: momentum after the
+     * finger has lifted, and programmatic scrolling, have no press to cancel.
+     */
+    private cancelPressForScroll;
+    /**
+     * Tell "the native side never sent it" from "it arrived and nothing was listening", which are
+     * otherwise identical symptoms. One line per event, so it is off unless asked for.
+     */
+    private trace;
+    /**
+     * `:focus` follows the native events rather than being inferred from a tap, so it is right for a
+     * field focused programmatically or by the keyboard's next-field button.
+     */
+    private trackFocus;
+    /** Walk target to root. Fabric hands JS only the hit target; the propagation is ours to do. */
+    private propagate;
+    /**
+     * Clone a committed node with whatever changed. Fabric's persistent tree has no in-place edit:
+     * a new revision is a new node, which is why a changed child forces its parent to clone too.
+     *
+     * `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.
+     */
+    private clone;
+    private detach;
+}
+export {};