gesso-core 0.4.1 → 0.5.0

package/dist/{index-CfUSbphd.d.ts → index-DBnLGexp.d.ts}

@@ -1013,7 +1013,50 @@ declare class LayoutRecord {
    * that offset to its content extent.
    */
   clips: boolean;
+  /**
+   * Where anything in this subtree may paint, in the same space as the
+   * box: the box itself, grown by whatever reaches past it under a node
+   * that doesn't clip (an absolute child, a child pushed past it). A
+   * renderer culls a node by this rather than by its box, since a node
+   * that doesn't clip lets its children paint anywhere. It's the box
+   * whenever nothing reaches past, which is nearly always. Worked out
+   * when a node with children is placed, and grown up the ancestors
+   * when a box is written; too large costs a descent, never a paint.
+   */
+  extentMinX: number;
+  extentMinY: number;
+  extentMaxX: number;
+  extentMaxY: number;
+  /**
+   * How far past each side of its box the node itself paints: its
+   * outer `boxShadows`, which no clip of its own holds in. Zero for
+   * nearly every node. Part of the extent, and of a clipping node's
+   * contribution to its parent's, since its clip is for its children.
+   * Read from the node when its box is written and when a frame
+   * repaints it; see `LayoutEngine.refreshPaintReach`.
+   */
+  paintReachLeft: number;
+  paintReachTop: number;
+  paintReachRight: number;
+  paintReachBottom: number;
   scrollable: boolean;
+  /**
+   * An editable, which scrolls its own text inside its box.
+   *
+   * Not `scrollable`: it has no children to translate and its offset
+   * follows the caret, so every path that treats a scroll container's
+   * content as children leaves it alone. What it shares with one is
+   * the offset and its clamp — see `scrollRange` — and, when it is
+   * multiline, the overlay scrollbars.
+   */
+  scrollsText: boolean;
+  /**
+   * A multiline editable, which shows the overlay scrollbars a scroll
+   * container does over its own text. A single-line field scrolls
+   * sideways too, but a bar under one line of text reads as part of
+   * the control rather than a hint that there is more of it.
+   */
+  textScrollbars: boolean;
   /**
    * A scroll container that reads right to left, so its overlay
    * scrollbar hangs on the left edge and the band that reveals it is
@@ -1072,42 +1115,54 @@ declare class LayoutRecord {
   /** Constraints this record was last measured under. */
   lastConstraints: Constraints;
   /**
-   * A second memoised measurement. Flex measures every item twice —
-   * loose for its max-content size, then tight at its final size — and
-   * a one-entry memo would miss on every pass of every later frame. The
-   * outputs of the previous constraints are kept here and swapped back
-   * in when those constraints come round again, so an unchanged item
-   * costs nothing in either pass.
-   */
-  altValid: boolean;
-  altConstraints: Constraints;
-  /**
-   * The alternate measurement's twelve outputs, one field each.
-   *
-   * These were a `number[]` built by an `outputs()` helper, which reads
-   * better and cost two array allocations on every flex item of every
-   * pass: a full pass of the benchmark list spent 2.2% of its time in
-   * the pair of helpers that packed and unpacked them, before the
-   * collector's share of having made the arrays at all. A field per
-   * output is the same twelve numbers with nothing built to hold them.
-   */
-  private altMeasuredWidth;
-  private altMeasuredHeight;
-  private altOuterWidth;
-  private altOuterHeight;
-  private altMinContentWidth;
-  private altMinContentHeight;
-  private altMaxContentWidth;
-  private altIntrinsicWidth;
-  private altIntrinsicHeight;
-  private altHasBaseline;
-  private altBaseline;
-  private altContentWidth;
-  private altContentHeight;
-  /** Keeps the current measurement as the alternate before a fresh one overwrites it. */
+   * The percentage base the current measurement resolved against, and
+   * whether the node has a length that resolves against one.
+   *
+   * A percentage is resolved against the container's content box,
+   * which is not in the constraints. A node sized `height: 100%` and
+   * asked the same loose constraints under a taller container must
+   * not be handed back the height it had in the shorter one, so for a
+   * node with a percentage the base is part of what a memo matches.
+   * Each axis counts only for a node with a percentage on it, so a
+   * block that is `width: 100%` is not measured again because its
+   * column's height changed, and a node with none (the overwhelming
+   * majority) matches as cheaply as it always did.
+   */
+  lastBaseWidth: number | undefined;
+  lastBaseHeight: number | undefined;
+  percentWidth: boolean;
+  percentHeight: boolean;
+  /** Whether a measurement under `baseWidth` by `baseHeight` would resolve the same percentages as the current one. */
+  sameBase(baseWidth: number | undefined, baseHeight: number | undefined): boolean;
+  /**
+   * Earlier memoised measurements, most recently used first.
+   *
+   * Flex measures an item more than once a pass, and a memo of one
+   * entry missed on every pass of every later frame. Two entries (the
+   * last one and one alternate) covered a column of items: loose for
+   * the max-content size, then tight at the final size. A row with a
+   * flexible child holding a column of auto-height blocks asks that
+   * column's items a third question: the flex basis measures them
+   * unbounded, the final width measures them loose in height, and a
+   * row that stretches its items measures them again at the stretched
+   * height. With two slots the third evicted one of the others, so an
+   * edit to one block re-measured every block on every keystroke: 6,005
+   * nodes for a 1,000-paragraph document, where a hit costs nothing.
+   *
+   * The slots are allocated the first time a record needs one, so a
+   * node only ever measured one way carries none.
+   */
+  private alternates;
+  /** Keeps the current measurement as the most recent alternate before a fresh one overwrites it. */
   saveAlt(): void;
-  /** Makes the alternate measurement current, and the current one alternate. */
-  swapAlt(): void;
+  /**
+   * Makes a remembered measurement for these constraints current, and
+   * keeps the current one as an alternate in its place. False when
+   * nothing remembered matches.
+   */
+  recallAlt(constraints: Constraints, baseWidth?: number, baseHeight?: number): boolean;
+  /** Forgets every remembered measurement: the node's content changed. */
+  forgetAlts(): void;
   /**
    * Set by the parent before measuring this node: something outside it
    * reads a content-derived output beyond its constrained size — its
@@ -1126,6 +1181,8 @@ declare class LayoutRecord {
   relayoutBoundary: boolean;
   measureDirty: boolean;
   placeDirty: boolean;
+  /** Whether the node's children have been placed at least once, so its subtree can be shifted rather than placed. */
+  placedOnce: boolean;
   transformDirty: boolean;
   /**
    * Which layout pass last folded the node's properties onto this
@@ -1224,6 +1281,15 @@ interface UiColors {
   readonly selectionBackground: UiColor;
   readonly selectionForeground: UiColor;
 }
+/**
+ * The stock palettes.
+ *
+ * Neutrals carry a little blue, as a screen's greys do now, rather
+ * than being an even mix of the three channels; the accent is deep
+ * enough that white on it reads (4.5:1 and up), which the bright
+ * Material blue this replaced did not. Values are written as 8-bit
+ * channels so each one can be read as the hex it is.
+ */
 declare const lightColors: UiColors;
 declare const darkColors: UiColors;
 /**
@@ -1726,6 +1792,8 @@ interface LayoutStats {
   measured: number;
   /** Nodes whose place ran. */
   placed: number;
+  /** Laid-out subtrees that moved without changing size, and were shifted rather than placed again. */
+  shifted: number;
   /** Subtrees laid out from a relayout boundary instead of the root. */
   relayoutRoots: number;
   /** Whether the pass started from the root. */
