gesso-framework 0.4.2 → 0.5.1

package/dist/{index-C9FAI_Kt.d.ts → index-Sff7qPGU.d.ts}

@@ -1,6 +1,8 @@
-import { C as CommandMap, I as ReadableCell, N as InputCell, P as OutputCell, S as Command, U as Component, V as InternalState, a as ComponentType, f as ChannelPort, h as Patch, i as ComponentProps, l as ChannelReplica, n as ComponentArgs, r as ComponentContext, s as Inputs, x as ChannelToken } from "./FunctionComponent-CgwLKE5d.js";
+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-U39HjNFA.js";
+import { S as InternalState, _ as ReadableCell, a as ComponentType, h as OutputCell, i as ComponentProps, l as ChannelReplica, m as InputCell, n as ComponentArgs, r as ComponentContext, s as Inputs, w as Component } from "./FunctionComponent-fYMdePtH.js";
 import { BehaviorSubject, Observable, Subscription } from "rxjs";
-import { AnimatedCell, AnimationDriver, CanvasHost, CaretRect, ComponentLikeElement, ComponentResolver, EditingState, EditingState as EditingState$1, IconRasterizer, ImageResolver, LayoutExplanation, LayoutInspector, MARK_PREFIX, MotionStateInput, MotionTiming, RendererBackend, Size, TextMeasureRequest, TextMeasurer, UI_ROLES, UI_SEMANTIC_STATES, UiAnimation, UiChild, 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, UiThemeExtension, UiTouchScroller, UiWheelController, VideoClock, VideoResolver, markInstant, markNow, measureSpan, performanceMarksEnabled, setPerformanceMarks as setPerformanceMarks$1 } from "gesso-core";
+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.
@@ -947,49 +949,6 @@ declare function Channel(token: {
   name: string;
 }): PropertyDecorator;
 //#endregion
-//#region src/channel/provide.d.ts
-/** What the owning thread supplies for a channel. */
-interface ChannelSource<View extends object, Commands extends object> {
-  /** One observable per declared view key. */
-  view: { readonly [K in keyof View]: Observable<View[K]>; };
-  /** One handler per declared command. */
-  commands?: Commands;
-}
-/**
- * Publishes a channel from the thread that owns its data.
- *
- * Each view key is subscribed, diffed against what the other side last
- * saw, and sent as patches. Whatever produced the observable — a bare
- * subject or a stack of layers — stays here; only plain data crosses.
- *
- * Keys are subscribed on the first sync request, so a channel nobody
- * is watching costs nothing.
- */
-declare function provide<View extends object, Commands extends object>(token: ChannelToken<View, Commands>, source: ChannelSource<View, Commands>, port: ChannelPort): ProvidedChannel;
-declare class ProvidedChannel {
-  private readonly token;
-  private readonly source;
-  private readonly port;
-  private readonly subscriptions;
-  /**
-   * What the other side is known to hold, seeded from the token's
-   * initial value — which the replica also starts from, so an app
-   * whose first emission equals the initial sends nothing at all.
-   */
-  private readonly previous;
-  private readonly checked;
-  private synced;
-  constructor(token: ChannelToken<object, CommandMap>, source: ChannelSource<object, CommandMap>, port: ChannelPort);
-  private receive;
-  private runCommand;
-  private sync;
-  private publish;
-  /** Re-sends every key in full, for a client that reattached. */
-  private resend;
-  private post;
-  dispose(): void;
-}
-//#endregion
 //#region src/channel/ChannelRegistry.d.ts
 /**
  * The channels a runtime can hand to its components, by name.
@@ -1040,154 +999,6 @@ declare function findUnplainPath(value: unknown, path?: readonly (string | numbe
  */
 declare function requirePlainData(channelName: string, key: string, value: unknown): void;
 //#endregion
-//#region src/worker/WorkerPorts.d.ts
-/**
- * Named `MessagePort`s into a worker.
- *
- * A worker's global `onmessage` is a single channel, so a worker that
- * receives messages on it can host exactly one conversation. That is
- * why a store in a data worker used to mean a worker per store: the
- * client claimed the `Worker` object itself, and a second one had
- * nowhere to go.
- *
- * A handshake fixes it. The client opens a `MessageChannel`, keeps one
- * end and transfers the other with a name; the worker serves that name
- * and the two ends talk privately from then on. The global channel is
- * used once per conversation and carries nothing else.
- *
- * Nothing here knows what travels over a port. It is the transport the
- * store replication in `../store/worker` runs on today and the barrier
- * contract will run on next.
- */
-/** A port-shaped thing: `MessagePort` and `Worker` both satisfy it. */
-interface MessageEndpoint {
-  postMessage(message: unknown): void;
-  onmessage: ((event: {
-    data: unknown;
-  }) => void) | null;
-}
-/** The one message the global channel carries. */
-interface PortHandshake {
-  type: 'gesso:port';
-  key: string;
-}
-declare function isPortHandshake(value: unknown): value is PortHandshake;
-/**
- * A worker spawned at most once, serving any number of named ports.
- *
- * Handed to several `useChannel` calls, it is what lets one worker
- * hold a whole application layer instead of one channel. Spawning is
- * deferred to the first `open`, so a handle nobody uses costs nothing.
- */
-interface WorkerHandle {
-  /**
-   * Opens a private channel under `key`, spawning the worker if this
-   * is the first one.
-   */
-  open(key: string): MessagePort;
-  /** Whether the worker has been spawned. */
-  readonly spawned: boolean;
-  /** Stops the worker, if it was ever started. */
-  terminate(): void;
-}
-/**
- * Stands for "whichever worker the shell spawned for the application".
- *
- * A registration inside the render worker cannot name that worker: it
- * is created by the shell and its port only arrives with `init`, long
- * after `useChannel` and `useService` have run. This sentinel is what a
- * registration puts there instead, and the render worker swaps it for
- * the real handle once the port shows up.
- *
- * Opening a port on it before then is a bug rather than a race, so it
- * says so.
- */
-declare const APPLICATION_WORKER: WorkerHandle;
-/**
- * Anything a handshake can be posted to with a port attached.
- * `Worker` and `MessagePort` both satisfy it.
- */
-interface TransferTarget {
-  postMessage(message: unknown, transfer: Transferable[]): void;
-}
-/**
- * A handle over an endpoint someone else owns.
- *
- * The shell spawns the application worker and hands the render worker
- * one end of a channel to it; this is what the render worker opens
- * named ports over. `terminate` is a no-op — the lifetime belongs to
- * whoever created the endpoint, and a handle that could kill a worker
- * it did not spawn would be a surprising thing to hand out.
- */
-declare function portHandle(endpoint: TransferTarget): WorkerHandle;
-/**
- * Routes handshakes arriving on a transferred port through the same
- * handlers as the worker's own global channel.
- *
- * The shell owns the application worker and gives the render worker a
- * port to it, so handshakes reach this worker two ways: on its global
- * channel (whoever spawned it) and on that port (whoever was given
- * it). Both should be served by the same handlers, and neither end
- * should have to know which route a channel came in on.
- */
-interface HubMessage {
-  type: 'gesso:hub';
-}
-declare function isHubMessage(value: unknown): value is HubMessage;
-/**
- * Wraps a worker factory so the worker is created once and shared.
- *
- * A factory rather than a URL for the same reason the render worker
- * takes one: a bundler only emits a chunk for a worker it can see
- * constructed literally in the calling module.
- *
- *   const data = workerHandle(
- *     () => new Worker(new URL('./data.worker.ts', import.meta.url), { type: 'module' })
- *   );
- */
-declare function workerHandle(factory: () => Worker): WorkerHandle;
-/**
- * Minimal view of a worker's global scope, so this module type-checks
- * against the DOM lib without pulling in the WebWorker lib.
- */
-interface PortHost {
-  onmessage: ((event: {
-    data: unknown;
-    ports?: readonly MessagePort[];
-  }) => void) | null;
-}
-/**
- * What a port is answered with when no handler claimed its name.
- *
- * Its own message type rather than a store's or a channel's, because
- * the transport does not know which of them the client is: both
- * recognise it, so a mismatched name is loud either way.
- */
-interface PortErrorMessage {
-  type: 'port:error';
-  message: string;
-}
-declare function isPortErrorMessage(value: unknown): value is PortErrorMessage;
-/**
- * Serves named ports inside a worker.
- *
- * Call it synchronously at the top level of the worker module, before
- * any await, so no handshake is missed.
- *
- * `onPort` returns whether it took the port. Returning false passes
- * the handshake to whatever was serving before, which is what lets two
- * kinds of thing — stores and channels, during the migration — share
- * one worker: each answers for its own names and declines the rest.
- * When nobody accepts, the port is answered with an error naming
- * everything the worker does serve, because a handshake that silently
- * matched nothing leaves the client waiting forever with nothing said.
- *
- * `names` is only read to build that message.
- *
- * Returns a function that stops serving.
- */
-declare function servePorts(onPort: (key: string, port: MessagePort) => boolean, names: () => readonly string[], host?: PortHost): () => void;
-//#endregion
 //#region src/channel/createChannelRegistry.d.ts
 /**
  * A registration with its types erased.
@@ -1227,6 +1038,12 @@ interface ChannelRegistration {
 }
 interface ChannelRegistryHandle {
   registry: ChannelRegistry;
+  /**
+   * The workers serving this registry's channels, so a thread can reach
+   * them for something other than a channel: an agent asking what each
+   * one serves.
+   */
+  readonly workers: ReadonlySet<WorkerHandle>;
   dispose(): void;
 }
 /**
@@ -1234,64 +1051,6 @@ interface ChannelRegistryHandle {
  */
 declare function createChannelRegistry(registrations: readonly ChannelRegistration[], onError?: (channelName: string, message: string, stack?: string) => void): ChannelRegistryHandle;
 //#endregion
