gesso-framework 0.6.30 → 0.8.0

package/dist/{index-DZbSb8IN.d.ts → index-DocVauCS.d.ts}

@@ -1,56 +1,7 @@
-import { f as ChannelToken, m as CommandMap, o as Patch, p as Command, r as ChannelPort } from "./ChannelProtocol-ByNoHujM.js";
-import { E as WorkerHandle, s as AgentConfirmation, t as UiHost, y as ChannelSource } from "./ui-CHtNccR8.js";
-import { C as InternalState, T as Component, a as ComponentType, c as Inputs, g as OutputCell, h as InputCell, i as ComponentProps, n as ComponentArgs, r as ComponentContext, u as ChannelReplica, v as ReadableCell } from "./FunctionComponent-CHtojpp7.js";
+import { L as ChannelToken, R as Command, a as ComponentType, c as Inputs, i as ComponentProps, j as Patch, n as ComponentArgs, p as InternalState, r as ComponentContext, u as Component, v as InputCell, x as ReadableCell, y as OutputCell } from "./FunctionComponent-BDVrANP0.js";
+import { C as ServiceRegistry, E as DesignThemes, O as AgentConfirmation, U as ChannelSource, X as WorkerHandle, b as ComponentElement, s as UiHost, t as AgentToolDefinition, w as ChannelRegistry, x as FrameworkChild } from "./tools-Bl8LZ7LR.js";
 import { BehaviorSubject, Observable, Subscription } from "rxjs";
-import { AnimatedCell, AnimationDriver, CanvasHost, CaretRect, ComponentLikeElement, ComponentResolver, EditingState, EditingState as EditingState$1, FocusOptions, IconRasterizer, ImageResolver, LayoutExplanation, LayoutInspector, MARK_PREFIX, MotionStateInput, MotionTiming, Reactive, RendererBackend, Size, TextMeasureRequest, TextMeasurer, UI_ROLES, UI_SEMANTIC_STATES, UiAnimation, UiChild, UiContrast, UiDurationToken, UiEasing, UiEasingToken, UiEditingController, UiElement, UiFileDropMessage, UiFindController, UiFocusManager, UiFrameClockFactory, UiInputDispatcher, UiInsets, UiKeyModifiers, UiKeyboardController, UiLength, UiModifier, UiMotion, UiNode, UiPlatformAdapter, UiPointerController, UiPointerDevice, UiReducedMotionPolicy, UiRole, UiScrollability, UiSelectionController, UiSemanticState, UiSemanticsAction, UiSemanticsMap, UiSemanticsMap as UiSemanticsMap$1, UiSemanticsPatch, UiSemanticsRecord, UiSemanticsRecord as UiSemanticsRecord$1, UiSemanticsUpdate, UiShortcutRegistry, UiSpringSpec, UiSpringToken, UiTextPosition, UiThemeExtension, UiTouchScroller, UiWheelController, VideoClock, VideoResolver, markInstant, markNow, measureSpan, performanceMarksEnabled, setPerformanceMarks as setPerformanceMarks$1 } from "gesso-core";
-//#region src/service/ServiceRegistry.d.ts
-/**
- * The runtime services a component may inject.
- *
- * A service is a plain class the runtime constructs once and hands to
- * whoever asks: the clipboard and window (`ShellService`), overlays,
- * focus, find, media, animation. They are not application state and
- * they never cross a thread — they hold a `UiNode`, an `ImageResolver`,
- * decoded bitmaps, a focus manager — so there is no replica, no patch
- * and no wire format anywhere near them.
- *
- * That is the whole difference from what used to be here. Application
- * state crosses the barrier and is declared as a channel; a service
- * stays on the render thread and is simply called. Both used to be
- * `Store`, and the single name hid which of the two rules applied.
- */
-declare class ServiceRegistry {
-  private readonly services;
-  /** Constructs and registers a service, once. */
-  register<T extends object>(ServiceClass: new () => T): T;
-  /**
-   * Points an existing service at a replacement class of the same
-   * name, keeping the instance (the HMR).
-   *
-   * A registry is keyed by the class object, which is the right key
-   * for every purpose but one: replacing a module produces a new class
-   * object, so a component from the replaced module injects a class
-   * the registry has never seen even though a service of that name is
-   * sitting in it. Re-keying is what lets the tree be rebuilt from new
-   * code while the service it depends on carries on holding what it
-   * was holding.
-   *
-   * **The instance keeps the behaviour it was constructed with.** It
-   * was built from the old class and its methods are the old code, so
-   * a change to a service's own body needs a full reload to take
-   * effect. State survives; behaviour does not. That is the trade
-   * every hot-replacement system makes, and pretending otherwise would
-   * be worse than saying it.
-   *
-   * Returns false when nothing of that name was registered, which
-   * means the caller is looking at a genuinely new service rather than
-   * a replacement.
-   */
-  adopt(ServiceClass: new () => object): boolean;
-  get<T extends object>(ServiceClass: new () => T): T;
-  has(ServiceClass: Function): boolean;
-}
-//#endregion
+import { AnimatedCell, AnimationDriver, CanvasHost, CaretRect, ComponentLikeElement, ComponentResolver, EditingState, EditingState as EditingState$1, FocusOptions, IconRasterizer, ImageResolver, LayoutExplanation, LayoutInspector, MARK_PREFIX, MotionStateInput, MotionTiming, Reactive, RendererBackend, Size, SvgResolver, TextMeasureRequest, TextMeasurer, UI_ROLES, UI_SEMANTIC_STATES, UiAnimation, UiChild, UiClock, UiContrast, UiDurationToken, UiEasing, UiEasingToken, UiEditingController, UiElement, UiEnvironmentKey, UiFileDropMessage, UiFindController, UiFocusManager, UiFrameClockFactory, UiInputDispatcher, UiInsets, UiKeyModifiers, UiKeyboardController, UiLength, UiModifier, UiMotion, UiNode, UiPlatformAdapter, UiPointer, UiPointerController, UiPointerDevice, UiReducedMotionPolicy, UiRole, UiScrollability, UiSelectionController, UiSemanticState, UiSemanticsAction, UiSemanticsMap, UiSemanticsMap as UiSemanticsMap$1, UiSemanticsPatch, UiSemanticsRecord, UiSemanticsRecord as UiSemanticsRecord$1, UiSemanticsUpdate, UiShortcutRegistry, UiSourceLocation, UiSpringSpec, UiSpringToken, UiTextPosition, UiTheme, UiThemeExtension, UiTouchScroller, UiWheelController, VideoClock, VideoResolver, markInstant, markNow, measureSpan, performanceMarksEnabled, setPerformanceMarks as setPerformanceMarks$1 } from "gesso-core";
 //#region src/derive.d.ts
 /** How `derive` decides that a new value is not a change. */
 type Equality<T> = 'reference' | 'structural' | ((a: T, b: T) => boolean);
@@ -932,6 +883,12 @@ interface ControlledOptions<T> {
   readonly fallback: T;
   /** Fired on every change in either form. */
   readonly onChange: OutputCell<[next: T]>;
+  /**
+   * Other outputs a parent may hear the change through instead: a
+   * drawer's `onClose` beside its `onOpenChange`. A parent listening on
+   * any of them owns the value, as one passing `onChange` does.
+   */
+  readonly heardBy?: readonly OutputCell<never>[];
 }
 /**
  * Controlled by default, self-managing when given only an initial value.
@@ -942,9 +899,58 @@ interface ControlledOptions<T> {
  * `defaultValue` and the control owns it, still reporting changes;
  * pass both and it throws, because two owners is a bug. `bind(cell)` is
  * the spread for the first form when the owner is a local cell.
+ *
+ * A `value` with no `onChange` beside it has nobody to own it, so it is
+ * where the control starts, and the control owns it from there; a new
+ * value from the parent starts it again. A screen written as a picture
+ * of a moment, `<Switch checked={true} />`, is then one a person can
+ * use: the design tool's Play mode runs mocks written exactly so, and a
+ * value that only the parent may change is what `readOnly` and
+ * `disabled` say, not a missing handler.
  */
 declare function controlled<T>(options: ControlledOptions<T>): ControlledValue<T>;
 //#endregion
