gesso-core 0.4.2 → 0.5.1

package/dist/{index-BiN3WdTh.d.ts → index-B3zydgF2.d.ts}

@@ -1013,6 +1013,32 @@ 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.
@@ -1089,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
@@ -1143,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
@@ -1241,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;
 /**
@@ -1743,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. */
@@ -1830,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
@@ -1991,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.
    */
@@ -2290,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
@@ -2306,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;
@@ -2665,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) | {
@@ -2788,27 +3107,46 @@ 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;
   /**
    * The value the node inherits for an environment key: what the
    * nearest provider above it supplies, else the key's default.
+   *
+   * `of` reads another node's instead, for a node whose environment
+   * belongs somewhere else: an overlay's content keeps the theme of
+   * the place it was declared, not of the layer it is drawn in.
    */
-  environment<T>(key: UiEnvironmentKey<T>): T;
+  environment<T>(key: UiEnvironmentKey<T>, of?: UiNode): T;
   /**
    * Called after the node's inherited environment changed — a theme
    * provider above it swapping palettes, or the node being mounted
    * into a tree that provides one. Removed on detach.
    *
+   * `of` follows another node's environment instead, as `environment`
+   * reads it; the listener is still removed when this node's modifier
+   * detaches.
+   *
    * Register this only when the modifier holds a value it read out of
    * the environment. A colour does not need it: a `UiColorValue` may
    * name a palette entry, which resolves at paint against whatever the
    * node inherits, which is why `focusRing` has no environment access
    * at all.
    */
-  onEnvironment(listener: () => void): void;
-  /** Moves keyboard focus to the node, if it can take it. */
-  focus(): void;
+  onEnvironment(listener: () => void, of?: UiNode): 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;
   /**
@@ -2965,7 +3303,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. */
@@ -3033,33 +3371,121 @@ 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`. */
-  readonly changes: Observable<Size>;
-}
-/**
+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>;
+}
+/**
  * A container size nothing has measured yet.
  *
  * The default for the environment key, so a component that reads the
@@ -3249,24 +3675,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.
  */
@@ -3275,6 +3705,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
 /**
@@ -3795,6 +4253,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.
@@ -3845,6 +4315,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;
@@ -3886,7 +4366,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;
 /**
@@ -4140,6 +4634,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.
@@ -5219,6 +5718,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;
@@ -5230,6 +5749,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;
   /**
@@ -5272,6 +5794,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. */
@@ -5284,8 +5822,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
@@ -5359,9 +5906,17 @@ 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';
+/**
+ * What a field offers as it's typed into: a list of suggestions to pick
+ * from (`list`), the rest of the word filled in after the caret
+ * (`inline`), or both. See `aria-autocomplete`.
+ */
+type UiAutocomplete = 'list' | 'inline' | 'both';
 declare const UI_ROLES: readonly UiRole[];
 declare function isUiRole(value: unknown): value is UiRole;
 /**
@@ -5372,7 +5927,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;
 /**
@@ -5657,6 +6224,19 @@ declare const UiProperties: {
     readonly x: number;
     readonly y: number;
   } | undefined>;
+  /**
+   * The part of the anchor to be placed beside, in the anchor's own
+   * coordinates (from its border box's top left): a character in a
+   * field, the word being typed. The node is placed against that
+   * rectangle as it would be against the whole anchor, and follows the
+   * anchor through scrolling in the same way. Ignored without `anchor`.
+   */
+  readonly anchorRect: UiPropertyDefinition<{
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  } | undefined>;
   /** Gap between an anchored node and its anchor. */
   readonly anchorOffset: UiPropertyDefinition<number | undefined>;
   /**
@@ -5778,6 +6358,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>;
@@ -5806,6 +6392,26 @@ 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>;
+  /**
+   * The node this one shows or changes: the list a combobox's field
+   * opens, the panel a tab switches to. The node should be a record of
+   * its own (a `listbox`, a `tabpanel`); see `aria-controls`.
+   */
+  readonly controls: UiPropertyDefinition<UiNode | null | undefined>;
+  /**
+   * What a field offers as it's typed into: `list` for a combobox whose
+   * list suggests, `inline` for a field that fills in the rest of the
+   * word, `both`. See `aria-autocomplete`.
+   */
+  readonly autocomplete: UiPropertyDefinition<UiAutocomplete | 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
@@ -6063,20 +6669,20 @@ type BoxModelProps = PropsOf<'width' | 'height' | 'minWidth' | 'maxWidth' | 'min
 type FlexItemProps = PropsOf<'flex' | 'flexGrow' | 'flexShrink' | 'flexBasis' | 'selfX' | 'selfY' | 'layoutData'>;
 /** Where an element sits in a Grid. */
 type GridItemProps = PropsOf<'column' | 'columnSpan' | 'row' | 'rowSpan'>;
-type PositionProps = PropsOf<'position' | 'top' | 'right' | 'bottom' | 'left' | 'inset' | 'zIndex' | 'lift' | 'liftBoundary' | 'anchor' | 'anchorPoint' | 'placement' | 'anchorOffset'>;
+type PositionProps = PropsOf<'position' | 'top' | 'right' | 'bottom' | 'left' | 'inset' | 'zIndex' | 'lift' | 'liftBoundary' | 'anchor' | 'anchorPoint' | 'anchorRect' | 'placement' | 'anchorOffset'>;
 type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColor' | 'borderWidth' | 'borderRadius' | 'opacity' | 'boxShadows' | 'visible' | 'transform'>;
 /**
  * Inherited text properties. Legal on any element: set on a container,
  * 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' | 'controls' | 'autocomplete'>;
 /** Environment values an element provides to its subtree. */
 type EnvironmentProps = PropsOf<'theme' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets'>;
 /**
@@ -6370,6 +6976,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.
@@ -6695,6 +7313,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.
    *
@@ -7043,7 +7667,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
@@ -7218,6 +7844,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;
@@ -7276,7 +7908,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
@@ -7360,6 +7992,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;
   /**
@@ -7368,7 +8002,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[];
 }
 /**
@@ -7533,7 +8170,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;
@@ -7593,6 +8235,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;
@@ -7814,6 +8460,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
@@ -8008,13 +8663,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[];
 }
@@ -8790,351 +9459,145 @@ declare class UiFindController {
   /** 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.
+  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
 /**
@@ -9578,6 +10041,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.
@@ -9587,7 +10052,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.
    *
@@ -9599,7 +10084,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.
@@ -9662,6 +10152,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.
    *
@@ -9675,6 +10198,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 {
@@ -9730,7 +10260,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;
   };
@@ -9807,6 +10342,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;
@@ -10031,7 +10568,7 @@ interface UiShortcutStep {
 /** What an application registers. */
 interface UiShortcut {
   /**
-   * The keys, as `'Mod+K'`, `'Shift+?'`, or `'g d'` for a chord: a
+   * The keys, as `'Mod+K'`, `'?'`, or `'g d'` for a chord: a
    * sequence of presses, separated by spaces, that must arrive in
    * order and within the chord timeout.
    */
@@ -10115,6 +10652,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;
@@ -10151,16 +10694,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;
 }
@@ -10173,14 +10721,31 @@ declare class UiShortcutRegistry {
  */
 declare function parseShortcut(keys: string): readonly UiShortcutStep[];
 /**
- * The shortcut as a palette should print it.
+ * 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[], platform?: EditingPlatform): string;
+/**
+ * The keys of each press, one string per key, for a help sheet that
+ * draws them as key caps: `[['⇧', '⌘', 'K']]` on a Mac and
+ * `[['Ctrl', 'Shift', 'K']]` elsewhere, and a chord is one array per
+ * press. They are the pieces `formatShortcut` joins, so a sheet and a
+ * palette print the same keys.
+ */
+declare function shortcutKeyCaps(steps: readonly UiShortcutStep[], platform?: EditingPlatform): readonly (readonly string[])[];
+/**
+ * The shortcut as a screen reader should say it: `Command Shift K` on a
+ * Mac and `Control Shift K` elsewhere, `Down arrow`, `Question mark`,
+ * and `g then d` for a chord.
  *
- * `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.
+ * A key cap's `⌘` or `↓` is read out inconsistently or not at all, and
+ * punctuation is skipped at a screen reader's default verbosity, so a
+ * row that shows caps takes this as its name.
  */
-declare function formatShortcut(steps: readonly UiShortcutStep[]): string;
+declare function describeShortcut(steps: readonly UiShortcutStep[], platform?: EditingPlatform): string;
 //#endregion
 //#region src/input/UiDragSession.d.ts
 /**
@@ -10236,6 +10801,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 {
@@ -10323,6 +10899,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. */
@@ -10347,6 +10925,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.
    *
@@ -10532,6 +11112,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. */
@@ -10570,6 +11156,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;
@@ -10584,6 +11199,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
@@ -10615,7 +11235,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;
@@ -10629,7 +11249,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. */
@@ -10668,6 +11310,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
@@ -10702,9 +11387,13 @@ declare class UiEditingController {
    * a second measurer that must never disagree with this one. Asking
    * is the only version that stays right.
    *
+   * `offset` asks where a caret at another character would be: where
+   * the word being typed began, for a list that stays under its start.
+   * It is clamped to the text.
+   *
    * Null when the node is not an editable, or has not been laid out.
    */
-  caretRectOf(node: UiNode): CaretRect | null;
+  caretRectOf(node: UiNode, offset?: number): CaretRect | null;
   private layoutOf;
 }
 //#endregion
@@ -11340,6 +12029,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;
@@ -11512,30 +12211,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;
   /**
@@ -11570,6 +12245,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. */
@@ -12026,6 +12709,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
@@ -12340,6 +13032,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
@@ -13011,8 +13743,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 {
@@ -14316,6 +15057,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.
@@ -14352,9 +15096,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>;
@@ -14838,7 +15588,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)
@@ -14870,6 +15622,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.
    *
@@ -14963,6 +15717,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;
   /**
@@ -16373,13 +17146,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:
@@ -16415,7 +17199,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. */
@@ -17278,6 +18066,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`).
@@ -17322,6 +18127,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
@@ -17412,6 +18219,12 @@ 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;
+  /** The record id of what this one shows or changes, such as the list a combobox opens. */
+  readonly controls?: string;
+  /** What a field offers as it's typed into. */
+  readonly autocomplete?: UiAutocomplete;
 }
 /** Insertion-ordered: iterating the map walks the tree in document order. */
 type UiSemanticsMap = ReadonlyMap<string, UiSemanticsRecord>;
@@ -17434,7 +18247,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.
  *
@@ -17455,7 +18290,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.
@@ -17487,6 +18372,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';
@@ -17507,6 +18397,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
@@ -17566,5 +18474,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp3Header as $, UiPointerController as $a, ScrollView as $c, paintValuesEqual as $d, UiModifierLayout as $f, UiTransform as $h, formatConstraints as $i, validateStates as $l, validateSubgrid as $m, DefaultVideoResolver as $n, EnvironmentNotifier as $o, resolveMotionState as $p, decorated as $r, clearSelectionRange as $s, PaintResolver as $t, defaultSpacing as $u, MARK_PREFIX as A, EditingState as Aa, selectionRects as Ac, UiTextLink as Ad, repeat as Af, normalizeTransition as Ah, parseAlignContent as Ai, RowProps as Al, UI_SUBGRID_AXES as Am, resolveNumber as An, UiPoint as Ao, UiKeyboardEvent as Ap, shortcuts as Ar, textRunBackgrounds as As, WebGPUTextureCache as At, UiTheme as Au, ByteSource as B, UiDroppedFile as Ba, ResponsiveProps as Bc, textContentOf as Bd, UiInsetRegistry as Bf, UiTweenOptions as Bh, SCROLLBAR_FADE_MS as Bi, UiPropertyValueOf as Bl, UiObjectFit as Bm, publishInset as Bn, scrollbarThumbs as Bo, noKeyModifiers as Bp, reorderable as Br, PaintTextSpan as Bs, WebGPUSurface as Bt, hasThemeExtension as Bu, paragraphGeometry as C, UiPlatformAdapter as Ca, caretRectFor as Cc, UiFontKerning as Cd, fr as Cf, findEnvironmentKey as Ch, GridPlacement as Ci, IdentityProps as Cl, DecorationRect as Cm, OverlayShape as Cn, SelectionControllerOptions as Co, MOUSE_POINTER as Cp, AnimateLayoutOptions as Cr, buildFontString as Cs, glyphCount as Ct, VirtualItemMeasure as Cu, UiFrameCallback as D, touchActionFor as Da, offsetAtPoint as Dc, UiResolvedTextSpan as Dd, isPercentLength as Df, UiTransitionSpec as Dh, AlignContent as Di, PositionProps as Dl, decorationRect as Dm, CanvasSurface as Dn, HitTestResult as Do, UiGestureEvent as Dp, ShortcutsOptions as Dr, layoutTextLines as Ds, GlyphSlot as Dt, UiVideoSurface as Du, wordRangeIn as E, prepareInputSurface as Ea, lineLimit as Ec, UiFontVariant as Ed, isMinMaxTrack as Ef, AnimationDriver as Eh, sizeGridTracks as Ei, PaintProps as El, decorationColor as Em, CanvasHost as En, HitTestLayoutReader as Eo, UiFocusEvent as Ep, ShortcutOptions as Er, fillTextRects as Es, GLYPH_SUBPIXEL_PHASES as Et, lazySource as Eu, setPerformanceMarks as F, UiDragPayload as Fa, nextWordEnd as Fc, editableSpansOf as Fd, boxShadowsEqual as Ff, UiAnimationOptions as Fh, ELLIPSIS as Fi, TypographyProps as Fl, UiCursor as Fm, themeTokens as Fn, ScrollbarAxis as Fo, UiPointerKind as Fp, DragSourceOptions as Fr, DEFAULT_FONT_SIZE as Fs, DrawStats as Ft, withDensity as Fu, Mp4AudioTrack as G, UiShortcutBinding as Ga, LazyRow as Gc, PaintLineCap as Gd, observeViewportInsets as Gf, UiSpringSpec as Gh, Edges as Gi, UiRole as Gl, UiSelfAlignment as Gm, ScrollOffset as Gn, matchRangesOf as Go, MotionChannel as Gp, clickOutside as Gr, createPaintState as Gs, registerFontStack as Gt, UiContrast as Gu, RangeSourceOptions as H, dragSessionFor as Ha, LazyGrid as Hc, textStylesEqual as Hd, UiInsets as Hf, UiDurationToken as Hh, ScrollAdjustment as Hi, UI_ROLES as Hl, UiPlacement as Hm, SizeContainerArgs as Hn, SubtreeBounds as Ho, DirtyNodeSet as Hp, DraggableOptions as Hr, VerticalAlign as Hs, bumpFontStack as Ht, themeExtension as Hu, VttCue as I, UiDragSession as Ia, previousGraphemeStart as Ic, flattenTextSpans as Id, UiPropertyDefinition as If, UiReducedMotionPolicy as Ih, layoutParagraph as Ii, UiEventProps as Il, UiDirection as Im, sameArgs as In, ScrollbarThumb as Io, UiSelectionChangeEvent as Ip, DropTargetOptions as Ir, DEFAULT_FONT_WEIGHT as Is, RenderHooks as It, UiThemeExtension as Iu, demuxMp4Audio as J, formatShortcut as Ja, Column as Jc, PaintTextAlign as Jd, bandOf as Jf, UiInterpolator as Jh, OverrideSources as Ji, isUiRole as Jl, UiTextDirection as Jm, VideoClock as Jn, FindOptions as Jo, MotionTiming as Jp, BordersOptions as Jr, normalizeVerticalAlign as Js, PaintPictureCache as Jt, raiseContrast as Ju, Mp4Sample as K, UiShortcutRegistry as Ka, Box as Kc, PaintLineJoin as Kd, UiContainerSize as Kf, UiSpringToken as Kh, LayoutExplanation as Ki, UiSemanticState as Kl, UiSubgridAxis as Km, ScrollPositionArgs as Kn, setMatchRanges as Ko, MotionState as Kp, autoFocus as Kr, isPaintVisible as Ks, PaintCanvas as Kt, contrastRatio as Ku, VttTrack as L, UiDragState as La, previousWordStart as Lc, resolvedSpansOf as Ld, defineProperty as Lf, UiSpring as Lh, proportionalFontMetrics as Li, UiNodeRef as Ll, UiFlexWrap as Lm, InsetPaddingArgs as Ln, scrollLeaderOf as Lo, UiTextChangeEvent as Lp, ReorderableOptions as Lr, DEFAULT_TEXT_COLOR as Ls, WebGPURenderer as Lt, UiThemeExtensionOptions as Lu, markNow as M, TouchScrollerOptions as Ma, lineEndAt as Mc, UiTextSpan as Md, UiBoxShadow as Mf, tween as Mh, parseMainAxisAlignment as Mi, StackProps as Ml, UiBorderRadiusValue as Mm, resolvePropertyByName as Mn, SCROLLBAR_INSET as Mo, UiPinchEvent as Mp, ZoomState as Mr, Canvas2DContext as Ms, isWebGPUAvailable as Mt, lightTheme as Mu, measureSpan as N, UiTouchScroller as Na, lineStartAt as Nc, UiTextStyle as Nd, boxShadow as Nf, AnimatedCell as Nh, FlexDirection as Ni, TextContentProps as Nl, UiColorValue as Nm, resolveString as Nn, SCROLLBAR_MIN_THUMB as No, UiPointerDevice as Np, pinchable as Nr, Canvas2DGradient as Ns, WebGPUError as Nt, themesEqual as Nu, UiScheduler as O, EditingControllerOptions as Oa, offsetAtX as Oc, UiSpannedText as Od, minmax as Of, UiTransitionValue as Oh, CrossAxisAlignment as Oi, PropsOf as Ol, hasDecorationPhase as Om, createCanvasSurface as On, HitTester as Oo, UiInputEvent as Op, contextMenu as Or, runCanvasStyleInto as Os, GlyphUpload as Ot, isVideoSurface as Ou, performanceMarksEnabled as P, EXTERNAL_FILES as Pa, nextGraphemeEnd as Pc, defaultTextStyle as Pd, boxShadowArraysEqual as Pf, UiAnimation as Ph, parseFlexDirection as Pi, TextProps as Pl, UiContentDistribution as Pm, ThemeTokenTarget as Pn, SCROLLBAR_THICKNESS as Po, UiPointerEvent as Pp, AutoScrollOptions as Pr, DEFAULT_FONT_FAMILY as Ps, CapturedFrame as Pt, withContrast as Pu, Mp3Frames as Q, PointerControllerOptions as Qa, Row as Qc, inputsEqual as Qd, UiModifierFocus as Qf, interpolatorFor as Qh, describeOverrides as Qi, validateRole as Ql, UiVerticalAlign as Qm, videoSource as Qn, UiEnvironmentKeys as Qo, pop as Qp, borders as Qr, TextRange as Qs, PaintGradient as Qt, UiSpacing as Qu, cueAt as R, UiDropEffect as Ra, wordRangeAt as Rc, spanAtOffset as Rd, propertyValuesEqual as Rf, UiSpringOptions as Rh, LayoutNotifier as Ri, UiProperties as Rl, UiFontWeight as Rm, PublishInsetArgs as Rn, scrollRange as Ro, UiWheelDeltaMode as Rp, dragSource as Rr, ObjectFit as Rs, WebGPURendererOptions as Rt, UiThemeExtensions as Ru, offsetAtPointIn as S, PlatformSurface as Sa, RunMeasure as Sc, visualStatesEqual as Sd, auto as Sf, createEnvironmentKey as Sh, GridItemRequest as Si, GridProps as Sl, DecorationFill as Sm, LABEL_PADDING_X as Sn, UiFindController as So, UiListenerErrorReporter as Sp, ImageResolver as Sr, applyCanvasTextStyle as Ss, createTextCache as St, VIRTUAL_WINDOW_PROP as Su, selectionRectsIn as T, pointerDeviceOf as Ta, lineIndexForOffset as Tc, UiFontStyle as Td, isFrLength as Tf, DirtyFlags as Th, placeGridItems as Ti, PaintElementProps as Tl, DecorationStroke as Tm, labelOrigin as Tn, UiSelectionController as To, UiEventType as Tp, ContextMenuOptions as Tr, drawText as Ts, GlyphShaper as Tt, VirtualViewport as Tu, bufferSource as U, ShortcutRegistryOptions as Ua, LazyGridProps as Uc, PaintBox as Ud, insetsEqual as Uf, UiEasingToken as Uh, AxisExplanation as Ui, UI_SEMANTIC_STATES as Ul, UiPointerEvents as Um, breakpoint as Un, TEXT_MATCHES_PROP as Uo, MOTION_CHANNELS as Up, draggable as Ur, colorToCss as Us, clearFontStacks as Ut, themeExtensionsEqual as Uu, DEFAULT_BLOCK_SIZE as V, UiFileDropMessage as Va, LazyColumn as Vc, textSpansEqual as Vd, UiInsetSource as Vf, createTween as Vh, SCROLLBAR_LINGER_MS as Vi, UiPropertyValues as Vl, UiOverflow as Vm, BreakpointArgs as Vn, scrollbarZoneAt as Vo, wheelDeltaYOf as Vp, DragOffset as Vr, TextAlign as Vs, createWebGPUSurface as Vt, noThemeExtensions as Vu, rangeSource as W, UiShortcut as Wa, LazyListProps as Wc, PaintFillRule as Wd, noInsets as Wf, UiMotion as Wh, CustomLayoutExplanation as Wi, UiLiveRegion as Wl, UiPosition as Wm, sizeContainer as Wn, clearMatchRanges as Wo, MOTION_REST as Wp, ClickOutsideOptions as Wr, computeObjectFitRect as Ws, fontStackFor as Wt, withThemeExtension as Wu, Mp3Format as X, KeyboardControllerOptions as Xa, Grid as Xc, UiPaint as Xd, unknownContainerSize as Xf, interpolateNumber as Xh, SizeDecision as Xi, normalizeStates as Xl, UiTextWrapValue as Xm, VideoState as Xn, UiEnvironmentProvider as Xo, fade as Xp, FocusRingOptions as Xr, DEFAULT_LINE_HEIGHT_FACTOR as Xs, paintPictures as Xt, UiDensity as Xu, demuxMp4Video as Y, parseShortcut as Ya, EditableText as Yc, PaintTextStyle as Yd, containerBands as Yf, interpolateColor as Yh, RelayoutExplanation as Yi, isUiSemanticState as Yl, UiTextOverflowValue as Ym, VideoSourceArgs as Yn, findMatchesIn as Yo, ResolvedMotionState as Yp, Decorations as Yr, resolvePaintState as Ys, PaintStats as Yt, relativeLuminance as Yu, Mp3Frame as Z, UiKeyboardController as Za, Paint as Zc, UiPath as Zd, UiModifierEnvironment as Zf, interpolateTransform as Zh, describeLength as Zi, statesEqual as Zl, UiThemeColorName as Zm, VideoTransport as Zn, provideEnvironment as Zo, isMotionRest as Zp, borderShapes as Zr, TEXT_SELECTION_PROP as Zs, PaintContext2D as Zt, densityFactors as Zu, linkOf as _, isNodeTabStop as _a, TextRunStyle as _c, UiVisualState as _d, FrLength as _f, easings as _g, darkColors as _h, inheritedPropertyNames as _i, EditableTextProps as _l, NodeProperty as _m, RendererBackend as _n, overrideSources as _o, UiPropValue as _p, IconRasterizerOptions as _r, CanvasTextStyle as _s, ScissorRect as _t, LazyListOptions as _u, diffSemantics as a, UiFrameClock as aa, FixedMetricsOptions as ac, shadowsEqual as ad, ResolvedGradientStop as af, UiBasicColors as ag, borderRadiusIsZero as ah, measure as ai, UiBinding as al, SharedClaim as am, PaintRecording as an, isScrollContainer as ao, defineModifier as ap, MotionArgs as ar, editorOf as as, CLIP_STRIDE_FLOATS as at, SheetHeaderRenderer as au, ParagraphGeometry as b, PlatformAdapterOptions as ba, CaretRect as bc, hasVisualState as bd, UiLength as bf, UiEnvironment as bh, propertyValuesEqualByName as bi, FlexItemProps as bl, UiPropertyOverride as bm, RenderChanges as bn, writeOverrideProperty as bo, UiEventListenerOptions as bp, DefaultImageResolver as br, TextLinePlacement as bs, TextRunDraw as bt, VIRTUAL_INDEX_PROP as bu, UiSemanticsMap as c, UiHostFrameClock as ca, ParagraphTextMeasurer as cc, UiTypographyRole as cd, UiGradientStop as cf, colorToRgba as cg, uniformBorderRadius as ch, bundle as ci, ChildrenBindingId as cl, LayoutBox as cm, InspectorOverlay as cn, UiGestureRecognizer as co, UiModifierTeardown as cp, sharedElement as cr, isReadOnly as cs, INSTANCE_STRIDE_BYTES as ct, SheetSourceArgs as cu, buildSemanticsTree as d, UiTimerFrameClock as da, TextLineRun as dc, typographyEqual as dd, gradientPaint as df, normalizeColor as dg, UiShapes as dh, accumulatedOffsetTo as di, BoxModelProps as dl, Size as dm, CanvasTextMeasurer as dn, FocusNotifier as do, UiChild as dp, ImageSources as dr, EditCommand as ds, NO_CLIP_INDEX as dt, UiVirtualSheetOptions as du, formatExplanation as ea, selectableTextNodes as ec, scaleSpacing as ed, pathValuesEqual as ef, UiTransforms as eg, UiBorderRadius as eh, focusRing as ei, Stack as el, rotateFrom as em, PaintTarget as en, ScrollContainerState as eo, UiModifierSet as ep, DefaultVideoResolverOptions as er, CARET_BLINK_MS as es, readMp3Header as et, CompositionRange as eu, semanticsInertAbove as f, UiTimerFrameClockOptions as fa, TextMeasureRequest as fc, MAX_MEASURES_PER_CHILD as fd, gradientsEqual as ff, parseColor as fg, defaultShapes as fh, contentOffset as fi, BoxProps as fl, TightenOptions as fm, Canvas2DRenderer as fn, FocusSource as fo, UiElement as fp, iconSource as fr, EditingPlatform as fs, PrimitiveCommand as ft, VIRTUAL_SHEET_PROP as fu, linkHoverOf as g, isNodeSelectable as ga, TextRunSpan as gc, isLayoutProtocol as gd, AutoLength as gf, cubicBezier as gg, colorsEqualPalette as gh, inheritedPropertyFlags as gi, ContainerProps as gl, NodeId as gm, ScrollLayerStats as gn, clearOverrideProperty as go, isUiElement as gp, IconRasterizer as gr, EditableLayout as gs, RenderTextCache as gt, LazyItemRenderer as gu, hasTextLinks as h, isNodeInert as ha, TextRunMeasurer as hc, UiLayoutProtocol as hd, validateGradient as hf, UiEasing as hg, UiColors as hh, getPropertyNames as hi, CommonProps as hl, tightenConstraints as hm, LayerCanvasFactory as hn, resetTransitionWarnings as ho, isUiChild as hp, IconContext as hr, isPrintable as hs, RenderList as ht, LazyGridOptions as hu, UiSemanticsPatch as i, UiAnimationFrameClock as ia, CharacterCountTextMeasurer as ic, defaultShadows as id, ResolvedGradient as if, transformsEqual as ig, borderRadiusEqual as ih, interactive as ii, BindingId as il, slideUp as im, PaintRecorder as in, UiWheelController as io, UiModifierKind as ip, canDecodeVideo as ir, editorFor as is, CLIP_STRIDE_BYTES as it, LazySheetProps as iu, markInstant as j, UiEditingController as ja, graphemeBoundaries as jc, UiTextMetrics as jd, resolveLength as jf, spring as jh, parseCrossAxisAlignment as ji, ScrollViewProps as jl, UiAlignment as jm, resolveProperty as jn, SCROLLBAR_HOVER_ZONE as jo, UiPasteEvent as jp, PinchableOptions as jr, textRunDecorations as js, initializeWebGPU as jt, darkTheme as ju, UiSchedulerOptions as k, EditingHost as ka, offsetForVerticalMove as kc, UiTextDecoration as kd, percent as kf, assertTransitionMap as kh, MainAxisAlignment as ki, Reactive as kl, paintsAfterChildren as km, resolveBoolean as kn, UiHitTester as ko, UiKeyModifiers as kp, shortcut as kr, runFontString as ks, WebGPUGlyphAtlas as kt, videoFrameSize as ku, UiSemanticsRecord as l, UiHostFrameClockOptions as la, SpannedRuns as lc, defaultTypography as ld, UiLinearGradient as lf, colorValuesEqual as lg, UiShapeExtensions as lh, noModifiers as li, UiChildrenBinding as ll, LayoutResult as lm, LayoutInspector as ln, PinchRecognizerOptions as lo, ComponentResolver as lp, IconSourceArgs as lr, nextCaretToggle as ls, INSTANCE_STRIDE_FLOATS as lt, SheetViewport as lu, clearLinkHover as m, isNodeHitTestable as ma, TextOverflow as mc, UiLayoutContext as md, radialGradient as mf, rgba as mg, shapesEqual as mh, findPropertyDefinition as mi, ColumnProps as ml, constraintsEqual as mm, traceRoundedRect as mn, NodeTransitions as mo, isObservable$1 as mp, IconCanvas as mr, detectEditingPlatform as ms, RenderCommand as mt, LazyAxis as mu, UiSemanticsBox as n, withOverrideSource as na, selectionRangeOf as nc, spacingSteps as nd, GradientPaint as nf, transform as ng, borderRadius as nh, InteractiveOptions as ni, createElement as nl, slideDown as nm, EMPTY_RECORDING as nn, UiScrollBehavior as no, assertModifierList as np, VideoPlayback as nr, EDITOR_PROP as ns, WebGPUGlyphPages as nt, EditableTextModel as nu, recordsEqual as o, UiFrameClockFactory as oa, FontMetrics as oc, UiTypography as od, UiGradient as of, UiColor as og, borderRadiusValuesEqual as oh, pressable as oi, UiGraph as ol, UiSharedElements as om, replayPaint as on, GestureInput as oo, isUiModifier as op, SharedElementArgs as or, isEditableNode as os, CommandKind as ot, SheetRange as ou, textRunOfRecordId as p, isNodeFocusable as pa, TextMeasurer as pc, UiLayoutChild as pd, linearGradient as pf, rgb8 as pg, isShapeName as ph, closestPropertyName as pi, ButtonProps as pl, clampSize as pm, Canvas2DRendererOptions as pn, UiFocusManager as po, isComponentLikeElement as pp, imageSource as pr, commandForKey as ps, PrimitiveKind as pt, sheetSource as pu, Mp4VideoTrack as q, UiShortcutStep as qa, Button as qc, PaintSurface as qd, UiContainerSizeSource as qf, defaultMotion as qh, LayoutStateExplanation as qi, UiSemanticStates as ql, UiTextAlign as qm, scrollPosition as qn, FindMatch as qo, MotionStateInput as qp, BorderEdge as qr, normalizeTextAlign as qs, PaintCanvasFactory as qt, highContrastColors as qu, UiSemanticsUpdate as r, UiFrame as ra, setSelectionRange as rc, UiShadows as rd, MAX_GRADIENT_STOPS as rf, transformIsIdentity as rg, borderRadiusCorners as rh, hoverable as ri, UiDefinition as rl, slideFrom as rm, PaintOp as rn, UiScrollability as ro, UiModifier as rp, VideoResolver as rr, caretVisibleAt as rs, Affine as rt, LazySheet as ru, TEXT_RUN_ID_SEPARATOR as s, UiFrameTime as sa, ParagraphLayout as sc, UiTypographyExtensions as sd, UiGradientOffset as sf, colorToHex as sg, normalizeBorderRadius as sh, UiModifierBundle as si, UiEventBinding as sl, Constraints as sm, INSPECTOR_HEAT_MS as sn, GestureRecognizerOptions as so, UiModifierHost as sp, motion as sr, isMultiline as ss, GlyphCommand as st, SheetRowRenderer as su, UiSemanticsAction as t, labelNode as ta, selectableTextOf as tc, spacingEqual as td, UiImage as tf, parseTransform as tg, UiBorderRadiuses as th, BUTTON_INTERACTION as ti, Text as tl, scaleFrom as tm, tracePathData as tn, ScrollSink as to, UiUnknownModifierPropertyError as tp, RangeResponse as tr, CARET_WIDTH as ts, splitMp3Frames as tt, EditUnit as tu, buildSemanticsSubtree as u, UiManualFrameClock as ua, TextLine as uc, isTypographyRole as ud, UiRadialGradient as uf, colorsEqual as ug, UiShapeName as uh, Transform as ui, UiGraphBuilder as ul, LayoutStats as um, LayoutInspectorOptions as un, UiPinchRecognizer as uo, ComponentLikeElement as up, ImageSourceArgs as ur, syncEditorValue as us, ImageCommand as ut, UiVirtualSheet as uu, linkRunAtPointIn as v, resolveCursor as va, TextWrap as vc, UiVisualStateSet as vd, MinMaxTrack as vf, linear as vg, lightColors as vh, propertyEffects as vi, EnvironmentProps as vl, UiNode as vm, UiRenderer as vn, resetOverrideWarnings as vo, UiProps as vp, IconSpec as vr, PlacedTextRun as vs, TEXTURED_STRIDE_BYTES as vt, LazySourceArgs as vu, paragraphGeometryFrom as w, capturePointer as wa, lineIndexAtY as wc, UiFontStretch as wd, isAutoLength as wf, UiNodeType as wh, GridTrack as wi, InteractionProps as wl, DecorationShape as wm, drawOverlayShapes as wn, SelectionHost as wo, UiBeforeInputEvent as wp, animateLayout as wr, createCanvasTextStyle as ws, textRuns as wt, VirtualUpdate as wu, hasDrawnText as x, PlatformEventTarget as xa, PlacedLine as xc, visualState as xd, UiTrackSize as xf, UiEnvironmentKey as xh, GridContribution as xi, GridItemProps as xl, UiPropertyOverrides as xm, RenderContext as xn, FindHost as xo, UiInputDispatcher as xp, DefaultImageResolverOptions as xr, TextRunRect as xs, buildRenderList as xt, VIRTUAL_LEAD_PROP as xu, setLinkHover as y, CanvasPlatformSurface as ya, spannedRunsFor as yc, defaultVisualState as yd, PercentLength as yf, steps as yg, LayoutRecord as yh, propertyIsInherited as yi, FlexContainerProps as yl, UiNodeTransitions as ym, LayoutReader as yn, writeDeclaredProperty as yo, UiEventListener as yp, iconKey as yr, SpanPaint as ys, TEXTURED_STRIDE_FLOATS as yt, UiVirtualWindow as yu, parseWebVtt as z, UiDropZone as za, Responsive as zc, spannedTextOf as zd, UiInsetEdge as zf, UiTween as zh, LayoutEngine as zi, UiPropertyName as zl, UiGridAutoFlow as zm, insetPadding as zn, scrollbarThumb as zo, UiWheelEvent as zp, dropTarget as zr, PaintState as zs, WebGPUCanvasHost as zt, defineThemeExtension as zu };
-//# sourceMappingURL=index-BiN3WdTh.d.ts.map
+export { Mp4AudioTrack as $, UiShortcutBinding as $a, LazyListProps as $c, textSpansEqual as $d, propertyValuesEqual as $f, UiTransitionValue as $h, Edges as $i, UiAutocomplete as $l, hasDecorationPhase as $m, ScrollOffset as $n, matchRangesOf as $o, UiInputEvent as $p, clickOutside as $r, computeObjectFitRect as $s, registerFontStack as $t, themeExtensionsEqual as $u, offsetAtPointIn as A, PlatformSurface as Aa, PlacedLine as Ac, hasVisualState as Ad, MinMaxTrack as Af, UiBasicColors as Ag, borderRadiusIsZero as Ah, GridItemRequest as Ai, GridItemProps as Al, SharedClaim as Am, LABEL_PADDING_X as An, UiFindController as Ao, UiModifierTeardown as Ap, ImageResolver as Ar, applyCanvasTextStyle as As, createTextCache as At, VIRTUAL_INDEX_PROP as Au, markNow as B, TouchScrollerOptions as Ba, graphemeBoundaries as Bc, UiTextLink as Bd, minmax as Bf, UiEasing as Bg, UiColors as Bh, parseMainAxisAlignment as Bi, ScrollViewProps as Bl, tightenConstraints as Bm, resolvePropertyByName as Bn, SCROLLBAR_INSET as Bo, isUiChild as Bp, ZoomState as Br, Canvas2DContext as Bs, isWebGPUAvailable as Bt, UiTheme as Bu, hasTextLinks as C, isNodeInert as Ca, TextOverflow as Cc, UiLayoutChild as Cd, gradientPaint as Cf, interpolatorFor as Cg, UiVerticalAlign as Ch, getPropertyNames as Ci, ColumnProps as Cl, pop as Cm, LayerCanvasFactory as Cn, resetTransitionWarnings as Co, UiUnknownModifierPropertyError as Cp, IconContext as Cr, isPrintable as Cs, RenderList as Ct, sheetSource as Cu, setLinkHover as D, CanvasPlatformSurface as Da, TextWrap as Dc, UiVisualState as Dd, validateGradient as Df, transform as Dg, borderRadius as Dh, propertyIsInherited as Di, EnvironmentProps as Dl, slideDown as Dm, LayoutReader as Dn, writeDeclaredProperty as Do, defineModifier as Dp, iconKey as Dr, SpanPaint as Ds, TEXTURED_STRIDE_FLOATS as Dt, LazyListOptions as Du, linkRunAtPointIn as E, resolveCursor as Ea, TextRunStyle as Ec, isLayoutProtocol as Ed, radialGradient as Ef, parseTransform as Eg, UiBorderRadiuses as Eh, propertyEffects as Ei, EditableTextProps as El, scaleFrom as Em, UiRenderer as En, resetOverrideWarnings as Eo, UiModifierKind as Ep, IconSpec as Er, PlacedTextRun as Es, TEXTURED_STRIDE_BYTES as Et, LazyItemRenderer as Eu, UiFrameCallback as F, touchActionFor as Fa, lineLimit as Fc, UiFontStyle as Fd, fr as Ff, colorsEqual as Fg, UiShapeName as Fh, AlignContent as Fi, PaintProps as Fl, LayoutStats as Fm, CanvasSurface as Fn, HitTestResult as Fo, ComponentLikeElement as Fp, ShortcutsOptions as Fr, layoutTextLines as Fs, GlyphSlot as Ft, VirtualViewport as Fu, VttTrack as G, UiDragState as Ga, previousGraphemeStart as Gc, defaultTextStyle as Gd, UiBoxShadow as Gf, UiEnvironment as Gh, proportionalFontMetrics as Gi, UiEventProps as Gl, UiPropertyOverride as Gm, InsetPaddingArgs as Gn, scrollLeaderOf as Go, UiEventListenerOptions as Gp, ReorderableOptions as Gr, DEFAULT_TEXT_COLOR as Gs, WebGPURenderer as Gt, withDensity as Gu, performanceMarksEnabled as H, EXTERNAL_FILES as Ha, lineStartAt as Hc, UiTextRange as Hd, repeat as Hf, easings as Hg, darkColors as Hh, parseFlexDirection as Hi, TextContentProps as Hl, NodeProperty as Hm, ThemeTokenTarget as Hn, SCROLLBAR_THICKNESS as Ho, UiPropValue as Hp, AutoScrollOptions as Hr, DEFAULT_FONT_FAMILY as Hs, CapturedFrame as Ht, lightTheme as Hu, UiScheduler as I, EditingControllerOptions as Ia, offsetAtPoint as Ic, UiFontVariant as Id, isAutoLength as If, normalizeColor as Ig, UiShapes as Ih, CrossAxisAlignment as Ii, PositionProps as Il, Size as Im, createCanvasSurface as In, HitTester as Io, UiChild as Ip, contextMenu as Ir, runCanvasStyleInto as Is, GlyphUpload as It, lazySource as Iu, ByteSource as J, UiDroppedFile as Ja, Responsive as Jc, hiddenRangesOf as Jd, boxShadowRadius as Jf, findEnvironmentKey as Jh, SCROLLBAR_FADE_MS as Ji, UiPropertyName as Jl, DecorationRect as Jm, publishInset as Jn, scrollbarThumbs as Jo, MOUSE_POINTER as Jp, reorderable as Jr, PaintState as Js, WebGPUSurface as Jt, UiThemeExtensions as Ju, cueAt as K, UiDropEffect as Ka, previousWordStart as Kc, editableSpansOf as Kd, boxShadow as Kf, UiEnvironmentKey as Kh, LayoutNotifier as Ki, UiNodeRef as Kl, UiPropertyOverrides as Km, PublishInsetArgs as Kn, scrollRange as Ko, UiInputDispatcher as Kp, dragSource as Kr, ObjectFit as Ks, WebGPURendererOptions as Kt, UiThemeExtension as Ku, UiSchedulerOptions as L, EditingHost as La, offsetAtX as Lc, UiResolvedTextSpan as Ld, isFrLength as Lf, parseColor as Lg, defaultShapes as Lh, MainAxisAlignment as Li, PropsOf as Ll, TightenOptions as Lm, resolveBoolean as Ln, UiHitTester as Lo, UiElement as Lp, shortcut as Lr, runFontString as Ls, WebGPUGlyphAtlas as Lt, UiVideoSurface as Lu, paragraphGeometryFrom as M, capturePointer as Ma, caretRectFor as Mc, visualStatesEqual as Md, UiLength as Mf, colorToHex as Mg, normalizeBorderRadius as Mh, GridTrack as Mi, IdentityProps as Ml, Constraints as Mm, drawOverlayShapes as Mn, SelectionHost as Mo, FocusSource as Mp, animateLayout as Mr, createCanvasTextStyle as Ms, textRuns as Mt, VIRTUAL_WINDOW_PROP as Mu, selectionRectsIn as N, pointerDeviceOf as Na, lineIndexAtY as Nc, UiFontKerning as Nd, UiTrackSize as Nf, colorToRgba as Ng, uniformBorderRadius as Nh, placeGridItems as Ni, InteractionProps as Nl, LayoutBox as Nm, labelOrigin as Nn, UiSelectionController as No, UiFocusManager as Np, ContextMenuOptions as Nr, drawText as Ns, GlyphShaper as Nt, VirtualItemMeasure as Nu, ParagraphGeometry as O, PlatformAdapterOptions as Oa, spannedRunsFor as Oc, UiVisualStateSet as Od, AutoLength as Of, transformIsIdentity as Og, borderRadiusCorners as Oh, propertyValuesEqualByName as Oi, FlexContainerProps as Ol, slideFrom as Om, RenderChanges as On, writeOverrideProperty as Oo, isUiModifier as Op, DefaultImageResolver as Or, TextLinePlacement as Os, TextRunDraw as Ot, LazySourceArgs as Ou, wordRangeIn as P, prepareInputSurface as Pa, lineIndexForOffset as Pc, UiFontStretch as Pd, auto as Pf, colorValuesEqual as Pg, UiShapeExtensions as Ph, sizeGridTracks as Pi, PaintElementProps as Pl, LayoutResult as Pm, CanvasHost as Pn, HitTestLayoutReader as Po, ComponentResolver as Pp, ShortcutOptions as Pr, fillTextRects as Ps, GLYPH_SUBPIXEL_PHASES as Pt, VirtualUpdate as Pu, rangeSource as Q, UiShortcut as Qa, LazyGridProps as Qc, textContentOf as Qd, defineProperty as Qf, UiTransitionSpec as Qh, CustomLayoutExplanation as Qi, UI_SEMANTIC_STATES as Ql, decorationRect as Qm, sizeContainer as Qn, clearMatchRanges as Qo, UiGestureEvent as Qp, ClickOutsideOptions as Qr, colorToCss as Qs, fontStackFor as Qt, themeExtension as Qu, MARK_PREFIX as R, EditingState as Ra, offsetForVerticalMove as Rc, UiSpannedText as Rd, isMinMaxTrack as Rf, rgb8 as Rg, isShapeName as Rh, parseAlignContent as Ri, Reactive as Rl, clampSize as Rm, resolveNumber as Rn, UiPoint as Ro, isComponentLikeElement as Rp, shortcuts as Rr, textRunBackgrounds as Rs, WebGPUTextureCache as Rt, isVideoSurface as Ru, clearLinkHover as S, isNodeHitTestable as Sa, TextMeasurer as Sc, MAX_MEASURES_PER_CHILD as Sd, UiRadialGradient as Sf, interpolateTransform as Sg, UiThemeColorName as Sh, findPropertyDefinition as Si, ButtonProps as Sl, isMotionRest as Sm, traceRoundedRect as Sn, NodeTransitions as So, UiModifierSet as Sp, IconCanvas as Sr, detectEditingPlatform as Ss, RenderCommand as St, VIRTUAL_SHEET_PROP as Su, linkOf as T, isNodeTabStop as Ta, TextRunSpan as Tc, UiLayoutProtocol as Td, linearGradient as Tf, UiTransforms as Tg, UiBorderRadius as Th, inheritedPropertyNames as Ti, ContainerProps as Tl, rotateFrom as Tm, RendererBackend as Tn, overrideSources as To, UiModifier as Tp, IconRasterizerOptions as Tr, CanvasTextStyle as Ts, ScissorRect as Tt, LazyGridOptions as Tu, setPerformanceMarks as U, UiDragPayload as Ua, nextGraphemeEnd as Uc, UiTextSpan as Ud, resolveLength as Uf, linear as Ug, lightColors as Uh, ELLIPSIS as Ui, TextProps as Ul, UiNode as Um, themeTokens as Un, ScrollbarAxis as Uo, UiProps as Up, DragSourceOptions as Ur, DEFAULT_FONT_SIZE as Us, DrawStats as Ut, themesEqual as Uu, measureSpan as V, UiTouchScroller as Va, lineEndAt as Vc, UiTextMetrics as Vd, percent as Vf, cubicBezier as Vg, colorsEqualPalette as Vh, FlexDirection as Vi, StackProps as Vl, NodeId as Vm, resolveString as Vn, SCROLLBAR_MIN_THUMB as Vo, isUiElement as Vp, pinchable as Vr, Canvas2DGradient as Vs, WebGPUError as Vt, darkTheme as Vu, VttCue as W, UiDragSession as Wa, nextWordEnd as Wc, UiTextStyle as Wd, BOX_SHADOW_BLUR_REACH as Wf, steps as Wg, LayoutRecord as Wh, layoutParagraph as Wi, TypographyProps as Wl, UiNodeTransitions as Wm, sameArgs as Wn, ScrollbarThumb as Wo, UiEventListener as Wp, DropTargetOptions as Wr, DEFAULT_FONT_WEIGHT as Ws, RenderHooks as Wt, withContrast as Wu, RangeSourceOptions as X, dragSessionFor as Xa, LazyColumn as Xc, spanAtOffset as Xd, boxShadowsEqual as Xf, DirtyFlags as Xh, ScrollAdjustment as Xi, UiPropertyValues as Xl, DecorationStroke as Xm, SizeContainerArgs as Xn, SubtreeBounds as Xo, UiEventType as Xp, DraggableOptions as Xr, TextAlign as Xs, bumpFontStack as Xt, hasThemeExtension as Xu, DEFAULT_BLOCK_SIZE as Y, UiFileDropMessage as Ya, ResponsiveProps as Yc, resolvedSpansOf as Yd, boxShadowReach as Yf, UiNodeType as Yh, SCROLLBAR_LINGER_MS as Yi, UiPropertyValueOf as Yl, DecorationShape as Ym, BreakpointArgs as Yn, scrollbarZoneAt as Yo, UiBeforeInputEvent as Yp, DragOffset as Yr, PaintTextSpan as Ys, createWebGPUSurface as Yt, defineThemeExtension as Yu, bufferSource as Z, ShortcutRegistryOptions as Za, LazyGrid as Zc, spannedTextOf as Zd, UiPropertyDefinition as Zf, AnimationDriver as Zh, AxisExplanation as Zi, UI_ROLES as Zl, decorationColor as Zm, breakpoint as Zn, TEXT_MATCHES_PROP as Zo, UiFocusEvent as Zp, draggable as Zr, VerticalAlign as Zs, clearFontStacks as Zt, noThemeExtensions as Zu, buildSemanticsTree as _, UiHostFrameClockOptions as _a, ParagraphTextMeasurer as _c, UiTypographyExtensions as _d, ResolvedGradientStop as _f, UiSpringToken as _g, UiSubgridAxis as _h, noModifiers as _i, ChildrenBindingId as _l, MotionState as _m, LayoutInspector as _n, GestureRecognizerOptions as _o, edgeField as _p, IconSourceArgs as _r, nextCaretToggle as _s, INSTANCE_STRIDE_FLOATS as _t, SheetRowRenderer as _u, diffSemantics as a, describeLength as aa, DEFAULT_LINE_HEIGHT_FACTOR as ac, relativeLuminance as ad, PaintSurface as af, UiAnimation as ag, UiContentDistribution as ah, borderShapes as ai, Grid as al, UiPointerEvent as am, PaintContext2D as an, shortcutKeyCaps as ao, noInsets as ap, VideoTransport as ar, provideEnvironment as as, Mp3Frame as at, isUiSemanticState as au, semanticsMemory as b, UiTimerFrameClockOptions as ba, TextLineRun as bc, isTypographyRole as bd, UiGradientStop as bf, interpolateColor as bg, UiTextOverflowValue as bh, contentOffset as bi, BoxModelProps as bl, ResolvedMotionState as bm, Canvas2DRenderer as bn, UiPinchRecognizer as bo, UiModifierFocus as bp, iconSource as br, EditingPlatform as bs, PrimitiveCommand as bt, UiVirtualSheet as bu, SemanticsMemory as c, formatExplanation as ca, clearSelectionRange as cc, UiSpacing as cd, UiPaint as cf, UiSpring as cg, UiFlexWrap as ch, focusRing as ci, ScrollView as cl, UiTextChangeEvent as cm, PaintTarget as cn, PointerControllerOptions as co, UiContainerSizeSource as cp, DefaultVideoResolverOptions as cr, CARET_BLINK_MS as cs, readMp3Header as ct, validateRole as cu, SemanticsRewalk as d, UiFrame as da, selectionRangeOf as dc, spacingEqual as dd, paintValuesEqual as df, UiTweenOptions as dg, UiObjectFit as dh, hoverable as di, createElement as dl, noKeyModifiers as dm, PaintOp as dn, ScrollSink as do, unknownContainerSize as dp, VideoResolver as dr, caretVisibleAt as ds, Affine as dt, EditUnit as du, LayoutExplanation as ea, createPaintState as ec, withThemeExtension as ed, textStylesEqual as ef, assertTransitionMap as eg, paintsAfterChildren as eh, autoFocus as ei, LazyRow as el, UiKeyModifiers as em, PaintCanvas as en, UiShortcutRegistry as eo, UiInsetEdge as ep, ScrollPositionArgs as er, setMatchRanges as es, Mp4Sample as et, UiLiveRegion as eu, SemanticsSpan as f, UiAnimationFrameClock as fa, setSelectionRange as fc, spacingSteps as fd, pathValuesEqual as ff, createTween as fg, UiOverflow as fh, interactive as fi, UiDefinition as fl, wheelDeltaYOf as fm, PaintRecorder as fn, UiScrollBehavior as fo, UiEditingGroup as fp, canDecodeVideo as fr, editorFor as fs, CLIP_STRIDE_BYTES as ft, EditableTextModel as fu, buildSemanticsSubtree as g, UiHostFrameClock as ga, ParagraphLayout as gc, UiTypography as gd, ResolvedGradient as gf, UiSpringSpec as gg, UiSelfAlignment as gh, bundle as gi, UiEventBinding as gl, MotionChannel as gm, InspectorOverlay as gn, GestureInput as go, comparePositions as gp, sharedElement as gr, isReadOnly as gs, INSTANCE_STRIDE_BYTES as gt, SheetRange as gu, UiSemanticsRecord as h, UiFrameTime as ha, FontMetrics as hc, shadowsEqual as hd, MAX_GRADIENT_STOPS as hf, UiMotion as hg, UiPosition as hh, UiModifierBundle as hi, UiGraph as hl, MOTION_REST as hm, INSPECTOR_HEAT_MS as hn, isScrollContainer as ho, adjacentField as hp, motion as hr, isMultiline as hs, GlyphCommand as ht, SheetHeaderRenderer as hu, UiSemanticsPatch as i, SizeDecision as ia, resolvePaintState as ic, raiseContrast as id, PaintLineJoin as if, AnimatedCell as ig, UiColorValue as ih, FocusRingOptions as ii, EditableText as il, UiPointerDevice as im, paintPictures as in, parseShortcut as io, insetsEqual as ip, VideoState as ir, UiEnvironmentProvider as is, Mp3Format as it, isUiRole as iu, paragraphGeometry as j, UiPlatformAdapter as ja, RunMeasure as jc, visualState as jd, PercentLength as jf, UiColor as jg, borderRadiusValuesEqual as jh, GridPlacement as ji, GridProps as jl, UiSharedElements as jm, OverlayShape as jn, SelectionControllerOptions as jo, FocusOptions as jp, AnimateLayoutOptions as jr, buildFontString as js, glyphCount as jt, VIRTUAL_LEAD_PROP as ju, hasDrawnText as k, PlatformEventTarget as ka, CaretRect as kc, defaultVisualState as kd, FrLength as kf, transformsEqual as kg, borderRadiusEqual as kh, GridContribution as ki, FlexItemProps as kl, slideUp as km, RenderContext as kn, FindHost as ko, UiModifierHost as kp, DefaultImageResolverOptions as kr, TextRunRect as ks, buildRenderList as kt, UiVirtualWindow as ku, SemanticsPlacement as l, labelNode as la, selectableTextNodes as lc, defaultSpacing as ld, UiPath as lf, UiSpringOptions as lg, UiFontWeight as lh, BUTTON_INTERACTION as li, Stack as ll, UiWheelDeltaMode as lm, tracePathData as ln, UiPointerController as lo, bandOf as lp, RangeResponse as lr, CARET_WIDTH as ls, splitMp3Frames as lt, validateStates as lu, UiSemanticsMap as m, UiFrameClockFactory as ma, FixedMetricsOptions as mc, defaultShadows as md, GradientPaint as mf, UiEasingToken as mg, UiPointerEvents as mh, pressable as mi, UiBinding as ml, MOTION_CHANNELS as mm, replayPaint as mn, UiWheelController as mo, UiTextPosition as mp, SharedElementArgs as mr, isEditableNode as ms, CommandKind as mt, LazySheetProps as mu, UiSemanticsBox as n, OverrideSources as na, normalizeTextAlign as nc, contrastRatio as nd, PaintFillRule as nf, spring as ng, UiAlignment as nh, BordersOptions as ni, Button as nl, UiPasteEvent as nm, PaintPictureCache as nn, describeShortcut as no, UiInsetSource as np, VideoClock as nr, FindOptions as ns, demuxMp4Audio as nt, UiSemanticState as nu, dropIndexShifts as o, describeOverrides as oa, TEXT_SELECTION_PROP as oc, UiDensity as od, PaintTextAlign as of, UiAnimationOptions as og, UiCursor as oh, borders as oi, Paint as ol, UiPointerKind as om, PaintGradient as on, KeyboardControllerOptions as oo, observeViewportInsets as op, videoSource as or, UiEnvironmentKeys as os, Mp3Frames as ot, normalizeStates as ou, TEXT_RUN_ID_SEPARATOR as p, UiFrameClock as pa, CharacterCountTextMeasurer as pc, UiShadows as pd, UiImage as pf, UiDurationToken as pg, UiPlacement as ph, measure as pi, BindingId as pl, DirtyNodeSet as pm, PaintRecording as pn, UiScrollability as po, UiGroupEdit as pp, MotionArgs as pr, editorOf as ps, CLIP_STRIDE_FLOATS as pt, LazySheet as pu, parseWebVtt as q, UiDropZone as qa, wordRangeAt as qc, flattenTextSpans as qd, boxShadowArraysEqual as qf, createEnvironmentKey as qh, LayoutEngine as qi, UiProperties as ql, DecorationFill as qm, insetPadding as qn, scrollbarThumb as qo, UiListenerErrorReporter as qp, dropTarget as qr, PaintBoxShadow as qs, WebGPUCanvasHost as qt, UiThemeExtensionOptions as qu, UiSemanticsUpdate as r, RelayoutExplanation as ra, normalizeVerticalAlign as rc, highContrastColors as rd, PaintLineCap as rf, tween as rg, UiBorderRadiusValue as rh, Decorations as ri, Column as rl, UiPinchEvent as rm, PaintStats as rn, formatShortcut as ro, UiInsets as rp, VideoSourceArgs as rr, findMatchesIn as rs, demuxMp4Video as rt, UiSemanticStates as ru, recordsEqual as s, formatConstraints as sa, TextRange as sc, densityFactors as sd, PaintTextStyle as sf, UiReducedMotionPolicy as sg, UiDirection as sh, decorated as si, Row as sl, UiSelectionChangeEvent as sm, PaintResolver as sn, UiKeyboardController as so, UiContainerSize as sp, DefaultVideoResolver as sr, EnvironmentNotifier as ss, Mp3Header as st, statesEqual as su, UiSemanticsAction as t, LayoutStateExplanation as ta, isPaintVisible as tc, UiContrast as td, PaintBox as tf, normalizeTransition as tg, UI_SUBGRID_AXES as th, BorderEdge as ti, Box as tl, UiKeyboardEvent as tm, PaintCanvasFactory as tn, UiShortcutStep as to, UiInsetRegistry as tp, scrollPosition as tr, FindMatch as ts, Mp4VideoTrack as tt, UiRole as tu, SemanticsReuse as u, withOverrideSource as ua, selectableTextOf as uc, scaleSpacing as ud, inputsEqual as uf, UiTween as ug, UiGridAutoFlow as uh, InteractiveOptions as ui, Text as ul, UiWheelEvent as um, EMPTY_RECORDING as un, ScrollContainerState as uo, containerBands as up, VideoPlayback as ur, EDITOR_PROP as us, WebGPUGlyphPages as ut, CompositionRange as uu, rewalkSemantics as v, UiManualFrameClock as va, SpannedRuns as vc, UiTypographyRole as vd, UiGradient as vf, defaultMotion as vg, UiTextAlign as vh, Transform as vi, UiChildrenBinding as vl, MotionStateInput as vm, LayoutInspectorOptions as vn, UiGestureRecognizer as vo, editingGroupOf as vp, ImageSourceArgs as vr, syncEditorValue as vs, ImageCommand as vt, SheetSourceArgs as vu, linkHoverOf as w, isNodeSelectable as wa, TextRunMeasurer as wc, UiLayoutContext as wd, gradientsEqual as wf, UiTransform as wg, validateSubgrid as wh, inheritedPropertyFlags as wi, CommonProps as wl, resolveMotionState as wm, ScrollLayerStats as wn, clearOverrideProperty as wo, assertModifierList as wp, IconRasterizer as wr, EditableLayout as ws, RenderTextCache as wt, LazyAxis as wu, textRunOfRecordId as x, isNodeFocusable as xa, TextMeasureRequest as xc, typographyEqual as xd, UiLinearGradient as xf, interpolateNumber as xg, UiTextWrapValue as xh, closestPropertyName as xi, BoxProps as xl, fade as xm, Canvas2DRendererOptions as xn, FocusNotifier as xo, UiModifierLayout as xp, imageSource as xr, commandForKey as xs, PrimitiveKind as xt, UiVirtualSheetOptions as xu, semanticsInertAbove as y, UiTimerFrameClock as ya, TextLine as yc, defaultTypography as yd, UiGradientOffset as yf, UiInterpolator as yg, UiTextDirection as yh, accumulatedOffsetTo as yi, UiGraphBuilder as yl, MotionTiming as ym, CanvasTextMeasurer as yn, PinchRecognizerOptions as yo, UiModifierEnvironment as yp, ImageSources as yr, EditCommand as ys, NO_CLIP_INDEX as yt, SheetViewport as yu, markInstant as z, UiEditingController as za, selectionRects as zc, UiTextDecoration as zd, isPercentLength as zf, rgba as zg, shapesEqual as zh, parseCrossAxisAlignment as zi, RowProps as zl, constraintsEqual as zm, resolveProperty as zn, SCROLLBAR_HOVER_ZONE as zo, isObservable$1 as zp, PinchableOptions as zr, textRunDecorations as zs, initializeWebGPU as zt, videoFrameSize as zu };
+//# sourceMappingURL=index-B3zydgF2.d.ts.map