-//#region src/channel/serveChannels.d.ts
-/**
- * One channel a worker offers: its token and what feeds it.
- *
- * Types erased structurally, for the same reason `ChannelRegistration`
- * erases them — a list of channels has no single generic
- * instantiation, and making every caller cast to reach one is worse
- * than describing what is actually needed.
- */
-interface ServedChannel {
-  token: {
-    name: string;
-    initial: object;
-  };
-  source: {
-    view: Record<string, Observable<unknown>>;
-    commands?: Record<string, Command>;
-  };
-}
-/**
- * One served channel, with its source checked against its token.
- *
- * `ServedChannel` is erased on purpose, so one list can hold channels
- * of every shape; the cost is that a view key the token declares and
- * the source forgets is found at startup, by the error `provide`
- * reports, rather than by the compiler. This is the typed seam: the
- * source must hold an Observable for every key of the token's view and
- * a handler for every command, and each handler takes the arguments
- * the token declares, so none of them needs an annotation.
- *
- *   serveChannels([
- *     serve(Catalog, { view: catalog, commands: { add: name => catalog.add(name) } })
- *   ]);
- *
- * The view may be any object with the right observables on it, which
- * is often the domain object itself when its properties are named
- * after the keys. Only the declared keys are read from it.
- */
-declare function serve<View extends object, Commands extends object>(token: ChannelToken<View, Commands>, source: ChannelSource<View, Commands>): ServedChannel;
-/**
- * Publishes channels from an application worker.
- *
- * Call it synchronously at the top level of the worker module, before
- * any await, so no handshake is missed:
- *
- *   const catalog = new CatalogViewModel(new CatalogDomain(new OpfsStore()));
- *   serveChannels([
- *     serve(Catalog, { view: { products: catalog.products$ }, commands: { … } })
- *   ]);
- *
- * Everything above this call is the application's own — plain classes,
- * plain observables, no framework import. This function is the entire
- * seam between it and the view.
- *
- * Returns a function that stops serving and disposes what it provided.
- */
-declare function serveChannels(channels: readonly ServedChannel[], host?: PortHost): () => void;
-//#endregion
 //#region src/channel/pick.d.ts
 /**
  * One key of a view model, as its own Observable, emitting only when
@@ -1356,6 +1115,13 @@ declare function createComponent<C extends ComponentType>(component: C, ...args:
 //#endregion
 //#region src/overlay/OverlayService.d.ts
 type OverlayPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+/** A rectangle inside an anchor, from its border box's top left. */
+interface OverlayRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
 /**
  * One thing floating above the app: a menu, a tooltip, a dialog.
  *
@@ -1371,6 +1137,15 @@ interface OverlayEntry {
   readonly id: string;
   readonly content: UiChild;
   readonly anchor?: UiNode | null;
+  /**
+   * The part of `anchor` to open beside, in the anchor's own
+   * coordinates: a character in a field, from
+   * `EditingService.caretRectOf(field, offset)`. The entry follows the
+   * anchor as it would without it, through scrolling and layout. It can
+   * be a stream, so a list under a word being typed moves with the word
+   * when it wraps to the next line, without being opened again.
+   */
+  readonly anchorRect?: Reactive<OverlayRect | undefined>;
   /** Default 'bottom'. */
   readonly placement?: OverlayPlacement;
   /** Gap between content and anchor. */