+//#region src/sharedValue.d.ts
+/**
+ * Named values the components under one node share, with no
+ * application behind them: what one screen of a prototype was given
+ * (an email typed on Forgot password), shown by the next (Check email),
+ * or a wizard's steps passing on what was filled in.
+ *
+ * A node provides a store to what it holds,
+ * `provide={[provided(SharedValuesKey, values)]}`, and a component asks
+ * for a value by name with `sharedValue(ctx, name, start)`. Under a
+ * store, every component asking for the same name has the same cell;
+ * with none above, each has its own, at its own start. So a design tool
+ * can draw a screen on its board as written, each frame alone, and play
+ * it with the screens before it.
+ *
+ * It is not where an application's state goes. That survives a reload
+ * and is on a channel, written by a command; these are cells, written
+ * by whatever holds one, and gone with the store.
+ */
+declare class SharedValues {
+  private readonly cells;
+  /** Every value by name, as it is now, in the order each was first asked for. */
+  readonly values: InternalState<ReadonlyMap<string, unknown>>;
+  /** The value named `name`: made at `start` by the first to ask, and the same cell for each after. */
+  cell<T>(name: string, start: T): InternalState<T>;
+  /** Writes a value by name, as a component holding it would; a name nobody has asked for is ignored. */
+  set(name: string, value: unknown): void;
+  /** Every value back at the start it was made with. */
+  reset(): void;
+  private publish;
+}
+/** Where a node provides a `SharedValues` to what it holds. */
+declare const SharedValuesKey: import("gesso-core").UiEnvironmentKey<SharedValues | null>;
+/**
+ * A value by name: the cell the nearest `SharedValues` above holds for
+ * it, shared with every component asking for it there; with none
+ * above, a cell of this component's own, at `start`. Bind it as any
+ * cell: `<TextInput {...bind(email)} />`.
+ */
+declare function sharedValue<T>(ctx: ComponentContext, name: string, start: T): InternalState<T>;
+//#endregion
 //#region src/decorators.d.ts
 /**
  * Declares a class as a Gesso component.
@@ -989,25 +995,6 @@ declare function Channel(token: {
   name: string;
 }): PropertyDecorator;
 //#endregion
-//#region src/channel/ChannelRegistry.d.ts
-/**
- * The channels a runtime can hand to its components, by name.
- *
- * A replica is the only thing kept: whether the data lives in another
- * worker or on this very thread is settled by the port it was attached
- * with, and nothing above here can tell.
- */
-declare class ChannelRegistry {
-  private readonly replicas;
-  /** Attaches a channel over `port`. */
-  attach<View extends object, Commands extends object>(token: ChannelToken<View, Commands>, port: ChannelPort): ChannelReplica<View, Commands>;
-  get<View extends object, Commands extends object>(token: ChannelToken<View, Commands>): ChannelReplica<View, Commands>;
-  has(token: ChannelToken<object, CommandMap>): boolean;
-  /** Every attached replica, for frame-aligned patch flushing. */
-  all(): ChannelReplica<object, CommandMap>[];
-  dispose(): void;
-}
-//#endregion
 //#region src/channel/plainData.d.ts
 /**
  * Checks that a value can cross the barrier.
@@ -1124,28 +1111,6 @@ declare function pickKeys<T extends object, K extends keyof T>(source: Observabl
 //#region src/channel/structuralEquals.d.ts
 declare function structurallyEqual<T>(a: T, b: T): boolean;
 //#endregion
-//#region src/ComponentElement.d.ts
-/**
- * Declarative representation of a component instance in the tree.
- *
- * ComponentElements are resolved by ComponentRenderer into plain
- * UiElement trees before being passed to UiGraphBuilder.
- */
-interface ComponentElement<P = Record<string, unknown>> {
-  readonly kind: 'component';
-  readonly tag: string;
-  /** The class or function to mount. */
-  readonly component: ComponentType;
-  readonly props: P;
-  readonly key?: string | number;
-}
-declare function isComponentElement(value: unknown): value is ComponentElement;
-/**
- * Anything the framework accepts as a child: a runtime element, an
- * observable stream of elements, or a component definition.
- */
-type FrameworkChild = UiChild | ComponentElement;
-//#endregion
 //#region src/createComponent.d.ts
 /**
  * Creates a ComponentElement for use as a child of a UiElement.
@@ -1183,10 +1148,14 @@ declare function createComponent<C extends ComponentType>(component: C, ...args:
  * edge of the screen whatever the language: an arrow drawn on a
  * diagram, a tooltip on a panel that is always on the left.
  *
+ * `over` lays the entry over the anchor at its size, grown by the
+ * offset on every side: the hole a spotlight leaves around what it
+ * shows. No direction turns it.
+ *
  * The direction is the entry's: the one its content reads in, which is
  * where its theme comes from too. See `OverlayEntry.environment`.
  */
