gesso-core 0.6.30 → 0.7.0

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

@@ -1685,6 +1685,18 @@ interface UiColors {
   readonly focusRing: UiColor;
   readonly selectionBackground: UiColor;
   readonly selectionForeground: UiColor;
+  /**
+   * A tooltip's box and its text.
+   *
+   * Their own pair rather than the control pair swapped round, which is
+   * what a tooltip used to be: that is dark on a light page, but on a
+   * dark one it turned the tooltip near-white, the brightest thing on
+   * the screen for a label that should sit quietly over it. A tooltip
+   * stays dark in both palettes, as the platforms draw theirs; in the
+   * dark one a step lighter than the panels, so it lifts off them.
+   */
+  readonly tooltipBackground: UiColor;
+  readonly tooltipForeground: UiColor;
 }
 /**
  * The stock palettes.
@@ -3111,6 +3123,22 @@ type UiPropValue = unknown | Observable<unknown>;
 type UiProps = Record<string, UiPropValue>;
 //#endregion
 //#region src/composition/UiElement.d.ts
+/**
+ * Where an element was written: the location the JSX compiler passes
+ * `jsxDEV` in development.
+ *
+ * Kept so a tool can go from a node on screen back to the line that
+ * made it, which a canvas otherwise cannot do: there is no DOM for a
+ * browser's own inspector to point at. A production build compiles to
+ * `jsx`, which is given none, so it costs nothing there.
+ */
+interface UiSourceLocation {
+  readonly fileName: string;
+  /** One-based, as the compiler gives it. */
+  readonly lineNumber: number;
+  /** One-based, as the compiler gives it. */
+  readonly columnNumber: number;
+}
 /**
  * Opaque marker for component definitions.
  *
@@ -3126,6 +3154,8 @@ interface ComponentLikeElement {
   readonly component: Function;
   readonly props: Record<string, unknown>;
   readonly key?: string | number;
+  /** Where the component was used, in development; see `UiSourceLocation`. */
+  readonly source?: UiSourceLocation;
 }
 /**
  * A child definition may be a static element, a component definition,
@@ -3158,6 +3188,8 @@ interface UiElement {
    * definitions.
    */
   readonly children: readonly UiChild[];
+  /** Where the element was written, in development; see `UiSourceLocation`. */
+  readonly source?: UiSourceLocation;
 }
 /**
  * Returns true when the value is a component definition.
@@ -4086,10 +4118,20 @@ declare class UiContainerSizeSource implements UiContainerSize {
  */
 declare function bandOf(width: number, breakpoints: readonly number[]): number;
 /**
- * The width bands of a container, one value per band entered.
+ * The width bands of a container, one value per band entered, and once
+ * more at the first size measured.
  *
  * What `Responsive` builds its children from, and what an author who
  * wants only a number rather than a subtree can subscribe to directly.
+ *
+ * The first value is the size before any layout, usually zeroes, and
+ * the first measurement is the real one. Emitting only when the band
+ * changed left a container whose real width fell in the same band as
+ * the guess built from the guess for good, so a builder that reads the
+ * width (`size.width < 600` inside the `[1024]` band) was handed zero
+ * on a 768-wide tablet. One more value at the first measurement costs
+ * one more build at most, once, and every build after it sees a size
+ * that was measured.
  */
 declare function containerBands(size: UiContainerSize, breakpoints: readonly number[]): Observable<number>;
 //#endregion