@@ -1861,6 +1636,7 @@ declare function observeColorScheme(onChange: (scheme: ColorScheme) => void): ()
  */
 type ShellRequest = {
   type: 'clipboard';
+  id: number;
   text: string;
 } | {
   type: 'openUrl';
@@ -2027,6 +1803,7 @@ interface ShellStorageResult {
 declare class ShellService {
   private handler;
   private readonly scheme;
+  private readonly contrastState;
   private readonly insets;
   private readonly isFullscreen;
   /** Popups asked for and not yet answered, by the id sent with each. */
@@ -2035,6 +1812,9 @@ declare class ShellService {
   /** Storage requests asked for and not yet answered, by the id sent with each. */
   private readonly stores;
   private nextStorageId;
+  /** Clipboard writes asked for and not yet answered, by the id sent with each. */
+  private readonly copies;
+  private nextCopyId;
   /** File requests asked for and not yet answered, by the id sent with each. */
   private readonly files;
   private nextFileId;
@@ -2067,6 +1847,18 @@ declare class ShellService {
    * read it beside a channel's view; its setter stays private here.
    */
   readonly colorScheme: ReadableCell<ColorScheme>;
+  /**
+   * The contrast the platform is asking for: `high` when the person has
+   * turned up contrast or turned on a contrast theme, `standard`
+   * otherwise. Reported by the shell like `colorScheme`, and as with it,
+   * what it means is the application's: `withContrast(theme, contrast)`
+   * is the theme that answers it.
+   *
+   *   const theme = combineLatest([shell.colorScheme, shell.contrast]).pipe(
+   *     map(([scheme, contrast]) => withContrast(scheme === 'dark' ? darkTheme : lightTheme, contrast))
+   *   );
+   */
+  readonly contrast: ReadableCell<UiContrast>;
   /** The current appearance, for code that needs it without subscribing. */
   get currentColorScheme(): ColorScheme;
   /**
@@ -2098,6 +1890,8 @@ declare class ShellService {
    * answer, and `colorScheme` is how an application hears about it.
    */
   applyColorScheme(scheme: ColorScheme): void;
+  /** Called by the runtime when the shell reports the contrast; not for applications. */
+  applyContrast(contrast: UiContrast): void;
   /**
    * Called by the runtime when the shell reports the platform's insets.
    *
@@ -2106,8 +1900,27 @@ declare class ShellService {
    * scroll event that moved no edge does not wake every subscriber.
    */
   applyViewportInsets(insets: UiInsets): void;
-  /** Puts text on the system clipboard. */
-  copyText(text: string): void;
+  /**
+   * Puts text on the system clipboard, and answers whether it got there.
+   *
+   * Most callers ignore the answer, and may: the text is on its way the
+   * moment this returns. It is for an application that tells the person
+   * what happened, a "Copied" toast after a menu command, say, which
+   * would be a lie on the occasions the browser refused. It does refuse:
+   * the clipboard wants a focused document, and some browsers a fresh
+   * gesture, and a key pressed in a render worker reaches the window's
+   * clipboard a message later than it reached the canvas.
+   *
+   * With no shell installed the answer is false, as `openPopup`'s is,
+   * rather than a promise that never settles.
+   */
+  copyText(text: string): Promise<boolean>;
+  /**
+   * Called by the runtime when the shell reports whether a clipboard
+   * write landed. Not for applications. An unknown id is ignored, on
+   * `settlePopup`'s terms.
+   */
+  settleClipboard(id: number, copied: boolean): void;
   /** Opens a URL in the user's browser, in a new tab or window. */
   openUrl(url: string): void;
   /**
@@ -3481,7 +3294,20 @@ declare class GessoRuntime {
   private readonly sharedElements;
   private readonly focusNotifier;
   private readonly environmentNotifier;
+  /**
+   * The semantics tree: every record by id, and each record's children
+   * in order.
+   *
+   * A record's own `index` is only kept current for the records that
+   * are sent; the order is `semanticsChildren`. Renumbering every
+   * record after an insertion cost a pass over the whole tree on every
+   * structural change, for indices nothing would read until a record
+   * was next sent or the tree was asked for (`semanticsTree`).
+   */
   private semantics;
+  private semanticsChildren;
+  /** The tree in document order with every index current, built when asked for. */
+  private semanticsOrdered;
   private semanticsListener;
   /**
    * The box last reported for each mirrored node, so a frame that
@@ -3489,6 +3315,8 @@ declare class GessoRuntime {
    * them. Only populated while a listener is attached.
    */
   private semanticsBoxes;
+  /** What each semantics walk leaves for the next; see `SemanticsMemory`. */
+  private readonly semanticsMemory;
   private lastFocusedId;
   /**
    * Where the caret was when `reload` replaced the tree, put back on
@@ -3502,6 +3330,14 @@ declare class GessoRuntime {
   private focusAfterReload;
   /** Whether `focusAfterReload` is waiting to be applied. */
   private restoringFocus;
+  /**
+   * Reveals asked for while the layout listeners run, kept until the
+   * frame's boxes have settled; null outside `settleLayout`, where a
+   * reveal is applied at once.
+   */
+  private deferredReveals;
+  /** Whether a frame has run out of layout passes and been warned about; see `MAX_LAYOUT_PASSES`. */
+  private warnedLayoutPasses;
   /** A frame changed semantics while nothing was listening; see `semanticsTree`. */
   private semanticsStale;
   private lastEditingState;
@@ -3800,6 +3636,8 @@ declare class GessoRuntime {
    * dark should look like.
    */
   setColorScheme(scheme: ColorScheme): void;
+  /** The contrast the platform asks for, passed straight to `ShellService`; see `ShellService.contrast`. */
+  setContrast(contrast: UiContrast): void;
   /**
    * The platform's own insets, as the shell reports them: the safe area
    * under a notch or a home indicator and the strip a soft keyboard
@@ -3844,6 +3682,11 @@ declare class GessoRuntime {
    * preference setters beside it this carries the id it is replying to.
    */
   settlePopup(id: number, opened: boolean): void;
+  /**
+   * Reports whether a clipboard write landed, settling the promise
+   * `ShellService.copyText` returned.
+   */
+  settleClipboard(id: number, copied: boolean): void;
   /**
    * Reports what the shell found in `localStorage`, settling the
    * promise `ShellService.requestStorage` returned.
@@ -3939,6 +3782,11 @@ declare class GessoRuntime {
    * Scrolls every scroll container above `node` just enough that the
    * node is inside its viewport, `padding` pixels from the nearest edge.
    * Nothing moves when it is already visible.
+   *
+   * Asked for from a layout listener — `autoFocus` taking focus is the
+   * usual one — it waits until the frame's layout has settled, so it
+   * reveals where the node ends up rather than where the first pass
+   * put it (see `settleLayout`).
    */
   scrollIntoView(node: UiNode, padding?: number): void;
   /**
@@ -4028,6 +3876,12 @@ declare class GessoRuntime {
    * boxes at all.
    */
   onSemantics(listener: ((update: UiSemanticsUpdate) => void) | null): void;
+  /**
+   * The id of the node that holds focus, or null. The same id the
+   * semantics tree keys its records by, so a reader of the tree can
+   * say which control a key press would reach.
+   */
+  focusedNodeId(): string | null;
   /**
    * The semantics tree as of the last frame that changed it.
    *
@@ -4036,6 +3890,17 @@ declare class GessoRuntime {
    * every frame having paid to keep one nothing was reading.
    */
   semanticsTree(): UiSemanticsMap;
+  /** Replaces the tree with one built in full, which is in document order. */
+  private storeSemantics;
+  /**
+   * The tree in document order, every index current: a walk down
+   * `semanticsChildren`, done when someone asks rather than per frame.
+   * Records whose index had gone out of date are brought up to date in
+   * the store as well.
+   */
+  private orderedSemantics;
+  /** A record's index among its siblings now, which its own `index` may not say. */
+  private semanticsIndexOf;
   /**
    * Something an assistive technology did to a mirrored element,
    * turned back into ordinary input.
@@ -4125,6 +3990,28 @@ declare class GessoRuntime {
    * decides how much of the tree has to be asked.
    */
   private rescopeSemantics;
+  /**
+   * The patches for a frame that changed the shape of the tree, without
+   * walking all of it, or null when the whole tree has to be rebuilt.
+   *
+   * Any frame that added or removed a child used to rebuild the tree
+   * from the root, describing every node again. In a 5,000-line editor
+   * that was 11 ms of every Enter, for one new paragraph. Now the walk
+   * starts at the nearest record above each change, as
+   * `rescopeSemantics` does for a change of meaning, and inside it a
+   * subtree nothing touched keeps its records: renumbered if its
+   * siblings moved, never described again (see
+   * `rebuildSemanticsSubtree`). What is described is the path down to
+   * each change, whatever is new, and everything under a node whose
+   * own meaning changed.
+   *
+   * The result is spliced into `this.semantics` in place, since the map
+   * is in document order and a record's subtree is a contiguous run of
+   * it, so adds still arrive in document order. Removals come first.
+   */
+  private restructureSemantics;
+  /** Whether a node is still in the tree being laid out. */
+  private attached;
   /**
    * The nearest node at or above `node` that holds a semantics record,
    * or null when nothing above it does.
@@ -4167,6 +4054,15 @@ declare class GessoRuntime {
    *
    * Ids that have left the tree are dropped here rather than tracked,
    * since a removal patch has already told the mirror about them.
+   *
+   * **Found by walking what is on screen, not by checking everything.**
+   * Bounding what was sent still computed every node's box to find out
+   * whether it was on screen: a 5,000-line document has three thousand
+   * fields, and the sweep cost 4 to 24 ms of every keystroke. The walk
+   * goes down from the root carrying the scroll and sticky offsets that
+   * `visibleBox` adds up per node, and passes over any subtree whose
+   * bounds (the hit tester's, see `subtreeBoundsFor`) are off screen.
+   * A node it passes over is one this skipped before anyway.
    */
   private collectSemanticsBoxes;
   /**
@@ -4240,6 +4136,58 @@ declare class GessoRuntime {
   private collectVirtualMeasures;
   /** A node's outer extent along the list's axis. */
   private extentOf;
+  /**
+   * Tells the layout listeners what moved, and lays out again for as
+   * long as what they do in answer needs it, so the frame paints the
+   * layout they settle on rather than the one they were told about.
+   *
+   * The browser's answer to the same problem. A `ResizeObserver`
+   * callback runs after layout and before paint, and when it changes
+   * layout the browser lays out again before it paints rather than
+   * showing the stale boxes for a frame. The listeners here are
+   * `breakpoint`, `sizeContainer` (and so `Responsive`),
+   * `scrollPosition`, `autoFocus` and anything else on `host.onLayout`.
+   * Before this a page whose breakpoint gave it wide padding was
+   * painted with its narrow padding on the frame it appeared, and
+   * jumped 16 px on the next.
+   *
+   * A pass after the first lays out only what the listeners dirtied,
+   * the same incremental pass any frame runs, and then tells only the
+   * listeners whose boxes it changed. A frame whose listeners wrote
+   * nothing that lays out, which is almost every frame, runs no second
+   * pass: it pays one look at the dirty set.
+   *
+   * **Bounded.** Listeners that keep moving each other's boxes would
+   * otherwise never let the frame paint. ResizeObserver bounds its loop
+   * by tree depth; this one is bounded by count, `MAX_LAYOUT_PASSES` in
+   * all, which is easier to reason about and more than a real chain
+   * needs (a breakpoint inside a `Responsive` inside a `Responsive` is
+   * four passes). Past it the frame paints what it has, the rest waits
+   * for the next frame as it always used to, and a warning says so
+   * once, as the browser's "ResizeObserver loop completed with
+   * undelivered notifications" does.
+   *
+   * **Reveals wait for the end.** `autoFocus` takes focus from a layout
+   * listener, on its node's first layout, and focus reveals the node:
+   * revealed from the first pass's boxes, it scrolled to where the node
+   * was before a breakpoint moved it. A reveal asked for while the
+   * listeners run is applied once they are quiet, from final boxes, and
+   * its scroll laid out like any other write. So is the focus a hot
+   * reload restores, after the listeners rather than before because
+   * `autoFocus` is one of them and the restore has to be the last word:
+   * every node in a subtree a reload replaced has its first layout on
+   * this frame.
+   */
+  private settleLayout;
+  /**
+   * Whether something written since the frame was collected has to be
+   * laid out before the frame paints: the same flags that make a frame
+   * lay out, or an inherited value still to be handed down.
+   */
+  private layoutPending;
+  /** Applies what waits for settled boxes: a reload's focus, then the reveals asked for. */
+  private finishSettling;
+  private warnLayoutPasses;
   private handleFrame;
   /**
    * Keeps frames coming while something is animating.
@@ -4348,6 +4296,14 @@ interface FrameMetrics {
   measured: number;
   /** Relayout boundaries the layout phase started from; 0 when it ran from the root or not at all. */
   relayoutRoots: number;
+  /**
+   * Times the frame laid out: 0 when it laid nothing out, 1 usually,
+   * more when a layout listener (a `breakpoint`, a `sizeContainer`, an
+   * `autoFocus`'s reveal) changed what the first pass laid out and the
+   * frame laid it out again before painting. `measured` and
+   * `relayoutRoots` count every pass.
+   */
+  layoutPasses: number;
   /** Milliseconds per phase. A phase with no work reports 0. */
   phases: FramePhaseTimings;
   /** The backend that drew this frame, or `pending` while WebGPU initialises. */
@@ -4538,9 +4494,12 @@ type ShellToRuntimeMessage = {
   type: 'compositionEnd';
   text: string;
   at?: number;
-} | {
+} |
+/** `html` is the clipboard's HTML, when it held some. */
+{
   type: 'paste';
   text: string;
+  html?: string;
   at?: number;
 } |
 /** The editing proxy lost focus to something outside the app. */
@@ -4589,6 +4548,9 @@ type ShellToRuntimeMessage = {
 {
   type: 'colorScheme';
   scheme: ColorScheme;
+} | {
+  type: 'contrast';
+  contrast: UiContrast;
 } |
 /**
  * What the window's own chrome is covering on each edge: the safe
@@ -4639,6 +4601,16 @@ type ShellToRuntimeMessage = {
   id: number;
   opened: boolean;
 } |
+/**
+ * Whether a `clipboard` request's text reached the clipboard, under
+ * the request's `id`. False when the browser refused both ways of
+ * writing it.
+ */
+{
+  type: 'clipboardResult';
+  id: number;
+  copied: boolean;
+} |
 /**
  * What the shell found in `localStorage` for a `storage` request
  * (ShellStorage). The second reply on this protocol, and it carries
@@ -4775,6 +4747,7 @@ type RuntimeToShellMessage = {
   nodes: number;
   measured: number;
   relayoutRoots: number;
+  layoutPasses: number;
   at: number;
   inputLatencyMs: number | null;
   phases: FramePhaseTimings;
@@ -4828,9 +4801,13 @@ type RuntimeToShellMessage = {
   type: 'editing';
   state: EditingState | null;
 } |
-/** Put text on the clipboard (ShellService.copyText). */
+/**
+ * Put text on the clipboard (ShellService.copyText). `id` pairs it
+ * with the `clipboardResult` that comes back, once.
+ */
 {
   type: 'clipboard';
+  id: number;
   text: string;
 } |
 /** Open a URL in a new tab (ShellService.openUrl). */
@@ -5388,6 +5365,30 @@ interface WorkerAppOptions {
    * reach. `gesso-electrobun`'s bridge is what goes here.
    */
   onOpenUrl?: (url: string) => void;
+  /**
+   * Offer the application's channels to an AI agent in the browser,
+   * through WebMCP (default false). Each channel's view and commands
+   * become tools registered with `document.modelContext` once the app
+   * mounts, removed when it is disposed. A browser without WebMCP
+   * registers nothing. Pass `{ confirm }` to ask the person about a
+   * `@confirm` command with the application's own dialog instead of
+   * the browser's. `gesso-framework/agent` has the rest.
+   */
+  webmcp?: boolean | {
+    confirm?: (request: AgentConfirmation) => boolean | Promise<boolean>;
+  };
+  /**
+   * The app is the page (default false): a key pressed while nothing
+   * on the page has focus goes to the app, and the canvas takes focus.
+   *
+   * Keys reach the app through the canvas, which has focus only once
+   * something put it there. A page that is all app loads with focus on
+   * the body, so its shortcuts did nothing until the first click, and a
+   * person who pressed `c` or Mod+K straight away got nothing. An app
+   * embedded in a page with other things on it leaves this off: a key
+   * pressed on that page isn't its.
+   */
+  pageKeys?: boolean;
   /**
    * Receives errors thrown inside the render worker: while handling a
    * message, uncaught during a frame, from the renderer, or from a
@@ -5554,7 +5555,16 @@ declare class WorkerApp {
    * uses this; its own view of the application is nothing at all.
    */
   get appLogic(): WorkerHandle | undefined;
+  /**
+   * Opens a port to whatever the render worker serves under `key`, or
+   * returns undefined before `mount` has started it. The development
+   * agent bridge asks for `gesso:agent` this way; nothing else in the
+   * shell talks to the render worker except through its protocol.
+   */
+  openRenderPort(key: string): MessagePort | undefined;
   mount(host: HTMLElement | string): () => void;
+  /** Removes the WebMCP tools `webmcp` registered, if it did. */
+  private disconnectWebMcp;
   /**
    * An error the browser raised *at the worker object*, which is not
    * the same thing as the worker reporting one.
@@ -5828,6 +5838,10 @@ interface CreateAppOptions extends Omit<WorkerAppOptions, 'renderWorker'> {
 declare function createApp(options?: CreateAppOptions): WorkerApp;
 //#endregion
 //#region src/app/GessoAppBuilder.d.ts
+/** What `useWebMcp` takes besides a boolean: the app's own way to ask the person. */
+interface WebMcpChoice {
+  confirm?: (request: AgentConfirmation) => boolean | Promise<boolean>;
+}
 /**
  * Fluent builder for the single-thread configuration.
  */
@@ -5845,6 +5859,10 @@ declare class GessoAppBuilder {
   private mediaOptions;
   private fontDeclarations;
   private app;
+  /** The mounted app's channel registry, for the workers an agent port asks. */
+  private channelHandle;
+  private webmcpChoice;
+  private disconnectWebMcp;
   private colorSchemePreference;
   constructor(root: FrameworkChild | ComponentType);
   /**
@@ -5964,6 +5982,25 @@ declare class GessoAppBuilder {
    * Returns a dispose function that tears the app down.
    */
   mountSync(host: HTMLElement | string): () => void;
+  /**
+   * Offer the app's channels and screen to an AI agent in the browser,
+   * through WebMCP (default false). The single-thread form of
+   * `createApp({ webmcp })`: registered once `mountSync` has run,
+   * removed when the app is unmounted. Call before `mountSync`.
+   */
+  useWebMcp(choice?: boolean | WebMcpChoice): this;
+  /**
+   * Opens a port to what this app serves under `key`, or returns
+   * undefined before `mountSync`.
+   *
+   * The same question `WorkerApp.openRenderPort` answers, asked of the
+   * page instead of a render worker, because in this configuration the
+   * page is the thread that draws. It serves one thing, `gesso:agent`:
+   * the channels fed here, the workers behind them, and the screen.
+   * The agent code is loaded the first time one is opened.
+   */
+  openRenderPort(key: string): MessagePort | undefined;
+  private connectWebMcp;
 }
 //#endregion
 //#region src/app/createSyncApp.d.ts
@@ -6065,6 +6102,14 @@ interface GessoAppOptions {
  */
 declare class GessoApp {
   private readonly runtime;
+  /**
+   * The clock the runtime was given, its callback, and whether a frame
+   * is waiting on it: what `uiHost().flush` needs to run that frame now,
+   * since a background tab gets no animation frames to run it.
+   */
+  private clock;
+  private frameCallback;
+  private framePending;
   private readonly canvas;
   private readonly host;
   private readonly inputEnabled;
@@ -6085,6 +6130,7 @@ declare class GessoApp {
   private detachFullscreen;
   private fullscreen;
   private detachReducedMotion;
+  private detachContrast;
   /** Stops watching `prefers-color-scheme`; null while overridden. */
   private detachColorScheme;
   /** Stops watching `visualViewport` for the safe area and the keyboard. */
@@ -6092,6 +6138,12 @@ declare class GessoApp {
   /** The appearance this shell reports; watched or overridden. */
   private colorSchemePreference;
   constructor(options: GessoAppOptions);
+  /**
+   * 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
+   * pending frame now. See `uiSurface` in `gesso-framework/agent`.
+   */
+  uiHost(): UiHost;
   /** The runtime services a component in this app can inject. */
   get services(): ServiceRegistry;
   /**
@@ -7492,12 +7544,53 @@ declare class EditingService {
    * scroll already applied: a popup placed under the caret adds the
    * node's position on screen and nothing else.
    *
+   * `offset` asks about a caret at another character than the one the
+   * caret is at: the start of the word being completed, so its list
+   * stays put as the word grows. With an overlay's `anchorRect` and the
+   * field as its anchor, the list follows the field from then on.
+   *
    * Null when the node is not an editable, when it has not been laid
    * out yet, or before the runtime has wired the controller — all
    * three of which are "ask again next frame" rather than errors, and
    * all three of which happen during the frame a field first appears.
    */
-  caretRectOf(node: UiNode | null): CaretRect | null;
+  caretRectOf(node: UiNode | null, offset?: number): CaretRect | null;
+  /**
+   * Selects from `anchor` to `focus` and focuses the field the focus is
+   * in: within one field, or across the fields of an editing group (see
+   * `UiEditingGroup`). What an editor does after a command over a
+   * selection (making it bold, say) to leave it selected, since its
+   * fields can only select their own text.
+   *
+   * False when the two ends aren't editables of one group, or before
+   * the runtime has wired the controller.
+   */
+  select(anchor: UiTextPosition, focus: UiTextPosition): boolean;
+}
+//#endregion
+//#region src/app/ScrollService.d.ts
+/**
+ * Scrolling a node into view, for a component that moves a highlight
+ * rather than focus.
+ *
+ * Focus moved from the keyboard already brings its node into view. A
+ * highlight doesn't move focus: a combobox's arrows walk its list while
+ * the caret stays in the field, and a grid's cursor can do the same.
+ * The list has to follow the highlight all the same, and only the
+ * runtime knows where the scroll containers above a node are and how
+ * far each has to move. This is the asking.
+ */
+declare class ScrollService {
+  private scroller;
+  /** Installed by the runtime; without one nothing scrolls. */
+  setScroller(scroller: ((node: UiNode, padding: number) => void) | null): void;
+  /**
+   * Scrolls every container above `node` just enough that it's inside
+   * the container's viewport, `padding` pixels from the nearest edge.
+   * Nothing moves when it's visible already. Before the node has been
+   * laid out there is nowhere to scroll it to, and nothing happens.
+   */
+  scrollIntoView(node: UiNode, padding?: number): void;
 }
 //#endregion
 //#region src/app/FocusService.d.ts
@@ -7525,14 +7618,28 @@ declare class FocusService {
   readonly focused: InternalState<UiNode | null>;
   /** Whether focus is confined to a subtree by an open trap. */
   readonly trapped: InternalState<boolean>;
+  /**
+   * Whether the focus held is focus the keyboard can see: reached by Tab
+   * or an arrow key, or by code with no pointer since, rather than by a
+   * press. CSS's `:focus-visible`, for something other than a ring that
+   * should answer the keyboard and not the click that happened to focus
+   * the same control: a tooltip, say.
+   */
+  readonly focusVisible: InternalState<boolean>;
   private manager;
   private detach;
   /** Actions taken before the runtime installed a manager, in order. */
   private queued;
   /** Installed by the runtime; without one every action is queued. */
   setManager(manager: UiFocusManager | null): void;
-  /** Gives the node keyboard focus. Non-focusable nodes are ignored. */
-  focus(node: UiNode): void;
+  /**
+   * Gives the node keyboard focus. Non-focusable nodes are ignored.
+   *
+   * The node is scrolled into view, unless `options.preventScroll` asks
+   * for the page to stay where it is, as `element.focus({ preventScroll:
+   * true })` does in a browser.
+   */
+  focus(node: UiNode, options?: FocusOptions): void;
   /** Drops focus without moving it anywhere. */
   blur(): void;
   /** Moves focus to the next focusable node, wrapping around. */
@@ -7565,7 +7672,8 @@ interface EditingProxySink {
   compositionStart(): void;
   compositionUpdate(text: string, caret: number): void;
   compositionEnd(text: string): void;
-  paste(text: string): void;
+  /** Pasted text, and the clipboard's HTML when it held some. */
+  paste(text: string, html: string | null): void;
   /** The proxy lost focus to something outside the app. */
   blur(): void;
   /**
@@ -7677,7 +7785,7 @@ declare class EditingProxy {
    * the reason the field's semantics live here rather than on a second
    * element beside it.
    */
-  describe(record: UiSemanticsRecord | null): void;
+  describe(record: UiSemanticsRecord | null, activeDescendant?: string, controls?: string): void;
   dispose(): void;
   /** Puts the element where the caret is, so the IME window opens there. */
   private position;
@@ -7686,11 +7794,12 @@ declare class EditingProxy {
   private listen;
 }
 /**
- * Writes text to the system clipboard from the main thread. The async
- * API needs a secure context and, in some browsers, a recent user
- * gesture; the `execCommand` fallback covers the rest.
+ * Writes text to the system clipboard from the main thread, and answers
+ * whether it got there. The async API needs a secure context and, in
+ * some browsers, a recent user gesture; the `execCommand` fallback
+ * covers the rest. False means both refused. It never rejects.
  */
-declare function writeClipboard(text: string, doc?: Document): void;
+declare function writeClipboard(text: string, doc?: Document): Promise<boolean>;
 //#endregion
 //#region src/app/SemanticsMirror.d.ts
 /**
@@ -7722,7 +7831,7 @@ interface SemanticsMirrorSink {
    * nothing at all and the text is dropped before the application
    * sees it.
    */
-  paste?(text: string): void;
+  paste?(text: string, html: string | null): void;
 }
 /**
  * The editing proxy, as the mirror needs it.
@@ -7736,8 +7845,13 @@ interface SemanticsMirrorSink {
 interface EditingMirrorTarget {
   /** True while the proxy holds DOM focus for a focused editable. */
   readonly active: boolean;
-  /** Describes the focused editable on the proxy's element, or clears it. */
-  describe(record: UiSemanticsRecord | null): void;
+  /**
+   * Describes the focused editable on the proxy's element, or clears it.
+   * `activeDescendant` and `controls` are the DOM ids of the elements
+   * its record's `activeDescendant` and `controls` name, for
+   * `aria-activedescendant` and `aria-controls`.
+   */
+  describe(record: UiSemanticsRecord | null, activeDescendant?: string, controls?: string): void;
   /** Takes DOM focus back for the focused editable. */
   focus(): void;
 }
@@ -7786,6 +7900,12 @@ declare class SemanticsMirror {
   private applying;
   private focusedId;
   private disposed;
+  /**
+   * Prefixes every element's DOM id, which `aria-activedescendant`
+   * refers to. Per mirror, because two apps on one page have nodes with
+   * the same ids.
+   */
+  private readonly idPrefix;
   constructor(canvas: HTMLCanvasElement, sink: SemanticsMirrorSink, editing?: EditingMirrorTarget | null);
   /** The container, for tests and for a shell that wants to inspect it. */
   get element(): HTMLElement;
@@ -7799,6 +7919,8 @@ declare class SemanticsMirror {
   apply(update: UiSemanticsUpdate): void;
   dispose(): void;
   private upsert;
+  /** Hands the proxy the focused editable's record, with the DOM ids of its active descendant and what it controls. */
+  private describeEditing;
   private createElement;
   /** Writes a record onto its element as ARIA, clearing what it no longer says. */
   private describe;
@@ -8067,6 +8189,15 @@ declare class RenderWorkerApp {
    * console is the worker global's, and this class is what owns the
    * global.
    */
+  /**
+   * Answers an agent port with every channel this application can
+   * reach: the ones fed from this thread, and whatever each worker
+   * behind them serves, asked over a port of its own. Imported rather
+   * than loaded on demand: a worker built as an IIFE, which is Vite's
+   * default, cannot split off a chunk, and a dynamic import here failed
+   * every such build. Nothing runs until an agent asks.
+   */
+  private serveAgent;
   private setConsoleForwarding;
   private dispatch;
   /**
@@ -8080,5 +8211,5 @@ declare class RenderWorkerApp {
   private initialize;
 }
 //#endregion
-export { StorageOutcome as $, UiPropReport as $n, themeTokenCell as $r, FontFamilyDeclaration as $t, PresenceProps as A, Equality as Ai, AnimateOptions as An, PortHost as Ar, ChannelErrorEntry as At, PersistedState as B, ShellRequest as Bn, ChannelRegistry as Br, RuntimeErrorSource as Bt, FocusService as C, FanOutOptions as Ci, AudioAction as Cn, serveChannels as Cr, WorkerAppOptions as Ct, observeMediaQuery as D, ReadSource as Di, AudioService as Dn, APPLICATION_WORKER as Dr, createShellHistory as Dt, FindService as E, ComputedOptions as Ei, AudioSample as En, createChannelRegistry as Er, ShellHistoryOptions as Et, AudioSinkOutput as F, ShellFile as Fn, portHandle as Fr, FrameEntry as Ft, IndexedDbStorageOptions as G, ColorSchemePreference as Gn, Define as Gr, GessoRuntime as Gt, ShellStorage as H, ShellStorageOp as Hn, ProvidedChannel as Hr, ShellToRuntimeMessage as Ht, MediaSessionLike as I, ShellFileRequest as In, servePorts as Ir, PatchEntry as It, OpfsStorage as J, NodePathTarget as Jn, Output as Jr, RuntimeInput as Jt, OpfsDirectory as K, observeColorScheme as Kn, Inject as Kr, GessoRuntimeOptions as Kt, audioClock as L, ShellFileResult as Ln, workerHandle as Lr, UiTreeNode as Lt, AudioElementLike as M, ServiceRegistry as Mi, SpringOptions as Mn, isHubMessage as Mr, ConsoleEntry as Mt, AudioSink as N, UiDuration as Nn, isPortErrorMessage as Nr, DevtoolsEvent as Nt, observeReducedMotion as O, computed as Oi, AudioState as On, MessageEndpoint as Or, ActionCause as Ot, AudioSinkOptions as P, UiEasingChoice as Pn, isPortHandshake as Pr, DevtoolsRequest as Pt, StorageAdapter as Q, UiPropOrigin as Qn, ThemeTokenCell as Qr, FontFaceLike as Qt, FrameService as R, ShellFileType as Rn, findUnplainPath as Rr, UiTreeSnapshot as Rt, writeClipboard as S, FanOut as Si, parseUrl as Sn, serve as Sr, WorkerApp as St, TextService as T, ComputedCell as Ti, AudioRequest as Tn, ChannelRegistryHandle as Tr, ShellHistoryMode as Tt, ShellStorageOptions as U, ShellStorageResult as Un, provide as Ur, FrameMetrics as Ut, persisted as V, ShellService as Vn, ChannelSource as Vr, RuntimeToShellMessage as Vt, IndexedDbStorage as W, ColorScheme as Wn, Channel as Wr, FramePhaseTimings as Wt, OpfsWritable as X, UiNodeReport as Xn, ControlledValue as Xr, UiFramePhase as Xt, OpfsStorageOptions as Y, UiEnvironmentReport as Yn, ControlledOptions as Yr, UI_FRAME_PHASES as Yt, MemoryStorage as Z, UiOwnerReport as Zn, controlled as Zr, FontFaceDeclaration as Zt, EditingMirrorTarget as _, resource as _i, route as _n, isComponentElement as _r, createSyncApp as _t, UiRole as a, EachKey as ai, RouteAnswer as an, formatNodeReport as ar, UndoShortcutOptions as at, EditingProxy as b, FanCell as bi, buildPath as bn, pickKeys as br, createApp as bt, UiSemanticsPatch as c, debounced as ci, RouterRoutes as cn, ComponentHostResolver as cr, undoable as ct, markNow as d, Mutation as di, OutletProps as dn, OverlayEntry as dr, UndoTransaction as dt, bind as ei, FontFamilyStatus as en, UiSemanticsReport as er, StorageRead as et, measureSpan as f, mutate as fi, RouteContext as fn, OverlayPlacement as fr, ShellLocalStore as ft, renderRoot as g, ResourceStatus as gi, RouteTarget as gn, FrameworkChild as gr, GessoAppOptions as gt, RenderWorkerApp as h, ResourceState as hi, RouteOptions as hn, ComponentElement as hr, GessoApp as ht, UI_SEMANTIC_STATES as i, Each as ii, MediaService as in, formatNodePath as ir, storageReadValue as it, RouterOutlet as j, derive as ji, AnimationService as jn, WorkerHandle as jr, CommandEntry as jt, Presence as k, DeriveOptions as ki, AudioStatus as kn, PortHandshake as kr, ActionEntry as kt, UiSemanticsRecord$1 as l, throttled as li, RouterService as ln, ComponentHost as lr, UndoStack as lt, setPerformanceMarks$1 as m, ResourceOptions as mi, RouteGuard as mn, createComponent as mr, shellStorageDenied as mt, MARK_PREFIX as n, ShowProps as ni, FontService as nn, describeStream as nr, storageErrorMessage as nt, UiSemanticState as o, EachProps as oi, RouteMatch as on, formatStream as or, registerUndoShortcuts as ot, performanceMarksEnabled as p, Resource as pi, RouteDefinition as pn, OverlayService as pr, performShellStorage as pt, OpfsFileHandle as q, BoundStream as qn, Input as qr, RendererChoice as qt, UI_ROLES as r, show as ri, MediaOptions as rn, formatAge as rr, storageReadFailure as rt, UiSemanticsMap$1 as s, each as si, RouterHistorySink as sn, printPropValue as sr, UndoableOptions as st, EditingState$1 as t, Show as ti, FontHost as tn, UiStreamReport as tr, classifyStorageError as tt, markInstant as u, MutateOptions as ui, RouteState as un, OverlayLayer as ur, UndoStackOptions as ut, SemanticsMirror as v, SelectOptions as vi, to as vn, structurallyEqual as vr, GessoAppBuilder as vt, EditingService as w, fanOut as wi, AudioMetadata as wn, ChannelRegistration as wr, ShellHistory as wt, EditingProxySink as x, FanKey as xi, formatUrl as xn, ServedChannel as xr, AppLogicEndpoint as xt, SemanticsMirrorSink as y, select as yi, RouteParams as yn, pick as yr, CreateAppOptions as yt, PersistedOptions as z, ShellRecentFile as zn, requirePlainData as zr, treeText as zt };
-//# sourceMappingURL=index-C9FAI_Kt.d.ts.map
+export { StorageAdapter as $, UiOwnerReport as $n, Resource as $r, FontFaceDeclaration as $t, Presence as A, AudioState as An, Channel as Ar, ActionCause as At, PersistedOptions as B, ShellFileType as Bn, bind as Br, UiTreeSnapshot as Bt, FocusService as C, formatUrl as Cn, pickKeys as Cr, AppLogicEndpoint as Ct, FindService as D, AudioRequest as Dn, findUnplainPath as Dr, ShellHistoryMode as Dt, TextService as E, AudioMetadata as En, createChannelRegistry as Er, ShellHistory as Et, AudioSinkOptions as F, UiDuration as Fn, ControlledOptions as Fr, DevtoolsEvent as Ft, IndexedDbStorage as G, ShellStorageResult as Gn, EachKey as Gr, FrameMetrics as Gt, persisted as H, ShellRequest as Hn, ShowProps as Hr, RuntimeErrorSource as Ht, AudioSinkOutput as I, UiEasingChoice as In, ControlledValue as Ir, DevtoolsRequest as It, OpfsFileHandle as J, observeColorScheme as Jn, debounced as Jr, GessoRuntimeOptions as Jt, IndexedDbStorageOptions as K, ColorScheme as Kn, EachProps as Kr, FramePhaseTimings as Kt, MediaSessionLike as L, ShellFile as Ln, controlled as Lr, FrameEntry as Lt, RouterOutlet as M, AnimateOptions as Mn, Inject as Mr, ChannelErrorEntry as Mt, AudioElementLike as N, AnimationService as Nn, Input as Nr, CommandEntry as Nt, observeMediaQuery as O, AudioSample as On, requirePlainData as Or, ShellHistoryOptions as Ot, AudioSink as P, SpringOptions as Pn, Output as Pr, ConsoleEntry as Pt, MemoryStorage as Q, UiNodeReport as Qn, mutate as Qr, UiFramePhase as Qt, audioClock as R, ShellFileRequest as Rn, ThemeTokenCell as Rr, PatchEntry as Rt, writeClipboard as S, buildPath as Sn, pick as Sr, createApp as St, EditingService as T, AudioAction as Tn, ChannelRegistryHandle as Tr, WorkerAppOptions as Tt, ShellStorage as U, ShellService as Un, show as Ur, RuntimeToShellMessage as Ut, PersistedState as V, ShellRecentFile as Vn, Show as Vr, treeText as Vt, ShellStorageOptions as W, ShellStorageOp as Wn, Each as Wr, ShellToRuntimeMessage as Wt, OpfsStorageOptions as X, NodePathTarget as Xn, MutateOptions as Xr, RuntimeInput as Xt, OpfsStorage as Y, BoundStream as Yn, throttled as Yr, RendererChoice as Yt, OpfsWritable as Z, UiEnvironmentReport as Zn, Mutation as Zr, UI_FRAME_PHASES as Zt, EditingMirrorTarget as _, derive as _i, RouteOptions as _n, createComponent as _r, GessoAppOptions as _t, UiRole as a, select as ai, MediaOptions as an, formatAge as ar, storageReadValue as at, EditingProxy as b, to as bn, isComponentElement as br, WebMcpChoice as bt, UiSemanticsPatch as c, FanOut as ci, RouteMatch as cn, formatStream as cr, UndoableOptions as ct, markNow as d, ComputedCell as di, RouterService as dn, ComponentHost as dr, UndoStackOptions as dt, ResourceOptions as ei, FontFaceLike as en, UiPropOrigin as er, StorageOutcome as et, measureSpan as f, ComputedOptions as fi, RouteState as fn, OverlayLayer as fr, UndoTransaction as ft, renderRoot as g, Equality as gi, RouteGuard as gn, OverlayService as gr, GessoApp as gt, RenderWorkerApp as h, DeriveOptions as hi, RouteDefinition as hn, OverlayRect as hr, shellStorageDenied as ht, UI_SEMANTIC_STATES as i, SelectOptions as ii, FontService as in, describeStream as ir, storageReadFailure as it, PresenceProps as j, AudioStatus as jn, Define as jr, ActionEntry as jt, observeReducedMotion as k, AudioService as kn, ChannelRegistry as kr, createShellHistory as kt, UiSemanticsRecord$1 as l, FanOutOptions as li, RouterHistorySink as ln, printPropValue as lr, undoable as lt, setPerformanceMarks$1 as m, computed as mi, RouteContext as mn, OverlayPlacement as mr, performShellStorage as mt, MARK_PREFIX as n, ResourceStatus as ni, FontFamilyStatus as nn, UiSemanticsReport as nr, classifyStorageError as nt, UiSemanticState as o, FanCell as oi, MediaService as on, formatNodePath as or, UndoShortcutOptions as ot, performanceMarksEnabled as p, ReadSource as pi, OutletProps as pn, OverlayEntry as pr, ShellLocalStore as pt, OpfsDirectory as q, ColorSchemePreference as qn, each as qr, GessoRuntime as qt, UI_ROLES as r, resource as ri, FontHost as rn, UiStreamReport as rr, storageErrorMessage as rt, UiSemanticsMap$1 as s, FanKey as si, RouteAnswer as sn, formatNodeReport as sr, registerUndoShortcuts as st, EditingState$1 as t, ResourceState as ti, FontFamilyDeclaration as tn, UiPropReport as tr, StorageRead as tt, markInstant as u, fanOut as ui, RouterRoutes as un, ComponentHostResolver as ur, UndoStack as ut, SemanticsMirror as v, ServiceRegistry as vi, RouteTarget as vn, ComponentElement as vr, createSyncApp as vt, ScrollService as w, parseUrl as wn, ChannelRegistration as wr, WorkerApp as wt, EditingProxySink as x, RouteParams as xn, structurallyEqual as xr, CreateAppOptions as xt, SemanticsMirrorSink as y, route as yn, FrameworkChild as yr, GessoAppBuilder as yt, FrameService as z, ShellFileResult as zn, themeTokenCell as zr, UiTreeNode as zt };
+//# sourceMappingURL=index-Sff7qPGU.d.ts.map