-type OverlayPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end' | 'start' | 'start-start' | 'start-end' | 'end' | 'end-start' | 'end-end';
+type OverlayPlacement = 'over' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end' | 'start' | 'start-start' | 'start-end' | 'end' | 'end-start' | 'end-end';
 /** A rectangle inside an anchor, from its border box's top left. */
 interface OverlayRect {
   readonly x: number;
@@ -1320,6 +1289,104 @@ declare class OverlayService {
   closeAll(): void;
   isOpen(id: string): boolean;
 }
+/**
+ * The overlays of the `OverlayScope` a node is in: where an entry
+ * opened there goes instead of the runtime's layer. Null outside every
+ * scope.
+ */
+declare const OverlayScopeKey: import("gesso-core").UiEnvironmentKey<OverlayService | null>;
+//#endregion
+//#region src/overlay/OverlayScope.d.ts
+interface OverlayScopeProps {
+  children?: UiChild;
+}
+/**
+ * A part of the tree that holds its own overlays: a dialog, menu or
+ * tooltip opened inside it is drawn inside it, over its content and
+ * nowhere else.
+ *
+ * What a design tool's player needs from the screen it plays: a dialog
+ * on that screen dims the screen, centres in it and is clipped by it,
+ * is scaled with it when the screen is drawn smaller than its own size,
+ * and leaves the tool around it pressable. A menu is placed and flipped
+ * within it, since an anchored entry stays inside the box its layer
+ * covers. Outside a scope, entries open in the runtime's own layer
+ * above the whole application, as they always have.
+ *
+ * It fills what holds it, and is the containing block of what it
+ * holds. `useOverlay` finds the nearest scope above the component that
+ * opens the entry; with none, it uses the runtime's `OverlayService`.
+ *
+ * A dialog's trap inside it holds the keyboard inside it only: the
+ * tool around it, and every other scope, keep their focus, and none is
+ * taken from them when it opens or handed to them when it closes.
+ */
+declare function OverlayScope(inputs: Inputs<OverlayScopeProps>, _ctx: ComponentContext): UiChild;
+//#endregion
+//#region src/startingInputsKey.d.ts
+/** One component's starting inputs: input names to values. */
+type StartingInputsRecord = Readonly<Record<string, unknown>>;
+/**
+ * Starting inputs by component name: one record for every instance of
+ * it, or a list for each in the order they are made (`null` for one
+ * left as written), so the second of three switches can start on.
+ */
+type StartingInputsByName = Readonly<Record<string, StartingInputsRecord | readonly (StartingInputsRecord | null)[]>>;
+/**
+ * The inputs components under a node start with, by component name,
+ * over what their parents pass; see `StartingInputs`. Empty outside one.
+ */
+declare const StartingInputsKey: UiEnvironmentKey<StartingInputsByName>;
+//#endregion
+//#region src/StartingInputs.d.ts
+interface StartingInputsProps {
+  /**
+   * Inputs by component name: `{ ScrollArea: { scrollY: 600 }, Tour: { step: 1 } }`;
+   * or a list for each instance in the order they are made, `null` for
+   * one left as written: `{ Toggle: [null, { on: true }] }`.
+   */
+  of?: StartingInputsByName;
+  children?: UiChild;
+}
+/**
+ * Draws what it holds with the components in it started from given
+ * inputs, named by component, over what their parents pass: every
+ * `ScrollArea` in it scrolled to 600, every `Tour` at its second step.
+ *
+ * What a design tool draws a moment of a screen with, beside the
+ * screen as written, without a copy of the screen to drift from it: a
+ * list scrolled far enough for its back-to-top button, a dialog open,
+ * a tour on its second step. A component reads them as it would its
+ * parent's props, so one that takes a value without a handler beside
+ * it starts there and is then the person's to change, in a design
+ * tool's player as anywhere. A preview of inputs (`InspectionService.
+ * previewInputs`) goes over them, and ending it comes back to them.
+ *
+ * They are read as each component is made, so they start a component
+ * rather than steer one: a new `of` reaches components made after it,
+ * and once the parent passes something new for an input, it is the
+ * parent's again, as a dialog saved open closes when its owner closes
+ * it.
+ * Nested, the outer one wins for an input both give a component, and
+ * the inner one's other inputs and names still reach in: what draws a
+ * screen at a moment decides over what the screen starts itself with,
+ * so a moment saved from a moment is the later one. A list per instance
+ * is taken whole. It fills what holds it.
+ */
+declare function StartingInputs(inputs: Inputs<StartingInputsProps>, ctx: ComponentContext): UiChild;
+//#endregion
+//#region src/liveInput.d.ts
+/**
+ * Says what an input of the component whose body is running holds now,
+ * as the component keeps it, and how to read it again: a switch turned
+ * on, a field typed in, a list scrolled to 600. The inspector reports it
+ * on the component's owner report (`live`), and a design tool saves a
+ * moment of a played screen from it, to start the screen there again
+ * (`StartingInputs`). `controlled` calls it for its value, so a control
+ * written by its contract reports itself; outside a component's body it
+ * does nothing.
+ */
+declare function liveInput(name: string, read: () => unknown): void;
 //#endregion
 //#region src/overlay/OverlayLayer.d.ts
 /**
@@ -1348,7 +1415,10 @@ declare class OverlayService {
  * why that node and not always the anchor.
  */
 declare class OverlayLayer extends Component {
-  overlays: OverlayService;
+  runtimeOverlays: OverlayService;
+  /** The entries to draw, when not the runtime's: an `OverlayScope`'s. */
+  service: InputCell<OverlayService | null>;
+  private get overlays();
   render(): UiElement;
   private renderEntries;
 }
@@ -1379,6 +1449,8 @@ declare class OverlayLayer extends Component {
 declare class ComponentHost<P extends Record<string, unknown> = Record<string, unknown>> {
   private readonly services;
   private readonly channels;
+  /** The slot's node, under its parent, for `ctx.environment`; null for a host made outside a tree. */
+  private readonly anchor;
   /** The class instance; undefined for a functional component. */
   readonly instance: Component | undefined;
   readonly element: ComponentElement<P>;
@@ -1400,11 +1472,29 @@ declare class ComponentHost<P extends Record<string, unknown> = Record<string, u
   private readonly inputSubscriptions;
   /** A functional component's cells, by prop name, as they were handed out. */
   private readonly functionalCells;
+  /**
+   * Inputs it is drawn with over its parent's, from a `StartingInputs`
+   * above it when it was made: a moment of a screen, a tour's second
+   * step. A preview goes over these, and ending one comes back to them.
+   */
+  private started;
+  /** What the parent passed for each started input at birth: a new value from it takes over. */
+  private readonly startedOver;
+  /** A started input the parent passes as a stream: the start, then the stream's changes; one per input, so it is not resubscribed. */
+  private readonly startedStreams;
+  /** What the component says it holds now, by input; see `liveInput`. */
+  private readonly live;
+  /** Inputs a tool draws the component with over its parent's, until it ends them; see `previewInputs`. */
+  private previewed;
+  /** A class's input values from before they were previewed, for the ones its parent does not pass. */
+  private readonly beforePreview;
   private readonly mountHooks;
   private readonly unmountHooks;
   /** True only while the component function runs; hooks may register then. */
   private rendering;
-  constructor(element: ComponentElement<P>, services?: ServiceRegistry, channels?: ChannelRegistry);
+  constructor(element: ComponentElement<P>, services?: ServiceRegistry, channels?: ChannelRegistry,
+  /** The slot's node, under its parent, for `ctx.environment`; null for a host made outside a tree. */
+  anchor?: UiNode | null);
   /** The class or function this host mounts. */
   get component(): ComponentType;
   /**
@@ -1428,6 +1518,21 @@ declare class ComponentHost<P extends Record<string, unknown> = Record<string, u
    * cell is what updates the output.
    */
   updateProps(props: P): void;
+  /**
+   * Feeds the inputs `values` names from them instead of from the
+   * parent, until a call with null hands them back to the parent: a
+   * design tool showing one of a component's states on the live tree.
+   * A later call replaces the earlier one; a new prop from the parent
+   * for a previewed input waits until the preview ends.
+   *
+   * Each input a preview starts or ends is handed its value even when
+   * it holds that value already, as a new value from the parent is: a
+   * control that owns what it was started at (`controlled`) starts
+   * again from it, rather than keeping what a person turned it to.
+   */
+  previewInputs(values: Readonly<Record<string, unknown>> | null): void;
+  /** What an input is fed from: a preview's value for it, else what it was started with, else the parent's prop. */
+  private providedFor;
   private renderFunction;
   /**
    * The props record a functional component reads: a cell per name,
@@ -1440,6 +1545,15 @@ declare class ComponentHost<P extends Record<string, unknown> = Record<string, u
   private createInputRecord;
   private createContext;
   private wireInputs;
+  /** What the component says each of its inputs holds now; see `liveInput`. */
+  liveInputs(): ReadonlyMap<string, unknown>;
+  /**
+   * What the parent most recently supplied for each input, as given:
+   * a value, an element or a stream, whether or not the component has
+   * read it yet. For a tool reading the tree, such as the inspector's
+   * owner report; nothing here changes it.
+   */
+  suppliedInputs(): ReadonlyMap<string, unknown>;
   /**
    * Connects one input cell to whatever the parent supplied.
    *
@@ -1481,7 +1595,7 @@ declare class ComponentHostResolver implements ComponentResolver {
   private readonly hosts;
   private pendingMounts;
   constructor(services?: ServiceRegistry, channels?: ChannelRegistry);
-  resolve(element: ComponentLikeElement, anchorId: string): UiChild;
+  resolve(element: ComponentLikeElement, anchorId: string, anchor?: UiNode): UiChild;
   release(anchorId: string): void;
   flushMounts(): void;
   /**
@@ -1560,8 +1674,22 @@ interface UiNodeReport {
    */
   readonly beneath: readonly UiBeneathReport[];
   readonly semantics?: UiSemanticsReport;
+  /**
+   * What the node draws while hovered and while pressed, from its
+   * `interactive` modifiers: the props it writes then, as the element
+   * would write them. For a design tool's handoff, which writes them
+   * as `:hover` and `:active`. Absent when it changes nothing.
+   */
+  readonly interaction?: UiInteractionReport;
   /** `formatExplanation` of the node's layout, which is L8's answer. */
   readonly explanation: string;
+  /**
+   * Where the element was written, when it was compiled for
+   * development. The one part of the report that is a handle after
+   * all: it names a line an editor can open, and an owner's `usedAt`
+   * names the line that used the component around it.
+   */
+  readonly source?: UiSourceLocation;
 }
 /** A node under the inspected one at the pointer. */
 interface UiBeneathReport {
@@ -1576,7 +1704,28 @@ interface UiOwnerReport {
   /** The `@Define` tag, else the class or function name. */
   readonly name: string;
   readonly anchorId: string;
+  /** Where the component was used, when compiled for development. */
+  readonly usedAt?: UiSourceLocation;
+  /**
+   * What its parent supplied for each input, as far as plain data can
+   * say: a word, a number or a flag as it is, and an element (a slot the
+   * parent filled) as `{ element: true }`. Handlers, data objects and
+   * streams with no current value are left out. What a design tool
+   * needs to write a component's use back as code: `label="Email"`.
+   */
+  readonly inputs?: Readonly<Record<string, UiOwnerInput>>;
+  /**
+   * What the component says its inputs hold now, as it keeps them
+   * (`liveInput`): a switch a person turned on, a list scrolled to 600.
+   * Plain values only. What a design tool saves a moment of a played
+   * screen from.
+   */
+  readonly live?: Readonly<Record<string, string | number | boolean | null>>;
 }
+/** One input's value in an owner report; see `UiOwnerReport.inputs`. */
+type UiOwnerInput = string | number | boolean | null | {
+  readonly element: true;
+};
 /** As much of a node as a one-line path needs. */
 interface NodePathTarget {
   /** `UiNodeType`, as its string value. */
@@ -1687,6 +1836,10 @@ interface UiEnvironmentReport {
   /** Whether this node provides the value rather than inheriting it. */
   readonly provided: boolean;
 }
+interface UiInteractionReport {
+  readonly hovered?: Readonly<Record<string, unknown>>;
+  readonly pressed?: Readonly<Record<string, unknown>>;
+}
 interface UiSemanticsReport {
   readonly role?: string;
   readonly label?: string;
@@ -1704,6 +1857,8 @@ interface UiSemanticsReport {
  */
 declare function printPropValue(value: unknown): string;
 /** The report as text, for a console or a test failure. */
+/** `file:line:column`, the form editors and terminals turn into a link. */
+declare function formatSourceLocation(source: UiSourceLocation): string;
 declare function formatNodeReport(report: UiNodeReport): string;
 //#endregion
 //#region src/app/colorScheme.d.ts
@@ -1956,6 +2111,7 @@ declare class ShellService {
   private leaving;
   private readonly scheme;
   private readonly contrastState;
+  private readonly pointerState;
   private readonly activeState;
   private readonly insets;
   private readonly isFullscreen;
@@ -2015,6 +2171,13 @@ declare class ShellService {
    *   );
    */
   readonly contrast: ReadableCell<UiContrast>;
+  /**
+   * What the person points with: `coarse` on a touch screen, `fine` with
+   * a mouse or a trackpad. Fine until a shell says otherwise. The
+   * runtime also provides it at the root (`UiEnvironmentKeys.pointer`),
+   * where controls read it; this is for the application's own choices.
+   */
+  readonly pointer: ReadableCell<UiPointer>;
   /**
    * Whether the window is the one the person is using: shown, and holding
    * the keyboard focus. False while it is behind another window,
@@ -2064,6 +2227,8 @@ declare class ShellService {
   /** Called by the runtime when the shell reports whether the window is active; not for applications. */
   applyWindowActive(active: boolean): void;
   /** Called by the runtime when the shell reports the contrast; not for applications. */
+  /** Called by the runtime when the shell reports what the person points with. */
+  applyPointer(pointer: UiPointer): void;
   applyContrast(contrast: UiContrast): void;
   /**
    * Called by the runtime when the shell reports the platform's insets.
@@ -2379,6 +2544,11 @@ interface AnimateOptions {
   reducedMotion?: UiReducedMotionPolicy;
   /** Wait this long before the first sample; see `UiAnimationOptions.delay`. */
   delay?: number;
+  /**
+   * The clock it runs on, where it is drawn: `ctx.environment(UiEnvironmentKeys.clock)`
+   * in a component, `clockOf(node)` from a node. Real time without one. See `UiClock`.
+   */
+  clock?: UiClock | null;
 }
 interface SpringOptions {
   /** A named spring, or one given outright. Defaults to `snappy`. */
@@ -2393,6 +2563,11 @@ interface SpringOptions {
   reducedMotion?: UiReducedMotionPolicy;
   /** Wait this long before the first sample; see `UiAnimationOptions.delay`. */
   delay?: number;
+  /**
+   * The clock it runs on, where it is drawn: `ctx.environment(UiEnvironmentKeys.clock)`
+   * in a component, `clockOf(node)` from a node. Real time without one. See `UiClock`.
+   */
+  clock?: UiClock | null;
 }
 /**
  * Animation, as a store components can inject.
@@ -2432,6 +2607,13 @@ declare class AnimationService {
    * animation drives a cell, which has no node — see `UiMotion`.
    */
   setMotion(motion: UiMotion): void;
+  private motionListener;
+  /**
+   * Called by the runtime, which provides the vocabulary at its root so
+   * a name in a `transition` or a `motion` state resolves to it too; a
+   * part of the tree may provide its own over it (`UiEnvironmentKeys.motion`).
+   */
+  setMotionListener(listener: ((motion: UiMotion) => void) | null): void;
   get motion(): UiMotion;
   /**
    * Turns reduced motion on or off for this runtime.
@@ -3140,6 +3322,8 @@ interface MediaOptions {
   resolver?: ImageResolver;
   /** Where an `Icon` finds its raster. */
   rasterizer?: IconRasterizer;
+  /** Where an `Image` reads an SVG source. */
+  vectors?: SvgResolver;
   /** Where a `Video` finds its decoder. */
   videoResolver?: VideoResolver;
 }
@@ -3162,6 +3346,7 @@ interface MediaOptions {
 declare class MediaService {
   private imageResolver;
   private iconRasterizer;
+  private svgResolver;
   private videoResolver;
   /**
    * Whether each of the three is the service's to dispose.
@@ -3177,6 +3362,10 @@ declare class MediaService {
   private ownsRasterizer;
   private ownsVideoResolver;
   get images(): ImageResolver;
+  /** Where an `Image` reads an SVG source, which it draws as vectors rather than decoding. */
+  get vectors(): SvgResolver;
+  /** The same seam, for SVG. A read file holds no pixels, so there is nothing to dispose either way. */
+  setSvgResolver(resolver: SvgResolver): void;
   get icons(): IconRasterizer;
   /**
    * Built on first use rather than in the field, because a decoder is
@@ -3478,6 +3667,8 @@ declare class GessoRuntime {
   readonly inspector: LayoutInspector;
   private readonly resolver;
   private readonly graph;
+  /** The properties `InspectionService.preview` is drawing over, by node; gone with the node. */
+  private readonly previewed;
   private readonly engine;
   private readonly builder;
   private readonly scheduler;
@@ -3517,6 +3708,8 @@ declare class GessoRuntime {
   private lastEarlyFrame;
   /** When the last discrete input was routed; see `answerInput`. */
   private lastDiscreteInput;
+  /** The wheel's steps since the last frame, added together; see `wheel`. */
+  private heldWheel;
   /** The display time the frame being drawn is for; see `FrameMetrics.time`. */
   private frameTime;
   /** When the frame's first phase began, before its changes were collected; see `FrameMetrics.durationMs`. */
@@ -3621,6 +3814,11 @@ declare class GessoRuntime {
    * them. Only populated while a listener is attached.
    */
   private semanticsBoxes;
+  /** When a frame last moved something, and when the boxes were last swept; see `updateSemantics`. */
+  private semanticsMovedAt;
+  private semanticsSweptAt;
+  /** The sweep owed once a run of moving frames stops. */
+  private semanticsSweepTimer;
   /** What each semantics walk leaves for the next; see `SemanticsMemory`. */
   private readonly semanticsMemory;
   private lastFocusedId;
@@ -3653,6 +3851,8 @@ declare class GessoRuntime {
   private audioListener;
   private caretTimer;
   private scrollbarTimer;
+  /** Pending frame the renderer asked for though nothing changes; see \`UiRenderer.nextRepaint\`. */
+  private rendererTimer;
   private inspectorTimer;
   /** Pending wake-up for an animation that does not want every frame. */
   private animationTimer;
@@ -3800,6 +4000,25 @@ declare class GessoRuntime {
    * refresh either.
    */
   answerInput(): void;
+  /**
+   * A step of the wheel, or of a trackpad's two fingers or its pinch,
+   * held until the frame and added to the others that arrive before it.
+   *
+   * A trackpad sends a step on every refresh, and a handler that takes
+   * longer than a refresh over one (a design tool's board zoomed over
+   * hundreds of frames, each of whose names it scales) fell behind for
+   * good: each step waited for the one before it, the frame waited for
+   * them all, and a pinch drew nothing until the fingers stopped, then
+   * jumped. Held, the steps that queue while the handler runs are one
+   * step at the next frame, so the handler runs once a frame however
+   * many arrive, and what it draws follows the fingers a frame at a
+   * time. A step with other modifiers or in another unit is not added
+   * to the held one but follows it, and any other input lets the held
+   * step go first (`releaseWheel`), so nothing is answered out of order.
+   */
+  wheel(...step: Parameters<UiWheelController['wheel']>): void;
+  /** Hands the held wheel step to the input now, before what follows it; see `wheel`. */
+  releaseWheel(): void;
   /** Draws the pending frame in a task of its own, if the guards in `answerInput` allow. */
   private drawEarly;
   /**
@@ -3874,6 +4093,21 @@ declare class GessoRuntime {
    * request produced it.
    */
   private sendTree;
+  /**
+   * The theme a node sees, by id, or with none named the theme the
+   * application's outermost content sees: from the application's root,
+   * down through every node with exactly one child, which passes the
+   * wrappers an application usually puts its theme on. Undefined before
+   * the root is built, or for an id the tree does not hold.
+   */
+  themeAt(id?: string): UiTheme | undefined;
+  /**
+   * `InspectionService.preview`: a write over the node's own value, as
+   * a modifier's is, from a source of its own placed after every
+   * modifier, so it wins and ending it restores what was under it.
+   */
+  private previewProperty;
+  private endPreviews;
   /** `inspectNode` for a node named by id, or null when the tree has no such node. */
   inspectNodeById(id: string): UiNodeReport | null;
   /**
@@ -4000,6 +4234,14 @@ declare class GessoRuntime {
   setColorScheme(scheme: ColorScheme): void;
   /** Whether the window is the one in use, passed straight to `ShellService`; see `ShellService.windowActive`. */
   setWindowActive(active: boolean): void;
+  /**
+   * What the person points with, as the shell reports it: kept on
+   * `ShellService.pointer`, and provided at the root, so every theme in
+   * the tree is turned for a finger on a touch device (`withPointer`)
+   * without the application doing anything. A subtree that says
+   * `pointer` itself keeps what it says.
+   */
+  setPointer(pointer: UiPointer): void;
   /** The contrast the platform asks for, passed straight to `ShellService`; see `ShellService.contrast`. */
   setContrast(contrast: UiContrast): void;
   /**
@@ -4104,6 +4346,9 @@ declare class GessoRuntime {
    */
   private pathOf;
   /** The components that rendered a node, nearest first. */
+  private sourceReport;
+  /** The props the node's `interactive` modifiers write while hovered and pressed, later ones over earlier. */
+  private interactionOf;
   private ownersOf;
   private propsOf;
   /**
@@ -4288,6 +4533,13 @@ declare class GessoRuntime {
    */
   applyFileDrop(message: UiFileDropMessage): void;
   applySemanticsAction(action: UiSemanticsAction): void;
+  /**
+   * A semantics action on a node: the mirror's, or `InspectionService.act`'s
+   * on a node with no record of its own. False when it did not take: focus
+   * refused (an open dialog's trap holds it elsewhere), or a field that
+   * takes no text.
+   */
+  private actOn;
   /**
    * An action on an inline link, which is a run and not a node.
    *
@@ -4396,6 +4648,29 @@ declare class GessoRuntime {
    * missing, rather than by scanning every key for the prefix.
    */
   private semanticIdsUnder;
+  /**
+   * The boxes for a frame that moved something but changed no meaning:
+   * all of them when it is the first move after a rest, and otherwise
+   * only the focused node's, with the sweep owed for when the moving
+   * stops (`SEMANTICS_SETTLE_MS`), or for when the boxes have been stale
+   * too long (`SEMANTICS_MOST_STALE_MS`).
+   *
+   * A pan or a zoom moves every box under the camera on every frame. In
+   * Atelier, a board of three dozen screens panned at 15%, the sweep was
+   * 3 to 4 ms of a 4 to 6 ms frame, with frames to 13 ms, past a 120 Hz
+   * display's 8.3; and the main thread wrote four styles on each of 545
+   * elements per frame, which in Chromium was 45% of that thread while
+   * it also had the wheel events to deliver. Nobody reads the rectangle
+   * of an element that is moving under a pan: a screen reader's cursor
+   * is on what it rests on. The focused node is the exception, since its
+   * focus ring is drawn from its element, so it moves every frame.
+   */
+  private movedSemanticsBoxes;
+  /** Sweeps the boxes once the moving has stopped, and sends what changed. */
+  private scheduleSemanticsSweep;
+  private sweepSemanticsBoxes;
+  /** The focused node's box when it differs from the one last sent, as `collectSemanticsBoxes` would give it. */
+  private focusedSemanticsBox;
   /**
    * The mirrored nodes whose box differs from the one last sent, and
    * which are on screen.
@@ -4592,6 +4867,13 @@ declare class GessoRuntime {
    * property change asks for. The engine says when the next change is
    * due; one pending timer marks a repaint for it.
    */
+  /**
+   * The renderer wants a frame though nothing changes: Canvas2D's kept
+   * subtrees are drawn sharp once a zoom settles. One pending timer
+   * marks the root for paint then, which leaves every kept thing as it
+   * is; a frame before it that is still not settled asks again.
+   */
+  private scheduleRendererRepaint;
   private scheduleScrollbarFade;
   /**
    * The caret blinks, which needs frames no property change asks for.
@@ -4608,7 +4890,7 @@ declare class GessoRuntime {
    * for; one pending timer marks a repaint for the next step due.
    */
   private scheduleInspectorRepaint;
-  /** Hands the listener the hovered node's cursor, when it changed. */
+  /** Hands the listener the hovered node's cursor, when it changed: the arrow over a scrollbar, as a native one shows. */
   private sendCursor;
   /**
    * Hands the listener the pointer's scroll chain, when it changed.
@@ -4949,6 +5231,9 @@ type ShellToRuntimeMessage = {
 } | {
   type: 'contrast';
   contrast: UiContrast;
+} | {
+  type: 'pointer';
+  pointer: UiPointer;
 } |
 /** Whether the window is shown and holds the focus; once at start-up and on every change. See `ShellService.windowActive`. */
 {
@@ -6421,6 +6706,8 @@ declare class GessoAppBuilder {
   private root;
   private readonly channelRegistrations;
   private readonly serviceRegistrations;
+  /** The application's own agent tools (`useAgentTools`). */
+  private readonly agentTools;
   private frameListener;
   private inspectListener;
   private devtoolsListener;
@@ -6462,6 +6749,8 @@ declare class GessoAppBuilder {
    * service.
    */
   useService(ServiceClass: new () => object): this;
+  /** Offers an agent tools of the application's own; see `renderRoot(...).useAgentTools`. */
+  useAgentTools(tools: readonly AgentToolDefinition[]): this;
   /**
    * Declares the app's routes, which is all it takes to make a
    * `RouterOutlet` in the tree resolve them. Mirrors
@@ -6731,6 +7020,8 @@ declare class GessoApp {
   /** The appearance this shell reports; watched or overridden. */
   private colorSchemePreference;
   constructor(options: GessoAppOptions);
+  /** Runs a pending frame now: see `FrameService.flush`. */
+  private flushFrame;
   /**
    * The running app, as the agent's screen tools need it: its semantics
    * tree and focus, the mirror's actions, keys, and a way to run a
@@ -7620,10 +7911,151 @@ declare function persisted<T>(adapter: StorageAdapter, key: string, options: Per
  */
 declare class FrameService {
   private readonly subject;
+  private flusher;
   /** Emits after each frame finishes, with what it cost and what it answered. */
   readonly frames: Observable<FrameMetrics>;
   /** Called by the runtime; not for components. */
   publish(metrics: FrameMetrics): void;
+  /** Called by the shell that drives the frames; not for components. */
+  setFlush(flush: (() => void) | null): void;
+  /**
+   * Draws a pending frame now, rather than when the display next asks
+   * for one; nothing when none is pending.
+   *
+   * A tab in the background is sent no frames. A design editor's tool,
+   * called by an agent while the editor's window is behind another,
+   * changes the screen and waits for it to be drawn before reading it:
+   * without this, it waits for a frame that never comes. The agent's
+   * own screen tools (`uiSurface`) do the same after each action.
+   */
+  flush(): void;
+}
+//#endregion
+//#region src/app/InspectionService.d.ts
+/**
+ * What is on the screen, as a component can ask: the nodes under a
+ * point, and what each one is.
+ *
+ * The inspector already answers both, for the devtools panel, from the
+ * runtime's hit tester and its node report. A tool built in Gesso that
+ * points at Gesso needs the same answers from inside the tree: a design
+ * editor whose canvas holds live frames, where a click picks the box
+ * under it instead of pressing it and says which line wrote it. So the
+ * runtime puts them here, as it puts frames in `FrameService`.
+ * Injected like any service: `ctx.inject(InspectionService)`.
+ */
+declare class InspectionService {
+  private host;
+  /** Called by the runtime; not for components. */
+  attach(host: InspectionHost): void;
+  /**
+   * Every node under a point, topmost first, in the coordinates a
+   * pointer event carries: the one a press would reach, then each one
+   * it is painted over. Empty before the first frame.
+   */
+  nodesAt(x: number, y: number): readonly UiNode[];
+  /**
+   * What the node is, as the inspector reports it: its box, its props,
+   * the components that rendered it and, compiled for development, the
+   * line that wrote it (`source`) and where each of those components
+   * was used (`owners[].usedAt`).
+   */
+  inspect(node: UiNode): UiNodeReport;
+  /**
+   * Where the node is drawn, as `inspect(node).box` reports it, without
+   * the rest of the report: for an editor that reads the boxes of many
+   * nodes as its view moves (a minimap of a board of frames), where
+   * building each node's props, owners and source was most of the cost.
+   */
+  box(node: UiNode): {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  };
+  /**
+   * Where the node is seen on the screen: `box` with every transform
+   * above it applied, so a node in a frame drawn at half its size is
+   * half its size, where it is drawn. What an overlay laid over the
+   * live tree is placed by (an outline on the component under the
+   * pointer). `box` keeps the untransformed box, which is where the
+   * node is in the layout: what an editor reading a zoomed board in
+   * the board's own coordinates (a minimap) needs.
+   */
+  screenBox(node: UiNode): {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  };
+  /**
+   * Draws a node as though it declared `value` for `property`, until
+   * the preview is ended or the node leaves the tree.
+   *
+   * What a design editor shows while a value is being chosen: a padding
+   * dragged or a colour hovered in a list is drawn at once, on the
+   * live tree, and only written to the source when the designer lets go.
+   * It wins over the element's own value and over its modifiers, and
+   * ending it restores whichever of those was there, inheritance
+   * included. The name and value are a prop's, as JSX would write them.
+   */
+  preview(node: UiNode, property: string, value: unknown): void;
+  /** Ends a preview of one property, or of every property previewed on the node. */
+  endPreview(node: UiNode, property?: string): void;
+  /**
+   * Draws a component as though its parent passed `inputs`, over what
+   * the parent did pass, until the preview is ended or the component
+   * leaves the tree. The component is named by its anchor, as
+   * `inspect(node).owners[].anchorId` gives it.
+   *
+   * What a design editor shows when a component on a played screen is
+   * jumped to one of its states (Filled, Error, Disabled): the same
+   * instance, still live, given that state's inputs, and the inputs it
+   * was written with back when the preview ends. A later preview of the
+   * same component replaces this one. The names and values are props',
+   * as JSX would write them. An anchor no component holds is ignored.
+   */
+  previewInputs(anchorId: string, inputs: Readonly<Record<string, unknown>>): void;
+  /** Ends a preview of a component's inputs: its parent's are its own again. */
+  endInputPreview(anchorId: string): void;
+  /**
+   * Presses a node, or replaces the text of the field it is, as a
+   * person would: a click at the middle of where it is drawn, which
+   * its handlers and every handler above it get, or the edit a
+   * keyboard makes once it has focus. The path the accessibility
+   * mirror's actions take, for any node in the tree, record or not.
+   *
+   * What a design editor's agent does to play a prototype in its live
+   * frames: a row pressed, an email typed, by a node it found with
+   * `nodesAt` or by walking the tree. False when it did not take: a
+   * node no longer in the tree, or a field that could not have focus
+   * because an open dialog's trap holds it, or takes no text.
+   */
+  act(node: UiNode, action: 'click' | 'setValue', value?: string): boolean;
+}
+/** What the runtime gives the service. */
+interface InspectionHost {
+  nodesAt(x: number, y: number): readonly UiNode[];
+  inspect(node: UiNode): UiNodeReport;
+  /** The node's box alone, as `inspect` reports it. */
+  box?(node: UiNode): {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  };
+  /** The node's box with the transforms above it applied. */
+  screenBox?(node: UiNode): {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  };
+  preview?(node: UiNode, property: string, value: unknown): void;
+  endPreview?(node: UiNode, property?: string): void;
+  /** Null ends the preview. */
+  previewInputs?(anchorId: string, inputs: Readonly<Record<string, unknown>> | null): void;
+  act?(node: UiNode, action: 'click' | 'setValue', value?: string): boolean;
 }
 //#endregion
 //#region src/app/videoClock.d.ts
@@ -8203,25 +8635,6 @@ declare class ScrollService {
 }
 //#endregion
 //#region src/app/FocusService.d.ts
-/**
- * Keyboard focus, as a store components can inject.
- *
- * `UiFocusManager` lives in the runtime and a component cannot reach
- * it — components reach the world through stores, as they do for the
- * clipboard (`ShellService`), overlays (`OverlayService`) and find
- * (`FindService`). Without this a component cannot autofocus a field,
- * trap the keyboard in a dialog, or put the caret in the input that
- * failed validation.
- *
- * Nodes come from a `ref` prop. A tree's refs fire before the runtime
- * installs the manager, so an action taken during the first build is
- * queued and replayed once there is one; that is the same problem
- * `FindService` solves for its query field, and the reason `autoFocus`
- * in a dialog works on the frame it mounts.
- *
- * It must stay on the render thread: its actions take `UiNode`s, which
- * never cross a worker boundary.
- */
 declare class FocusService {
   /** The node holding focus, or null. A control binds its focus ring to this. */
   readonly focused: InternalState<UiNode | null>;
@@ -8255,6 +8668,12 @@ declare class FocusService {
   focusNext(): void;
   /** Moves focus to the previous focusable node, wrapping around. */
   focusPrevious(): void;
+  /**
+   * The tab stops under `within` (the whole tree when not given), in
+   * the order Tab visits them: what a design tool numbers to show a
+   * screen's keyboard order. Empty before the runtime has a manager.
+   */
+  tabStops(within?: UiNode): UiNode[];
   /**
    * Confines focus to `scope` until `releaseTrap`, moving it inside if
    * it was elsewhere. Traps nest: a dialog opened over a dialog traps
@@ -8701,6 +9120,13 @@ interface WorkerGlobal {
  * useChannel() calls always land before the shell's init message is
  * processed.
  */
+/** An error the render worker reported, as an application's `onError` hears it. */
+interface RenderWorkerError {
+  readonly message: string;
+  readonly stack?: string;
+  /** Where it came from: a frame, a listener, the renderer, a channel, a message, or nothing that caught it. */
+  readonly source: RuntimeErrorSource;
+}
 declare function renderRoot(root: FrameworkChild | ComponentType): RenderWorkerApp;
 declare class RenderWorkerApp {
   private readonly channelRegistrations;
@@ -8711,6 +9137,14 @@ declare class RenderWorkerApp {
   private root;
   private readonly host;
   private runtime;
+  /** See `renderThemesWith`. */
+  private renderThemes;
+  /** See `loadModulesWith`. */
+  private loadModule;
+  /** The application's own agent tools (`useAgentTools`). */
+  private readonly agentTools;
+  /** What the application asked to hear of the errors this worker reports (`onError`). */
+  private readonly errorListeners;
   /** Held so forwarded display refreshes can be handed to it. */
   private clock;
   private channels;
@@ -8728,6 +9162,11 @@ declare class RenderWorkerApp {
    * would be a bare sentence with nothing to look up.
    */
   private reportUncaught;
+  /**
+   * Tells the shell about an error, which shows it (the development
+   * overlay), and every listener the application gave `onError`.
+   */
+  private reportError;
   /**
    * Replaces the application's root and rebuilds its tree, for hot
    * module replacement.
@@ -8752,6 +9191,24 @@ declare class RenderWorkerApp {
    * message it simply changes which root will be built.
    */
   reload(root: FrameworkChild | ComponentType, services?: readonly (new () => object)[]): void;
+  /**
+   * How `render_frame` loads a module an agent names, given its path from
+   * the project root with a leading slash (`/mocks/Settings.tsx`). By
+   * default it is imported from where the application is served, which
+   * suits an application drawing its own modules. One whose modules are
+   * served from somewhere else says where: a design editor serving the
+   * project it designs from another folder.
+   *
+   *   renderRoot(Editor).loadModulesWith(path => import(`/@fs${projectRoot}${path}`))
+   */
+  loadModulesWith(load: (path: string) => Promise<Record<string, unknown>>): this;
+  /**
+   * The themes an application designs in, asked on each call, when they
+   * are not the one it is drawn in: a design editor's project's. They
+   * are what `render_frame` draws in and `tokens_view` reports unless an
+   * agent asks for the application's own; see `designedTheme`.
+   */
+  renderThemesWith(themes: () => DesignThemes): this;
   /**
    * Registers a channel.
    *
@@ -8777,6 +9234,23 @@ declare class RenderWorkerApp {
    * service.
    */
   useService(ServiceClass: new () => object): this;
+  /**
+   * Offers an agent tools of the application's own, beside its
+   * channels' and its screen's: ones that answer with something other
+   * than a view, such as a measurement or a composed picture. See
+   * `AgentToolDefinition`. Called again, it adds to them.
+   *
+   *   renderRoot(Editor).useAgentTools(editorTools);
+   */
+  useAgentTools(tools: readonly AgentToolDefinition[]): this;
+  /**
+   * Hears every error this worker reports to the shell: a frame that
+   * threw, a listener, the renderer, a channel, anything uncaught. For
+   * an application that shows errors itself, where they happen: a design
+   * editor listing what is wrong with a mock rather than an overlay over
+   * the editor, with the plugin's `overlay: false`.
+   */
+  onError(listener: (error: RenderWorkerError) => void): this;
   /**
    * Declares the app's routes, which is all it takes to make a
    * `RouterOutlet` in the tree resolve them.
@@ -8862,5 +9336,5 @@ declare class RenderWorkerApp {
   private initialize;
 }
 //#endregion
-export { StorageAdapter as $, UiNodeReport as $n, mutate as $r, UiFramePhase as $t, Presence as A, AudioService as An, ChannelRegistry as Ar, createShellHistory as At, PersistedOptions as B, ShellFileResult as Bn, themeTokenCell as Br, UiTreeNode as Bt, FocusService as C, buildPath as Cn, pick as Cr, createApp as Ct, FindService as D, AudioMetadata as Dn, createChannelRegistry as Dr, ShellHistory as Dt, TextService as E, AudioAction as En, ChannelRegistryHandle as Er, WorkerAppOptions as Et, AudioSinkOptions as F, SpringOptions as Fn, Output as Fr, ConsoleEntry as Ft, IndexedDbStorage as G, ShellStorageOp as Gn, Each as Gr, ShellToRuntimeMessage as Gt, persisted as H, ShellRecentFile as Hn, Show as Hr, treeText as Ht, AudioSinkOutput as I, UiDuration as In, ControlledOptions as Ir, DevtoolsEvent as It, OpfsFileHandle as J, ColorSchemePreference as Jn, each as Jr, GessoRuntime as Jt, IndexedDbStorageOptions as K, ShellStorageResult as Kn, EachKey as Kr, FrameMetrics as Kt, MediaSessionLike as L, UiEasingChoice as Ln, ControlledValue as Lr, DevtoolsRequest as Lt, RouterOutlet as M, AudioStatus as Mn, Define as Mr, ActionEntry as Mt, AudioElementLike as N, AnimateOptions as Nn, Inject as Nr, ChannelErrorEntry as Nt, observeMediaQuery as O, AudioRequest as On, findUnplainPath as Or, ShellHistoryMode as Ot, AudioSink as P, AnimationService as Pn, Input as Pr, CommandEntry as Pt, MemoryStorage as Q, UiEnvironmentReport as Qn, Mutation as Qr, UI_FRAME_PHASES as Qt, audioClock as R, ShellFile as Rn, controlled as Rr, FrameEntry as Rt, writeClipboard as S, RouteParams as Sn, structurallyEqual as Sr, CreateAppOptions as St, EditingService as T, parseUrl as Tn, ChannelRegistration as Tr, WorkerApp as Tt, ShellStorage as U, ShellRequest as Un, ShowProps as Ur, RuntimeErrorSource as Ut, PersistedState as V, ShellFileType as Vn, bind as Vr, UiTreeSnapshot as Vt, ShellStorageOptions as W, ShellService as Wn, show as Wr, RuntimeToShellMessage as Wt, OpfsStorageOptions as X, BoundStream as Xn, throttled as Xr, RendererChoice as Xt, OpfsStorage as Y, observeColorScheme as Yn, debounced as Yr, GessoRuntimeOptions as Yt, OpfsWritable as Z, NodePathTarget as Zn, MutateOptions as Zr, RuntimeInput as Zt, EditingMirrorTarget as _, Equality as _i, RouteGuard as _n, OverlayService as _r, GessoApp as _t, UiRole as a, SelectOptions as ai, FontService as an, describeStream as ar, storageReadValue as at, EditingProxy as b, route as bn, FrameworkChild as br, GessoAppBuilder as bt, UiSemanticsPatch as c, FanKey as ci, RouteAnswer as cn, formatNodeReport as cr, UndoableOptions as ct, markNow as d, fanOut as di, RouterRoutes as dn, ComponentHostResolver as dr, UndoStackOptions as dt, Resource as ei, FontFaceDeclaration as en, UiOwnerReport as er, StorageOutcome as et, measureSpan as f, ComputedCell as fi, RouterService as fn, ComponentHost as fr, UndoTransaction as ft, renderRoot as g, DeriveOptions as gi, RouteDefinition as gn, OverlayRect as gr, shellStorageDenied as gt, RenderWorkerApp as h, computed as hi, RouteContext as hn, OverlayPlacement as hr, performShellStorage as ht, UI_SEMANTIC_STATES as i, resource as ii, FontHost as in, UiStreamReport as ir, storageReadFailure as it, PresenceProps as j, AudioState as jn, Channel as jr, ActionCause as jt, observeReducedMotion as k, AudioSample as kn, requirePlainData as kr, ShellHistoryOptions as kt, UiSemanticsRecord$1 as l, FanOut as li, RouteMatch as ln, formatStream as lr, undoable as lt, setPerformanceMarks$1 as m, ReadSource as mi, OutletProps as mn, OverlayEntry as mr, ShellLocalStore as mt, MARK_PREFIX as n, ResourceState as ni, FontFamilyDeclaration as nn, UiPropReport as nr, classifyStorageError as nt, UiSemanticState as o, select as oi, MediaOptions as on, formatAge as or, UndoShortcutOptions as ot, performanceMarksEnabled as p, ComputedOptions as pi, RouteState as pn, OverlayLayer as pr, rememberedDirectory as pt, OpfsDirectory as q, ColorScheme as qn, EachProps as qr, FramePhaseTimings as qt, UI_ROLES as r, ResourceStatus as ri, FontFamilyStatus as rn, UiSemanticsReport as rr, storageErrorMessage as rt, UiSemanticsMap$1 as s, FanCell as si, MediaService as sn, formatNodePath as sr, registerUndoShortcuts as st, EditingState$1 as t, ResourceOptions as ti, FontFaceLike as tn, UiPropOrigin as tr, StorageRead as tt, markInstant as u, FanOutOptions as ui, RouterHistorySink as un, printPropValue as ur, UndoStack as ut, SemanticsMirror as v, derive as vi, RouteOptions as vn, createComponent as vr, GessoAppOptions as vt, ScrollService as w, formatUrl as wn, pickKeys as wr, AppLogicEndpoint as wt, EditingProxySink as x, to as xn, isComponentElement as xr, WebMcpChoice as xt, SemanticsMirrorSink as y, ServiceRegistry as yi, RouteTarget as yn, ComponentElement as yr, createSyncApp as yt, FrameService as z, ShellFileRequest as zn, ThemeTokenCell as zr, PatchEntry as zt };
-//# sourceMappingURL=index-DZbSb8IN.d.ts.map
+export { OpfsStorageOptions as $, BoundStream as $n, ThemeTokenCell as $r, RendererChoice as $t, observeReducedMotion as A, DeriveOptions as Ai, AudioMetadata as An, OverlayRect as Ar, ShellHistory as At, InspectionHost as B, UiEasingChoice as Bn, findUnplainPath as Br, DevtoolsRequest as Bt, writeClipboard as C, FanOut as Ci, route as Cn, StartingInputsByName as Cr, GessoAppBuilder as Ct, TextService as D, ComputedOptions as Di, formatUrl as Dn, OverlayScopeProps as Dr, AppLogicEndpoint as Dt, EditingService as E, ComputedCell as Ei, buildPath as En, OverlayScope as Er, createApp as Et, AudioSink as F, AudioStatus as Fn, pick as Fr, ActionEntry as Ft, persisted as G, ShellRecentFile as Gn, Input as Gr, treeText as Gt, FrameService as H, ShellFileRequest as Hn, Channel as Hr, PatchEntry as Ht, AudioSinkOptions as I, AnimateOptions as In, pickKeys as Ir, ChannelErrorEntry as It, IndexedDbStorage as J, ShellStorageOp as Jn, SharedValuesKey as Jr, ShellToRuntimeMessage as Jt, ShellStorage as K, ShellRequest as Kn, Output as Kr, RuntimeErrorSource as Kt, AudioSinkOutput as L, AnimationService as Ln, ChannelRegistration as Lr, CommandEntry as Lt, PresenceProps as M, derive as Mi, AudioSample as Mn, OverlayService as Mr, ShellHistoryOptions as Mt, RouterOutlet as N, AudioService as Nn, createComponent as Nr, createShellHistory as Nt, FindService as O, ReadSource as Oi, parseUrl as On, OverlayEntry as Or, WorkerApp as Ot, AudioElementLike as P, AudioState as Pn, structurallyEqual as Pr, ActionCause as Pt, OpfsStorage as Q, observeColorScheme as Qn, controlled as Qr, GessoRuntimeOptions as Qt, MediaSessionLike as R, SpringOptions as Rn, ChannelRegistryHandle as Rr, ConsoleEntry as Rt, EditingProxySink as S, FanKey as Si, RouteTarget as Sn, StartingInputsProps as Sr, createSyncApp as St, ScrollService as T, fanOut as Ti, RouteParams as Tn, StartingInputsRecord as Tr, CreateAppOptions as Tt, PersistedOptions as U, ShellFileResult as Un, Define as Ur, UiTreeNode as Ut, InspectionService as V, ShellFile as Vn, requirePlainData as Vr, FrameEntry as Vt, PersistedState as W, ShellFileType as Wn, Inject as Wr, UiTreeSnapshot as Wt, OpfsDirectory as X, ColorScheme as Xn, ControlledOptions as Xr, FramePhaseTimings as Xt, IndexedDbStorageOptions as Y, ShellStorageResult as Yn, sharedValue as Yr, FrameMetrics as Yt, OpfsFileHandle as Z, ColorSchemePreference as Zn, ControlledValue as Zr, GessoRuntime as Zt, renderRoot as _, ResourceStatus as _i, OutletProps as _n, ComponentHostResolver as _r, ShellLocalStore as _t, UiRole as a, Each as ai, FontFamilyDeclaration as an, UiOwnerReport as ar, classifyStorageError as at, SemanticsMirrorSink as b, select as bi, RouteGuard as bn, liveInput as br, GessoApp as bt, UiSemanticsPatch as c, each as ci, FontService as cn, UiSemanticsReport as cr, storageReadValue as ct, markNow as d, MutateOptions as di, RouteAnswer as dn, formatAge as dr, UndoableOptions as dt, themeTokenCell as ei, RuntimeInput as en, NodePathTarget as er, OpfsWritable as et, measureSpan as f, Mutation as fi, RouteMatch as fn, formatNodePath as fr, undoable as ft, RenderWorkerError as g, ResourceState as gi, RouteState as gn, printPropValue as gr, rememberedDirectory as gt, RenderWorkerApp as h, ResourceOptions as hi, RouterService as hn, formatStream as hr, UndoTransaction as ht, UI_SEMANTIC_STATES as i, show as ii, FontFaceLike as in, UiOwnerInput as ir, StorageRead as it, Presence as j, Equality as ji, AudioRequest as jn, OverlayScopeKey as jr, ShellHistoryMode as jt, observeMediaQuery as k, computed as ki, AudioAction as kn, OverlayPlacement as kr, WorkerAppOptions as kt, UiSemanticsRecord$1 as l, debounced as li, MediaOptions as ln, UiStreamReport as lr, UndoShortcutOptions as lt, setPerformanceMarks$1 as m, Resource as mi, RouterRoutes as mn, formatSourceLocation as mr, UndoStackOptions as mt, MARK_PREFIX as n, Show as ni, UiFramePhase as nn, UiInteractionReport as nr, StorageAdapter as nt, UiSemanticState as o, EachKey as oi, FontFamilyStatus as on, UiPropOrigin as or, storageErrorMessage as ot, performanceMarksEnabled as p, mutate as pi, RouterHistorySink as pn, formatNodeReport as pr, UndoStack as pt, ShellStorageOptions as q, ShellService as qn, SharedValues as qr, RuntimeToShellMessage as qt, UI_ROLES as r, ShowProps as ri, FontFaceDeclaration as rn, UiNodeReport as rr, StorageOutcome as rt, UiSemanticsMap$1 as s, EachProps as si, FontHost as sn, UiPropReport as sr, storageReadFailure as st, EditingState$1 as t, bind as ti, UI_FRAME_PHASES as tn, UiEnvironmentReport as tr, MemoryStorage as tt, markInstant as u, throttled as ui, MediaService as un, describeStream as ur, registerUndoShortcuts as ut, EditingMirrorTarget as v, resource as vi, RouteContext as vn, ComponentHost as vr, performShellStorage as vt, FocusService as w, FanOutOptions as wi, to as wn, StartingInputsKey as wr, WebMcpChoice as wt, EditingProxy as x, FanCell as xi, RouteOptions as xn, StartingInputs as xr, GessoAppOptions as xt, SemanticsMirror as y, SelectOptions as yi, RouteDefinition as yn, OverlayLayer as yr, shellStorageDenied as yt, audioClock as z, UiDuration as zn, createChannelRegistry as zr, DevtoolsEvent as zt };
+//# sourceMappingURL=index-DocVauCS.d.ts.map