@@ -4186,1360 +4228,1511 @@ declare class UiInsetRegistry implements UiInsetSource {
  */
 declare function observeViewportInsets(onChange: (insets: UiInsets) => void): () => void;
 //#endregion
-//#region src/properties/UiPropertyDefinition.d.ts
+//#region src/environment/UiSpacing.d.ts
 /**
- * Metadata describing a single UI property.
- *
- * The runtime uses this definition to know:
+ * A renderer-independent spacing scale.
  *
- *   - what the property is called
- *   - what value to use when none is specified
- *   - whether the value inherits from the scoped environment
- *   - what changing the value invalidates
- *   - how to compare two values for equality
+ * Each value is a logical pixel gap. The names are the shape scale's
+ * names on purpose: an application that has learned `borderRadius`
+ * from `theme.shapes` already knows what `small` and `extraLarge`
+ * mean, and one vocabulary across the theme is one thing to learn.
  *
- * A property may optionally declare an environment key and a
- * resolver that extracts the property value from that environment
- * value. When `environmentKey` is absent, inherited properties look
- * for an environment key whose name matches the property name.
+ * Eight steps rather than the shape scale's seven, because spacing is
+ * the token an application reaches for most often and a scale that
+ * cannot say "two" sends the author back to a literal. The values are
+ * a four pixel grid with a two pixel step at the bottom, which is what
+ * the two applications' own numbers already cluster on.
  */
-interface UiPropertyDefinition<T> {
-  readonly name: string;
-  readonly defaultValue: T;
-  readonly inherited: boolean;
-  readonly affects: DirtyFlags;
-  readonly compare?: (a: T, b: T) => boolean;
-  readonly environmentKey?: UiEnvironmentKey<unknown>;
-  readonly resolveFromEnvironment?: (value: unknown) => T;
-  /**
-   * Rejects a value the property cannot hold, returning the message
-   * for the error the builder throws. Declared only by properties with
-   * a closed set of values, such as `role`; the builder checks it when
-   * a plain value is written, so it costs nothing on the graph's own
-   * write path. A value arriving through an Observable is checked by
-   * whatever reads it, as a bound length is checked at layout.
-   */
-  readonly validate?: (value: T) => string | undefined;
-  /**
-   * Narrows `affects` for one particular change, when what changed
-   * shows that less is invalid than the property's worst case.
-   *
-   * `paint` is the reason it exists. A painter may declare an intrinsic
-   * size, so a new painter can change layout, and `affects` has to say
-   * so; but a new picture with the same declared size (usually none)
-   * cannot, and marking layout for it laid the tree out again up to the
-   * nearest relayout boundary on every repaint, which for a painted
-   * node sized by its parent was the root, every frame of a scroll.
-   * Given the old and new values and the flags `affects` gives, it
-   * returns the flags this change actually needs.
-   */
-  readonly narrowEffects?: (previous: T, next: T, flags: DirtyFlags) => DirtyFlags;
+interface UiSpacing {
+  readonly none: number;
+  readonly hairline: number;
+  readonly extraSmall: number;
+  readonly small: number;
+  readonly medium: number;
+  readonly large: number;
+  readonly extraLarge: number;
+  readonly huge: number;
 }
+declare const defaultSpacing: UiSpacing;
+/** The steps, in order, for a scale that is derived rather than written out. */
+declare const spacingSteps: readonly (keyof UiSpacing)[];
 /**
- * Creates a property definition with the supplied metadata.
+ * The same scale at a different density.
  *
- * The default compare function is reference equality (`Object.is`).
+ * Rounded to whole pixels, because a padding that lands on a half
+ * pixel puts every box inside it on one too, and the renderers snap
+ * differently at that point. `none` stays zero at every density: a gap
+ * an application asked not to have is not a gap to shrink.
  */
-declare function defineProperty<T>(options: Omit<UiPropertyDefinition<T>, 'name'> & {
-  name: string;
-}): UiPropertyDefinition<T>;
+declare function scaleSpacing(spacing: UiSpacing, factor: number): UiSpacing;
 /**
- * Compares two property values using the definition's comparison
- * function, falling back to `Object.is` when none is provided.
+ * Compares two spacing scales for equality.
  */
-declare function propertyValuesEqual<T>(definition: UiPropertyDefinition<T>, a: T, b: T): boolean;
+declare function spacingEqual(a: UiSpacing, b: UiSpacing): boolean;
 //#endregion
-//#region src/properties/UiBoxShadow.d.ts
+//#region src/properties/UiTextStyle.d.ts
 /**
- * Renderer-independent box shadow description, with CSS `box-shadow`
- * semantics.
+ * A coherent typography value.
  *
- * An outer shadow is the node's (rounded) box, grown by `spreadRadius`
- * on every side, moved by the offset, blurred by `blurRadius` (a
- * Gaussian whose standard deviation is half of it), and seen only
- * outside the box. An inset one is the same shape inverted and seen
- * only inside the box. `color` may be a palette name, resolved against
- * the node's theme as `backgroundColor` is.
+ * TextStyle is the unit of inheritance: a parent can provide a
+ * TextStyle and descendants can override individual fields while
+ * keeping the rest.
+ *
+ * The four fields below `textDirection` are optional because the
+ * environment's typography roles were written before they existed and
+ * a role that says nothing about them means "normal", which is what
+ * their property defaults already say.
  */
-interface UiBoxShadow {
-  readonly offsetX: number;
-  readonly offsetY: number;
-  readonly blurRadius: number;
-  readonly spreadRadius: number;
-  readonly color: UiColorValue;
-  readonly inset?: boolean;
+interface UiTextStyle {
+  readonly fontFamily: string;
+  readonly fontSize: number;
+  readonly fontWeight: UiFontWeight;
+  readonly lineHeight: number;
+  readonly letterSpacing: number;
+  readonly color: UiColor;
+  readonly textAlign: UiTextAlign;
+  readonly textDirection: UiTextDirection;
+  readonly fontStyle?: UiFontStyle;
+  readonly fontStretch?: UiFontStretch;
+  readonly fontVariant?: UiFontVariant;
+  readonly fontKerning?: UiFontKerning;
+  readonly textDecoration?: UiTextDecoration;
 }
+/** Upright or sloped. `oblique` is a synthesised slant where no italic face exists. */
+type UiFontStyle = 'normal' | 'italic' | 'oblique';
 /**
- * Creates a box shadow with the supplied parameters.
- */
-declare function boxShadow(offsetX: number, offsetY: number, blurRadius: number, spreadRadius: number, color: UiColorValue, inset?: boolean): UiBoxShadow;
-/**
- * Compares two box shadows for equality.
+ * The width axis, as CSS names it.
+ *
+ * A variable font's `wdth` is reached through these keywords and
+ * nowhere else: the Canvas2D context takes `fontStretch` as a
+ * property, and a font string cannot carry an axis tuple.
  */
-declare function boxShadowsEqual(a: UiBoxShadow, b: UiBoxShadow): boolean;
+type UiFontStretch = 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'normal' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded';
 /**
- * Compares two shadow arrays for equality.
+ * The one font-variant value the CSS font shorthand carries, and so
+ * the one a canvas font string carries. `font-feature-settings` is not
+ * part of the shorthand and the context has no property for it, which
+ * is why `tnum` and `liga` are not here.
  */
-declare function boxShadowArraysEqual(a: readonly UiBoxShadow[], b: readonly UiBoxShadow[]): boolean;
+type UiFontVariant = 'normal' | 'small-caps';
+/** Whether the shaper applies the font's kerning pairs. */
+type UiFontKerning = 'auto' | 'normal' | 'none';
+/** Lines drawn with the text. Both may be asked for at once. */
+type UiTextDecoration = 'none' | 'underline' | 'line-through' | 'underline line-through';
 /**
- * How far a shadow's blur reaches past the edge of its shape, as a
- * multiple of `blurRadius`.
+ * The fields of a style that change how wide its text measures.
  *
- * The blur is a Gaussian with a standard deviation of half the radius,
- * so this is three standard deviations: what is left beyond it is
- * under a quarter of a percent of the shadow's colour, and both
- * renderers stop drawing there.
- */
-declare const BOX_SHADOW_BLUR_REACH = 1.5;
-/**
- * The corner radius of a shadow's shape, from the box's and the
- * spread: an outer shadow's corner grows with its spread, an inset
- * one's hole shrinks with it. A square corner stays square, as CSS
- * keeps it.
+ * The split matters: only these reach the measure request, so a run
+ * that changes colour, background or underline is repainted from the
+ * paragraph the cache already holds, and only a run that changes font
+ * makes the paragraph new. See `TextMeasurer.ts`.
  */
-declare function boxShadowRadius(boxRadius: number, spreadRadius: number, inset: boolean): number;
+interface UiTextMetrics {
+  readonly fontFamily?: string;
+  readonly fontSize?: number;
+  readonly fontWeight?: UiFontWeight;
+  readonly fontStyle?: UiFontStyle;
+  readonly fontStretch?: UiFontStretch;
+  readonly fontVariant?: UiFontVariant;
+  readonly fontKerning?: UiFontKerning;
+  readonly letterSpacing?: number;
+  /**
+   * Kept in the text but not drawn: the run takes no room, paints
+   * nothing, and a caret steps over it as one unit.
+   *
+   * It is a metric field because it changes a width, to nothing. Its
+   * characters stay where they were, so every offset still means what
+   * it meant, a copy of the text still copies them, and the semantics
+   * mirror still reads them. It is how an editor that styles markup
+   * as it is typed (`**bold**` drawn as a bold word) puts the markers
+   * out of sight without taking them out of the string.
+   */
+  readonly hidden?: boolean;
+}
 /**
- * How far past each side of the box a node's outer shadows may paint,
- * written into `out`; all zero for a node with none. Inset shadows
- * paint inside the box and add nothing.
+ * A run that is activated rather than only read.
+ *
+ * `onClick` runs on a press that neither moved nor selected, and on
+ * Enter or Space while the run is focused. `label` names the run in
+ * the semantics mirror when the text itself would not ("here" is a
+ * link a screen reader cannot use); `href` is carried for the
+ * application's own use and the runtime never navigates to it.
  */
-declare function boxShadowReach(shadows: readonly UiBoxShadow[], out: {
-  left: number;
-  top: number;
-  right: number;
-  bottom: number;
-}): void;
-//#endregion
-//#region src/layout/UiLength.d.ts
+interface UiTextLink {
+  readonly onClick?: () => void;
+  readonly label?: string;
+  readonly href?: string;
+}
 /**
- * Length values accepted by size and offset properties.
+ * One run of a paragraph, with the style fields it overrides.
  *
- * A plain number is logical pixels. Anything else is a small tagged
- * object built by the helpers below — never a string to parse — so a
- * typo is a type error, and a malformed value reaching the engine at
- * runtime throws at layout rather than silently becoming zero.
+ * A `Text` node takes either a `text` string or a `spans` array, and
+ * the array is the whole of the paragraph: its texts concatenated in
+ * order are the text, so every offset the rest of the runtime
+ * works in — a line's `start`, a selection range, a find match, a
+ * caret — means the same thing whether the paragraph has runs or not.
+ * That is the property the whole feature rests on, and it is why runs
+ * are a shape of one paragraph rather than a tree of nodes.
  *
- *   width: 200            // pixels
- *   width: percent(50)    // half of the containing size, when it is
- *                         // definite; behaves as `auto` otherwise
- *   margin: auto          // main-axis auto margins absorb free space;
- *                         // cross-axis ones centre the item
- *   minWidth: auto        // the default: a flex item's automatic
- *                         // minimum, its min-content size
+ * Anything a span does not set it inherits from the node, and the
+ * node from its environment, exactly as a node inherits today.
  */
-interface PercentLength {
-  readonly unit: 'percent';
-  readonly value: number;
-}
-interface AutoLength {
-  readonly unit: 'auto';
+interface UiTextSpan extends UiTextMetrics {
+  readonly text: string;
+  readonly color?: UiColorValue;
+  readonly backgroundColor?: UiColorValue;
+  readonly textDecoration?: UiTextDecoration;
+  readonly link?: UiTextLink;
 }
-type UiLength = number | PercentLength | AutoLength;
-/** A grid track that takes a share of free space, `fr(1)`. */
-interface FrLength {
-  readonly unit: 'fr';
-  readonly value: number;
+/** A span placed in the flattened text: the same fields, plus where it is. */
+interface UiResolvedTextSpan extends UiTextMetrics {
+  readonly start: number;
+  readonly end: number;
+  readonly color?: UiColorValue;
+  readonly backgroundColor?: UiColorValue;
+  readonly textDecoration?: UiTextDecoration;
+  readonly link?: UiTextLink;
 }
-/** A grid track bounded below and above, `minmax(100, fr(1))`. */
-interface MinMaxTrack {
-  readonly unit: 'minmax';
-  readonly min: number | PercentLength | AutoLength;
-  readonly max: number | PercentLength | AutoLength | FrLength;
+/** A paragraph's text and the runs inside it. */
+interface UiSpannedText {
+  readonly text: string;
+  readonly spans: readonly UiResolvedTextSpan[];
 }
-/** What a grid's `columns` / `rows` arrays hold. */
-type UiTrackSize = number | PercentLength | AutoLength | FrLength | MinMaxTrack;
-declare function fr(value: number): FrLength;
-declare function minmax(min: MinMaxTrack['min'], max: MinMaxTrack['max']): MinMaxTrack;
-/** `repeat(3, fr(1))` → three `fr(1)` tracks; several sizes repeat as a pattern. */
-declare function repeat(count: number, ...sizes: UiTrackSize[]): UiTrackSize[];
-declare function isFrLength(value: unknown): value is FrLength;
-declare function isMinMaxTrack(value: unknown): value is MinMaxTrack;
-declare function percent(value: number): PercentLength;
-declare const auto: AutoLength;
-declare function isAutoLength(value: unknown): value is AutoLength | 'auto';
-declare function isPercentLength(value: unknown): value is PercentLength;
 /**
- * Resolves a property value to pixels.
- *
- * Returns `undefined` when the property is unset, `null`, `auto`, or a
- * percentage of an indefinite size — every case the caller treats as
- * "no value". Returns `'auto'` only when `keepAuto` is set, for the
- * properties where auto means something (margins, minimum sizes).
+ * What text is set in when nothing says otherwise.
  *
- * Anything else that is not a finite number or a tagged length throws,
- * naming the property: `width: '100%'` must fail loudly, not lay out
- * as if the property were absent.
+ * `system-ui` is the platform's own interface face (San Francisco,
+ * Segoe UI, Roboto), which is what an application on that platform is
+ * expected to look like; `sans-serif` is there for an engine that does
+ * not know the generic. The line is 20 on 14, about 1.43, because the
+ * 1.2 that a browser's `normal` comes to sets lines too tight to read
+ * in a paragraph. The ink is the stock palette's `text`, not black.
  */
-declare function resolveLength(value: unknown, base: number | undefined, property: string, keepAuto?: boolean): number | undefined | 'auto';
-//#endregion
-//#region src/properties/UiGradient.d.ts
+declare const defaultTextStyle: UiTextStyle;
+/** The text of a span array, with each run's offsets into it. */
+declare function flattenTextSpans(spans: readonly UiTextSpan[]): UiSpannedText;
 /**
- * Renderer-independent gradient descriptions.
- *
- * A gradient is a paint, not a colour: it is what a box's background
- * is filled with instead of one flat value, and both backends have to
- * arrive at the same pixels from it. So the description here is
- * geometry plus stops, with nothing renderer-shaped in it, and the two
- * renderers share the arithmetic in `gradientPaint` below rather than
- * each deriving a gradient line of its own.
+ * A node's paragraph as text and runs, or undefined when it has no
+ * runs.
  *
- * Lengths follow the rest of the framework: a plain number is logical
- * pixels and `percent(n)` is a fraction of whatever the value is a
- * fraction of, never a string to parse. For a stop that is the length
- * of the gradient itself, so `percent(50)` is halfway along it whatever
- * the box measures, and `24` is 24 pixels from its start.
+ * `spans` wins over `text` when both are set, because a node that was
+ * given runs meant them; the `text` prop is then ignored rather than
+ * appended, so there is exactly one source of offsets.
  */
-/** How far along a gradient a stop sits. */
-type UiGradientOffset = number | PercentLength;
-interface UiGradientStop {
-  /**
-   * Omitted on every stop of a gradient means "spread them evenly",
-   * which is what almost every gradient wants. Omitted on only some of
-   * them is an error rather than a guess: CSS's rule for filling the
-   * gaps is subtle enough that a reader could not predict the result.
-   *
-   * A number is a pixel length along the ramp, never a fraction of it:
-   * `{ offset: 0.45 }` is under half a pixel in, and a gradient whose
-   * stops all sit within the first pixel paints a one-pixel ramp that
-   * reads as nothing at all. A fraction is `percent(45)`. So
-   * `validateGradient` refuses a gradient whose numeric offsets all lie
-   * within 0 to 1 when there are two or more of them; one stop at a
-   * pixel or less among larger pixel offsets is a real position and is
-   * left alone.
-   */
-  readonly offset?: UiGradientOffset;
-  /**
-   * A palette name resolves against the theme the node inherits, so a
-   * themed gradient follows a theme change exactly as `backgroundColor`
-   * does.
-   */
-  readonly color: UiColorValue;
-}
-interface UiLinearGradient {
-  readonly kind: 'linear';
-  /**
-   * Direction in radians, on CSS's compass: 0 points at the top of the
-   * box and the angle turns clockwise, so `Math.PI / 2` runs left to
-   * right and `Math.PI` runs top to bottom.
-   */
-  readonly angle: number;
-  readonly stops: readonly UiGradientStop[];
-}
-interface UiRadialGradient {
-  readonly kind: 'radial';
-  /** The centre, from the box's top-left. Defaults to `percent(50)` on both axes. */
-  readonly centerX?: UiGradientOffset;
-  readonly centerY?: UiGradientOffset;
-  /**
-   * The radius of the outermost stop. `percent(100)`, the default, is
-   * the distance from the centre to the box's farthest corner, which is
-   * CSS's `farthest-corner`.
-   */
-  readonly radius?: UiGradientOffset;
-  readonly stops: readonly UiGradientStop[];
-}
-type UiGradient = UiLinearGradient | UiRadialGradient;
+declare function spannedTextOf(node: UiNode): UiSpannedText | undefined;
 /**
- * The most stops one gradient may carry.
+ * The text a node draws: its runs' text if it has runs, its `text`
+ * property otherwise.
  *
- * The WebGPU side stores a gradient as a fixed-size slab in a storage
- * buffer, because a variable-length record would need a second buffer
- * of stops and an index into it for what is, in every real interface, a
- * handful of colours. Eight keeps a record at twelve `vec4`s, and a
- * ninth stop is a loud error rather than a stop that quietly vanishes:
- * see `validateGradient`.
+ * Every reader of a node's paragraph goes through this — layout,
+ * paint, selection, find and the semantics mirror — so a spanned
+ * paragraph is selectable, findable and readable without any of them
+ * knowing what a span is.
  */
-declare const MAX_GRADIENT_STOPS = 8;
+declare function textContentOf(node: UiNode): string;
+/** The runs of a node's paragraph; empty when it has none. */
+declare function resolvedSpansOf(node: UiNode): readonly UiResolvedTextSpan[];
 /**
- * A linear gradient at `angle` radians, clockwise from the top.
+ * The runs an *editable* node styles its own text with.
  *
- *   linearGradient(Math.PI, [{ color: '#0ea5e9' }, { color: '#1e293b' }])
- */
-declare function linearGradient(angle: number, stops: readonly UiGradientStop[]): UiLinearGradient;
-/** A radial gradient, centred and sized as `UiRadialGradient` describes. */
-declare function radialGradient(stops: readonly UiGradientStop[], options?: Omit<UiRadialGradient, 'kind' | 'stops'>): UiRadialGradient;
-/**
- * Rejects a gradient the renderers cannot draw, returning the message
- * for the error the caller raises.
+ * An editable's paragraph is the user's, held by its model rather
+ * than by a property — so unlike a `Text`, its runs do not supply the
+ * text, they only describe it. `spans` on an editable is presentation
+ * over a string somebody is typing.
  *
- * The property registry calls this when a plain value is written, so a
- * bad gradient fails where it was authored. A gradient arriving through
- * an Observable is checked by `resolveGradient` instead, at paint,
- * which is where a bound length is checked too.
+ * Which is why this checks. Every offset the editor works in — the
+ * caret, the selection, the hit test that turns a click into a text
+ * position — is an offset into the model's string. Runs describing a
+ * *different* string would put the glyphs somewhere the caret does
+ * not agree with, and the field would look subtly, unfixably wrong.
+ * When they disagree the text is drawn unstyled, which is a frame of
+ * plain colour rather than a frame of nonsense, and corrects itself
+ * as soon as the application catches up.
  */
-declare function validateGradient(value: unknown): string | undefined;
-/** Whether two gradient property values would paint the same, for the registry. */
-declare function gradientsEqual(a: UiGradient | undefined, b: UiGradient | undefined): boolean;
-interface ResolvedGradientStop {
-  readonly offset: UiGradientOffset | undefined;
-  readonly color: UiColor;
+declare function editableSpansOf(node: UiNode, text: string, composition?: UiTextRange | null): readonly UiResolvedTextSpan[];
+/** A stretch of a paragraph, as offsets into its text. */
+interface UiTextRange {
+  readonly start: number;
+  readonly end: number;
 }
+/** The part of a run `hiddenRangesOf` reads; a paint span has it as well as a resolved one. */
+type HiddenSpan = Pick<UiResolvedTextSpan, 'start' | 'end' | 'hidden'>;
 /**
- * A gradient with its palette names resolved against the node's theme,
- * and nothing else changed.
+ * The stretches of a paragraph its runs hide, in order, with runs that
+ * touch merged into one: `**` hidden next to a hidden `_` is one
+ * stretch of three characters, which a caret steps over at once.
+ * Remembered by the identity of the array, as the flattening is.
+ */
+declare function hiddenRangesOf(spans: readonly HiddenSpan[]): readonly UiTextRange[];
+/** The span covering an offset, or undefined where no run does. */
+declare function spanAtOffset(spans: readonly UiResolvedTextSpan[], offset: number): UiResolvedTextSpan | undefined;
+/**
+ * Compares two span arrays for equality.
  *
- * Geometry stays as it was authored because it needs the node's box,
- * which `resolvePaintState` does not have: the renderer turns this into
- * a `GradientPaint` once it knows the record. Splitting it that way
- * also means the theme is read once per node per frame rather than once
- * per stop per pixel.
+ * A link is compared by identity, as every function-valued prop in
+ * the registry is: an application that rebuilds its handler each
+ * render says the run changed, which costs a paint and no layout,
+ * since a handler is not a metric field.
  */
-type ResolvedGradient = {
-  readonly kind: 'linear';
-  readonly angle: number;
-  readonly stops: readonly ResolvedGradientStop[];
-} | {
-  readonly kind: 'radial';
-  readonly centerX: UiGradientOffset | undefined;
-  readonly centerY: UiGradientOffset | undefined;
-  readonly radius: UiGradientOffset | undefined;
-  readonly stops: readonly ResolvedGradientStop[];
-};
+declare function textSpansEqual(a: readonly UiTextSpan[] | undefined, b: readonly UiTextSpan[] | undefined): boolean;
 /**
- * Note that the resolution itself, `resolveGradient`, lives in
- * `UiThemeColor.ts` rather than here. The registry imports this file
- * for `gradientsEqual` and `validateGradient`, and the theme lookup
- * reads properties, so a gradient that resolved its own stops would
- * close a cycle through the registry. It is the same split that keeps
- * `colorValuesEqual` in `UiColor.ts`.
+ * Whether two lists of runs are the same text, set the same way, and
+ * differ at most in colour, background and decoration, which are drawn
+ * rather than measured.
  */
+declare function spansDifferOnlyInPaint(a: readonly UiTextSpan[] | undefined, b: readonly UiTextSpan[] | undefined): boolean;
 /**
- * A gradient placed in a box: geometry in the box's own coordinates,
- * with the origin at its top-left, and stop offsets as fractions of the
- * gradient's length.
- *
- * This is the shared form both renderers draw from. Canvas2D adds the
- * box's origin and hands the numbers to `createLinearGradient`; the
- * WebGPU builder writes them into the frame's gradient buffer and the
- * fragment shader evaluates the same ramp per pixel.
+ * Compares two text styles for equality.
  */
-interface GradientPaint {
-  readonly kind: 'linear' | 'radial';
-  /** Linear: the start of the gradient line. Radial: the centre. */
-  readonly x0: number;
-  readonly y0: number;
-  /** Linear: the end of the gradient line. Radial: the centre again. */
-  readonly x1: number;
-  readonly y1: number;
-  /** Radial only; zero for a linear gradient. */
-  readonly radius: number;
-  readonly stops: readonly {
-    readonly offset: number;
-    readonly color: UiColor;
-  }[];
-}
+declare function textStylesEqual(a: UiTextStyle, b: UiTextStyle): boolean;
+//#endregion
+//#region src/environment/UiTypography.d.ts
 /**
- * Places a resolved gradient in a box of the given size.
+ * A typography scale.
  *
- * The linear case is CSS's: the gradient line runs through the centre
- * of the box in the direction of the angle, and it is long enough that
- * the two corners nearest its ends sit exactly on its endpoints, which
- * is `|w·sin| + |h·cos|`. The radial case is a circle, centred where
- * the gradient says and reaching the farthest corner at `percent(100)`.
+ * Each named style is a complete TextStyle so that it can be
+ * inherited as a unit. Components can override individual fields
+ * while falling back to the scale for the rest.
+ */
+interface UiTypography {
+  readonly body: UiTextStyle;
+  readonly bodyLarge: UiTextStyle;
+  readonly bodySmall: UiTextStyle;
+  readonly headline: UiTextStyle;
+  readonly title: UiTextStyle;
+  readonly label: UiTextStyle;
+}
+/**
+ * Roles an application adds to the scale, declared by merging.
  *
- * Offsets are clamped into `[0, 1]` and forced to not go backwards, as
- * CSS forces them, so the two backends receive one already-sorted list
- * and neither has to decide what a stop behind its predecessor means.
+ * A scale of six covers a document and not an application: the two
+ * applications here use fourteen and eleven distinct sizes. Rather
+ * than grow `UiTypography` for everyone, or send an application back
+ * to writing numbers on elements, a theme's typography may carry names
+ * of its own, and an application declares them so they type:
+ *
+ *   declare module 'gesso-core' {
+ *     interface UiTypographyExtensions {
+ *       readonly cardTitle: unknown;
+ *       readonly display: unknown;
+ *     }
+ *   }
+ *
+ * The value type is not used, only the key, because what the theme
+ * carries is always a `UiTextStyle`. Declaring one makes
+ * `textStyle="cardTitle"` legal and `textStyle="cardTtile"` a compile
+ * error, which is the whole point.
  */
-declare function gradientPaint(gradient: ResolvedGradient, width: number, height: number): GradientPaint;
+interface UiTypographyExtensions {}
+/**
+ * A role in the scale, as an element names it: `textStyle="title"`.
+ *
+ * The idiom the documentation teaches. A size, a weight and a line
+ * height written out on an element are three numbers to keep in step
+ * across a screen and six to keep in step across an application, and
+ * none of them follows a theme; a role is one word that does.
+ */
+type UiTypographyRole = keyof UiTypography | (keyof UiTypographyExtensions & string);
+/**
+ * Whether a value names a role of the supplied scale.
+ *
+ * Asked of the scale rather than of a written-out list, so a role an
+ * application added is a role. A name the scale does not carry is not
+ * one, and the element keeps whatever type it inherited rather than
+ * drawing at a default size, which is the quieter of the two failures.
+ */
+declare function isTypographyRole(value: unknown, scale: UiTypography): value is UiTypographyRole;
+/**
+ * The stock scale: one face, and line heights on a 4-point grid rather
+ * than 1.2 of the size, so a paragraph has room and a stack of text
+ * lines up with the spacing scale around it.
+ */
+declare const defaultTypography: UiTypography;
+/**
+ * Compares two typography scales for equality.
+ *
+ * Over the keys rather than a written-out list, as `colorsEqualPalette`
+ * is and for the same reason: a scale that carries roles of its own
+ * has to invalidate on a change to one of them. Written out, the six
+ * shipped roles were compared and an application's own were not, so a
+ * scale differing only in a role it had added compared equal and the
+ * change never reached the nodes that would have read it.
+ */
+declare function typographyEqual(a: UiTypography, b: UiTypography): boolean;
 //#endregion
-//#region src/properties/UiImage.d.ts
+//#region src/properties/UiBoxShadow.d.ts
 /**
- * Renderer-facing image type.
+ * Renderer-independent box shadow description, with CSS `box-shadow`
+ * semantics.
  *
- * ImageBitmap is available on the main thread and in Workers
- * (createImageBitmap), so the rendering core never depends on
- * HTMLImageElement and an image decoded in a worker can be drawn there.
+ * An outer shadow is the node's (rounded) box, grown by `spreadRadius`
+ * on every side, moved by the offset, blurred by `blurRadius` (a
+ * Gaussian whose standard deviation is half of it), and seen only
+ * outside the box. An inset one is the same shape inverted and seen
+ * only inside the box. `color` may be a palette name, resolved against
+ * the node's theme as `backgroundColor` is.
  */
-type UiImage = ImageBitmap;
+interface UiBoxShadow {
+  readonly offsetX: number;
+  readonly offsetY: number;
+  readonly blurRadius: number;
+  readonly spreadRadius: number;
+  readonly color: UiColorValue;
+  readonly inset?: boolean;
+}
+/** A size on the theme's shadow scale (`UiTheme.shadows`), which `boxShadows` takes as a name. */
+type UiShadowName = 'none' | 'extraSmall' | 'small' | 'medium' | 'large' | 'extraLarge';
+/**
+ * What `boxShadows` holds: the shadows themselves, or a size on the
+ * theme's scale, `boxShadows="medium"`, as `borderRadius` takes a shape.
+ * A name follows the theme, so a rebrand's shadows reach every card.
+ */
+type UiBoxShadows = readonly UiBoxShadow[] | UiShadowName;
+/**
+ * The shadows a `boxShadows` value stands for: itself, or the named
+ * size from `scale`, the node's theme's shadows. A name the scale lacks,
+ * or no scale, is no shadow.
+ */
+declare function shadowsOf(value: unknown, scale: {
+  readonly [name: string]: readonly UiBoxShadow[];
+} | undefined): readonly UiBoxShadow[];
+/**
+ * Compares two `boxShadows` values: two names by name, two lists entry by entry.
+ */
+declare function boxShadowValuesEqual(a: UiBoxShadows, b: UiBoxShadows): boolean;
+/**
+ * Creates a box shadow with the supplied parameters.
+ */
+declare function boxShadow(offsetX: number, offsetY: number, blurRadius: number, spreadRadius: number, color: UiColorValue, inset?: boolean): UiBoxShadow;
+/**
+ * Compares two box shadows for equality.
+ */
+declare function boxShadowsEqual(a: UiBoxShadow, b: UiBoxShadow): boolean;
+/**
+ * Compares two shadow arrays for equality.
+ */
+declare function boxShadowArraysEqual(a: readonly UiBoxShadow[], b: readonly UiBoxShadow[]): boolean;
+/**
+ * How far a shadow's blur reaches past the edge of its shape, as a
+ * multiple of `blurRadius`.
+ *
+ * The blur is a Gaussian with a standard deviation of half the radius,
+ * so this is three standard deviations: what is left beyond it is
+ * under a quarter of a percent of the shadow's colour, and both
+ * renderers stop drawing there.
+ */
+declare const BOX_SHADOW_BLUR_REACH = 1.5;
+/**
+ * The corner radius of a shadow's shape, from the box's and the
+ * spread: an outer shadow's corner grows with its spread, an inset
+ * one's hole shrinks with it. A square corner stays square, as CSS
+ * keeps it.
+ */
+declare function boxShadowRadius(boxRadius: number, spreadRadius: number, inset: boolean): number;
+/**
+ * How far past each side of the box a node's outer shadows may paint,
+ * written into `out`; all zero for a node with none. Inset shadows
+ * paint inside the box and add nothing.
+ */
+declare function boxShadowReach(shadows: readonly UiBoxShadow[], out: {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}): void;
 //#endregion
-//#region src/rendering/PaintSurface.d.ts
+//#region src/environment/UiShadows.d.ts
 /**
- * The drawing vocabulary an application gets when it wants to draw
- * something the property set has no name for: a sparkline, a gauge, a
- * waveform, a chart axis.
+ * A renderer-independent shadow scale.
  *
- * It sits beside `UiRenderer` on purpose argues
- * the placement at length. The short version is the risk it exists to
- * avoid: a paint hook handed a `CanvasRenderingContext2D` would be a
- * Canvas2D-only capability with a WebGPU backend that could never
- * catch up, which is how a second-class renderer is made. Nothing here
- * names a canvas, a device or a texture, so neither backend can be the
- * one the vocabulary was written for.
+ * Each value is an array of shadows so layered shadows can be
+ * expressed. Renderers translate these into native shadow drawing
+ * operations.
+ */
+interface UiShadows {
+  readonly none: readonly UiBoxShadow[];
+  readonly extraSmall: readonly UiBoxShadow[];
+  readonly small: readonly UiBoxShadow[];
+  readonly medium: readonly UiBoxShadow[];
+  readonly large: readonly UiBoxShadow[];
+  readonly extraLarge: readonly UiBoxShadow[];
+}
+declare const defaultShadows: UiShadows;
+/**
+ * Compares two shadow scales for equality.
+ */
+declare function shadowsEqual(a: UiShadows, b: UiShadows): boolean;
+//#endregion
+//#region src/environment/UiDensity.d.ts
+/**
+ * How tightly a theme packs.
  *
- * **Coordinates are the node's own.** `(0, 0)` is the top-left of the
- * resolved box and the box's width and height are the extent, so a
- * painter never reads a layout record and never learns where on the
- * screen it ended up. The device scale arrives separately, for the one
- * thing that genuinely needs it: choosing a hairline that is one
- * physical pixel rather than one logical one.
+ * An axis rather than a second theme: an application that wants a
+ * compact table and a comfortable settings sheet provides the same
+ * theme twice with one field changed, and nothing else about its
+ * colours or type is duplicated.
  *
- * **Every call is recorded, not executed.** The object a painter is
- * handed is a `PaintRecorder`, and what it produces is a
- * `PaintRecording`: plain data, comparable, replayable, and cheap
- * enough to keep. See `PaintRecording.ts` for why that indirection is
- * what makes the two backends agree.
+ * `comfortable` is the scale as written. `compact` is three quarters
+ * of it, `spacious` a quarter more. Only the spacing scale moves; type
+ * and shape do not, because a smaller gap between two rows is a
+ * density choice and a smaller word is a typography one.
  */
-interface PaintSurface {
-  /** Pushes the transform, the clip and every style value. */
-  save(): void;
-  restore(): void;
-  translate(x: number, y: number): void;
-  scale(x: number, y: number): void;
-  /** Radians, clockwise, about the current origin. */
-  rotate(angle: number): void;
-  /** Multiplies the current transform by the 3x2 affine `a b c d e f`. */
-  transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
-  beginPath(): void;
-  moveTo(x: number, y: number): void;
-  lineTo(x: number, y: number): void;
-  quadraticCurveTo(cx: number, cy: number, x: number, y: number): void;
-  bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
-  /** Radians; `counterclockwise` defaults to false. */
-  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
-  rect(x: number, y: number, width: number, height: number): void;
-  /** One radius for all four corners, clamped to half the smaller side. */
-  roundRect(x: number, y: number, width: number, height: number, radius: number): void;
-  closePath(): void;
-  /**
-   * Appends SVG path data to the current path, in the surface's own
-   * coordinates.
-   *
-   * The whole grammar an icon set uses is understood, `A` included:
-   * `PaintPathData.ts` turns it into the calls above, so a `d` string
-   * costs exactly what writing those calls by hand would and works
-   * wherever the rest of this does. That last part is the reason it is
-   * parsed here rather than handed to `Path2D`, which exists in a
-   * browser and not in the suite.
-   */
-  path(d: string): void;
-  /**
-   * A `UiColor`, a hex or named CSS colour, or a palette name.
-   *
-   * A palette name is the reason a painted node follows the light and
-   * dark toggle without the painter knowing there was a toggle: the
-   * name is resolved against whatever theme the node inherits, at the
-   * moment the picture is made, exactly as a `backgroundColor` prop is.
-   */
-  fillColor(color: UiColorValue): void;
-  /**
-   * A gradient for the fills that follow, placed in the rectangle
-   * given here rather than in the node's box, so a painter can ramp
-   * one bar of a chart without arithmetic of its own.
-   */
-  fillGradient(gradient: UiGradient, x: number, y: number, width: number, height: number): void;
-  strokeColor(color: UiColorValue): void;
-  lineWidth(width: number): void;
-  lineCap(cap: PaintLineCap): void;
-  lineJoin(join: PaintLineJoin): void;
-  miterLimit(limit: number): void;
-  /**
-   * A dash pattern in logical pixels, and how far into it the first
-   * dash starts. An empty pattern draws solid.
-   */
-  lineDash(segments: readonly number[], offset?: number): void;
-  /** 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.
-   *
-   * 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;
-  /** Fills the current path. The default rule is `nonzero`. */
-  fill(rule?: PaintFillRule): void;
-  stroke(): void;
-  /** Intersects the clip with the current path, until the next `restore`. */
-  clip(rule?: PaintFillRule): void;
+type UiDensity = 'compact' | 'comfortable' | 'spacious';
+/** The multiplier each density applies to the spacing scale. */
+declare const densityFactors: Readonly<Record<UiDensity, number>>;
+//#endregion
+//#region src/environment/UiContrast.d.ts
+/**
+ * How much separation a theme keeps between what is drawn and what it
+ * is drawn on.
+ *
+ * `standard` is the palette as the designer wrote it. `high` is the
+ * same palette with every foreground pushed away from the surface
+ * behind it until it clears a contrast ratio, which is what a person
+ * who has turned the operating system's high-contrast setting on is
+ * asking for. It is an axis of the theme rather than a second palette
+ * so that an application which has already chosen its colours does not
+ * have to choose them twice, and so that the accessibility audit has
+ * one place to look.
+ */
+type UiContrast = 'standard' | 'high';
+/**
+ * Relative luminance, as WCAG defines it.
+ *
+ * Alpha is ignored: a token is compared against the surface it sits
+ * on, and what a translucent foreground actually looks like depends on
+ * a composite this cannot see. Raising a translucent token toward the
+ * extreme is still the right direction.
+ */
+declare function relativeLuminance(color: UiColor): number;
+/**
+ * The WCAG contrast ratio between two colours, from 1 to 21.
+ */
+declare function contrastRatio(a: UiColor, b: UiColor): number;
+/**
+ * The same colour, moved toward black or white until it clears
+ * `ratio` against `against`.
+ *
+ * Toward whichever extreme is already the further from the surface, so
+ * text on a dark ground gets lighter and text on a light ground gets
+ * darker: pushing the other way would cross the surface's own
+ * luminance and come out worse before it came out better. A colour
+ * that cannot reach the ratio even at the extreme is returned at the
+ * extreme, which is the best the palette can do and is still an
+ * improvement.
+ *
+ * Mixed in linear steps of the stored channels rather than by solving
+ * for the luminance, because the search is sixteen steps and this runs
+ * when a theme is built, not when a frame is drawn.
+ */
+declare function raiseContrast(color: UiColor, against: UiColor, ratio: number): UiColor;
+/** What a high-contrast palette needs to know of an application's own names. */
+interface HighContrastOptions {
   /**
-   * One line of text at a baseline, in the current fill colour.
-   *
-   * Deliberately one line and not a paragraph: wrapping, bidi and
-   * selection belong to the text node, which does them properly, and a
-   * painter that needs them should draw a text node instead. This is
-   * for the labels a chart puts on its own axes.
+   * Names a custom palette added that are grounds, not marks, and are
+   * left alone as the stock grounds are: a code editor's selection, its
+   * current line, a diff's filled lines. Raised as foregrounds, they
+   * would turn bright enough against the page that what is drawn on them
+   * could not be read.
    */
-  text(value: string, x: number, y: number, style?: PaintTextStyle): void;
-  /** Draws an image into a rectangle, stretched to fill it. */
-  image(image: UiImage, x: number, y: number, width: number, height: number): void;
-}
-type PaintFillRule = 'nonzero' | 'evenodd';
-type PaintLineCap = 'butt' | 'round' | 'square';
-type PaintLineJoin = 'miter' | 'round' | 'bevel';
-type PaintTextAlign = 'left' | 'center' | 'right';
-/** The little of a text style a single painted line can carry. */
-interface PaintTextStyle {
-  readonly fontSize?: number;
-  readonly fontFamily?: string;
-  readonly fontWeight?: number | string;
-  /** Which end of the run `x` names. Defaults to `left`. */
-  readonly align?: PaintTextAlign;
+  readonly surfaces?: Iterable<string>;
 }
 /**
- * The box a painter is asked to fill, in its own coordinates.
+ * A palette at high contrast.
  *
- * The node's border box, not its content box: a painter that wants to
- * respect padding is told what it is and decides, because a gauge
- * drawn to the edge and a chart inset by its padding are both
- * legitimate and the property set cannot tell which was meant.
+ * Every extra name a custom palette added is raised too, against the
+ * page background, because a palette that grew a token for its own
+ * accent should not be the one thing that stays quiet when the setting
+ * is turned on; unless it says it is a ground (`surfaces`). The named
+ * foregrounds above override that default with the surface they are
+ * really drawn on.
  */
-interface PaintBox {
-  readonly width: number;
-  readonly height: number;
-  readonly paddingTop: number;
-  readonly paddingRight: number;
-  readonly paddingBottom: number;
-  readonly paddingLeft: number;
+declare function highContrastColors(colors: UiColors, options?: HighContrastOptions): UiColors;
+//#endregion
+//#region src/environment/UiThemeExtension.d.ts
+/**
+ * Tokens an application adds to a theme, under its own name.
+ *
+ * `UiTheme` carries the vocabulary every application shares: colours,
+ * type, shapes, shadows, spacing. An application always has more than
+ * that, and the two in this repository each grew a module of module
+ * level constants to hold it, which is a theme that no provider can
+ * change and no appearance toggle can reach.
+ *
+ * An extension is that module turned into part of the theme:
+ *
+ *   const brand = defineThemeExtension({
+ *     name: 'brand',
+ *     defaults: { linen: '#be9a6e', chalk: '#f7f3ea' }
+ *   });
+ *
+ *   const theme = withThemeExtension(lightTheme, brand, { linen: …, chalk: … });
+ *   themeExtension(theme, brand).linen
+ *
+ * The read is a property access on the object the extension was
+ * declared with, so an editor completes the token names and a
+ * misspelling is a compile error. Nothing about `UiTheme` or
+ * `themesEqual` changes to add one: the extensions ride in a map keyed
+ * by the symbol `defineThemeExtension` minted, and `themesEqual`
+ * compares them with each extension's own comparison.
+ *
+ * A component in a library may declare an extension too, which is how
+ * a component that needs a token the shared vocabulary does not have
+ * gets one without adding a prop for it.
+ */
+interface UiThemeExtension<T extends object> {
+  /** Identity, so two extensions cannot collide on a name. */
+  readonly key: symbol;
+  readonly name: string;
+  /** What `themeExtension` returns for a theme that does not carry it. */
+  readonly defaults: T;
+  /** What it returns instead for such a theme turned for a finger; `defaults` when absent. See `UiPointer`. */
+  readonly coarse?: T;
+  readonly equals: (a: T, b: T) => boolean;
+}
+interface UiThemeExtensionOptions<T extends object> {
+  readonly name: string;
+  readonly defaults: T;
   /**
-   * Physical pixels per logical pixel the picture is being made at.
+   * The group's values for a finger: what a theme turned for touch
+   * (`withPointer(theme, 'coarse')`) reads when it does not carry the
+   * group itself. A control library's touch sizes go here, so an
+   * application gets them on a touch screen with nothing to provide.
+   */
+  readonly coarse?: T;
+  /**
+   * How two values of this extension are compared, for the environment
+   * to decide whether a theme change has to invalidate the subtree.
    *
-   * The one thing a painter needs the device for: `1 / scale` is a
-   * hairline, and a grid line drawn at `1` on a retina display is two
-   * physical pixels wide and looks it.
+   * The default compares the group's own keys, and compares each one
+   * structurally when it is a plain object, so a group of `UiColor`
+   * tokens built freshly on each appearance change is equal to the one
+   * before it. It goes no deeper than that: an extension whose tokens
+   * are themselves nested groups should pass its own comparison rather
+   * than find out later that its theme never invalidates.
    */
-  readonly scale: number;
+  readonly equals?: (a: T, b: T) => boolean;
 }
+/** The map a theme carries. Empty for every stock theme. */
+type UiThemeExtensions = ReadonlyMap<symbol, object>;
+declare const noThemeExtensions: UiThemeExtensions;
 /**
- * What a node's `paint` prop holds: the drawing, and what it depends
- * on.
+ * Declares a group of tokens an application or a library adds to a
+ * theme. Call it once, at module level, and export the result.
+ */
+declare function defineThemeExtension<T extends object>(options: UiThemeExtensionOptions<T>): UiThemeExtension<T>;
+/** What the theme carries for this extension, or its declared defaults. */
+declare function themeExtension<T extends object>(theme: {
+  readonly extensions?: UiThemeExtensions;
+  readonly pointer?: 'fine' | 'coarse';
+}, extension: UiThemeExtension<T>): T;
+/** Whether the theme carries this extension at all, rather than falling back. */
+declare function hasThemeExtension<T extends object>(theme: {
+  readonly extensions?: UiThemeExtensions;
+}, extension: UiThemeExtension<T>): boolean;
+/**
+ * The same theme with one extension's tokens set.
  *
- * `inputs` is the whole of the cost story. The picture is made when
- * the inputs change and at no other time, so a painted node on a
- * still frame costs one image draw and nothing else, and
- * `PaintPicture.budget.spec.ts` asserts exactly that. Without it the
- * only safe assumption would be that the closure captured something
- * new, and every frame would repaint.
+ * Returns a new theme; a theme is a value and is compared as one. The
+ * extensions map is copied rather than mutated for the same reason,
+ * since two themes derived from one base must not share it.
+ */
+declare function withThemeExtension<Theme extends {
+  readonly extensions?: UiThemeExtensions;
+}, T extends object>(theme: Theme, extension: UiThemeExtension<T>, value: T): Theme;
+/**
+ * Compares the extension maps of two themes.
  *
- * Values are compared with `Object.is`, one by one, so a list of
- * numbers or of stable references works and an array literal rebuilt
- * per render does not defeat it. Omitting `inputs` means the drawing
- * never changes on its own, which is the right default for a static
- * shape and the wrong one for a chart.
+ * A key one carries and the other does not is a difference, and each
+ * key is compared with the comparison its own extension declared. The
+ * comparison lives on the value rather than in a registry so that an
+ * extension declared in an application is compared as well as one
+ * declared here, which is the whole point of the mechanism.
  */
-interface UiPaint {
-  readonly draw: (surface: PaintSurface, box: PaintBox) => void;
-  readonly inputs?: readonly unknown[];
-  /**
-   * The size the node takes when the layout has none to give it: no
-   * width or height, no flex, nothing stretching it. Zero, like any
-   * other empty leaf, when it is absent.
-   */
-  readonly intrinsicWidth?: number;
-  readonly intrinsicHeight?: number;
-}
+declare function themeExtensionsEqual(a: UiThemeExtensions | undefined, b: UiThemeExtensions | undefined): boolean;
+//#endregion
+//#region src/environment/UiUnits.d.ts
 /**
- * A static vector shape, as a property rather than a function.
+ * What a theme's lengths are measured against.
  *
- * The declarative half of this workstream: an icon, a logo, a
- * decorative rule, anything whose geometry is fixed and whose colours
- * follow the theme. It is drawn through the same surface a painter
- * writes to, so there is no second path to keep in step, and a node
- * may carry both a `path` and a `paint` (the path is drawn first, and
- * the painter draws over it).
+ * Every length Gesso lays out or paints is a logical pixel, the CSS
+ * pixel, and nothing in the layout pass knows another unit. A designer
+ * thinks in more than one: type in points or rems, a print margin in
+ * millimetres, a badge in inches. The two numbers here are what those
+ * are worth in pixels, carried on the theme so a screen and the scales
+ * it is written from agree on them.
+ *
+ * They are resolved when a value is written, not when it is laid out:
+ * `lengths(theme.units).rem(1.5)` is the number 24, and the element
+ * that receives it never knows it was a rem. That keeps the layout
+ * engine's per-node cache honest, since a resolved number cannot change
+ * under it when a parent's units do, and it is why changing a theme's
+ * units moves what is written with them the next time it is written,
+ * not the screen already drawn.
  */
-interface UiPath {
-  /** SVG path data, in `viewBox` units. */
-  readonly d: string;
+interface UiUnits {
   /**
-   * The square the path is authored in, scaled to fit the node's box
-   * as `object-fit: contain` would, and centred in it. Omitted means
-   * the path is already in the node's own logical pixels.
+   * How many logical pixels make an inch, and from it a point (1/72 in)
+   * and a millimetre (1/25.4 in). 96, as in CSS, so a theme that never
+   * sets it measures as the browser does.
    */
-  readonly viewBox?: number;
-  readonly fill?: UiColorValue;
-  readonly fillRule?: PaintFillRule;
-  readonly stroke?: UiColorValue;
-  readonly strokeWidth?: number;
-  readonly lineCap?: PaintLineCap;
-  readonly lineJoin?: PaintLineJoin;
-  readonly miterLimit?: number;
-  readonly dash?: readonly number[];
-  readonly dashOffset?: number;
+  readonly pixelsPerInch: number;
+  /** What one `rem` is, in logical pixels: 16, as a browser's default root font. */
+  readonly rootFontSize: number;
 }
+declare const defaultUnits: UiUnits;
 /**
- * Whether two `paint` values would draw the same picture.
+ * Conversions from a designer's units to logical pixels, for one set
+ * of units.
  *
- * Identity on `draw` plus item-by-item identity on `inputs`, which is
- * the comparison the property registry runs on every write. A painter
- * rebuilt by a render body has a new `draw`, so a component that wants
- * the caching has to hoist the function and vary the inputs, which is
- * the same rule a modifier's arguments follow.
+ * Unrounded, because a size in points is often meant to be a fraction
+ * of a pixel (`pt(10.5)` is 14): rounding is the author's choice, made
+ * where a half pixel would put every box inside on one too.
  */
-declare function paintValuesEqual(a: UiPaint | undefined, b: UiPaint | undefined): boolean;
-/** Item-by-item identity, with absent and empty treated alike. */
-declare function inputsEqual(a: readonly unknown[] | undefined, b: readonly unknown[] | undefined): boolean;
-/** Whether two `path` values describe the same shape in the same style. */
-declare function pathValuesEqual(a: UiPath | undefined, b: UiPath | undefined): boolean;
-//#endregion
-//#region src/properties/UiTextStyle.d.ts
+interface UiLengths {
+  /** The units these convert with. */
+  readonly units: UiUnits;
+  /** Multiples of the root font size: `rem(1.5)` is 24 at the default 16. */
+  rem(value: number): number;
+  /** Inches: `inch(1)` is the pixels per inch. */
+  inch(value: number): number;
+  /** Points, 72 to the inch: `pt(12)` is 16 at 96 pixels per inch. */
+  pt(value: number): number;
+  /** Millimetres, 25.4 to the inch. */
+  mm(value: number): number;
+}
 /**
- * A coherent typography value.
+ * The conversions for a set of units, usually a theme's.
  *
- * TextStyle is the unit of inheritance: a parent can provide a
- * TextStyle and descendants can override individual fields while
- * keeping the rest.
+ *   const { rem, pt } = lengths(theme.units);
+ *   <box padding={rem(1)}><text fontSize={pt(12)} /></box>
  *
- * The four fields below `textDirection` are optional because the
- * environment's typography roles were written before they existed and
- * a role that says nothing about them means "normal", which is what
- * their property defaults already say.
- */
-interface UiTextStyle {
-  readonly fontFamily: string;
-  readonly fontSize: number;
-  readonly fontWeight: UiFontWeight;
-  readonly lineHeight: number;
-  readonly letterSpacing: number;
-  readonly color: UiColor;
-  readonly textAlign: UiTextAlign;
-  readonly textDirection: UiTextDirection;
-  readonly fontStyle?: UiFontStyle;
-  readonly fontStretch?: UiFontStretch;
-  readonly fontVariant?: UiFontVariant;
-  readonly fontKerning?: UiFontKerning;
-  readonly textDecoration?: UiTextDecoration;
-}
-/** Upright or sloped. `oblique` is a synthesised slant where no italic face exists. */
-type UiFontStyle = 'normal' | 'italic' | 'oblique';
-/**
- * The width axis, as CSS names it.
+ * A theme writes its own scales the same way, from the units it is
+ * about to carry, so the scales follow them:
  *
- * A variable font's `wdth` is reached through these keywords and
- * nowhere else: the Canvas2D context takes `fontStretch` as a
- * property, and a font string cannot carry an axis tuple.
+ *   const units = { pixelsPerInch: 96, rootFontSize: 16 };
+ *   const { rem } = lengths(units);
+ *   export const theme = { ...lightTheme, units, spacing: { ...lightTheme.spacing, large: rem(1) } };
+ *
+ * Throws on units that cannot measure anything, a zero or negative or
+ * non-finite number, since every length written from them would be.
  */
-type UiFontStretch = 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'normal' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded';
+declare function lengths(units?: UiUnits): UiLengths;
 /**
- * The one font-variant value the CSS font shorthand carries, and so
- * the one a canvas font string carries. `font-feature-settings` is not
- * part of the shorthand and the context has no property for it, which
- * is why `tnum` and `liga` are not here.
+ * Compares two sets of units for equality.
  */
-type UiFontVariant = 'normal' | 'small-caps';
-/** Whether the shaper applies the font's kerning pairs. */
-type UiFontKerning = 'auto' | 'normal' | 'none';
-/** Lines drawn with the text. Both may be asked for at once. */
-type UiTextDecoration = 'none' | 'underline' | 'line-through' | 'underline line-through';
+declare function unitsEqual(a: UiUnits, b: UiUnits): boolean;
+//#endregion
+//#region src/environment/UiTheme.d.ts
 /**
- * The fields of a style that change how wide its text measures.
+ * A renderer-independent theme.
  *
- * The split matters: only these reach the measure request, so a run
- * that changes colour, background or underline is repainted from the
- * paragraph the cache already holds, and only a run that changes font
- * makes the paragraph new. See `TextMeasurer.ts`.
+ * A theme bundles colors, typography, shapes, shadows and spacing into
+ * a single environment value. It can be provided at any node and is
+ * inherited by descendants until another provider overrides it.
+ *
+ * `density` and `contrast` are axes rather than scales: they record
+ * which way this theme was already turned, so a component can branch
+ * on the answer and `withDensity` and `withContrast` can turn it
+ * again from the base. `units` is what an inch and a rem are worth in
+ * pixels, for lengths written in them; see `UiUnits.ts`. `extensions`
+ * is where an application's own token groups live; see
+ * `UiThemeExtension.ts`.
  */
-interface UiTextMetrics {
-  readonly fontFamily?: string;
-  readonly fontSize?: number;
-  readonly fontWeight?: UiFontWeight;
-  readonly fontStyle?: UiFontStyle;
-  readonly fontStretch?: UiFontStretch;
-  readonly fontVariant?: UiFontVariant;
-  readonly fontKerning?: UiFontKerning;
-  readonly letterSpacing?: number;
+interface UiTheme {
+  readonly colors: UiColors;
+  readonly typography: UiTypography;
+  readonly shapes: UiShapes;
+  readonly shadows: UiShadows;
+  readonly spacing: UiSpacing;
+  readonly density: UiDensity;
+  readonly contrast: UiContrast;
+  readonly units: UiUnits;
+  readonly extensions?: UiThemeExtensions;
   /**
-   * Kept in the text but not drawn: the run takes no room, paints
-   * nothing, and a caret steps over it as one unit.
-   *
-   * It is a metric field because it changes a width, to nothing. Its
-   * characters stay where they were, so every offset still means what
-   * it meant, a copy of the text still copies them, and the semantics
-   * mirror still reads them. It is how an editor that styles markup
-   * as it is typed (`**bold**` drawn as a bold word) puts the markers
-   * out of sight without taking them out of the string.
+   * What the person points with, which way this theme was turned (see
+   * `UiPointer`); absent is `fine`. Set by `withPointer`, which every
+   * subtree under a `pointer="coarse"` (or a touch device) is drawn in.
    */
-  readonly hidden?: boolean;
+  readonly pointer?: UiPointer;
+  /** What the theme changes for a finger; see `UiThemeTouch`. */
+  readonly touch?: UiThemeTouch;
 }
+declare const lightTheme: UiTheme;
+declare const darkTheme: UiTheme;
 /**
- * A run that is activated rather than only read.
+ * Compares two themes for equality.
  *
- * `onClick` runs on a press that neither moved nor selected, and on
- * Enter or Space while the run is focused. `label` names the run in
- * the semantics mirror when the text itself would not ("here" is a
- * link a screen reader cannot use); `href` is carried for the
- * application's own use and the runtime never navigates to it.
+ * The extensions are compared with each extension's own comparison, so
+ * an application that adds a token group gets invalidation on a change
+ * to it without editing this function. That was the point of the
+ * mechanism: a theme layer
+ * added without extending `themesEqual` is a theme change that does
+ * not repaint, and it is easy to forget.
  */
-interface UiTextLink {
-  readonly onClick?: () => void;
-  readonly label?: string;
-  readonly href?: string;
-}
+declare function themesEqual(a: UiTheme, b: UiTheme): boolean;
 /**
- * One run of a paragraph, with the style fields it overrides.
+ * The same theme at another density.
  *
- * A `Text` node takes either a `text` string or a `spans` array, and
- * the array is the whole of the paragraph: its texts concatenated in
- * order are the text, so every offset the rest of the runtime
- * works in — a line's `start`, a selection range, a find match, a
- * caret — means the same thing whether the paragraph has runs or not.
- * That is the property the whole feature rests on, and it is why runs
- * are a shape of one paragraph rather than a tree of nodes.
+ * Derived from the theme it is given rather than from a base, so
+ * asking twice for `compact` does not shrink the scale twice: a theme
+ * already at that density is returned unchanged.
+ */
+declare function withDensity(theme: UiTheme, density: UiDensity): UiTheme;
+/**
+ * The same theme at another contrast.
  *
- * Anything a span does not set it inherits from the node, and the
- * node from its environment, exactly as a node inherits today.
+ * There is no way back from `high`: raising a palette loses what it
+ * was, and a theme that has to be able to return keeps its standard
+ * self and derives the high-contrast one from it. That is what an
+ * application does anyway, since the setting it follows is a cell and
+ * both themes exist for the life of the application.
  */
-interface UiTextSpan extends UiTextMetrics {
-  readonly text: string;
-  readonly color?: UiColorValue;
-  readonly backgroundColor?: UiColorValue;
-  readonly textDecoration?: UiTextDecoration;
-  readonly link?: UiTextLink;
-}
-/** A span placed in the flattened text: the same fields, plus where it is. */
-interface UiResolvedTextSpan extends UiTextMetrics {
-  readonly start: number;
-  readonly end: number;
-  readonly color?: UiColorValue;
-  readonly backgroundColor?: UiColorValue;
-  readonly textDecoration?: UiTextDecoration;
-  readonly link?: UiTextLink;
-}
-/** A paragraph's text and the runs inside it. */
-interface UiSpannedText {
-  readonly text: string;
-  readonly spans: readonly UiResolvedTextSpan[];
-}
+declare function withContrast(theme: UiTheme, contrast: UiContrast, options?: HighContrastOptions): UiTheme;
+//#endregion
+//#region src/environment/UiPointer.d.ts
 /**
- * What text is set in when nothing says otherwise.
+ * What the person points with: a mouse or a trackpad (`fine`), or a
+ * finger (`coarse`), as CSS's `pointer` media feature says it.
  *
- * `system-ui` is the platform's own interface face (San Francisco,
- * Segoe UI, Roboto), which is what an application on that platform is
- * expected to look like; `sans-serif` is there for an engine that does
- * not know the generic. The line is 20 on 14, about 1.43, because the
- * 1.2 that a browser's `normal` comes to sets lines too tight to read
- * in a paragraph. The ink is the stock palette's `text`, not black.
+ * Separate from how big the screen is, because the two do not go
+ * together: a tablet with a trackpad is fine, a laptop with a touch
+ * screen is coarse. A layout follows the width (`Responsive`,
+ * `breakpoint`); a control follows this, growing to a target a finger
+ * can hit.
  */
-declare const defaultTextStyle: UiTextStyle;
-/** The text of a span array, with each run's offsets into it. */
-declare function flattenTextSpans(spans: readonly UiTextSpan[]): UiSpannedText;
+type UiPointer = 'fine' | 'coarse';
 /**
- * A node's paragraph as text and runs, or undefined when it has no
- * runs.
- *
- * `spans` wins over `text` when both are set, because a node that was
- * given runs meant them; the `text` prop is then ignored rather than
- * appended, so there is exactly one source of offsets.
+ * What a theme changes for a finger, laid over itself by
+ * `withPointer(theme, 'coarse')`: type a size larger (an input at 16
+ * pixels, which a phone does not zoom into), more room, and token
+ * groups of its own for touch. Any part left out stays as it is, and a
+ * token group the theme does not carry falls back to the group's own
+ * touch values (`UiThemeExtensionOptions.coarse`).
  */
-declare function spannedTextOf(node: UiNode): UiSpannedText | undefined;
+interface UiThemeTouch {
+  readonly typography?: Partial<UiTypography>;
+  readonly spacing?: Partial<UiSpacing>;
+  readonly extensions?: UiThemeExtensions;
+}
+/** The smallest target a finger can be asked to hit, in pixels: WCAG's 2.5.5, Apple's and Android's 44 to 48. */
+declare const TOUCH_TARGET = 44;
 /**
- * The text a node draws: its runs' text if it has runs, its `text`
- * property otherwise.
+ * The same theme for another pointer.
  *
- * Every reader of a node's paragraph goes through this — layout,
- * paint, selection, find and the semantics mirror — so a spanned
- * paragraph is selectable, findable and readable without any of them
- * knowing what a span is.
+ * Turned to `coarse`, it is the theme with its `touch` laid over it and
+ * `pointer` saying so; turned back, it is the theme it was turned from,
+ * kept for the purpose, so a subtree that goes from touch to mouse and
+ * back gets the identical theme each time. A theme already for that
+ * pointer is returned as it is.
  */
-declare function textContentOf(node: UiNode): string;
-/** The runs of a node's paragraph; empty when it has none. */
-declare function resolvedSpansOf(node: UiNode): readonly UiResolvedTextSpan[];
+declare function withPointer(theme: UiTheme, pointer: UiPointer): UiTheme;
+//#endregion
+//#region src/properties/UiPropertyDefinition.d.ts
 /**
- * The runs an *editable* node styles its own text with.
+ * Metadata describing a single UI property.
  *
- * An editable's paragraph is the user's, held by its model rather
- * than by a property — so unlike a `Text`, its runs do not supply the
- * text, they only describe it. `spans` on an editable is presentation
- * over a string somebody is typing.
+ * The runtime uses this definition to know:
  *
- * Which is why this checks. Every offset the editor works in — the
- * caret, the selection, the hit test that turns a click into a text
- * position — is an offset into the model's string. Runs describing a
- * *different* string would put the glyphs somewhere the caret does
- * not agree with, and the field would look subtly, unfixably wrong.
- * When they disagree the text is drawn unstyled, which is a frame of
- * plain colour rather than a frame of nonsense, and corrects itself
- * as soon as the application catches up.
+ *   - what the property is called
+ *   - what value to use when none is specified
+ *   - whether the value inherits from the scoped environment
+ *   - what changing the value invalidates
+ *   - how to compare two values for equality
+ *
+ * A property may optionally declare an environment key and a
+ * resolver that extracts the property value from that environment
+ * value. When `environmentKey` is absent, inherited properties look
+ * for an environment key whose name matches the property name.
  */
-declare function editableSpansOf(node: UiNode, text: string, composition?: UiTextRange | null): readonly UiResolvedTextSpan[];
-/** A stretch of a paragraph, as offsets into its text. */
-interface UiTextRange {
-  readonly start: number;
-  readonly end: number;
+interface UiPropertyDefinition<T> {
+  readonly name: string;
+  readonly defaultValue: T;
+  readonly inherited: boolean;
+  readonly affects: DirtyFlags;
+  readonly compare?: (a: T, b: T) => boolean;
+  readonly environmentKey?: UiEnvironmentKey<unknown>;
+  readonly resolveFromEnvironment?: (value: unknown) => T;
+  /**
+   * Rejects a value the property cannot hold, returning the message
+   * for the error the builder throws. Declared only by properties with
+   * a closed set of values, such as `role`; the builder checks it when
+   * a plain value is written, so it costs nothing on the graph's own
+   * write path. A value arriving through an Observable is checked by
+   * whatever reads it, as a bound length is checked at layout.
+   */
+  readonly validate?: (value: T) => string | undefined;
+  /**
+   * Narrows `affects` for one particular change, when what changed
+   * shows that less is invalid than the property's worst case.
+   *
+   * `paint` is the reason it exists. A painter may declare an intrinsic
+   * size, so a new painter can change layout, and `affects` has to say
+   * so; but a new picture with the same declared size (usually none)
+   * cannot, and marking layout for it laid the tree out again up to the
+   * nearest relayout boundary on every repaint, which for a painted
+   * node sized by its parent was the root, every frame of a scroll.
+   * Given the old and new values and the flags `affects` gives, it
+   * returns the flags this change actually needs.
+   */
+  readonly narrowEffects?: (previous: T, next: T, flags: DirtyFlags) => DirtyFlags;
 }
-/** The part of a run `hiddenRangesOf` reads; a paint span has it as well as a resolved one. */
-type HiddenSpan = Pick<UiResolvedTextSpan, 'start' | 'end' | 'hidden'>;
 /**
- * The stretches of a paragraph its runs hide, in order, with runs that
- * touch merged into one: `**` hidden next to a hidden `_` is one
- * stretch of three characters, which a caret steps over at once.
- * Remembered by the identity of the array, as the flattening is.
+ * Creates a property definition with the supplied metadata.
+ *
+ * The default compare function is reference equality (`Object.is`).
  */
-declare function hiddenRangesOf(spans: readonly HiddenSpan[]): readonly UiTextRange[];
-/** The span covering an offset, or undefined where no run does. */
-declare function spanAtOffset(spans: readonly UiResolvedTextSpan[], offset: number): UiResolvedTextSpan | undefined;
+declare function defineProperty<T>(options: Omit<UiPropertyDefinition<T>, 'name'> & {
+  name: string;
+}): UiPropertyDefinition<T>;
 /**
- * Compares two span arrays for equality.
- *
- * A link is compared by identity, as every function-valued prop in
- * the registry is: an application that rebuilds its handler each
- * render says the run changed, which costs a paint and no layout,
- * since a handler is not a metric field.
+ * Compares two property values using the definition's comparison
+ * function, falling back to `Object.is` when none is provided.
  */
-declare function textSpansEqual(a: readonly UiTextSpan[] | undefined, b: readonly UiTextSpan[] | undefined): boolean;
+declare function propertyValuesEqual<T>(definition: UiPropertyDefinition<T>, a: T, b: T): boolean;
+//#endregion
+//#region src/layout/UiLength.d.ts
 /**
- * Whether two lists of runs are the same text, set the same way, and
- * differ at most in colour, background and decoration, which are drawn
- * rather than measured.
+ * Length values accepted by size and offset properties.
+ *
+ * A plain number is logical pixels. Anything else is a small tagged
+ * object built by the helpers below — never a string to parse — so a
+ * typo is a type error, and a malformed value reaching the engine at
+ * runtime throws at layout rather than silently becoming zero.
+ *
+ *   width: 200            // pixels
+ *   width: percent(50)    // half of the containing size, when it is
+ *                         // definite; behaves as `auto` otherwise
+ *   margin: auto          // main-axis auto margins absorb free space;
+ *                         // cross-axis ones centre the item
+ *   minWidth: auto        // the default: a flex item's automatic
+ *                         // minimum, its min-content size
  */
-declare function spansDifferOnlyInPaint(a: readonly UiTextSpan[] | undefined, b: readonly UiTextSpan[] | undefined): boolean;
+interface PercentLength {
+  readonly unit: 'percent';
+  readonly value: number;
+}
+interface AutoLength {
+  readonly unit: 'auto';
+}
+type UiLength = number | PercentLength | AutoLength;
+/** A grid track that takes a share of free space, `fr(1)`. */
+interface FrLength {
+  readonly unit: 'fr';
+  readonly value: number;
+}
+/** A grid track bounded below and above, `minmax(100, fr(1))`. */
+interface MinMaxTrack {
+  readonly unit: 'minmax';
+  readonly min: number | PercentLength | AutoLength;
+  readonly max: number | PercentLength | AutoLength | FrLength;
+}
+/** What a grid's `columns` / `rows` arrays hold. */
+type UiTrackSize = number | PercentLength | AutoLength | FrLength | MinMaxTrack;
+declare function fr(value: number): FrLength;
+declare function minmax(min: MinMaxTrack['min'], max: MinMaxTrack['max']): MinMaxTrack;
+/** `repeat(3, fr(1))` → three `fr(1)` tracks; several sizes repeat as a pattern. */
+declare function repeat(count: number, ...sizes: UiTrackSize[]): UiTrackSize[];
+declare function isFrLength(value: unknown): value is FrLength;
+declare function isMinMaxTrack(value: unknown): value is MinMaxTrack;
+declare function percent(value: number): PercentLength;
+declare const auto: AutoLength;
+declare function isAutoLength(value: unknown): value is AutoLength | 'auto';
+declare function isPercentLength(value: unknown): value is PercentLength;
 /**
- * Compares two text styles for equality.
+ * Resolves a property value to pixels.
+ *
+ * Returns `undefined` when the property is unset, `null`, `auto`, or a
+ * percentage of an indefinite size — every case the caller treats as
+ * "no value". Returns `'auto'` only when `keepAuto` is set, for the
+ * properties where auto means something (margins, minimum sizes).
+ *
+ * Anything else that is not a finite number or a tagged length throws,
+ * naming the property: `width: '100%'` must fail loudly, not lay out
+ * as if the property were absent.
  */
-declare function textStylesEqual(a: UiTextStyle, b: UiTextStyle): boolean;
+declare function resolveLength(value: unknown, base: number | undefined, property: string, keepAuto?: boolean): number | undefined | 'auto';
 //#endregion
-//#region src/properties/UiVisualState.d.ts
+//#region src/properties/UiGradient.d.ts
 /**
- * A small, explicit set of interactive visual states.
+ * Renderer-independent gradient descriptions.
  *
- * This is intentionally not a CSS pseudo-class system. Components
- * can resolve properties against the current state set, and the
- * reactive pipeline can drive state changes through Observables.
+ * A gradient is a paint, not a colour: it is what a box's background
+ * is filled with instead of one flat value, and both backends have to
+ * arrive at the same pixels from it. So the description here is
+ * geometry plus stops, with nothing renderer-shaped in it, and the two
+ * renderers share the arithmetic in `gradientPaint` below rather than
+ * each deriving a gradient line of its own.
+ *
+ * Lengths follow the rest of the framework: a plain number is logical
+ * pixels and `percent(n)` is a fraction of whatever the value is a
+ * fraction of, never a string to parse. For a stop that is the length
+ * of the gradient itself, so `percent(50)` is halfway along it whatever
+ * the box measures, and `24` is 24 pixels from its start.
  */
-declare enum UiVisualState {
-  Normal = "normal",
-  Hovered = "hovered",
-  Pressed = "pressed",
-  Focused = "focused",
-  Disabled = "disabled",
-  Selected = "selected",
-  Dragged = "dragged"
+/** How far along a gradient a stop sits. */
+type UiGradientOffset = number | PercentLength;
+interface UiGradientStop {
+  /**
+   * Omitted on every stop of a gradient means "spread them evenly",
+   * which is what almost every gradient wants. Omitted on only some of
+   * them is an error rather than a guess: CSS's rule for filling the
+   * gaps is subtle enough that a reader could not predict the result.
+   *
+   * A number is a pixel length along the ramp, never a fraction of it:
+   * `{ offset: 0.45 }` is under half a pixel in, and a gradient whose
+   * stops all sit within the first pixel paints a one-pixel ramp that
+   * reads as nothing at all. A fraction is `percent(45)`. So
+   * `validateGradient` refuses a gradient whose numeric offsets all lie
+   * within 0 to 1 when there are two or more of them; one stop at a
+   * pixel or less among larger pixel offsets is a real position and is
+   * left alone.
+   */
+  readonly offset?: UiGradientOffset;
+  /**
+   * A palette name resolves against the theme the node inherits, so a
+   * themed gradient follows a theme change exactly as `backgroundColor`
+   * does.
+   */
+  readonly color: UiColorValue;
+}
+interface UiLinearGradient {
+  readonly kind: 'linear';
+  /**
+   * Direction in radians, on CSS's compass: 0 points at the top of the
+   * box and the angle turns clockwise, so `Math.PI / 2` runs left to
+   * right and `Math.PI` runs top to bottom.
+   */
+  readonly angle: number;
+  readonly stops: readonly UiGradientStop[];
+}
+interface UiRadialGradient {
+  readonly kind: 'radial';
+  /** The centre, from the box's top-left. Defaults to `percent(50)` on both axes. */
+  readonly centerX?: UiGradientOffset;
+  readonly centerY?: UiGradientOffset;
+  /**
+   * The radius of the outermost stop. `percent(100)`, the default, is
+   * the distance from the centre to the box's farthest corner, which is
+   * CSS's `farthest-corner`.
+   */
+  readonly radius?: UiGradientOffset;
+  readonly stops: readonly UiGradientStop[];
 }
+type UiGradient = UiLinearGradient | UiRadialGradient;
 /**
- * A set of active visual states.
+ * The most stops one gradient may carry.
+ *
+ * The WebGPU side stores a gradient as a fixed-size slab in a storage
+ * buffer, because a variable-length record would need a second buffer
+ * of stops and an index into it for what is, in every real interface, a
+ * handful of colours. Eight keeps a record at twelve `vec4`s, and a
+ * ninth stop is a loud error rather than a stop that quietly vanishes:
+ * see `validateGradient`.
  */
-type UiVisualStateSet = ReadonlySet<UiVisualState>;
+declare const MAX_GRADIENT_STOPS = 8;
 /**
- * Creates a state set from zero or more states.
+ * A linear gradient at `angle` radians, clockwise from the top.
+ *
+ *   linearGradient(Math.PI, [{ color: '#0ea5e9' }, { color: '#1e293b' }])
  */
-declare function visualState(...states: UiVisualState[]): UiVisualStateSet;
+declare function linearGradient(angle: number, stops: readonly UiGradientStop[]): UiLinearGradient;
+/** A radial gradient, centred and sized as `UiRadialGradient` describes. */
+declare function radialGradient(stops: readonly UiGradientStop[], options?: Omit<UiRadialGradient, 'kind' | 'stops'>): UiRadialGradient;
 /**
- * The default visual state set containing only Normal.
+ * Rejects a gradient the renderers cannot draw, returning the message
+ * for the error the caller raises.
+ *
+ * The property registry calls this when a plain value is written, so a
+ * bad gradient fails where it was authored. A gradient arriving through
+ * an Observable is checked by `resolveGradient` instead, at paint,
+ * which is where a bound length is checked too.
  */
-declare const defaultVisualState: UiVisualStateSet;
+declare function validateGradient(value: unknown): string | undefined;
+/** Whether two gradient property values would paint the same, for the registry. */
+declare function gradientsEqual(a: UiGradient | undefined, b: UiGradient | undefined): boolean;
+interface ResolvedGradientStop {
+  readonly offset: UiGradientOffset | undefined;
+  readonly color: UiColor;
+}
 /**
- * Returns true when the supplied state is active in the set.
+ * A gradient with its palette names resolved against the node's theme,
+ * and nothing else changed.
+ *
+ * Geometry stays as it was authored because it needs the node's box,
+ * which `resolvePaintState` does not have: the renderer turns this into
+ * a `GradientPaint` once it knows the record. Splitting it that way
+ * also means the theme is read once per node per frame rather than once
+ * per stop per pixel.
  */
-declare function hasVisualState(states: UiVisualStateSet, state: UiVisualState): boolean;
+type ResolvedGradient = {
+  readonly kind: 'linear';
+  readonly angle: number;
+  readonly stops: readonly ResolvedGradientStop[];
+} | {
+  readonly kind: 'radial';
+  readonly centerX: UiGradientOffset | undefined;
+  readonly centerY: UiGradientOffset | undefined;
+  readonly radius: UiGradientOffset | undefined;
+  readonly stops: readonly ResolvedGradientStop[];
+};
 /**
- * Compares two visual state sets for equality.
+ * Note that the resolution itself, `resolveGradient`, lives in
+ * `UiThemeColor.ts` rather than here. The registry imports this file
+ * for `gradientsEqual` and `validateGradient`, and the theme lookup
+ * reads properties, so a gradient that resolved its own stops would
+ * close a cycle through the registry. It is the same split that keeps
+ * `colorValuesEqual` in `UiColor.ts`.
  */
-declare function visualStatesEqual(a: UiVisualStateSet, b: UiVisualStateSet): boolean;
-//#endregion
-//#region src/layout/CustomLayout.d.ts
 /**
- * How many times one child may be measured in a single call to a
- * protocol's `layout`.
- *
- * Two, because two is what the engine's own flex algorithm needs: a
- * base measurement at the item's content size, and a second one once
- * the main axis is resolved so a cross size that depends on it comes
- * out right. A protocol that needs a third measurement of the same
- * child is almost always measuring inside a loop over its siblings,
- * which is the shape that turns a linear pass into a quadratic one, so
- * the third throws rather than running.
+ * A gradient placed in a box: geometry in the box's own coordinates,
+ * with the origin at its top-left, and stop offsets as fractions of the
+ * gradient's length.
  *
- * The cap is per child, so the total across a call can never exceed
- * twice the number of children however the protocol distributes them.
+ * This is the shared form both renderers draw from. Canvas2D adds the
+ * box's origin and hands the numbers to `createLinearGradient`; the
+ * WebGPU builder writes them into the frame's gradient buffer and the
+ * fragment shader evaluates the same ramp per pixel.
  */
-declare const MAX_MEASURES_PER_CHILD = 2;
+interface GradientPaint {
+  readonly kind: 'linear' | 'radial';
+  /** Linear: the start of the gradient line. Radial: the centre. */
+  readonly x0: number;
+  readonly y0: number;
+  /** Linear: the end of the gradient line. Radial: the centre again. */
+  readonly x1: number;
+  readonly y1: number;
+  /** Radial only; zero for a linear gradient. */
+  readonly radius: number;
+  readonly stops: readonly {
+    readonly offset: number;
+    readonly color: UiColor;
+  }[];
+}
 /**
- * One child of a custom layout, as its protocol sees it.
+ * Places a resolved gradient in a box of the given size.
  *
- * Deliberately not a `UiNode`. A protocol is application code running
- * inside the layout pass, and the four things here are the whole
- * budget: it can ask a child how big it is at a given size, read what
- * it last answered, read the value the element declared as
- * `layoutData`, and say where it goes. It cannot reach the node, its
- * record, its siblings' records or the engine, so there is no way for
- * it to move a box the pass is not expecting to move, and no way for
- * it to read geometry that this pass has not computed yet.
+ * The linear case is CSS's: the gradient line runs through the centre
+ * of the box in the direction of the angle, and it is long enough that
+ * the two corners nearest its ends sit exactly on its endpoints, which
+ * is `|w·sin| + |h·cos|`. The radial case is a circle, centred where
+ * the gradient says and reaching the farthest corner at `percent(100)`.
  *
- * A handle lives for exactly one call. Holding one and using it later
- * throws, because a `place` that landed after the pass had ended would
- * write a box nothing invalidated.
+ * Offsets are clamped into `[0, 1]` and forced to not go backwards, as
+ * CSS forces them, so the two backends receive one already-sorted list
+ * and neither has to decide what a stop behind its predecessor means.
  */
-interface UiLayoutChild {
-  /** Its position among the container's in-flow children, from zero. */
-  readonly index: number;
-  /**
-   * Whatever the element declared as `layoutData`: a weight, a lane, a
-   * timestamp. The protocol decides what the value means; the engine
-   * only carries it.
-   */
-  readonly data: unknown;
-  /**
-   * Measures the child under `constraints` and returns the size it
-   * takes, margins excluded.
-   *
-   * At most `MAX_MEASURES_PER_CHILD` times per call. A child that is
-   * never measured is measured once by the engine, under the same
-   * constraints the container was given, so a protocol that only
-   * arranges fixed-size children need not measure at all.
-   */
-  measure(constraints: Constraints): Size;
-  /** What the last `measure` returned, or a zero size before the first. */
-  readonly size: Size;
-  /**
-   * Puts the child's border box at a point in the container's content
-   * box, `start` running from the edge the reading starts at.
-   *
-   * Under `textDirection="rtl"` that edge is the right one and the
-   * engine mirrors the coordinate, so a layout written once is laid out
-   * both ways round. A protocol that needs to know which way it is
-   * being mirrored reads `UiLayoutContext.direction`.
-   *
-   * `margin` on a child is not applied: only the protocol knows what
-   * the space between two of its own children means, and a margin the
-   * engine added behind its back would move boxes it had placed.
-   */
-  place(start: number, top: number): void;
-  /**
-   * Where `place` last put the child, in the same coordinates, or null
-   * when this pass has not placed it. Read by `explain`.
-   */
-  readonly position: {
-    readonly start: number;
-    readonly top: number;
-  } | null;
-}
-/** What a protocol is told about the container it is laying out. */
-interface UiLayoutContext {
-  /** Which way the container reads, so a protocol can be asymmetric on purpose. */
-  readonly direction: 'ltr' | 'rtl';
-  /** The container's content box, padding excluded, when the axis is definite. */
-  readonly definiteWidth: number | undefined;
-  readonly definiteHeight: number | undefined;
-}
+declare function gradientPaint(gradient: ResolvedGradient, width: number, height: number): GradientPaint;
+//#endregion
+//#region src/properties/UiImage.d.ts
 /**
- * A layout an application writes itself: the analogue of SwiftUI's
- * `Layout` and Compose's `Layout {}`.
+ * Renderer-facing image type.
  *
- * A masonry, a radial arrangement, a timeline and a tag cloud are all
- * one function over the children's sizes, and none of them is
- * expressible in flex or in grid. Before this they were written with
- * `position: 'absolute'` and a `ctx.bounds()` subscription, which put
- * the arrangement one frame behind the sizes it was arranged from and
- * made every such component measure its own children twice.
+ * ImageBitmap is available on the main thread and in Workers
+ * (createImageBitmap), so the rendering core never depends on
+ * HTMLImageElement and an image decoded in a worker can be drawn there.
+ */
+type UiImage = ImageBitmap;
+//#endregion
+//#region src/rendering/PaintSurface.d.ts
+/**
+ * The drawing vocabulary an application gets when it wants to draw
+ * something the property set has no name for: a sparkline, a gauge, a
+ * waveform, a chart axis.
  *
- * The protocol speaks the engine's own vocabulary. `Constraints` is
- * the same class the engine hands down, `Size` is what a measurement
- * returns, and the size the protocol returns is clamped by the node's
- * own `width`, `minWidth` and the rest exactly as a Row's content size
- * is. That is the point of the shape: a custom layout is another
- * container, not a hole in the pass.
+ * It sits beside `UiRenderer` on purpose argues
+ * the placement at length. The short version is the risk it exists to
+ * avoid: a paint hook handed a `CanvasRenderingContext2D` would be a
+ * Canvas2D-only capability with a WebGPU backend that could never
+ * catch up, which is how a second-class renderer is made. Nothing here
+ * names a canvas, a device or a texture, so neither backend can be the
+ * one the vocabulary was written for.
  *
- * Hold the protocol object still. It is a property value, compared with
- * `Object.is` like every other, so a fresh object per render marks the
- * node dirty on every frame. Build it once at module scope, or
- * memoise it on the parameters it closes over.
+ * **Coordinates are the node's own.** `(0, 0)` is the top-left of the
+ * resolved box and the box's width and height are the extent, so a
+ * painter never reads a layout record and never learns where on the
+ * screen it ended up. The device scale arrives separately, for the one
+ * thing that genuinely needs it: choosing a hairline that is one
+ * physical pixel rather than one logical one.
  *
- * See `layout/conformance` for what the engine is graded against, and
- * `apps/playground/src/examples/MasonryApp.tsx` for a masonry written
- * against these exports alone.
+ * **Every call is recorded, not executed.** The object a painter is
+ * handed is a `PaintRecorder`, and what it produces is a
+ * `PaintRecording`: plain data, comparable, replayable, and cheap
+ * enough to keep. See `PaintRecording.ts` for why that indirection is
+ * what makes the two backends agree.
  */
-interface UiLayoutProtocol {
-  /** Names the arrangement in `explain` and in an error. */
-  readonly name: string;
+interface PaintSurface {
+  /** Pushes the transform, the clip and every style value. */
+  save(): void;
+  restore(): void;
+  translate(x: number, y: number): void;
+  scale(x: number, y: number): void;
+  /** Radians, clockwise, about the current origin. */
+  rotate(angle: number): void;
+  /** Multiplies the current transform by the 3x2 affine `a b c d e f`. */
+  transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+  beginPath(): void;
+  moveTo(x: number, y: number): void;
+  lineTo(x: number, y: number): void;
+  quadraticCurveTo(cx: number, cy: number, x: number, y: number): void;
+  bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
+  /** Radians; `counterclockwise` defaults to false. */
+  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+  rect(x: number, y: number, width: number, height: number): void;
+  /** One radius for all four corners, clamped to half the smaller side. */
+  roundRect(x: number, y: number, width: number, height: number, radius: number): void;
+  closePath(): void;
+  /**
+   * Appends SVG path data to the current path, in the surface's own
+   * coordinates.
+   *
+   * The whole grammar an icon set uses is understood, `A` included:
+   * `PaintPathData.ts` turns it into the calls above, so a `d` string
+   * costs exactly what writing those calls by hand would and works
+   * wherever the rest of this does. That last part is the reason it is
+   * parsed here rather than handed to `Path2D`, which exists in a
+   * browser and not in the suite.
+   */
+  path(d: string): void;
   /**
-   * Measures the children, places them, and returns the size the
-   * content needs.
+   * A `UiColor`, a hex or named CSS colour, or a palette name.
    *
-   * Called twice per pass over a node whose layout is not memoised:
-   * once while measuring, when the returned size is what the container
-   * reports to its parent and `place` does nothing, and once while
-   * placing, when the constraints are the resolved content box and the
-   * `place` calls are what assign the boxes. Both calls see the same
-   * children in the same order, so a protocol that is a function of its
-   * arguments needs no state between them, and one that keeps state
-   * anyway will be wrong the first time a memo hit skips a measurement.
+   * A palette name is the reason a painted node follows the light and
+   * dark toggle without the painter knowing there was a toggle: the
+   * name is resolved against whatever theme the node inherits, at the
+   * moment the picture is made, exactly as a `backgroundColor` prop is.
    */
-  layout(children: readonly UiLayoutChild[], constraints: Constraints, context: UiLayoutContext): Size;
+  fillColor(color: UiColorValue): void;
   /**
-   * Sentences describing the arrangement, for `LayoutEngine.explain`.
+   * A gradient for the fills that follow, placed in the rectangle
+   * given here rather than in the node's box, so a painter can ramp
+   * one bar of a chart without arithmetic of its own.
+   */
+  fillGradient(gradient: UiGradient, x: number, y: number, width: number, height: number): void;
+  strokeColor(color: UiColorValue): void;
+  lineWidth(width: number): void;
+  lineCap(cap: PaintLineCap): void;
+  lineJoin(join: PaintLineJoin): void;
+  miterLimit(limit: number): void;
+  /**
+   * A dash pattern in logical pixels, and how far into it the first
+   * dash starts. An empty pattern draws solid.
+   */
+  lineDash(segments: readonly number[], offset?: number): void;
+  /** 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.
    *
-   * Called after a pass, never during one, and given handles that can
-   * be read but neither measured nor placed. Say the things the boxes
-   * do not: how many columns there are, which one a child landed in,
-   * what was left over. `formatExplanation` prints them under the
-   * node's own reasons.
+   * Scoped by `save` and `restore` like every other style value, so a
+   * frosted panel is `save`, `blur`, draw, `restore`. Zero clears it.
    */
-  explain?(children: readonly UiLayoutChild[], size: Size, context: UiLayoutContext): readonly string[];
+  blur(radius: number): void;
+  /** Fills the current path. The default rule is `nonzero`. */
+  fill(rule?: PaintFillRule): void;
+  stroke(): void;
+  /** Intersects the clip with the current path, until the next `restore`. */
+  clip(rule?: PaintFillRule): void;
+  /**
+   * One line of text at a baseline, in the current fill colour.
+   *
+   * Deliberately one line and not a paragraph: wrapping, bidi and
+   * selection belong to the text node, which does them properly, and a
+   * painter that needs them should draw a text node instead. This is
+   * for the labels a chart puts on its own axes.
+   */
+  text(value: string, x: number, y: number, style?: PaintTextStyle): void;
+  /** Draws an image into a rectangle, stretched to fill it. */
+  image(image: UiImage, x: number, y: number, width: number, height: number): void;
 }
-/** Whether a property value is a usable layout protocol. */
-declare function isLayoutProtocol(value: unknown): value is UiLayoutProtocol;
-//#endregion
-//#region src/environment/UiTypography.d.ts
-/**
- * A typography scale.
- *
- * Each named style is a complete TextStyle so that it can be
- * inherited as a unit. Components can override individual fields
- * while falling back to the scale for the rest.
- */
-interface UiTypography {
-  readonly body: UiTextStyle;
-  readonly bodyLarge: UiTextStyle;
-  readonly bodySmall: UiTextStyle;
-  readonly headline: UiTextStyle;
-  readonly title: UiTextStyle;
-  readonly label: UiTextStyle;
+type PaintFillRule = 'nonzero' | 'evenodd';
+type PaintLineCap = 'butt' | 'round' | 'square';
+type PaintLineJoin = 'miter' | 'round' | 'bevel';
+type PaintTextAlign = 'left' | 'center' | 'right';
+/** The little of a text style a single painted line can carry. */
+interface PaintTextStyle {
+  readonly fontSize?: number;
+  readonly fontFamily?: string;
+  readonly fontWeight?: number | string;
+  /** Which end of the run `x` names. Defaults to `left`. */
+  readonly align?: PaintTextAlign;
 }
 /**
- * Roles an application adds to the scale, declared by merging.
- *
- * A scale of six covers a document and not an application: the two
- * applications here use fourteen and eleven distinct sizes. Rather
- * than grow `UiTypography` for everyone, or send an application back
- * to writing numbers on elements, a theme's typography may carry names
- * of its own, and an application declares them so they type:
- *
- *   declare module 'gesso-core' {
- *     interface UiTypographyExtensions {
- *       readonly cardTitle: unknown;
- *       readonly display: unknown;
- *     }
- *   }
- *
- * The value type is not used, only the key, because what the theme
- * carries is always a `UiTextStyle`. Declaring one makes
- * `textStyle="cardTitle"` legal and `textStyle="cardTtile"` a compile
- * error, which is the whole point.
- */
-interface UiTypographyExtensions {}
-/**
- * A role in the scale, as an element names it: `textStyle="title"`.
- *
- * The idiom the documentation teaches. A size, a weight and a line
- * height written out on an element are three numbers to keep in step
- * across a screen and six to keep in step across an application, and
- * none of them follows a theme; a role is one word that does.
- */
-type UiTypographyRole = keyof UiTypography | (keyof UiTypographyExtensions & string);
-/**
- * Whether a value names a role of the supplied scale.
+ * The box a painter is asked to fill, in its own coordinates.
  *
- * Asked of the scale rather than of a written-out list, so a role an
- * application added is a role. A name the scale does not carry is not
- * one, and the element keeps whatever type it inherited rather than
- * drawing at a default size, which is the quieter of the two failures.
- */
-declare function isTypographyRole(value: unknown, scale: UiTypography): value is UiTypographyRole;
-/**
- * The stock scale: one face, and line heights on a 4-point grid rather
- * than 1.2 of the size, so a paragraph has room and a stack of text
- * lines up with the spacing scale around it.
+ * The node's border box, not its content box: a painter that wants to
+ * respect padding is told what it is and decides, because a gauge
+ * drawn to the edge and a chart inset by its padding are both
+ * legitimate and the property set cannot tell which was meant.
  */
-declare const defaultTypography: UiTypography;
+interface PaintBox {
+  readonly width: number;
+  readonly height: number;
+  readonly paddingTop: number;
+  readonly paddingRight: number;
+  readonly paddingBottom: number;
+  readonly paddingLeft: number;
+  /**
+   * Physical pixels per logical pixel the picture is being made at.
+   *
+   * The one thing a painter needs the device for: `1 / scale` is a
+   * hairline, and a grid line drawn at `1` on a retina display is two
+   * physical pixels wide and looks it.
+   */
+  readonly scale: number;
+}
 /**
- * Compares two typography scales for equality.
+ * What a node's `paint` prop holds: the drawing, and what it depends
+ * on.
  *
- * Over the keys rather than a written-out list, as `colorsEqualPalette`
- * is and for the same reason: a scale that carries roles of its own
- * has to invalidate on a change to one of them. Written out, the six
- * shipped roles were compared and an application's own were not, so a
- * scale differing only in a role it had added compared equal and the
- * change never reached the nodes that would have read it.
- */
-declare function typographyEqual(a: UiTypography, b: UiTypography): boolean;
-//#endregion
-//#region src/environment/UiShadows.d.ts
-/**
- * A renderer-independent shadow scale.
+ * `inputs` is the whole of the cost story. The picture is made when
+ * the inputs change and at no other time, so a painted node on a
+ * still frame costs one image draw and nothing else, and
+ * `PaintPicture.budget.spec.ts` asserts exactly that. Without it the
+ * only safe assumption would be that the closure captured something
+ * new, and every frame would repaint.
  *
- * Each value is an array of shadows so layered shadows can be
- * expressed. Renderers translate these into native shadow drawing
- * operations.
+ * Values are compared with `Object.is`, one by one, so a list of
+ * numbers or of stable references works and an array literal rebuilt
+ * per render does not defeat it. Omitting `inputs` means the drawing
+ * never changes on its own, which is the right default for a static
+ * shape and the wrong one for a chart.
  */
-interface UiShadows {
-  readonly none: readonly UiBoxShadow[];
-  readonly extraSmall: readonly UiBoxShadow[];
-  readonly small: readonly UiBoxShadow[];
-  readonly medium: readonly UiBoxShadow[];
-  readonly large: readonly UiBoxShadow[];
-  readonly extraLarge: readonly UiBoxShadow[];
+interface UiPaint {
+  readonly draw: (surface: PaintSurface, box: PaintBox) => void;
+  readonly inputs?: readonly unknown[];
+  /**
+   * The size the node takes when the layout has none to give it: no
+   * width or height, no flex, nothing stretching it. Zero, like any
+   * other empty leaf, when it is absent.
+   */
+  readonly intrinsicWidth?: number;
+  readonly intrinsicHeight?: number;
 }
-declare const defaultShadows: UiShadows;
-/**
- * Compares two shadow scales for equality.
- */
-declare function shadowsEqual(a: UiShadows, b: UiShadows): boolean;
-//#endregion
-//#region src/environment/UiSpacing.d.ts
 /**
- * A renderer-independent spacing scale.
- *
- * Each value is a logical pixel gap. The names are the shape scale's
- * names on purpose: an application that has learned `borderRadius`
- * from `theme.shapes` already knows what `small` and `extraLarge`
- * mean, and one vocabulary across the theme is one thing to learn.
+ * A static vector shape, as a property rather than a function.
  *
- * Eight steps rather than the shape scale's seven, because spacing is
- * the token an application reaches for most often and a scale that
- * cannot say "two" sends the author back to a literal. The values are
- * a four pixel grid with a two pixel step at the bottom, which is what
- * the two applications' own numbers already cluster on.
+ * The declarative half of this workstream: an icon, a logo, a
+ * decorative rule, anything whose geometry is fixed and whose colours
+ * follow the theme. It is drawn through the same surface a painter
+ * writes to, so there is no second path to keep in step, and a node
+ * may carry both a `path` and a `paint` (the path is drawn first, and
+ * the painter draws over it).
  */
-interface UiSpacing {
-  readonly none: number;
-  readonly hairline: number;
-  readonly extraSmall: number;
-  readonly small: number;
-  readonly medium: number;
-  readonly large: number;
-  readonly extraLarge: number;
-  readonly huge: number;
+interface UiPath {
+  /** SVG path data, in `viewBox` units. */
+  readonly d: string;
+  /**
+   * The square the path is authored in, scaled to fit the node's box
+   * as `object-fit: contain` would, and centred in it. Omitted means
+   * the path is already in the node's own logical pixels.
+   */
+  readonly viewBox?: number;
+  readonly fill?: UiColorValue;
+  readonly fillRule?: PaintFillRule;
+  readonly stroke?: UiColorValue;
+  readonly strokeWidth?: number;
+  readonly lineCap?: PaintLineCap;
+  readonly lineJoin?: PaintLineJoin;
+  readonly miterLimit?: number;
+  readonly dash?: readonly number[];
+  readonly dashOffset?: number;
 }
-declare const defaultSpacing: UiSpacing;
-/** The steps, in order, for a scale that is derived rather than written out. */
-declare const spacingSteps: readonly (keyof UiSpacing)[];
 /**
- * The same scale at a different density.
+ * Whether two `paint` values would draw the same picture.
  *
- * Rounded to whole pixels, because a padding that lands on a half
- * pixel puts every box inside it on one too, and the renderers snap
- * differently at that point. `none` stays zero at every density: a gap
- * an application asked not to have is not a gap to shrink.
- */
-declare function scaleSpacing(spacing: UiSpacing, factor: number): UiSpacing;
-/**
- * Compares two spacing scales for equality.
+ * Identity on `draw` plus item-by-item identity on `inputs`, which is
+ * the comparison the property registry runs on every write. A painter
+ * rebuilt by a render body has a new `draw`, so a component that wants
+ * the caching has to hoist the function and vary the inputs, which is
+ * the same rule a modifier's arguments follow.
  */
-declare function spacingEqual(a: UiSpacing, b: UiSpacing): boolean;
+declare function paintValuesEqual(a: UiPaint | undefined, b: UiPaint | undefined): boolean;
+/** Item-by-item identity, with absent and empty treated alike. */
+declare function inputsEqual(a: readonly unknown[] | undefined, b: readonly unknown[] | undefined): boolean;
+/** Whether two `path` values describe the same shape in the same style. */
+declare function pathValuesEqual(a: UiPath | undefined, b: UiPath | undefined): boolean;
 //#endregion
-//#region src/environment/UiDensity.d.ts
+//#region src/properties/UiVisualState.d.ts
 /**
- * How tightly a theme packs.
- *
- * An axis rather than a second theme: an application that wants a
- * compact table and a comfortable settings sheet provides the same
- * theme twice with one field changed, and nothing else about its
- * colours or type is duplicated.
+ * A small, explicit set of interactive visual states.
  *
- * `comfortable` is the scale as written. `compact` is three quarters
- * of it, `spacious` a quarter more. Only the spacing scale moves; type
- * and shape do not, because a smaller gap between two rows is a
- * density choice and a smaller word is a typography one.
+ * This is intentionally not a CSS pseudo-class system. Components
+ * can resolve properties against the current state set, and the
+ * reactive pipeline can drive state changes through Observables.
  */
-type UiDensity = 'compact' | 'comfortable' | 'spacious';
-/** The multiplier each density applies to the spacing scale. */
-declare const densityFactors: Readonly<Record<UiDensity, number>>;
-//#endregion
-//#region src/environment/UiContrast.d.ts
+declare enum UiVisualState {
+  Normal = "normal",
+  Hovered = "hovered",
+  Pressed = "pressed",
+  Focused = "focused",
+  Disabled = "disabled",
+  Selected = "selected",
+  Dragged = "dragged"
+}
 /**
- * How much separation a theme keeps between what is drawn and what it
- * is drawn on.
- *
- * `standard` is the palette as the designer wrote it. `high` is the
- * same palette with every foreground pushed away from the surface
- * behind it until it clears a contrast ratio, which is what a person
- * who has turned the operating system's high-contrast setting on is
- * asking for. It is an axis of the theme rather than a second palette
- * so that an application which has already chosen its colours does not
- * have to choose them twice, and so that the accessibility audit has
- * one place to look.
+ * A set of active visual states.
  */
-type UiContrast = 'standard' | 'high';
+type UiVisualStateSet = ReadonlySet<UiVisualState>;
 /**
- * Relative luminance, as WCAG defines it.
- *
- * Alpha is ignored: a token is compared against the surface it sits
- * on, and what a translucent foreground actually looks like depends on
- * a composite this cannot see. Raising a translucent token toward the
- * extreme is still the right direction.
+ * Creates a state set from zero or more states.
  */
-declare function relativeLuminance(color: UiColor): number;
+declare function visualState(...states: UiVisualState[]): UiVisualStateSet;
 /**
- * The WCAG contrast ratio between two colours, from 1 to 21.
+ * The default visual state set containing only Normal.
  */
-declare function contrastRatio(a: UiColor, b: UiColor): number;
+declare const defaultVisualState: UiVisualStateSet;
 /**
- * The same colour, moved toward black or white until it clears
- * `ratio` against `against`.
- *
- * Toward whichever extreme is already the further from the surface, so
- * text on a dark ground gets lighter and text on a light ground gets
- * darker: pushing the other way would cross the surface's own
- * luminance and come out worse before it came out better. A colour
- * that cannot reach the ratio even at the extreme is returned at the
- * extreme, which is the best the palette can do and is still an
- * improvement.
- *
- * Mixed in linear steps of the stored channels rather than by solving
- * for the luminance, because the search is sixteen steps and this runs
- * when a theme is built, not when a frame is drawn.
+ * Returns true when the supplied state is active in the set.
  */
-declare function raiseContrast(color: UiColor, against: UiColor, ratio: number): UiColor;
-/** What a high-contrast palette needs to know of an application's own names. */
-interface HighContrastOptions {
-  /**
-   * Names a custom palette added that are grounds, not marks, and are
-   * left alone as the stock grounds are: a code editor's selection, its
-   * current line, a diff's filled lines. Raised as foregrounds, they
-   * would turn bright enough against the page that what is drawn on them
-   * could not be read.
-   */
-  readonly surfaces?: Iterable<string>;
-}
+declare function hasVisualState(states: UiVisualStateSet, state: UiVisualState): boolean;
 /**
- * A palette at high contrast.
- *
- * Every extra name a custom palette added is raised too, against the
- * page background, because a palette that grew a token for its own
- * accent should not be the one thing that stays quiet when the setting
- * is turned on; unless it says it is a ground (`surfaces`). The named
- * foregrounds above override that default with the surface they are
- * really drawn on.
+ * Compares two visual state sets for equality.
  */
-declare function highContrastColors(colors: UiColors, options?: HighContrastOptions): UiColors;
+declare function visualStatesEqual(a: UiVisualStateSet, b: UiVisualStateSet): boolean;
 //#endregion
-//#region src/environment/UiThemeExtension.d.ts
+//#region src/layout/CustomLayout.d.ts
 /**
- * Tokens an application adds to a theme, under its own name.
- *
- * `UiTheme` carries the vocabulary every application shares: colours,
- * type, shapes, shadows, spacing. An application always has more than
- * that, and the two in this repository each grew a module of module
- * level constants to hold it, which is a theme that no provider can
- * change and no appearance toggle can reach.
- *
- * An extension is that module turned into part of the theme:
+ * How many times one child may be measured in a single call to a
+ * protocol's `layout`.
  *
- *   const brand = defineThemeExtension({
- *     name: 'brand',
- *     defaults: { linen: '#be9a6e', chalk: '#f7f3ea' }
- *   });
+ * Two, because two is what the engine's own flex algorithm needs: a
+ * base measurement at the item's content size, and a second one once
+ * the main axis is resolved so a cross size that depends on it comes
+ * out right. A protocol that needs a third measurement of the same
+ * child is almost always measuring inside a loop over its siblings,
+ * which is the shape that turns a linear pass into a quadratic one, so
+ * the third throws rather than running.
  *
- *   const theme = withThemeExtension(lightTheme, brand, { linen: …, chalk: … });
- *   themeExtension(theme, brand).linen
+ * The cap is per child, so the total across a call can never exceed
+ * twice the number of children however the protocol distributes them.
+ */
+declare const MAX_MEASURES_PER_CHILD = 2;
+/**
+ * One child of a custom layout, as its protocol sees it.
  *
- * The read is a property access on the object the extension was
- * declared with, so an editor completes the token names and a
- * misspelling is a compile error. Nothing about `UiTheme` or
- * `themesEqual` changes to add one: the extensions ride in a map keyed
- * by the symbol `defineThemeExtension` minted, and `themesEqual`
- * compares them with each extension's own comparison.
+ * Deliberately not a `UiNode`. A protocol is application code running
+ * inside the layout pass, and the four things here are the whole
+ * budget: it can ask a child how big it is at a given size, read what
+ * it last answered, read the value the element declared as
+ * `layoutData`, and say where it goes. It cannot reach the node, its
+ * record, its siblings' records or the engine, so there is no way for
+ * it to move a box the pass is not expecting to move, and no way for
+ * it to read geometry that this pass has not computed yet.
  *
- * A component in a library may declare an extension too, which is how
- * a component that needs a token the shared vocabulary does not have
- * gets one without adding a prop for it.
+ * A handle lives for exactly one call. Holding one and using it later
+ * throws, because a `place` that landed after the pass had ended would
+ * write a box nothing invalidated.
  */
-interface UiThemeExtension<T extends object> {
-  /** Identity, so two extensions cannot collide on a name. */
-  readonly key: symbol;
-  readonly name: string;
-  /** What `themeExtension` returns for a theme that does not carry it. */
-  readonly defaults: T;
-  readonly equals: (a: T, b: T) => boolean;
-}
-interface UiThemeExtensionOptions<T extends object> {
-  readonly name: string;
-  readonly defaults: T;
+interface UiLayoutChild {
+  /** Its position among the container's in-flow children, from zero. */
+  readonly index: number;
   /**
-   * How two values of this extension are compared, for the environment
-   * to decide whether a theme change has to invalidate the subtree.
+   * Whatever the element declared as `layoutData`: a weight, a lane, a
+   * timestamp. The protocol decides what the value means; the engine
+   * only carries it.
+   */
+  readonly data: unknown;
+  /**
+   * Measures the child under `constraints` and returns the size it
+   * takes, margins excluded.
    *
-   * The default compares the group's own keys, and compares each one
-   * structurally when it is a plain object, so a group of `UiColor`
-   * tokens built freshly on each appearance change is equal to the one
-   * before it. It goes no deeper than that: an extension whose tokens
-   * are themselves nested groups should pass its own comparison rather
-   * than find out later that its theme never invalidates.
+   * At most `MAX_MEASURES_PER_CHILD` times per call. A child that is
+   * never measured is measured once by the engine, under the same
+   * constraints the container was given, so a protocol that only
+   * arranges fixed-size children need not measure at all.
    */
-  readonly equals?: (a: T, b: T) => boolean;
-}
-/** The map a theme carries. Empty for every stock theme. */
-type UiThemeExtensions = ReadonlyMap<symbol, object>;
-declare const noThemeExtensions: UiThemeExtensions;
-/**
- * Declares a group of tokens an application or a library adds to a
- * theme. Call it once, at module level, and export the result.
- */
-declare function defineThemeExtension<T extends object>(options: UiThemeExtensionOptions<T>): UiThemeExtension<T>;
-/** What the theme carries for this extension, or its declared defaults. */
-declare function themeExtension<T extends object>(theme: {
-  readonly extensions?: UiThemeExtensions;
-}, extension: UiThemeExtension<T>): T;
-/** Whether the theme carries this extension at all, rather than falling back. */
-declare function hasThemeExtension<T extends object>(theme: {
-  readonly extensions?: UiThemeExtensions;
-}, extension: UiThemeExtension<T>): boolean;
+  measure(constraints: Constraints): Size;
+  /** What the last `measure` returned, or a zero size before the first. */
+  readonly size: Size;
+  /**
+   * Puts the child's border box at a point in the container's content
+   * box, `start` running from the edge the reading starts at.
+   *
+   * Under `textDirection="rtl"` that edge is the right one and the
+   * engine mirrors the coordinate, so a layout written once is laid out
+   * both ways round. A protocol that needs to know which way it is
+   * being mirrored reads `UiLayoutContext.direction`.
+   *
+   * `margin` on a child is not applied: only the protocol knows what
+   * the space between two of its own children means, and a margin the
+   * engine added behind its back would move boxes it had placed.
+   */
+  place(start: number, top: number): void;
+  /**
+   * Where `place` last put the child, in the same coordinates, or null
+   * when this pass has not placed it. Read by `explain`.
+   */
+  readonly position: {
+    readonly start: number;
+    readonly top: number;
+  } | null;
+}
+/** What a protocol is told about the container it is laying out. */
+interface UiLayoutContext {
+  /** Which way the container reads, so a protocol can be asymmetric on purpose. */
+  readonly direction: 'ltr' | 'rtl';
+  /** The container's content box, padding excluded, when the axis is definite. */
+  readonly definiteWidth: number | undefined;
+  readonly definiteHeight: number | undefined;
+}
 /**
- * The same theme with one extension's tokens set.
+ * A layout an application writes itself: the analogue of SwiftUI's
+ * `Layout` and Compose's `Layout {}`.
  *
- * Returns a new theme; a theme is a value and is compared as one. The
- * extensions map is copied rather than mutated for the same reason,
- * since two themes derived from one base must not share it.
- */
-declare function withThemeExtension<Theme extends {
-  readonly extensions?: UiThemeExtensions;
-}, T extends object>(theme: Theme, extension: UiThemeExtension<T>, value: T): Theme;
-/**
- * Compares the extension maps of two themes.
+ * A masonry, a radial arrangement, a timeline and a tag cloud are all
+ * one function over the children's sizes, and none of them is
+ * expressible in flex or in grid. Before this they were written with
+ * `position: 'absolute'` and a `ctx.bounds()` subscription, which put
+ * the arrangement one frame behind the sizes it was arranged from and
+ * made every such component measure its own children twice.
  *
- * A key one carries and the other does not is a difference, and each
- * key is compared with the comparison its own extension declared. The
- * comparison lives on the value rather than in a registry so that an
- * extension declared in an application is compared as well as one
- * declared here, which is the whole point of the mechanism.
- */
-declare function themeExtensionsEqual(a: UiThemeExtensions | undefined, b: UiThemeExtensions | undefined): boolean;
-//#endregion
-//#region src/environment/UiTheme.d.ts
-/**
- * A renderer-independent theme.
+ * The protocol speaks the engine's own vocabulary. `Constraints` is
+ * the same class the engine hands down, `Size` is what a measurement
+ * returns, and the size the protocol returns is clamped by the node's
+ * own `width`, `minWidth` and the rest exactly as a Row's content size
+ * is. That is the point of the shape: a custom layout is another
+ * container, not a hole in the pass.
  *
- * A theme bundles colors, typography, shapes, shadows and spacing into
- * a single environment value. It can be provided at any node and is
- * inherited by descendants until another provider overrides it.
+ * Hold the protocol object still. It is a property value, compared with
+ * `Object.is` like every other, so a fresh object per render marks the
+ * node dirty on every frame. Build it once at module scope, or
+ * memoise it on the parameters it closes over.
  *
- * `density` and `contrast` are axes rather than scales: they record
- * which way this theme was already turned, so a component can branch
- * on the answer and `withDensity` and `withContrast` can turn it
- * again from the base. `extensions` is where an application's own
- * token groups live; see `UiThemeExtension.ts`.
+ * See `layout/conformance` for what the engine is graded against, and
+ * `apps/playground/src/examples/MasonryApp.tsx` for a masonry written
+ * against these exports alone.
  */
-interface UiTheme {
-  readonly colors: UiColors;
-  readonly typography: UiTypography;
-  readonly shapes: UiShapes;
-  readonly shadows: UiShadows;
-  readonly spacing: UiSpacing;
-  readonly density: UiDensity;
-  readonly contrast: UiContrast;
-  readonly extensions?: UiThemeExtensions;
+interface UiLayoutProtocol {
+  /** Names the arrangement in `explain` and in an error. */
+  readonly name: string;
+  /**
+   * Measures the children, places them, and returns the size the
+   * content needs.
+   *
+   * Called twice per pass over a node whose layout is not memoised:
+   * once while measuring, when the returned size is what the container
+   * reports to its parent and `place` does nothing, and once while
+   * placing, when the constraints are the resolved content box and the
+   * `place` calls are what assign the boxes. Both calls see the same
+   * children in the same order, so a protocol that is a function of its
+   * arguments needs no state between them, and one that keeps state
+   * anyway will be wrong the first time a memo hit skips a measurement.
+   */
+  layout(children: readonly UiLayoutChild[], constraints: Constraints, context: UiLayoutContext): Size;
+  /**
+   * Sentences describing the arrangement, for `LayoutEngine.explain`.
+   *
+   * Called after a pass, never during one, and given handles that can
+   * be read but neither measured nor placed. Say the things the boxes
+   * do not: how many columns there are, which one a child landed in,
+   * what was left over. `formatExplanation` prints them under the
+   * node's own reasons.
+   */
+  explain?(children: readonly UiLayoutChild[], size: Size, context: UiLayoutContext): readonly string[];
 }
-declare const lightTheme: UiTheme;
-declare const darkTheme: UiTheme;
-/**
- * Compares two themes for equality.
- *
- * The extensions are compared with each extension's own comparison, so
- * an application that adds a token group gets invalidation on a change
- * to it without editing this function. That was the point of the
- * mechanism: a theme layer
- * added without extending `themesEqual` is a theme change that does
- * not repaint, and it is easy to forget.
- */
-declare function themesEqual(a: UiTheme, b: UiTheme): boolean;
-/**
- * The same theme at another density.
- *
- * Derived from the theme it is given rather than from a base, so
- * asking twice for `compact` does not shrink the scale twice: a theme
- * already at that density is returned unchanged.
- */
-declare function withDensity(theme: UiTheme, density: UiDensity): UiTheme;
-/**
- * The same theme at another contrast.
- *
- * There is no way back from `high`: raising a palette loses what it
- * was, and a theme that has to be able to return keeps its standard
- * self and derives the high-contrast one from it. That is what an
- * application does anyway, since the setting it follows is a cell and
- * both themes exist for the life of the application.
- */
-declare function withContrast(theme: UiTheme, contrast: UiContrast, options?: HighContrastOptions): UiTheme;
+/** Whether a property value is a usable layout protocol. */
+declare function isLayoutProtocol(value: unknown): value is UiLayoutProtocol;
 //#endregion
 //#region src/properties/UiVideo.d.ts
 /**
@@ -7043,7 +7236,7 @@ declare const UiProperties: {
    */
   readonly borderRadius: UiPropertyDefinition<UiBorderRadiusValue>;
   readonly opacity: UiPropertyDefinition<number>;
-  readonly boxShadows: UiPropertyDefinition<readonly UiBoxShadow[]>;
+  readonly boxShadows: UiPropertyDefinition<UiBoxShadows>;
   readonly visible: UiPropertyDefinition<boolean>;
   readonly fontFamily: UiPropertyDefinition<string>;
   readonly fontSize: UiPropertyDefinition<number>;
@@ -7153,6 +7346,15 @@ declare const UiProperties: {
    * container instead.
    */
   readonly pointerEvents: UiPropertyDefinition<UiPointerEvents | undefined>;
+  /**
+   * Takes a mouse over this subtree as a finger, as a browser's device
+   * mode does: nothing is hovered without a press, a press hovers what
+   * it lands on until it lifts, and the press has a finger's slop and
+   * gestures. For a design tool playing a screen drawn for touch with a
+   * mouse; read up the ancestor chain. A finger and a pen are
+   * unchanged.
+   */
+  readonly touchEmulation: UiPropertyDefinition<boolean | undefined>;
   readonly focusable: UiPropertyDefinition<boolean | undefined>;
   readonly tabStop: UiPropertyDefinition<boolean | undefined>;
   readonly disabled: UiPropertyDefinition<boolean | undefined>;
@@ -7242,6 +7444,15 @@ declare const UiProperties: {
   readonly columnCount: UiPropertyDefinition<number | undefined>;
   /** Any subset of x, y, scaleX, scaleY, rotation; the rest is identity. */
   readonly transform: UiPropertyDefinition<Partial<UiTransform> | undefined>;
+  /**
+   * Keep what this subtree paints as pixels, and copy them while only
+   * what is above it moves or scales: a design tool's frames under a
+   * zooming camera, a map's tiles under a pan. Canvas2D only; see
+   * `RasterCache.ts` for when it draws them again. A hint: a subtree
+   * that changes on most frames, or one too large to hold at the scale
+   * it is drawn at, is drawn directly.
+   */
+  readonly rasterize: UiPropertyDefinition<boolean>;
   readonly text: UiPropertyDefinition<string | undefined>;
   readonly image: UiPropertyDefinition<ImageBitmap | undefined>;
   /**
@@ -7253,6 +7464,16 @@ declare const UiProperties: {
    * why the value is a surface with a version rather than a frame.
    */
   readonly video: UiPropertyDefinition<UiVideoSurface | undefined>;
+  /**
+   * The URL the node's picture was loaded from, as `imageSource` last
+   * resolved it: an image's or an SVG's.
+   *
+   * Nothing lays it out or paints it. It is there for what reads a tree
+   * as a document, an inspector, a design tool writing the screen as
+   * HTML, since the bitmap or the drawing on the node no longer says
+   * where it came from.
+   */
+  readonly src: UiPropertyDefinition<string | undefined>;
   readonly objectFit: UiPropertyDefinition<UiObjectFit | undefined>;
   readonly scrollX: UiPropertyDefinition<number | undefined>;
   /**
@@ -7333,6 +7554,13 @@ declare const UiProperties: {
   /** Set by LazySheet on the scroll container: its UiVirtualSheet. */
   readonly virtualSheet: UiPropertyDefinition<UiVirtualSheet | undefined>;
   readonly theme: UiPropertyDefinition<UiTheme | undefined>;
+  /**
+   * What the person points with in this subtree, `fine` or `coarse`,
+   * over the device's: a design tool's frame drawn as a phone says
+   * `coarse`, and the controls in it grow to a finger's size. See
+   * `UiPointer`.
+   */
+  readonly pointer: UiPropertyDefinition<UiPointer | undefined>;
   /**
    * The type this element and its subtree are written in: a role in
    * the theme's scale (`textStyle="title"`), or a style of its own.
@@ -7503,13 +7731,13 @@ type FlexItemProps = PropsOf<'flex' | 'flexGrow' | 'flexShrink' | 'flexBasis' |
 /** Where an element sits in a Grid. */
 type GridItemProps = PropsOf<'column' | 'columnSpan' | 'row' | 'rowSpan'>;
 type PositionProps = PropsOf<'position' | 'top' | 'right' | 'bottom' | 'left' | 'inset' | 'zIndex' | 'lift' | 'liftBoundary' | 'anchor' | 'anchorPoint' | 'anchorRect' | 'placement' | 'anchorOffset'>;
-type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColor' | 'borderWidth' | 'borderRadius' | 'opacity' | 'boxShadows' | 'visible' | 'transform'>;
+type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColor' | 'borderWidth' | 'borderRadius' | 'opacity' | 'boxShadows' | 'visible' | 'transform' | 'rasterize'>;
 /**
  * Inherited text properties. Legal on any element: set on a container,
  * they cascade to the text below it.
  */
 type TypographyProps = PropsOf<'color' | 'fontFamily' | 'fontSize' | 'fontWeight' | 'lineHeight' | 'letterSpacing' | 'textAlign' | 'textDirection' | 'fontStyle' | 'fontStretch' | 'fontVariant' | 'fontKerning' | 'textDecoration'>;
-type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'focusable' | 'tabStop' | 'disabled' | 'hitTestable' | 'visualState' | 'selectable' | 'editingGroup' | 'textInput'>;
+type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'touchEmulation' | 'focusable' | 'tabStop' | 'disabled' | 'hitTestable' | 'visualState' | 'selectable' | 'editingGroup' | 'textInput'>;
 /**
  * What the element means, for assistive technology. Legal on any
  * element; a component sets them on the node that *is* the control,
@@ -7517,7 +7745,7 @@ type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'focusable' | 'tabS
  */
 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' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets'>;
+type EnvironmentProps = PropsOf<'theme' | 'pointer' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets'>;
 /**
  * Behaviour attached to an element without wrapping it: hover and
  * press state, a focus ring, a tooltip, drag. See `packages/core/src/modifiers`.
@@ -7870,6 +8098,17 @@ declare class UiGraphBuilder {
   private warnMissingAnimations;
   /** The modifiers attached to a node, for the inspector and for tests. */
   modifiersFor(node: UiNode): UiModifierSet | undefined;
+  /**
+   * Where the element a node was last reconciled from was written, for
+   * the inspector and for tools that edit the source. For a component's
+   * anchor it is where the component was used, so walking up from a
+   * node gives the line that made it and then each place it was used.
+   *
+   * Read off the definition the builder already keeps for each node
+   * rather than stored on the node, so it costs a tree nothing when no
+   * element carries one, which is every element in production.
+   */
+  sourceOf(node: UiNode): UiSourceLocation | undefined;
   /**
    * Rejects a prop nothing will ever read.
    *
@@ -9502,6 +9741,13 @@ declare const UiEnvironmentKeys: {
    * as it changes. Provided by `Responsive` and by the
    * `containerSize` property; see `UiContainerSize`.
    */
+  /**
+   * What the person points with here: the device's, as the runtime
+   * reads it (CSS's `pointer` feature), or what an ancestor said with
+   * `pointer`. A theme provided under `coarse` is turned for it
+   * (`withPointer`). See `UiPointer`.
+   */
+  readonly pointer: UiEnvironmentKey<UiPointer>;
   readonly containerSize: UiEnvironmentKey<UiContainerSize>;
   /**
    * What is in the way of the content on each edge: the platform's
@@ -11059,6 +11305,11 @@ interface PointerControllerOptions {
  *     same thing by holding, which the gesture recognizer answers.
  *   - Touch hover: a finger's hover is dropped when it lifts, because
  *     the finger is no longer anywhere. A mouse keeps its hover.
+ *   - Touch emulation: over a `touchEmulation` subtree a mouse is taken
+ *     as a finger, as a browser's device mode does. Its moves with
+ *     nothing pressed hover nothing there, and a press there is a
+ *     finger's from down to up: its slop, its gestures and its hover
+ *     dropped when it lifts.
  *   - Scrollbars: a press on a scroll container's thumb starts a drag
  *     that moves the content with the pointer; a press on the track
  *     beside a visible thumb pages one viewport toward the pointer.
@@ -11116,6 +11367,8 @@ declare class UiPointerController {
     readonly y: number;
   } | null;
   private lastPosition;
+  /** Whether the last hover hit was on a scrollbar; see `overScrollbar`. */
+  private hoverOnScrollbar;
   /** The pressed node and its ancestors when the press began, deepest first. */
   private downPath;
   get hoveredNode(): UiNode | null;
@@ -11132,26 +11385,33 @@ declare class UiPointerController {
   private captured;
   /** The scroll container whose thumb is being dragged, or null. */
   get draggingScrollbarOf(): UiNode | null;
+  /**
+   * Whether the pointer is on a scrollbar, or dragging a thumb: the arrow
+   * is shown there whatever the content under the bar asks for, as over a
+   * native scrollbar. A hit on a bar is its scroll container's, so the
+   * cursor set above that (an editor's I-beam) was shown over the thumb.
+   */
+  get overScrollbar(): boolean;
   /**
    * Pointer press. Hit-tests at the point, establishes hover, and
    * dispatches PointerDown to the pressed node. Subsequent moves and
    * the up are routed to that node until release.
    */
-  pointerDown(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, pointer?: UiPointerDevice): UiPointerEvent;
+  pointerDown(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, device?: UiPointerDevice): UiPointerEvent;
   /**
    * Pointer movement. While a press is active the move is routed to
    * the pressed node (capture); otherwise it hit-tests, updates
    * hover enter/leave, and dispatches PointerMove to the hovered
    * node. Returns null when the move lands on empty space.
    */
-  pointerMove(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, pointer?: UiPointerDevice): UiPointerEvent | null;
+  pointerMove(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, device?: UiPointerDevice): UiPointerEvent | null;
   /**
    * Pointer release. Dispatches PointerUp to the pressed node and,
    * when the press did not travel beyond the slop and was not
    * cancelled via preventDefault on the down, synthesizes a Click on
    * the same node. Returns null when nothing was pressed.
    */
-  pointerUp(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, pointer?: UiPointerDevice): UiPointerEvent | null;
+  pointerUp(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, device?: UiPointerDevice): UiPointerEvent | null;
   /**
    * Pairs this Click with the one before it, and dispatches a
    * DoubleClick when they make a pair.
@@ -11168,7 +11428,7 @@ declare class UiPointerController {
    * Aborts the active press: dispatches PointerCancel to the pressed
    * node and clears press state so no Click is synthesized.
    */
-  pointerCancel(pointer?: UiPointerDevice): void;
+  pointerCancel(device?: UiPointerDevice): void;
   /**
    * Whether an event from this contact should be acted on.
    *
@@ -11178,6 +11438,8 @@ declare class UiPointerController {
    * a mouse that never pressed anything.
    */
   private ownsPress;
+  /** The contact an event is from: the press's own, which an emulated finger's mouse events are part of. */
+  private contactOf;
   /**
    * A press on the thumb starts a drag that maps pointer travel to
    * scroll offset through the thumb's travel range. A press on the
@@ -11314,6 +11576,8 @@ interface UiShortcutStep {
   readonly meta: boolean;
   readonly shift: boolean;
   readonly alt: boolean;
+  /** The physical key a press was made on, in the DOM's `code` vocabulary; only a press has one. */
+  readonly code?: string;
 }
 /** What an application registers. */
 interface UiShortcut {
@@ -11442,8 +11706,11 @@ declare class UiShortcutRegistry {
    * `preventDefault()` so the keyboard controller's own defaults (Tab
    * navigation, Enter on a button, an editable's typing) do not also
    * act on a key that has already been spent.
+   *
+   * `code` is the physical key, which a digit written with Shift
+   * matches on (see `sameStep`).
    */
-  handleKey(key: string, modifiers: UiKeyModifiers, focused: UiNode | null): boolean;
+  handleKey(key: string, modifiers: UiKeyModifiers, focused: UiNode | null, code?: string): boolean;
   private platform;
   /** Whether a field would take this key as an edit of its own, rather than as text or as Enter. */
   private isEditingKey;
@@ -12500,7 +12767,6 @@ declare function isNodeInert(node: UiNode): boolean;
  * descendant can set 'auto'; the hit tester follows that itself.
  */
 declare function isSubtreeInert(node: UiNode): boolean;
-/** `pointerEvents` as CSS inherits it: the nearest value set from the node up, 'auto' when none is. */
 declare function pointerEventsOf(node: UiNode | null): 'auto' | 'none';
 /** The node itself cannot be the target of a hit, but children can. */
 declare function isNodeHitTestable(node: UiNode): boolean;
@@ -12696,6 +12962,8 @@ declare class UiHostFrameClock implements UiFrameClock {
   /** Gaps between this thread's own refreshes while frames ran back to back. */
   private readonly localIntervals;
   private lastLocalTime;
+  /** How long the frame drawn at `lastLocalTime` took, which says whether the gap after it was the refresh's or the frame's. */
+  private lastLocalCost;
   /** The display's interval and the host's time origin, once the host has said. */
   private display;
   /**
@@ -12704,6 +12972,11 @@ declare class UiHostFrameClock implements UiFrameClock {
    * show (see \`displayInterval\`).
    */
   private locked;
+  /** This thread's own `requestAnimationFrame` once given up, kept to see whether it keeps time after all. */
+  private givenUp;
+  /** When this thread's refreshes were last timed again, and their times while they are being. */
+  private lastRetry;
+  private retrying;
   /** The host's recent refresh times, which give the beat its phase. */
   private readonly refreshes;
   /** Host refreshes since the last frame drawn on the beat. */
@@ -12759,6 +13032,23 @@ declare class UiHostFrameClock implements UiFrameClock {
    * a faster screen), not a worker failing to keep up with it.
    */
   private compareLocal;
+  /**
+   * Times this thread's own refreshes again, now and then, once they were
+   * given up, and takes them back if they keep the display's time.
+   *
+   * Given up for good, a worker's refreshes stayed given up whatever had
+   * made them slow. A Chrome worker busy between its frames, opening a
+   * large file or scrolling through lines it has never drawn, refreshes
+   * late and unevenly, which no measure of the gaps alone told from
+   * WebKit's timer: 5.5, 25.5, 10.9, 25 ms on a 165 Hz display one time,
+   * 12.1, 6.1, 12.2, 24.2 the next. Its frames then went through the
+   * host's ticks for as long as the page was open, a message and a hop
+   * through the page's thread each. Timed again while frames are cheap,
+   * they come a refresh apart and are taken back; WebKit's come 15 ms
+   * apart on a 120 Hz display however idle the thread is, and stay given
+   * up. Nine refreshes every two seconds or more, while frames come cheap.
+   */
+  private retryLocal;
   /** A time on the host's clock, on this thread's. */
   private toLocal;
   /**
@@ -13119,7 +13409,6 @@ declare function labelNode(node: UiNode): string;
 declare function formatExplanation(explanation: LayoutExplanation): string;
 //#endregion
 //#region src/layout/LayoutEngine.d.ts
-/** How long overlay scrollbars stay after the last scroll change. */
 declare const SCROLLBAR_LINGER_MS = 1200;
 /** Portion of the linger during which the scrollbar fades out. */
 declare const SCROLLBAR_FADE_MS = 350;
@@ -13427,6 +13716,15 @@ declare class LayoutEngine {
    * with the node and sits twice as far into it.
    */
   screenBox(node: UiNode, part?: LayoutBox): LayoutBox;
+  /**
+   * Where everything under a node is drawn, through every transform
+   * above it: its subtree's bounds, as `subtreeBoundsFor` left them,
+   * projected as `screenBox` projects the node's own box. Null when the
+   * subtree has no bounds to cull by (it draws past them, or has no
+   * record). What a walk under a panned, zoomed parent passes a whole
+   * subtree over by when none of it is on screen.
+   */
+  screenBounds(node: UiNode): LayoutBox | null;
   /**
    * The scroll offsets each scroll ancestor would need so that `node`
    * is inside its viewport, `padding` pixels from the nearest edge,
@@ -14190,6 +14488,16 @@ declare class LayoutEngine {
    */
   private lengthProp;
   private lengthPropOrAuto;
+  /**
+   * A length, or nothing when the value cannot be one. A plain value
+   * that cannot is refused when it is written (each length property's
+   * `validate`); one that arrives bound, from an Observable, is caught
+   * here. Throwing here abandoned the frame, and with it every other
+   * element: one mock's `width: '100%'` stopped a whole design editor
+   * drawing. So it is said, once for the node and property, and the
+   * element is laid out as if the property were not set.
+   */
+  private lengthOrNothing;
   /**
    * A margin side: the side's own value, else the logical side that
    * resolved to it, else its axis, else the shorthand; may be auto.
@@ -15268,11 +15576,9 @@ interface DefaultImageResolverOptions {
  *
  * **What it cannot decode.** `createImageBitmap` takes a `Blob`, and
  * Chrome refuses an SVG one — "The source image could not be decoded".
- * So an `Image` pointed at an `.svg` fails on a browser where the same
- * file in an `<img>` would work, and a vector glyph belongs in `Icon`,
- * which draws a path rather than decoding a document. Found by
- * pointing the playground's Media card at an SVG data URL and getting
- * a placeholder.
+ * Found by pointing the playground's Media card at an SVG data URL and
+ * getting a placeholder. So an `Image` never sends one here: an SVG
+ * source is read by `SvgResolver` and drawn as vectors (`svg/`).
  *
  * **Eviction.** Reference counting first, LRU second. A bitmap
  * something on screen is holding is never evicted, however long the
@@ -15298,6 +15604,131 @@ declare class DefaultImageResolver implements ImageResolver {
   dispose(): void;
 }
 //#endregion
+//#region src/rendering/svg/SvgXml.d.ts
+/**
+ * Just enough XML to read an SVG file, in a worker.
+ *
+ * A render worker has no `DOMParser`, and an SVG file is XML, so the
+ * file is read here: elements, their attributes and their nesting.
+ * Text is kept only where SVG gives it meaning to a drawing, inside
+ * `<style>`; everything else that is not an element (the declaration,
+ * a doctype, comments, processing instructions) is skipped.
+ *
+ * Forgiving on purpose, in the way `tracePathData` is: a file a
+ * design tool exported is well formed, and one that is not is better
+ * drawn as far as it reads than refused, so an unclosed element is
+ * closed at the end and a stray close tag is ignored.
+ */
+interface SvgXmlElement {
+  /** The element's name, with any namespace prefix: `svg`, `path`, `xlink:href` is an attribute. */
+  readonly name: string;
+  readonly attributes: Readonly<Record<string, string>>;
+  readonly children: readonly SvgXmlElement[];
+  /** The text directly inside it, joined; empty for an element with none. */
+  readonly text: string;
+}
+//#endregion
+//#region src/rendering/svg/SvgDocument.d.ts
+/**
+ * An SVG file, read and ready to draw.
+ *
+ * Gesso cannot hand an SVG file to the platform: `createImageBitmap`
+ * refuses one in Chrome, and a render worker has no `<img>` to draw it
+ * through. It does not need to. An SVG is shapes, paint and transforms,
+ * and `PaintSurface` is exactly that vocabulary, so the file is read
+ * here and drawn through it by `drawSvg`: as vectors, on either
+ * renderer, at whatever size the node is laid out at, and with
+ * `currentColor` following the theme.
+ *
+ * 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.
+ */
+interface SvgDocument {
+  /** The `<svg>` element. */
+  readonly root: SvgXmlElement;
+  /** The size the file asks to be drawn at, in logical pixels: its `width` and `height`, else its viewBox's. */
+  readonly width: number;
+  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. */
+  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. */
+  readonly unsupported: readonly string[];
+}
+interface SvgRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+/** One rule of a `<style>`: which elements, and what it declares for them. */
+interface SvgStyleRule {
+  readonly selector: SvgSelector;
+  readonly declarations: Readonly<Record<string, string>>;
+  /** For the cascade: ids over classes over names. */
+  readonly specificity: number;
+}
+/** A compound selector of the kind exporters write: `path`, `.st0`, `#logo`, `g.mark`. */
+interface SvgSelector {
+  readonly name?: string;
+  readonly id?: string;
+  readonly classes: readonly string[];
+}
+/**
+ * Reads an SVG file. Throws when it holds no `<svg>` element, since
+ * there is then nothing to draw and the caller should fall back.
+ */
+declare function parseSvg(source: string): SvgDocument;
+//#endregion
+//#region src/rendering/svg/SvgResolver.d.ts
+/**
+ * Turns an SVG source into a read document, as `ImageResolver` turns a
+ * picture's into a bitmap: fetched once, read once, shared by every
+ * node that shows it.
+ */
+interface SvgResolver {
+  /** The read document, or a rejection when it will not fetch or is not SVG. */
+  resolve(source: string): Promise<SvgDocument>;
+  /** The document when it has already been read, so a node built in this frame draws it at once. */
+  peek?(source: string): SvgDocument | null;
+}
+interface DefaultSvgResolverOptions {
+  /** How many read files to keep. They are small: a tree of elements, no pixels. */
+  capacity?: number;
+  /** Injectable for specs, and for an app that fetches through its own stack. */
+  fetch?: (source: string) => Promise<string>;
+}
+/**
+ * Whether a source is an SVG file, from its name or its data URL's
+ * type: what `Image` asks before it decodes, since the platform
+ * decoder refuses SVG and this one draws it.
+ */
+declare function isSvgSource(source: string): boolean;
+/**
+ * Fetch, read, keep.
+ *
+ * Kept by recency and never closed, unlike a bitmap: a read file holds
+ * no decoded pixels, so there is nothing to release promptly, and a
+ * file a screen shows a hundred times (an icon in every row) is read
+ * once. A failed fetch is not kept, so the next node tries again.
+ */
+declare class DefaultSvgResolver implements SvgResolver {
+  private readonly entries;
+  private readonly settled;
+  private readonly capacity;
+  private readonly fetchText;
+  constructor(options?: DefaultSvgResolverOptions);
+  resolve(source: string): Promise<SvgDocument>;
+  peek(source: string): SvgDocument | null;
+}
+//#endregion
 //#region src/rendering/IconRasterizer.d.ts
 /** What an icon is: a path in a square viewBox, at a size, in a colour. */
 interface IconSpec {
@@ -15385,6 +15816,16 @@ declare class IconRasterizer {
 }
 //#endregion
 //#region src/modifiers/media.d.ts
+/**
+ * How many pictures the media modifiers in this thread are still
+ * fetching or decoding: an `Image`'s bitmap or its SVG.
+ *
+ * A tree waiting on a picture asks for no frames while it waits, so a
+ * caller that judges a tree finished by its quiet (`renderFrame`, which
+ * draws a mock once, off screen) would draw it without the picture.
+ * This is the other half of finished: nothing still on its way.
+ */
+declare function mediaLoadsInFlight(): number;
 /** One url, or several to try in order until one resolves. */
 type ImageSources = string | readonly string[];
 interface ImageSourceArgs {
@@ -15395,6 +15836,13 @@ interface ImageSourceArgs {
    * new value replaces the last.
    */
   readonly source: Reactive<ImageSources>;
+  /**
+   * Where an SVG source is read, since the platform decoder refuses
+   * one. Given, an `.svg` or `data:image/svg+xml` source is drawn as
+   * vectors through the node's `paint`, fitted by its `objectFit`;
+   * without it, an SVG source is decoded like any other and fails.
+   */
+  readonly vectors?: SvgResolver;
   readonly onState?: (state: 'loading' | 'loaded' | 'failed', error?: unknown) => void;
 }
 /**
@@ -16568,6 +17016,14 @@ interface UiRenderer {
    * emptied too and will not say so. The next frame redraws everything.
    */
   surfaceRestored?(): void;
+  /**
+   * When, on the \`performance.now\` clock, the renderer wants a frame
+   * though nothing changes: Canvas2D's kept subtrees, drawn stretched
+   * while a zoom moves, are drawn sharp once it settles, and nothing
+   * else would ask for that frame. Undefined when nothing waits. Read
+   * after each frame.
+   */
+  nextRepaint?(): number | undefined;
   dispose(): void;
 }
 //#endregion
@@ -16711,6 +17167,112 @@ declare class TextRasterCache {
   private drop;
 }
 //#endregion
+//#region src/rendering/canvas2d/RasterCache.d.ts
+/**
+ * Subtrees kept as pixels, for a node marked `rasterize`, and copied
+ * onto the frame while only what is above them moves or scales.
+ *
+ * **Why.** A design tool's board is a camera over a few dozen frames,
+ * each a whole screen of photographs, vector logos and text. Zooming
+ * it changes nothing inside any frame, yet a full traversal draws every
+ * one of them again on every step: in Atelier, twenty frames cost 10 to
+ * 50 ms a step, most of it resampling the photographs and filling the
+ * logos' paths at a scale they had not been drawn at before. Copied, a
+ * frame is one `drawImage`.
+ *
+ * **What is kept.** What the node and its subtree paint, drawn once into
+ * a canvas of its own at the device scale it is drawn at, over the
+ * area its subtree may paint (its record's extent), relative to its own
+ * corner: a node that moves without changing is copied where it is.
+ *
+ * **When it is drawn again.**
+ *
+ *   - At once, when what it shows may have changed: anything in the
+ *     subtree was dirtied, an ancestor changed what it passes down, the
+ *     node changed size, or the frame was not vouched for.
+ *   - Once a zoom has settled, when the scale it is drawn at is not the
+ *     one it was kept at. While the scale keeps changing the pixels it
+ *     has are stretched, which is blurred or soft for a moment and keeps
+ *     the frame rate; when the scale has held for `SETTLE_MS` it is
+ *     drawn again, sharp, a few a frame, and `nextRepaint` asks the
+ *     runtime for the frame that does it, since nothing else would.
+ *   - Mid-zoom, when the stretch is past what still reads as the picture
+ *     (`MAX_STRETCH`) and the frame has the time left for it, by what it
+ *     took the last time; one that would drop the frame waits to settle.
+ *
+ * **When it is drawn directly instead.** A context that rotates or
+ * skews; a node with a transform or a sticky shift of its own; a
+ * subtree that would not fit in `MAX_RASTER_PIXELS` at the scale it is
+ * drawn at (zoomed far into it, where only a part is on screen and
+ * culling draws just that part); one whose pixels change without its
+ * changes saying so (a caret, a fading scrollbar, a video) or which lifts
+ * something to the top layer; and one drawn again on most of its recent
+ * frames, which a cache would only draw twice.
+ */
+declare class RasterCache {
+  private readonly createCanvas;
+  private readonly settleMs;
+  private readonly entries;
+  private frame;
+  private pixels;
+  private open;
+  /** Pixels drawn again this frame for a sharper scale. */
+  private spent;
+  /** The frame's own size in device pixels; nothing larger is kept. */
+  private surfacePixels;
+  private wanted;
+  /** Copies, draws into the cache, and draws left to the frame, since the last reset. For budget specs. */
+  readonly stats: {
+    copied: number;
+    drawn: number;
+    direct: number;
+  };
+  constructor(createCanvas: LayerCanvasFactory, settleMs?: number);
+  /**
+   * Marks what the frame's changes leave out of date, before anything is
+   * drawn. A frame the caller could not vouch for, or one after a frame
+   * that never finished, leaves everything out of date.
+   */
+  beginFrame(changes: RenderChanges | undefined, surfacePixels?: number): void;
+  /** Lets go of what was not drawn lately: removed, culled for a while, or hidden. */
+  endFrame(): void;
+  dropAll(): void;
+  resetStats(): void;
+  /**
+   * When the frame just drawn would like another though nothing changes:
+   * a zoom settling, whose kept pixels are then drawn again at the scale
+   * it stopped at. Undefined when nothing waits.
+   */
+  get nextRepaint(): number | undefined;
+  /**
+   * Draws a node and its subtree from the cache, drawing them into it
+   * first when what it holds is out of date. `paint` draws them into the
+   * context it is handed, already placed, and answers whether what it
+   * drew may be kept (see the class comment). False when the node should
+   * be drawn directly.
+   */
+  draw(ctx: Canvas2DContext, node: UiNode, rec: LayoutRecord, now: number, paint: (target: Canvas2DContext, width: number, height: number) => boolean): boolean;
+  /**
+   * A subtree kept at another scale than it is drawn at: stretched while
+   * the scale is moving, drawn again once it has settled or when it is
+   * stretched too far, as the frame's budget allows.
+   */
+  private resharpen;
+  private want;
+  /**
+   * Draws the subtree into the node's canvas at a scale, its area's
+   * corner at (`cornerX`, `cornerY`) in layout pixels, with the
+   * fraction of a device pixel its corner lands on, so a copy at that
+   * scale is the direct draw's pixels. Null when no canvas could be had,
+   * or when what `paint` drew may not be kept; the entry then draws
+   * directly for a while, and this frame copies what was drawn.
+   */
+  private redraw;
+  /** Makes room for `needed` more pixels, letting go of what was drawn least recently; false when it cannot. */
+  private make;
+  private drop;
+}
+//#endregion
 //#region src/rendering/canvas2d/Canvas2DRenderer.d.ts
 interface Canvas2DRendererOptions {
   /**
@@ -16733,8 +17295,10 @@ interface Canvas2DRendererOptions {
    */
   scrollLayers?: boolean;
   /**
-   * Makes the canvases scroll layers and kept text are held in. Defaults
-   * to an `OffscreenCanvas`; a spec passes a double.
+   * Makes the canvases scroll layers, kept text and opacity groups are
+   * held in. Defaults to an `OffscreenCanvas`; a spec passes a double.
+   * Where none can be had, a group's opacity is multiplied into each of
+   * its draws instead (see `GroupOpacity.ts`).
    */
   createLayerCanvas?: LayerCanvasFactory;
   /**
@@ -16749,6 +17313,16 @@ interface Canvas2DRendererOptions {
    * the layers themselves passes 1.
    */
   scrollLayerSettleFrames?: number;
+  /**
+   * Whether a node marked \`rasterize\` keeps its subtree as pixels.
+   * Defaults to true; false draws it every frame. See \`RasterCache.ts\`.
+   */
+  rasterCache?: boolean;
+  /**
+   * How long a zoom's scale must hold before what was kept at another is
+   * drawn again, sharp. Defaults to \`SETTLE_MS\`; a spec passes 0.
+   */
+  rasterSettleMs?: number;
 }
 /**
  * Canvas2D rendering backend.
@@ -16775,6 +17349,12 @@ interface Canvas2DRendererOptions {
  * containers clip to their viewport and translate by
  * (-scrollX, -scrollY); node transforms compose on the current CTM.
  *
+ * Opacity groups: a node at `opacity < 1` whose subtree paints more
+ * than one draw is drawn into an offscreen layer and blended onto the
+ * frame once, as CSS composites it (`GroupOpacity.ts`). One that
+ * paints a single draw multiplies `globalAlpha` instead, which is the
+ * same picture for nothing.
+ *
  * State isolation: save()/restore() are used exactly when a node
  * introduces opacity, a transform, or a scroll viewport. Flat style
  * fields (fillStyle, font, lineWidth, ...) are assigned before each
@@ -16852,7 +17432,30 @@ declare class Canvas2DRenderer implements UiRenderer {
    * not keep what it drew if it moved.
    */
   private volatileDraws;
+  /**
+   * The canvases opacity groups are drawn in, one per depth of nesting,
+   * so a group inside a group never draws over what holds it. Each
+   * group sizes the one at its depth to its region (`layerRegion`).
+   */
+  private readonly groups;
+  /** How many groups the walk is inside. */
+  private groupDepth;
   constructor(options: Canvas2DRendererOptions);
+  /** Subtrees marked \`rasterize\` kept as pixels; see \`RasterCache.ts\`. */
+  private readonly rasters;
+  /** How deep inside a kept subtree's own walk the traversal is. One is not kept inside another. */
+  private rasterDepth;
+  /**
+   * The device pixels the walk draws within: the surface's, or a kept
+   * subtree's canvas while it is drawn into. An opacity group's region is
+   * cut to them.
+   */
+  private boundsWidth;
+  private boundsHeight;
+  /** What the raster cache did since the last reset, or null with it off. For budget specs. */
+  get rasterCacheStats(): RasterCache['stats'] | null;
+  /** When a frame is wanted though nothing changes: a zoom settling, whose kept pixels are then drawn sharp. */
+  nextRepaint(): number | undefined;
   /** Text kept as pixels; see `TextRasterCache.ts`. */
   private readonly textCache;
   /** What the text cache did since the last reset, or null with it off. For budget specs. */
@@ -16867,6 +17470,8 @@ declare class Canvas2DRenderer implements UiRenderer {
   resize(width: number, height: number, dpr: number): void;
   /** A restored scroll layer reads as healthy and holds nothing. */
   surfaceRestored(): void;
+  /** Kept subtrees were drawn with the fallback face. */
+  fontsChanged(): void;
   dispose(): void;
   render(root: UiNode, context: RenderContext): void;
   /**
@@ -16876,6 +17481,21 @@ declare class Canvas2DRenderer implements UiRenderer {
   private resolvePaint;
   private beginFrame;
   private renderNode;
+  /**
+   * Draws a node marked \`rasterize\` from its kept pixels, drawing it
+   * into them first when they are out of date. False when it is to be
+   * drawn directly: a transform of its own, which its extent does not
+   * include, or anything \`RasterCache\` declines.
+   */
+  private drawKept;
+  /**
+   * The canvas an opacity group at the current depth is drawn in, made
+   * the first time a group reaches that depth. Null where no canvas can
+   * be had, or where the frame's context cannot say what transform the
+   * layer should take on; the group then multiplies its opacity into
+   * each draw, as before.
+   */
+  private groupLayer;
   private renderChildren;
   /**
    * The top layer: the nodes that asked for `lift`, drawn after the
@@ -17020,6 +17640,13 @@ declare class Canvas2DRenderer implements UiRenderer {
   /** One walk of a layer's children, clipped to `strips` and culled to what reaches them. */
   private walkLayer;
   private applyTransform;
+  /**
+   * Whether where a node's subtree may paint meets the visible region,
+   * after its sticky shift and its own transform, which its extent does
+   * not include: a node a transform moves on screen from off it is
+   * drawn. One that turns is always drawn.
+   */
+  private extentVisible;
   private intersectsCull;
   /**
    * Intersects the visible region with a scroll viewport and shifts
@@ -17034,6 +17661,13 @@ declare class Canvas2DRenderer implements UiRenderer {
    */
   private paintScrollbars;
   private pushCull;
+  /**
+   * Takes the visible region back through a node's sticky shift and a
+   * transform that only moves and scales, into the coordinates its
+   * children are laid out in. False, with nothing pushed, for one that
+   * turns or flips.
+   */
+  private pushMappedCull;
   private popCull;
 }
 /**
@@ -17195,6 +17829,35 @@ declare class LayoutInspector {
   private clippedVisibleBox;
 }
 //#endregion
+//#region src/rendering/svg/SvgDraw.d.ts
+/** How a drawing fills a box whose shape is not its own: `objectFit`'s values. */
+type SvgFit = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+interface SvgDrawOptions {
+  /** How the drawing fills the box. `contain` by default, as an `<img>` of an SVG keeps its proportions. */
+  readonly fit?: SvgFit;
+  /**
+   * What \`currentColor\` is: a palette name or a colour. By default the
+   * node's own text colour, inherited, so an icon set authored in
+   * \`currentColor\` takes the colour of the text around it and follows a
+   * theme change.
+   */
+  readonly color?: UiColorValue;
+}
+/**
+ * Draws a read SVG file into a box, through the surface every painted
+ * node draws through, so it is vectors on either renderer and is drawn
+ * again at whatever size the box is laid out at.
+ */
+declare function drawSvg(document: SvgDocument, surface: PaintSurface, box: Pick<PaintBox, 'width' | 'height'>, options?: SvgDrawOptions): void;
+/**
+ * A read SVG file as a node's `paint`: drawn to fill the node, and the
+ * file's own size as the node's when the layout gives it none.
+ *
+ * The same object for the same file and options, so a node given it
+ * again is not drawn again; see `paintValuesEqual`.
+ */
+declare function svgPaint(document: SvgDocument, options?: SvgDrawOptions): UiPaint;
+//#endregion
 //#region src/rendering/PaintRecording.d.ts
 /**
  * One call a painter made, as data.
@@ -17861,6 +18524,12 @@ declare class WebGPURenderer implements UiRenderer {
   private frameLayout;
   private frameBindGroup;
   private cachedInstanceData;
+  /**
+   * The textures opacity groups are drawn in, one per depth of nesting,
+   * so a group inside a group never clears what holds it. Made the first
+   * time a frame reaches that depth and again when the surface resizes.
+   */
+  private groupLayers;
   /** Draw calls of the most recent frame. */
   readonly lastDraws: DrawStats;
   private pendingCapture;
@@ -17901,6 +18570,8 @@ declare class WebGPURenderer implements UiRenderer {
    * primitives under a scissor, one draw per text run or image.
    */
   render(root: UiNode, context: RenderContext): void;
+  /** The layer for an opacity group at `depth`, made or remade at the surface's size. */
+  private groupLayer;
   /**
    * When a capture is pending, encodes a copy of the frame into a
    * mappable buffer and returns the step that maps it after submit.
@@ -18042,6 +18713,12 @@ interface TexturedPipeline {
   textSampler: GPUSampler;
   /** Linear sampling: images are scaled by objectFit. */
   imageSampler: GPUSampler;
+  /**
+   * The same quads, blending a premultiplied opacity-group layer rather
+   * than a straight-alpha texture; bound with `textSampler`, since a
+   * layer is drawn one texel to a pixel.
+   */
+  layerPipeline: GPURenderPipeline;
 }
 //#endregion
 //#region src/rendering/webgpu/WebGPUTextureCache.d.ts
@@ -18419,7 +19096,14 @@ declare const enum CommandKind {
   /** A contiguous range of glyph instances sharing one atlas page. */
   Glyphs = 1,
   /** One textured instance drawn with an image. */
-  Image = 2
+  Image = 2,
+  /**
+   * Everything until the matching `EndLayer` is drawn into a cleared
+   * layer of its own, the start of an opacity group (`GroupOpacity.ts`).
+   */
+  BeginLayer = 3,
+  /** The layer is done, and is blended onto what holds it at the group's opacity. */
+  EndLayer = 4
 }
 type Affine = [number, number, number, number, number, number];
 interface ScissorRect {
@@ -18465,7 +19149,25 @@ interface ImageCommand {
   drawWidth: number;
   drawHeight: number;
 }
-type RenderCommand = PrimitiveCommand | GlyphCommand | ImageCommand;
+interface BeginLayerCommand {
+  kind: CommandKind.BeginLayer;
+  /** Always null: opening a layer draws nothing. */
+  scissor: null;
+}
+interface EndLayerCommand {
+  kind: CommandKind.EndLayer;
+  /**
+   * The textured instance that blends the layer: a quad over the
+   * group's region (`layerRegion`), one texel to a device pixel,
+   * carrying the group's opacity and the rounded clip its ancestors
+   * set. Null when the region is off the surface and there is nothing
+   * to blend.
+   */
+  instance: number | null;
+  /** The ancestors' clip, in physical pixels; null for none. */
+  scissor: ScissorRect | null;
+}
+type RenderCommand = PrimitiveCommand | GlyphCommand | ImageCommand | BeginLayerCommand | EndLayerCommand;
 /**
  * One line of text the frame drew, as a whole.
  *
@@ -19720,5 +20422,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp4AudioTrack as $, UiDroppedFile as $a, Row as $c, PaintLineJoin as $d, insetsEqual as $f, rgb8 as $g, TextMeasurer as $h, AxisExplanation as $i, normalizeStates as $l, paintsAfterChildren as $m, ScrollOffset as $n, scrollRange as $o, UiKeyModifiers as $p, clickOutside as $r, DEFAULT_TEXT_COLOR as $s, registerFontStack as $t, relativeLuminance as $u, offsetAtPointIn as A, resolveCursor as Aa, offsetForVerticalMove as Ac, UiFontVariant as Ad, fr as Af, UiMotion as Ag, borderRadiusValuesEqual as Ah, propertyValuesEqualByName as Ai, Reactive as Al, UiSharedElements as Am, LABEL_PADDING_X as An, overrideSources as Ao, FocusSource as Ap, ImageResolver as Ar, detectEditingPlatform as As, createTextCache as At, UiVideoSurface as Au, markNow as B, touchActionFor as Ba, Responsive as Bc, editableSpansOf as Bd, UiBoxShadow as Bf, UiTransforms as Bg, colorsEqualPalette as Bh, parseAlignContent as Bi, UiPropertyName as Bl, NodeId as Bm, resolvePropertyByName as Bn, HitTestResult as Bo, UiPropValue as Bp, ZoomState as Br, createCanvasTextStyle as Bs, isWebGPUAvailable as Bt, UiThemeExtensionOptions as Bu, hasTextLinks as C, isNodeFocusable as Ca, RunMeasure as Cc, defaultVisualState as Cd, AutoLength as Cf, UiSpring as Cg, validateSubgrid as Ch, findPropertyDefinition as Ci, GridProps as Cl, resolveMotionState as Cm, LayerCanvasFactory as Cn, UiGestureRecognizer as Co, UiModifier as Cp, IconContext as Cr, isMultiline as Cs, RenderList as Ct, VIRTUAL_INDEX_PROP as Cu, setLinkHover as D, isNodeTabStop as Da, lineLimit as Dc, UiFontKerning as Dd, UiLength as Df, createTween as Dg, borderRadiusCorners as Dh, propertyEffects as Di, PaintProps as Dl, slideFrom as Dm, LayoutReader as Dn, NodeTransitions as Do, UiModifierHost as Dp, iconKey as Dr, EditCommand as Ds, TEXTURED_STRIDE_FLOATS as Dt, VirtualUpdate as Du, linkRunAtPointIn as E, isNodeSelectable as Ea, lineIndexForOffset as Ec, visualStatesEqual as Ed, PercentLength as Ef, UiTweenOptions as Eg, borderRadius as Eh, inheritedPropertyNames as Ei, PaintElementProps as El, slideDown as Em, UiRenderer as En, FocusNotifier as Eo, isUiModifier as Ep, IconSpec as Er, syncEditorValue as Es, TEXTURED_STRIDE_BYTES as Et, VirtualItemMeasure as Eu, UiFrameCallback as F, UiPlatformAdapter as Fa, nextGraphemeEnd as Fc, UiTextMetrics as Fd, minmax as Ff, interpolateColor as Fg, UiShapes as Fh, placeGridItems as Fi, TextProps as Fl, Size as Fm, CanvasSurface as Fn, UiFindController as Fo, UiElement as Fp, ShortcutsOptions as Fr, SpanPaint as Fs, GlyphSlot as Ft, lightTheme as Fu, VttTrack as G, TouchScrollerOptions as Ga, LazyListProps as Gc, spannedTextOf as Gd, boxShadowsEqual as Gf, UiBasicColors as Gg, FixedMetricsOptions as Gh, ELLIPSIS as Gi, UiAutocomplete as Gl, UiPropertyOverrides as Gm, InsetPaddingArgs as Gn, SCROLLBAR_INSET as Go, UiListenerErrorReporter as Gp, ReorderableOptions as Gr, runFontString as Gs, WebGPURenderer as Gt, themeExtension as Gu, performanceMarksEnabled as H, EditingHost as Ha, LazyColumn as Hc, hiddenRangesOf as Hd, boxShadowArraysEqual as Hf, transform as Hg, lightColors as Hh, parseMainAxisAlignment as Hi, UiPropertyValues as Hl, UiNode as Hm, ThemeTokenTarget as Hn, UiHitTester as Ho, UiEventListener as Hp, AutoScrollOptions as Hr, fillTextRects as Hs, CapturedFrame as Ht, defineThemeExtension as Hu, UiScheduler as I, capturePointer as Ia, nextWordEnd as Ic, UiTextRange as Id, percent as If, interpolateNumber as Ig, defaultShapes as Ih, sizeGridTracks as Ii, TypographyProps as Il, TightenOptions as Im, createCanvasSurface as In, SelectionControllerOptions as Io, isComponentLikeElement as Ip, contextMenu as Ir, TextLinePlacement as Is, GlyphUpload as It, themesEqual as Iu, ByteSource as J, UiDragPayload as Ja, Button as Jc, textSpansEqual as Jd, propertyValuesEqual as Jf, colorToRgba as Jg, ParagraphTextMeasurer as Jh, LayoutNotifier as Ji, UiRole as Jl, DecorationShape as Jm, publishInset as Jn, ScrollBounds as Jo, UiCompositionEvent as Jp, reorderable as Jr, Canvas2DContext as Js, WebGPUSurface as Jt, HighContrastOptions as Ju, cueAt as K, UiTouchScroller as Ka, LazyRow as Kc, spansDifferOnlyInPaint as Kd, UiPropertyDefinition as Kf, UiColor as Kg, FontMetrics as Kh, layoutParagraph as Ki, UiLiveRegion as Kl, DecorationFill as Km, PublishInsetArgs as Kn, SCROLLBAR_MIN_THUMB as Ko, MOUSE_POINTER as Kp, dragSource as Kr, textRunBackgrounds as Ks, WebGPURendererOptions as Kt, themeExtensionsEqual as Ku, UiSchedulerOptions as L, isImeKey as La, previousGraphemeStart as Lc, UiTextSpan as Ld, repeat as Lf, interpolateTransform as Lg, isShapeName as Lh, AlignContent as Li, UiEventProps as Ll, clampSize as Lm, resolveBoolean as Ln, SelectionHost as Lo, isObservable$1 as Lp, shortcut as Lr, TextRunRect as Ls, WebGPUGlyphAtlas as Lt, withContrast as Lu, paragraphGeometryFrom as M, PlatformAdapterOptions as Ma, graphemeBoundaries as Mc, UiSpannedText as Md, isFrLength as Mf, UiSpringToken as Mg, uniformBorderRadius as Mh, GridItemRequest as Mi, ScrollViewProps as Ml, LayoutBox as Mm, drawOverlayShapes as Mn, writeDeclaredProperty as Mo, ComponentResolver as Mp, animateLayout as Mr, EditableLayout as Ms, textRuns as Mt, videoFrameSize as Mu, selectionRectsIn as N, PlatformEventTarget as Na, lineEndAt as Nc, UiTextDecoration as Nd, isMinMaxTrack as Nf, defaultMotion as Ng, UiShapeExtensions as Nh, GridPlacement as Ni, StackProps as Nl, LayoutResult as Nm, labelOrigin as Nn, writeOverrideProperty as No, ComponentLikeElement as Np, ContextMenuOptions as Nr, CanvasTextStyle as Ns, GlyphShaper as Nt, UiTheme as Nu, ParagraphGeometry as O, isSubtreeInert as Oa, offsetAtPoint as Oc, UiFontStretch as Od, UiTrackSize as Of, UiDurationToken as Og, borderRadiusEqual as Oh, propertyIsInherited as Oi, PositionProps as Ol, slideUp as Om, RenderChanges as On, resetTransitionWarnings as Oo, UiModifierTeardown as Op, DefaultImageResolver as Or, EditingPlatform as Os, TextRunDraw as Ot, VirtualViewport as Ou, wordRangeIn as P, PlatformSurface as Pa, lineStartAt as Pc, UiTextLink as Pd, isPercentLength as Pf, UiInterpolator as Pg, UiShapeName as Ph, GridTrack as Pi, TextContentProps as Pl, LayoutStats as Pm, CanvasHost as Pn, FindHost as Po, UiChild as Pp, ShortcutOptions as Pr, PlacedTextRun as Ps, GLYPH_SUBPIXEL_PHASES as Pt, darkTheme as Pu, rangeSource as Q, UiDropZone as Qa, Paint as Qc, PaintLineCap as Qd, UiInsets as Qf, parseColor as Qg, TextMeasureRequest as Qh, ScrollAdjustment as Qi, isUiSemanticState as Ql, hasDecorationPhase as Qm, sizeContainer as Qn, scrollLeaderOf as Qo, UiInputEvent as Qp, ClickOutsideOptions as Qr, DEFAULT_FONT_WEIGHT as Qs, fontStackFor as Qt, raiseContrast as Qu, MARK_PREFIX as R, pointerDeviceOf as Ra, previousWordStart as Rc, UiTextStyle as Rd, resolveLength as Rf, interpolatorFor as Rg, shapesEqual as Rh, CrossAxisAlignment as Ri, UiNodeRef as Rl, constraintsEqual as Rm, resolveNumber as Rn, UiSelectionController as Ro, isUiChild as Rp, shortcuts as Rr, applyCanvasTextStyle as Rs, WebGPUTextureCache as Rt, withDensity as Ru, clearLinkHover as S, UiTimerFrameClockOptions as Sa, PlacedLine as Sc, UiVisualStateSet as Sd, validateGradient as Sf, UiReducedMotionPolicy as Sg, UiVerticalAlign as Sh, closestPropertyName as Si, GridItemProps as Sl, pop as Sm, traceRoundedRect as Sn, GestureRecognizerOptions as So, assertModifierList as Sp, IconCanvas as Sr, isEditableNode as Ss, RenderCommand as St, UiVirtualWindow as Su, linkOf as T, isNodeInert as Ta, lineIndexAtY as Tc, visualState as Td, MinMaxTrack as Tf, UiTween as Tg, UiBorderRadiuses as Th, inheritedPropertyFlags as Ti, InteractionProps as Tl, scaleFrom as Tm, RendererBackend as Tn, UiPinchRecognizer as To, defineModifier as Tp, IconRasterizerOptions as Tr, nextCaretToggle as Ts, ScissorRect as Tt, VIRTUAL_WINDOW_PROP as Tu, setPerformanceMarks as U, EditingState as Ua, LazyGrid as Uc, resolvedSpansOf as Ud, boxShadowRadius as Uf, transformIsIdentity as Ug, LayoutRecord as Uh, FlexDirection as Ui, UI_ROLES as Ul, UiNodeTransitions as Um, themeTokens as Un, UiPoint as Uo, UiEventListenerOptions as Up, DragSourceOptions as Ur, layoutTextLines as Us, DrawStats as Ut, hasThemeExtension as Uu, measureSpan as V, EditingControllerOptions as Va, ResponsiveProps as Vc, flattenTextSpans as Vd, boxShadow as Vf, parseTransform as Vg, darkColors as Vh, parseCrossAxisAlignment as Vi, UiPropertyValueOf as Vl, NodeProperty as Vm, resolveString as Vn, HitTester as Vo, UiProps as Vp, pinchable as Vr, drawText as Vs, WebGPUError as Vt, UiThemeExtensions as Vu, VttCue as W, UiEditingController as Wa, LazyGridProps as Wc, spanAtOffset as Wd, boxShadowReach as Wf, transformsEqual as Wg, CharacterCountTextMeasurer as Wh, parseFlexDirection as Wi, UI_SEMANTIC_STATES as Wl, UiPropertyOverride as Wm, sameArgs as Wn, SCROLLBAR_HOVER_ZONE as Wo, UiInputDispatcher as Wp, DropTargetOptions as Wr, runCanvasStyleInto as Ws, RenderHooks as Wt, noThemeExtensions as Wu, RangeSourceOptions as X, UiDragState as Xa, EditableText as Xc, PaintBox as Xd, UiInsetRegistry as Xf, colorsEqual as Xg, TextLine as Xh, SCROLLBAR_FADE_MS as Xi, UiSemanticStates as Xl, decorationColor as Xm, SizeContainerArgs as Xn, ScrollbarThumb as Xo, UiFocusEvent as Xp, DraggableOptions as Xr, DEFAULT_FONT_FAMILY as Xs, bumpFontStack as Xt, contrastRatio as Xu, DEFAULT_BLOCK_SIZE as Y, UiDragSession as Ya, Column as Yc, textStylesEqual as Yd, UiInsetEdge as Yf, colorValuesEqual as Yg, SpannedRuns as Yh, LayoutEngine as Yi, UiSemanticState as Yl, DecorationStroke as Ym, BreakpointArgs as Yn, ScrollbarAxis as Yo, UiEventType as Yp, DragOffset as Yr, Canvas2DGradient as Ys, createWebGPUSurface as Yt, UiContrast as Yu, bufferSource as Z, UiDropEffect as Za, Grid as Zc, PaintFillRule as Zd, UiInsetSource as Zf, normalizeColor as Zg, TextLineRun as Zh, SCROLLBAR_LINGER_MS as Zi, isUiRole as Zl, decorationRect as Zm, breakpoint as Zn, scrollBounds as Zo, UiGestureEvent as Zp, draggable as Zr, DEFAULT_FONT_SIZE as Zs, clearFontStacks as Zt, highContrastColors as Zu, buildSemanticsTree as _, UiFrameTime as _a, selectableTextNodes as _c, UiLayoutChild as _d, UiRadialGradient as _f, spring as _g, UiTextAlign as _h, bundle as _i, ContainerProps as _l, MotionStateInput as _m, LayoutInspector as _n, UiScrollBehavior as _o, UiModifierEnvironment as _p, IconSourceArgs as _r, CARET_WIDTH as _s, INSTANCE_STRIDE_FLOATS as _t, LazyAxis as _u, diffSemantics as a, steps as a_, RelayoutExplanation as aa, VerticalAlign as ac, spacingEqual as ad, inputsEqual as af, spannedRunsFor as ag, UiCursor as ah, borderShapes as ai, BindingId as al, UiPointerKind as am, PaintContext2D as an, UiShortcutRegistry as ao, containerBands as ap, VideoTransport as ar, TEXT_MATCHES_PROP as as, Mp3Frame as at, EditableTextModel as au, semanticsMemory as b, UiManualFrameClock as ba, setSelectionRange as bc, isLayoutProtocol as bd, linearGradient as bf, UiAnimation as bg, UiTextWrapValue as bh, accumulatedOffsetTo as bi, FlexContainerProps as bl, fade as bm, Canvas2DRenderer as bn, isScrollContainer as bo, UiModifierSet as bp, iconSource as br, editorFor as bs, PrimitiveCommand as bt, LazyListOptions as bu, SemanticsMemory as c, describeOverrides as ca, createPaintState as cc, defaultShadows as cd, UiImage as cf, createEnvironmentKey as cg, UiFontWeight as ch, focusRing as ci, UiEventBinding as cl, UiWheelDeltaMode as cm, PaintTarget as cn, formatShortcut as co, UiTextInputState as cp, DefaultVideoResolverOptions as cr, setMatchRanges as cs, readMp3Header as ct, SheetHeaderRenderer as cu, SemanticsRewalk as d, labelNode as da, normalizeVerticalAlign as dc, UiTypographyExtensions as dd, ResolvedGradient as df, DirtyFlags as dg, UiOverflow as dh, hoverable as di, UiGraphBuilder as dl, wheelDeltaYOf as dm, PaintOp as dn, KeyboardControllerOptions as do, UiGroupEdit as dp, VideoResolver as dr, findMatchesIn as ds, Affine as dt, SheetSourceArgs as du, rgba as e_, CustomLayoutExplanation as ea, ObjectFit as ec, UiDensity as ed, PaintSurface as ef, TextOverflow as eg, UI_SUBGRID_AXES as eh, autoFocus as ei, ScrollView as el, UiKeyboardEvent as em, PaintCanvas as en, UiFileDropMessage as eo, noInsets as ep, ScrollPositionArgs as er, scrollbarThumb as es, Mp4Sample as et, statesEqual as eu, SemanticsSpan as f, withOverrideSource as fa, resolvePaintState as fc, UiTypographyRole as fd, ResolvedGradientStop as ff, AnimationDriver as fg, UiPlacement as fh, interactive as fi, BoxModelProps as fl, DirtyNodeSet as fm, PaintRecorder as fn, UiKeyboardController as fo, UiTextPosition as fp, canDecodeVideo as fr, UiEnvironmentProvider as fs, CLIP_STRIDE_BYTES as ft, SheetViewport as fu, buildSemanticsSubtree as g, UiFrameClockFactory as ga, clearSelectionRange as gc, MAX_MEASURES_PER_CHILD as gd, UiLinearGradient as gf, normalizeTransition as gg, UiSubgridAxis as gh, UiModifierBundle as gi, CommonProps as gl, MotionState as gm, InspectorOverlay as gn, ScrollSink as go, editingGroupOf as gp, sharedElement as gr, CARET_BLINK_MS as gs, INSTANCE_STRIDE_BYTES as gt, sheetSource as gu, UiSemanticsRecord as h, UiFrameClock as ha, TextRange as hc, typographyEqual as hd, UiGradientStop as hf, assertTransitionMap as hg, UiSelfAlignment as hh, pressable as hi, ColumnProps as hl, MotionChannel as hm, INSPECTOR_HEAT_MS as hn, ScrollContainerState as ho, edgeField as hp, motion as hr, EnvironmentNotifier as hs, GlyphCommand as ht, VIRTUAL_SHEET_PROP as hu, UiSemanticsPatch as i, linear as i_, OverrideSources as ia, TextAlign as ic, scaleSpacing as id, UiPath as if, TextWrap as ig, UiContentDistribution as ih, FocusRingOptions as ii, UiDefinition as il, UiPointerEvent as im, paintPictures as in, UiShortcutBinding as io, bandOf as ip, VideoState as ir, SubtreeBounds as is, Mp3Format as it, EditUnit as iu, paragraphGeometry as j, CanvasPlatformSurface as ja, selectionRects as jc, UiResolvedTextSpan as jd, isAutoLength as jf, UiSpringSpec as jg, normalizeBorderRadius as jh, GridContribution as ji, RowProps as jl, Constraints as jm, OverlayShape as jn, resetOverrideWarnings as jo, UiFocusManager as jp, AnimateLayoutOptions as jr, isPrintable as js, glyphCount as jt, isVideoSurface as ju, hasDrawnText as k, pointerEventsOf as ka, offsetAtX as kc, UiFontStyle as kd, auto as kf, UiEasingToken as kg, borderRadiusIsZero as kh, propertyNarrowers as ki, PropsOf as kl, SharedClaim as km, RenderContext as kn, clearOverrideProperty as ko, FocusOptions as kp, DefaultImageResolverOptions as kr, commandForKey as ks, buildRenderList as kt, lazySource as ku, SemanticsPlacement as l, formatConstraints as la, isPaintVisible as lc, shadowsEqual as ld, GradientPaint as lf, findEnvironmentKey as lg, UiGridAutoFlow as lh, BUTTON_INTERACTION as li, ChildrenBindingId as ll, UiWheelEvent as lm, tracePathData as ln, parseShortcut as lo, textInputOf as lp, RangeResponse as lr, FindMatch as ls, splitMp3Frames as lt, SheetRange as lu, UiSemanticsMap as m, UiAnimationFrameClock as ma, TEXT_SELECTION_PROP as mc, isTypographyRole as md, UiGradientOffset as mf, UiTransitionValue as mg, UiPosition as mh, measureFlow as mi, ButtonProps as ml, MOTION_REST as mm, replayPaint as mn, UiPointerController as mo, comparePositions as mp, SharedElementArgs as mr, UiEnvironmentKeys as ms, CommandKind as mt, UiVirtualSheetOptions as mu, UiSemanticsBox as n, cubicBezier as n_, LayoutExplanation as na, PaintState as nc, UiSpacing as nd, PaintTextStyle as nf, TextRunSpan as ng, UiBorderRadiusValue as nh, BordersOptions as ni, Text as nl, UiPinchEvent as nm, PaintPictureCache as nn, ShortcutRegistryOptions as no, UiContainerSize as np, VideoClock as nr, scrollbarZoneAt as ns, demuxMp4Audio as nt, validateStates as nu, dropIndexShifts as o, SizeDecision as oa, colorToCss as oc, spacingSteps as od, paintValuesEqual as of, UiEnvironment as og, UiDirection as oh, borders as oi, UiBinding as ol, UiSelectionChangeEvent as om, PaintGradient as on, UiShortcutStep as oo, unknownContainerSize as op, videoSource as or, clearMatchRanges as os, Mp3Frames as ot, LazySheet as ou, TEXT_RUN_ID_SEPARATOR as p, UiFrame as pa, DEFAULT_LINE_HEIGHT_FACTOR as pc, defaultTypography as pd, UiGradient as pf, UiTransitionSpec as pg, UiPointerEvents as ph, measure as pi, BoxProps as pl, MOTION_CHANNELS as pm, PaintRecording as pn, PointerControllerOptions as po, adjacentField as pp, MotionArgs as pr, provideEnvironment as ps, CLIP_STRIDE_FLOATS as pt, UiVirtualSheet as pu, parseWebVtt as q, EXTERNAL_FILES as qa, Box as qc, textContentOf as qd, defineProperty as qf, colorToHex as qg, ParagraphLayout as qh, proportionalFontMetrics as qi, UiOrientation as ql, DecorationRect as qm, insetPadding as qn, SCROLLBAR_THICKNESS as qo, UiBeforeInputEvent as qp, dropTarget as qr, textRunDecorations as qs, WebGPUCanvasHost as qt, withThemeExtension as qu, UiSemanticsUpdate as r, easings as r_, LayoutStateExplanation as ra, PaintTextSpan as rc, defaultSpacing as rd, UiPaint as rf, TextRunStyle as rg, UiColorValue as rh, Decorations as ri, createElement as rl, UiPointerDevice as rm, PaintStats as rn, UiShortcut as ro, UiContainerSizeSource as rp, VideoSourceArgs as rr, scrollsFromRight as rs, demuxMp4Video as rt, CompositionRange as ru, recordsEqual as s, describeLength as sa, computeObjectFitRect as sc, UiShadows as sd, pathValuesEqual as sf, UiEnvironmentKey as sg, UiFlexWrap as sh, decorated as si, UiGraph as sl, UiTextChangeEvent as sm, PaintResolver as sn, describeShortcut as so, UiTextInput as sp, DefaultVideoResolver as sr, matchRangesOf as ss, Mp3Header as st, LazySheetProps as su, UiSemanticsAction as t, UiEasing as t_, Edges as ta, PaintBoxShadow as tc, densityFactors as td, PaintTextAlign as tf, TextRunMeasurer as tg, UiAlignment as th, BorderEdge as ti, Stack as tl, UiPasteEvent as tm, PaintCanvasFactory as tn, dragSessionFor as to, observeViewportInsets as tp, scrollPosition as tr, scrollbarThumbs as ts, Mp4VideoTrack as tt, validateRole as tu, SemanticsReuse as u, formatExplanation as ua, normalizeTextAlign as uc, UiTypography as ud, MAX_GRADIENT_STOPS as uf, UiNodeType as ug, UiObjectFit as uh, InteractiveOptions as ui, UiChildrenBinding as ul, noKeyModifiers as um, EMPTY_RECORDING as un, shortcutKeyCaps as uo, UiEditingGroup as up, VideoPlayback as ur, FindOptions as us, WebGPUGlyphPages as ut, SheetRowRenderer as uu, rewalkSemantics as v, UiHostFrameClock as va, selectableTextOf as vc, UiLayoutContext as vd, gradientPaint as vf, tween as vg, UiTextDirection as vh, noModifiers as vi, EditableTextProps as vl, MotionTiming as vm, LayoutInspectorOptions as vn, UiScrollability as vo, UiModifierFocus as vp, ImageSourceArgs as vr, EDITOR_PROP as vs, ImageCommand as vt, LazyGridOptions as vu, linkHoverOf as w, isNodeHitTestable as wa, caretRectFor as wc, hasVisualState as wd, FrLength as wf, UiSpringOptions as wg, UiBorderRadius as wh, getPropertyNames as wi, IdentityProps as wl, rotateFrom as wm, ScrollLayerStats as wn, PinchRecognizerOptions as wo, UiModifierKind as wp, IconRasterizer as wr, isReadOnly as ws, RenderTextCache as wt, VIRTUAL_LEAD_PROP as wu, textRunOfRecordId as x, UiTimerFrameClock as xa, CaretRect as xc, UiVisualState as xd, radialGradient as xf, UiAnimationOptions as xg, UiThemeColorName as xh, contentOffset as xi, FlexItemProps as xl, isMotionRest as xm, Canvas2DRendererOptions as xn, GestureInput as xo, UiUnknownModifierPropertyError as xp, imageSource as xr, editorOf as xs, PrimitiveKind as xt, LazySourceArgs as xu, semanticsInertAbove as y, UiHostFrameClockOptions as ya, selectionRangeOf as yc, UiLayoutProtocol as yd, gradientsEqual as yf, AnimatedCell as yg, UiTextOverflowValue as yh, Transform as yi, EnvironmentProps as yl, ResolvedMotionState as ym, CanvasTextMeasurer as yn, UiWheelController as yo, UiModifierLayout as yp, ImageSources as yr, caretVisibleAt as ys, NO_CLIP_INDEX as yt, LazyItemRenderer as yu, markInstant as z, prepareInputSurface as za, wordRangeAt as zc, defaultTextStyle as zd, BOX_SHADOW_BLUR_REACH as zf, UiTransform as zg, UiColors as zh, MainAxisAlignment as zi, UiProperties as zl, tightenConstraints as zm, resolveProperty as zn, HitTestLayoutReader as zo, isUiElement as zp, PinchableOptions as zr, buildFontString as zs, initializeWebGPU as zt, UiThemeExtension as zu };
-//# sourceMappingURL=index-CLCtv12G.d.ts.map
+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