gesso-core 0.7.0 → 0.8.0

package/dist/{index-B5r1ETCh.d.ts → index-CQPJZwhG.d.ts}

@@ -8,6 +8,13 @@ import { BehaviorSubject, Observable, Subject } from "rxjs";
  * easing — so nothing downstream clamps what it returns.
  */
 type UiEasing = (t: number) => number;
+/**
+ * The easing as CSS writes it, `cubic-bezier(0.2, 0, 0, 1)` or `linear`,
+ * for an easing made by `cubicBezier` or `linear`; undefined for one
+ * that is only a function, which CSS cannot name. What a design tool's
+ * handoff writes into a `transition`.
+ */
+declare function easingCss(easing: UiEasing): string | undefined;
 /** Progress equals time. What a spinner and a sweep want. */
 declare const linear: UiEasing;
 /**
@@ -291,11 +298,30 @@ declare function interpolatorFor(from: unknown, to: unknown): UiInterpolator<unk
  * it has forty opinions. the rule for colour —
  * tokens only, never a literal in a component — applies to time.
  */
-type UiDurationToken = 'instant' | 'fast' | 'normal' | 'slow' | 'deliberate';
+type UiDurationToken = 'instant' | 'fast' | 'normal' | 'slow' | 'deliberate' | (keyof UiDurationExtensions & string);
 /** The named curves; see `UiEasing.ts` for what each one is for. */
-type UiEasingToken = keyof typeof easings;
+type UiEasingToken = keyof typeof easings | (keyof UiEasingExtensions & string);
 /** The named springs, for a movement that follows a gesture. */
-type UiSpringToken = 'gentle' | 'snappy' | 'stiff';
+type UiSpringToken = 'gentle' | 'snappy' | 'stiff' | (keyof UiSpringExtensions & string);
+/**
+ * Names an application adds to the vocabulary, as typography roles are
+ * added (`UiTypographyExtensions`): a design's own `press` beside
+ * `fast`, given its value in the motion it provides (`defineMotion`).
+ *
+ *   declare module 'gesso-core' {
+ *     interface UiDurationExtensions {
+ *       readonly press: unknown;
+ *     }
+ *   }
+ *
+ * Only the key is used. Declaring one makes `transition={{ opacity:
+ * 'press' }}` legal and a misspelling a compile error.
+ */
+interface UiDurationExtensions {}
+/** Curves an application names; see `UiDurationExtensions`. */
+interface UiEasingExtensions {}
+/** Springs an application names; see `UiDurationExtensions`. */
+interface UiSpringExtensions {}
 /**
  * A spring, in the physical sense: `stiffness` pulls towards the
  * target, `damping` resists velocity, `mass` resists both.
@@ -314,21 +340,42 @@ interface UiSpringSpec {
 /**
  * A vocabulary of motion, beside the palette and the type scale.
  *
- * It is deliberately **not** a field on `UiTheme`. A theme value is
- * resolved per node — `resolveColorValue` asks what the node inherits
- * — and an animation drives a *cell*, which has no node, so a motion
- * token on the theme would be a token nothing could resolve. That is
- * the mistake `visualState` made: a value
- * shipped where nothing reads it. An application that wants a
- * different feel installs one with `AnimationService.setMotion`, which
- * is per runtime, as everything else in front of the graph is.
+ * It is deliberately **not** a field on `UiTheme`: a theme value is
+ * resolved per node at paint, and a name in an animation is resolved
+ * once, when the animation starts. An application that wants a
+ * different feel installs one with `AnimationService.setMotion`, for
+ * the whole runtime, and a part of the tree may provide another over it
+ * (`UiEnvironmentKeys.motion`): a name in a `transition` or a `motion`
+ * state resolves against the motion where it is drawn (`motionOf`).
  */
 interface UiMotion {
   readonly durations: Readonly<Record<UiDurationToken, number>>;
   readonly easings: Readonly<Record<UiEasingToken, UiEasing>>;
   readonly springs: Readonly<Record<UiSpringToken, UiSpringSpec>>;
 }
+/** What a design changes in the vocabulary: any name, its own included. */
+interface UiMotionChanges {
+  readonly durations?: Readonly<Partial<Record<UiDurationToken, number>>>;
+  readonly easings?: Readonly<Partial<Record<UiEasingToken, UiEasing>>>;
+  readonly springs?: Readonly<Partial<Record<UiSpringToken, UiSpringSpec>>>;
+}
 declare const defaultMotion: UiMotion;
+/**
+ * A vocabulary with a design's own values, Gesso's for the rest:
+ *
+ *   export const motion = defineMotion({ durations: { fast: 100, press: 90 } });
+ *
+ * Provided to a part of the tree (`UiEnvironmentKeys.motion`) or to the
+ * whole runtime (`AnimationService.setMotion`), it is what a name in a
+ * `transition`, a `motion` state or `AnimationService` resolves to.
+ */
+declare function defineMotion(changes: UiMotionChanges): UiMotion;
+/** A duration by name or in milliseconds, as `motion` has it; `normal` for a name it lacks. */
+declare function durationIn(motion: UiMotion, duration: number | UiDurationToken | undefined): number;
+/** A curve by name, or given outright; `standard` for none or a name it lacks. */
+declare function easingIn(motion: UiMotion, easing: UiEasing | UiEasingToken | undefined): UiEasing;
+/** A spring by name, or given outright; `snappy` for none or a name it lacks. */
+declare function springIn(motion: UiMotion, spring: UiSpringSpec | UiSpringToken | undefined): UiSpringSpec;
 //#endregion
 //#region src/animation/UiAnimation.d.ts
 /**
@@ -499,7 +546,8 @@ declare abstract class UiAnimation<T> {
    */
   continueFrom(previous: UiAnimation<T>): void;
   protected onBegin(): void;
-  advance(now: number): void;
+  /** `hold`: at its end, stay there, unfinished, to be sampled again at an earlier time (`UiClock.holding`). */
+  advance(now: number, hold?: boolean): void;
   /**
    * Moves the ideal timeline on by one step.
    *
@@ -597,13 +645,15 @@ declare function createTween<T>(cell: AnimatedCell<T>, to: T, options: UiTweenOp
  */
 type UiTransitionSpec = {
   readonly kind: 'tween';
-  readonly duration: number;
-  readonly easing?: UiEasing;
+  /** Milliseconds, or a name resolved against the motion where it is drawn. */
+  readonly duration: number | UiDurationToken;
+  readonly easing?: UiEasing | UiEasingToken;
   readonly stepMs?: number;
   readonly reducedMotion?: UiReducedMotionPolicy;
 } | {
   readonly kind: 'spring';
-  readonly spring: UiSpringSpec;
+  /** Given outright, or a name resolved against the motion where it is drawn. */
+  readonly spring: UiSpringSpec | UiSpringToken;
   readonly restDelta?: number;
   readonly reducedMotion?: UiReducedMotionPolicy;
 };