@@ -1813,11 +1881,12 @@ declare class UiSharedElements {
    * But it must not disappear *yet*. A claim happens during
    * reconciliation, and the arriving node has no box until the frame
    * lays out — so yielding here leaves a window in which neither
-   * element is drawn. For a transform morph that window is closed
-   * within the same frame; for a geometry morph, which cannot write a
-   * box after layout has run, it is a whole frame long, and a whole
-   * frame with neither the old card nor the new one is a flash of the
-   * page behind them. It was exactly that visible.
+   * element is drawn. The window closes within the frame now, for a
+   * geometry morph as for a transform one, but only because the
+   * arriving element takes its place in that frame's layout pass; when
+   * a geometry morph's box waited for the next frame, a whole frame
+   * with neither the old card nor the new one was a flash of the page
+   * behind them, and it was exactly that visible.
    *
    * So the caller yields the previous holder at the moment it actually
    * takes its place. Until then both are on screen, in the same
@@ -1974,6 +2043,15 @@ declare class DirtyNodeSet {
   delete(node: UiNode): boolean;
   get size(): number;
   isEmpty(): boolean;
+  /**
+   * Whether any node in the set carries one of `flags`, without
+   * draining it.
+   *
+   * What a frame asks after its layout listeners have run: whether one
+   * of them wrote something that has to be laid out again before the
+   * frame paints. Stops at the first node that says yes.
+   */
+  anyFlags(flags: DirtyFlags): boolean;
   /**
    * Drains the set, returning the nodes in insertion order.
    */
@@ -2273,7 +2351,21 @@ declare class UiKeyboardEvent extends UiInputEvent {
 declare class UiBeforeInputEvent extends UiInputEvent {
   readonly inputType: string;
   readonly data: string | null;
-  constructor(inputType: string, data: string | null);
+  /**
+   * For `insertFromPaste`, the clipboard's HTML when it held some,
+   * else null. `data` is always its plain text, which is what the
+   * field inserts; an editor that keeps structure (a heading, a list,
+   * a link) can cancel the edit and convert this instead.
+   */
+  readonly html: string | null;
+  constructor(inputType: string, data: string | null,
+  /**
+   * For `insertFromPaste`, the clipboard's HTML when it held some,
+   * else null. `data` is always its plain text, which is what the
+   * field inserts; an editor that keeps structure (a heading, a list,
+   * a link) can cancel the edit and convert this instead.
+   */
+  html?: string | null);
 }
 /**
  * An editable node's text changed: the new value and the selection
@@ -2289,7 +2381,11 @@ declare class UiBeforeInputEvent extends UiInputEvent {
  */
 declare class UiPasteEvent extends UiInputEvent {
   readonly text: string;
-  constructor(text: string);
+  /** The clipboard's HTML when it held some, else null. */
+  readonly html: string | null;
+  constructor(text: string,
+  /** The clipboard's HTML when it held some, else null. */
+  html?: string | null);
 }
 declare class UiTextChangeEvent extends UiInputEvent {
   readonly value: string;
@@ -2648,6 +2744,246 @@ interface ComponentResolver {
   flushMounts(): void;
 }
 //#endregion
+//#region src/input/UiFocusManager.d.ts
+/**
+ * One entry on the focus scope stack.
+ *
+ * `restore` is what held focus when the scope was pushed, so popping
+ * can hand focus back to the control that opened the dialog. Scopes
+ * nest: a confirmation dialog over a dialog pushes a second one, and
+ * each pop restores its own opener.
+ */
+/**
+ * What moved focus, which decides whether the focused node is scrolled
+ * into view.
+ *
+ * A browser draws the same distinction and it is the reason it exists:
+ * keyboard focus must reveal its target, because a control the person
+ * cannot see is a control they cannot use, while a *click* has already
+ * shown them where they are — the thing they pressed is under their
+ * cursor. Scrolling after a click moves the page out from under a
+ * pointer that is still there, and on a tall element that is a jump of
+ * most of the screen.
+ */
+type FocusSource = 'pointer' | 'keyboard' | 'program';
+/**
+ * How focus is moved, beyond what moved it. The DOM's `FocusOptions`,
+ * for the part of it that means something here.
+ */
+interface FocusOptions {
+  /**
+   * Leaves every scroll container where it is, as
+   * `element.focus({ preventScroll: true })` does: the node takes focus
+   * without being scrolled into view.
+   *
+   * For focus placed for a screen reader's sake rather than the eye's.
+   * A page that focuses its content region when it opens, so the region
+   * is read out, starts at its top; revealing the region as well would
+   * scroll a tall one to a few pixels short of its own edge, because a
+   * reveal keeps a margin from the viewport.
+   *
+   * Kept for as long as the node holds focus: a key pressed later makes
+   * the focus visible without scrolling to it either. Moving focus
+   * again, by Tab or by code, reveals as usual.
+   */
+  readonly preventScroll?: boolean;
+}
+/**
+ * How the person last drove the app, as far as focus can tell: the
+ * pointer or the keyboard. This is what decides whether focus is
+ * *visible*, the way `:focus-visible` does in a browser: a ring that
+ * appeared on every mouse click would mark a control nobody is about to
+ * drive with the keyboard, so the ring waits until the keyboard is used.
+ */
+type FocusModality = 'pointer' | 'keyboard';
+/**
+ * Logical focus within the UI tree.
+ *
+ * At most one node holds focus at a time. Focus transitions are
+ * target-only: the node losing focus receives Blur (with the new
+ * node as `relatedNode`), then the node gaining focus receives Focus
+ * (with the old node as `relatedNode`).
+ *
+ * Tab / Shift+Tab navigation walks the focusable nodes in document
+ * (depth-first) order and wraps around. A node participates when
+ * `isNodeFocusable` says so: focusable by type (Button), explicitly
+ * opted in via `focusable: true`, and never when inert.
+ *
+ * Focus-on-press is applied through `focusOnPress`, which the pointer
+ * pipeline calls after a successful pointerdown (skipped when the
+ * down was defaultPrevented).
+ *
+ * **Scopes.** `pushScope(node)` confines focus to a subtree: traversal
+ * collects only that subtree's focusables, so Tab wraps inside it, and
+ * `focus()` refuses a node outside it — which is what makes a modal
+ * dialog modal for the keyboard. `popScope()` restores focus to
+ * whatever held it when the scope was pushed. Components reach both
+ * through `FocusService`, never directly.
+ */
+declare class UiFocusManager {
+  private readonly dispatcher;
+  private root;
+  private focused;
+  /**
+   * Keyboard until told otherwise, so focus placed before any input
+   * (an `autoFocus`, a dialog's first field) is visible, as a browser
+   * would show it.
+   */
+  private modality;
+  /** How the focused node took focus; see `FocusOptions.preventScroll`. */
+  private focusedOptions;
+  private readonly listeners;
+  private readonly scopeListeners;
+  private readonly scopes;
+  /** The field of each editing group that last had focus, where Tab back into the group lands. */
+  private readonly groupEntries;
+  constructor(root: UiNode, dispatcher: UiInputDispatcher);
+  /** The root used for focus-order traversal. Clears any active scope. */
+  setRoot(root: UiNode): void;
+  /** The node that currently holds logical focus, or null. */
+  get focusedNode(): UiNode | null;
+  hasFocus(): boolean;
+  /** How the person last drove the app. */
+  get focusModality(): FocusModality;
+  /**
+   * Whether the focus held should be shown. True while focus was
+   * reached by the keyboard, or by code with no pointer since; false
+   * after a pointer press, until the next key.
+   */
+  get focusVisible(): boolean;
+  /**
+   * Records an input the person made. A change of modality while a node
+   * holds focus is reported to the focus listeners as a change on that
+   * node, so a ring can appear on a mouse-focused control the moment an
+   * arrow key is pressed, and disappear again on the next press.
+   */
+  noteInput(modality: FocusModality): void;
+  /**
+   * The subtree focus is currently confined to: the innermost scope,
+   * or the whole tree when none is active.
+   */
+  get scopeRoot(): UiNode;
+  /** Whether focus is confined to a subtree. */
+  get trapped(): boolean;
+  /**
+   * Moves focus to the node. Returns false when the node cannot be
+   * focused (inert, non-focusable, outside the active scope); true
+   * otherwise, including when the node already held focus (a no-op
+   * that emits nothing).
+   *
+   * `options` travel with the change to the listeners, which is where
+   * the runtime decides whether to scroll the node into view.
+   */
+  focus(node: UiNode, source?: FocusSource, options?: FocusOptions): boolean;
+  /**
+   * Called after focus moves or clears, with the new focused node. The
+   * runtime uses it to scroll the focused node into view, unless the
+   * options say not to.
+   */
+  onFocusChange(listener: (node: UiNode | null, source: FocusSource, options: FocusOptions) => void): () => void;
+  /** Called after a scope is pushed or popped. */
+  onScopeChange(listener: () => void): () => void;
+  private notify;
+  private notifyScope;
+  /** Drops focus without moving it anywhere. */
+  blur(): void;
+  /**
+   * Focus-on-press hook: focuses the nearest focusable node at or above
+   * the one that was pressed.
+   *
+   * The walk upward is what the DOM does, and what a container that is
+   * one tab stop needs: pressing a tab hits the Text inside it, a table
+   * cell hits a Box three levels below the table, and a component whose
+   * arrows move a selection is keyboard-dead after a mouse press if the
+   * press left focus where it was. Found in a browser, on `Tabs` —
+   * clicking a tab selected it and the arrows then did nothing.
+   *
+   * Nothing focusable above the press leaves focus untouched, as before:
+   * pressing the page background is not a request to blur.
+   */
+  focusOnPress(node: UiNode): void;
+  /** Moves focus to the next focusable node, wrapping to the first. */
+  focusNext(): boolean;
+  /** Moves focus to the previous focusable node, wrapping to the last. */
+  focusPrevious(): boolean;
+  /**
+   * Confines focus to `root` until the matching `popScope`.
+   *
+   * Focus that is outside the new scope moves to its first focusable,
+   * so the very next Tab stays inside; a scope with nothing focusable
+   * in it drops focus rather than leaving it behind the dialog.
+   */
+  pushScope(root: UiNode): void;
+  /**
+   * Moves focus into the innermost scope when it is outside it, and
+   * drops it when the scope has nothing to focus.
+   *
+   * A scope is usually taken from a `ref`, which fires before the
+   * node's children are reconciled — so at that moment a dialog is an
+   * empty box and there is nothing in it to focus. The runtime calls
+   * this again once the frame's tree is built, which is when a dialog
+   * gets its caret. Idempotent: with focus already inside the scope,
+   * or no scope at all, it does nothing.
+   *
+   * **The scope root is the fallback, and it is the whole reason
+   * `tabStop` exists.** A scope with no tab stop inside it used to
+   * blur, which hands the keyboard to nothing: a `Dialog` whose body
+   * is a sentence and a button could not be dismissed with Escape,
+   * because Escape had nowhere to be delivered. Falling back to the
+   * root fixes that only if the root can hold focus without becoming a
+   * stop of its own, or every dialog grows a tab stop that announces
+   * nothing. `focusable: true, tabStop: false` on the body is exactly
+   * that pair, and the fallback is what makes it worth setting.
+   *
+   * Blurring is still what happens when the root cannot hold focus
+   * either, because a scope that has genuinely nothing to focus is
+   * better admitted than faked.
+   */
+  settleScope(): void;
+  /**
+   * Ends the innermost scope and hands focus back to whatever held it
+   * when that scope was pushed, when that node is still in the tree
+   * and still focusable. Otherwise focus is dropped rather than left
+   * on a node the scope was hiding.
+   */
+  popScope(): void;
+  /**
+   * Reacts to a subtree leaving the graph.
+   *
+   * The graph reports the root of a removed subtree after detaching
+   * every node in it, so the descendants' parent links are already
+   * gone: the test is "is this node still attached", not "was it in
+   * that subtree".
+   *
+   * A scope whose subtree has gone is a trap that ended, so it is
+   * popped as though the component had released it and focus returns
+   * to the opener — a dialog that unmounts hands the keyboard back
+   * without having to sequence its own teardown. Focus lost with the
+   * subtree is dropped without a Blur, since the node's listeners were
+   * released with it.
+   */
+  handleNodeRemoved(_node: UiNode): void;
+  private moveFocus;
+  /**
+   * The tab stops in document order (parent before children).
+   *
+   * Tab stops and not every focusable node: a container with
+   * `tabStop: false` can hold focus and is not a place the cycle
+   * stops, which is what lets a dialog body be the keyboard's home of
+   * last resort without becoming a stop of its own.
+   */
+  private collectFocusable;
+  /** Whether an ancestor is hidden or disabled, which takes the node's focus away with it. */
+  private insideHidden;
+  /** The editing group a field belongs to, by its root, or null for anything that isn't a field of one. */
+  private groupOf;
+  /** Whether the node may hold focus given the active scope, if any. */
+  private withinScope;
+  /** Whether the node is still connected to the traversal root. */
+  private isAttached;
+  private isWithin;
+}
+//#endregion
 //#region src/modifiers/UiModifierHost.d.ts
 /** Anything a modifier can hand to `own` to have released on detach. */
 type UiModifierTeardown = (() => void) | {
@@ -2771,6 +3107,13 @@ interface UiModifierHost {
    * A scroll is a superset of what a listener may care about: read
    * `flowBox()` inside the listener when what matters is the node's
    * place in the layout rather than on the screen.
+   *
+   * It runs after the frame's layout and before the frame paints, and
+   * the listener may change layout from it: the runtime lays out again
+   * before painting, and tells the listeners whose boxes that moved, so
+   * what was written is on screen on the same frame. The loop is
+   * bounded, so a listener that answers its own change with another
+   * one is painted unsettled and warned about rather than hanging.
    */
   onLayout(listener: (box: LayoutBox) => void): void;
   /**
@@ -2790,8 +3133,12 @@ interface UiModifierHost {
    * at all.
    */
   onEnvironment(listener: () => void): void;
-  /** Moves keyboard focus to the node, if it can take it. */
-  focus(): void;
+  /**
+   * Moves keyboard focus to the node, if it can take it. It is scrolled
+   * into view as any focus from code is, unless `options.preventScroll`
+   * says otherwise.
+   */
+  focus(options?: FocusOptions): void;
   /** Whether the node currently holds keyboard focus. */
   isFocused(): boolean;
   /**
@@ -2948,7 +3295,7 @@ interface UiModifierFocus {
   isFocused(node: UiNode): boolean;
   /** Whether the focus `node` holds should be shown; see `UiFocusManager.focusVisible`. */
   isFocusVisible(node: UiNode): boolean;
-  focus(node: UiNode): void;
+  focus(node: UiNode, options?: FocusOptions): void;
   onFocusChange(node: UiNode, listener: (focused: boolean) => void): () => void;
 }
 /** Where a modifier's environment access comes from. */
@@ -3016,30 +3363,118 @@ declare class UiModifierSet {
  */
 declare function assertModifierList(node: UiNode, value: unknown): readonly UiModifier[];
 //#endregion
-//#region src/environment/UiContainerSize.d.ts
+//#region src/editing/UiEditingGroup.d.ts
 /**
- * A box's content size as it changes, for the things that branch on
- * it.
+ * Fields that select as one: the editables inside a container that sets
+ * `editingGroup`.
  *
- * The value behind `UiEnvironmentKeys.containerSize`, and deliberately
- * a *source* rather than a size. An environment value is a snapshot
- * that a subtree caches, so putting a number in one would mean
- * rebuilding the environment of everything under a container on every
- * pixel of a drag. The source object never changes identity, so the
- * environment is built once; what changes is what the source reports,
- * and only the code that asked to hear about it does any work.
+ * A document editor is many fields, one per paragraph, and a person
+ * selects across paragraphs as if they were one text: dragging from one
+ * into the next, Shift and an arrow off the end of a line, Shift and a
+ * press further down, select all. Each field's own selection can only
+ * cover its own text, so inside a group the editing controller keeps a
+ * selection whose two ends may sit in different fields, lights every
+ * field between them, and hands the shell the selected text, so native
+ * copy and cut take all of it.
  *
- * A media query is the wrong tool for this and is why the environment
- * carries the container and not the window. `observeMediaQuery` needs
- * a window, the runtime that would branch on it is usually in a
- * worker, and the question a component actually has is "how much room
- * do I have", which is not the window's width in any layout with a
- * sidebar in it.
+ * What happens to such a selection when the person types, deletes,
+ * presses Enter, pastes or cuts is the application's: only it knows
+ * that joining a heading to the list under it makes a heading. So those
+ * edits are not applied to any field. They go to `onEdit`, with both
+ * ends, and the application changes its document and puts the caret
+ * where it belongs.
+ *
+ * A selection inside one field is that field's, as it always was.
  */
-interface UiContainerSize {
-  /** The last size reported, or zeroes before the first layout. */
-  readonly current: Size;
-  /** Every distinct size, starting with `current`. */
+interface UiEditingGroup {
+  /** An edit over a selection that spans fields. Nothing is applied for it. */
+  onEdit(edit: UiGroupEdit): void;
+  /**
+   * The text a selection spanning fields copies as. By default each
+   * field's selected text, joined by newlines.
+   */
+  copyText?(start: UiTextPosition, end: UiTextPosition): string;
+  /**
+   * The selection as HTML, which a copy puts on the clipboard beside
+   * the text, for a target that takes formatting (a document, an email).
+   * Asked for a selection across fields and for one inside a single
+   * field of the group. Null or absent copies text alone.
+   */
+  copyHtml?(start: UiTextPosition, end: UiTextPosition): string | null;
+  /**
+   * A selection across fields began, moved, or ended (null). For a
+   * command the application runs over it, such as making it bold:
+   * keys reach the focused field first, and only the group knows what
+   * the selection covers.
+   */
+  onSelectionChange?(selection: {
+    readonly start: UiTextPosition;
+    readonly end: UiTextPosition;
+  } | null): void;
+}
+/** A place in a field's text. */
+interface UiTextPosition {
+  readonly node: UiNode;
+  readonly offset: number;
+}
+/**
+ * An edit over a selection that spans fields, in the DOM's vocabulary:
+ * `insertText` with the text, `insertParagraph` for Enter,
+ * `insertFromPaste`, a `delete…` type for Backspace and Delete, and
+ * `deleteByCut`. `start` comes before `end` in document order.
+ */
+interface UiGroupEdit {
+  readonly inputType: string;
+  readonly data: string | null;
+  /** For a paste, the clipboard's HTML when it held some. */
+  readonly html?: string | null;
+  readonly start: UiTextPosition;
+  readonly end: UiTextPosition;
+}
+/** The group a field belongs to, and the container that declared it, or null. */
+declare function editingGroupOf(node: UiNode): {
+  readonly root: UiNode;
+  readonly group: UiEditingGroup;
+} | null;
+/**
+ * The next field in document order after `from` (or before it, for -1),
+ * inside `root`, or null at either end. Walks only as far as it has to,
+ * so stepping from one paragraph to the next costs the nodes between
+ * them, not the whole document.
+ */
+declare function adjacentField(root: UiNode, from: UiNode, direction: 1 | -1): UiNode | null;
+/** The first or last field inside `root`, or null when it has none. */
+declare function edgeField(root: UiNode, direction: 1 | -1): UiNode | null;
+/**
+ * Which of two positions comes first in document order: negative, zero
+ * or positive, as a comparator.
+ */
+declare function comparePositions(a: UiTextPosition, b: UiTextPosition): number;
+//#endregion
+//#region src/environment/UiContainerSize.d.ts
+/**
+ * A box's content size as it changes, for the things that branch on
+ * it.
+ *
+ * The value behind `UiEnvironmentKeys.containerSize`, and deliberately
+ * a *source* rather than a size. An environment value is a snapshot
+ * that a subtree caches, so putting a number in one would mean
+ * rebuilding the environment of everything under a container on every
+ * pixel of a drag. The source object never changes identity, so the
+ * environment is built once; what changes is what the source reports,
+ * and only the code that asked to hear about it does any work.
+ *
+ * A media query is the wrong tool for this and is why the environment
+ * carries the container and not the window. `observeMediaQuery` needs
+ * a window, the runtime that would branch on it is usually in a
+ * worker, and the question a component actually has is "how much room
+ * do I have", which is not the window's width in any layout with a
+ * sidebar in it.
+ */
+interface UiContainerSize {
+  /** The last size reported, or zeroes before the first layout. */
+  readonly current: Size;
+  /** Every distinct size, starting with `current`. */
   readonly changes: Observable<Size>;
 }
 /**
@@ -3232,24 +3667,28 @@ declare function propertyValuesEqual<T>(definition: UiPropertyDefinition<T>, a:
 //#endregion
 //#region src/properties/UiBoxShadow.d.ts
 /**
- * Renderer-independent box shadow description.
+ * Renderer-independent box shadow description, with CSS `box-shadow`
+ * semantics.
  *
- * A shadow is defined by its offset, blur, spread, color, and
- * whether it is inset. The renderer is responsible for translating
- * these semantics into drawing operations.
+ * An outer shadow is the node's (rounded) box, grown by `spreadRadius`
+ * on every side, moved by the offset, blurred by `blurRadius` (a
+ * Gaussian whose standard deviation is half of it), and seen only
+ * outside the box. An inset one is the same shape inverted and seen
+ * only inside the box. `color` may be a palette name, resolved against
+ * the node's theme as `backgroundColor` is.
  */
 interface UiBoxShadow {
   readonly offsetX: number;
   readonly offsetY: number;
   readonly blurRadius: number;
   readonly spreadRadius: number;
-  readonly color: UiColor;
+  readonly color: UiColorValue;
   readonly inset?: boolean;
 }
 /**
  * Creates a box shadow with the supplied parameters.
  */
-declare function boxShadow(offsetX: number, offsetY: number, blurRadius: number, spreadRadius: number, color: UiColor, inset?: boolean): UiBoxShadow;
+declare function boxShadow(offsetX: number, offsetY: number, blurRadius: number, spreadRadius: number, color: UiColorValue, inset?: boolean): UiBoxShadow;
 /**
  * Compares two box shadows for equality.
  */
@@ -3258,6 +3697,34 @@ declare function boxShadowsEqual(a: UiBoxShadow, b: UiBoxShadow): boolean;
  * Compares two shadow arrays for equality.
  */
 declare function boxShadowArraysEqual(a: readonly UiBoxShadow[], b: readonly UiBoxShadow[]): boolean;
+/**
+ * How far a shadow's blur reaches past the edge of its shape, as a
+ * multiple of `blurRadius`.
+ *
+ * The blur is a Gaussian with a standard deviation of half the radius,
+ * so this is three standard deviations: what is left beyond it is
+ * under a quarter of a percent of the shadow's colour, and both
+ * renderers stop drawing there.
+ */
+declare const BOX_SHADOW_BLUR_REACH = 1.5;
+/**
+ * The corner radius of a shadow's shape, from the box's and the
+ * spread: an outer shadow's corner grows with its spread, an inset
+ * one's hole shrinks with it. A square corner stays square, as CSS
+ * keeps it.
+ */
+declare function boxShadowRadius(boxRadius: number, spreadRadius: number, inset: boolean): number;
+/**
+ * How far past each side of the box a node's outer shadows may paint,
+ * written into `out`; all zero for a node with none. Inset shadows
+ * paint inside the box and add nothing.
+ */
+declare function boxShadowReach(shadows: readonly UiBoxShadow[], out: {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}): void;
 //#endregion
 //#region src/layout/UiLength.d.ts
 /**
@@ -3778,6 +4245,18 @@ interface UiTextMetrics {
   readonly fontVariant?: UiFontVariant;
   readonly fontKerning?: UiFontKerning;
   readonly letterSpacing?: number;
+  /**
+   * Kept in the text but not drawn: the run takes no room, paints
+   * nothing, and a caret steps over it as one unit.
+   *
+   * It is a metric field because it changes a width, to nothing. Its
+   * characters stay where they were, so every offset still means what
+   * it meant, a copy of the text still copies them, and the semantics
+   * mirror still reads them. It is how an editor that styles markup
+   * as it is typed (`**bold**` drawn as a bold word) puts the markers
+   * out of sight without taking them out of the string.
+   */
+  readonly hidden?: boolean;
 }
 /**
  * A run that is activated rather than only read.
@@ -3828,6 +4307,16 @@ interface UiSpannedText {
   readonly text: string;
   readonly spans: readonly UiResolvedTextSpan[];
 }
+/**
+ * What text is set in when nothing says otherwise.
+ *
+ * `system-ui` is the platform's own interface face (San Francisco,
+ * Segoe UI, Roboto), which is what an application on that platform is
+ * expected to look like; `sans-serif` is there for an engine that does
+ * not know the generic. The line is 20 on 14, about 1.43, because the
+ * 1.2 that a browser's `normal` comes to sets lines too tight to read
+ * in a paragraph. The ink is the stock palette's `text`, not black.
+ */
 declare const defaultTextStyle: UiTextStyle;
 /** The text of a span array, with each run's offsets into it. */
 declare function flattenTextSpans(spans: readonly UiTextSpan[]): UiSpannedText;
@@ -3869,7 +4358,21 @@ declare function resolvedSpansOf(node: UiNode): readonly UiResolvedTextSpan[];
  * plain colour rather than a frame of nonsense, and corrects itself
  * as soon as the application catches up.
  */
-declare function editableSpansOf(node: UiNode, text: string): readonly UiResolvedTextSpan[];
+declare function editableSpansOf(node: UiNode, text: string, composition?: UiTextRange | null): readonly UiResolvedTextSpan[];
+/** A stretch of a paragraph, as offsets into its text. */
+interface UiTextRange {
+  readonly start: number;
+  readonly end: number;
+}
+/** The part of a run `hiddenRangesOf` reads; a paint span has it as well as a resolved one. */
+type HiddenSpan = Pick<UiResolvedTextSpan, 'start' | 'end' | 'hidden'>;
+/**
+ * The stretches of a paragraph its runs hide, in order, with runs that
+ * touch merged into one: `**` hidden next to a hidden `_` is one
+ * stretch of three characters, which a caret steps over at once.
+ * Remembered by the identity of the array, as the flattening is.
+ */
+declare function hiddenRangesOf(spans: readonly HiddenSpan[]): readonly UiTextRange[];
 /** The span covering an offset, or undefined where no run does. */
 declare function spanAtOffset(spans: readonly UiResolvedTextSpan[], offset: number): UiResolvedTextSpan | undefined;
 /**
@@ -4123,6 +4626,11 @@ type UiTypographyRole = keyof UiTypography | (keyof UiTypographyExtensions & str
  * drawing at a default size, which is the quieter of the two failures.
  */
 declare function isTypographyRole(value: unknown, scale: UiTypography): value is UiTypographyRole;
+/**
+ * The stock scale: one face, and line heights on a 4-point grid rather
+ * than 1.2 of the size, so a paragraph has room and a stack of text
+ * lines up with the spacing scale around it.
+ */
 declare const defaultTypography: UiTypography;
 /**
  * Compares two typography scales for equality.
@@ -5202,6 +5710,26 @@ interface CompositionRange {
  * took. `replaceText` — the host resetting the value from outside —
  * drops the history: the text it replaces never existed as far as the
  * next undo is concerned.
+ *
+ * **Hidden text.** Runs the field draws as nothing (`hidden` on a
+ * span) are still in the text, and the caret treats each stretch of
+ * them as one unit it cannot stop inside:
+ *
+ * - A move by grapheme or word crosses one visible grapheme or word,
+ *   and with it the hidden text in the way, and stops on the side of
+ *   any hidden text there nearest where it started. From the end of
+ *   `**bold**`, Left stops between `l` and `d`; from the start, Right
+ *   stops after `b`. Where nothing visible is left that way the caret
+ *   goes past the hidden text to the edge, so it is never stuck.
+ * - Backspace and Delete remove the visible grapheme or word next to
+ *   the caret and keep hidden text at either end of it: Backspace at
+ *   the end of `**bold**` leaves `**bol**`. Hidden text strictly inside
+ *   what they remove goes with it, as it does from a selection, which
+ *   is deleted exactly as selected. With nothing visible that way they
+ *   delete nothing.
+ * - An offset the application sets is kept as given, even inside
+ *   hidden text: it may be about to show that text. The next move
+ *   steps out of it.
  */
 declare class EditableTextModel {
   private textValue;
@@ -5213,6 +5741,9 @@ declare class EditableTextModel {
   private redoStack;
   private lastEdit;
   private lastEditEnd;
+  private hiddenRanges;
+  private hiddenText;
+  private visibleCache;
   /** Whether the node holds focus; the caret only shows (and blinks) then. */
   focused: boolean;
   /**
@@ -5255,6 +5786,22 @@ declare class EditableTextModel {
   get composing(): boolean;
   get canUndo(): boolean;
   get canRedo(): boolean;
+  /**
+   * The stretches of the text that are not drawn, in order; empty when
+   * none are, or when the ranges were given for a text the field no
+   * longer holds (a keystroke the application has not restyled yet).
+   */
+  get hidden(): readonly UiTextRange[];
+  /**
+   * Says which stretches of `text` are not drawn. `editorFor` calls
+   * this from the node's runs; the ranges only count while the field
+   * holds that text.
+   */
+  setHidden(text: string, ranges: readonly UiTextRange[]): void;
+  /** An offset moved out of hidden text, to the nearer end of it; any other offset as it is. */
+  caretOffsetNear(offset: number): number;
+  /** Whether no visible grapheme lies from the caret in `direction`, so a move that way can only reach the edge. */
+  atVisibleEdge(direction: -1 | 1): boolean;
   /** Sets the selection; `focus` defaults to `anchor` (a caret). */
   select(anchor: number, focus?: number): void;
   /** Moves the caret to `offset`, extending the selection from the anchor when asked. */
@@ -5267,8 +5814,17 @@ declare class EditableTextModel {
    * vertical movement is the caller's, since it needs geometry.
    */
   move(unit: EditUnit, direction: -1 | 1, extend: boolean): void;
-  /** The offset one `unit` away from `from` in `direction`. */
+  /** The offset one `unit` away from `from` in `direction`; see "Hidden text" above. */
   offsetBy(from: number, unit: EditUnit, direction: -1 | 1): number;
+  /** The text as drawn, or null when nothing in it is hidden. */
+  private visible;
+  /**
+   * The source range a delete of one `unit` from the caret removes, in
+   * a text with hidden runs: the visible stretch it crosses, without
+   * the hidden text at either end of it. Null when nothing visible is
+   * there to delete.
+   */
+  private visibleDeletion;
   /**
    * Replaces the selection with `text` and puts the caret after it.
    * Single-grapheme insertions at the caret coalesce into one undo
@@ -5342,7 +5898,9 @@ declare class EditableTextModel {
  * What a node is. Closed, so a typo is a build error the way an
  * unknown prop already is: the mirror can only emit roles it knows.
  */
-type UiRole = 'button' | 'checkbox' | 'switch' | 'radio' | 'radiogroup' | 'slider' | 'spinbutton' | 'textbox' | 'searchbox' | 'combobox' | 'listbox' | 'option' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'tab' | 'tablist' | 'tabpanel' | 'link' | 'progressbar' | 'list' | 'listitem' | 'tree' | 'treeitem' | 'grid' | 'row' | 'columnheader' | 'rowheader' | 'cell' | 'group' | 'separator' | 'toolbar' | 'heading' | 'image' | 'paragraph' | 'dialog' | 'alertdialog' | 'tooltip' | 'alert' | 'status' | 'banner' | 'navigation' | 'main' | 'region' | 'form' | 'search' | 'contentinfo';
+type UiRole = 'button' | 'checkbox' | 'switch' | 'radio' | 'radiogroup' | 'slider' | 'spinbutton' | 'textbox' | 'searchbox' | 'combobox' | 'listbox' | 'option' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'tab' | 'tablist' | 'tabpanel' | 'link' | 'progressbar' | 'list' | 'listitem' | 'tree' | 'treeitem' | 'grid' | 'row' | 'columnheader' | 'rowheader' | 'cell' |
+/** A cell of an interactive `grid`: what a calendar's day is, and what can be `selected`. */
+'gridcell' | 'group' | 'separator' | 'toolbar' | 'heading' | 'image' | 'paragraph' | 'dialog' | 'alertdialog' | 'tooltip' | 'alert' | 'status' | 'banner' | 'navigation' | 'main' | 'region' | 'form' | 'search' | 'contentinfo';
 /** How urgently a live region's changes are announced. */
 type UiLiveRegion = 'polite' | 'assertive';
 declare const UI_ROLES: readonly UiRole[];
@@ -5355,7 +5913,19 @@ declare function isUiRole(value: unknown): value is UiRole;
  * two ways to say it would let them disagree. The semantics record
  * derives it.
  */
-type UiSemanticState = 'checked' | 'mixed' | 'expanded' | 'collapsed' | 'selected' | 'pressed' | 'busy' | 'invalid' | 'required' | 'readonly' | 'modal';
+type UiSemanticState = 'checked' | 'mixed' | 'expanded' | 'collapsed' | 'selected' | 'pressed' | 'busy' | 'invalid' | 'required' | 'readonly' | 'modal' |
+/**
+ * On a `listbox`, `grid` or `tree` whose selection is a set: without
+ * it a screen reader treats the option it's on as the one selected.
+ */
+'multiselectable' |
+/**
+ * The item that is the current one of a set, such as the page a
+ * navigation link leads to while it's open. `selected` is for choices
+ * in a listbox, grid or tabs, and a screen reader ignores it on a link
+ * or a button.
+ */
+'current';
 declare const UI_SEMANTIC_STATES: readonly UiSemanticState[];
 declare function isUiSemanticState(value: unknown): value is UiSemanticState;
 /**
@@ -5761,6 +6331,12 @@ declare const UiProperties: {
    * label out by default.
    */
   readonly selectable: UiPropertyDefinition<boolean | undefined>;
+  /**
+   * Makes the editables inside one selection: a selection can start in
+   * one and end in another, and edits over it go to the group's
+   * `onEdit`. See `UiEditingGroup`.
+   */
+  readonly editingGroup: UiPropertyDefinition<UiEditingGroup | undefined>;
   readonly pointerEvents: UiPropertyDefinition<UiPointerEvents | undefined>;
   readonly focusable: UiPropertyDefinition<boolean | undefined>;
   readonly tabStop: UiPropertyDefinition<boolean | undefined>;
@@ -5789,6 +6365,14 @@ declare const UiProperties: {
   readonly posInSet: UiPropertyDefinition<number | undefined>;
   /** How many items the set holds, including the ones not mounted. */
   readonly setSize: UiPropertyDefinition<number | undefined>;
+  /**
+   * The descendant that's active while this node keeps focus: the
+   * highlighted option of a combobox whose field holds the caret, the
+   * cell a grid's cursor is on. A screen reader announces it as if it
+   * were focused. The node should be a record of its own (an `option`,
+   * a `gridcell`); see `aria-activedescendant`.
+   */
+  readonly activeDescendant: UiPropertyDefinition<UiNode | null | undefined>;
   /**
    * How deep a treeitem sits, 1 for a root. A tree is rendered as a
    * flat list of rows — it must be, to be virtualized — so the nesting
@@ -5824,6 +6408,31 @@ declare const UiProperties: {
    */
   readonly scrollBehavior: UiPropertyDefinition<"instant" | "smooth" | undefined>;
   readonly scrollY: UiPropertyDefinition<number | undefined>;
+  /**
+   * Another node whose scroll offset this scroll container takes, on
+   * the axes `scrollWithAxis` names: a line-number gutter beside an
+   * editable's text, a spreadsheet's row header beside its grid.
+   *
+   * Taken in the same layout pass that settles the other node's
+   * offset, so the two are painted in step on every frame, whatever
+   * scrolled the other one — a wheel, a scrollbar, the caret, a clamp
+   * after text was deleted. Binding `scrollY` to what `scrollPosition`
+   * reports cannot do that: the report arrives after the frame is laid
+   * out, and the follower is a frame behind.
+   *
+   * The follower's own `scrollX`/`scrollY` are ignored on a followed
+   * axis, it shows no scrollbars, and a wheel over it scrolls the node
+   * it follows. The other node may be any scroll container or an
+   * editable, which scrolls its own text; the offset is clamped to the
+   * follower's own range, so give it content as tall as the text.
+   *
+   * The follower may be `overflow: 'hidden'`, which is otherwise never
+   * scrolled: following makes it scrolled, and nothing but the leader
+   * moves it.
+   */
+  readonly scrollWith: UiPropertyDefinition<UiNode | null | undefined>;
+  /** Which axes `scrollWith` follows: 'both' (default), 'x' or 'y'. */
+  readonly scrollWithAxis: UiPropertyDefinition<"both" | "x" | "y" | undefined>;
   /**
    * What happens to a wheel delta this node cannot use.
    *
@@ -6028,13 +6637,13 @@ type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColo
  * they cascade to the text below it.
  */
 type TypographyProps = PropsOf<'color' | 'fontFamily' | 'fontSize' | 'fontWeight' | 'lineHeight' | 'letterSpacing' | 'textAlign' | 'textDirection' | 'fontStyle' | 'fontStretch' | 'fontVariant' | 'fontKerning' | 'textDecoration'>;
-type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'focusable' | 'tabStop' | 'disabled' | 'hitTestable' | 'visualState' | 'selectable'>;
+type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'focusable' | 'tabStop' | 'disabled' | 'hitTestable' | 'visualState' | 'selectable' | 'editingGroup'>;
 /**
  * What the element means, for assistive technology. Legal on any
  * element; a component sets them on the node that *is* the control,
  * not on a wrapper. See `UiSemantics.ts`.
  */
-type SemanticsProps = PropsOf<'role' | 'label' | 'description' | 'live' | 'states' | 'valueNow' | 'valueMin' | 'valueMax' | 'valueText' | 'posInSet' | 'setSize' | 'level'>;
+type SemanticsProps = PropsOf<'role' | 'label' | 'description' | 'live' | 'states' | 'valueNow' | 'valueMin' | 'valueMax' | 'valueText' | 'posInSet' | 'setSize' | 'level' | 'activeDescendant'>;
 /** Environment values an element provides to its subtree. */
 type EnvironmentProps = PropsOf<'theme' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets'>;
 /**
@@ -6068,7 +6677,7 @@ type CommonProps = IdentityProps & UiEventProps & BoxModelProps & FlexItemProps
  * layout replaces whatever the container would have done with its
  * children, whichever container it is; see `layout/CustomLayout.ts`.
  */
-type ContainerProps = CommonProps & PropsOf<'overflow' | 'scrollX' | 'scrollY' | 'scrollBehavior' | 'overscrollBehavior' | 'layout'>;
+type ContainerProps = CommonProps & PropsOf<'overflow' | 'scrollX' | 'scrollY' | 'scrollWith' | 'scrollWithAxis' | 'scrollBehavior' | 'overscrollBehavior' | 'layout'>;
 /** Props of a flex container: Row, Column, ScrollView. */
 type FlexContainerProps = ContainerProps & PropsOf<'gap' | 'rowGap' | 'columnGap' | 'x' | 'y' | 'flexWrap' | 'alignContent' | 'direction'>;
 /**
@@ -6328,6 +6937,18 @@ declare class UiGraphBuilder {
    * instance is unchanged and torn down when a property stops
    * being reactive.
    */
+  /**
+   * The properties each node's element declared last time, so a render
+   * that stops declaring one takes it off the node.
+   *
+   * Only bindings used to be torn down that way. A plain value stayed:
+   * a conditional that swapped `<scrollview padding={20}>` for a
+   * `<scrollview>` reused the node and kept the padding, and an editor
+   * switching from its source view back to its document came back
+   * twenty pixels narrower. Only what the builder declared is tracked,
+   * so what modifiers and the runtime write on a node is left alone.
+   */
+  private readonly declaredProps;
   private reconcileProps;
   /**
    * Attaches, updates and detaches the node's modifiers.
@@ -6653,6 +7274,12 @@ declare class UiGraph {
    * hold the node and would otherwise pay for an id lookup.
    */
   updateNodeProperty<T>(node: UiNode, property: string, value: T, dirtyFlags?: DirtyFlags): boolean;
+  /**
+   * Removes a property the element declared and no longer does, through
+   * the same cascade a write goes through, so a modifier overriding it
+   * keeps its value. See `UiGraphBuilder.reconcileProps`.
+   */
+  removeNodeProperty(node: UiNode, property: string, dirtyFlags?: DirtyFlags): boolean;
   /**
    * Writes a property without consulting the node's transitions.
    *
@@ -7001,7 +7628,9 @@ interface ResponsiveProps extends ColumnProps {
  * The first build happens before any layout, when the size is zero, so
  * `build` must return something sensible for a container whose room is
  * not yet known. Zero picks the narrowest arm, which is the right
- * guess and also what a phone gets.
+ * guess and also what a phone gets. It is never what a wider container
+ * paints: the first layout reports the real size, the arm for it is
+ * built, and the runtime lays that out before the frame paints.
  */
 declare function Responsive(props: ResponsiveProps, build: (size: Size) => UiChild | readonly UiChild[]): UiElement;
 //#endregion
@@ -7176,6 +7805,12 @@ interface TextRunStyle {
 interface TextRunSpan extends TextRunStyle {
   readonly start: number;
   readonly end: number;
+  /**
+   * The run is in the text but takes no room: every width that touches
+   * it counts it as nothing, and a line's `runs` leave it out, so no
+   * renderer has anything to draw for it.
+   */
+  readonly hidden?: boolean;
 }
 interface TextMeasureRequest {
   text: string;
@@ -7234,7 +7869,7 @@ interface TextLine {
   width: number;
   /**
    * The line cut at its runs, present only for a paragraph that has
-   * spans.
+   * spans. A hidden run is not among them.
    *
    * Measured once, here, where the line's own width is measured. That
    * is what keeps a spanned paragraph as cheap to paint as a plain
@@ -7318,6 +7953,8 @@ interface SpannedRuns {
   indexAt(offset: number): number;
   /** The request an offset is measured with: its run's, or the paragraph's. */
   requestAt(offset: number): TextMeasureRequest;
+  /** Whether the character at `offset` is in a hidden run. */
+  hiddenAt(offset: number): boolean;
   /** Width of `text.slice(start, end)`, measured run by run. */
   width(text: string, start: number, end: number): number;
   /**
@@ -7326,7 +7963,10 @@ interface SpannedRuns {
    * as.
    */
   widthOf(run: string, offset: number): number;
-  /** `text.slice(start, end)` cut at the run boundaries, each piece placed from `x`. */
+  /**
+   * `text.slice(start, end)` cut at the run boundaries, each piece
+   * placed from `x`. Hidden pieces take no room and are left out.
+   */
   cut(text: string, start: number, end: number, x: number): TextLineRun[];
 }
 /**
@@ -7491,7 +8131,12 @@ interface PaintState {
   borderColor: UiColor | undefined;
   borderWidth: number;
   borderRadius: UiBorderRadius;
-  boxShadows: readonly UiBoxShadow[];
+  /**
+   * The node's shadows, in the order they were declared, with palette
+   * names resolved against its theme. A shadow whose colour names
+   * nothing is dropped, as a background that names nothing is.
+   */
+  boxShadows: readonly PaintBoxShadow[];
   hasTransform: boolean;
   transform: UiTransform;
   text: string | undefined;
@@ -7551,6 +8196,10 @@ interface PaintState {
   matchColor: UiColor;
   caretColor: UiColor;
 }
+/** A shadow ready to paint: a `UiBoxShadow` whose colour is resolved. */
+interface PaintBoxShadow extends UiBoxShadow {
+  readonly color: UiColor;
+}
 /** A run of a paragraph, ready to paint: metrics, resolved colours, and its link. */
 interface PaintTextSpan extends UiTextMetrics {
   readonly start: number;
@@ -7772,6 +8421,15 @@ interface Canvas2DContext {
   font: string;
   textAlign: CanvasTextAlign;
   textBaseline: CanvasTextBaseline;
+  /**
+   * The shadow a fill casts, which is how a `boxShadows` entry is drawn.
+   * Unlike everything else here, the offset and blur are in device
+   * pixels: the current transform does not apply to them.
+   */
+  shadowColor: string;
+  shadowBlur: number;
+  shadowOffsetX: number;
+  shadowOffsetY: number;
 }
 //#endregion
 //#region src/rendering/TextRenderer.d.ts
@@ -7966,13 +8624,27 @@ declare class EditableLayout {
   readonly rtl: boolean;
   constructor(model: EditableTextModel, box: LayoutBox, state: PaintState, measurer: TextMeasurer);
   caretRect(offset?: number): CaretRect;
+  /**
+   * The caret position nearest a point. Where hidden text sits at the
+   * boundary nearest the point, a point before the boundary (left of it
+   * in left-to-right text) lands before the hidden text and a point
+   * past it lands after: hidden text takes no room, so its two ends
+   * are drawn at one x and the side of the press is what tells them
+   * apart. Never inside hidden text.
+   */
   offsetAt(x: number, y: number): number;
   verticalMove(offset: number, direction: -1 | 1, goalX?: number): {
     offset: number;
     x: number;
   } | null;
-  /** Boxes behind the selected text. */
-  selectionBoxes(): LayoutBox[];
+  /**
+   * Boxes behind the selected text: the field's part of a selection
+   * across an editing group when `range` is given, else its own.
+   */
+  selectionBoxes(range?: {
+    readonly start: number;
+    readonly end: number;
+  }): LayoutBox[];
   /** Boxes under the text the IME is composing, for its underline. */
   compositionBoxes(): LayoutBox[];
 }
@@ -8244,6 +8916,23 @@ declare const SCROLLBAR_MIN_THUMB = 24;
 /** Distance from the end edge within which the pointer reveals the bar. */
 declare const SCROLLBAR_HOVER_ZONE = 16;
 type ScrollbarAxis = 'x' | 'y';
+/**
+ * The node a `scrollWith` container follows, or null for one that
+ * scrolls on its own. A follower has no scrollbar of its own, and what
+ * would scroll it scrolls this instead.
+ */
+declare function scrollLeaderOf(node: UiNode): UiNode | null;
+/**
+ * The furthest a record's content can be scrolled along an axis.
+ *
+ * The one answer the layout engine's clamp, the scrollbars and the
+ * scroll sinks all read, so a wheel stops exactly where the caret
+ * would. A field may go one caret width past its text, so that a
+ * caret at the very end is inside the box and not on the clipped
+ * edge; a field wide enough for its text gets no allowance, or the
+ * line would shift by a pixel the moment the caret reached the end.
+ */
+declare function scrollRange(rec: LayoutRecord, axis: ScrollbarAxis): number;
 /**
  * One scrollbar's geometry, in the container's record coordinates
  * (pre-scroll, like the record box): the thumb rectangle and the
@@ -8730,352 +9419,146 @@ declare class UiFindController {
   handleKey(key: string, modifiers: UiKeyModifiers): boolean;
   /** The query the matches are for; empty when nothing is being searched. */
   get query(): string;
-  /** Every match, in document order. */
-  get matches(): readonly FindMatch[];
-  get matchCount(): number;
-  /** The index of the active match, or -1 when there is none. */
-  get activeIndex(): number;
-  /**
-   * Runs a query over the app's text and activates the first match.
-   * Returns how many there are; an empty query clears everything.
-   */
-  search(query: string, options?: FindOptions): number;
-  /**
-   * Re-runs the current query. The tree changed under it — content was
-   * edited, a list scrolled new rows in — so the matches did too.
-   */
-  refresh(): void;
-  /** Moves to the next match, wrapping around. */
-  next(): boolean;
-  /** Moves to the previous match, wrapping around. */
-  previous(): boolean;
-  /** Drops the query, the matches and their highlights. */
-  clear(): void;
-  /**
-   * A node left the tree. Its matches went with it, so the search is
-   * re-run rather than left pointing at something that is gone.
-   */
-  handleNodeRemoved(node: UiNode): void;
-  private notify;
-  private step;
-  /**
-   * The matches of a query, dropped where the text they are in is not
-   * drawn: a paragraph capped by `maxLines` shows part of itself, and a
-   * match the user cannot see must not be counted or stepped through.
-   * Geometry is only measured for the nodes that matched at all.
-   */
-  private collect;
-  /** Writes the match ranges onto the nodes that hold them. */
-  private highlight;
-  /** Selects the match at `index` and scrolls it into view. */
-  private activate;
-  private revealMatch;
-  private geometryEndOf;
-  /** The node's text laid out in its own coordinates; see UiSelectionController. */
-  private geometryOf;
-}
-//#endregion
-//#region src/graph/UiPropertyOverrides.d.ts
-/**
- * The cascade a modifier writes into.
- *
- *   effective(property) = the last override in modifier order,
- *                         else what the element declared
- *
- * Keeping the element's own value rather than replacing it is what
- * makes a modifier safe to detach: dragging can write `transform` and
- * `opacity` for as long as the drag lasts, and dropping restores
- * exactly what the element asked for — including "nothing", which
- * restores inheritance from the environment rather than a default.
- *
- * Everything here funnels into `graph.applyResolvedProperty`, so
- * layout, paint, input and the environment read what they always read.
- */
-/**
- * A write from the element: a plain prop, or an emission from a bound
- * Observable. It updates the declared value; whether it reaches the
- * node depends on whether a modifier is currently overriding it.
- */
-declare function writeDeclaredProperty(graph: UiGraph, node: UiNode, property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
-/**
- * A write from a modifier. Replaces that modifier's own entry, or adds
- * one in its position in the list.
- */
-declare function writeOverrideProperty(graph: UiGraph, node: UiNode, property: NodeProperty, override: Omit<UiPropertyOverride, 'value'> & {
-  value: unknown;
-}, flags: DirtyFlags): boolean;
-/** Removes one modifier's write, restoring whatever was under it. */
-declare function clearOverrideProperty(graph: UiGraph, node: UiNode, property: NodeProperty, source: symbol, flags: DirtyFlags): boolean;
-/** The names of the modifiers overriding a property, in order. */
-declare function overrideSources(node: UiNode, property: NodeProperty): string[];
-/** Test hook: forgets which conflicts have been reported. */
-declare function resetOverrideWarnings(): void;
-//#endregion
-//#region src/graph/UiPropertyTransitions.d.ts
-/**
- * The transitions declared on one node, and the animations they are
- * currently running.
- *
- * This is the same shape as the override cascade and for the same
- * reason that lives on the node: **both
- * the builder's static writes and a binding's emissions funnel through
- * `updateNodeProperty`**, so interposing there is the only place that
- * catches both. `node.transitions` is null until an element declares
- * one, so the cost to a tree without transitions is the second field
- * read on the write path.
- *
- * What it interposes is a write, not a binding. The Observable a
- * component wrote is still bound by the graph and still emits into the
- * same property; what changes is that the emission becomes a target
- * rather than a value. So nothing about component identity, binding
- * teardown or `getBindingForProperty` moves, and a `transition` can be
- * added to an element without touching anything else about it.
- */
-declare class NodeTransitions implements UiNodeTransitions {
-  private readonly node;
-  private readonly graph;
-  private readonly driver;
-  private specs;
-  private readonly cells;
-  private readonly targets;
-  constructor(node: UiNode, graph: UiGraph, driver: AnimationDriver);
-  /** Replaces what the element declares; a property dropped from the list stops animating. */
-  setSpecs(specs: ReadonlyMap<NodeProperty, UiTransitionSpec>): void;
-  get size(): number;
-  /**
-   * Takes over a write, or declines it.
-   *
-   * Declines when the property has no transition, when the node has no
-   * value yet — a node's *first* value is not a change and animating
-   * from nothing would mean animating from a default nobody asked for
-   * — and when the two values cannot be blended (`interpolatorFor`
-   * says which, and why).
-   */
-  write(property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
-  /** Cancels everything, for a node leaving the tree or dropping the prop. */
-  release(): void;
-  private stopProperty;
-  /**
-   * The cell one property animates through, kept for the life of the
-   * node: the driver keys its running set by cell identity, so a fresh
-   * adapter per write would leave the previous animation running.
-   *
-   * Writing goes through `updateNodePropertyNow`, which is the path a
-   * plain write takes minus this class — so a modifier's override still
-   * sits on top of an animated value, exactly as it sits on top of a
-   * bound one.
-   */
-  private cellFor;
-  private startAnimation;
-}
-/** Test hook: forgets which properties have been reported. */
-declare function resetTransitionWarnings(): void;
-//#endregion
-//#region src/input/UiFocusManager.d.ts
-/**
- * One entry on the focus scope stack.
- *
- * `restore` is what held focus when the scope was pushed, so popping
- * can hand focus back to the control that opened the dialog. Scopes
- * nest: a confirmation dialog over a dialog pushes a second one, and
- * each pop restores its own opener.
- */
-/**
- * What moved focus, which decides whether the focused node is scrolled
- * into view.
- *
- * A browser draws the same distinction and it is the reason it exists:
- * keyboard focus must reveal its target, because a control the person
- * cannot see is a control they cannot use, while a *click* has already
- * shown them where they are — the thing they pressed is under their
- * cursor. Scrolling after a click moves the page out from under a
- * pointer that is still there, and on a tall element that is a jump of
- * most of the screen.
- */
-type FocusSource = 'pointer' | 'keyboard' | 'program';
-/**
- * How the person last drove the app, as far as focus can tell: the
- * pointer or the keyboard. This is what decides whether focus is
- * *visible*, the way `:focus-visible` does in a browser: a ring that
- * appeared on every mouse click would mark a control nobody is about to
- * drive with the keyboard, so the ring waits until the keyboard is used.
- */
-type FocusModality = 'pointer' | 'keyboard';
-/**
- * Logical focus within the UI tree.
- *
- * At most one node holds focus at a time. Focus transitions are
- * target-only: the node losing focus receives Blur (with the new
- * node as `relatedNode`), then the node gaining focus receives Focus
- * (with the old node as `relatedNode`).
- *
- * Tab / Shift+Tab navigation walks the focusable nodes in document
- * (depth-first) order and wraps around. A node participates when
- * `isNodeFocusable` says so: focusable by type (Button), explicitly
- * opted in via `focusable: true`, and never when inert.
- *
- * Focus-on-press is applied through `focusOnPress`, which the pointer
- * pipeline calls after a successful pointerdown (skipped when the
- * down was defaultPrevented).
- *
- * **Scopes.** `pushScope(node)` confines focus to a subtree: traversal
- * collects only that subtree's focusables, so Tab wraps inside it, and
- * `focus()` refuses a node outside it — which is what makes a modal
- * dialog modal for the keyboard. `popScope()` restores focus to
- * whatever held it when the scope was pushed. Components reach both
- * through `FocusService`, never directly.
- */
-declare class UiFocusManager {
-  private readonly dispatcher;
-  private root;
-  private focused;
-  /**
-   * Keyboard until told otherwise, so focus placed before any input
-   * (an `autoFocus`, a dialog's first field) is visible, as a browser
-   * would show it.
-   */
-  private modality;
-  private readonly listeners;
-  private readonly scopeListeners;
-  private readonly scopes;
-  constructor(root: UiNode, dispatcher: UiInputDispatcher);
-  /** The root used for focus-order traversal. Clears any active scope. */
-  setRoot(root: UiNode): void;
-  /** The node that currently holds logical focus, or null. */
-  get focusedNode(): UiNode | null;
-  hasFocus(): boolean;
-  /** How the person last drove the app. */
-  get focusModality(): FocusModality;
-  /**
-   * Whether the focus held should be shown. True while focus was
-   * reached by the keyboard, or by code with no pointer since; false
-   * after a pointer press, until the next key.
-   */
-  get focusVisible(): boolean;
-  /**
-   * Records an input the person made. A change of modality while a node
-   * holds focus is reported to the focus listeners as a change on that
-   * node, so a ring can appear on a mouse-focused control the moment an
-   * arrow key is pressed, and disappear again on the next press.
-   */
-  noteInput(modality: FocusModality): void;
-  /**
-   * The subtree focus is currently confined to: the innermost scope,
-   * or the whole tree when none is active.
-   */
-  get scopeRoot(): UiNode;
-  /** Whether focus is confined to a subtree. */
-  get trapped(): boolean;
-  /**
-   * Moves focus to the node. Returns false when the node cannot be
-   * focused (inert, non-focusable, outside the active scope); true
-   * otherwise, including when the node already held focus (a no-op
-   * that emits nothing).
-   */
-  focus(node: UiNode, source?: FocusSource): boolean;
-  /**
-   * Called after focus moves or clears, with the new focused node. The
-   * runtime uses it to scroll the focused node into view.
-   */
-  onFocusChange(listener: (node: UiNode | null, source: FocusSource) => void): () => void;
-  /** Called after a scope is pushed or popped. */
-  onScopeChange(listener: () => void): () => void;
-  private notify;
-  private notifyScope;
-  /** Drops focus without moving it anywhere. */
-  blur(): void;
-  /**
-   * Focus-on-press hook: focuses the nearest focusable node at or above
-   * the one that was pressed.
-   *
-   * The walk upward is what the DOM does, and what a container that is
-   * one tab stop needs: pressing a tab hits the Text inside it, a table
-   * cell hits a Box three levels below the table, and a component whose
-   * arrows move a selection is keyboard-dead after a mouse press if the
-   * press left focus where it was. Found in a browser, on `Tabs` —
-   * clicking a tab selected it and the arrows then did nothing.
-   *
-   * Nothing focusable above the press leaves focus untouched, as before:
-   * pressing the page background is not a request to blur.
-   */
-  focusOnPress(node: UiNode): void;
-  /** Moves focus to the next focusable node, wrapping to the first. */
-  focusNext(): boolean;
-  /** Moves focus to the previous focusable node, wrapping to the last. */
-  focusPrevious(): boolean;
-  /**
-   * Confines focus to `root` until the matching `popScope`.
-   *
-   * Focus that is outside the new scope moves to its first focusable,
-   * so the very next Tab stays inside; a scope with nothing focusable
-   * in it drops focus rather than leaving it behind the dialog.
-   */
-  pushScope(root: UiNode): void;
-  /**
-   * Moves focus into the innermost scope when it is outside it, and
-   * drops it when the scope has nothing to focus.
-   *
-   * A scope is usually taken from a `ref`, which fires before the
-   * node's children are reconciled — so at that moment a dialog is an
-   * empty box and there is nothing in it to focus. The runtime calls
-   * this again once the frame's tree is built, which is when a dialog
-   * gets its caret. Idempotent: with focus already inside the scope,
-   * or no scope at all, it does nothing.
-   *
-   * **The scope root is the fallback, and it is the whole reason
-   * `tabStop` exists.** A scope with no tab stop inside it used to
-   * blur, which hands the keyboard to nothing: a `Dialog` whose body
-   * is a sentence and a button could not be dismissed with Escape,
-   * because Escape had nowhere to be delivered. Falling back to the
-   * root fixes that only if the root can hold focus without becoming a
-   * stop of its own, or every dialog grows a tab stop that announces
-   * nothing. `focusable: true, tabStop: false` on the body is exactly
-   * that pair, and the fallback is what makes it worth setting.
-   *
-   * Blurring is still what happens when the root cannot hold focus
-   * either, because a scope that has genuinely nothing to focus is
-   * better admitted than faked.
+  /** Every match, in document order. */
+  get matches(): readonly FindMatch[];
+  get matchCount(): number;
+  /** The index of the active match, or -1 when there is none. */
+  get activeIndex(): number;
+  /**
+   * Runs a query over the app's text and activates the first match.
+   * Returns how many there are; an empty query clears everything.
    */
-  settleScope(): void;
+  search(query: string, options?: FindOptions): number;
   /**
-   * Ends the innermost scope and hands focus back to whatever held it
-   * when that scope was pushed, when that node is still in the tree
-   * and still focusable. Otherwise focus is dropped rather than left
-   * on a node the scope was hiding.
+   * Re-runs the current query. The tree changed under it — content was
+   * edited, a list scrolled new rows in — so the matches did too.
    */
-  popScope(): void;
+  refresh(): void;
+  /** Moves to the next match, wrapping around. */
+  next(): boolean;
+  /** Moves to the previous match, wrapping around. */
+  previous(): boolean;
+  /** Drops the query, the matches and their highlights. */
+  clear(): void;
   /**
-   * Reacts to a subtree leaving the graph.
-   *
-   * The graph reports the root of a removed subtree after detaching
-   * every node in it, so the descendants' parent links are already
-   * gone: the test is "is this node still attached", not "was it in
-   * that subtree".
+   * A node left the tree. Its matches went with it, so the search is
+   * re-run rather than left pointing at something that is gone.
+   */
+  handleNodeRemoved(node: UiNode): void;
+  private notify;
+  private step;
+  /**
+   * The matches of a query, dropped where the text they are in is not
+   * drawn: a paragraph capped by `maxLines` shows part of itself, and a
+   * match the user cannot see must not be counted or stepped through.
+   * Geometry is only measured for the nodes that matched at all.
+   */
+  private collect;
+  /** Writes the match ranges onto the nodes that hold them. */
+  private highlight;
+  /** Selects the match at `index` and scrolls it into view. */
+  private activate;
+  private revealMatch;
+  private geometryEndOf;
+  /** The node's text laid out in its own coordinates; see UiSelectionController. */
+  private geometryOf;
+}
+//#endregion
+//#region src/graph/UiPropertyOverrides.d.ts
+/**
+ * The cascade a modifier writes into.
+ *
+ *   effective(property) = the last override in modifier order,
+ *                         else what the element declared
+ *
+ * Keeping the element's own value rather than replacing it is what
+ * makes a modifier safe to detach: dragging can write `transform` and
+ * `opacity` for as long as the drag lasts, and dropping restores
+ * exactly what the element asked for — including "nothing", which
+ * restores inheritance from the environment rather than a default.
+ *
+ * Everything here funnels into `graph.applyResolvedProperty`, so
+ * layout, paint, input and the environment read what they always read.
+ */
+/**
+ * A write from the element: a plain prop, or an emission from a bound
+ * Observable. It updates the declared value; whether it reaches the
+ * node depends on whether a modifier is currently overriding it.
+ */
+declare function writeDeclaredProperty(graph: UiGraph, node: UiNode, property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
+/**
+ * A write from a modifier. Replaces that modifier's own entry, or adds
+ * one in its position in the list.
+ */
+declare function writeOverrideProperty(graph: UiGraph, node: UiNode, property: NodeProperty, override: Omit<UiPropertyOverride, 'value'> & {
+  value: unknown;
+}, flags: DirtyFlags): boolean;
+/** Removes one modifier's write, restoring whatever was under it. */
+declare function clearOverrideProperty(graph: UiGraph, node: UiNode, property: NodeProperty, source: symbol, flags: DirtyFlags): boolean;
+/** The names of the modifiers overriding a property, in order. */
+declare function overrideSources(node: UiNode, property: NodeProperty): string[];
+/** Test hook: forgets which conflicts have been reported. */
+declare function resetOverrideWarnings(): void;
+//#endregion
+//#region src/graph/UiPropertyTransitions.d.ts
+/**
+ * The transitions declared on one node, and the animations they are
+ * currently running.
+ *
+ * This is the same shape as the override cascade and for the same
+ * reason that lives on the node: **both
+ * the builder's static writes and a binding's emissions funnel through
+ * `updateNodeProperty`**, so interposing there is the only place that
+ * catches both. `node.transitions` is null until an element declares
+ * one, so the cost to a tree without transitions is the second field
+ * read on the write path.
+ *
+ * What it interposes is a write, not a binding. The Observable a
+ * component wrote is still bound by the graph and still emits into the
+ * same property; what changes is that the emission becomes a target
+ * rather than a value. So nothing about component identity, binding
+ * teardown or `getBindingForProperty` moves, and a `transition` can be
+ * added to an element without touching anything else about it.
+ */
+declare class NodeTransitions implements UiNodeTransitions {
+  private readonly node;
+  private readonly graph;
+  private readonly driver;
+  private specs;
+  private readonly cells;
+  private readonly targets;
+  constructor(node: UiNode, graph: UiGraph, driver: AnimationDriver);
+  /** Replaces what the element declares; a property dropped from the list stops animating. */
+  setSpecs(specs: ReadonlyMap<NodeProperty, UiTransitionSpec>): void;
+  get size(): number;
+  /**
+   * Takes over a write, or declines it.
    *
-   * A scope whose subtree has gone is a trap that ended, so it is
-   * popped as though the component had released it and focus returns
-   * to the opener — a dialog that unmounts hands the keyboard back
-   * without having to sequence its own teardown. Focus lost with the
-   * subtree is dropped without a Blur, since the node's listeners were
-   * released with it.
+   * Declines when the property has no transition, when the node has no
+   * value yet — a node's *first* value is not a change and animating
+   * from nothing would mean animating from a default nobody asked for
+   * — and when the two values cannot be blended (`interpolatorFor`
+   * says which, and why).
    */
-  handleNodeRemoved(_node: UiNode): void;
-  private moveFocus;
+  write(property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
+  /** Cancels everything, for a node leaving the tree or dropping the prop. */
+  release(): void;
+  private stopProperty;
   /**
-   * The tab stops in document order (parent before children).
+   * The cell one property animates through, kept for the life of the
+   * node: the driver keys its running set by cell identity, so a fresh
+   * adapter per write would leave the previous animation running.
    *
-   * Tab stops and not every focusable node: a container with
-   * `tabStop: false` can hold focus and is not a place the cycle
-   * stops, which is what lets a dialog body be the keyboard's home of
-   * last resort without becoming a stop of its own.
+   * Writing goes through `updateNodePropertyNow`, which is the path a
+   * plain write takes minus this class — so a modifier's override still
+   * sits on top of an animated value, exactly as it sits on top of a
+   * bound one.
    */
-  private collectFocusable;
-  /** Whether the node may hold focus given the active scope, if any. */
-  private withinScope;
-  /** Whether the node is still connected to the traversal root. */
-  private isAttached;
-  private isWithin;
+  private cellFor;
+  private startAnimation;
 }
+/** Test hook: forgets which properties have been reported. */
+declare function resetTransitionWarnings(): void;
 //#endregion
 //#region src/input/FocusNotifier.d.ts
 /**
@@ -9519,6 +10002,8 @@ declare class UiWheelController {
    * still constructs; without it such a root is read as the default.
    */
   private readonly rootNode;
+  /** The clock the precise-device memory below reads. Injectable for specs. */
+  private readonly now;
   constructor(hitTester: HitTester, dispatcher: UiInputDispatcher, scrollSink: ScrollSink,
   /**
    * The tree's root, when the host knows it.
@@ -9528,7 +10013,27 @@ declare class UiWheelController {
    * container to walk up from. Optional so every existing caller
    * still constructs; without it such a root is read as the default.
    */
-  rootNode?: (() => UiNode | null) | null);
+  rootNode?: (() => UiNode | null) | null,
+  /** The clock the precise-device memory below reads. Injectable for specs. */
+  now?: () => number, options?: UiWheelControllerOptions);
+  /** Whether a precision device's steps are paced over frames; see `advance`. */
+  private readonly paced;
+  /** A precision device's gesture, by the container it scrolls. */
+  private readonly pacing;
+  /** When the event being routed happened, for the gesture it joins. */
+  private eventTime;
+  /** The last frame's time, and the display's interval measured from it. */
+  private lastFrame;
+  private frameInterval;
+  /**
+   * Until when the wheel is taken to be a precision device whatever an
+   * event says. One event can't always tell: Chrome on a Mac reports a
+   * trackpad's legacy delta as three times its pixel delta, so a step of
+   * 40 pixels reads as a whole detent. A mouse wheel never sends an event
+   * that doesn't look notched, so one that doesn't means a trackpad, and
+   * every event close behind it (a gesture, and its momentum) is one too.
+   */
+  private preciseUntil;
   /**
    * The node the last wheel landed on, or null before any.
    *
@@ -9540,7 +10045,12 @@ declare class UiWheelController {
    * wheel of a burst land correctly even though the first could not.
    */
   lastWheelTarget: UiNode | null;
-  wheel(x: number, y: number, deltaX: number, deltaY: number, modifiers?: UiKeyModifiers, deltaMode?: UiWheelDeltaMode, wheelDeltaY?: number): UiWheelEvent;
+  wheel(x: number, y: number, deltaX: number, deltaY: number, modifiers?: UiKeyModifiers, deltaMode?: UiWheelDeltaMode, wheelDeltaY?: number,
+  /**
+   * When the event happened, on this controller's clock. Pacing
+   * predicts from it; without it, the time it arrives stands in.
+   */
+  at?: number): UiWheelEvent;
   /**
    * Whether a wheel at this point would move anything, without moving
    * it.
@@ -9603,6 +10113,39 @@ declare class UiWheelController {
    */
   private appContainsOverscroll;
   private applyDelta;
+  /**
+   * A container's state as a step should judge it: during a paced gesture,
+   * where the steps so far have really taken it, not where the prediction
+   * has drawn it. Judged by what's drawn, a flick into the top found no
+   * room once the prediction got there first, its last steps were refused,
+   * and withdrawing the prediction then moved the list back down off the
+   * top.
+   */
+  private gestureState;
+  /**
+   * Moves each precision-device gesture for one frame. A host that turned
+   * pacing on calls this once a frame, with the frame's time, before the
+   * frame reads scroll offsets.
+   *
+   * A trackpad sends on its own clock, not the display's, so a frame
+   * comes a varying time after the last step: applied as they arrive, a
+   * steady flick moves the page by uneven amounts, which reads as
+   * judder. Evening that out by waiting for steps puts the page behind
+   * the hand. So this does what a browser does for its own scrolling:
+   * it puts the page where the input will have reached when the frame is
+   * shown, the steps so far plus their velocity times the time since the
+   * last one, never more than a frame and a half ahead. Steps come out
+   * even, and nothing trails.
+   *
+   * A gesture's first step, with no velocity yet, goes as it is. Once the
+   * steps stop, the prediction is withdrawn and the page settles exactly
+   * where they add up to; a trackpad's momentum slows to nothing first,
+   * so there is next to nothing to withdraw.
+   *
+   * True while a gesture is still being paced, so the host keeps frames
+   * coming until it has settled.
+   */
+  advance(time?: number): boolean;
   /**
    * A wheel delta in whatever unit it arrived in, as pixels.
    *
@@ -9616,6 +10159,13 @@ declare class UiWheelController {
 }
 /** A ScrollView, or any node with overflow 'scroll' or 'auto'. */
 declare function isScrollContainer(node: UiNode): boolean;
+interface UiWheelControllerOptions {
+  /**
+   * Pace a precision device's steps to the frame instead of applying each
+   * as it arrives; the host then calls `advance` once a frame.
+   */
+  readonly pace?: boolean;
+}
 //#endregion
 //#region src/input/UiPointerController.d.ts
 interface PointerControllerOptions {
@@ -9671,7 +10221,12 @@ interface PointerControllerOptions {
    */
   editing?: {
     isEditable(node: UiNode): boolean;
-    pointerDown(node: UiNode, x: number, y: number, modifiers: UiKeyModifiers): void;
+    /** The field of an editing group a press on none of its fields belongs to; see `UiEditingController.fieldNear`. */
+    fieldNear?(target: UiNode, y: number, handlesPress: (node: UiNode) => boolean): UiNode | null;
+    /** The text offset under a point in a field, as the field is drawn now; see `UiEditingController.offsetAt`. */
+    offsetAt?(node: UiNode, x: number, y: number): number;
+    /** `offset`, when given, is where the press landed, found before it moved focus. */
+    pointerDown(node: UiNode, x: number, y: number, modifiers: UiKeyModifiers, offset?: number): void;
     pointerMove(node: UiNode, x: number, y: number): void;
     pointerUp(): void;
   };
@@ -9748,6 +10303,8 @@ interface PointerControllerOptions {
 declare class UiPointerController {
   private readonly hitTester;
   private readonly dispatcher;
+  /** Whether a node answers a press itself: a click or pointer listener of its own. */
+  private handlesPress;
   private readonly slop;
   private readonly touchSlop;
   private readonly gestures;
@@ -10056,6 +10613,12 @@ interface ShortcutRegistryOptions {
  * Without that rule an application with a `n` for "new note" becomes an
  * application you cannot type the letter n into, which is the failure
  * every home-grown key handler eventually ships.
+ *
+ * ## Pressing is not a shortcut
+ *
+ * A bare Enter or Space is skipped while a button or link has focus,
+ * unless the shortcut is that control's own: the control is focused, so
+ * it has the key first, as it would in a browser.
  */
 declare class UiShortcutRegistry {
   private readonly bindings;
@@ -10092,16 +10655,21 @@ declare class UiShortcutRegistry {
    * act on a key that has already been spent.
    */
   handleKey(key: string, modifiers: UiKeyModifiers, focused: UiNode | null): boolean;
+  private platform;
+  /** Whether a field would take this key as an edit of its own, rather than as text or as Enter. */
+  private isEditingKey;
   /** Forgets a half-typed chord, for a route change or a lost focus. */
   reset(): void;
   /**
    * Whether a binding would fire for a key going to `focused`.
    *
-   * Three things take a shortcut out: its scope does not contain the
-   * focused node, its own `when` says no, and, for a shortcut with no
-   * modifier at all, the focused node is somewhere text is being
-   * typed. The last is the rule that keeps a single-letter shortcut
-   * from making a text field unusable.
+   * Four things take a shortcut out: its scope does not contain the
+   * focused node, its own `when` says no, for a shortcut with no
+   * modifier at all the focused node is somewhere text is being typed,
+   * and for a bare Enter or Space the focused node is a button that
+   * isn't the shortcut's own. The third keeps a single-letter shortcut
+   * from making a text field unusable; the fourth keeps a list's Enter
+   * from opening a row when the button focused inside it was pressed.
    */
   private isLive;
 }
@@ -10114,14 +10682,13 @@ declare class UiShortcutRegistry {
  */
 declare function parseShortcut(keys: string): readonly UiShortcutStep[];
 /**
- * The shortcut as a palette should print it.
- *
- * `Mod` is printed as `Ctrl`, not as a platform glyph: the render
- * worker cannot see the platform, and a wrong symbol is worse than a
- * plain word. An application that knows what it is running on can
- * format the `steps` itself.
+ * The shortcut as a palette should print it, the way the platform
+ * writes its own: `⇧⌘K` on a Mac, where `Mod` is Command, and
+ * `Ctrl+Shift+K` elsewhere, where it is Control. The platform is the
+ * one the editing keys follow (`detectEditingPlatform`, from the user
+ * agent, which a worker can read too).
  */
-declare function formatShortcut(steps: readonly UiShortcutStep[]): string;
+declare function formatShortcut(steps: readonly UiShortcutStep[], platform?: EditingPlatform): string;
 //#endregion
 //#region src/input/UiDragSession.d.ts
 /**
@@ -10177,6 +10744,17 @@ interface UiDropZone {
   leave(): void;
   /** The drag was released over the zone. What it did, for the source. */
   drop(state: UiDragState): UiDropEffect;
+  /**
+   * The point is inside this zone and the zone would take the payload,
+   * whether or not a deeper zone won the drop; null once it no longer
+   * is, or the drag ended.
+   *
+   * `over` goes to the winner alone, which is right for "where would
+   * this land" and wrong for auto-scroll: a list whose rows are drop
+   * zones of their own is never the winner, so a drag held at its edge
+   * never scrolled it. Auto-scroll listens here instead.
+   */
+  hover?(state: UiDragState | null): void;
 }
 /** The result a completed drag reports back to whatever started it. */
 interface UiDragResult {
@@ -10264,6 +10842,8 @@ declare class UiDragSession {
   private readonly zones;
   private current;
   private inside;
+  /** Every zone the point is in that would take the payload, winner or not. */
+  private hovering;
   /** Registers a drop target. The returned function unregisters it. */
   addZone(zone: UiDropZone): () => void;
   /** The drag in flight, or null when nothing is being carried. */
@@ -10288,6 +10868,8 @@ declare class UiDragSession {
   end(): UiDragResult | null;
   /** Abandons the drag: the zone under it is told, and nothing is dropped. */
   cancel(): void;
+  /** Tells every zone the drag was hovering over that it no longer is. */
+  private unhover;
   /**
    * Turns a shell's file-drop message into an ordinary drag.
    *
@@ -10473,6 +11055,12 @@ interface EditingState {
   readonly caret: LayoutBox;
   readonly multiline: boolean;
   readonly composing: boolean;
+  /**
+   * The selection as HTML, which a copy puts on the clipboard beside
+   * the text, when the field's editing group gives some (see
+   * `UiEditingGroup.copyHtml`). Absent otherwise.
+   */
+  readonly html?: string;
 }
 interface EditingControllerOptions {
   /** Keyboard conventions; detected from the user agent by default. */
@@ -10511,6 +11099,35 @@ declare class UiEditingController {
   private dragging;
   private lastPress;
   private compositionOpen;
+  /**
+   * The text as it was when the composition began. A commit is reported
+   * against this, not against the text with the composition in it,
+   * which already holds what is committed whenever the person picks
+   * the candidate on screen: compared with that, a commit changed
+   * nothing and the application never heard about the text.
+   */
+  private compositionBase;
+  /**
+   * A selection across the fields of an editing group, while it spans
+   * more than one; null while the selection is one field's own. `lit`
+   * is every field drawing part of it. See `UiEditingGroup`.
+   */
+  private span;
+  /**
+   * What the group last made of a selection for the clipboard, kept
+   * while the selection and the texts it covers stay the same: the
+   * state is asked for every frame, and serializing a long selection
+   * every frame would cost more than the frame.
+   */
+  private copied;
+  /** Set while the span moves focus to the field its focus end is in, so that move does not end it. */
+  private spanFocusing;
+  /**
+   * The field focus left for the one just pressed. A press focuses its
+   * field before this controller hears of it, so a Shift and press in a
+   * new field needs to know where the selection was anchored.
+   */
+  private pressedFrom;
   constructor(host: EditingHost, dispatcher: UiInputDispatcher, focus: UiFocusManager, options?: EditingControllerOptions);
   /** The editable that holds focus, or null. */
   get focused(): UiNode | null;
@@ -10525,6 +11142,11 @@ declare class UiEditingController {
   handleKey(node: UiNode, key: string, modifiers: UiKeyModifiers, textFromKeys?: boolean): boolean;
   private execute;
   private move;
+  /** Whether a move would go past the edge of a field, rather than somewhere in it. */
+  private leavesField;
+  /** Where a selection extended into a field from the one before or after it lands. */
+  private entryOffset;
+  private moveInField;
   /**
    * A `beforeinput` from the shell's editing proxy, in the DOM's
    * vocabulary. Returns true when it was applied to the focused
@@ -10556,7 +11178,7 @@ declare class UiEditingController {
    * text means something to it that it means to nothing else, and
    * before this there was no way for it to hear about one at all.
    */
-  paste(text: string): boolean;
+  paste(text: string, html?: string | null): boolean;
   private offerPaste;
   private insert;
   compositionStart(): void;
@@ -10570,7 +11192,29 @@ declare class UiEditingController {
    * selects the word, a third the line. Dragging afterwards extends the
    * selection from the anchor.
    */
-  pointerDown(node: UiNode, x: number, y: number, modifiers: UiKeyModifiers): void;
+  /**
+   * The field a press belongs to that landed inside an editing group
+   * but on none of its fields: in the padding round the fields, the gap
+   * between two of them, or the plain structure a field sits in (a list
+   * item's bullet). The nearest field, by height, as a document puts the
+   * caret on the nearest line. Null for a press outside any group, and
+   * for one on something that answers presses itself, such as a task's
+   * checkbox: `handlesPress` says which nodes do.
+   */
+  fieldNear(target: UiNode, y: number, handlesPress: (node: UiNode) => boolean): UiNode | null;
+  /**
+   * The offset under a point in a field, by its layout as it stands. The
+   * pointer controller asks this before a press moves focus, and hands
+   * the answer to `pointerDown`; see there.
+   */
+  offsetAt(node: UiNode, x: number, y: number): number;
+  /**
+   * `pressedAt` is the offset the press landed on, found before focus
+   * moved. A field may change how it is drawn when it takes focus (its
+   * runs show text they hid), and from then on its geometry is not the
+   * one the person pressed on. Without it, the offset is found here.
+   */
+  pointerDown(node: UiNode, x: number, y: number, modifiers: UiKeyModifiers, pressedAt?: number): void;
   pointerMove(node: UiNode, x: number, y: number): void;
   pointerUp(): void;
   /** The focused editable's state for the shell to mirror, or null. */
@@ -10609,6 +11253,49 @@ declare class UiEditingController {
    */
   private notifySelection;
   private afterSelectionChange;
+  /**
+   * Selects from `anchor` to `focus`, in one field or across the fields
+   * of an editing group, and focuses the field the focus end is in: what
+   * an application does after a command over a selection, to leave it
+   * selected. False when the two ends are not editables of one group.
+   */
+  select(anchor: UiTextPosition, focus: UiTextPosition): boolean;
+  /** Whether a selection is spanning the fields of a group. */
+  get spanning(): boolean;
+  /**
+   * Selects from `anchor` to `focus` across a group's fields: lights
+   * every field between them with its part, gives the focus field its
+   * own part in its model (anchored on the side the selection comes
+   * from, so its keys and its IME stay sensible), and moves focus there.
+   * Two ends in one field are that field's selection, as ever.
+   */
+  private setSpan;
+  /** Ends a selection across fields, if there is one, unlighting them. */
+  private clearSpan;
+  /** Collapses a selection across fields to its start (-1) or its end (1). */
+  private collapseSpan;
+  /**
+   * Hands an edit over a selection across fields to the group, and ends
+   * the selection. No field is changed: the application changes its
+   * document, which changes the fields, and places the caret.
+   */
+  private spanEdit;
+  /** The text and HTML a selection across fields copies as. */
+  private spanCopy;
+  /** The HTML a selection inside one field of a group copies as, if the group gives any. */
+  private fieldHtml;
+  private cachedCopy;
+  /** Where a Shift and press extends from: the focused field's anchor, if it is in the same group. */
+  private anchorIn;
+  /**
+   * The field of a group a drag at height `y` is over: stepping up or
+   * down from `from` until one reaches it, so a drag costs the fields it
+   * crosses. A point in the gap between two fields belongs to the next
+   * one in the direction of travel.
+   */
+  private fieldAt;
+  /** Focuses a field for the span without ending it. */
+  private focusField;
   /**
    * Asks the host to scroll the caret into view, when the node has been
    * laid out: the field's own text first, then any scroll container
@@ -11281,6 +11968,16 @@ declare class UiFrame {
    * node looked at.
    */
   anyFlags(flags: DirtyFlags): boolean;
+  /**
+   * This frame and `later` as one: every node in either, with the
+   * flags it carried in both.
+   *
+   * What the phases after layout read when layout ran more than once
+   * in a frame (see `UiScheduler.recollect`): a node dirtied by a
+   * layout listener has to be re-meant and redrawn like any other
+   * node the frame changed.
+   */
+  merged(later: UiFrame): UiFrame;
   get size(): number;
   isEmpty(): boolean;
   dirtyFlagsFor(node: UiNode): DirtyFlags;
@@ -11453,30 +12150,6 @@ interface ScrollAdjustment {
   scrollX: number;
   scrollY: number;
 }
-/**
- * Calculates geometry for a retained UiNode tree.
- *
- * Layout owns a separate projection of the graph (LayoutRecords
- * keyed by UiNode identity) so the graph stays structural and
- * the renderer/hit-testing read geometry from one place. The
- * engine knows nothing about Canvas, WebGPU, or the DOM: it
- * produces numbers only.
- *
- *   measure: bottom-up, dirty subtrees only, early-stop via
- *            idempotent measured-size comparison
- *   place:   top-down, dirty paths only, re-places a child's
- *            descendants only when its box actually changed
- *
- * Flex is two-pass, as in CSS: items are first measured at their
- * max-content size to obtain a flex base, the main axis is resolved,
- * and any item whose main size changed is measured again at that size
- * so a cross size that depends on it — wrapped text above all — comes
- * out right. The second pass only touches items that actually flexed.
- *
- * Scroll offset is a coordinate-space translation stored on the
- * container record; descendants keep content coordinates, so
- * scrolling never re-measures or re-places them.
- */
 declare class LayoutEngine {
   private records;
   /**
@@ -11511,6 +12184,14 @@ declare class LayoutEngine {
    * no children to translate, so they are kept apart from `scrollNodes`.
    */
   private readonly textScrollNodes;
+  /**
+   * The editables whose text scroll needs clamping at the end of this
+   * pass: the ones measured in it, whose extent may have changed, and
+   * the ones whose offset was written. A field nothing touched keeps
+   * the offset it had; clamping every editable every frame cost a
+   * keystroke five thousand clamps in a 5,000-line document.
+   */
+  private readonly textScrollPending;
   /** Absolutely positioned nodes placed against an anchor node. */
   private readonly anchoredNodes;
   /** The anchor each of those nodes was last placed against. */
@@ -11745,6 +12426,8 @@ declare class LayoutEngine {
   revealScrollbars(node: UiNode): void;
   /** Every scroll container that has been laid out. */
   scrollContainers(): Iterable<UiNode>;
+  /** Everything that can show a scrollbar: scroll containers, then fields. */
+  private scrollbarNodes;
   /**
    * When the next scrollbar changes appearance (starts fading or
    * disappears), or undefined when none is showing. Lets a host schedule
@@ -11965,6 +12648,15 @@ declare class LayoutEngine {
    */
   private minContentHeightContribution;
   private measureStack;
+  /** What a stack asks a child while measuring: tight on a stretched axis, up to its content box otherwise. */
+  private stackQuestion;
+  /**
+   * Whether a scroller's content is read from outside it. Scrolled
+   * content pushes on nothing past a scroller whose size is its own,
+   * but one without is its content's size under a loose bound, so
+   * whatever reads its size reads the content's.
+   */
+  private scrollContentMatters;
   private measureScroll;
   /**
    * A leaf is its content plus padding. Text content comes from the
@@ -12126,18 +12818,18 @@ declare class LayoutEngine {
    */
   private markLayoutDirty;
   private applyScroll;
+  /**
+   * A `scrollWith` container's offset: the leader's, on the axes it
+   * follows, clamped to the follower's own range. No scrollbar shows
+   * for it, since what is being scrolled is the leader.
+   */
+  private applyFollowedScroll;
   /**
    * Brings a record's scroll offset up to date with its `scrollX` and
-   * `scrollY` properties, clamped to what there is to scroll. This runs
-   * every pass, so an offset written against a larger content — a field
-   * whose text has since been deleted, a list that lost rows — comes
-   * back into range on its own.
-   *
-   * A field that scrolls may go one caret width further than its text,
-   * so that a caret at the very end is inside the box and not on its
-   * edge, where the clip would take it. A field wide enough for its
-   * text does not: the allowance would shift the line by a pixel the
-   * moment the caret reached the end.
+   * `scrollY` properties, clamped to what there is to scroll (see
+   * `scrollRange`). This runs every pass, so an offset written against
+   * a larger content — a field whose text has since been deleted, a
+   * list that lost rows — comes back into range on its own.
    */
   private applyScrollOffset;
   /**
@@ -12279,6 +12971,46 @@ declare class LayoutEngine {
    * size properties itself, in measure().
    */
   private assignBox;
+  /**
+   * A frame repainted the node, perhaps with new shadows. A shadow lays
+   * nothing out, so no pass would otherwise notice that the node now
+   * paints further out, or less far, than its extent says.
+   */
+  private refreshPaintReach;
+  /**
+   * Moves a laid-out subtree by (dx, dy) without placing it again.
+   *
+   * Boxes are absolute, so a block inserted at the top of a long
+   * document moved every box below it, and each one that moved was
+   * placed again: its children re-measured (memo hits) and re-assigned,
+   * all the way down. An Enter in a 5,000-line document placed 9,572
+   * nodes and cost 18 ms of layout. A subtree that moved without
+   * changing size, with nothing inside it waiting to be laid out, is
+   * placed relative to itself already, so every box in it moves by the
+   * same amount, which is one addition per node.
+   *
+   * Two kinds of node don't move with it. An absolutely positioned
+   * descendant whose containing block is outside the subtree is placed
+   * against that block, which didn't move. An anchored one is placed
+   * against its anchor, and is placed again (`movedAnchored`) when its
+   * anchor is one of the boxes that moved.
+   */
+  /**
+   * A node's paint extent, once its children are placed: its box and its
+   * own shadows, grown by each child's (a clipping child's box, since nothing paints past
+   * it; anything else's extent). Then carried up, since an ancestor that
+   * wasn't placed this pass still needs to hear.
+   */
+  private updateExtent;
+  /**
+   * Grows each ancestor's extent to cover a node's, up to the first
+   * that clips or already covers it, which is at once in the usual case.
+   * An incremental pass doesn't place the ancestors of the subtree it
+   * laid out, so this is how they hear that something under them moved
+   * past them.
+   */
+  private growExtentUp;
+  private shiftSubtree;
   private scrollDirection;
   /**
    * Iterates over a node's in-flow children, transparently expanding
@@ -12950,8 +13682,17 @@ declare function borders(options: BordersOptions): UiModifier<Decorations>;
 declare function borderShapes(options: BordersOptions): readonly DecorationShape[];
 //#endregion
 //#region src/modifiers/focus.d.ts
-/** Takes focus the first time the node is laid out. */
-declare function autoFocus(): UiModifier<void>;
+/**
+ * Takes focus the first time the node is laid out.
+ *
+ * The node is scrolled into view, as focus from code always is, once
+ * the frame's layout has settled. Pass `{ preventScroll: true }` to
+ * leave the page where it is, as `element.focus({ preventScroll: true })`
+ * does: for a region focused when a page opens so a screen reader reads
+ * it, where revealing it would scroll a tall region to a few pixels
+ * short of its own top instead of leaving the page at its start.
+ */
+declare function autoFocus(options?: FocusOptions): UiModifier<FocusOptions>;
 //#endregion
 //#region src/modifiers/clickOutside.d.ts
 interface ClickOutsideOptions {
@@ -14255,6 +14996,9 @@ interface SizeContainerArgs {
  * padding, and a layout that switched arms at 600 px would otherwise
  * switch at 600 px of border box and lay itself out in 560.
  *
+ * What a subtree builds from the size it reports is laid out on the
+ * same frame, before anything paints; see `UiModifierHost.onLayout`.
+ *
  * `Responsive` attaches this for you. Attach it by hand when the
  * source has to be reachable somewhere the helper's own children are
  * not, and put the same object on the node's `containerSize` prop.
@@ -14291,9 +15035,15 @@ interface BreakpointArgs {
  * about it and the thing a media query cannot do: a card in a sidebar
  * asks how wide the card is, not how wide the window is.
  *
- * Nothing is written until the node has been laid out once, so the
- * first frame uses the element's own values. Give the element the
- * narrowest band's values as its declared props if that matters.
+ * Nothing is written until the node has been laid out once, but the
+ * first frame is already right: the runtime lays out again before it
+ * paints when a layout listener changes layout (see
+ * `UiModifierHost.onLayout`), so the frame a node first appears on,
+ * and the frame a resize crosses a width on, are drawn with the band's
+ * values. The element's own values are what that first pass measures
+ * with; give it the narrowest band's values as its declared props so a
+ * layout nothing settles (a headless one, a spec driving layout by
+ * hand) starts from the right band.
  */
 declare const breakpoint: ((args: BreakpointArgs, key?: string | number) => UiModifier<BreakpointArgs>) & {
   readonly kind: UiModifierKind<BreakpointArgs>;
@@ -14777,7 +15527,9 @@ interface Canvas2DRendererOptions {
  *
  * Painting per node (in order):
  *
+ *   0. outer shadows     (boxShadows, last declared first, as CSS stacks them)
  *   1. background fill   (backgroundColor, rounded rect when radius > 0)
+ *   1b. inset shadows    (boxShadows marked `inset`, over the background)
  *   2. background image  (image + objectFit)
  *   2b. picture          (what a Paint node's `paint`/`path` drew)
  *   3. border            (borderWidth/borderColor)
@@ -14809,6 +15561,8 @@ declare class Canvas2DRenderer implements UiRenderer {
   /** Scratch for the padded box text is drawn in; reused across nodes. */
   private readonly contentBox;
   private readonly paint;
+  /** The frame's context, wrapped so a huge scroll offset keeps its precision; reset each frame. */
+  private precise;
   /**
    * Whose style the shared paint scratch currently holds.
    *
@@ -14902,6 +15656,25 @@ declare class Canvas2DRenderer implements UiRenderer {
   /** Everything between the boundary (or the root) and a lifted node. */
   private applyAncestors;
   private paintBackground;
+  /**
+   * The node's outer shadows, or its inset ones, with CSS `box-shadow`
+   * semantics: see `UiBoxShadow`.
+   *
+   * Drawn with the canvas's own shadow, which blurs whatever a fill
+   * covers. The fill itself must not show, so the shape is drawn well
+   * away from the box, outside the clip, and its shadow is cast back by
+   * exactly that distance. The clip is what CSS clips a shadow to: for
+   * an outer shadow the ring around the box, so a translucent background
+   * does not show the shadow through it; for an inset one the box. An
+   * inset shadow is the shadow of a frame around a hole, the hole being
+   * the box moved by the offset and shrunk by the spread.
+   *
+   * A canvas shadow's offset and blur are in device pixels and ignore
+   * the transform, so both are carried through it here: the throw by
+   * the transform's linear part, the blur by its scale. The list is
+   * walked backwards because CSS paints the first shadow on top.
+   */
+  private paintShadows;
   /** The node's box, following its corner radius. */
   private fillBox;
   /**
@@ -16312,13 +17085,24 @@ declare class GlyphShaper {
  *   2  size.xy
  *   4  color.rgba
  *   8  radius, opacity, borderWidth
- *   11 kind               (u32: PrimitiveKind)
+ *   11 kind               (PrimitiveKind, as a float)
  *   12 transform          3x2 affine, absolute layout → logical screen
  *   18 clipIndex          index into the clip chain, -1 for none
  *   19 gradientIndex      index into the frame's gradients, -1 for none
- *   20 (end)
- */
-declare const INSTANCE_STRIDE_FLOATS = 20;
+ *   20 shadow             offsetX, offsetY, spread, the other shape's radius
+ *   24 (end)
+ *
+ * A shadow is two rounded rectangles, the blurred one and the box it
+ * is cut by, and an instance describes the first. For an outer shadow
+ * the rectangle is the blurred shape grown by the blur's reach
+ * (`BOX_SHADOW_BLUR_REACH` × blur), `radius` its corners, `borderWidth`
+ * the blur, and the box it must not show under is recovered from the
+ * offset and spread, with the box's own radius last. An inset shadow's
+ * rectangle is the box, and the hole it is cast from is the box moved
+ * by the offset and shrunk by the spread, with the hole's radius last.
+ * Every other instance writes zeros there.
+ */
+declare const INSTANCE_STRIDE_FLOATS = 24;
 declare const INSTANCE_STRIDE_BYTES: number;
 /**
  * Textured instance layout (glyphs and images), in floats:
@@ -16354,7 +17138,11 @@ declare const CLIP_STRIDE_BYTES: number;
 declare const NO_CLIP_INDEX = -1;
 declare const enum PrimitiveKind {
   Fill = 0,
-  Border = 1
+  Border = 1,
+  /** A `boxShadows` entry outside the box; see the instance layout. */
+  Shadow = 2,
+  /** A `boxShadows` entry marked `inset`. */
+  InsetShadow = 3
 }
 declare const enum CommandKind {
   /** A contiguous range of primitive instances under one scissor. */
@@ -17217,6 +18005,23 @@ declare class UiScheduler {
    * cleared surface for a frame.
    */
   flush(time: UiFrameTime): void;
+  /**
+   * Takes what was dirtied since `frame` was collected into that same
+   * frame, rather than leaving it for the next one.
+   *
+   * For a phase that has to finish inside the frame what the frame
+   * started. A layout listener (a `breakpoint`, a `sizeContainer`)
+   * that writes padding after the boxes are final has made those boxes
+   * stale, and painting them would show the stale layout for one frame
+   * before the next corrects it. The runtime lays the writes out again
+   * from what this returns, before anything paints.
+   *
+   * The result holds only the newly dirtied nodes, with `frame`'s id
+   * and time: it is more of the same frame, not a new one, so the
+   * frame count does not move. Anything armed by those writes finds
+   * nothing left to do.
+   */
+  recollect(frame: UiFrame): UiFrame;
   /**
    * Runs one frame, and names its three parts for the browser's
    * profiler when anything is recording (`PerformanceMarks`).
@@ -17261,6 +18066,8 @@ interface ParagraphGeometry {
   readonly end: number;
   readonly measure: RunMeasure;
   readonly rtl: boolean;
+  /** Stretches of the text its runs hide; a double click selects words as drawn. */
+  readonly hidden: readonly UiTextRange[];
 }
 /**
  * Lays a node's text out in its content box, exactly as the renderers
@@ -17351,6 +18158,8 @@ interface UiSemanticsRecord {
   readonly setSize?: number;
   /** How deep a treeitem sits, 1 for a root. */
   readonly level?: number;
+  /** The record id of the descendant that's active while this one keeps focus. */
+  readonly activeDescendant?: string;
 }
 /** Insertion-ordered: iterating the map walks the tree in document order. */
 type UiSemanticsMap = ReadonlyMap<string, UiSemanticsRecord>;
@@ -17373,7 +18182,29 @@ type UiSemanticsMap = ReadonlyMap<string, UiSemanticsRecord>;
  *      is, carrying `disabled` — unavailable is a thing to announce,
  *      hidden is not.
  */
-declare function buildSemanticsTree(root: UiNode): Map<string, UiSemanticsRecord>;
+declare function buildSemanticsTree(root: UiNode, memory?: SemanticsMemory): Map<string, UiSemanticsRecord>;
+/**
+ * What a walk leaves behind for the next one, so a structural change can
+ * be described without walking everything again.
+ *
+ * `described` is every node a walk has given a record, so a record is
+ * only ever taken back by the node that earned it: an id can come back
+ * on a new node once its old one has gone. `spans` is, for every node
+ * without a record of its own, which records it contributed to the
+ * record above it: the first, by id, and how many. An untouched
+ * transparent subtree (a block of a long document, say) is then
+ * renumbered as a run of its parent's children instead of walked.
+ */
+interface SemanticsMemory {
+  readonly described: WeakSet<UiNode>;
+  readonly spans: WeakMap<UiNode, SemanticsSpan>;
+}
+interface SemanticsSpan {
+  readonly parent: string | null;
+  readonly first: string | null;
+  readonly count: number;
+}
+declare function semanticsMemory(): SemanticsMemory;
 /**
  * The records one subtree contributes, as if walked in place.
  *
@@ -17394,7 +18225,57 @@ declare function buildSemanticsTree(root: UiNode): Map<string, UiSemanticsRecord
  * `inert` is whether an ancestor above this subtree is disabled, which
  * only the caller can know.
  */
-declare function buildSemanticsSubtree(node: UiNode, parent: string | null, index: number, inert: boolean): Map<string, UiSemanticsRecord> | null;
+declare function buildSemanticsSubtree(node: UiNode, parent: string | null, index: number, inert: boolean, memory?: SemanticsMemory): Map<string, UiSemanticsRecord> | null;
+/**
+ * What a walk after a structural change may take from the tree it is
+ * replacing.
+ *
+ * `previous` is the last tree's records by id; their indices may be out
+ * of date, so a record's place is read from `childrenOf`, its parent's
+ * children in order, and `positionOf`. `unchanged(node)` says that a
+ * node and everything under it mean what they meant then: nothing in it
+ * was described differently, and it took no children and lost none.
+ */
+interface SemanticsReuse {
+  readonly previous: ReadonlyMap<string, UiSemanticsRecord>;
+  readonly childrenOf: (parent: string | null) => readonly string[];
+  readonly positionOf: (parent: string | null, id: string) => number;
+  readonly memory: SemanticsMemory;
+  readonly unchanged: (node: UiNode) => boolean;
+}
+/** What a walk after a structural change found. */
+interface SemanticsRewalk {
+  /** The records described afresh, with their indices. */
+  readonly records: Map<string, UiSemanticsRecord>;
+  /** For each record the walk went inside, its children's ids in order. */
+  readonly children: Map<string | null, string[]>;
+  /** Records taken back as they were, subtrees and all, without being described. */
+  readonly kept: Set<string>;
+  /** Every record the walk put somewhere, in document order, with where. */
+  readonly placed: readonly SemanticsPlacement[];
+}
+interface SemanticsPlacement {
+  readonly id: string;
+  readonly parent: string | null;
+  readonly index: number;
+}
+/**
+ * Walks a subtree again after the shape of the tree changed inside it,
+ * describing only what changed.
+ *
+ * A full walk asks every node what it means, and moves every record
+ * whose siblings moved. After a block is inserted in a long document
+ * nearly every node means what it did. So a record `reuse.unchanged`
+ * vouches for is taken back as it was, and an untouched transparent
+ * subtree (one with no record of its own, like a block of the document)
+ * is taken back as the run of its parent's children it contributed last
+ * time, without being walked into. Nothing taken back is renumbered:
+ * the caller learns where everything went from `children` and `placed`.
+ *
+ * `node` has to carry a record, as for `buildSemanticsSubtree`; null
+ * otherwise.
+ */
+declare function rewalkSemantics(node: UiNode, parent: string | null, index: number, inert: boolean, reuse: SemanticsReuse): SemanticsRewalk | null;
 /**
  * Whether an ancestor of `node` is disabled, which every record in its
  * subtree inherits.
@@ -17426,6 +18307,11 @@ declare function textRunOfRecordId(id: string): {
  * from them, and a whole record cannot be applied out of order into
  * something half-updated. `remove` carries only the id, since a
  * removed subtree's records are each removed in their own patch.
+ *
+ * A record whose index moved only because a sibling came or went is
+ * not sent (see `dropIndexShifts`). A consumer that applies removals,
+ * then adds and updates in order, placing each at its index, keeps its
+ * children in order without them.
  */
 type UiSemanticsPatch = {
   readonly op: 'add';
@@ -17446,6 +18332,24 @@ type UiSemanticsPatch = {
  * a mirror can append as it reads.
  */
 declare function diffSemantics(previous: UiSemanticsMap, next: UiSemanticsMap): UiSemanticsPatch[];
+/**
+ * Drops the updates that only renumber a record whose siblings kept
+ * their order.
+ *
+ * A record carries its index among its siblings, so inserting one near
+ * the top of a list changes the index of every record after it, and
+ * each of those used to go out as an update: 4,266 patches for one
+ * paragraph inserted in a 5,000-line document, every one of them
+ * crossing to the main thread and rewriting a mirror element. They say
+ * nothing a mirror needs. It applies removals, then adds in document
+ * order at their indices, so the elements that stayed are already in
+ * the right order around the ones that came and went. Only when the
+ * siblings that stayed changed their order among themselves (a move)
+ * do the new indices matter, and then every update is kept.
+ *
+ * The records keep their new indices; this only thins the patches.
+ */
+declare function dropIndexShifts(previous: UiSemanticsMap, next: UiSemanticsMap, patches: readonly UiSemanticsPatch[]): UiSemanticsPatch[];
 /** Structural equality over the record's flat, pruned members. */
 declare function recordsEqual(a: UiSemanticsRecord, b: UiSemanticsRecord): boolean;
 //#endregion
@@ -17505,5 +18409,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp3Header as $, UiPointerController as $a, Text as $c, UiImage as $d, UiUnknownModifierPropertyError as $f, parseTransform as $h, formatConstraints as $i, EditUnit as $l, UiBorderRadiuses as $m, DefaultVideoResolver as $n, CARET_WIDTH as $o, scaleFrom as $p, decorated as $r, selectableTextOf as $s, PaintResolver as $t, spacingEqual as $u, MARK_PREFIX as A, EditingState as Aa, lineEndAt as Ac, UiTextSpan as Ad, UiBoxShadow as Af, tween as Ah, parseAlignContent as Ai, StackProps as Al, UiBorderRadiusValue as Am, resolveNumber as An, UiPoint as Ao, UiPinchEvent as Ap, shortcuts as Ar, Canvas2DContext as As, WebGPUTextureCache as At, lightTheme as Au, ByteSource as B, UiDroppedFile as Ba, LazyGrid as Bc, textStylesEqual as Bd, UiInsets as Bf, UiDurationToken as Bh, SCROLLBAR_FADE_MS as Bi, UI_ROLES as Bl, UiPlacement as Bm, publishInset as Bn, SubtreeBounds as Bo, DirtyNodeSet as Bp, reorderable as Br, VerticalAlign as Bs, WebGPUSurface as Bt, themeExtension as Bu, paragraphGeometry as C, UiPlatformAdapter as Ca, lineIndexForOffset as Cc, UiFontStyle as Cd, isFrLength as Cf, DirtyFlags as Ch, GridPlacement as Ci, PaintElementProps as Cl, DecorationStroke as Cm, OverlayShape as Cn, SelectionControllerOptions as Co, UiEventType as Cp, AnimateLayoutOptions as Cr, drawText as Cs, glyphCount as Ct, VirtualViewport as Cu, UiFrameCallback as D, touchActionFor as Da, offsetForVerticalMove as Dc, UiTextDecoration as Dd, percent as Df, assertTransitionMap as Dh, AlignContent as Di, Reactive as Dl, paintsAfterChildren as Dm, CanvasSurface as Dn, HitTestResult as Do, UiKeyModifiers as Dp, ShortcutsOptions as Dr, runFontString as Ds, GlyphSlot as Dt, videoFrameSize as Du, wordRangeIn as E, prepareInputSurface as Ea, offsetAtX as Ec, UiSpannedText as Ed, minmax as Ef, UiTransitionValue as Eh, sizeGridTracks as Ei, PropsOf as El, hasDecorationPhase as Em, CanvasHost as En, HitTestLayoutReader as Eo, UiInputEvent as Ep, ShortcutOptions as Er, runCanvasStyleInto as Es, GLYPH_SUBPIXEL_PHASES as Et, isVideoSurface as Eu, setPerformanceMarks as F, UiDragPayload as Fa, previousWordStart as Fc, resolvedSpansOf as Fd, defineProperty as Ff, UiSpring as Fh, ELLIPSIS as Fi, UiNodeRef as Fl, UiFlexWrap as Fm, themeTokens as Fn, ScrollbarAxis as Fo, UiTextChangeEvent as Fp, DragSourceOptions as Fr, DEFAULT_TEXT_COLOR as Fs, DrawStats as Ft, UiThemeExtensionOptions as Fu, Mp4AudioTrack as G, UiShortcutBinding as Ga, Button as Gc, PaintSurface as Gd, UiContainerSizeSource as Gf, defaultMotion as Gh, Edges as Gi, UiSemanticStates as Gl, UiTextAlign as Gm, ScrollOffset as Gn, FindMatch as Go, MotionStateInput as Gp, clickOutside as Gr, normalizeTextAlign as Gs, registerFontStack as Gt, highContrastColors as Gu, RangeSourceOptions as H, dragSessionFor as Ha, LazyListProps as Hc, PaintFillRule as Hd, noInsets as Hf, UiMotion as Hh, ScrollAdjustment as Hi, UiLiveRegion as Hl, UiPosition as Hm, SizeContainerArgs as Hn, clearMatchRanges as Ho, MOTION_REST as Hp, DraggableOptions as Hr, computeObjectFitRect as Hs, bumpFontStack as Ht, withThemeExtension as Hu, VttCue as I, UiDragSession as Ia, wordRangeAt as Ic, spanAtOffset as Id, propertyValuesEqual as If, UiSpringOptions as Ih, layoutParagraph as Ii, UiProperties as Il, UiFontWeight as Im, sameArgs as In, ScrollbarThumb as Io, UiWheelDeltaMode as Ip, DropTargetOptions as Ir, ObjectFit as Is, RenderHooks as It, UiThemeExtensions as Iu, demuxMp4Audio as J, formatShortcut as Ja, Grid as Jc, UiPaint as Jd, unknownContainerSize as Jf, interpolateNumber as Jh, OverrideSources as Ji, normalizeStates as Jl, UiTextWrapValue as Jm, VideoClock as Jn, UiEnvironmentProvider as Jo, fade as Jp, BordersOptions as Jr, DEFAULT_LINE_HEIGHT_FACTOR as Js, PaintPictureCache as Jt, UiDensity as Ju, Mp4Sample as K, UiShortcutRegistry as Ka, Column as Kc, PaintTextAlign as Kd, bandOf as Kf, UiInterpolator as Kh, LayoutExplanation as Ki, isUiRole as Kl, UiTextDirection as Km, ScrollPositionArgs as Kn, FindOptions as Ko, MotionTiming as Kp, autoFocus as Kr, normalizeVerticalAlign as Ks, PaintCanvas as Kt, raiseContrast as Ku, VttTrack as L, UiDragState as La, Responsive as Lc, spannedTextOf as Ld, UiInsetEdge as Lf, UiTween as Lh, proportionalFontMetrics as Li, UiPropertyName as Ll, UiGridAutoFlow as Lm, InsetPaddingArgs as Ln, scrollbarThumb as Lo, UiWheelEvent as Lp, ReorderableOptions as Lr, PaintState as Ls, WebGPURenderer as Lt, defineThemeExtension as Lu, markNow as M, TouchScrollerOptions as Ma, nextGraphemeEnd as Mc, defaultTextStyle as Md, boxShadowArraysEqual as Mf, UiAnimation as Mh, parseMainAxisAlignment as Mi, TextProps as Ml, UiContentDistribution as Mm, resolvePropertyByName as Mn, SCROLLBAR_INSET as Mo, UiPointerEvent as Mp, ZoomState as Mr, DEFAULT_FONT_FAMILY as Ms, isWebGPUAvailable as Mt, withContrast as Mu, measureSpan as N, UiTouchScroller as Na, nextWordEnd as Nc, editableSpansOf as Nd, boxShadowsEqual as Nf, UiAnimationOptions as Nh, FlexDirection as Ni, TypographyProps as Nl, UiCursor as Nm, resolveString as Nn, SCROLLBAR_MIN_THUMB as No, UiPointerKind as Np, pinchable as Nr, DEFAULT_FONT_SIZE as Ns, WebGPUError as Nt, withDensity as Nu, UiScheduler as O, EditingControllerOptions as Oa, selectionRects as Oc, UiTextLink as Od, repeat as Of, normalizeTransition as Oh, CrossAxisAlignment as Oi, RowProps as Ol, UI_SUBGRID_AXES as Om, createCanvasSurface as On, HitTester as Oo, UiKeyboardEvent as Op, contextMenu as Or, textRunBackgrounds as Os, GlyphUpload as Ot, UiTheme as Ou, performanceMarksEnabled as P, EXTERNAL_FILES as Pa, previousGraphemeStart as Pc, flattenTextSpans as Pd, UiPropertyDefinition as Pf, UiReducedMotionPolicy as Ph, parseFlexDirection as Pi, UiEventProps as Pl, UiDirection as Pm, ThemeTokenTarget as Pn, SCROLLBAR_THICKNESS as Po, UiSelectionChangeEvent as Pp, AutoScrollOptions as Pr, DEFAULT_FONT_WEIGHT as Ps, CapturedFrame as Pt, UiThemeExtension as Pu, Mp3Frames as Q, PointerControllerOptions as Qa, Stack as Qc, pathValuesEqual as Qd, UiModifierSet as Qf, UiTransforms as Qh, describeOverrides as Qi, CompositionRange as Ql, UiBorderRadius as Qm, videoSource as Qn, CARET_BLINK_MS as Qo, rotateFrom as Qp, borders as Qr, selectableTextNodes as Qs, PaintGradient as Qt, scaleSpacing as Qu, cueAt as R, UiDropEffect as Ra, ResponsiveProps as Rc, textContentOf as Rd, UiInsetRegistry as Rf, UiTweenOptions as Rh, LayoutNotifier as Ri, UiPropertyValueOf as Rl, UiObjectFit as Rm, PublishInsetArgs as Rn, scrollbarThumbs as Ro, noKeyModifiers as Rp, dragSource as Rr, PaintTextSpan as Rs, WebGPURendererOptions as Rt, hasThemeExtension as Ru, offsetAtPointIn as S, PlatformSurface as Sa, lineIndexAtY as Sc, UiFontStretch as Sd, isAutoLength as Sf, UiNodeType as Sh, GridItemRequest as Si, InteractionProps as Sl, DecorationShape as Sm, LABEL_PADDING_X as Sn, UiFindController as So, UiBeforeInputEvent as Sp, ImageResolver as Sr, createCanvasTextStyle as Ss, createTextCache as St, VirtualUpdate as Su, selectionRectsIn as T, pointerDeviceOf as Ta, offsetAtPoint as Tc, UiResolvedTextSpan as Td, isPercentLength as Tf, UiTransitionSpec as Th, placeGridItems as Ti, PositionProps as Tl, decorationRect as Tm, labelOrigin as Tn, UiSelectionController as To, UiGestureEvent as Tp, ContextMenuOptions as Tr, layoutTextLines as Ts, GlyphShaper as Tt, UiVideoSurface as Tu, bufferSource as U, ShortcutRegistryOptions as Ua, LazyRow as Uc, PaintLineCap as Ud, observeViewportInsets as Uf, UiSpringSpec as Uh, AxisExplanation as Ui, UiRole as Ul, UiSelfAlignment as Um, breakpoint as Un, matchRangesOf as Uo, MotionChannel as Up, draggable as Ur, createPaintState as Us, clearFontStacks as Ut, UiContrast as Uu, DEFAULT_BLOCK_SIZE as V, UiFileDropMessage as Va, LazyGridProps as Vc, PaintBox as Vd, insetsEqual as Vf, UiEasingToken as Vh, SCROLLBAR_LINGER_MS as Vi, UI_SEMANTIC_STATES as Vl, UiPointerEvents as Vm, BreakpointArgs as Vn, TEXT_MATCHES_PROP as Vo, MOTION_CHANNELS as Vp, DragOffset as Vr, colorToCss as Vs, createWebGPUSurface as Vt, themeExtensionsEqual as Vu, rangeSource as W, UiShortcut as Wa, Box as Wc, PaintLineJoin as Wd, UiContainerSize as Wf, UiSpringToken as Wh, CustomLayoutExplanation as Wi, UiSemanticState as Wl, UiSubgridAxis as Wm, sizeContainer as Wn, setMatchRanges as Wo, MotionState as Wp, ClickOutsideOptions as Wr, isPaintVisible as Ws, fontStackFor as Wt, contrastRatio as Wu, Mp3Format as X, KeyboardControllerOptions as Xa, Row as Xc, inputsEqual as Xd, UiModifierFocus as Xf, interpolatorFor as Xh, SizeDecision as Xi, validateRole as Xl, UiVerticalAlign as Xm, VideoState as Xn, UiEnvironmentKeys as Xo, pop as Xp, FocusRingOptions as Xr, TextRange as Xs, paintPictures as Xt, UiSpacing as Xu, demuxMp4Video as Y, parseShortcut as Ya, Paint as Yc, UiPath as Yd, UiModifierEnvironment as Yf, interpolateTransform as Yh, RelayoutExplanation as Yi, statesEqual as Yl, UiThemeColorName as Ym, VideoSourceArgs as Yn, provideEnvironment as Yo, isMotionRest as Yp, Decorations as Yr, TEXT_SELECTION_PROP as Ys, PaintStats as Yt, densityFactors as Yu, Mp3Frame as Z, UiKeyboardController as Za, ScrollView as Zc, paintValuesEqual as Zd, UiModifierLayout as Zf, UiTransform as Zh, describeLength as Zi, validateStates as Zl, validateSubgrid as Zm, VideoTransport as Zn, EnvironmentNotifier as Zo, resolveMotionState as Zp, borderShapes as Zr, clearSelectionRange as Zs, PaintContext2D as Zt, defaultSpacing as Zu, linkOf as _, isNodeTabStop as _a, spannedRunsFor as _c, defaultVisualState as _d, PercentLength as _f, steps as _g, LayoutRecord as _h, inheritedPropertyNames as _i, FlexContainerProps as _l, UiNodeTransitions as _m, RendererBackend as _n, overrideSources as _o, UiEventListener as _p, IconRasterizerOptions as _r, SpanPaint as _s, ScissorRect as _t, UiVirtualWindow as _u, diffSemantics as a, UiFrameClock as aa, ParagraphLayout as ac, UiTypographyExtensions as ad, UiGradientOffset as af, colorToHex as ag, normalizeBorderRadius as ah, measure as ai, UiEventBinding as al, Constraints as am, PaintRecording as an, isScrollContainer as ao, UiModifierHost as ap, MotionArgs as ar, isMultiline as as, CLIP_STRIDE_FLOATS as at, SheetRowRenderer as au, ParagraphGeometry as b, PlatformAdapterOptions as ba, RunMeasure as bc, visualStatesEqual as bd, auto as bf, createEnvironmentKey as bh, propertyValuesEqualByName as bi, GridProps as bl, DecorationFill as bm, RenderChanges as bn, writeOverrideProperty as bo, UiListenerErrorReporter as bp, DefaultImageResolver as br, applyCanvasTextStyle as bs, TextRunDraw as bt, VIRTUAL_WINDOW_PROP as bu, UiSemanticsMap as c, UiHostFrameClock as ca, TextLine as cc, isTypographyRole as cd, UiRadialGradient as cf, colorsEqual as cg, UiShapeName as ch, bundle as ci, UiGraphBuilder as cl, LayoutStats as cm, InspectorOverlay as cn, UiGestureRecognizer as co, ComponentLikeElement as cp, sharedElement as cr, syncEditorValue as cs, INSTANCE_STRIDE_BYTES as ct, UiVirtualSheet as cu, buildSemanticsTree as d, UiTimerFrameClock as da, TextMeasurer as dc, UiLayoutChild as dd, linearGradient as df, rgb8 as dg, isShapeName as dh, accumulatedOffsetTo as di, ButtonProps as dl, clampSize as dm, CanvasTextMeasurer as dn, FocusNotifier as do, isComponentLikeElement as dp, ImageSources as dr, commandForKey as ds, NO_CLIP_INDEX as dt, sheetSource as du, formatExplanation as ea, selectionRangeOf as ec, spacingSteps as ed, GradientPaint as ef, transform as eg, borderRadius as eh, focusRing as ei, createElement as el, slideDown as em, PaintTarget as en, ScrollContainerState as eo, assertModifierList as ep, DefaultVideoResolverOptions as er, EDITOR_PROP as es, readMp3Header as et, EditableTextModel as eu, semanticsInertAbove as f, UiTimerFrameClockOptions as fa, TextOverflow as fc, UiLayoutContext as fd, radialGradient as ff, rgba as fg, shapesEqual as fh, contentOffset as fi, ColumnProps as fl, constraintsEqual as fm, Canvas2DRenderer as fn, FocusSource as fo, isObservable$1 as fp, iconSource as fr, detectEditingPlatform as fs, PrimitiveCommand as ft, LazyAxis as fu, linkHoverOf as g, isNodeSelectable as ga, TextWrap as gc, UiVisualStateSet as gd, MinMaxTrack as gf, linear as gg, lightColors as gh, inheritedPropertyFlags as gi, EnvironmentProps as gl, UiNode as gm, ScrollLayerStats as gn, clearOverrideProperty as go, UiProps as gp, IconRasterizer as gr, PlacedTextRun as gs, RenderTextCache as gt, LazySourceArgs as gu, hasTextLinks as h, isNodeInert as ha, TextRunStyle as hc, UiVisualState as hd, FrLength as hf, easings as hg, darkColors as hh, getPropertyNames as hi, EditableTextProps as hl, NodeProperty as hm, LayerCanvasFactory as hn, resetTransitionWarnings as ho, UiPropValue as hp, IconContext as hr, CanvasTextStyle as hs, RenderList as ht, LazyListOptions as hu, UiSemanticsPatch as i, UiAnimationFrameClock as ia, FontMetrics as ic, UiTypography as id, UiGradient as if, UiColor as ig, borderRadiusValuesEqual as ih, interactive as ii, UiGraph as il, UiSharedElements as im, PaintRecorder as in, UiWheelController as io, isUiModifier as ip, canDecodeVideo as ir, isEditableNode as is, CLIP_STRIDE_BYTES as it, SheetRange as iu, markInstant as j, UiEditingController as ja, lineStartAt as jc, UiTextStyle as jd, boxShadow as jf, AnimatedCell as jh, parseCrossAxisAlignment as ji, TextContentProps as jl, UiColorValue as jm, resolveProperty as jn, SCROLLBAR_HOVER_ZONE as jo, UiPointerDevice as jp, PinchableOptions as jr, Canvas2DGradient as js, initializeWebGPU as jt, themesEqual as ju, UiSchedulerOptions as k, EditingHost as ka, graphemeBoundaries as kc, UiTextMetrics as kd, resolveLength as kf, spring as kh, MainAxisAlignment as ki, ScrollViewProps as kl, UiAlignment as km, resolveBoolean as kn, UiHitTester as ko, UiPasteEvent as kp, shortcut as kr, textRunDecorations as ks, WebGPUGlyphAtlas as kt, darkTheme as ku, UiSemanticsRecord as l, UiHostFrameClockOptions as la, TextLineRun as lc, typographyEqual as ld, gradientPaint as lf, normalizeColor as lg, UiShapes as lh, noModifiers as li, BoxModelProps as ll, Size as lm, LayoutInspector as ln, PinchRecognizerOptions as lo, UiChild as lp, IconSourceArgs as lr, EditCommand as ls, INSTANCE_STRIDE_FLOATS as lt, UiVirtualSheetOptions as lu, clearLinkHover as m, isNodeHitTestable as ma, TextRunSpan as mc, isLayoutProtocol as md, AutoLength as mf, cubicBezier as mg, colorsEqualPalette as mh, findPropertyDefinition as mi, ContainerProps as ml, NodeId as mm, traceRoundedRect as mn, NodeTransitions as mo, isUiElement as mp, IconCanvas as mr, EditableLayout as ms, RenderCommand as mt, LazyItemRenderer as mu, UiSemanticsBox as n, withOverrideSource as na, CharacterCountTextMeasurer as nc, defaultShadows as nd, ResolvedGradient as nf, transformsEqual as ng, borderRadiusEqual as nh, InteractiveOptions as ni, BindingId as nl, slideUp as nm, EMPTY_RECORDING as nn, UiScrollBehavior as no, UiModifierKind as np, VideoPlayback as nr, editorFor as ns, WebGPUGlyphPages as nt, LazySheetProps as nu, recordsEqual as o, UiFrameClockFactory as oa, ParagraphTextMeasurer as oc, UiTypographyRole as od, UiGradientStop as of, colorToRgba as og, uniformBorderRadius as oh, pressable as oi, ChildrenBindingId as ol, LayoutBox as om, replayPaint as on, GestureInput as oo, UiModifierTeardown as op, SharedElementArgs as or, isReadOnly as os, CommandKind as ot, SheetSourceArgs as ou, textRunOfRecordId as p, isNodeFocusable as pa, TextRunMeasurer as pc, UiLayoutProtocol as pd, validateGradient as pf, UiEasing as pg, UiColors as ph, closestPropertyName as pi, CommonProps as pl, tightenConstraints as pm, Canvas2DRendererOptions as pn, UiFocusManager as po, isUiChild as pp, imageSource as pr, isPrintable as ps, PrimitiveKind as pt, LazyGridOptions as pu, Mp4VideoTrack as q, UiShortcutStep as qa, EditableText as qc, PaintTextStyle as qd, containerBands as qf, interpolateColor as qh, LayoutStateExplanation as qi, isUiSemanticState as ql, UiTextOverflowValue as qm, scrollPosition as qn, findMatchesIn as qo, ResolvedMotionState as qp, BorderEdge as qr, resolvePaintState as qs, PaintCanvasFactory as qt, relativeLuminance as qu, UiSemanticsUpdate as r, UiFrame as ra, FixedMetricsOptions as rc, shadowsEqual as rd, ResolvedGradientStop as rf, UiBasicColors as rg, borderRadiusIsZero as rh, hoverable as ri, UiBinding as rl, SharedClaim as rm, PaintOp as rn, UiScrollability as ro, defineModifier as rp, VideoResolver as rr, editorOf as rs, Affine as rt, SheetHeaderRenderer as ru, TEXT_RUN_ID_SEPARATOR as s, UiFrameTime as sa, SpannedRuns as sc, defaultTypography as sd, UiLinearGradient as sf, colorValuesEqual as sg, UiShapeExtensions as sh, UiModifierBundle as si, UiChildrenBinding as sl, LayoutResult as sm, INSPECTOR_HEAT_MS as sn, GestureRecognizerOptions as so, ComponentResolver as sp, motion as sr, nextCaretToggle as ss, GlyphCommand as st, SheetViewport as su, UiSemanticsAction as t, labelNode as ta, setSelectionRange as tc, UiShadows as td, MAX_GRADIENT_STOPS as tf, transformIsIdentity as tg, borderRadiusCorners as th, BUTTON_INTERACTION as ti, UiDefinition as tl, slideFrom as tm, tracePathData as tn, ScrollSink as to, UiModifier as tp, RangeResponse as tr, caretVisibleAt as ts, splitMp3Frames as tt, LazySheet as tu, buildSemanticsSubtree as u, UiManualFrameClock as ua, TextMeasureRequest as uc, MAX_MEASURES_PER_CHILD as ud, gradientsEqual as uf, parseColor as ug, defaultShapes as uh, Transform as ui, BoxProps as ul, TightenOptions as um, LayoutInspectorOptions as un, UiPinchRecognizer as uo, UiElement as up, ImageSourceArgs as ur, EditingPlatform as us, ImageCommand as ut, VIRTUAL_SHEET_PROP as uu, linkRunAtPointIn as v, resolveCursor as va, CaretRect as vc, hasVisualState as vd, UiLength as vf, UiEnvironment as vh, propertyEffects as vi, FlexItemProps as vl, UiPropertyOverride as vm, UiRenderer as vn, resetOverrideWarnings as vo, UiEventListenerOptions as vp, IconSpec as vr, TextLinePlacement as vs, TEXTURED_STRIDE_BYTES as vt, VIRTUAL_INDEX_PROP as vu, paragraphGeometryFrom as w, capturePointer as wa, lineLimit as wc, UiFontVariant as wd, isMinMaxTrack as wf, AnimationDriver as wh, GridTrack as wi, PaintProps as wl, decorationColor as wm, drawOverlayShapes as wn, SelectionHost as wo, UiFocusEvent as wp, animateLayout as wr, fillTextRects as ws, textRuns as wt, lazySource as wu, hasDrawnText as x, PlatformEventTarget as xa, caretRectFor as xc, UiFontKerning as xd, fr as xf, findEnvironmentKey as xh, GridContribution as xi, IdentityProps as xl, DecorationRect as xm, RenderContext as xn, FindHost as xo, MOUSE_POINTER as xp, DefaultImageResolverOptions as xr, buildFontString as xs, buildRenderList as xt, VirtualItemMeasure as xu, setLinkHover as y, CanvasPlatformSurface as ya, PlacedLine as yc, visualState as yd, UiTrackSize as yf, UiEnvironmentKey as yh, propertyIsInherited as yi, GridItemProps as yl, UiPropertyOverrides as ym, LayoutReader as yn, writeDeclaredProperty as yo, UiInputDispatcher as yp, iconKey as yr, TextRunRect as ys, TEXTURED_STRIDE_FLOATS as yt, VIRTUAL_LEAD_PROP as yu, parseWebVtt as z, UiDropZone as za, LazyColumn as zc, textSpansEqual as zd, UiInsetSource as zf, createTween as zh, LayoutEngine as zi, UiPropertyValues as zl, UiOverflow as zm, insetPadding as zn, scrollbarZoneAt as zo, wheelDeltaYOf as zp, dropTarget as zr, TextAlign as zs, WebGPUCanvasHost as zt, noThemeExtensions as zu };
-//# sourceMappingURL=index-CfUSbphd.d.ts.map
+export { Mp4AudioTrack as $, UiShortcutBinding as $a, Box as $c, PaintFillRule as $d, UiInsetSource as $f, spring as $h, Edges as $i, UiSemanticState as $l, UiAlignment as $m, ScrollOffset as $n, FindMatch as $o, UiPasteEvent as $p, clickOutside as $r, isPaintVisible as $s, registerFontStack as $t, contrastRatio as $u, offsetAtPointIn as A, PlatformSurface as Aa, caretRectFor as Ac, UiFontKerning as Ad, UiTrackSize as Af, colorToRgba as Ag, uniformBorderRadius as Ah, GridItemRequest as Ai, IdentityProps as Al, LayoutBox as Am, LABEL_PADDING_X as An, SelectionHost as Ao, UiFocusManager as Ap, ImageResolver as Ar, createCanvasTextStyle as As, createTextCache as At, VirtualItemMeasure as Au, markNow as B, TouchScrollerOptions as Ba, lineStartAt as Bc, UiTextSpan as Bd, resolveLength as Bf, linear as Bg, lightColors as Bh, parseMainAxisAlignment as Bi, TextContentProps as Bl, UiNode as Bm, resolvePropertyByName as Bn, SCROLLBAR_THICKNESS as Bo, UiProps as Bp, ZoomState as Br, DEFAULT_FONT_FAMILY as Bs, isWebGPUAvailable as Bt, themesEqual as Bu, hasTextLinks as C, isNodeInert as Ca, TextRunSpan as Cc, isLayoutProtocol as Cd, radialGradient as Cf, parseTransform as Cg, UiBorderRadiuses as Ch, getPropertyNames as Ci, ContainerProps as Cl, scaleFrom as Cm, LayerCanvasFactory as Cn, overrideSources as Co, UiModifierKind as Cp, IconContext as Cr, CanvasTextStyle as Cs, RenderList as Ct, LazyItemRenderer as Cu, setLinkHover as D, CanvasPlatformSurface as Da, CaretRect as Dc, hasVisualState as Dd, MinMaxTrack as Df, UiBasicColors as Dg, borderRadiusIsZero as Dh, propertyIsInherited as Di, FlexItemProps as Dl, SharedClaim as Dm, LayoutReader as Dn, FindHost as Do, UiModifierTeardown as Dp, iconKey as Dr, TextRunRect as Ds, TEXTURED_STRIDE_FLOATS as Dt, VIRTUAL_INDEX_PROP as Du, linkRunAtPointIn as E, resolveCursor as Ea, spannedRunsFor as Ec, defaultVisualState as Ed, FrLength as Ef, transformsEqual as Eg, borderRadiusEqual as Eh, propertyEffects as Ei, FlexContainerProps as El, slideUp as Em, UiRenderer as En, writeOverrideProperty as Eo, UiModifierHost as Ep, IconSpec as Er, TextLinePlacement as Es, TEXTURED_STRIDE_BYTES as Et, UiVirtualWindow as Eu, UiFrameCallback as F, touchActionFor as Fa, offsetAtX as Fc, UiSpannedText as Fd, isMinMaxTrack as Ff, rgb8 as Fg, isShapeName as Fh, AlignContent as Fi, PropsOf as Fl, clampSize as Fm, CanvasSurface as Fn, UiHitTester as Fo, isComponentLikeElement as Fp, ShortcutsOptions as Fr, runFontString as Fs, GlyphSlot as Ft, isVideoSurface as Fu, VttTrack as G, UiDragState as Ga, wordRangeAt as Gc, hiddenRangesOf as Gd, boxShadowRadius as Gf, findEnvironmentKey as Gh, proportionalFontMetrics as Gi, UiProperties as Gl, DecorationRect as Gm, InsetPaddingArgs as Gn, scrollbarThumb as Go, MOUSE_POINTER as Gp, ReorderableOptions as Gr, PaintBoxShadow as Gs, WebGPURenderer as Gt, UiThemeExtensions as Gu, performanceMarksEnabled as H, EXTERNAL_FILES as Ha, nextWordEnd as Hc, defaultTextStyle as Hd, UiBoxShadow as Hf, UiEnvironment as Hh, parseFlexDirection as Hi, TypographyProps as Hl, UiPropertyOverride as Hm, ThemeTokenTarget as Hn, ScrollbarThumb as Ho, UiEventListenerOptions as Hp, AutoScrollOptions as Hr, DEFAULT_FONT_WEIGHT as Hs, CapturedFrame as Ht, withDensity as Hu, UiScheduler as I, EditingControllerOptions as Ia, offsetForVerticalMove as Ic, UiTextDecoration as Id, isPercentLength as If, rgba as Ig, shapesEqual as Ih, CrossAxisAlignment as Ii, Reactive as Il, constraintsEqual as Im, createCanvasSurface as In, UiPoint as Io, isObservable$1 as Ip, contextMenu as Ir, textRunBackgrounds as Is, GlyphUpload as It, videoFrameSize as Iu, ByteSource as J, UiDroppedFile as Ja, LazyColumn as Jc, spannedTextOf as Jd, UiPropertyDefinition as Jf, AnimationDriver as Jh, SCROLLBAR_FADE_MS as Ji, UiPropertyValues as Jl, decorationColor as Jm, publishInset as Jn, SubtreeBounds as Jo, UiFocusEvent as Jp, reorderable as Jr, TextAlign as Js, WebGPUSurface as Jt, noThemeExtensions as Ju, cueAt as K, UiDropEffect as Ka, Responsive as Kc, resolvedSpansOf as Kd, boxShadowReach as Kf, UiNodeType as Kh, LayoutNotifier as Ki, UiPropertyName as Kl, DecorationShape as Km, PublishInsetArgs as Kn, scrollbarThumbs as Ko, UiBeforeInputEvent as Kp, dragSource as Kr, PaintState as Ks, WebGPURendererOptions as Kt, defineThemeExtension as Ku, UiSchedulerOptions as L, EditingHost as La, selectionRects as Lc, UiTextLink as Ld, minmax as Lf, UiEasing as Lg, UiColors as Lh, MainAxisAlignment as Li, RowProps as Ll, tightenConstraints as Lm, resolveBoolean as Ln, SCROLLBAR_HOVER_ZONE as Lo, isUiChild as Lp, shortcut as Lr, textRunDecorations as Ls, WebGPUGlyphAtlas as Lt, UiTheme as Lu, paragraphGeometryFrom as M, capturePointer as Ma, lineIndexForOffset as Mc, UiFontStyle as Md, fr as Mf, colorsEqual as Mg, UiShapeName as Mh, GridTrack as Mi, PaintElementProps as Ml, LayoutStats as Mm, drawOverlayShapes as Mn, HitTestLayoutReader as Mo, ComponentLikeElement as Mp, animateLayout as Mr, fillTextRects as Ms, textRuns as Mt, VirtualViewport as Mu, selectionRectsIn as N, pointerDeviceOf as Na, lineLimit as Nc, UiFontVariant as Nd, isAutoLength as Nf, normalizeColor as Ng, UiShapes as Nh, placeGridItems as Ni, PaintProps as Nl, Size as Nm, labelOrigin as Nn, HitTestResult as No, UiChild as Np, ContextMenuOptions as Nr, layoutTextLines as Ns, GlyphShaper as Nt, lazySource as Nu, ParagraphGeometry as O, PlatformAdapterOptions as Oa, PlacedLine as Oc, visualState as Od, PercentLength as Of, UiColor as Og, borderRadiusValuesEqual as Oh, propertyValuesEqualByName as Oi, GridItemProps as Ol, UiSharedElements as Om, RenderChanges as On, UiFindController as Oo, FocusOptions as Op, DefaultImageResolver as Or, applyCanvasTextStyle as Os, TextRunDraw as Ot, VIRTUAL_LEAD_PROP as Ou, wordRangeIn as P, prepareInputSurface as Pa, offsetAtPoint as Pc, UiResolvedTextSpan as Pd, isFrLength as Pf, parseColor as Pg, defaultShapes as Ph, sizeGridTracks as Pi, PositionProps as Pl, TightenOptions as Pm, CanvasHost as Pn, HitTester as Po, UiElement as Pp, ShortcutOptions as Pr, runCanvasStyleInto as Ps, GLYPH_SUBPIXEL_PHASES as Pt, UiVideoSurface as Pu, rangeSource as Q, UiShortcut as Qa, LazyRow as Qc, PaintBox as Qd, UiInsetRegistry as Qf, normalizeTransition as Qh, CustomLayoutExplanation as Qi, UiRole as Ql, UI_SUBGRID_AXES as Qm, sizeContainer as Qn, setMatchRanges as Qo, UiKeyboardEvent as Qp, ClickOutsideOptions as Qr, createPaintState as Qs, fontStackFor as Qt, UiContrast as Qu, MARK_PREFIX as R, EditingState as Ra, graphemeBoundaries as Rc, UiTextMetrics as Rd, percent as Rf, cubicBezier as Rg, colorsEqualPalette as Rh, parseAlignContent as Ri, ScrollViewProps as Rl, NodeId as Rm, resolveNumber as Rn, SCROLLBAR_INSET as Ro, isUiElement as Rp, shortcuts as Rr, Canvas2DContext as Rs, WebGPUTextureCache as Rt, darkTheme as Ru, clearLinkHover as S, isNodeHitTestable as Sa, TextRunMeasurer as Sc, UiLayoutProtocol as Sd, linearGradient as Sf, UiTransforms as Sg, UiBorderRadius as Sh, findPropertyDefinition as Si, CommonProps as Sl, rotateFrom as Sm, traceRoundedRect as Sn, clearOverrideProperty as So, UiModifier as Sp, IconCanvas as Sr, EditableLayout as Ss, RenderCommand as St, LazyGridOptions as Su, linkOf as T, isNodeTabStop as Ta, TextWrap as Tc, UiVisualStateSet as Td, AutoLength as Tf, transformIsIdentity as Tg, borderRadiusCorners as Th, inheritedPropertyNames as Ti, EnvironmentProps as Tl, slideFrom as Tm, RendererBackend as Tn, writeDeclaredProperty as To, isUiModifier as Tp, IconRasterizerOptions as Tr, SpanPaint as Ts, ScissorRect as Tt, LazySourceArgs as Tu, setPerformanceMarks as U, UiDragPayload as Ua, previousGraphemeStart as Uc, editableSpansOf as Ud, boxShadow as Uf, UiEnvironmentKey as Uh, ELLIPSIS as Ui, UiEventProps as Ul, UiPropertyOverrides as Um, themeTokens as Un, scrollLeaderOf as Uo, UiInputDispatcher as Up, DragSourceOptions as Ur, DEFAULT_TEXT_COLOR as Us, DrawStats as Ut, UiThemeExtension as Uu, measureSpan as V, UiTouchScroller as Va, nextGraphemeEnd as Vc, UiTextStyle as Vd, BOX_SHADOW_BLUR_REACH as Vf, steps as Vg, LayoutRecord as Vh, FlexDirection as Vi, TextProps as Vl, UiNodeTransitions as Vm, resolveString as Vn, ScrollbarAxis as Vo, UiEventListener as Vp, pinchable as Vr, DEFAULT_FONT_SIZE as Vs, WebGPUError as Vt, withContrast as Vu, VttCue as W, UiDragSession as Wa, previousWordStart as Wc, flattenTextSpans as Wd, boxShadowArraysEqual as Wf, createEnvironmentKey as Wh, layoutParagraph as Wi, UiNodeRef as Wl, DecorationFill as Wm, sameArgs as Wn, scrollRange as Wo, UiListenerErrorReporter as Wp, DropTargetOptions as Wr, ObjectFit as Ws, RenderHooks as Wt, UiThemeExtensionOptions as Wu, RangeSourceOptions as X, dragSessionFor as Xa, LazyGridProps as Xc, textSpansEqual as Xd, propertyValuesEqual as Xf, UiTransitionValue as Xh, ScrollAdjustment as Xi, UI_SEMANTIC_STATES as Xl, hasDecorationPhase as Xm, SizeContainerArgs as Xn, clearMatchRanges as Xo, UiInputEvent as Xp, DraggableOptions as Xr, colorToCss as Xs, bumpFontStack as Xt, themeExtensionsEqual as Xu, DEFAULT_BLOCK_SIZE as Y, UiFileDropMessage as Ya, LazyGrid as Yc, textContentOf as Yd, defineProperty as Yf, UiTransitionSpec as Yh, SCROLLBAR_LINGER_MS as Yi, UI_ROLES as Yl, decorationRect as Ym, BreakpointArgs as Yn, TEXT_MATCHES_PROP as Yo, UiGestureEvent as Yp, DragOffset as Yr, VerticalAlign as Ys, createWebGPUSurface as Yt, themeExtension as Yu, bufferSource as Z, ShortcutRegistryOptions as Za, LazyListProps as Zc, textStylesEqual as Zd, UiInsetEdge as Zf, assertTransitionMap as Zh, AxisExplanation as Zi, UiLiveRegion as Zl, paintsAfterChildren as Zm, breakpoint as Zn, matchRangesOf as Zo, UiKeyModifiers as Zp, draggable as Zr, computeObjectFitRect as Zs, clearFontStacks as Zt, withThemeExtension as Zu, buildSemanticsTree as _, UiHostFrameClockOptions as _a, TextLine as _c, isTypographyRole as _d, UiGradientStop as _f, interpolateColor as _g, UiTextOverflowValue as _h, noModifiers as _i, UiGraphBuilder as _l, ResolvedMotionState as _m, LayoutInspector as _n, PinchRecognizerOptions as _o, UiModifierFocus as _p, IconSourceArgs as _r, EditCommand as _s, INSTANCE_STRIDE_FLOATS as _t, UiVirtualSheet as _u, diffSemantics as a, describeLength as aa, TextRange as ac, UiSpacing as ad, UiPaint as af, UiSpring as ag, UiFlexWrap as ah, borderShapes as ai, Row as al, UiTextChangeEvent as am, PaintContext2D as an, UiKeyboardController as ao, UiContainerSizeSource as ap, VideoTransport as ar, EnvironmentNotifier as as, Mp3Frame as at, validateRole as au, semanticsMemory as b, UiTimerFrameClockOptions as ba, TextMeasurer as bc, UiLayoutChild as bd, gradientPaint as bf, interpolatorFor as bg, UiVerticalAlign as bh, contentOffset as bi, ButtonProps as bl, pop as bm, Canvas2DRenderer as bn, NodeTransitions as bo, UiUnknownModifierPropertyError as bp, iconSource as br, detectEditingPlatform as bs, PrimitiveCommand as bt, sheetSource as bu, SemanticsMemory as c, formatExplanation as ca, selectableTextOf as cc, spacingEqual as cd, paintValuesEqual as cf, UiTweenOptions as cg, UiObjectFit as ch, focusRing as ci, Text as cl, noKeyModifiers as cm, PaintTarget as cn, ScrollContainerState as co, unknownContainerSize as cp, DefaultVideoResolverOptions as cr, EDITOR_PROP as cs, readMp3Header as ct, EditUnit as cu, SemanticsRewalk as d, UiFrame as da, CharacterCountTextMeasurer as dc, defaultShadows as dd, GradientPaint as df, UiEasingToken as dg, UiPointerEvents as dh, hoverable as di, BindingId as dl, MOTION_CHANNELS as dm, PaintOp as dn, UiScrollability as do, UiTextPosition as dp, VideoResolver as dr, editorOf as ds, Affine as dt, LazySheetProps as du, LayoutExplanation as ea, normalizeTextAlign as ec, highContrastColors as ed, PaintLineCap as ef, tween as eg, UiBorderRadiusValue as eh, autoFocus as ei, Button as el, UiPinchEvent as em, PaintCanvas as en, UiShortcutRegistry as eo, UiInsets as ep, ScrollPositionArgs as er, FindOptions as es, Mp4Sample as et, UiSemanticStates as eu, SemanticsSpan as f, UiAnimationFrameClock as fa, FixedMetricsOptions as fc, shadowsEqual as fd, MAX_GRADIENT_STOPS as ff, UiMotion as fg, UiPosition as fh, interactive as fi, UiBinding as fl, MOTION_REST as fm, PaintRecorder as fn, UiWheelController as fo, adjacentField as fp, canDecodeVideo as fr, isEditableNode as fs, CLIP_STRIDE_BYTES as ft, SheetHeaderRenderer as fu, buildSemanticsSubtree as g, UiHostFrameClock as ga, SpannedRuns as gc, defaultTypography as gd, UiGradientOffset as gf, UiInterpolator as gg, UiTextDirection as gh, bundle as gi, UiChildrenBinding as gl, MotionTiming as gm, InspectorOverlay as gn, UiGestureRecognizer as go, UiModifierEnvironment as gp, sharedElement as gr, syncEditorValue as gs, INSTANCE_STRIDE_BYTES as gt, SheetViewport as gu, UiSemanticsRecord as h, UiFrameTime as ha, ParagraphTextMeasurer as hc, UiTypographyRole as hd, UiGradient as hf, defaultMotion as hg, UiTextAlign as hh, UiModifierBundle as hi, ChildrenBindingId as hl, MotionStateInput as hm, INSPECTOR_HEAT_MS as hn, GestureRecognizerOptions as ho, editingGroupOf as hp, motion as hr, nextCaretToggle as hs, GlyphCommand as ht, SheetSourceArgs as hu, UiSemanticsPatch as i, SizeDecision as ia, TEXT_SELECTION_PROP as ic, densityFactors as id, PaintTextStyle as if, UiReducedMotionPolicy as ig, UiDirection as ih, FocusRingOptions as ii, Paint as il, UiSelectionChangeEvent as im, paintPictures as in, KeyboardControllerOptions as io, UiContainerSize as ip, VideoState as ir, UiEnvironmentKeys as is, Mp3Format as it, statesEqual as iu, paragraphGeometry as j, UiPlatformAdapter as ja, lineIndexAtY as jc, UiFontStretch as jd, auto as jf, colorValuesEqual as jg, UiShapeExtensions as jh, GridPlacement as ji, InteractionProps as jl, LayoutResult as jm, OverlayShape as jn, UiSelectionController as jo, ComponentResolver as jp, AnimateLayoutOptions as jr, drawText as js, glyphCount as jt, VirtualUpdate as ju, hasDrawnText as k, PlatformEventTarget as ka, RunMeasure as kc, visualStatesEqual as kd, UiLength as kf, colorToHex as kg, normalizeBorderRadius as kh, GridContribution as ki, GridProps as kl, Constraints as km, RenderContext as kn, SelectionControllerOptions as ko, FocusSource as kp, DefaultImageResolverOptions as kr, buildFontString as ks, buildRenderList as kt, VIRTUAL_WINDOW_PROP as ku, SemanticsPlacement as l, labelNode as la, selectionRangeOf as lc, spacingSteps as ld, pathValuesEqual as lf, createTween as lg, UiOverflow as lh, BUTTON_INTERACTION as li, createElement as ll, wheelDeltaYOf as lm, tracePathData as ln, ScrollSink as lo, UiEditingGroup as lp, RangeResponse as lr, caretVisibleAt as ls, splitMp3Frames as lt, EditableTextModel as lu, UiSemanticsMap as m, UiFrameClockFactory as ma, ParagraphLayout as mc, UiTypographyExtensions as md, ResolvedGradientStop as mf, UiSpringToken as mg, UiSubgridAxis as mh, pressable as mi, UiEventBinding as ml, MotionState as mm, replayPaint as mn, GestureInput as mo, edgeField as mp, SharedElementArgs as mr, isReadOnly as ms, CommandKind as mt, SheetRowRenderer as mu, UiSemanticsBox as n, OverrideSources as na, resolvePaintState as nc, relativeLuminance as nd, PaintSurface as nf, UiAnimation as ng, UiContentDistribution as nh, BordersOptions as ni, EditableText as nl, UiPointerEvent as nm, PaintPictureCache as nn, formatShortcut as no, noInsets as np, VideoClock as nr, UiEnvironmentProvider as ns, demuxMp4Audio as nt, isUiSemanticState as nu, dropIndexShifts as o, describeOverrides as oa, clearSelectionRange as oc, defaultSpacing as od, UiPath as of, UiSpringOptions as og, UiFontWeight as oh, borders as oi, ScrollView as ol, UiWheelDeltaMode as om, PaintGradient as on, PointerControllerOptions as oo, bandOf as op, videoSource as or, CARET_BLINK_MS as os, Mp3Frames as ot, validateStates as ou, TEXT_RUN_ID_SEPARATOR as p, UiFrameClock as pa, FontMetrics as pc, UiTypography as pd, ResolvedGradient as pf, UiSpringSpec as pg, UiSelfAlignment as ph, measure as pi, UiGraph as pl, MotionChannel as pm, PaintRecording as pn, isScrollContainer as po, comparePositions as pp, MotionArgs as pr, isMultiline as ps, CLIP_STRIDE_FLOATS as pt, SheetRange as pu, parseWebVtt as q, UiDropZone as qa, ResponsiveProps as qc, spanAtOffset as qd, boxShadowsEqual as qf, DirtyFlags as qh, LayoutEngine as qi, UiPropertyValueOf as ql, DecorationStroke as qm, insetPadding as qn, scrollbarZoneAt as qo, UiEventType as qp, dropTarget as qr, PaintTextSpan as qs, WebGPUCanvasHost as qt, hasThemeExtension as qu, UiSemanticsUpdate as r, RelayoutExplanation as ra, DEFAULT_LINE_HEIGHT_FACTOR as rc, UiDensity as rd, PaintTextAlign as rf, UiAnimationOptions as rg, UiCursor as rh, Decorations as ri, Grid as rl, UiPointerKind as rm, PaintStats as rn, parseShortcut as ro, observeViewportInsets as rp, VideoSourceArgs as rr, provideEnvironment as rs, demuxMp4Video as rt, normalizeStates as ru, recordsEqual as s, formatConstraints as sa, selectableTextNodes as sc, scaleSpacing as sd, inputsEqual as sf, UiTween as sg, UiGridAutoFlow as sh, decorated as si, Stack as sl, UiWheelEvent as sm, PaintResolver as sn, UiPointerController as so, containerBands as sp, DefaultVideoResolver as sr, CARET_WIDTH as ss, Mp3Header as st, CompositionRange as su, UiSemanticsAction as t, LayoutStateExplanation as ta, normalizeVerticalAlign as tc, raiseContrast as td, PaintLineJoin as tf, AnimatedCell as tg, UiColorValue as th, BorderEdge as ti, Column as tl, UiPointerDevice as tm, PaintCanvasFactory as tn, UiShortcutStep as to, insetsEqual as tp, scrollPosition as tr, findMatchesIn as ts, Mp4VideoTrack as tt, isUiRole as tu, SemanticsReuse as u, withOverrideSource as ua, setSelectionRange as uc, UiShadows as ud, UiImage as uf, UiDurationToken as ug, UiPlacement as uh, InteractiveOptions as ui, UiDefinition as ul, DirtyNodeSet as um, EMPTY_RECORDING as un, UiScrollBehavior as uo, UiGroupEdit as up, VideoPlayback as ur, editorFor as us, WebGPUGlyphPages as ut, LazySheet as uu, rewalkSemantics as v, UiManualFrameClock as va, TextLineRun as vc, typographyEqual as vd, UiLinearGradient as vf, interpolateNumber as vg, UiTextWrapValue as vh, Transform as vi, BoxModelProps as vl, fade as vm, LayoutInspectorOptions as vn, UiPinchRecognizer as vo, UiModifierLayout as vp, ImageSourceArgs as vr, EditingPlatform as vs, ImageCommand as vt, UiVirtualSheetOptions as vu, linkHoverOf as w, isNodeSelectable as wa, TextRunStyle as wc, UiVisualState as wd, validateGradient as wf, transform as wg, borderRadius as wh, inheritedPropertyFlags as wi, EditableTextProps as wl, slideDown as wm, ScrollLayerStats as wn, resetOverrideWarnings as wo, defineModifier as wp, IconRasterizer as wr, PlacedTextRun as ws, RenderTextCache as wt, LazyListOptions as wu, textRunOfRecordId as x, isNodeFocusable as xa, TextOverflow as xc, UiLayoutContext as xd, gradientsEqual as xf, UiTransform as xg, validateSubgrid as xh, closestPropertyName as xi, ColumnProps as xl, resolveMotionState as xm, Canvas2DRendererOptions as xn, resetTransitionWarnings as xo, assertModifierList as xp, imageSource as xr, isPrintable as xs, PrimitiveKind as xt, LazyAxis as xu, semanticsInertAbove as y, UiTimerFrameClock as ya, TextMeasureRequest as yc, MAX_MEASURES_PER_CHILD as yd, UiRadialGradient as yf, interpolateTransform as yg, UiThemeColorName as yh, accumulatedOffsetTo as yi, BoxProps as yl, isMotionRest as ym, CanvasTextMeasurer as yn, FocusNotifier as yo, UiModifierSet as yp, ImageSources as yr, commandForKey as ys, NO_CLIP_INDEX as yt, VIRTUAL_SHEET_PROP as yu, markInstant as z, UiEditingController as za, lineEndAt as zc, UiTextRange as zd, repeat as zf, easings as zg, darkColors as zh, parseCrossAxisAlignment as zi, StackProps as zl, NodeProperty as zm, resolveProperty as zn, SCROLLBAR_MIN_THUMB as zo, UiPropValue as zp, PinchableOptions as zr, Canvas2DGradient as zs, initializeWebGPU as zt, lightTheme as zu };
+//# sourceMappingURL=index-DBnLGexp.d.ts.map