@@ -615,10 +665,10 @@ type UiTransitionSpec = {
  * transition does. A spring is for a property that is one number, like
  * `opacity`: a transform only tweens (see `spring`).
  */
-type UiTransitionValue = number | UiTransitionSpec;
+type UiTransitionValue = number | UiDurationToken | UiTransitionSpec;
 /** A tween of `duration` milliseconds along `easing`. */
-declare function tween(duration: number, options?: {
-  easing?: UiEasing;
+declare function tween(duration: number | UiDurationToken, options?: {
+  easing?: UiEasing | UiEasingToken;
   stepMs?: number;
   reducedMotion?: UiReducedMotionPolicy;
 }): UiTransitionSpec;
@@ -639,143 +689,6 @@ declare function normalizeTransition(value: UiTransitionValue): UiTransitionSpec
  */
 declare function assertTransitionMap(nodeId: string, value: unknown, isKnownProperty: (name: string) => boolean): ReadonlyMap<string, UiTransitionSpec>;
 //#endregion
-//#region src/animation/AnimationDriver.d.ts
-/**
- * The running animations of one runtime, and the thing the `ticks`
- * phase advances.
- *
- * **One animation per cell.** Starting a second one on a cell
- * supersedes the first, which completes without reaching its target.
- * That rule is not a simplification: it is what makes a gesture work
- * — every retarget while a finger moves is a new animation on the same
- * cell — and it removes the whole question of what two animations
- * writing one value would mean.
- *
- * The driver is per runtime for the reason `MediaService` is: the
- * playground runs several runtimes in one worker, and a module-level
- * set of animations would tick a disposed runtime's cells.
- */
-declare class AnimationDriver {
-  private readonly running;
-  private reducedMotion;
-  private hidden;
-  private wake;
-  /**
-   * Called when an animation enters the running set on an idle driver.
-   *
-   * The runtime arms a frame here. Without it an animation started
-   * from a click handler that changes nothing else would never get a
-   * first frame: the scheduler arms only on dirt, the animation's dirt
-   * is made inside a frame, and no frame would ever come. Re-arming
-   * *between* frames is `scheduleAnimationTick`'s job; this is only
-   * the first one.
-   */
-  setWakeListener(listener: (() => void) | null): void;
-  /** Whether anything is running, so the `ticks` phase can report 0. */
-  get isRunning(): boolean;
-  get size(): number;
-  /** Whether a person has asked for less motion; see `UiReducedMotionPolicy`. */
-  get isReducedMotion(): boolean;
-  /**
-   * Whether an animation should be put where it is going instead of
-   * being run there.
-   *
-   * Two questions with one answer: a person who has asked for less
-   * motion and a page nobody is looking at both want the end state and
-   * not the journey to it, and in both cases `keep` is the way an
-   * animation says its movement is the information rather than the
-   * decoration.
-   */
-  private lands;
-  /**
-   * Starts an animation, replacing whatever was driving its cell.
-   *
-   * Returns the values it will write. Under reduced motion, or while
-   * the document is hidden, an animation whose policy is `snap` never
-   * enters the set at all: the cell takes its target here, in the
-   * caller's turn, and the returned observable has already completed.
-   * So a reduced-motion app runs no animation frames, rather than
-   * running them and drawing the same thing sixty times.
-   */
-  start<T>(animation: UiAnimation<T>): Observable<T>;
-  /** The animation currently driving a cell, if any. */
-  animationFor<T>(cell: AnimatedCell<T>): UiAnimation<T> | undefined;
-  /**
-   * Stops whatever is driving a cell, leaving it where it stands.
-   *
-   * This is how a node leaving the tree releases its animations, which
-   * is the leak the media tier names for image bitmaps and which
-   * matters here too: a driver holding a cell holds every closure the
-   * component that made it captured.
-   */
-  stop<T>(cell: AnimatedCell<T>): boolean;
-  stopAll(): void;
-  /**
-   * A person's motion preference changed.
-   *
-   * Turning it on finishes everything already in flight that is
-   * willing to be finished, rather than leaving a dialog stuck
-   * half-faded until the animation it was told not to run runs out.
-   */
-  setReducedMotion(reduced: boolean): void;
-  /**
-   * The document went out of sight, or came back.
-   *
-   * A hidden page still paints. The runtime deliberately keeps giving
-   * frames to a change that genuinely happened, so the canvas holds a
-   * correct picture rather than whatever was on it when the tab went
-   * away, and a route loaded hidden is drawn once its images have
-   * decoded rather than being left half empty. What it does not do is
-   * advance animations, because frames spent watching something move
-   * that nobody can see are frames spent for nothing.
-   *
-   * Those two together leave an animation frozen at whatever value it
-   * had reached, and painted there. For most animations that is
-   * harmless: a colour halfway between two colours is still a colour.
-   * For an **entrance** it is not, because an entrance begins at
-   * `opacity: 0` and its frozen first value is an element that is not
-   * there. Segue's track page, opened in a background tab, held sixty
-   * two pixels of empty page where its play button belonged, and every
-   * screen built from `motion({ initial })` did the same. It came back
-   * the moment the tab did, which is exactly why it reads as a
-   * rendering bug rather than as a tab that is not being drawn.
-   *
-   * So a hidden page lands its animations instead of freezing them, in
-   * the same way and for the same reason a reduced-motion preference
-   * does: what an animation has to say to nobody is nothing, and the
-   * state it was going to end at is the one the page should be holding
-   * while it waits to be looked at. An animation whose movement is the
-   * information (`keep`) is left alone either way, so a spinner is
-   * still a spinner when the tab comes back.
-   */
-  setHidden(hidden: boolean): void;
-  /** Puts everything that may be landed where it was going. */
-  private landRunning;
-  /**
-   * When the earliest animation next wants a frame, or undefined when
-   * nothing is running.
-   *
-   * This is the whole answer to "how does an animation keep frames
-   * coming on an idle app". The runtime asks after every frame: an
-   * answer at or before `now` means arm the next frame, a later one
-   * means a timer, and undefined means arm nothing — which is why an
-   * idle app's profile reads `ticks 0.00` for the strong reason (no
-   * frames at all) rather than the weak one (frames that did nothing).
-   */
-  nextTickAt(now: number): number | undefined;
-  /**
-   * Advances every animation whose next sample is due, writing each
-   * one's cell. This is the `ticks` phase.
-   *
-   * It runs before the dirty set is snapshotted for exactly the reason
-   * `patches` and `environment` do: the writes it makes have to belong
-   * to the frame about to be collected, or a frame would draw the
-   * previous tick's values and every animation would run one frame
-   * behind.
-   */
-  advance(now: number): void;
-}
-//#endregion
 //#region src/graph/DirtyFlags.d.ts
 declare enum DirtyFlags {
   None = 0,
@@ -841,6 +754,27 @@ declare function createEnvironmentKey<T>(options: {
  * declared as a key.
  */
 declare function findEnvironmentKey(name: string): UiEnvironmentKey<unknown> | undefined;
+/**
+ * A value a node provides for a key of your own, to everything under
+ * it: `provide={[provided(Session, session)]}`.
+ *
+ * The keys Gesso declares are provided by props of their own (`theme`,
+ * `pointer`, `contentColor`); this is how a key made with
+ * `createEnvironmentKey` is. A component under the node reads it with
+ * `ctx.environment(key)`. What the environment holds is compared by
+ * the key's `compare`, else by identity, so a value that changes often
+ * is better provided as a source (a cell) than as each new value: the
+ * source is set once and never compares unequal again.
+ */
+interface UiProvision<T = unknown> {
+  readonly key: UiEnvironmentKey<T>;
+  readonly value: T;
+}
+/**
+ * A value for `key`, for a node's `provide`. Typed against the key
+ * here and erased in the result, so one list holds keys of any type.
+ */
+declare function provided<T>(key: UiEnvironmentKey<T>, value: T): UiProvision;
 //#endregion
 //#region src/environment/UiEnvironment.d.ts
 /**
@@ -909,6 +843,86 @@ declare class UiEnvironment {
   providesOwn(name: string): boolean;
 }
 //#endregion
+//#region src/layout/LayoutTypes.d.ts
+interface Size {
+  width: number;
+  height: number;
+}
+interface LayoutBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/**
+ * Options applied to a Constraints instance.
+ *
+ * An explicit width/height makes that axis tight
+ * (min === max), mirroring CSS replaced sizing.
+ */
+interface TightenOptions {
+  width?: number;
+  height?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  minHeight?: number;
+  maxHeight?: number;
+}
+/**
+ * Immutable bounds handed down the layout tree.
+ *
+ * Unbounded axes use Infinity for max.
+ */
+declare class Constraints {
+  readonly minWidth: number;
+  readonly maxWidth: number;
+  readonly minHeight: number;
+  readonly maxHeight: number;
+  constructor(minWidth?: number, maxWidth?: number, minHeight?: number, maxHeight?: number);
+  static unbounded(): Constraints;
+  static tight(width: number, height: number): Constraints;
+  static loose(width: number, height: number): Constraints;
+  hasBoundedWidth(): boolean;
+  hasBoundedHeight(): boolean;
+}
+/** What one layout call did; see LayoutEngine.stats. */
+interface LayoutStats {
+  /** Nodes whose measure ran (memo hits excluded). */
+  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. */
+  fullLayout: boolean;
+  /** Every node whose measure ran, in order, when `LayoutEngine.trace` is on. */
+  measuredNodes: UiNode[];
+}
+/**
+ * The result of a full layout pass for the layout root.
+ *
+ * Descendant geometry is read from LayoutRecords.
+ */
+interface LayoutResult {
+  root: UiNode;
+  box: LayoutBox;
+  contentWidth: number;
+  contentHeight: number;
+  scrollX: number;
+  scrollY: number;
+  clip: LayoutBox;
+}
+declare function clampSize(constraints: Constraints, width: number, height: number): Size;
+declare function constraintsEqual(a: Constraints, b: Constraints): boolean;
+/**
+ * Returns new constraints with the options applied on top of
+ * the supplied constraints. Explicit sizes make an axis tight,
+ * min/max values tighten the existing bounds.
+ */
+declare function tightenConstraints(constraints: Constraints, options: TightenOptions): Constraints;
+//#endregion
 //#region src/layout/TextMeasurer.d.ts
 type TextWrap = 'word' | 'char' | 'none';
 type TextOverflow = 'clip' | 'ellipsis';
@@ -1880,8 +1894,11 @@ declare const UI_SUBGRID_AXES: readonly UiSubgridAxis[];
 declare function validateSubgrid(value: unknown): string | undefined;
 type UiPosition = 'static' | 'relative' | 'absolute' | 'sticky';
 type UiOverflow = 'visible' | 'hidden' | 'scroll' | 'auto';
-/** Side and alignment of an anchored node against its anchor. */
-type UiPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+/**
+ * Side and alignment of an anchored node against its anchor, or `over`
+ * it: laid over the anchor's box, grown by the offset on every side.
+ */
+type UiPlacement = 'over' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
 type UiTextWrapValue = 'word' | 'char' | 'none';
 type UiTextOverflowValue = 'clip' | 'ellipsis';
 /**
@@ -2062,6 +2079,12 @@ interface UiPropertyOverride {
   readonly name: string;
   order: number;
   value: unknown;
+  /**
+   * Drawn at once, past any transition the node declares, and taken
+   * away at once too: a design tool's preview of a value being chosen,
+   * which has to keep up with the drag that chooses it.
+   */
+  readonly snap?: boolean;
 }
 /**
  * The cascade for one overridden property: the element's own value,
@@ -2087,6 +2110,10 @@ interface UiPropertyOverrides {
 interface UiNodeTransitions {
   /** Takes over a write by animating towards it, or declines it. */
   write(property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
+  /** Stops animating one property, leaving it where it stands, for a write that is drawn at once. */
+  cancel(property: NodeProperty): void;
+  /** What the element declares, by property, as written: a name stays a name. For a tool that reads it. */
+  readonly declared: ReadonlyMap<NodeProperty, UiTransitionSpec>;
   /** Cancels everything, for a node leaving the tree. */
   release(): void;
 }
@@ -2147,117 +2174,254 @@ declare class UiNode {
   /**
    * The scoped environment this node reads inherited values from.
    *
-   * Null means the node uses the default environment values. The
-   * environment is assigned by the graph builder when a node or an
-   * ancestor provides environment values.
+   * Null means the node uses the default environment values. The
+   * environment is assigned by the graph builder when a node or an
+   * ancestor provides environment values.
+   */
+  environment: UiEnvironment | null;
+  /**
+   * Shapes the node's modifiers put in its own paint pass, merged in
+   * modifier order.
+   *
+   * Null until a modifier decorates, so the cost to an undecorated
+   * node is the one null check each renderer already makes per node,
+   * and a tree of ten thousand plain boxes pays nothing. Written only
+   * through `UiModifierHost.decorate`; see `rendering/Decorations.ts`
+   * for what a shape means and where it lands.
+   */
+  decorations: readonly DecorationShape[] | null;
+  /**
+   * How this node's properties get from one value to the next.
+   *
+   * Null until the element declares a `transition`, so the cost to a
+   * tree without one is a field read on the property write path — the
+   * same shape, and the same argument, as `overrides` above.
+   */
+  transitions: UiNodeTransitions | null;
+  hasChildren(): boolean;
+  isDirty(): boolean;
+  getProperty<T>(property: NodeProperty): T | undefined;
+  setProperty<T>(property: NodeProperty, value: T): void;
+  /** Removes a property; whether it was there. */
+  removeProperty(property: NodeProperty): boolean;
+}
+//#endregion
+//#region src/animation/UiClock.d.ts
+/**
+ * How time passes for the animations under a node: at a speed of its
+ * own, or not at all.
+ *
+ * A node provides one to its subtree,
+ * `provide={[provided(UiEnvironmentKeys.clock, clock)]}`, and every
+ * animation started there runs on it: a transition, a `motion` state,
+ * hover and press, and `AnimationService.animate` given the node it
+ * animates `on`. Nothing provided is real time.
+ *
+ * What a design tool needs to show one screen two ways at once. The
+ * frames on its board are pictures: under a `settled` clock every
+ * animation lands where it is going the moment it starts, and a loop
+ * holds still. The screen it plays runs at the person's own speed, a
+ * quarter of it to watch a press closely, or paused. Reduced motion and
+ * a hidden page are the whole app's; this is one part of it.
+ *
+ * An animation takes all its time from the driver, which hands each
+ * the local time of its clock, so nothing inside a tween or a spring
+ * knows; and the driver asks for the next frame in real time, so a
+ * slowed clock asks for frames as often as it needs them and a paused
+ * one asks for none.
+ */
+declare class UiClock {
+  private rate;
+  /** A real time and the local time it was, from the last change of speed: where local time is measured from. */
+  private anchor;
+  /** The real time last asked about, where a change of speed takes effect. */
+  private lastReal;
+  /** Every animation lands where it is going, and none runs. */
+  settled: boolean;
+  /**
+   * Animations that reach their end stay, held there, rather than
+   * finishing: so moving the time back (`seek`) plays them back. What a
+   * design tool scrubs a transition with; let go, they finish as they
+   * would have. A spring, which is worked out step by step rather than
+   * from the time, holds but does not run back.
+   */
+  holding: boolean;
+  /** Bumped by `seek`, so a driver knows to draw again at the new time. */
+  moves: number;
+  constructor(options?: {
+    readonly speed?: number;
+    readonly settled?: boolean;
+  });
+  /** How fast time passes: 1 is real time, 0.25 a quarter of it, 0 paused. */
+  get speed(): number;
+  set speed(next: number);
+  /** The local time now, as last asked: where a seek is measured from. */
+  get now(): number;
+  /**
+   * Puts local time at `at`, from now on: forward, or back to replay
+   * what is held (`holding`). Paused, it stays there; running, it goes
+   * on from there.
+   */
+  seek(at: number): void;
+  /** The local time at real time `now`. The first time asked, the two agree. */
+  local(now: number): number;
+  /** The real time at which local time `at` comes; Infinity while paused. */
+  real(at: number): number;
+}
+/** The motion vocabulary names resolve to under `node`: the nearest provided above it, or Gesso's. */
+declare function motionOf(node: UiNode | null | undefined): UiMotion;
+/** The clock the animations under `node` run on: the nearest one provided above it, or null for real time. */
+declare function clockOf(node: UiNode | null | undefined): UiClock | null;
+//#endregion
+//#region src/animation/AnimationDriver.d.ts
+/**
+ * The running animations of one runtime, and the thing the `ticks`
+ * phase advances.
+ *
+ * **One animation per cell.** Starting a second one on a cell
+ * supersedes the first, which completes without reaching its target.
+ * That rule is not a simplification: it is what makes a gesture work
+ * — every retarget while a finger moves is a new animation on the same
+ * cell — and it removes the whole question of what two animations
+ * writing one value would mean.
+ *
+ * The driver is per runtime for the reason `MediaService` is: the
+ * playground runs several runtimes in one worker, and a module-level
+ * set of animations would tick a disposed runtime's cells.
+ */
+declare class AnimationDriver {
+  private readonly running;
+  /** The clock each running animation was started on, when it was not real time; see `UiClock`. */
+  private readonly clocks;
+  /** Each clock's `moves` as last drawn: one moved since (a seek) is drawn at its new time at once. */
+  private readonly seenMoves;
+  private reducedMotion;
+  private hidden;
+  private advancing;
+  private wake;
+  /**
+   * Called when an animation enters the running set on an idle driver.
+   *
+   * The runtime arms a frame here. Without it an animation started
+   * from a click handler that changes nothing else would never get a
+   * first frame: the scheduler arms only on dirt, the animation's dirt
+   * is made inside a frame, and no frame would ever come. Re-arming
+   * *between* frames is `scheduleAnimationTick`'s job; this is only
+   * the first one.
+   */
+  setWakeListener(listener: (() => void) | null): void;
+  /**
+   * Whether a frame of the running animations is being written now: a
+   * value written meanwhile is a step of an animation, not a change for
+   * a transition to animate again.
+   */
+  get isAdvancing(): boolean;
+  /** Whether anything is running, so the `ticks` phase can report 0. */
+  get isRunning(): boolean;
+  get size(): number;
+  /** Whether a person has asked for less motion; see `UiReducedMotionPolicy`. */
+  get isReducedMotion(): boolean;
+  /**
+   * Whether an animation should be put where it is going instead of
+   * being run there.
+   *
+   * Two questions with one answer: a person who has asked for less
+   * motion and a page nobody is looking at both want the end state and
+   * not the journey to it, and in both cases `keep` is the way an
+   * animation says its movement is the information rather than the
+   * decoration.
+   */
+  private lands;
+  /**
+   * Starts an animation, replacing whatever was driving its cell.
+   *
+   * Returns the values it will write. Under reduced motion, or while
+   * the document is hidden, an animation whose policy is `snap` never
+   * enters the set at all: the cell takes its target here, in the
+   * caller's turn, and the returned observable has already completed.
+   * So a reduced-motion app runs no animation frames, rather than
+   * running them and drawing the same thing sixty times.
+   */
+  start<T>(animation: UiAnimation<T>, clock?: UiClock | null): Observable<T>;
+  /** The animation currently driving a cell, if any. */
+  animationFor<T>(cell: AnimatedCell<T>): UiAnimation<T> | undefined;
+  /**
+   * Stops whatever is driving a cell, leaving it where it stands.
+   *
+   * This is how a node leaving the tree releases its animations, which
+   * is the leak the media tier names for image bitmaps and which
+   * matters here too: a driver holding a cell holds every closure the
+   * component that made it captured.
+   */
+  stop<T>(cell: AnimatedCell<T>): boolean;
+  stopAll(): void;
+  /**
+   * A person's motion preference changed.
+   *
+   * Turning it on finishes everything already in flight that is
+   * willing to be finished, rather than leaving a dialog stuck
+   * half-faded until the animation it was told not to run runs out.
+   */
+  setReducedMotion(reduced: boolean): void;
+  /**
+   * The document went out of sight, or came back.
+   *
+   * A hidden page still paints. The runtime deliberately keeps giving
+   * frames to a change that genuinely happened, so the canvas holds a
+   * correct picture rather than whatever was on it when the tab went
+   * away, and a route loaded hidden is drawn once its images have
+   * decoded rather than being left half empty. What it does not do is
+   * advance animations, because frames spent watching something move
+   * that nobody can see are frames spent for nothing.
+   *
+   * Those two together leave an animation frozen at whatever value it
+   * had reached, and painted there. For most animations that is
+   * harmless: a colour halfway between two colours is still a colour.
+   * For an **entrance** it is not, because an entrance begins at
+   * `opacity: 0` and its frozen first value is an element that is not
+   * there. Segue's track page, opened in a background tab, held sixty
+   * two pixels of empty page where its play button belonged, and every
+   * screen built from `motion({ initial })` did the same. It came back
+   * the moment the tab did, which is exactly why it reads as a
+   * rendering bug rather than as a tab that is not being drawn.
+   *
+   * So a hidden page lands its animations instead of freezing them, in
+   * the same way and for the same reason a reduced-motion preference
+   * does: what an animation has to say to nobody is nothing, and the
+   * state it was going to end at is the one the page should be holding
+   * while it waits to be looked at. An animation whose movement is the
+   * information (`keep`) is left alone either way, so a spinner is
+   * still a spinner when the tab comes back.
    */
-  environment: UiEnvironment | null;
+  setHidden(hidden: boolean): void;
+  /** Puts everything that may be landed where it was going. */
+  private landRunning;
   /**
-   * Shapes the node's modifiers put in its own paint pass, merged in
-   * modifier order.
+   * When the earliest animation next wants a frame, or undefined when
+   * nothing is running.
    *
-   * Null until a modifier decorates, so the cost to an undecorated
-   * node is the one null check each renderer already makes per node,
-   * and a tree of ten thousand plain boxes pays nothing. Written only
-   * through `UiModifierHost.decorate`; see `rendering/Decorations.ts`
-   * for what a shape means and where it lands.
+   * This is the whole answer to "how does an animation keep frames
+   * coming on an idle app". The runtime asks after every frame: an
+   * answer at or before `now` means arm the next frame, a later one
+   * means a timer, and undefined means arm nothing — which is why an
+   * idle app's profile reads `ticks 0.00` for the strong reason (no
+   * frames at all) rather than the weak one (frames that did nothing).
    */
-  decorations: readonly DecorationShape[] | null;
+  nextTickAt(now: number): number | undefined;
   /**
-   * How this node's properties get from one value to the next.
+   * Advances every animation whose next sample is due, writing each
+   * one's cell. This is the `ticks` phase.
    *
-   * Null until the element declares a `transition`, so the cost to a
-   * tree without one is a field read on the property write path — the
-   * same shape, and the same argument, as `overrides` above.
+   * It runs before the dirty set is snapshotted for exactly the reason
+   * `patches` and `environment` do: the writes it makes have to belong
+   * to the frame about to be collected, or a frame would draw the
+   * previous tick's values and every animation would run one frame
+   * behind.
    */
-  transitions: UiNodeTransitions | null;
-  hasChildren(): boolean;
-  isDirty(): boolean;
-  getProperty<T>(property: NodeProperty): T | undefined;
-  setProperty<T>(property: NodeProperty, value: T): void;
-  /** Removes a property; whether it was there. */
-  removeProperty(property: NodeProperty): boolean;
-}
-//#endregion
-//#region src/layout/LayoutTypes.d.ts
-interface Size {
-  width: number;
-  height: number;
-}
-interface LayoutBox {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-/**
- * Options applied to a Constraints instance.
- *
- * An explicit width/height makes that axis tight
- * (min === max), mirroring CSS replaced sizing.
- */
-interface TightenOptions {
-  width?: number;
-  height?: number;
-  minWidth?: number;
-  maxWidth?: number;
-  minHeight?: number;
-  maxHeight?: number;
-}
-/**
- * Immutable bounds handed down the layout tree.
- *
- * Unbounded axes use Infinity for max.
- */
-declare class Constraints {
-  readonly minWidth: number;
-  readonly maxWidth: number;
-  readonly minHeight: number;
-  readonly maxHeight: number;
-  constructor(minWidth?: number, maxWidth?: number, minHeight?: number, maxHeight?: number);
-  static unbounded(): Constraints;
-  static tight(width: number, height: number): Constraints;
-  static loose(width: number, height: number): Constraints;
-  hasBoundedWidth(): boolean;
-  hasBoundedHeight(): boolean;
-}
-/** What one layout call did; see LayoutEngine.stats. */
-interface LayoutStats {
-  /** Nodes whose measure ran (memo hits excluded). */
-  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. */
-  fullLayout: boolean;
-  /** Every node whose measure ran, in order, when `LayoutEngine.trace` is on. */
-  measuredNodes: UiNode[];
-}
-/**
- * The result of a full layout pass for the layout root.
- *
- * Descendant geometry is read from LayoutRecords.
- */
-interface LayoutResult {
-  root: UiNode;
-  box: LayoutBox;
-  contentWidth: number;
-  contentHeight: number;
-  scrollX: number;
-  scrollY: number;
-  clip: LayoutBox;
+  advance(now: number): void;
+  private advanceRunning;
+  private advanceEach;
 }
-declare function clampSize(constraints: Constraints, width: number, height: number): Size;
-declare function constraintsEqual(a: Constraints, b: Constraints): boolean;
-/**
- * Returns new constraints with the options applied on top of
- * the supplied constraints. Explicit sizes make an axis tight,
- * min/max values tighten the existing bounds.
- */
-declare function tightenConstraints(constraints: Constraints, options: TightenOptions): Constraints;
 //#endregion
 //#region src/animation/UiSharedElements.d.ts
 /**
@@ -3238,8 +3402,11 @@ interface ComponentResolver {
    * Called on every reconcile pass that reaches the slot. Returning
    * the same value for an unchanged component is expected; the
    * builder reconciles it idempotently.
+   *
+   * `anchor` is the slot's node, already under its parent, so what
+   * the component is placed in can be read while its body runs.
    */
-  resolve(element: ComponentLikeElement, anchorId: string): UiChild;
+  resolve(element: ComponentLikeElement, anchorId: string, anchor?: UiNode): UiChild;
   /**
    * Tears down the host owning `anchorId`.
    *
@@ -3333,6 +3500,12 @@ type FocusModality = 'pointer' | 'keyboard';
  * dialog modal for the keyboard. `popScope()` restores focus to
  * whatever held it when the scope was pushed. Components reach both
  * through `FocusService`, never directly.
+ *
+ * A scope inside a bound (`setFocusBounds`) is modal only inside it. A
+ * dialog open in one of a design tool's frames confines the keyboard in
+ * that frame, when it is there, and leaves the tool around it, and every
+ * other frame, to the person: it takes no focus from outside, and gives
+ * none back when it closes.
  */
 declare class UiFocusManager {
   private readonly dispatcher;
@@ -3349,11 +3522,17 @@ declare class UiFocusManager {
   private readonly listeners;
   private readonly scopeListeners;
   private readonly scopes;
+  private isBound;
   /** 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;
+  /**
+   * Which nodes bound a scope taken inside them: a trap under one is
+   * modal only inside it. `OverlayScope`'s, set by the framework.
+   */
+  setFocusBounds(isBound: ((node: UiNode) => boolean) | null): void;
   /** The node that currently holds logical focus, or null. */
   get focusedNode(): UiNode | null;
   hasFocus(): boolean;
@@ -3421,7 +3600,8 @@ declare class UiFocusManager {
   /** Moves focus to the previous focusable node, wrapping to the last. */
   focusPrevious(): boolean;
   /**
-   * Confines focus to `root` until the matching `popScope`.
+   * Confines focus to `root` until the matching `popScope`; inside a
+   * bound, only for focus inside it (see the class's note).
    *
    * Focus that is outside the new scope moves to its first focusable,
    * so the very next Tab stays inside; a scope with nothing focusable
@@ -3491,6 +3671,12 @@ declare class UiFocusManager {
    * stops, which is what lets a dialog body be the keyboard's home of
    * last resort without becoming a stop of its own.
    */
+  /**
+   * The tab stops under `within`, or in the active scope, in the order
+   * Tab visits them: what a design tool numbers to show a screen's
+   * keyboard order.
+   */
+  tabStops(within?: UiNode): UiNode[];
   private collectFocusable;
   /** Whether an ancestor is hidden or disabled, which takes the node's focus away with it. */
   private insideHidden;
@@ -3498,6 +3684,18 @@ declare class UiFocusManager {
   private groupOf;
   /** Whether the node may hold focus given the active scope, if any. */
   private withinScope;
+  /**
+   * The innermost scope that confines a node: a bounded one only inside
+   * its bound, so a node, or no focus at all, outside it answers to the
+   * scope under it.
+   */
+  private scopeFor;
+  /**
+   * The bound above a scope's root, found once the root is in the tree
+   * (a trap is taken from a `ref`, which may fire before) and kept, so
+   * a scope whose subtree has gone still knows it.
+   */
+  private boundOf;
   /** Whether the node is still connected to the traversal root. */
   private isAttached;
   private isWithin;
@@ -3644,6 +3842,19 @@ interface UiModifierHost {
    * one is painted unsettled and warned about rather than hanging.
    */
   onLayout(listener: (box: LayoutBox) => void): void;
+  /**
+   * Called after any frame that changed the node's `flowBox` or its own
+   * scroll offset, with the `flowBox`; not when a scroll or a transform
+   * above it only moves it on screen. Removed on detach.
+   *
+   * The one to use when what the listener reads is the node's own place
+   * in the layout — its size for a breakpoint, its box for a layout
+   * animation, its offset for a scroll position — which a pan of a
+   * design tool's board, or a page's scroll, does not change. Asking
+   * nothing on those frames is most of what it is for. Runs where
+   * `onLayout` runs, with the same freedom to change layout.
+   */
+  onFlowLayout(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.
@@ -3819,6 +4030,8 @@ interface UiModifierLayout {
    */
   viewport?(): LayoutBox | null;
   onLayout(node: UiNode, listener: (box: LayoutBox) => void): () => void;
+  /** See `UiModifierHost.onFlowLayout`. Absent, `onLayout` stands in, which tells a listener more often, never less. */
+  onFlowLayout?(node: UiNode, listener: (box: LayoutBox) => void): () => void;
 }
 /**
  * Where a modifier's focus access comes from.
@@ -3870,6 +4083,8 @@ declare class UiModifierSet {
   private decorationsFor;
   /** The names of what is attached, in order, for the inspector. */
   get names(): string[];
+  /** What is attached, each kind with its current arguments, in order: for a tool reading what a node does. */
+  get modifiers(): readonly UiModifier[];
   get size(): number;
   /**
    * Brings the attached set in line with what the element declares.
@@ -4628,6 +4843,14 @@ declare const BOX_SHADOW_BLUR_REACH = 1.5;
  * one's hole shrinks with it. A square corner stays square, as CSS
  * keeps it.
  */
+/**
+ * A box's corner radius as its shadows take it: no more than half its
+ * shorter side, as CSS shrinks radii to fit the box before a shadow is
+ * spread from them. A box of no size with a 16 radius has no corners,
+ * so the hole an outer shadow leaves under it is nothing: a spotlight's
+ * hole shrunk to a point showed a 16-pixel circle where there was none.
+ */
+declare function fittedShadowRadius(boxRadius: number, width: number, height: number): number;
 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,
@@ -5195,6 +5418,16 @@ interface UiGradientStop {
    * does.
    */
   readonly color: UiColorValue;
+  /**
+   * How much of the colour shows, 0 to 1, multiplied into its alpha once
+   * a palette name has been resolved: `{ color: 'background', opacity: 0 }`.
+   *
+   * What a fade to nothing is made of. A canvas blends a gradient's stops
+   * without premultiplying, so a ramp from white to `transparent`, which
+   * is transparent *black*, passes through grey on its way out; a ramp to
+   * the same colour at no opacity stays that colour all the way.
+   */
+  readonly opacity?: number;
 }
 interface UiLinearGradient {
   readonly kind: 'linear';
@@ -5422,12 +5655,44 @@ interface PaintSurface {
   /** Multiplies into the opacity already in force, as a node's does. */
   alpha(value: number): void;
   /**
-   * Blurs everything drawn after it, by a radius in logical pixels.
+   * Blurs everything drawn after it, by a radius (CSS's standard
+   * deviation) in the current coordinates, so a blur under a `scale`
+   * scales with what it blurs. The transform in force at the call is
+   * the one it is measured in.
    *
    * Scoped by `save` and `restore` like every other style value, so a
    * frosted panel is `save`, `blur`, draw, `restore`. Zero clears it.
    */
   blur(radius: number): void;
+  /**
+   * Starts a masked layer: what is drawn from here to `layerMask` is
+   * the layer's content, kept apart from what is drawn already and cut
+   * to this rectangle, in the current coordinates.
+   *
+   * Saves the state as `save` does. The content starts with the
+   * transform in force and an empty path, and with every other style
+   * value at its initial one: the alpha, blur and clip in force here
+   * apply to the layer as a whole, when `endMaskedLayer` draws it.
+   *
+   * An SVG `<mask>` and a drop shadow are both drawn this way. A host
+   * that cannot keep a layer apart draws the content unmasked and the
+   * mask not at all, which is a picture that is wrong in one detail
+   * rather than missing.
+   */
+  beginMaskedLayer(x: number, y: number, width: number, height: number): void;
+  /**
+   * Ends the layer's content and starts its mask: the state is as
+   * `beginMaskedLayer` found it, the path empty, and the mask cut to the
+   * same rectangle. Where the mask is drawn the content shows, by how
+   * much `mode` says; where nothing is, nothing does.
+   */
+  layerMask(mode?: PaintMaskMode): void;
+  /**
+   * Draws the layer's content, masked, where it began, and restores the
+   * state `beginMaskedLayer` saved. A layer ended without a mask draws
+   * its content as it is.
+   */
+  endMaskedLayer(): void;
   /** Fills the current path. The default rule is `nonzero`. */
   fill(rule?: PaintFillRule): void;
   stroke(): void;
@@ -5449,6 +5714,13 @@ type PaintFillRule = 'nonzero' | 'evenodd';
 type PaintLineCap = 'butt' | 'round' | 'square';
 type PaintLineJoin = 'miter' | 'round' | 'bevel';
 type PaintTextAlign = 'left' | 'center' | 'right';
+/**
+ * How a layer's mask says how much of it shows. `luminance`, the
+ * default, is SVG's `<mask>` and CSS's `mask-type: luminance`: the
+ * mask's brightness times its alpha, so white shows the content and
+ * black hides it. `alpha` is the mask's alpha alone, whatever its colour.
+ */
+type PaintMaskMode = 'luminance' | 'alpha';
 /** The little of a text style a single painted line can carry. */
 interface PaintTextStyle {
   readonly fontSize?: number;
@@ -7151,7 +7423,10 @@ declare const UiProperties: {
    * Side and alignment against the anchor: 'bottom' (default),
    * 'bottom-start', 'bottom-end', 'top', 'top-start', 'top-end',
    * 'left', 'left-start', 'left-end', 'right', 'right-start',
-   * 'right-end'.
+   * 'right-end'; or 'over', which lays the node over the anchor at its
+   * size, grown by `anchorOffset` on every side: a spotlight's hole, a
+   * focus ring drawn above everything, following the anchor as any
+   * anchored node does.
    */
   readonly placement: UiPropertyDefinition<UiPlacement | undefined>;
   /**
@@ -7573,6 +7848,8 @@ declare const UiProperties: {
    */
   readonly textStyle: UiPropertyDefinition<UiTextStyle | UiTypographyRole | undefined>;
   readonly contentColor: UiPropertyDefinition<UiColorValue | undefined>;
+  /** Values for keys of the application's own, provided to the subtree; see `UiProvision`. */
+  readonly provide: UiPropertyDefinition<readonly UiProvision<unknown>[] | undefined>;
   /**
    * Declares this node a size query container: its content size is
    * published to the subtree through `UiEnvironmentKeys.containerSize`,
@@ -7745,7 +8022,7 @@ type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'touchEmulation' |
  */
 type SemanticsProps = PropsOf<'role' | 'label' | 'description' | 'live' | 'states' | 'valueNow' | 'valueMin' | 'valueMax' | 'valueText' | 'posInSet' | 'setSize' | 'level' | 'rowIndex' | 'columnIndex' | 'rowCount' | 'columnCount' | 'activeDescendant' | 'controls' | 'autocomplete' | 'orientation'>;
 /** Environment values an element provides to its subtree. */
-type EnvironmentProps = PropsOf<'theme' | 'pointer' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets'>;
+type EnvironmentProps = PropsOf<'theme' | 'pointer' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets' | 'provide'>;
 /**
  * Behaviour attached to an element without wrapping it: hover and
  * press state, a focus ring, a tooltip, drag. See `packages/core/src/modifiers`.
@@ -8430,15 +8707,10 @@ declare class UiGraph {
    */
   removeNodeProperty(node: UiNode, property: string, dirtyFlags?: DirtyFlags): boolean;
   /**
-   * Writes a property without consulting the node's transitions.
-   *
-   * What a transition's own per-frame writes go through: they are
-   * already the animation towards the target, so re-entering the
-   * transition check would have each frame start an animation towards
-   * the value it had just produced. Everything below this — the
-   * override cascade, the equality check, the dirty marking — is
-   * unchanged, so an animated value is overridable by a modifier
-   * exactly as a bound one is.
+   * Writes the element's value for a property: onto the node, or into
+   * the cascade under a modifier writing over it. The same as
+   * `updateNodeProperty`, kept by its name for the callers that write
+   * a value of the runtime's own, such as the root's pointer.
    */
   updateNodePropertyNow<T>(node: UiNode, property: string, value: T, dirtyFlags?: DirtyFlags): boolean;
   /**
@@ -8448,8 +8720,18 @@ declare class UiGraph {
    * Removing rather than writing a default is what lets a detaching
    * modifier restore inheritance: a node that never declared `color`
    * reads it from the environment again, as it did before.
+   *
+   * `snap` draws it at once, past any transition the node declares;
+   * see `UiPropertyOverride.snap`.
    */
-  applyResolvedProperty(node: UiNode, property: NodeProperty, present: boolean, value: unknown, dirtyFlags: DirtyFlags): boolean;
+  applyResolvedProperty(node: UiNode, property: NodeProperty, present: boolean, value: unknown, dirtyFlags: DirtyFlags, snap?: boolean): boolean;
+  /**
+   * Writes what a transition's frame drew, without consulting the
+   * transition again: the frame is already the animation towards the
+   * target, and re-entering it would start an animation towards the
+   * value it had just produced.
+   */
+  applyAnimatedValue(node: UiNode, property: NodeProperty, value: unknown, dirtyFlags: DirtyFlags): boolean;
   /**
    * Adds the environment flag to a write of `color` or of a text
    * style field, which a node provides to its subtree as well as
@@ -9761,6 +10043,10 @@ declare const UiEnvironmentKeys: {
    * with two windows provides one per window.
    */
   readonly insets: UiEnvironmentKey<UiInsetSource>;
+  /** The durations, easings and springs a name resolves to under a node; see `UiMotion`. */
+  readonly motion: UiEnvironmentKey<UiMotion>;
+  /** The clock the animations under a node run on; null is real time. See `UiClock`. */
+  readonly clock: UiEnvironmentKey<UiClock | null>;
 };
 //#endregion
 //#region src/environment/UiEnvironmentProvider.d.ts
@@ -10549,16 +10835,17 @@ declare class NodeTransitions implements UiNodeTransitions {
   write(property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
   /** Cancels everything, for a node leaving the tree or dropping the prop. */
   release(): void;
+  cancel(property: NodeProperty): void;
+  get declared(): ReadonlyMap<NodeProperty, UiTransitionSpec>;
   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.
+   * It writes what is drawn (`applyAnimatedValue`): the target already
+   * is the value the element and any modifier over it settled on, so a
+   * frame of the way there goes onto the node as it is.
    */
   private cellFor;
   private startAnimation;
@@ -11058,11 +11345,27 @@ declare class UiWheelController {
    * wheel of a burst land correctly even though the first could not.
    */
   lastWheelTarget: UiNode | null;
+  /** Where the last wheel event was, for the latch; see `latched`. */
+  private lastX;
+  private lastY;
   /**
    * The container the wheel last scrolled, for a frame's report of where
    * scrolling put it. Null until the wheel has scrolled something.
    */
   lastScrolled: UiNode | null;
+  /**
+   * The node the last wheel event landed on, while this one belongs to
+   * the same gesture: close behind it, with the pointer where it was.
+   * Null when it does not, and the point is tested afresh.
+   *
+   * A browser does the same, latching a wheel gesture to the element its
+   * first step landed on, and for the reason it matters here: testing the
+   * point asks for bounds that the gesture's own last step may have made
+   * out of date. A pinch over a design tool's board scales every name on
+   * it, and each step of it filled in the bounds of 1,800 names again,
+   * 4 ms, to find what the step before had found.
+   */
+  private latched;
   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
@@ -13543,8 +13846,21 @@ declare class LayoutEngine {
    * from the first move to the last.
    */
   private layoutVersion;
-  /** The version `subtreeBounds` on the records was filled from. */
-  private boundsVersion;
+  /**
+   * Where the subtree bounds are out of date: everything, after a full
+   * pass; otherwise the nodes whose box or children or transform
+   * changed (`boundsMoved`) and the subtrees moved whole
+   * (`boundsShifted`), which `refreshSubtreeBounds` fills in again with
+   * their ancestors and nothing else.
+   */
+  private boundsWhole;
+  private readonly boundsMoved;
+  private readonly boundsShifted;
+  /**
+   * How many transforms changed: a transform moves no box, so it leaves
+   * `layoutVersion` alone, and `geometryVersion` adds these to it.
+   */
+  private transformMoves;
   constructor(textMeasurer?: TextMeasurer);
   recordFor(node: UiNode): LayoutRecord | undefined;
   /**
@@ -14096,6 +14412,8 @@ declare class LayoutEngine {
    * into the same visible space before comparing them.
    */
   private placeAnchored;
+  /** Lays a node exactly over a box, at its size, whatever size it asks for: `placement: 'over'`. */
+  private placeOver;
   /**
    * Places a measured node beside a box — an anchor's, or a point's of
    * no size — flipping to the opposite side when the named one would
@@ -14173,6 +14491,8 @@ declare class LayoutEngine {
    * chain the renderer composes on the way down, walked up; a turned box
    * is the box its corners span.
    */
+  /** How many changed nodes are refilled one by one before the whole tree is; see `WHOLE_BOUNDS_REFILL`. */
+  private wholeBoundsRefill;
   private projectBox;
   /**
    * A canvas box brought into the space an absolute child's record is
@@ -14567,8 +14887,28 @@ interface NotifiedLayout {
 declare class LayoutNotifier {
   private readonly listeners;
   private readonly last;
+  /**
+   * Listeners told about the node's place in the layout and its scroll
+   * offset, and not about where it is drawn (`addFlow`).
+   */
+  private readonly flowListeners;
+  private readonly flowLast;
   /** Registers a listener; the returned function removes it. */
   add(node: UiNode, listener: (box: LayoutBox) => void): () => void;
+  /**
+   * Registers a listener told when the node's laid-out box or its own
+   * scroll offset changes, and not when a scroll or a transform above it
+   * moves it on screen; the returned function removes it.
+   *
+   * Most listeners are this kind: a size container, a breakpoint, a
+   * layout animation, a scroll position read only the node's own box
+   * and offset. Told of every move on screen, each of them was asked
+   * on every step of a pan over a design tool's board, 2,600 of them,
+   * to find nothing it reads had changed; and each answer was where
+   * the node was drawn, worked out through every ancestor. Its place in
+   * the layout is its record, read at once.
+   */
+  addFlow(node: UiNode, listener: (box: LayoutBox) => void): () => void;
   get size(): number;
   /** Whether anything is listening, so a frame can skip the walk. */
   isEmpty(): boolean;
@@ -14576,7 +14916,7 @@ declare class LayoutNotifier {
    * Calls the listeners of every watched node whose box or scroll
    * offset differs from what it was last told about.
    */
-  notify(read: (node: UiNode) => NotifiedLayout): void;
+  notify(read: (node: UiNode) => NotifiedLayout, readFlow?: (node: UiNode) => NotifiedLayout): void;
   /** Drops a removed node's listeners, so nothing keeps it alive. */
   handleNodeRemoved(node: UiNode): void;
 }
@@ -14901,6 +15241,18 @@ declare function bundle(...parts: readonly (UiModifier | UiModifierBundle)[]): U
 declare const noModifiers: UiModifierBundle;
 //#endregion
 //#region src/modifiers/interaction.d.ts
+/** A pointer or keyboard state a tool draws an element in without the pointer or the keyboard. */
+type UiShownAs = 'hovered' | 'pressed' | 'focused';
+/**
+ * Draws what is under a node as though it were hovered, pressed or
+ * focused: every `interactive` modifier there shows its hover or press
+ * look, and every `focusRing` its ring. What a design tool draws a
+ * component's pointer states with, beside its other states, where no
+ * pointer is over it. Read as each modifier attaches, so a node drawn
+ * under it starts so and stays so; the pointer still adds its own.
+ * Pressed is hovered too, as a press under a pointer is.
+ */
+declare const ShownAsKey: UiEnvironmentKey<UiShownAs | null>;
 /**
  * Pointer state, as a property anything can read, and the property
  * writes that follow from it.
@@ -15642,10 +15994,10 @@ interface SvgXmlElement {
  *
  * What a design tool exports is what is read: shapes and paths, groups
  * and `<use>`, transforms, solid fills and strokes with their
- * opacities, linear and radial gradients, clip paths, a `<style>` of
- * simple selectors, and nested `<svg>`. What is not drawn yet is named
- * in `unsupported`, so a file that leans on it can say so rather than
- * look subtly wrong.
+ * opacities, linear and radial gradients, clip paths, masks, a filter
+ * that is one drop shadow, a `<style>` of simple selectors, and nested
+ * `<svg>`. What is not drawn yet is named in `unsupported`, so a file
+ * that leans on it can say so rather than look subtly wrong.
  */
 interface SvgDocument {
   /** The `<svg>` element. */
@@ -15655,11 +16007,16 @@ interface SvgDocument {
   readonly height: number;
   /** The region of the drawing's own coordinates that fills that size. */
   readonly viewBox: SvgRect;
-  /** Every element with an `id`, for `<use>`, gradients and clip paths. */
+  /** Every element with an `id`, for `<use>`, gradients, clip paths, masks and filters. */
   readonly ids: ReadonlyMap<string, SvgXmlElement>;
   /** The rules of its `<style>` elements, in document order. */
   readonly rules: readonly SvgStyleRule[];
-  /** What the file uses that is not drawn: `text`, `filter`, `mask` and so on, once each. */
+  /**
+   * What the file uses that is not drawn: `text`, `image`, `marker` and
+   * so on, once each. `filter` is a filter that is anything but one
+   * `<feDropShadow>`, or a `filter` that names something else; `mask`
+   * is a `mask` that names something other than a `<mask>`.
+   */
   readonly unsupported: readonly string[];
 }
 interface SvgRect {
@@ -17974,6 +18331,17 @@ type PaintOp = {
 } | {
   readonly op: 'blur';
   readonly radius: number;
+} | {
+  readonly op: 'beginMaskedLayer';
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+} | {
+  readonly op: 'layerMask';
+  readonly mode: PaintMaskMode;
+} | {
+  readonly op: 'endMaskedLayer';
 } | {
   readonly op: 'fill';
   readonly rule: PaintFillRule;
@@ -18057,6 +18425,9 @@ declare class PaintRecorder implements PaintSurface {
   lineDash(segments: readonly number[], offset?: number): void;
   alpha(value: number): void;
   blur(radius: number): void;
+  beginMaskedLayer(x: number, y: number, width: number, height: number): void;
+  layerMask(mode?: PaintMaskMode): void;
+  endMaskedLayer(): void;
   fill(rule?: PaintFillRule): void;
   stroke(): void;
   clip(rule?: PaintFillRule): void;
@@ -18146,12 +18517,74 @@ interface PaintContext2D {
    * rather than none.
    */
   filter?: string;
+  /**
+   * What a masked layer needs of a context, all optional for the reason
+   * `filter` is: a host or a double without them draws the layer's
+   * content unmasked. The context drawn into reads and sets its whole
+   * transform, to place a layer in device pixels; a layer's own canvas
+   * also composites and reads its pixels back.
+   */
+  getTransform?(): PaintMatrix;
+  setTransform?(a: number, b: number, c: number, d: number, e: number, f: number): void;
+  globalCompositeOperation?: string;
+  getImageData?(x: number, y: number, width: number, height: number): PaintPixels;
+  putImageData?(pixels: PaintPixels, x: number, y: number): void;
   fillStyle: string | PaintGradient;
   strokeStyle: string | PaintGradient;
   font: string;
   textAlign: 'left' | 'center' | 'right';
   textBaseline: 'alphabetic';
 }
+/** An affine matrix to device pixels, `a b c d e f`, as `getTransform` reports one. */
+interface PaintMatrix {
+  readonly a: number;
+  readonly b: number;
+  readonly c: number;
+  readonly d: number;
+  readonly e: number;
+  readonly f: number;
+}
+/** A context's pixels, unpremultiplied RGBA, as `getImageData` reads them. */
+interface PaintPixels {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8ClampedArray;
+}
+/**
+ * The canvas a picture is drawn into, and the bitmap it becomes.
+ *
+ * `IconCanvas`'s sibling, and injectable for the same two reasons: the
+ * suite has no `OffscreenCanvas`, and a host that lacks one should
+ * fail by drawing nothing rather than by throwing in a frame.
+ *
+ * `take()` is synchronous, which is the whole reason the default is
+ * `transferToImageBitmap` and not `createImageBitmap`. An asynchronous
+ * raster would put the picture a frame behind its inputs and would
+ * need a way to ask for another frame from inside a renderer, which no
+ * renderer has and none should.
+ */
+interface PaintCanvas {
+  context(): PaintContext2D | null;
+  take(): UiImage;
+}
+type PaintCanvasFactory = (width: number, height: number) => PaintCanvas | null;
+/**
+ * Where a target's masked layers come from: a canvas per layer, and the
+ * rectangle of the context drawn into, in its device pixels, that a
+ * layer is cut to. Without one a target draws a layer's content
+ * unmasked.
+ */
+interface PaintLayers {
+  readonly create: PaintCanvasFactory;
+  readonly bounds: PaintDeviceRect;
+}
+/** A rectangle in device pixels. */
+interface PaintDeviceRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
 /** The part of a canvas gradient a picture uses. */
 interface PaintGradient {
   addColorStop(offset: number, color: string): void;
@@ -18180,8 +18613,8 @@ interface PaintResolver {
  * picture's cache key.
  */
 declare class PaintTarget implements PaintSurface {
-  private readonly ctx;
   private readonly resolver;
+  private readonly layerSource?;
   /**
    * The pending blur radius per save level.
    *
@@ -18191,7 +18624,17 @@ declare class PaintTarget implements PaintSurface {
    */
   private readonly blurStack;
   private blurRadius;
-  constructor(ctx: PaintContext2D, resolver: PaintResolver);
+  /** The context drawn into now: the one given, or a layer's while its content or mask is drawn. */
+  private ctx;
+  /** The masked layers begun and not yet ended, innermost last. */
+  private readonly layers;
+  /**
+   * How many layers are drawing nothing at the moment: one cut to
+   * nothing, or a mask a host could not keep apart. Fills, strokes,
+   * text and images are dropped while it is above zero.
+   */
+  private suppressed;
+  constructor(ctx: PaintContext2D, resolver: PaintResolver, layerSource?: PaintLayers | undefined);
   save(): void;
   restore(): void;
   translate(x: number, y: number): void;
@@ -18223,7 +18666,25 @@ declare class PaintTarget implements PaintSurface {
   miterLimit(limit: number): void;
   lineDash(segments: readonly number[], offset?: number): void;
   alpha(value: number): void;
+  /**
+   * A canvas's filter is measured in device pixels whatever the
+   * transform, so the radius is scaled by the transform's here, where
+   * there is one to read.
+   */
   blur(radius: number): void;
+  /**
+   * The content is drawn into a canvas of its own, the size of the
+   * layer's rectangle in device pixels and cut to the part of the
+   * context drawn into that it covers, under the same transform less
+   * the canvas's corner. A fresh canvas per layer, sized once: drawing
+   * into a canvas just blended from makes Chrome copy it first (see
+   * `GroupOpacity.ts`).
+   */
+  beginMaskedLayer(x: number, y: number, width: number, height: number): void;
+  layerMask(mode?: PaintMaskMode): void;
+  endMaskedLayer(): void;
+  /** A canvas for a layer's content or mask, placed and cut as the layer is; null where none can be had. */
+  private openLayerCanvas;
   fill(rule?: PaintFillRule): void;
   stroke(): void;
   clip(rule?: PaintFillRule): void;
@@ -18232,24 +18693,6 @@ declare class PaintTarget implements PaintSurface {
 }
 //#endregion
 //#region src/rendering/PaintPicture.d.ts
-/**
- * The canvas a picture is drawn into, and the bitmap it becomes.
- *
- * `IconCanvas`'s sibling, and injectable for the same two reasons: the
- * suite has no `OffscreenCanvas`, and a host that lacks one should
- * fail by drawing nothing rather than by throwing in a frame.
- *
- * `take()` is synchronous, which is the whole reason the default is
- * `transferToImageBitmap` and not `createImageBitmap`. An asynchronous
- * raster would put the picture a frame behind its inputs and would
- * need a way to ask for another frame from inside a renderer, which no
- * renderer has and none should.
- */
-interface PaintCanvas {
-  context(): PaintContext2D | null;
-  take(): UiImage;
-}
-type PaintCanvasFactory = (width: number, height: number) => PaintCanvas | null;
 /** What a painted frame did, for `PaintPicture.budget.spec.ts`. */
 interface PaintStats {
   /** How many times a painter's `draw` ran. */
@@ -20422,5 +20865,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp4AudioTrack as $, EditingControllerOptions as $a, ResponsiveProps as $c, darkTheme as $d, UiTextLink as $f, createTween as $g, borderRadiusCorners as $h, parseCrossAxisAlignment as $i, UiPropertyValueOf as $l, slideFrom as $m, BreakpointArgs as $n, HitTester as $o, UiModifierTeardown as $p, pinchable as $r, drawText as $s, registerFontStack as $t, hasVisualState as $u, offsetAtPointIn as A, linear as A_, UiHostFrameClock as Aa, selectableTextOf as Ac, FrLength as Ad, UiBoxShadow as Af, TextWrap as Ag, UiContentDistribution as Ah, noModifiers as Ai, EditableTextProps as Al, UiPointerEvent as Am, UiRenderer as An, UiScrollability as Ao, containerBands as Ap, IconRasterizerOptions as Ar, EDITOR_PROP as As, createTextCache as At, LazyGridOptions as Au, markNow as B, isSubtreeInert as Ba, offsetAtPoint as Bc, isPercentLength as Bd, UiTypography as Bf, UiTransitionValue as Bg, UiPosition as Bh, propertyIsInherited as Bi, PositionProps as Bl, MOTION_REST as Bm, createCanvasSurface as Bn, resetTransitionWarnings as Bo, edgeField as Bp, DefaultImageResolver as Br, EditingPlatform as Bs, isWebGPUAvailable as Bt, VirtualViewport as Bu, hasTextLinks as C, normalizeColor as C_, labelNode as Ca, normalizeVerticalAlign as Cc, UiRadialGradient as Cd, relativeLuminance as Cf, TextLineRun as Cg, decorationRect as Ch, hoverable as Ci, UiGraphBuilder as Cl, UiGestureEvent as Cm, CanvasTextMeasurer as Cn, KeyboardControllerOptions as Co, UiInsets as Cp, ImageSources as Cr, findMatchesIn as Cs, RenderList as Ct, SheetSourceArgs as Cu, setLinkHover as D, UiEasing as D_, UiFrameClock as Da, TextRange as Dc, radialGradient as Dd, defaultShadows as Df, TextRunMeasurer as Dg, UiAlignment as Dh, pressable as Di, ColumnProps as Dl, UiPasteEvent as Dm, LayerCanvasFactory as Dn, ScrollContainerState as Do, UiContainerSize as Dp, IconCanvas as Dr, EnvironmentNotifier as Ds, TEXTURED_STRIDE_FLOATS as Dt, VIRTUAL_SHEET_PROP as Du, linkRunAtPointIn as E, rgba as E_, UiAnimationFrameClock as Ea, TEXT_SELECTION_PROP as Ec, linearGradient as Ed, UiShadows as Ef, TextOverflow as Eg, UI_SUBGRID_AXES as Eh, measureFlow as Ei, ButtonProps as El, UiKeyboardEvent as Em, traceRoundedRect as En, UiPointerController as Eo, observeViewportInsets as Ep, mediaLoadsInFlight as Er, UiEnvironmentKeys as Es, TEXTURED_STRIDE_BYTES as Et, UiVirtualSheetOptions as Eu, UiFrameCallback as F, isNodeFocusable as Fa, RunMeasure as Fc, auto as Fd, boxShadowRadius as Ff, findEnvironmentKey as Fg, UiGridAutoFlow as Fh, findPropertyDefinition as Fi, GridProps as Fl, UiWheelEvent as Fm, OverlayShape as Fn, UiGestureRecognizer as Fo, UiEditingGroup as Fp, SvgResolver as Fr, isMultiline as Fs, GlyphSlot as Ft, VIRTUAL_INDEX_PROP as Fu, VttTrack as G, PlatformEventTarget as Ga, lineEndAt as Gc, UiPropertyDefinition as Gd, typographyEqual as Gf, AnimatedCell as Gg, UiTextOverflowValue as Gh, GridPlacement as Gi, StackProps as Gl, ResolvedMotionState as Gm, resolveString as Gn, writeOverrideProperty as Go, UiModifierSet as Gp, ContextMenuOptions as Gr, CanvasTextStyle as Gs, WebGPURenderer as Gt, MAX_MEASURES_PER_CHILD as Gu, performanceMarksEnabled as H, resolveCursor as Ha, offsetForVerticalMove as Hc, percent as Hd, UiTypographyRole as Hf, normalizeTransition as Hg, UiSubgridAxis as Hh, propertyValuesEqualByName as Hi, Reactive as Hl, MotionState as Hm, resolveNumber as Hn, overrideSources as Ho, UiModifierEnvironment as Hp, ImageResolver as Hr, detectEditingPlatform as Hs, CapturedFrame as Ht, UiVideoSurface as Hu, UiScheduler as I, isNodeHitTestable as Ia, caretRectFor as Ic, fr as Id, boxShadowReach as If, UiNodeType as Ig, UiObjectFit as Ih, getPropertyNames as Ii, IdentityProps as Il, noKeyModifiers as Im, drawOverlayShapes as In, PinchRecognizerOptions as Io, UiGroupEdit as Ip, isSvgSource as Ir, isReadOnly as Is, GlyphUpload as It, VIRTUAL_LEAD_PROP as Iu, ByteSource as J, capturePointer as Ja, nextWordEnd as Jc, TOUCH_TARGET as Jd, UiFontStyle as Jf, UiReducedMotionPolicy as Jg, UiVerticalAlign as Jh, sizeGridTracks as Ji, TypographyProps as Jl, pop as Jm, sameArgs as Jn, SelectionControllerOptions as Jo, UiModifier as Jp, contextMenu as Jr, TextLinePlacement as Js, WebGPUSurface as Jt, UiLayoutProtocol as Ju, cueAt as K, PlatformSurface as Ka, lineStartAt as Kc, defineProperty as Kd, UiFontKerning as Kf, UiAnimation as Kg, UiTextWrapValue as Kh, GridTrack as Ki, TextContentProps as Kl, fade as Km, ThemeTokenTarget as Kn, FindHost as Ko, UiUnknownModifierPropertyError as Kp, ShortcutOptions as Kr, PlacedTextRun as Ks, WebGPURendererOptions as Kt, UiLayoutChild as Ku, UiSchedulerOptions as L, isNodeInert as La, lineIndexAtY as Lc, isAutoLength as Ld, boxShadowValuesEqual as Lf, DirtyFlags as Lg, UiOverflow as Lh, inheritedPropertyFlags as Li, InteractionProps as Ll, wheelDeltaYOf as Lm, labelOrigin as Ln, UiPinchRecognizer as Lo, UiTextPosition as Lp, SvgDocument as Lr, nextCaretToggle as Ls, WebGPUGlyphAtlas as Lt, VIRTUAL_WINDOW_PROP as Lu, paragraphGeometryFrom as M, UiManualFrameClock as Ma, setSelectionRange as Mc, PercentLength as Md, UiShadowName as Mf, UiEnvironment as Mg, UiDirection as Mh, accumulatedOffsetTo as Mi, FlexContainerProps as Ml, UiSelectionChangeEvent as Mm, RenderChanges as Mn, isScrollContainer as Mo, UiTextInput as Mp, iconKey as Mr, editorFor as Ms, textRuns as Mt, LazyListOptions as Mu, selectionRectsIn as N, UiTimerFrameClock as Na, CaretRect as Nc, UiLength as Nd, boxShadow as Nf, UiEnvironmentKey as Ng, UiFlexWrap as Nh, contentOffset as Ni, FlexItemProps as Nl, UiTextChangeEvent as Nm, RenderContext as Nn, GestureInput as No, UiTextInputState as Np, DefaultSvgResolver as Nr, editorOf as Ns, GlyphShaper as Nt, LazySourceArgs as Nu, ParagraphGeometry as O, cubicBezier as O_, UiFrameClockFactory as Oa, clearSelectionRange as Oc, validateGradient as Od, shadowsEqual as Of, TextRunSpan as Og, UiBorderRadiusValue as Oh, UiModifierBundle as Oi, CommonProps as Ol, UiPinchEvent as Om, ScrollLayerStats as On, ScrollSink as Oo, UiContainerSizeSource as Op, IconContext as Or, CARET_BLINK_MS as Os, TextRunDraw as Ot, sheetSource as Ou, wordRangeIn as P, UiTimerFrameClockOptions as Pa, PlacedLine as Pc, UiTrackSize as Pd, boxShadowArraysEqual as Pf, createEnvironmentKey as Pg, UiFontWeight as Ph, closestPropertyName as Pi, GridItemProps as Pl, UiWheelDeltaMode as Pm, LABEL_PADDING_X as Pn, GestureRecognizerOptions as Po, textInputOf as Pp, DefaultSvgResolverOptions as Pr, isEditableNode as Ps, GLYPH_SUBPIXEL_PHASES as Pt, UiVirtualWindow as Pu, rangeSource as Q, touchActionFor as Qa, Responsive as Qc, UiTheme as Qd, UiTextDecoration as Qf, UiTweenOptions as Qg, borderRadius as Qh, parseAlignContent as Qi, UiPropertyName as Ql, slideDown as Qm, publishInset as Qn, HitTestResult as Qo, UiModifierHost as Qp, ZoomState as Qr, createCanvasTextStyle as Qs, fontStackFor as Qt, defaultVisualState as Qu, MARK_PREFIX as R, isNodeSelectable as Ra, lineIndexForOffset as Rc, isFrLength as Rd, boxShadowsEqual as Rf, AnimationDriver as Rg, UiPlacement as Rh, inheritedPropertyNames as Ri, PaintElementProps as Rl, DirtyNodeSet as Rm, CanvasHost as Rn, FocusNotifier as Ro, adjacentField as Rp, SvgRect as Rr, syncEditorValue as Rs, WebGPUTextureCache as Rt, VirtualItemMeasure as Ru, clearLinkHover as S, colorsEqual as S_, formatExplanation as Sa, normalizeTextAlign as Sc, UiLinearGradient as Sd, raiseContrast as Sf, TextLine as Sg, decorationColor as Sh, InteractiveOptions as Si, UiChildrenBinding as Sl, UiFocusEvent as Sm, LayoutInspectorOptions as Sn, shortcutKeyCaps as So, UiInsetSource as Sp, ImageSourceArgs as Sr, FindOptions as Ss, RenderCommand as St, SheetRowRenderer as Su, linkOf as T, rgb8 as T_, UiFrame as Ta, DEFAULT_LINE_HEIGHT_FACTOR as Tc, gradientsEqual as Td, densityFactors as Tf, TextMeasurer as Tg, paintsAfterChildren as Th, measure as Ti, BoxProps as Tl, UiKeyModifiers as Tm, Canvas2DRendererOptions as Tn, PointerControllerOptions as To, noInsets as Tp, imageSource as Tr, provideEnvironment as Ts, ScissorRect as Tt, UiVirtualSheet as Tu, setPerformanceMarks as U, CanvasPlatformSurface as Ua, selectionRects as Uc, repeat as Ud, defaultTypography as Uf, spring as Ug, UiTextAlign as Uh, GridContribution as Ui, RowProps as Ul, MotionStateInput as Um, resolveProperty as Un, resetOverrideWarnings as Uo, UiModifierFocus as Up, AnimateLayoutOptions as Ur, isPrintable as Us, DrawStats as Ut, isVideoSurface as Uu, measureSpan as V, pointerEventsOf as Va, offsetAtX as Vc, minmax as Vd, UiTypographyExtensions as Vf, assertTransitionMap as Vg, UiSelfAlignment as Vh, propertyNarrowers as Vi, PropsOf as Vl, MotionChannel as Vm, resolveBoolean as Vn, clearOverrideProperty as Vo, editingGroupOf as Vp, DefaultImageResolverOptions as Vr, commandForKey as Vs, WebGPUError as Vt, lazySource as Vu, VttCue as W, PlatformAdapterOptions as Wa, graphemeBoundaries as Wc, resolveLength as Wd, isTypographyRole as Wf, tween as Wg, UiTextDirection as Wh, GridItemRequest as Wi, ScrollViewProps as Wl, MotionTiming as Wm, resolvePropertyByName as Wn, writeDeclaredProperty as Wo, UiModifierLayout as Wp, animateLayout as Wr, EditableLayout as Ws, RenderHooks as Wt, videoFrameSize as Wu, RangeSourceOptions as X, pointerDeviceOf as Xa, previousWordStart as Xc, UiThemeTouch as Xd, UiResolvedTextSpan as Xf, UiSpringOptions as Xg, UiBorderRadius as Xh, CrossAxisAlignment as Xi, UiNodeRef as Xl, rotateFrom as Xm, PublishInsetArgs as Xn, UiSelectionController as Xo, defineModifier as Xp, shortcuts as Xr, applyCanvasTextStyle as Xs, bumpFontStack as Xt, UiVisualState as Xu, DEFAULT_BLOCK_SIZE as Y, isImeKey as Ya, previousGraphemeStart as Yc, UiPointer as Yd, UiFontVariant as Yf, UiSpring as Yg, validateSubgrid as Yh, AlignContent as Yi, UiEventProps as Yl, resolveMotionState as Ym, InsetPaddingArgs as Yn, SelectionHost as Yo, UiModifierKind as Yp, shortcut as Yr, TextRunRect as Ys, createWebGPUSurface as Yt, isLayoutProtocol as Yu, bufferSource as Z, prepareInputSurface as Za, wordRangeAt as Zc, withPointer as Zd, UiSpannedText as Zf, UiTween as Zg, UiBorderRadiuses as Zh, MainAxisAlignment as Zi, UiProperties as Zl, scaleFrom as Zm, insetPadding as Zn, HitTestLayoutReader as Zo, isUiModifier as Zp, PinchableOptions as Zr, buildFontString as Zs, clearFontStacks as Zt, UiVisualStateSet as Zu, buildSemanticsTree as _, UiBasicColors as __, RelayoutExplanation as _a, VerticalAlign as _c, ResolvedGradient as _d, withThemeExtension as _f, FixedMetricsOptions as _g, UiPropertyOverrides as _h, borderShapes as _i, BindingId as _l, UiListenerErrorReporter as _m, drawSvg as _n, UiShortcutRegistry as _o, scaleSpacing as _p, MotionArgs as _r, TEXT_MATCHES_PROP as _s, INSTANCE_STRIDE_FLOATS as _t, EditableTextModel as _u, diffSemantics as a, defaultMotion as a_, proportionalFontMetrics as aa, textRunDecorations as ac, PaintLineJoin as ad, UiUnits as af, UiShapeExtensions as ag, LayoutResult as ah, dropTarget as ai, Box as al, UiChild as am, PaintContext2D as an, EXTERNAL_FILES as ao, editableSpansOf as ap, scrollPosition as ar, SCROLLBAR_THICKNESS as as, Mp3Frame as at, UiOrientation as au, semanticsMemory as b, colorToRgba as b_, describeOverrides as ba, createPaintState as bc, UiGradientOffset as bd, contrastRatio as bf, ParagraphTextMeasurer as bg, DecorationShape as bh, focusRing as bi, UiEventBinding as bl, UiCompositionEvent as bm, InspectorOverlay as bn, formatShortcut as bo, UiInsetEdge as bp, sharedElement as br, setMatchRanges as bs, PrimitiveCommand as bt, SheetHeaderRenderer as bu, SemanticsMemory as c, interpolateNumber as c_, SCROLLBAR_FADE_MS as ca, DEFAULT_FONT_FAMILY as cc, PaintTextStyle as cd, unitsEqual as cf, defaultShapes as cg, TightenOptions as ch, DraggableOptions as ci, EditableText as cl, isComponentLikeElement as cm, PaintTarget as cn, UiDragState as co, resolvedSpansOf as cp, VideoState as cr, ScrollbarThumb as cs, readMp3Header as ct, UiSemanticStates as cu, SemanticsRewalk as d, UiTransform as d_, AxisExplanation as da, DEFAULT_TEXT_COLOR as dc, inputsEqual as dd, UiThemeExtensions as df, UiColors as dg, tightenConstraints as dh, clickOutside as di, Row as dl, isUiElement as dm, PaintOp as dn, UiDroppedFile as do, spansDifferOnlyInPaint as dp, DefaultVideoResolver as dr, scrollRange as ds, Affine as dt, normalizeStates as du, UiDurationToken as e_, parseMainAxisAlignment as ea, fillTextRects as ec, visualState as ed, lightTheme as ef, borderRadiusEqual as eg, slideUp as eh, AutoScrollOptions as ei, LazyColumn as el, FocusOptions as em, PaintCanvas as en, EditingHost as eo, UiTextMetrics as ep, SizeContainerArgs as er, UiHitTester as es, Mp4Sample as et, UiPropertyValues as eu, SemanticsSpan as f, UiTransforms as f_, CustomLayoutExplanation as fa, ObjectFit as fc, paintValuesEqual as fd, defineThemeExtension as ff, colorsEqualPalette as fg, NodeId as fh, autoFocus as fi, ScrollView as fl, UiPropValue as fm, PaintRecorder as fn, UiFileDropMessage as fo, textContentOf as fp, DefaultVideoResolverOptions as fr, scrollbarThumb as fs, CLIP_STRIDE_BYTES as ft, statesEqual as fu, buildSemanticsSubtree as g, transformsEqual as g_, OverrideSources as ga, TextAlign as gc, MAX_GRADIENT_STOPS as gd, themeExtensionsEqual as gf, CharacterCountTextMeasurer as gg, UiPropertyOverride as gh, FocusRingOptions as gi, UiDefinition as gl, UiInputDispatcher as gm, SvgFit as gn, UiShortcutBinding as go, defaultSpacing as gp, canDecodeVideo as gr, SubtreeBounds as gs, INSTANCE_STRIDE_BYTES as gt, EditUnit as gu, UiSemanticsRecord as h, transformIsIdentity as h_, LayoutStateExplanation as ha, PaintTextSpan as hc, GradientPaint as hd, themeExtension as hf, LayoutRecord as hg, UiNodeTransitions as hh, Decorations as hi, createElement as hl, UiEventListenerOptions as hm, SvgDrawOptions as hn, UiShortcut as ho, UiSpacing as hp, VideoResolver as hr, scrollsFromRight as hs, GlyphCommand as ht, CompositionRange as hu, UiSemanticsPatch as i, UiSpringToken as i_, layoutParagraph as ia, textRunBackgrounds as ic, PaintLineCap as id, UiLengths as if, uniformBorderRadius as ig, LayoutBox as ih, dragSource as ii, LazyRow as il, ComponentLikeElement as im, paintPictures as in, UiTouchScroller as io, defaultTextStyle as ip, ScrollPositionArgs as ir, SCROLLBAR_MIN_THUMB as is, Mp3Format as it, UiLiveRegion as iu, paragraphGeometry as j, steps as j_, UiHostFrameClockOptions as ja, selectionRangeOf as jc, MinMaxTrack as jd, UiBoxShadows as jf, spannedRunsFor as jg, UiCursor as jh, Transform as ji, EnvironmentProps as jl, UiPointerKind as jm, LayoutReader as jn, UiWheelController as jo, unknownContainerSize as jp, IconSpec as jr, caretVisibleAt as js, glyphCount as jt, LazyItemRenderer as ju, hasDrawnText as k, easings as k_, UiFrameTime as ka, selectableTextNodes as kc, AutoLength as kd, BOX_SHADOW_BLUR_REACH as kf, TextRunStyle as kg, UiColorValue as kh, bundle as ki, ContainerProps as kl, UiPointerDevice as km, RendererBackend as kn, UiScrollBehavior as ko, bandOf as kp, IconRasterizer as kr, CARET_WIDTH as ks, buildRenderList as kt, LazyAxis as ku, SemanticsPlacement as l, interpolateTransform as l_, SCROLLBAR_LINGER_MS as la, DEFAULT_FONT_SIZE as lc, UiPaint as ld, UiThemeExtension as lf, isShapeName as lg, clampSize as lh, draggable as li, Grid as ll, isObservable$1 as lm, tracePathData as ln, UiDropEffect as lo, spanAtOffset as lp, VideoTransport as lr, scrollBounds as ls, splitMp3Frames as lt, isUiRole as lu, UiSemanticsMap as m, transform as m_, LayoutExplanation as ma, PaintState as mc, UiImage as md, noThemeExtensions as mf, lightColors as mg, UiNode as mh, BordersOptions as mi, Text as ml, UiEventListener as mm, replayPaint as mn, ShortcutRegistryOptions as mo, textStylesEqual as mp, VideoPlayback as mr, scrollbarZoneAt as ms, CommandKind as mt, validateStates as mu, UiSemanticsBox as n, UiMotion as n_, parseFlexDirection as na, runCanvasStyleInto as nc, PaintBox as nd, withContrast as nf, borderRadiusValuesEqual as ng, UiSharedElements as nh, DropTargetOptions as ni, LazyGridProps as nl, UiFocusManager as nm, PaintPictureCache as nn, UiEditingController as no, UiTextSpan as np, sizeContainer as nr, SCROLLBAR_HOVER_ZONE as ns, demuxMp4Audio as nt, UI_SEMANTIC_STATES as nu, dropIndexShifts as o, UiInterpolator as o_, LayoutNotifier as oa, Canvas2DContext as oc, PaintSurface as od, defaultUnits as of, UiShapeName as og, LayoutStats as oh, reorderable as oi, Button as ol, UiElement as om, PaintGradient as on, UiDragPayload as oo, flattenTextSpans as op, VideoClock as or, ScrollBounds as os, Mp3Frames as ot, UiRole as ou, TEXT_RUN_ID_SEPARATOR as p, parseTransform as p_, Edges as pa, PaintBoxShadow as pc, pathValuesEqual as pd, hasThemeExtension as pf, darkColors as pg, NodeProperty as ph, BorderEdge as pi, Stack as pl, UiProps as pm, PaintRecording as pn, dragSessionFor as po, textSpansEqual as pp, RangeResponse as pr, scrollbarThumbs as ps, CLIP_STRIDE_FLOATS as pt, validateRole as pu, parseWebVtt as q, UiPlatformAdapter as qa, nextGraphemeEnd as qc, propertyValuesEqual as qd, UiFontStretch as qf, UiAnimationOptions as qg, UiThemeColorName as qh, placeGridItems as qi, TextProps as ql, isMotionRest as qm, themeTokens as qn, UiFindController as qo, assertModifierList as qp, ShortcutsOptions as qr, SpanPaint as qs, WebGPUCanvasHost as qt, UiLayoutContext as qu, UiSemanticsUpdate as r, UiSpringSpec as r_, ELLIPSIS as ra, runFontString as rc, PaintFillRule as rd, withDensity as rf, normalizeBorderRadius as rg, Constraints as rh, ReorderableOptions as ri, LazyListProps as rl, ComponentResolver as rm, PaintStats as rn, TouchScrollerOptions as ro, UiTextStyle as rp, ScrollOffset as rr, SCROLLBAR_INSET as rs, demuxMp4Video as rt, UiAutocomplete as ru, recordsEqual as s, interpolateColor as s_, LayoutEngine as sa, Canvas2DGradient as sc, PaintTextAlign as sd, lengths as sf, UiShapes as sg, Size as sh, DragOffset as si, Column as sl, UiSourceLocation as sm, PaintResolver as sn, UiDragSession as so, hiddenRangesOf as sp, VideoSourceArgs as sr, ScrollbarAxis as ss, Mp3Header as st, UiSemanticState as su, UiSemanticsAction as t, UiEasingToken as t_, FlexDirection as ta, layoutTextLines as tc, visualStatesEqual as td, themesEqual as tf, borderRadiusIsZero as tg, SharedClaim as th, DragSourceOptions as ti, LazyGrid as tl, FocusSource as tm, PaintCanvasFactory as tn, EditingState as to, UiTextRange as tp, breakpoint as tr, UiPoint as ts, Mp4VideoTrack as tt, UI_ROLES as tu, SemanticsReuse as u, interpolatorFor as u_, ScrollAdjustment as ua, DEFAULT_FONT_WEIGHT as uc, UiPath as ud, UiThemeExtensionOptions as uf, shapesEqual as ug, constraintsEqual as uh, ClickOutsideOptions as ui, Paint as ul, isUiChild as um, EMPTY_RECORDING as un, UiDropZone as uo, spannedTextOf as up, videoSource as ur, scrollLeaderOf as us, WebGPUGlyphPages as ut, isUiSemanticState as uu, rewalkSemantics as v, UiColor as v_, SizeDecision as va, colorToCss as vc, ResolvedGradientStop as vd, HighContrastOptions as vf, FontMetrics as vg, DecorationFill as vh, borders as vi, UiBinding as vl, MOUSE_POINTER as vm, svgPaint as vn, UiShortcutStep as vo, spacingEqual as vp, SharedElementArgs as vr, clearMatchRanges as vs, ImageCommand as vt, LazySheet as vu, linkHoverOf as w, parseColor as w_, withOverrideSource as wa, resolvePaintState as wc, gradientPaint as wd, UiDensity as wf, TextMeasureRequest as wg, hasDecorationPhase as wh, interactive as wi, BoxModelProps as wl, UiInputEvent as wm, Canvas2DRenderer as wn, UiKeyboardController as wo, insetsEqual as wp, iconSource as wr, UiEnvironmentProvider as ws, RenderTextCache as wt, SheetViewport as wu, textRunOfRecordId as x, colorValuesEqual as x_, formatConstraints as xa, isPaintVisible as xc, UiGradientStop as xd, highContrastColors as xf, SpannedRuns as xg, DecorationStroke as xh, BUTTON_INTERACTION as xi, ChildrenBindingId as xl, UiEventType as xm, LayoutInspector as xn, parseShortcut as xo, UiInsetRegistry as xp, IconSourceArgs as xr, FindMatch as xs, PrimitiveKind as xt, SheetRange as xu, semanticsInertAbove as y, colorToHex as y_, describeLength as ya, computeObjectFitRect as yc, UiGradient as yd, UiContrast as yf, ParagraphLayout as yg, DecorationRect as yh, decorated as yi, UiGraph as yl, UiBeforeInputEvent as ym, INSPECTOR_HEAT_MS as yn, describeShortcut as yo, spacingSteps as yp, motion as yr, matchRangesOf as ys, NO_CLIP_INDEX as yt, LazySheetProps as yu, markInstant as z, isNodeTabStop as za, lineLimit as zc, isMinMaxTrack as zd, shadowsOf as zf, UiTransitionSpec as zg, UiPointerEvents as zh, propertyEffects as zi, PaintProps as zl, MOTION_CHANNELS as zm, CanvasSurface as zn, NodeTransitions as zo, comparePositions as zp, parseSvg as zr, EditCommand as zs, initializeWebGPU as zt, VirtualUpdate as zu };
-//# sourceMappingURL=index-B5r1ETCh.d.ts.map
+export { Mp4AudioTrack as $, steps as $_, UiPlatformAdapter as $a, nextGraphemeEnd as $c, defineProperty as $d, typographyEqual as $f, UiTransitionValue as $g, UiBorderRadius as $h, placeGridItems as $i, TextProps as $l, ResolvedMotionState as $m, InsetPaddingArgs as $n, UiFindController as $o, UiModifierSet as $p, shortcut as $r, SpanPaint as $s, registerFontStack as $t, UiLayoutContext as $u, offsetAtPointIn as A, interpolateTransform as A_, withOverrideSource as Aa, resolvePaintState as Ac, UiRadialGradient as Ad, relativeLuminance as Af, TextRunMeasurer as Ag, UiAlignment as Ah, interactive as Ai, BoxModelProps as Al, UiFocusEvent as Am, traceRoundedRect as An, UiKeyboardController as Ao, UiInsetSource as Ap, mediaLoadsInFlight as Ar, UiEnvironmentProvider as As, createTextCache as At, SheetViewport as Au, markNow as B, colorToHex as B_, UiTimerFrameClockOptions as Ba, PlacedLine as Bc, UiLength as Bd, boxShadow as Bf, TightenOptions as Bg, UiOverflow as Bh, closestPropertyName as Bi, GridItemProps as Bl, UiSelectionChangeEvent as Bm, drawOverlayShapes as Bn, GestureRecognizerOptions as Bo, UiTextInput as Bp, isSvgSource as Br, isEditableNode as Bs, isWebGPUAvailable as Bt, UiVirtualWindow as Bu, hasTextLinks as C, defineMotion as C_, RelayoutExplanation as Ca, VerticalAlign as Cc, MAX_GRADIENT_STOPS as Cd, themeExtensionsEqual as Cf, ParagraphTextMeasurer as Cg, DecorationShape as Ch, decorated as Ci, BindingId as Cl, UiEventListenerOptions as Cm, INSPECTOR_HEAT_MS as Cn, UiShortcutRegistry as Co, UiSpacing as Cp, motion as Cr, TEXT_MATCHES_PROP as Cs, RenderList as Ct, EditableTextModel as Cu, setLinkHover as D, UiInterpolator as D_, formatConstraints as Da, isPaintVisible as Dc, UiGradientOffset as Dd, contrastRatio as Df, TextMeasureRequest as Dg, hasDecorationPhase as Dh, ShownAsKey as Di, ChildrenBindingId as Dl, UiBeforeInputEvent as Dm, CanvasTextMeasurer as Dn, parseShortcut as Do, spacingSteps as Dp, ImageSources as Dr, FindMatch as Ds, TEXTURED_STRIDE_FLOATS as Dt, SheetRange as Du, linkRunAtPointIn as E, springIn as E_, describeOverrides as Ea, createPaintState as Ec, UiGradient as Ed, UiContrast as Ef, TextLineRun as Eg, decorationRect as Eh, InteractiveOptions as Ei, UiEventBinding as El, MOUSE_POINTER as Em, LayoutInspectorOptions as En, formatShortcut as Eo, spacingEqual as Ep, ImageSourceArgs as Er, setMatchRanges as Es, TEXTURED_STRIDE_BYTES as Et, SheetHeaderRenderer as Eu, UiFrameCallback as F, transform as F_, UiFrameTime as Fa, selectableTextNodes as Fc, validateGradient as Fd, shadowsEqual as Ff, Constraints as Fg, UiDirection as Fh, bundle as Fi, ContainerProps as Fl, UiPasteEvent as Fm, LayoutReader as Fn, UiScrollBehavior as Fo, UiContainerSize as Fp, IconSpec as Fr, CARET_WIDTH as Fs, GlyphSlot as Ft, LazyAxis as Fu, VttTrack as G, parseColor as G_, isNodeTabStop as Ga, lineLimit as Gc, isFrLength as Gd, boxShadowsEqual as Gf, UiEnvironmentKey as Gg, UiSubgridAxis as Gh, propertyEffects as Gi, PaintProps as Gl, wheelDeltaYOf as Gm, resolveBoolean as Gn, NodeTransitions as Go, UiTextPosition as Gp, DefaultImageResolverOptions as Gr, EditCommand as Gs, WebGPURenderer as Gt, VirtualUpdate as Gu, performanceMarksEnabled as H, colorValuesEqual as H_, isNodeHitTestable as Ha, caretRectFor as Hc, auto as Hd, boxShadowRadius as Hf, constraintsEqual as Hg, UiPointerEvents as Hh, getPropertyNames as Hi, IdentityProps as Hl, UiWheelDeltaMode as Hm, CanvasHost as Hn, PinchRecognizerOptions as Ho, textInputOf as Hp, SvgRect as Hr, isReadOnly as Hs, CapturedFrame as Ht, VIRTUAL_LEAD_PROP as Hu, UiScheduler as I, transformIsIdentity as I_, UiHostFrameClock as Ia, selectableTextOf as Ic, AutoLength as Id, BOX_SHADOW_BLUR_REACH as If, LayoutBox as Ig, UiFlexWrap as Ih, noModifiers as Ii, EditableTextProps as Il, UiPinchEvent as Im, RenderChanges as In, UiScrollability as Io, UiContainerSizeSource as Ip, iconKey as Ir, EDITOR_PROP as Is, GlyphUpload as It, LazyGridOptions as Iu, ByteSource as J, UiEasing as J_, resolveCursor as Ja, offsetForVerticalMove as Jc, minmax as Jd, UiTypography as Jf, findEnvironmentKey as Jg, UiTextOverflowValue as Jh, propertyValuesEqualByName as Ji, Reactive as Jl, MOTION_REST as Jm, resolvePropertyByName as Jn, overrideSources as Jo, edgeField as Jp, animateLayout as Jr, detectEditingPlatform as Js, WebGPUSurface as Jt, UiVideoSurface as Ju, cueAt as K, rgb8 as K_, isSubtreeInert as Ka, offsetAtPoint as Kc, isMinMaxTrack as Kd, fittedShadowRadius as Kf, UiProvision as Kg, UiTextAlign as Kh, propertyIsInherited as Ki, PositionProps as Kl, DirtyNodeSet as Km, resolveNumber as Kn, resetTransitionWarnings as Ko, adjacentField as Kp, ImageResolver as Kr, EditingPlatform as Ks, WebGPURendererOptions as Kt, VirtualViewport as Ku, UiSchedulerOptions as L, transformsEqual as L_, UiHostFrameClockOptions as La, selectionRangeOf as Lc, FrLength as Ld, UiBoxShadow as Lf, LayoutResult as Lg, UiFontWeight as Lh, Transform as Li, EnvironmentProps as Ll, UiPointerDevice as Lm, RenderContext as Ln, UiWheelController as Lo, bandOf as Lp, DefaultSvgResolver as Lr, caretVisibleAt as Ls, WebGPUGlyphAtlas as Lt, LazyItemRenderer as Lu, paragraphGeometryFrom as M, UiTransform as M_, UiAnimationFrameClock as Ma, TEXT_SELECTION_PROP as Mc, gradientsEqual as Md, densityFactors as Mf, TextRunStyle as Mg, UiColorValue as Mh, measureFlow as Mi, ButtonProps as Ml, UiInputEvent as Mm, ScrollLayerStats as Mn, UiPointerController as Mo, insetsEqual as Mp, IconContext as Mr, UiEnvironmentKeys as Ms, textRuns as Mt, UiVirtualSheetOptions as Mu, selectionRectsIn as N, UiTransforms as N_, UiFrameClock as Na, TextRange as Nc, linearGradient as Nd, UiShadows as Nf, TextWrap as Ng, UiContentDistribution as Nh, pressable as Ni, ColumnProps as Nl, UiKeyModifiers as Nm, RendererBackend as Nn, ScrollContainerState as No, noInsets as Np, IconRasterizer as Nr, EnvironmentNotifier as Ns, GlyphShaper as Nt, VIRTUAL_SHEET_PROP as Nu, ParagraphGeometry as O, interpolateColor as O_, formatExplanation as Oa, normalizeTextAlign as Oc, UiGradientStop as Od, highContrastColors as Of, TextMeasurer as Og, paintsAfterChildren as Oh, UiShownAs as Oi, UiChildrenBinding as Ol, UiCompositionEvent as Om, Canvas2DRenderer as On, shortcutKeyCaps as Oo, UiInsetEdge as Op, iconSource as Or, FindOptions as Os, TextRunDraw as Ot, SheetRowRenderer as Ou, wordRangeIn as P, parseTransform as P_, UiFrameClockFactory as Pa, clearSelectionRange as Pc, radialGradient as Pd, defaultShadows as Pf, spannedRunsFor as Pg, UiCursor as Ph, UiModifierBundle as Pi, CommonProps as Pl, UiKeyboardEvent as Pm, UiRenderer as Pn, ScrollSink as Po, observeViewportInsets as Pp, IconRasterizerOptions as Pr, CARET_BLINK_MS as Ps, GLYPH_SUBPIXEL_PHASES as Pt, sheetSource as Pu, rangeSource as Q, linear as Q_, PlatformSurface as Qa, lineStartAt as Qc, UiPropertyDefinition as Qd, isTypographyRole as Qf, UiTransitionSpec as Qg, validateSubgrid as Qh, GridTrack as Qi, TextContentProps as Ql, MotionTiming as Qm, sameArgs as Qn, FindHost as Qo, UiModifierLayout as Qp, contextMenu as Qr, PlacedTextRun as Qs, fontStackFor as Qt, UiLayoutChild as Qu, MARK_PREFIX as R, UiBasicColors as R_, UiManualFrameClock as Ra, setSelectionRange as Rc, MinMaxTrack as Rd, UiBoxShadows as Rf, LayoutStats as Rg, UiGridAutoFlow as Rh, accumulatedOffsetTo as Ri, FlexContainerProps as Rl, UiPointerEvent as Rm, LABEL_PADDING_X as Rn, isScrollContainer as Ro, containerBands as Rp, DefaultSvgResolverOptions as Rr, editorFor as Rs, WebGPUTextureCache as Rt, LazyListOptions as Ru, clearLinkHover as S, defaultMotion as S_, OverrideSources as Sa, TextAlign as Sc, GradientPaint as Sd, themeExtension as Sf, ParagraphLayout as Sg, DecorationRect as Sh, borders as Si, UiDefinition as Sl, UiEventListener as Sm, svgPaint as Sn, UiShortcutBinding as So, textStylesEqual as Sp, SharedElementArgs as Sr, SubtreeBounds as Ss, RenderCommand as St, EditUnit as Su, linkOf as T, easingIn as T_, describeLength as Ta, computeObjectFitRect as Tc, ResolvedGradientStop as Td, HighContrastOptions as Tf, TextLine as Tg, decorationColor as Th, BUTTON_INTERACTION as Ti, UiGraph as Tl, UiListenerErrorReporter as Tm, LayoutInspector as Tn, describeShortcut as To, scaleSpacing as Tp, IconSourceArgs as Tr, matchRangesOf as Ts, ScissorRect as Tt, LazySheetProps as Tu, setPerformanceMarks as U, colorsEqual as U_, isNodeInert as Ua, lineIndexAtY as Uc, fr as Ud, boxShadowReach as Uf, tightenConstraints as Ug, UiPosition as Uh, inheritedPropertyFlags as Ui, InteractionProps as Ul, UiWheelEvent as Um, CanvasSurface as Un, UiPinchRecognizer as Uo, UiEditingGroup as Up, parseSvg as Ur, nextCaretToggle as Us, DrawStats as Ut, VIRTUAL_WINDOW_PROP as Uu, measureSpan as V, colorToRgba as V_, isNodeFocusable as Va, RunMeasure as Vc, UiTrackSize as Vd, boxShadowArraysEqual as Vf, clampSize as Vg, UiPlacement as Vh, findPropertyDefinition as Vi, GridProps as Vl, UiTextChangeEvent as Vm, labelOrigin as Vn, UiGestureRecognizer as Vo, UiTextInputState as Vp, SvgDocument as Vr, isMultiline as Vs, WebGPUError as Vt, VIRTUAL_INDEX_PROP as Vu, VttCue as W, normalizeColor as W_, isNodeSelectable as Wa, lineIndexForOffset as Wc, isAutoLength as Wd, boxShadowValuesEqual as Wf, UiEnvironment as Wg, UiSelfAlignment as Wh, inheritedPropertyNames as Wi, PaintElementProps as Wl, noKeyModifiers as Wm, createCanvasSurface as Wn, FocusNotifier as Wo, UiGroupEdit as Wp, DefaultImageResolver as Wr, syncEditorValue as Ws, RenderHooks as Wt, VirtualItemMeasure as Wu, RangeSourceOptions as X, easingCss as X_, PlatformAdapterOptions as Xa, graphemeBoundaries as Xc, repeat as Xd, UiTypographyRole as Xf, UiNodeType as Xg, UiThemeColorName as Xh, GridItemRequest as Xi, ScrollViewProps as Xl, MotionState as Xm, ThemeTokenTarget as Xn, writeDeclaredProperty as Xo, UiModifierEnvironment as Xp, ShortcutOptions as Xr, EditableLayout as Xs, bumpFontStack as Xt, videoFrameSize as Xu, DEFAULT_BLOCK_SIZE as Y, cubicBezier as Y_, CanvasPlatformSurface as Ya, selectionRects as Yc, percent as Yd, UiTypographyExtensions as Yf, provided as Yg, UiTextWrapValue as Yh, GridContribution as Yi, RowProps as Yl, MotionChannel as Ym, resolveString as Yn, resetOverrideWarnings as Yo, editingGroupOf as Yp, ContextMenuOptions as Yr, isPrintable as Ys, createWebGPUSurface as Yt, isVideoSurface as Yu, bufferSource as Z, easings as Z_, PlatformEventTarget as Za, lineEndAt as Zc, resolveLength as Zd, defaultTypography as Zf, DirtyFlags as Zg, UiVerticalAlign as Zh, GridPlacement as Zi, StackProps as Zl, MotionStateInput as Zm, themeTokens as Zn, writeOverrideProperty as Zo, UiModifierFocus as Zp, ShortcutsOptions as Zr, CanvasTextStyle as Zs, clearFontStacks as Zt, MAX_MEASURES_PER_CHILD as Zu, buildSemanticsTree as _, UiMotion as __, AxisExplanation as _a, DEFAULT_TEXT_COLOR as _c, UiPath as _d, UiThemeExtensionOptions as _f, lightColors as _g, UiNode as _h, BorderEdge as _i, Row as _l, isObservable$1 as _m, PaintRecording as _n, UiDroppedFile as _o, spanAtOffset as _p, RangeResponse as _r, scrollRange as _s, INSTANCE_STRIDE_FLOATS as _t, normalizeStates as _u, diffSemantics as a, UiAnimation as a_, parseCrossAxisAlignment as aa, drawText as ac, hasVisualState as ad, UiTheme as af, borderRadiusValuesEqual as ag, scaleFrom as ah, DragSourceOptions as ai, ResponsiveProps as al, isUiModifier as am, PaintContext2D as an, EditingControllerOptions as ao, UiSpannedText as ap, breakpoint as ar, HitTester as as, Mp3Frame as at, UiPropertyValueOf as au, semanticsMemory as b, UiSpringSpec as b_, LayoutExplanation as ba, PaintState as bc, pathValuesEqual as bd, hasThemeExtension as bf, FixedMetricsOptions as bg, UiPropertyOverrides as bh, FocusRingOptions as bi, Text as bl, UiPropValue as bm, SvgFit as bn, ShortcutRegistryOptions as bo, textContentOf as bp, canDecodeVideo as br, scrollbarZoneAt as bs, PrimitiveCommand as bt, validateStates as bu, SemanticsMemory as c, UiSpring as c_, parseFlexDirection as ca, runCanvasStyleInto as cc, PaintBox as cd, themesEqual as cf, UiShapeExtensions as cg, slideUp as ch, dragSource as ci, LazyGridProps as cl, FocusOptions as cm, PaintLayers as cn, UiEditingController as co, UiTextMetrics as cp, ScrollPositionArgs as cr, SCROLLBAR_HOVER_ZONE as cs, readMp3Header as ct, UI_SEMANTIC_STATES as cu, SemanticsRewalk as d, UiTweenOptions as d_, proportionalFontMetrics as da, textRunDecorations as dc, PaintLineJoin as dd, UiLengths as df, defaultShapes as dg, AnimationDriver as dh, DragOffset as di, Box as dl, ComponentResolver as dm, PaintResolver as dn, EXTERNAL_FILES as do, UiTextStyle as dp, VideoSourceArgs as dr, SCROLLBAR_THICKNESS as ds, Affine as dt, UiOrientation as du, assertTransitionMap as e_, sizeGridTracks as ea, TextLinePlacement as ec, UiLayoutProtocol as ed, propertyValuesEqual as ef, UiBorderRadiuses as eg, fade as eh, shortcuts as ei, nextWordEnd as el, UiUnknownModifierPropertyError as em, PaintPictureCache as en, capturePointer as eo, UiFontKerning as ep, PublishInsetArgs as er, SelectionControllerOptions as es, Mp4Sample as et, TypographyProps as eu, SemanticsSpan as f, createTween as f_, LayoutNotifier as fa, Canvas2DContext as fc, PaintMaskMode as fd, UiUnits as ff, isShapeName as fg, UiClock as fh, DraggableOptions as fi, Button as fl, ComponentLikeElement as fm, PaintTarget as fn, UiDragPayload as fo, defaultTextStyle as fp, VideoState as fr, ScrollBounds as fs, CLIP_STRIDE_BYTES as ft, UiRole as fu, buildSemanticsSubtree as g, UiEasingToken as g_, ScrollAdjustment as ga, DEFAULT_FONT_WEIGHT as gc, UiPaint as gd, UiThemeExtension as gf, darkColors as gg, NodeProperty as gh, autoFocus as gi, Paint as gl, isComponentLikeElement as gm, PaintRecorder as gn, UiDropZone as go, resolvedSpansOf as gp, DefaultVideoResolverOptions as gr, scrollLeaderOf as gs, INSTANCE_STRIDE_BYTES as gt, isUiSemanticState as gu, UiSemanticsRecord as h, UiEasingExtensions as h_, SCROLLBAR_LINGER_MS as ha, DEFAULT_FONT_SIZE as hc, PaintTextStyle as hd, unitsEqual as hf, colorsEqualPalette as hg, NodeId as hh, clickOutside as hi, Grid as hl, UiSourceLocation as hm, PaintOp as hn, UiDropEffect as ho, hiddenRangesOf as hp, DefaultVideoResolver as hr, scrollBounds as hs, GlyphCommand as ht, isUiRole as hu, UiSemanticsPatch as i, AnimatedCell as i_, parseAlignContent as ia, createCanvasTextStyle as ic, defaultVisualState as id, withPointer as if, borderRadiusIsZero as ig, rotateFrom as ih, AutoScrollOptions as ii, Responsive as il, defineModifier as im, PaintCanvasFactory as in, touchActionFor as io, UiResolvedTextSpan as ip, SizeContainerArgs as ir, HitTestResult as is, Mp3Format as it, UiPropertyName as iu, paragraphGeometry as j, interpolatorFor as j_, UiFrame as ja, DEFAULT_LINE_HEIGHT_FACTOR as jc, gradientPaint as jd, UiDensity as jf, TextRunSpan as jg, UiBorderRadiusValue as jh, measure as ji, BoxProps as jl, UiGestureEvent as jm, LayerCanvasFactory as jn, PointerControllerOptions as jo, UiInsets as jp, IconCanvas as jr, provideEnvironment as js, glyphCount as jt, UiVirtualSheet as ju, hasDrawnText as k, interpolateNumber as k_, labelNode as ka, normalizeVerticalAlign as kc, UiLinearGradient as kd, raiseContrast as kf, TextOverflow as kg, UI_SUBGRID_AXES as kh, hoverable as ki, UiGraphBuilder as kl, UiEventType as km, Canvas2DRendererOptions as kn, KeyboardControllerOptions as ko, UiInsetRegistry as kp, imageSource as kr, findMatchesIn as ks, buildRenderList as kt, SheetSourceArgs as ku, SemanticsPlacement as l, UiSpringOptions as l_, ELLIPSIS as la, runFontString as lc, PaintFillRule as ld, withContrast as lf, UiShapeName as lg, SharedClaim as lh, dropTarget as li, LazyListProps as ll, FocusSource as lm, PaintMatrix as ln, TouchScrollerOptions as lo, UiTextRange as lp, scrollPosition as lr, SCROLLBAR_INSET as ls, splitMp3Frames as lt, UiAutocomplete as lu, UiSemanticsMap as m, UiDurationToken as m_, SCROLLBAR_FADE_MS as ma, DEFAULT_FONT_FAMILY as mc, PaintTextAlign as md, lengths as mf, UiColors as mg, motionOf as mh, ClickOutsideOptions as mi, EditableText as ml, UiElement as mm, EMPTY_RECORDING as mn, UiDragState as mo, flattenTextSpans as mp, videoSource as mr, ScrollbarThumb as ms, CommandKind as mt, UiSemanticStates as mu, UiSemanticsBox as n, spring as n_, CrossAxisAlignment as na, applyCanvasTextStyle as nc, UiVisualState as nd, UiPointer as nf, borderRadiusCorners as ng, pop as nh, ZoomState as ni, previousWordStart as nl, UiModifier as nm, paintPictures as nn, pointerDeviceOf as no, UiFontStyle as np, publishInset as nr, UiSelectionController as ns, demuxMp4Audio as nt, UiNodeRef as nu, dropIndexShifts as o, UiAnimationOptions as o_, parseMainAxisAlignment as oa, fillTextRects as oc, visualState as od, darkTheme as of, normalizeBorderRadius as og, slideDown as oh, DropTargetOptions as oi, LazyColumn as ol, UiModifierHost as om, PaintDeviceRect as on, EditingHost as oo, UiTextDecoration as op, sizeContainer as or, UiHitTester as os, Mp3Frames as ot, UiPropertyValues as ou, TEXT_RUN_ID_SEPARATOR as p, UiDurationExtensions as p_, LayoutEngine as pa, Canvas2DGradient as pc, PaintSurface as pd, defaultUnits as pf, shapesEqual as pg, clockOf as ph, draggable as pi, Column as pl, UiChild as pm, tracePathData as pn, UiDragSession as po, editableSpansOf as pp, VideoTransport as pr, ScrollbarAxis as ps, CLIP_STRIDE_FLOATS as pt, UiSemanticState as pu, parseWebVtt as q, rgba as q_, pointerEventsOf as qa, offsetAtX as qc, isPercentLength as qd, shadowsOf as qf, createEnvironmentKey as qg, UiTextDirection as qh, propertyNarrowers as qi, PropsOf as ql, MOTION_CHANNELS as qm, resolveProperty as qn, clearOverrideProperty as qo, comparePositions as qp, AnimateLayoutOptions as qr, commandForKey as qs, WebGPUCanvasHost as qt, lazySource as qu, UiSemanticsUpdate as r, tween as r_, MainAxisAlignment as ra, buildFontString as rc, UiVisualStateSet as rd, UiThemeTouch as rf, borderRadiusEqual as rg, resolveMotionState as rh, pinchable as ri, wordRangeAt as rl, UiModifierKind as rm, PaintCanvas as rn, prepareInputSurface as ro, UiFontVariant as rp, BreakpointArgs as rr, HitTestLayoutReader as rs, demuxMp4Video as rt, UiProperties as ru, recordsEqual as s, UiReducedMotionPolicy as s_, FlexDirection as sa, layoutTextLines as sc, visualStatesEqual as sd, lightTheme as sf, uniformBorderRadius as sg, slideFrom as sh, ReorderableOptions as si, LazyGrid as sl, UiModifierTeardown as sm, PaintGradient as sn, EditingState as so, UiTextLink as sp, ScrollOffset as sr, UiPoint as ss, Mp3Header as st, UI_ROLES as su, UiSemanticsAction as t, normalizeTransition as t_, AlignContent as ta, TextRunRect as tc, isLayoutProtocol as td, TOUCH_TARGET as tf, borderRadius as tg, isMotionRest as th, PinchableOptions as ti, previousGraphemeStart as tl, assertModifierList as tm, PaintStats as tn, isImeKey as to, UiFontStretch as tp, insetPadding as tr, SelectionHost as ts, Mp4VideoTrack as tt, UiEventProps as tu, SemanticsReuse as u, UiTween as u_, layoutParagraph as ua, textRunBackgrounds as uc, PaintLineCap as ud, withDensity as uf, UiShapes as ug, UiSharedElements as uh, reorderable as ui, LazyRow as ul, UiFocusManager as um, PaintPixels as un, UiTouchScroller as uo, UiTextSpan as up, VideoClock as ur, SCROLLBAR_MIN_THUMB as us, WebGPUGlyphPages as ut, UiLiveRegion as uu, rewalkSemantics as v, UiMotionChanges as v_, CustomLayoutExplanation as va, ObjectFit as vc, inputsEqual as vd, UiThemeExtensions as vf, LayoutRecord as vg, UiNodeTransitions as vh, BordersOptions as vi, ScrollView as vl, isUiChild as vm, replayPaint as vn, UiFileDropMessage as vo, spannedTextOf as vp, VideoPlayback as vr, scrollbarThumb as vs, ImageCommand as vt, statesEqual as vu, linkHoverOf as w, durationIn as w_, SizeDecision as wa, colorToCss as wc, ResolvedGradient as wd, withThemeExtension as wf, SpannedRuns as wg, DecorationStroke as wh, focusRing as wi, UiBinding as wl, UiInputDispatcher as wm, InspectorOverlay as wn, UiShortcutStep as wo, defaultSpacing as wp, sharedElement as wr, clearMatchRanges as ws, RenderTextCache as wt, LazySheet as wu, textRunOfRecordId as x, UiSpringToken as x_, LayoutStateExplanation as xa, PaintTextSpan as xc, UiImage as xd, noThemeExtensions as xf, FontMetrics as xg, DecorationFill as xh, borderShapes as xi, createElement as xl, UiProps as xm, drawSvg as xn, UiShortcut as xo, textSpansEqual as xp, MotionArgs as xr, scrollsFromRight as xs, PrimitiveKind as xt, CompositionRange as xu, semanticsInertAbove as y, UiSpringExtensions as y_, Edges as ya, PaintBoxShadow as yc, paintValuesEqual as yd, defineThemeExtension as yf, CharacterCountTextMeasurer as yg, UiPropertyOverride as yh, Decorations as yi, Stack as yl, isUiElement as ym, SvgDrawOptions as yn, dragSessionFor as yo, spansDifferOnlyInPaint as yp, VideoResolver as yr, scrollbarThumbs as ys, NO_CLIP_INDEX as yt, validateRole as yu, markInstant as z, UiColor as z_, UiTimerFrameClock as za, CaretRect as zc, PercentLength as zd, UiShadowName as zf, Size as zg, UiObjectFit as zh, contentOffset as zi, FlexItemProps as zl, UiPointerKind as zm, OverlayShape as zn, GestureInput as zo, unknownContainerSize as zp, SvgResolver as zr, editorOf as zs, initializeWebGPU as zt, LazySourceArgs as zu };
+//# sourceMappingURL=index-CQPJZwhG.d.ts.map