@ixfx/components 0.15.4 → 0.16.0

package/bundle/index.d.ts

@@ -2656,6 +2656,92 @@ declare class TreeDataModel {
   _subscribe(callback: ModelSubscriber): () => void;
 }
 //#endregion
+//#region src/common/view-state/types.d.ts
+/**
+ * Shared view-state contract for list-like components.
+ *
+ * View state is everything about *how* a component is showing its data —
+ * selection, expansion, scroll, column sizes — kept separate from the data
+ * itself. It is plain JSON (arrays and records, never Sets or Maps) so a host
+ * can `JSON.stringify` it straight into whatever storage it likes. Components
+ * never persist it themselves; see `bindViewState()`.
+ *
+ * Every field is keyed by the stable item / column / group key, never by
+ * index, so state can be re-applied to data that has been rebuilt, re-sorted
+ * or streamed in over time. Keys the current data doesn't contain are kept
+ * as pending and applied once a matching item appears.
+ */
+/** Current schema version. Bump on breaking shape changes. */
+declare const VIEW_STATE_VERSION = 1;
+/** Name of the debounced change event every view-stateful component fires. */
+declare const VIEW_STATE_CHANGE = "view-state-change";
+/**
+ * Where the viewport is scrolled to. `anchor` is the preferred form: the key
+ * of the first visible item plus how far (px) the viewport top sits below
+ * that item's start. It survives items being inserted above. `top` / `left`
+ * are raw pixel offsets, used when there is no keyed item to anchor to.
+ */
+type ScrollState = {
+  readonly top: number;
+  readonly left?: number;
+  readonly anchor?: {
+    readonly key: string;
+    readonly offset: number;
+  };
+};
+/** Fields shared by all view states. Components extend this with their own. */
+type ViewStateBase = {
+  readonly v: typeof VIEW_STATE_VERSION;
+  /** Component kind, e.g. `tree-list`. Mismatched states are ignored. */
+  readonly kind: string;
+  /** Selected item keys. In `checked` interaction modes this is the checked set. */
+  readonly selected?: readonly string[];
+  /** Keyboard cursor (tickled / focused item) key. */
+  readonly focus?: string;
+  readonly scroll?: ScrollState;
+  /**
+   * Explicit open/closed choices for expandable things (tree branches, groups),
+   * keyed by item or group key. A missing key means "use the default".
+   */
+  readonly expanded?: Readonly<Record<string, boolean>>;
+};
+/**
+ * What triggered a `view-state-change`:
+ * - `user` — a direct interaction (click, key, drag, scroll)
+ * - `data` — the data changed and the component adjusted (e.g. pruned focus)
+ * - `restore` — pending state was applied to newly-arrived items, or `setViewState()` ran
+ */
+type ViewStateChangeReason = `user` | `data` | `restore`;
+type ViewStateChangeDetail<S extends ViewStateBase = ViewStateBase> = {
+  readonly state: S;
+  readonly reason: ViewStateChangeReason;
+};
+type ViewStateChangeEvent<S extends ViewStateBase = ViewStateBase> = CustomEvent<ViewStateChangeDetail<S>>;
+type GetViewStateOptions<S extends ViewStateBase> = {
+  /** Only include these fields (plus `v` and `kind`). Default: all. */
+  readonly include?: ReadonlyArray<Exclude<keyof S, `v` | `kind`>>;
+  /**
+   * Include pending state for keys not (yet) present in the data. Default
+   * `true` — leaving it out means a save made mid-rebuild overwrites the
+   * stored state with a partial one.
+   */
+  readonly includePending?: boolean;
+};
+/** Implemented by every component that supports view-state snapshot / restore. */
+type ViewStateful<S extends ViewStateBase = ViewStateBase> = {
+  /** Snapshot the current view state as plain JSON. */
+  getViewState: (options?: GetViewStateOptions<S>) => S;
+  /**
+   * Apply a (possibly partial) view state. Only fields present are applied;
+   * absent fields are left as they are. Keys not in the current data are kept
+   * pending and applied when matching items appear. A state whose `kind` or
+   * `v` doesn't match is ignored with a console warning.
+   */
+  setViewState: (state: Partial<S>) => void;
+  /** Drop all pending (not-yet-matched) state. */
+  clearPendingViewState: () => void;
+};
+//#endregion
 //#region src/common/tree-component.d.ts
 type TreeDndMode = `none` | `internal` | `external` | `both`;
 type TreeDropPosition = `before` | `after` | `inside`;
@@ -2794,6 +2880,11 @@ interface TreeComponentEventMap {
   'tree-drop': TreeDropEvent;
   'tree-drag-end': TreeDragEndEvent;
 }
+/** Options for `selectAll()` / `deselectAll()`. */
+type TreeSelectAllOptions = {
+  /** Only act on rows that are showing (e.g. Ctrl+A), not those in collapsed branches. */
+  readonly visibleOnly?: boolean;
+};
 /**
  * The common interface all tree-like components must implement.
  *
@@ -2807,7 +2898,12 @@ interface TreeComponentEventMap {
  * }
  * ```
  */
-interface TreeComponent extends EventTarget {
+/**
+ * Every tree component supports view-state snapshot / restore
+ * (`getViewState` / `setViewState` / `clearPendingViewState`, see
+ * `docs/infra-view-state.md`). Each narrows the state type with its own fields.
+ */
+interface TreeComponent extends EventTarget, ViewStateful {
   /**
    * Root node of the tree.
    * Set this directly for static/fully-known trees.
@@ -2862,13 +2958,13 @@ interface TreeComponent extends EventTarget {
   /** Clear the entire selection. */
   clearSelection: () => void;
   /**
-   * Select all visible items.
-   * In `checked` mode, checks the checkbox of each visible node (recursively toggling descendants).
-   * In all other modes, adds every visible selectable node to the selection.
+   * Select every selectable item — in tree components, including those inside
+   * collapsed branches (only filter matches while a filter is active). Pass
+   * `{ visibleOnly: true }` to limit it to the items showing.
    */
-  selectAll: () => void;
-  /** Deselect all items. In `checked` mode, unchecks each visible node. */
-  deselectAll: () => void;
+  selectAll: (options?: TreeSelectAllOptions) => void;
+  /** Mirror of `selectAll`: deselect the items it would select. */
+  deselectAll: (options?: TreeSelectAllOptions) => void;
   /**
    * Expand ancestors and select the node reached by following `keys` from the root's children.
    * Returns `true` if the path was found and applied.
@@ -2934,12 +3030,207 @@ declare function applyTreeDrop(root: TreeNode, ctx: TreeDropApplyContext): TreeN
 /** Build a synthetic `TreeDropTarget` for programmatic moves (see `TreeDataModel`). */
 declare function dropTargetFor(referenceKey: string, position: TreeDropPosition, index?: number): TreeDropTarget;
 //#endregion
+//#region src/common/view-state/bind.d.ts
+type ViewStateBinding<S extends ViewStateBase> = {
+  /** Return the previously saved state, or nothing. Called once, immediately. */
+  readonly load: () => Partial<S> | null | undefined;
+  /** Store the state. Called after debounced changes and on `pagehide`. */
+  readonly save: (state: S) => void;
+  /**
+   * Also save changes caused by restoring (pending state being applied).
+   * Default `false` — they only echo what `load()` returned.
+   */
+  readonly saveOnRestore?: boolean;
+};
+/** Whether `el` implements the view-state API. */
+declare function isViewStateful(el: unknown): el is ViewStateful & EventTarget;
+/**
+ * Wire a component's view state to storage the host controls. Loads and
+ * applies once, then saves on every `view-state-change` and when the page is
+ * hidden. Returns a function that stops saving.
+ *
+ * ```ts
+ * const stop = bindViewState(tree, {
+ *   load: () => JSON.parse(localStorage.getItem(`files`) ?? `null`),
+ *   save: s => localStorage.setItem(`files`, JSON.stringify(s)),
+ * });
+ * ```
+ */
+declare function bindViewState<S extends ViewStateBase>(el: ViewStateful<S> & EventTarget, binding: ViewStateBinding<S>): () => void;
+//#endregion
+//#region src/common/view-state/pending.d.ts
+/**
+ * Pure helpers for *pending* view state: keyed intent that is waiting for a
+ * matching item to appear in the data.
+ *
+ * Pending sets / maps are insertion-ordered (oldest first) and capped so a
+ * long-running app with churning data can't grow them without bound.
+ */
+/** Default cap on pending keys per facet. Oldest entries are dropped first. */
+declare const MAX_PENDING_KEYS = 2000;
+type PendingKeys = ReadonlySet<string>;
+type PendingFlags = ReadonlyMap<string, boolean>;
+declare const EMPTY_KEYS: PendingKeys;
+declare const EMPTY_FLAGS: PendingFlags;
+/**
+ * Split `keys` into those `has` reports present (to apply now) and those
+ * still missing (to keep pending). Returns the input set untouched as
+ * `missing` when nothing matched, so callers can cheaply detect "no change".
+ */
+declare function partitionKeys(keys: PendingKeys, has: (key: string) => boolean): {
+  readonly present: readonly string[];
+  readonly missing: PendingKeys;
+};
+/** As {@link partitionKeys}, for keyed boolean flags (e.g. expanded / collapsed). */
+declare function partitionFlags(flags: PendingFlags, has: (key: string) => boolean): {
+  readonly present: ReadonlyArray<readonly [string, boolean]>;
+  readonly missing: PendingFlags;
+};
+/** Keep at most `max` keys, dropping the oldest. */
+declare function capKeys(keys: PendingKeys, max?: number): PendingKeys;
+/** Keep at most `max` flags, dropping the oldest. */
+declare function capFlags(flags: PendingFlags, max?: number): PendingFlags;
+/** `flags` without `key` (same instance when absent). */
+declare function withoutFlag(flags: PendingFlags, key: string): PendingFlags;
+/** JSON record → flags map. Non-boolean values are ignored. */
+declare function flagsFromRecord(record: Readonly<Record<string, boolean>> | undefined): PendingFlags;
+/**
+ * Combine pending and live flags into one JSON record. Live entries win when
+ * a key is in both (it shouldn't be — matched keys leave pending).
+ */
+declare function flagsToRecord(...sources: Array<Iterable<readonly [string, boolean]>>): Record<string, boolean>;
+/** Pending keys followed by live keys, de-duplicated, as a JSON array. */
+declare function keysToArray(...sources: Array<Iterable<string>>): string[];
+/** Map `keys` to `true` flags — for components that record a plain key set. */
+declare function keysAsFlags(keys: Iterable<string>, value?: boolean): Iterable<readonly [string, boolean]>;
+//#endregion
+//#region src/common/view-state/scroll-anchor.d.ts
+/**
+ * Scroll-position helpers. A raw `scrollTop` is wrong as soon as anything is
+ * inserted above it, so view state records the first visible item's key plus
+ * an offset into it, and falls back to pixels only when nothing is keyed.
+ */
+type ScrollAxis = `vertical` | `horizontal`;
+/**
+ * Capture a {@link ScrollState} for a DOM-rendered list. `items` must be in
+ * visual order along `axis`; the first one whose far edge is below / right of
+ * the viewport start is the anchor (found by binary search).
+ */
+declare function captureElementScroll(viewport: HTMLElement, items: readonly Element[], getKey: (el: Element) => string | undefined, axis?: ScrollAxis): ScrollState;
+/**
+ * Scroll `viewport` so `item` sits at the anchor's offset. Returns `false`
+ * when the viewport can't scroll far enough yet (content still arriving),
+ * so the caller can keep the anchor pending.
+ */
+declare function restoreElementScroll(viewport: HTMLElement, item: Element, offset: number, axis?: ScrollAxis): boolean;
+/**
+ * Set the scroll offset along `axis`. Returns `false` when `target` is beyond
+ * the current scroll range (it is clamped and should be retried later).
+ */
+declare function scrollToOffset(viewport: HTMLElement, target: number, axis?: ScrollAxis): boolean;
+/**
+ * Anchor for a virtualised list with arithmetic row geometry: pass the first
+ * visible index, the key at that index and that row's start offset.
+ */
+declare function anchorFromRow(scrollOffset: number, key: string | undefined, rowStart: number, crossOffset?: number): ScrollState;
+/**
+ * Call `onIntent` the first time the user does something that scrolls or
+ * moves within `target` (wheel, touch, pointer on the scrollbar, navigation
+ * key). Used to cancel a pending scroll restore — the user's own scroll wins.
+ * Programmatic `scrollTop` writes do not trigger it. Returns a disposer.
+ */
+declare function onUserScrollIntent(target: EventTarget, onIntent: () => void): () => void;
+//#endregion
+//#region src/common/view-state/view-state-controller.d.ts
+type ViewStateControllerOptions<S extends ViewStateBase> = {
+  /** Component kind written into every state, e.g. `tree-list`. */
+  readonly kind: string;
+  /** Build the full current state (pending included). Called when the change event fires. */
+  readonly capture: () => S;
+  /** Trailing debounce for `view-state-change`, ms. Default 150. */
+  readonly debounceMs?: number;
+};
+/**
+ * Plumbing shared by every view-stateful component:
+ *
+ * - **change events** — `notify(reason)` coalesces changes into one debounced
+ *   `view-state-change` event (strongest reason wins: user > data > restore),
+ *   flushed immediately on disconnect so the last change is never lost.
+ * - **restore marking** — changes made inside `restoring(fn)` are reported as
+ *   `restore`, so persistence code can skip writing back what it just loaded.
+ * - **validation** — `accepts(state)` rejects a state for another kind / version.
+ * - **pending scroll** — a scroll position waiting for its anchor item (or for
+ *   enough content). Cancelled by the user's own scroll intent on the target
+ *   given to `observeScrollTarget()`.
+ *
+ * The component owns its facets (selection, expansion, columns) and decides
+ * what's pending; this controller only carries the cross-cutting parts.
+ */
+declare class ViewStateController<S extends ViewStateBase> implements ReactiveController {
+  #private;
+  constructor(host: ReactiveControllerHost & EventTarget, options: ViewStateControllerOptions<S>);
+  get kind(): string;
+  hostConnected(): void;
+  hostDisconnected(): void;
+  /** Record a change. Inside `restoring()` the reason is forced to `restore`. */
+  notify(reason?: ViewStateChangeReason): void;
+  /** Fire any pending change event now. */
+  flush(): void;
+  /** Run `fn` with every `notify()` inside it reported as `restore`. */
+  restoring<T>(fn: () => T): T;
+  /** True while inside `restoring()`. */
+  get isRestoring(): boolean;
+  /** Whether `state` is for this component kind and schema version. Warns when not. */
+  accepts(state: Partial<S> | null | undefined): state is Partial<S>;
+  /**
+   * Stamp `v` / `kind` onto `fields` and apply `include`. Components build
+   * their full field set and pass it through here from `getViewState()`.
+   */
+  shape(fields: Omit<S, `v` | `kind`>, options?: GetViewStateOptions<S>): S;
+  /**
+   * Watch `target` for user scroll intent (wheel / touch / pointer / nav key);
+   * any intent drops the pending scroll. Call again if the scroll container
+   * is replaced.
+   */
+  observeScrollTarget(target: EventTarget): void;
+  get pendingScroll(): ScrollState | undefined;
+  set pendingScroll(scroll: ScrollState | undefined);
+  /**
+   * Try the pending scroll with `apply`; it returns `true` once the position
+   * was fully reached (anchor present, content long enough), which clears it.
+   * Call after each render that may have added items.
+   */
+  applyPendingScroll(apply: (scroll: ScrollState) => boolean): void;
+  /**
+   * Call from the viewport's `scroll` listener. Ignored while a scroll restore
+   * is still pending; the event caused by a restore's own write is reported
+   * as `restore`, anything else as `user`.
+   */
+  notifyScroll(): void;
+}
+//#endregion
 //#region src/tree/types.d.ts
 /** Tree layout/display configuration (tree-specific, not shared). */
 type TreeConfig = {
   indent: number;
 };
 //#endregion
+//#region src/crumbs/crumb-view-state.d.ts
+/**
+ * Pure view-state helpers for `ixfx-crumb-navigation` (also used by
+ * `ixfx-flat-list`, whose location is the same kind of key path).
+ * See docs/infra-view-state.md.
+ */
+/**
+ * `ixfx-crumb-navigation` view state. The location *is* the selection (one
+ * node), so it is stored once, as the key path that reaches it — a path, not
+ * a lone key, so a saved location deep in a lazy tree can be loaded down to.
+ */
+type CrumbNavigationViewState = ViewStateBase & {
+  /** Keys from the root (excluded) down to the current location. `[]` = the root. */
+  readonly path?: readonly string[];
+};
+//#endregion
 //#region src/narrowed-text/types.d.ts
 type NarrowedTextItem = Readonly<{
   value: string;
@@ -3080,6 +3371,11 @@ declare class CrumbNavigationElement extends LitElement implements TreeComponent
   hideRoot: boolean;
   padEnding: boolean;
   withUp: boolean;
+  /**
+   * Whether restoring view state may call `loadChildren` to reach a saved
+   * location through unloaded branches (one load at a time). Default `true`.
+   */
+  restoreLoads: boolean;
   private tickled;
   select(node: TreeNode): void;
   deselect(_node: TreeNode): void;
@@ -3092,6 +3388,15 @@ declare class CrumbNavigationElement extends LitElement implements TreeComponent
     node: TreeNode;
     depth: number;
   }>;
+  /** Snapshot the location as a key path. Includes a saved location not reached yet. */
+  getViewState(options?: GetViewStateOptions<CrumbNavigationViewState>): CrumbNavigationViewState;
+  /**
+   * Go to a saved location. Keys not loaded yet are reached as they appear —
+   * via `loadChildren` when `restoreLoads` — moving through each loaded ancestor.
+   */
+  setViewState(state: Partial<CrumbNavigationViewState>): void;
+  clearPendingViewState(): void;
+  willUpdate(changedProps: PropertyValues): void;
   updated(changedProps: PropertyValues): void;
   connectedCallback(): void;
   disconnectedCallback(): void;
@@ -3374,6 +3679,12 @@ type DataGridColumn<R = unknown> = {
   button?: false | true | {
     icon?: string;
   };
+  /** Heading for this column in the built-in column menu; columns sharing a group are listed in one submenu. Ungrouped columns stay at the top level. */
+  group?: string;
+  /** Pixels added to the measured text width when auto-sizing (e.g. a thumbnail beside the text). Lets a `renderer` column be auto-sized. */
+  fixedExtraWidth?: number;
+  /** Custom content-width measure (px) for one row, used when auto-sizing. Lets a `renderer` column be auto-sized. */
+  measure?: (row: R, col: DataGridColumn<R>) => number;
 };
 type GlobalFormatter = (value: unknown, columnName: string, row: unknown) => unknown;
 /**
@@ -3415,6 +3726,31 @@ type DataGridGroupLabel = (groupKey: string, rows: readonly unknown[]) => string
 /** Whether the data-grid renders its built-in header column/group menu. */
 type DataGridColumnMenu = `auto` | `none`;
 //#endregion
+//#region src/data-grid/data-grid-view-state.d.ts
+/**
+ * Pure view-state helpers for `ixfx-data-grid`. The grid runs these whenever
+ * its rows or columns change, so state keyed to rows / columns that left the
+ * data goes pending and comes back when those keys reappear.
+ */
+/** Saved layout for one column, keyed by column key in {@link DataGridViewState.columns}. */
+type DataGridColumnViewState = {
+  readonly width?: number;
+  readonly visible?: boolean;
+  /** Rank among the saved columns (lower is further left). */
+  readonly order?: number;
+};
+/**
+ * `ixfx-data-grid` view state. `expanded` is keyed by group key; groups
+ * default to open, so a collapsed group is `false`.
+ */
+type DataGridViewState = ViewStateBase & {
+  readonly columns?: Readonly<Record<string, DataGridColumnViewState>>;
+  /** Sorted column + direction; `null` means unsorted. */
+  readonly sort?: DataGridSortState;
+  /** Group-by column key (`null` = ungrouped). Only recorded when `allowGrouping` is on. */
+  readonly groupBy?: string | null;
+};
+//#endregion
 //#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/slab.d.ts
 interface Slab {
   i16: Int16Array;
@@ -4494,14 +4830,30 @@ declare class DataGridElement extends LitElement {
   /**
    * Resize a single column, by key, to fit its contents (header label + every
    * row's formatted value), animating the width change smoothly. Only works
-   * for plain columns - one with a custom `renderer` can't be measured
-   * reliably from its raw value, so it's left untouched. Returns `false` (and
-   * does nothing) if the column doesn't exist, isn't resizable, or has a
-   * `renderer`.
+   * for plain columns, or `renderer` columns that supply `measure` or
+   * `fixedExtraWidth` - otherwise a renderer's output can't be measured
+   * reliably from the raw value, so it's left untouched. Returns `false` (and
+   * does nothing) if the column doesn't exist, isn't resizable, or has an
+   * unmeasurable `renderer`.
    */
   autoSizeColumn(key: string): boolean;
   private _columnResizeAnimationMs;
   private _onResizePointerDown;
+  /**
+   * Snapshot selection, cursor, scroll, collapsed groups, column layout, sort
+   * and (with `allowGrouping`) grouping as plain JSON, keyed by row / group /
+   * column key. Includes pending state for keys not currently present. Rows
+   * keyed by index (no `key` / `id` under the default `getRowKey`) are never
+   * recorded.
+   */
+  getViewState(options?: GetViewStateOptions<DataGridViewState>): DataGridViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; row and
+   * column keys that aren't defined yet are applied as they appear (including
+   * rows streamed in with `appendRows()`).
+   */
+  setViewState(state: Partial<DataGridViewState>): void;
+  clearPendingViewState(): void;
   getVisibleRange(): {
     startRow: number;
     endRow: number;
@@ -4692,6 +5044,21 @@ interface ListElementEventMap {
   'list-item-click': ListItemClickEvent;
 }
 //#endregion
+//#region src/detail-list/detail-list-view-state.d.ts
+/**
+ * Pure helpers behind `ixfx-detail-list`'s view state (see
+ * `docs/infra-view-state.md`). The component keeps only the wiring.
+ *
+ * - `selected` — selected item keys (in `checked` mode, the checked set:
+ *   `data-checked` is derived from the selection, not stored separately).
+ * - `expanded` — `{ [groupKey]: false }` for collapsed groups. Groups default
+ *   open, so only collapses are recorded; `true` re-opens.
+ * - `focus` — keyboard-cursor key.
+ * - `scroll` — horizontal: `left` plus an anchor on the top item of the first
+ *   visible column.
+ */
+type DetailListViewState = ViewStateBase;
+//#endregion
 //#region src/vertical-list/types.d.ts
 /**
  * `list-drag-over` / `list-drop`. `key` and `item` are `undefined` when the
@@ -4728,6 +5095,20 @@ type ListContextMenuEvent = CustomEvent<ListContextMenuDetail>;
 type ListEditCommitEvent = CustomEvent<ListEditCommitDetail>;
 type ListEditCancelEvent = CustomEvent<ListEditCancelDetail>;
 //#endregion
+//#region src/vertical-list/vertical-list-view-state.d.ts
+/**
+ * Pure helpers behind `ixfx-vertical-list`'s view state. The component runs
+ * them whenever its items change (light-DOM edits, `addItem` / `setItems` /
+ * `clearItems`, adapter rebuilds, virtual registry changes), so state keyed to
+ * rows that left the list goes pending and comes back when those keys reappear.
+ */
+/**
+ * `ixfx-vertical-list` view state. All fields are the shared base fields:
+ * `selected` (the checked set in `checked` mode), `focus` (keyboard cursor)
+ * and `scroll`. Keys are each row's `data-key` / `data-value`.
+ */
+type VerticalListViewState = ViewStateBase;
+//#endregion
 //#region src/editable-label/editable-label.d.ts
 type EditableMode = `label` | `editor`;
 type EntryMode = `free` | `text` | `number` | `percent`;
@@ -5021,6 +5402,18 @@ declare class VerticalListElement extends LitElement {
   focusKey(key: string): void;
   /** The item carrying this `data-key`, or `undefined`. */
   getItemByKey(key: string): Element | undefined;
+  /**
+   * Snapshot selection (the checked set in `checked` mode), keyboard cursor
+   * and scroll as plain JSON keyed by `data-key` / `data-value`. Includes
+   * pending state for keys not currently in the list.
+   */
+  getViewState(options?: GetViewStateOptions<VerticalListViewState>): VerticalListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * not in the list yet are applied as matching rows appear.
+   */
+  setViewState(state: Partial<VerticalListViewState>): void;
+  clearPendingViewState(): void;
   /**
    * Keys of items currently intersecting the viewport — for prioritising
    * viewport-first work (e.g. metadata/thumbnail fetches). A rect-intersection
@@ -5324,6 +5717,18 @@ declare class DetailListElement extends LitElement {
   /** Move the cursor to the item with this key and scroll it into view. */
   focusKey(key: string): void;
   selectedFilter(kind: `selected` | `checked` | `either`): Generator<Element>;
+  /**
+   * Snapshot selection, collapsed groups, cursor and scroll as plain JSON,
+   * keyed by item / group key. Includes pending state for keys not present.
+   */
+  getViewState(options?: GetViewStateOptions<DetailListViewState>): DetailListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys not
+   * in the data are applied as matching items arrive (rebuilds, provider
+   * batches, `addItem`, light-DOM appends).
+   */
+  setViewState(state: Partial<DetailListViewState>): void;
+  clearPendingViewState(): void;
   /** Groups in display order (empty when ungrouped). */
   get groups(): readonly ListGroupInfo[];
   /** Collapse or expand one group. Fires `list-group-toggle` when the state changes. */
@@ -5388,6 +5793,7 @@ declare global {
 interface DetailListElementEventMap extends ListElementEventMap, ListGroupEventMap {
   'detail-list-viewport-change': ListViewportChangeEvent;
   'list-native-drag-start': ListNativeDragStartEvent<Element>;
+  'view-state-change': ViewStateChangeEvent<DetailListViewState>;
 }
 //#endregion
 //#region src/dock/types.d.ts
@@ -5398,6 +5804,15 @@ type DockLayout = {
   readonly root: DockNode;
 };
 type DockNode = DockSplitNode | DockStackNode;
+/**
+ * `ixfx-dock-host` view state (`kind: 'dock-host'`). `layout` is the whole
+ * dock tree — splits and their sizes, stacks with tab order, active tab and
+ * collapse — keyed by panel id. Panels it names that the host doesn't hold
+ * yet keep their place and slot in when they arrive.
+ */
+type DockHostViewState = ViewStateBase & {
+  readonly layout?: DockLayout;
+};
 /**
  * N-ary split node, rendered as a single `ixfx-split-layout`.
  * `direction` uses the element's flexbox sense: `row` places children
@@ -5749,6 +6164,24 @@ interface LayoutSnapshot {
   version: 1;
   root: SnapshotNode;
 }
+/**
+ * Saved size of one direct child of an `ixfx-split-layout`, keyed by the
+ * child's `id` in {@link SplitLayoutViewState.layout}.
+ */
+interface SplitPanelViewState {
+  /**
+   * Share (0..1) of the weighted flow. For a collapsed panel, the share it
+   * returns to when expanded.
+   */
+  readonly weight: number;
+  /** Collapsed to the gutter. Absent ⇒ expanded. */
+  readonly collapsed?: boolean;
+}
+/** `ixfx-split-layout` view state (`kind: 'split-layout'`). */
+type SplitLayoutViewState = ViewStateBase & {
+  /** Direct children with an author-given `id`, keyed by that id. */
+  readonly layout?: Readonly<Record<string, SplitPanelViewState>>;
+};
 interface PanelInfo {
   id: string;
   el: HTMLElement;
@@ -5814,10 +6247,17 @@ declare global {
 //#endregion
 //#region src/split-layout/split-layout.d.ts
 declare class SplitLayoutElement extends LitElement {
+  #private;
   direction: Axis;
   sizes: string;
   gutterSize: string;
   snap: string;
+  /**
+   * Forget the saved size of a child that leaves instead of re-applying it
+   * when a child with that id returns. For hosts that drive child sizes
+   * themselves (e.g. `ixfx-dock-host`, whose leaf ids are positional).
+   */
+  forgetAbsent: boolean;
   private _model;
   private _resizing;
   private _groupEl?;
@@ -5830,9 +6270,20 @@ declare class SplitLayoutElement extends LitElement {
   firstUpdated(): void;
   private _setupObserver;
   private _rebuildModel;
+  private _writeCollapsedAttributes;
   get panels(): PanelInfo[];
-  getLayout(): LayoutSnapshot | null;
-  setLayout(s: LayoutSnapshot): void;
+  /**
+   * Snapshot the size and collapse of every direct child with an `id`.
+   * Includes saved entries for children not currently slotted.
+   */
+  getViewState(options?: GetViewStateOptions<SplitLayoutViewState>): SplitLayoutViewState;
+  /**
+   * Apply saved sizes. Entries for children that aren't slotted yet are kept
+   * and applied when a child with that id appears. Present children without
+   * an entry keep their relative size.
+   */
+  setViewState(state: Partial<SplitLayoutViewState>): void;
+  clearPendingViewState(): void;
   getSizes(_groupId?: string): Record<string, number>;
   setSizes(weights: number[] | Record<string, number>, _groupId?: string): void;
   collapse(idOrEl: string | HTMLElement): void;
@@ -6023,6 +6474,7 @@ interface DockHostElementEventMap {
   'dock-panel-drag-in': DockDragBoundaryEvent;
 }
 declare class DockHostElement extends LitElement {
+  #private;
   /** Initial layout as `DockLayout` JSON. Absent ⇒ all pooled panels go into one root stack. */
   layout: string | null;
   /**
@@ -6068,7 +6520,7 @@ declare class DockHostElement extends LitElement {
   /**
    * Placement policy per named leaf: `{ allow, deny }` kind sets plus an
    * `allowEdgeSplit` gate (default `true`). Host-level only — never serialized
-   * into the layout, but kept across `loadLayout()` calls. Existing panels are
+   * into the layout, but kept across `setViewState()` calls. Existing panels are
    * grandfathered; rules govern future placements (drags, `addPanel`,
    * re-homing). See {@link setLeafPlacementPolicy}.
    */
@@ -6078,7 +6530,7 @@ declare class DockHostElement extends LitElement {
   private _junctionsRaf;
   private _hostResizeObserver;
   /**
-   * Bumped on every `loadLayout()`. Stamped onto each rendered
+   * Bumped on every layout restore (`setViewState()`). Stamped onto each rendered
    * `ixfx-split-layout` as `data-dock-gen`, so `_foldLiveWeights` can tell a
    * split that still carries the *previous* generation's live weights (its
    * async re-render hasn't landed yet) from one that's caught up — and skip
@@ -6128,9 +6580,29 @@ declare class DockHostElement extends LitElement {
   private _observePanel;
   private _unobservePanel;
   private _syncPool;
-  /** Serialize the current layout, folding live split weights from the DOM. */
-  saveLayout(): DockLayout;
-  loadLayout(layout: DockLayout): void;
+  /**
+   * Snapshot the layout (live split weights folded in from the DOM). With
+   * `includePending` (default), panels the restored layout names but the
+   * host doesn't hold yet are kept in place; without it they are left out.
+   */
+  getViewState(options?: GetViewStateOptions<DockHostViewState>): DockHostViewState;
+  /**
+   * Restore a layout. Panels it names that aren't in the host yet keep their
+   * place (shown as a placeholder tab) and slot in when they arrive — as a
+   * light-DOM child, or via `addPanel()` without a target. Pooled panels it
+   * doesn't name are appended to the first stack admitting their kind.
+   */
+  setViewState(state: Partial<DockHostViewState>): void;
+  /**
+   * Placeholders are part of the layout tree rather than a separate pending
+   * set, so there is nothing to clear here: remove a placeholder with
+   * `removePanel(id)`.
+   */
+  clearPendingViewState(): void;
+  /** The current layout, folding live split weights from the DOM. */
+  private _captureLayout;
+  /** Whether `panelId` is in the model only as a placeholder from a restored layout. */
+  private _isPlaceholder;
   /**
    * Dock a panel. Returns false (without touching the DOM) when the
    * explicitly targeted container denies the panel's `kind`.
@@ -6170,7 +6642,7 @@ declare class DockHostElement extends LitElement {
    * {@link setLeafPlacementPolicy}'s `allowEdgeSplit` (default `true`).
    * Pass `[]` to seal the leaf (nothing admitted). Warns when no stack
    * currently carries `name`, but the rule is still stored and applies once
-   * one appears. Rules are host policy: kept across `loadLayout()`, never
+   * one appears. Rules are host policy: kept across `setViewState()`, never
    * serialized.
    */
   setLeafExclusiveContents(name: string, kinds: readonly string[]): void;
@@ -6196,7 +6668,7 @@ declare class DockHostElement extends LitElement {
    * unconstrained* leaf — the policy is not propagated to it.
    *
    * Warns when no stack currently carries `name`; the policy is stored and
-   * applies once one appears. Host policy: kept across `loadLayout()`, never
+   * applies once one appears. Host policy: kept across `setViewState()`, never
    * serialized.
    */
   setLeafPlacementPolicy(name: string, policy: DockLeafPlacementPolicy): void;
@@ -6321,6 +6793,12 @@ declare class DockHostElement extends LitElement {
   /** Fold live weights from each rendered `ixfx-split-layout` into the model. */
   private _foldLiveWeights;
   private _onSplitWeightsChanged;
+  /**
+   * Splits inside the dock are an implementation detail: keep their own
+   * `view-state-change` from escaping (retargeted, it would look like ours).
+   * Events from panel content pass through untouched.
+   */
+  private _onInnerViewState;
   private _onSplitCollapsed;
   private _onSplitClose;
   private _onTabChange;
@@ -6680,6 +7158,15 @@ type FlatListEditCommitDetail = {
 type FlatListEditCancelDetail = {
   readonly node: TreeNode;
 };
+/**
+ * `ixfx-flat-list` view state. `selected`, `focus` and `scroll` belong to the
+ * level at `path`; they are held until that level is shown, then handed to
+ * the inner list.
+ */
+type FlatListViewState = ViewStateBase & {
+  /** Keys from the root (excluded) to the level shown — the `path` property. */
+  readonly path?: readonly string[];
+};
 type FlatListNavigateEvent = CustomEvent<FlatListNavigateDetail>;
 type FlatListSelectEvent = CustomEvent<FlatListSelectDetail>;
 type FlatListActivateEvent = CustomEvent<FlatListActivateDetail>;
@@ -6798,6 +7285,18 @@ declare class FlatListElement extends LitElement {
   navigateInto(key: string): boolean;
   /** Move to the parent level. Returns false at the root. */
   navigateUp(): boolean;
+  /**
+   * Snapshot the level shown (`path`) and, from the inner list, its selection,
+   * cursor and scroll. Includes a saved level not reached yet.
+   */
+  getViewState(options?: GetViewStateOptions<FlatListViewState>): FlatListViewState;
+  /**
+   * Go to a saved level. Keys not loaded yet are reached as they load (the
+   * level shown is always loaded); `selected` / `focus` / `scroll` apply once
+   * that level is shown.
+   */
+  setViewState(state: Partial<FlatListViewState>): void;
+  clearPendingViewState(): void;
   disconnectedCallback(): void;
   protected willUpdate(changed: PropertyValues): void;
   protected updated(changed: PropertyValues): void;
@@ -7364,6 +7863,29 @@ declare class ListSelectionController<T> {
    * fires once if anything changed.
    */
   removeKeys(keys: Iterable<string>, resolve: (key: string) => T | undefined): void;
+  /** Selected keys waiting for their items to appear. */
+  get pendingKeys(): PendingKeys;
+  /**
+   * Restore a selection by key: keys that resolve are selected now (one
+   * `onChange`), the rest are kept pending for `resolvePending()`. Replaces
+   * any previous selection and pending keys. Unlike `selectKeys`, this works
+   * in `selectionMode="none"` only to the extent of holding keys pending.
+   */
+  restoreKeys(keys: Iterable<string>, resolve: (key: string) => T | undefined): void;
+  /**
+   * Select pending keys whose items now resolve (call after items are added
+   * or rebuilt). Fires `onChange` once when anything was selected; returns
+   * whether it did.
+   */
+  resolvePending(resolve: (key: string) => T | undefined): boolean;
+  /**
+   * Silently deselect `items` that left the data, keeping their keys pending
+   * so they are re-selected if the same keys come back (data reset, re-fetch).
+   * No `onChange`; returns whether the selection changed.
+   */
+  demote(items: Iterable<T>): boolean;
+  /** Drop pending keys without touching the live selection. */
+  clearPending(): void;
   /** Route a click on `item` according to the current interaction mode. */
   handleClick(item: T, gesture: ListSelectionGesture): void;
   /** Route a Space keypress on `item` according to the current interaction mode. */
@@ -7378,7 +7900,8 @@ declare class ListSelectionController<T> {
   remap(fn: (item: T) => T): void;
   /**
    * Hard reset: empty the selection and clear the anchor without firing
-   * `onChange` (e.g. when all items are removed).
+   * `onChange` (e.g. when all items are removed). Keyed selected items become
+   * pending, so a rebuilt item set re-selects them via `resolvePending()`.
    */
   reset(): void;
   /**
@@ -7389,6 +7912,46 @@ declare class ListSelectionController<T> {
   seed(items: Iterable<T>, anchor?: T): void;
 }
 //#endregion
+//#region src/interaction/scroll-hover-guard.d.ts
+/**
+ * Scroll-hover guard: tells a hover-driven cursor to hold still while a scroll
+ * gesture moves items beneath a stationary pointer.
+ *
+ * With virtualised / scrolling lists, wheel or trackpad scrolling slides items
+ * under the pointer and the browser fires `pointerenter` on them from its
+ * (throttled) post-scroll hit-test. Following those enters makes the hover
+ * cursor trail the content. The guard opens a suppression window on scroll and
+ * closes it on the next *real* pointer movement or when the pointer leaves.
+ *
+ * While suppressed, `host` carries a `data-scroll-hover-suppress` attribute so
+ * CSS `:hover` highlights can be gated too.
+ */
+type ScrollHoverGuard = Readonly<{
+  /** True while hover-driven cursor moves should be ignored. */
+  suppressed: () => boolean;
+  /** Call from the scroll container's `scroll` (and any manual-scroll wheel) handler. */
+  onScroll: () => void;
+  /** Call from a `pointermove` listener covering the list. */
+  onPointerMove: (e: PointerEvent) => void;
+  /** Call when the pointer leaves the list. */
+  onPointerLeave: () => void;
+  /** Close any open suppression window (e.g. on disconnect or opt-out). */
+  end: () => void;
+}>;
+type ScrollHoverGuardConfig = Readonly<{
+  host: HTMLElement;
+  /** Whether suppression is enabled; read on every scroll. */
+  enabled: () => boolean;
+  /**
+   * Called when real pointer movement ends suppression, with the pointer
+   * position. The enter that accompanied that movement may have been swallowed,
+   * so the consumer should re-hover whatever item is now under the pointer.
+   */
+  onResume?: (clientX: number, clientY: number) => void;
+}>;
+declare const SCROLL_HOVER_SUPPRESS_ATTR = "data-scroll-hover-suppress";
+declare function createScrollHoverGuard(config: ScrollHoverGuardConfig): ScrollHoverGuard;
+//#endregion
 //#region src/interaction/tickled-controller.d.ts
 /**
  * Represents an item that can be tickled (highlighted via hover or keyboard navigation)
@@ -7817,6 +8380,23 @@ interface GridListFullElementEventMap extends GridListElementEventMap {
   'list-native-drag-start': ListNativeDragStartEvent;
 }
 //#endregion
+//#region src/grid-list/grid-list-view-state.d.ts
+/**
+ * Pure view-state helpers for `ixfx-grid-list`. The component runs
+ * {@link reconcileGroups} whenever its item set or grouping changes, so a
+ * group's collapsed state survives the group disappearing (data reset,
+ * filter, streaming) and comes back when the group does. Scroll is captured
+ * and restored arithmetically from the virtual layout, along the main axis
+ * (`scrollLeft` in `row` orientation, `scrollTop` otherwise).
+ */
+/**
+ * `ixfx-grid-list` view state. All fields are the shared base fields:
+ * `selected` (item keys), `focus` (keyboard cursor key), `scroll`, and
+ * `expanded` (group key → open; groups default open, so only `false` entries
+ * are ever recorded).
+ */
+type GridListViewState = ViewStateBase;
+//#endregion
 //#region src/grid-list/grid-list.d.ts
 declare class GridListElement<T = unknown> extends LitElement {
   #private;
@@ -7830,18 +8410,17 @@ declare class GridListElement<T = unknown> extends LitElement {
    */
   disableHoverTickle: boolean;
   /**
-   * Ignore hover-target changes caused by scrolling. With virtualisation, a
-   * wheel / trackpad gesture replaces the cell beneath a stationary pointer,
-   * and the freshly rendered cell's `pointerenter` would move the cursor and
-   * emit `list-tickle` even though the pointer never moved. With this set,
-   * `pointerenter`-driven tickling is suppressed while a scroll gesture is
-   * active — the host also carries a `data-scroll-hover-suppress` attribute
-   * that gates the CSS `:hover` highlight, so the visual cursor holds still
-   * too. Hover resumes on the next real pointer movement, or after the pointer
-   * leaves and re-enters the list. Click selection, keyboard navigation, and
-   * `focusKey()` are unaffected.
-   */
-  disableScrollHoverTickle: boolean;
+   * Let hover follow cells that scroll beneath a stationary pointer. Off by
+   * default: with virtualisation, a wheel / trackpad gesture replaces the cell
+   * beneath the pointer, and following its `pointerenter` would move the
+   * cursor and emit `list-tickle` even though the pointer never moved. While a
+   * scroll gesture is active those enters are ignored and the host carries a
+   * `data-scroll-hover-suppress` attribute that gates the CSS `:hover`
+   * highlight, so the visual cursor holds still too. Hover resumes on the next
+   * real pointer movement, or after the pointer leaves the list. Click
+   * selection, keyboard navigation, and `focusKey()` are unaffected.
+   */
+  scrollHoverTickle: boolean;
   itemSize: number;
   gap: number;
   /**
@@ -8031,8 +8610,9 @@ declare class GridListElement<T = unknown> extends LitElement {
   removeSelectedKeys(keys: Iterable<string>): void;
   /**
    * Data mode: replace the whole item array. Selection and cursor keep any key
-   * that is still present; keys that vanish are dropped (one `list-select`).
-   * A no-op in element mode.
+   * that is still present; keys that vanish are deselected silently and held
+   * as pending view state, so they come back if the key reappears. A no-op in
+   * element mode.
    */
   setItems(items: readonly T[]): void;
   /**
@@ -8049,19 +8629,36 @@ declare class GridListElement<T = unknown> extends LitElement {
    */
   updateItem(key: string, item: T): void;
   /**
-   * Data mode: remove the items carrying these keys. Removed keys are dropped
-   * from selection and cursor (via the `items` change). A no-op in element mode.
+   * Data mode: remove the items carrying these keys. Removed keys leave the
+   * selection and cursor silently (via the `items` change) and are held as
+   * pending view state. A no-op in element mode.
    */
   removeItems(keys: Iterable<string>): void;
   /**
    * Data mode: drop every item. Selection and cursor are reset and one
-   * `list-select` with empty sets is emitted. A no-op in element mode.
+   * `list-select` with empty sets is emitted; their keys are held as pending
+   * view state, so re-adding the same keys restores them. A no-op in element
+   * mode.
    */
   clearItems(): void;
   /** Move the cursor to the item with this key and scroll it into view. */
   focusKey(key: string): void;
   /** The key of the item under the cursor, or `undefined`. */
   get tickledKey(): string | undefined;
+  /**
+   * Snapshot selection, collapsed groups, keyboard cursor and scroll as plain
+   * JSON, keyed by item / group key. Includes pending state for keys not
+   * currently present unless `includePending: false`.
+   */
+  getViewState(options?: GetViewStateOptions<GridListViewState>): GridListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * (items or groups) that aren't present yet are applied as they appear.
+   * Restored selection fires `list-select`.
+   */
+  setViewState(state: Partial<GridListViewState>): void;
+  /** Drop view state still waiting for its keys to appear. */
+  clearPendingViewState(): void;
   /** Element mode: the light-DOM element carrying `key`, or `undefined`. */
   getItem(key: string): Element | undefined;
   /** Element mode: the light-DOM element at effective index `index`. */
@@ -8261,6 +8858,10 @@ interface GroupedItemListerElement<T> {
   addEventListener: (<K extends keyof GroupedItemListerElementEventMap<T>>(type: K, listener: (this: GroupedItemListerElement<T>, event: GroupedItemListerElementEventMap<T>[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
 }
 //#endregion
+//#region src/tree/tree-view-state.d.ts
+/** `ixfx-tree-list` view state. All fields are the shared base fields. */
+type TreeListViewState = ViewStateBase;
+//#endregion
 //#region src/tree/tree-base.d.ts
 /**
  * `auto` windows the list once it has more than `virtualizeThreshold` visible
@@ -8289,6 +8890,13 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
   get selectedNodes(): ReadonlySet<TreeNode>;
   filterPredicate: TreeFilterPredicate | undefined;
   disableKeyboardNavigation: boolean;
+  /**
+   * Let hover follow rows that scroll beneath a stationary pointer. Off by
+   * default: while a scroll gesture is active, row `pointerenter` is ignored so
+   * the hover cursor holds still instead of trailing the content. Hover resumes
+   * on the next real pointer movement, or when the pointer leaves the tree.
+   */
+  scrollHoverTickle: boolean;
   registry: CommandRegistry<unknown> | undefined;
   /**
    * Space-separated subset of `navigate select filter` — limits which
@@ -8338,6 +8946,12 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
   applyInternalDrop: boolean;
   /** Immutable: replace via `#setExpanded` so the flat-row cache is invalidated. */
   protected _expandedKeys: ReadonlySet<string>;
+  /**
+   * Whether restoring view state may call `loadChildren` / `model` to open
+   * saved branches that aren't loaded yet (one at a time, cascading down the
+   * saved path). Default `true`.
+   */
+  restoreLoads: boolean;
   /** Bumped whenever `_selectedNodes` content may have changed. */
   protected _selectionVersion: number;
   /**
@@ -8352,6 +8966,13 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
   /** Depths at which any loaded node carries an icon (stable across expansion). */
   protected get _depthsWithIcons(): ReadonlySet<number>;
   protected tickled: TickledController<string>;
+  /**
+   * Row `pointerenter` funnel: moves the hover cursor unless a scroll gesture
+   * is sliding rows beneath a stationary pointer (see `scrollHoverTickle`).
+   * Subclasses rendering their own rows should call this rather than the
+   * tickled controller directly.
+   */
+  protected _handleRowPointerEnter(node: TreeNode, depth: number): void;
   protected _focusedDepth: number;
   /** Incremental search (navigate / select / filter). See `docs/infra-incremental.md`. */
   readonly search: ListSearchController<{
@@ -8381,11 +9002,31 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
   disconnectedCallback(): void;
   getConfig(): TreeConfig;
   setConfig(config: Partial<TreeConfig>): void;
+  /**
+   * Snapshot selection, expansion, cursor and scroll as plain JSON, keyed by
+   * `item.key`. Includes pending state for keys not currently loaded.
+   */
+  getViewState(options?: GetViewStateOptions<TreeListViewState>): TreeListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * that aren't loaded yet are applied as they appear — including via
+   * `loadChildren` / `model` for saved-open branches when `restoreLoads`.
+   */
+  setViewState(state: Partial<TreeListViewState>): void;
+  clearPendingViewState(): void;
   select(node: TreeNode): void;
   deselect(node: TreeNode): void;
   clearSelection(): void;
-  selectAll(): void;
-  deselectAll(): void;
+  /**
+   * Select every selectable node in the tree, or only the matches while a
+   * `filterPredicate` is active. Nodes inside collapsed branches are included;
+   * unloaded (lazy) children are not. With `visibleOnly`, only rows that are
+   * showing are selected (Ctrl+A). In `checked` mode checking a row checks its
+   * descendants, so `visibleOnly` makes no difference there.
+   */
+  selectAll(options?: TreeSelectAllOptions): void;
+  /** Mirror of {@link selectAll}: deselect the same set of nodes it would select. */
+  deselectAll(options?: TreeSelectAllOptions): void;
   /**
    * Expand every already-loaded branch in a single update. With `maxDepth`,
    * only branches at depth < `maxDepth` are expanded (the root's children are
@@ -8963,6 +9604,29 @@ type HyperbolicFocusDetail = {
 };
 type HyperbolicFocusEvent = CustomEvent<HyperbolicFocusDetail>;
 //#endregion
+//#region src/hyperbolic-tree/hyperbolic-view-state.d.ts
+/**
+ * Pure view-state helpers for `ixfx-hyperbolictree-list`. The element re-runs
+ * {@link reconcileHyperbolicViewState} whenever its structure changes (new
+ * `root` / `model`, model invalidation, a lazy load), so state keyed to nodes
+ * that left the tree goes pending and comes back when those keys reappear.
+ */
+/**
+ * `ixfx-hyperbolictree-list` view state.
+ * - `selected` / `focus` — the shared base fields (`focus` is the keyboard
+ *   cursor, not the centred node).
+ * - `center` — key path from the root's children down to the centred node
+ *   (`[]` = the root). A path, not a lone key, because keys may repeat across
+ *   branches here (e.g. `readme.md`), and so a deep centre in lazily-loaded
+ *   data can be restored by loading each ancestor in turn. A free pan away
+ *   from the centred node is transient and not saved.
+ * - `zoom` — the visual magnification (the `zoom` property).
+ */
+type HyperbolicTreeListViewState = ViewStateBase & {
+  readonly center?: readonly string[];
+  readonly zoom?: number;
+};
+//#endregion
 //#region src/hyperbolic-tree/render-utils.d.ts
 /**
  * How nodes are drawn:
@@ -9126,6 +9790,11 @@ declare class HyperbolicTreeListElement extends LitElement implements TreeCompon
    * repeats keys across branches still focuses the node actually clicked.
    */
   private _focusId;
+  /**
+   * Whether restoring a saved `center` may call `loadChildren` / `model` to
+   * load the ancestors on its path (one at a time, cascading down). Default `true`.
+   */
+  restoreLoads: boolean;
   /**
    * Canonical → screen projection overriding the settled "focus at the
    * center" view — set per-frame while a focus change animates, and by
@@ -9153,6 +9822,7 @@ declare class HyperbolicTreeListElement extends LitElement implements TreeCompon
   private _hostSize;
   connectedCallback(): void;
   disconnectedCallback(): void;
+  protected willUpdate(changedProps: PropertyValues): void;
   protected updated(changedProps: PropertyValues): void;
   select(node: TreeNode): void;
   deselect(node: TreeNode): void;
@@ -9188,6 +9858,18 @@ declare class HyperbolicTreeListElement extends LitElement implements TreeCompon
     node: TreeNode;
     depth: number;
   }>;
+  /**
+   * Snapshot selection, centred node, keyboard cursor and zoom as plain JSON,
+   * keyed by `item.key`. Includes pending state for keys not currently loaded.
+   */
+  getViewState(options?: GetViewStateOptions<HyperbolicTreeListViewState>): HyperbolicTreeListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * that aren't loaded yet are applied as they appear — a deep `center` loads
+   * its ancestors via `loadChildren` / `model` when `restoreLoads`.
+   */
+  setViewState(state: Partial<HyperbolicTreeListViewState>): void;
+  clearPendingViewState(): void;
   protected render(): import("lit").TemplateResult<1>;
   static styles: import("lit").CSSResult[];
 }
@@ -9326,6 +10008,26 @@ declare function computeHyperbolicLayout(root: TreeNode | undefined, options?: C
   edges: HyperbolicLayoutEdge[];
 };
 //#endregion
+//#region src/icicle-tree/icicle-view-state.d.ts
+/**
+ * Pure helpers behind `ixfx-icicletree-list` view state (also used by the
+ * sunburst, which shares the zoom-path model). The component runs them on
+ * every update, so state keyed to nodes that left the tree goes pending and
+ * comes back when those keys reappear. See `docs/infra-view-state.md`.
+ */
+/**
+ * `ixfx-icicletree-list` view state: `selected`, `focus`, `scroll`, plus the
+ * zoom path.
+ */
+type IcicleViewState = ViewStateBase & {
+  /**
+   * Keys from the root's children down to the zoomed-into node; `[]` = the
+   * full tree. A path rather than a lone key so a lazily-loaded tree can be
+   * opened down to it, one load at a time.
+   */
+  readonly zoom?: readonly string[];
+};
+//#endregion
 //#region src/icicle-tree/types.d.ts
 /**
  * Weight accessor — returns the area share of `item` within its siblings.
@@ -9503,6 +10205,11 @@ declare class IcicleTreeListElement extends LitElement implements TreeComponent,
   /** Current zoom root. `undefined` when showing the full tree. Pure view-state — `root` is never mutated. */
   get focusedNode(): TreeNode | undefined;
   private _zoomKey;
+  /**
+   * Whether restoring a saved zoom may call `loadChildren` / `model` to load
+   * the nodes along its path (one at a time). Default `true`.
+   */
+  restoreLoads: boolean;
   /** Incremental search (navigate / select / filter). See `docs/infra-incremental.md`. */
   readonly search: ListSearchController<{
     node: TreeNode;
@@ -9520,7 +10227,20 @@ declare class IcicleTreeListElement extends LitElement implements TreeComponent,
   private _tooltipEl;
   connectedCallback(): void;
   disconnectedCallback(): void;
+  protected willUpdate(changedProps: PropertyValues): void;
   protected updated(changedProps: PropertyValues): void;
+  /**
+   * Snapshot selection, zoom path, keyboard cursor and scroll as plain JSON,
+   * keyed by `item.key`. Includes pending state for keys not currently loaded.
+   */
+  getViewState(options?: GetViewStateOptions<IcicleViewState>): IcicleViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * that aren't loaded yet are applied as they appear — including via
+   * `loadChildren` / `model` down a saved zoom path when `restoreLoads`.
+   */
+  setViewState(state: Partial<IcicleViewState>): void;
+  clearPendingViewState(): void;
   select(node: TreeNode): void;
   deselect(node: TreeNode): void;
   clearSelection(): void;
@@ -9585,6 +10305,13 @@ declare function findIcicleNode(root: TreeNode | undefined, key: string): TreeNo
  * Returns `undefined` when the key is absent. The first entry is always `root`.
  */
 declare function findIciclePath(root: TreeNode | undefined, key: string): TreeNode[] | undefined;
+/**
+ * Follow `keys` from `root`; a leading key equal to the root's own key
+ * matches the root itself. Returns `undefined` when a key isn't found.
+ */
+declare function resolveIcicleKeyPath(root: TreeNode | undefined, keys: readonly string[]): TreeNode | undefined;
+/** Key path (depth-first) to the first node among `nodes` matching `predicate`. */
+declare function findIcicleKeyPath(nodes: readonly TreeNode[], predicate: (node: TreeNode) => boolean, prefix?: readonly string[]): string[] | undefined;
 /**
  * Compute the visible rectangles for an icicle view.
  *
@@ -9977,9 +10704,6 @@ declare global {
 //#endregion
 //#region src/miller/types.d.ts
 type MillerSelectionMode = `implicit` | `standard` | `manual` | `checked` | `vscode`;
-type MillerConfig = {
-  columnWidths: Record<number, number>;
-};
 /** Detail for the `header-click` event fired when a column header is clicked. */
 type MillerHeaderClickDetail = {
   /** Zero-based column index whose header was clicked. */
@@ -10044,6 +10768,26 @@ type MillerItemState = {
   isLeaf: boolean;
 };
 //#endregion
+//#region src/miller/miller-view-state.d.ts
+/**
+ * Pure view-state helpers for `ixfx-miller-*`. The element runs these
+ * whenever its data changes (new root, lazy load, `invalidateStructure()`)
+ * and on `setViewState()`; see docs/infra-view-state.md.
+ */
+/** `ixfx-miller-list` view state. */
+type MillerListViewState = ViewStateBase & {
+  /**
+   * Key of the open branch at each depth, from column 0 down, relative to the
+   * view root. A Miller view has exactly one open branch per column, so this
+   * is an ordered path rather than an `expanded` record.
+   */
+  readonly path?: readonly string[];
+  /** User-resized column widths in px, keyed by column depth. */
+  readonly columnWidths?: Readonly<Record<string, number>>;
+  /** Per-column scroll, keyed by the key of the node whose children the column lists. */
+  readonly columnScroll?: Readonly<Record<string, ScrollState>>;
+};
+//#endregion
 //#region src/miller/miller-base.d.ts
 /**
  * Base class for Miller column components. Handles column lifecycle,
@@ -10140,6 +10884,12 @@ declare class MillerBaseElement extends LitElement implements TreeComponent, Tre
   protected _selectedByDepth: Map<number, TreeNode>;
   protected _selectedKeys: Set<string>;
   protected _selectedNodes: Set<TreeNode>;
+  /**
+   * Whether restoring view state may call `loadChildren` / `model` to open a
+   * saved path through branches that aren't loaded yet (one load at a time,
+   * cascading down the path). Default `true`.
+   */
+  restoreLoads: boolean;
   /** Incremental search (navigate / select / filter). See `docs/infra-incremental.md`. */
   readonly search: ListSearchController<{
     node: TreeNode;
@@ -10148,11 +10898,24 @@ declare class MillerBaseElement extends LitElement implements TreeComponent, Tre
   /** Command registry carrying this component's `list.search.*` commands. */
   get registry(): CommandRegistry<unknown> | undefined;
   tickled: TickledController<string>;
+  willUpdate(_changedProps: PropertyValues): void;
   updated(changedProps: PropertyValues): void;
+  firstUpdated(): void;
   connectedCallback(): void;
   disconnectedCallback(): void;
-  getConfig(): MillerConfig;
-  setConfig(config: MillerConfig): void;
+  /**
+   * Snapshot the open path, selection, keyboard cursor, column widths and
+   * column scroll as plain JSON, keyed by `item.key`. Includes pending state
+   * for keys not currently loaded.
+   */
+  getViewState(options?: GetViewStateOptions<MillerListViewState>): MillerListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys not
+   * loaded yet are applied as they appear — including via `loadChildren` /
+   * `model` for the saved path when `restoreLoads`.
+   */
+  setViewState(state: Partial<MillerListViewState>): void;
+  clearPendingViewState(): void;
   /** Read current selection as an immutable set of item keys. */
   get selectedKeys(): ReadonlySet<string>;
   /** Replace entire selection and trigger a re-render. */
@@ -10452,6 +11215,21 @@ type MulticolSelectDetail = {
   readonly columns: readonly MulticolColumnSelection[];
 };
 //#endregion
+//#region src/multicol-list/multicol-view-state.d.ts
+/**
+ * `ixfx-multicol-list` view state. The shared `selected` / `scroll` fields
+ * aren't used: every column has its own selection and scroll, keyed by
+ * column id.
+ */
+type MulticolListViewState = ViewStateBase & {
+  /** Column layout in display order. */
+  readonly columns?: readonly MulticolColumnState[];
+  /** Selected item keys per column id. A missing / empty column is at 'All'. */
+  readonly selectedByColumn?: Readonly<Record<string, readonly string[]>>;
+  /** Scroll position of each column's list, keyed by column id. */
+  readonly scrollByColumn?: Readonly<Record<string, ScrollState>>;
+};
+//#endregion
 //#region src/multicol-list/multicol-list.d.ts
 type MulticolSelectEvent = CustomEvent<MulticolSelectDetail>;
 type MulticolColumnsChangeDetail = {
@@ -10462,6 +11240,7 @@ type MulticolColumnsChangeEvent = CustomEvent<MulticolColumnsChangeDetail>;
 interface MulticolListElementEventMap {
   'multicol-select': MulticolSelectEvent;
   'multicol-columns-change': MulticolColumnsChangeEvent;
+  'view-state-change': ViewStateChangeEvent<MulticolListViewState>;
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -10489,8 +11268,6 @@ declare class MulticolListElement extends LitElement {
   private _idCounter;
   private _autoSeeded;
   private _drag;
-  get columns(): readonly MulticolColumnState[];
-  setColumns(states: readonly MulticolColumnState[]): void;
   addColumn(categoryKey: string, position?: number): void;
   removeColumn(columnId: string): void;
   getSelection(): ReadonlyArray<{
@@ -10499,7 +11276,22 @@ declare class MulticolListElement extends LitElement {
     values: readonly string[];
   }>;
   clearSelection(): void;
+  protected createRenderRoot(): HTMLElement | DocumentFragment;
   protected render(): import("lit").TemplateResult<1>;
+  /**
+   * Snapshot the column layout (in display order) and each column's
+   * selection and scroll, keyed by column id. Includes pending state —
+   * saved columns whose category isn't known and keys not yet in the data.
+   */
+  getViewState(options?: GetViewStateOptions<MulticolListViewState>): MulticolListViewState;
+  /**
+   * Apply saved view state; fields present replace the current ones.
+   * `columns` creates, reorders, re-points and removes columns to match
+   * (columns whose category isn't in `categories` wait until it is).
+   * Selection keys not in a column's data are applied when they arrive.
+   */
+  setViewState(state: Partial<MulticolListViewState>): void;
+  clearPendingViewState(): void;
   protected updated(changedProperties: Map<string, unknown>): void;
   private _renderColumn;
   private _getCategoryLabel;
@@ -11704,6 +12496,336 @@ declare function preserveRestoreWeights(previous: GroupNode | null, next: GroupN
 declare function findPanelNode(group: GroupNode, id: string): PanelNode | undefined;
 declare function walk(group: GroupNode, visitor: (node: LayoutNode, path: number[]) => void): void;
 //#endregion
+//#region src/sunburst-tree/types.d.ts
+/**
+ * Value accessor — returns the magnitude of a node, branches included.
+ *
+ * A child's arc is its share of its parent's value:
+ * `child / max(parent, Σ siblings)`. When children sum to less than their
+ * parent, the remainder shows as an unfilled gap — which is what makes
+ * progressively-arriving data fill in visibly. When they sum to more, they're
+ * scaled to fit.
+ *
+ * Return `undefined` (or a negative / non-finite number) for "unknown": the
+ * node then uses the sum of its loaded children's values, or `1` for a leaf
+ * or not-yet-loaded node.
+ *
+ * Default: `item => item.weight`.
+ */
+type SunburstValueAccessor = (item: TreeItem, node: TreeNode) => number | undefined;
+/** Formats a node's value for the centre readout. */
+type SunburstValueFormatter = (value: number, node: TreeNode) => string;
+/**
+ * Pointer/keyboard gesture mapping (subset of `TreeInteractionMode`).
+ * - `'implicit'` — click selects + zooms; single selection follows the pointer.
+ * - `'standard'` — click selects + zooms; Ctrl/Cmd+click toggles, Shift+click range-selects.
+ * - `'manual'` — click only zooms; selection is driven via `select()`/`deselect()`/`clearSelection()`.
+ *
+ * `checked` is deliberately unsupported — a checkbox per arc does not hold up
+ * at small arc sizes.
+ */
+type SunburstInteractionMode = `implicit` | `standard` | `manual`;
+/**
+ * A node positioned in the absolute (unzoomed) layout produced by
+ * `computeSunburstLayout()`. Angles are fractions of a full turn, clockwise
+ * from 12 o'clock; the true root spans `0..1`.
+ */
+type SunburstLayoutNode = {
+  /** Key path from the true root, joined with {@link SUNBURST_PATH_SEPARATOR}. */
+  readonly id: string;
+  readonly node: TreeNode;
+  readonly parentId: string | undefined;
+  /** Depth from the true root (root is `0`). */
+  readonly depth: number;
+  /** Start angle, fraction of a turn (0–1). */
+  readonly x0: number;
+  /** End angle, fraction of a turn (0–1). */
+  readonly x1: number;
+  /** Resolved value (accessor result, or fallback). */
+  readonly value: number;
+  /** 0-based position among siblings. */
+  readonly index: number;
+  /** Number of siblings (for `aria-setsize`). */
+  readonly setSize: number;
+  readonly hasChildren: boolean;
+};
+/** Absolute layout, keyed by id, in ring-major (breadth-first) order. */
+type SunburstLayout = ReadonlyMap<string, SunburstLayoutNode>;
+type ComputeSunburstLayoutOptions = {
+  valueAccessor?: SunburstValueAccessor;
+  /**
+   * Deepest absolute depth (root is `0`) to lay out. Nodes below it get no
+   * position. Defaults to no limit.
+   */
+  maxDepth?: number;
+};
+/**
+ * The zoom window the absolute layout is projected through: the zoom node's
+ * angular span becomes the full circle, and its depth becomes the centre.
+ */
+type SunburstView = {
+  readonly x0: number;
+  readonly x1: number;
+  /** Absolute depth of the zoom node. */
+  readonly depth: number;
+};
+/**
+ * Everything that's animated about one arc, in screen terms. Interpolated
+ * per frame between the displayed state and the target state.
+ */
+type SunburstArcVisual = {
+  /** Start angle, fraction of a turn (0–1) of the zoomed view. */
+  readonly a0: number;
+  /** End angle, fraction of a turn (0–1) of the zoomed view. */
+  readonly a1: number;
+  /**
+   * Ring index relative to the zoom node: `0` is the first ring, `-1` the
+   * centre disc, `≤ -2` collapsed into the centre. Fractional mid-animation.
+   */
+  readonly depth: number;
+  /** Hue offset in degrees (added to `--sunbursttree-hue-start`). */
+  readonly hue: number;
+  /** Sibling-position tone offset, `-0.5..0.5`. */
+  readonly shade: number;
+  readonly opacity: number;
+};
+/** Ring geometry in SVG user units (CSS px). */
+type SunburstRings = {
+  /** Radius of the centre disc. */
+  readonly center: number;
+  /** Width of each ring. */
+  readonly ring: number;
+};
+/** Where to draw an arc's label, if it fits. */
+type SunburstLabelPlacement = {
+  readonly kind: `straight`;
+  readonly x: number;
+  readonly y: number;
+  /** Rotation in degrees, applied about (x, y). */
+  readonly rotate: number;
+  readonly text: string;
+} | {
+  readonly kind: `curved`;
+  /** Guide path for `<textPath>`: an arc along the ring's middle, drawn so text reads upright. */
+  readonly path: string;
+  readonly text: string;
+};
+/** Ids are key paths; keys only need to be unique among siblings. */
+declare const SUNBURST_PATH_SEPARATOR = "";
+//#endregion
+//#region src/sunburst-tree/layout.d.ts
+/** Default accessor: the shared `TreeItem.weight` field. */
+declare const defaultSunburstValueAccessor: SunburstValueAccessor;
+/** Id of the child `key` under `parentId`. */
+declare function sunburstChildId(parentId: string, key: string): string;
+/** Join a key path (root key first) into an id. */
+declare function sunburstPathToId(path: readonly string[]): string;
+/** True when `ancestorId` is a strict ancestor of `id`. */
+declare function isSunburstAncestorId(ancestorId: string, id: string): boolean;
+/** Split an id back into its key path. */
+declare function sunburstIdToPath(id: string): string[];
+/** Parent id, or `undefined` for the root id. */
+declare function sunburstParentId(id: string): string | undefined;
+/** Resolve an id (key path from the root, root key included) to a node. */
+declare function findSunburstNodeById(root: TreeNode | undefined, id: string): TreeNode | undefined;
+/**
+ * Depth-first search for the first node matching `predicate`. Returns its id
+ * (root key included), or `undefined`.
+ */
+declare function findSunburstId(root: TreeNode | undefined, predicate: (node: TreeNode) => boolean): string | undefined;
+/**
+ * Returns a memoised resolver for node values: the accessor's value when
+ * valid, else the sum of loaded children, else `1`.
+ */
+declare function createValueResolver(accessor: SunburstValueAccessor): (node: TreeNode) => number;
+/** True when `node` may have children (loaded or loadable). */
+declare function sunburstHasChildren(node: TreeNode): boolean;
+/**
+ * Compute the absolute layout of the whole (loaded) tree. The root spans the
+ * full turn at depth `0`; each child spans
+ * `parentSpan × value / max(parentValue, Σ siblingValues)`, packed from the
+ * parent's start angle in sibling order. Returned in ring-major order.
+ */
+declare function computeSunburstLayout(root: TreeNode | undefined, options?: ComputeSunburstLayoutOptions): SunburstLayout;
+//#endregion
+//#region src/sunburst-tree/sunburst-view-state.d.ts
+/**
+ * Pure helpers behind `ixfx-sunbursttree-list` view state. Arcs are
+ * identified by key *path* (keys need only be unique among siblings), so live
+ * selection follows its path across data changes; saved keys — which are
+ * bare `item.key`s — resolve to the first node, depth-first, carrying them.
+ * See `docs/infra-view-state.md`.
+ */
+/** `ixfx-sunbursttree-list` view state: `selected`, `focus`, plus the zoom path. */
+type SunburstViewState = ViewStateBase & {
+  /**
+   * Keys from the root's children down to the centre node; `[]` = the full
+   * tree. A path because keys are only unique among siblings, and so a
+   * lazily-loaded tree can be opened down to it, one load at a time.
+   */
+  readonly zoom?: readonly string[];
+};
+//#endregion
+//#region src/sunburst-tree/sunbursttree-list.d.ts
+/** Fired when the zoom root changes. `node` is `undefined` on zoom-out to the full tree. */
+type SunburstZoomDetail = {
+  readonly node: TreeNode | undefined;
+  /** Absolute depth of the zoom node (root's children are depth 0); `-1` when fully zoomed out. */
+  readonly depth: number;
+};
+type SunburstZoomEvent = CustomEvent<SunburstZoomDetail>;
+interface SunburstTreeListElementEventMap extends TreeComponentEventMap {
+  'select': TreeSelectEvent;
+  'tickle': TreeTickleEvent;
+  'activate': TreeActivateEvent;
+  'item-click': TreeItemClickEvent;
+  'item-dblclick': TreeItemDblClickEvent;
+  'expand': TreeExpandEvent;
+  'collapse': TreeCollapseEvent;
+  'zoom': SunburstZoomEvent;
+}
+/**
+ * `ixfx-sunbursttree-list` — a zoomable sunburst over weighted tree data.
+ *
+ * The zoom node is the centre disc; each ring outward is one generation,
+ * each arc's angle its share of its parent's value. Every data, weighting or
+ * zoom change animates from what's on screen to the new layout. Hues come
+ * from the ring around the centre; descendants take tones of their
+ * first-ring ancestor's hue.
+ *
+ * Implements `TreeComponent`. Deliberate differences from `ixfx-tree-list`:
+ * - **Expand/collapse is reinterpreted as zoom.** `expand` fires on zoom-in,
+ *   `collapse` on zoom-out.
+ * - **`interactionMode` drops `checked`**; **`exclusivity` is ignored**.
+ * - **`filterPredicate` dims** non-matching arcs instead of hiding them.
+ * - **Reassigning `root` keeps zoom and selection** where the same key paths
+ *   still exist, so streamed or immutably-rebuilt data animates in place.
+ */
+declare class SunburstTreeListElement extends LitElement implements TreeComponent, TreeSearchHost {
+  #private;
+  static shadowRootOptions: {
+    delegatesFocus: boolean;
+    clonable?: boolean;
+    customElementRegistry?: CustomElementRegistry | null;
+    mode: ShadowRootMode;
+    serializable?: boolean;
+    slotAssignment?: SlotAssignmentMode;
+  };
+  root: TreeNode | undefined;
+  model: TreeDataModel | undefined;
+  /** Callback to lazily load children for a node. Superseded by `model` when both are set. */
+  loadChildren: LoadChildrenCallback | undefined;
+  /** Accepted for `TreeComponent` compatibility but ignored. */
+  exclusivity: TreeExclusivity;
+  selectionFilter: TreeSelectionFilter;
+  /** Gesture mapping. `checked` is unsupported. */
+  interactionMode: SunburstInteractionMode;
+  /** How many rings render around the centre. */
+  maxDepth: number;
+  /** Radius of the centre disc as a fraction of the overall radius (0–0.9). */
+  centerRatio: number;
+  /** Arcs whose outer edge is shorter than this (px) aren't drawn. */
+  minArcLength: number;
+  /** Hide in-arc labels (the centre readout still shows). */
+  disableLabels: boolean;
+  /**
+   * Curve labels to follow their ring (`<textPath>`) instead of drawing them
+   * straight. Arcs too narrow for that still get straight radial labels.
+   */
+  curvedLabels: boolean;
+  /** Duration (ms) of data, weighting and zoom transitions. `0` snaps. Respects `prefers-reduced-motion`. */
+  animationDuration: number;
+  /**
+   * Node value. Swap it to change weighting scheme — the chart animates to
+   * the new layout without rebuilding anything. Default: `item.weight`.
+   * See `SunburstValueAccessor` for how missing values fall back.
+   */
+  valueAccessor: SunburstValueAccessor;
+  /** Formats values for the centre readout. */
+  valueFormatter: SunburstValueFormatter;
+  selectedNode: TreeNode | undefined;
+  private _selectedNodes;
+  get selectedNodes(): ReadonlySet<TreeNode>;
+  filterPredicate: TreeFilterPredicate | undefined;
+  disableKeyboardNavigation: boolean;
+  registry: CommandRegistry<unknown> | undefined;
+  /** Space-separated subset of `navigate select filter`. See `docs/infra-incremental.md`. */
+  searchModes: string | undefined;
+  /** Current zoom root. `undefined` when showing the full tree. Pure view-state. */
+  get focusedNode(): TreeNode | undefined;
+  /** Id (key path) of the zoom node; `undefined` = the true root. */
+  private _zoomId;
+  /**
+   * Whether restoring a saved zoom may call `loadChildren` / `model` to load
+   * the nodes along its path (one at a time). Default `true`.
+   */
+  restoreLoads: boolean;
+  private _size;
+  readonly search: ListSearchController<{
+    node: TreeNode;
+    depth: number;
+  }>;
+  private tickled;
+  /** Set by every update request except animation frames — triggers a re-layout. */
+  private _layoutDirty;
+  private _ticking;
+  requestUpdate(...args: Parameters<LitElement[`requestUpdate`]>): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  protected willUpdate(changed: PropertyValues): void;
+  protected updated(changed: PropertyValues): void;
+  /**
+   * Snapshot selection, zoom path and keyboard cursor as plain JSON, keyed by
+   * `item.key`. Includes pending state for keys not currently loaded.
+   */
+  getViewState(options?: GetViewStateOptions<SunburstViewState>): SunburstViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * that aren't loaded yet are applied as they appear — including via
+   * `loadChildren` / `model` down a saved zoom path when `restoreLoads`.
+   */
+  setViewState(state: Partial<SunburstViewState>): void;
+  clearPendingViewState(): void;
+  select(node: TreeNode): void;
+  deselect(node: TreeNode): void;
+  clearSelection(): void;
+  selectAll(): void;
+  deselectAll(): void;
+  selectMany(nodes: Iterable<TreeNode>): void;
+  /**
+   * Zoom so `node` becomes the centre, its children the first ring. Fires
+   * `zoom` and `expand` (or `collapse` when `node` is an ancestor of the
+   * current centre). Pure view-state — `root` is never mutated.
+   */
+  zoomTo(node: TreeNode): void;
+  /** Zoom out one level: the centre's parent becomes the centre. */
+  zoomUp(): void;
+  /** Zoom all the way out to the full tree. */
+  zoomOut(): void;
+  /** Zoom to reveal the node at `keys` (path from the root's children), then select it. */
+  navigateTo(keys: readonly string[]): boolean;
+  /** Zoom + select the first node (depth-first) matching `predicate`. */
+  navigateToNode(predicate: (node: TreeNode) => boolean): boolean;
+  /** Zoom to reveal the first node with `key` and move the cursor to it, without selecting. */
+  revealKey(key: string): boolean;
+  /** Arcs currently drawn (centre excluded), ring-major, depth from the root's children. */
+  getNodes(): ReadonlyArray<{
+    node: TreeNode;
+    depth: number;
+  }>;
+  protected render(): import("lit").TemplateResult<1>;
+  static styles: import("lit").CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-sunbursttree-list': SunburstTreeListElement;
+  }
+}
+interface SunburstTreeListElement {
+  addEventListener: (<K extends keyof SunburstTreeListElementEventMap>(type: K, listener: (this: SunburstTreeListElement, event: SunburstTreeListElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+  removeEventListener: (<K extends keyof SunburstTreeListElementEventMap>(type: K, listener: (this: SunburstTreeListElement, event: SunburstTreeListElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);
+}
+//#endregion
 //#region src/swipe/swipe.d.ts
 type SwipeInputDetail = {
   readonly value: number;
@@ -12741,6 +13863,24 @@ declare function findTreemapPath(root: TreeNode | undefined, key: string): TreeN
  */
 declare function computeTreemapLayout(root: TreeNode | undefined, options?: ComputeTreemapLayoutOptions): TreemapRect[];
 //#endregion
+//#region src/treemap/treemap-view-state.d.ts
+/**
+ * Pure view-state helpers for `ixfx-treemap-list`. The element re-runs
+ * {@link reconcileTreemapViewState} whenever its structure changes (new
+ * `root` / `model`, model invalidation, a lazy load), so state keyed to nodes
+ * that left the tree goes pending and comes back when those keys reappear.
+ */
+/**
+ * `ixfx-treemap-list` view state.
+ * - `selected` / `focus` — the shared base fields.
+ * - `zoom` — key path from the root's children down to the zoom root
+ *   (`[]` = the full tree). A path rather than a lone key so a deep zoom into
+ *   lazily-loaded data can be restored by loading each ancestor in turn.
+ */
+type TreemapListViewState = ViewStateBase & {
+  readonly zoom?: readonly string[];
+};
+//#endregion
 //#region src/treemap/treemap-list.d.ts
 /** Fired when the zoom root changes. `node` is `undefined` on zoom-out to the full tree. */
 type TreemapZoomDetail = {
@@ -12877,6 +14017,11 @@ declare class TreemapListElement extends LitElement implements TreeComponent, Tr
   /** Current zoom root. `undefined` when showing the full tree. Pure view-state — `root` is never mutated. */
   get focusedNode(): TreeNode | undefined;
   private _zoomKey;
+  /**
+   * Whether restoring a saved `zoom` may call `loadChildren` / `model` to load
+   * the ancestors on its path (one at a time, cascading down). Default `true`.
+   */
+  restoreLoads: boolean;
   /** Incremental search (navigate / select / filter). See `docs/infra-incremental.md`. */
   readonly search: ListSearchController<{
     node: TreeNode;
@@ -12885,6 +14030,7 @@ declare class TreemapListElement extends LitElement implements TreeComponent, Tr
   private tickled;
   connectedCallback(): void;
   disconnectedCallback(): void;
+  protected willUpdate(changedProps: PropertyValues): void;
   protected updated(changedProps: PropertyValues): void;
   select(node: TreeNode): void;
   deselect(node: TreeNode): void;
@@ -12927,6 +14073,18 @@ declare class TreemapListElement extends LitElement implements TreeComponent, Tr
     node: TreeNode;
     depth: number;
   }>;
+  /**
+   * Snapshot selection, zoom path and keyboard cursor as plain JSON, keyed by
+   * `item.key`. Includes pending state for keys not currently loaded.
+   */
+  getViewState(options?: GetViewStateOptions<TreemapListViewState>): TreemapListViewState;
+  /**
+   * Apply saved view state. Fields present replace the current ones; keys
+   * that aren't loaded yet are applied as they appear — a deep `zoom` loads
+   * its ancestors via `loadChildren` / `model` when `restoreLoads`.
+   */
+  setViewState(state: Partial<TreemapListViewState>): void;
+  clearPendingViewState(): void;
   protected render(): import("lit").TemplateResult<1>;
   static styles: import("lit").CSSResult[];
 }
@@ -12941,6 +14099,17 @@ interface TreemapListElement {
 }
 //#endregion
 //#region src/twosplit-layout/split-layout.d.ts
+/** One side of an `ixfx-twosplit-layout` in its view state. */
+type TwoSplitPanelViewState = {
+  /** CSS size, as in `sizeA` / `sizeB` (e.g. `30%`, `200px`). */
+  readonly size: string;
+  /** Collapsed by dragging to the edge. Absent ⇒ expanded. */
+  readonly collapsed?: boolean;
+};
+/** `ixfx-twosplit-layout` view state (`kind: 'twosplit-layout'`), keyed by slot name. */
+type TwoSplitLayoutViewState = ViewStateBase & {
+  readonly layout?: Readonly<Partial<Record<`a` | `b`, TwoSplitPanelViewState>>>;
+};
 /**
  * Lays out two elements within a container, with a bar to resize them
  * proportionally.
@@ -12984,6 +14153,12 @@ declare class TwoSplitLayoutElement extends LitElement {
   disconnectedCallback(): void;
   firstUpdated(): void;
   updated(changedProperties: Map<string, unknown>): void;
+  /** Snapshot both sides' size and collapse. */
+  getViewState(options?: GetViewStateOptions<TwoSplitLayoutViewState>): TwoSplitLayoutViewState;
+  /** Restore sizes / collapse. A side missing from `layout` is left as it is. */
+  setViewState(state: Partial<TwoSplitLayoutViewState>): void;
+  /** Both slots always exist, so nothing is ever pending. */
+  clearPendingViewState(): void;
   getZone(): HTMLElement | undefined;
   render(): import("lit").TemplateResult<1>;
   static styles: import("lit").CSSResult[];
@@ -13087,4 +14262,4 @@ interface XyPad {
 //#region src/index.d.ts
 declare function init(): void;
 //#endregion
-export { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent, type AcTokenAddDetail, type AcTokenAddEvent, AcTokenElement, type AcTokenElementEventMap, type AcTokenItem, type AcTokenRemoveDetail, type AcTokenRemoveEvent, type AcTokenStyle, type AcTokenStyleFn, type AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, AddItemOptions, Axis, BottomDrawerCloseEvent, BottomDrawerCommand, BottomDrawerElement, BottomDrawerElementEventMap, BottomDrawerResizeDetail, BottomDrawerResizeEvent, type BuiltInFormatterName, type BuiltInFormatterOptions, ButtonElement, ButtonElementEventMap, ButtonToggleDetail, ButtonToggleEvent, type CheckState, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, CheckedSelect, CheckedSelectChangeDetail, CheckedSelectChangeEvent, CheckedSelectEventMap, type CheckedSelectItem, ClickSnapMode, ColourMapConfig, ColourMode, ColourPicker, type ColourPickerChangeEvent, type ColourPickerEventDetail, type ColourPickerInputEvent, ColourPickerPopup, ColourResult, type ComputeHyperbolicLayoutOptions, ComputeIcicleLayoutOptions, type ComputeTreemapLayoutOptions, ConfigEntry, ContiguousSelectEventDetail, CrossoverBehaviour, CrumbDragStartDetail, CrumbDragStartEvent, CrumbDropDetail, CrumbDropEvent, CrumbExternalDropParser, CrumbNavChangeDetail, CrumbNavChangeEvent, CrumbNavExpandDetail, CrumbNavExpandEvent, CrumbNavNavigateDetail, CrumbNavNavigateEvent, CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent, CrumbPathController, CrumbPathControllerOptions, CrumbPathElement, CrumbPathElementEventMap, CrumbSegment, CrumbSegmentDragData, CrumbSegmentDragLookupFn, CrumbSiblingLookupFn, type CssVars, CustomCheckboxOptions, DEFAULT_SIBLING_SPACING, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataGridCellClickDetail, DataGridCellClickEvent, DataGridCellEditDetail, DataGridCellEditEvent, type DataGridColumn, type DataGridColumnMenu, DataGridColumnReorderDetail, DataGridColumnReorderEvent, DataGridColumnResizeDetail, DataGridColumnResizeEvent, DataGridColumnVisibilityDetail, DataGridColumnVisibilityEvent, type DataGridDataType, type DataGridEditability, type DataGridEditorContext, type DataGridEditorFactory, type DataGridEditorType, DataGridElement, DataGridElementEventMap, type DataGridGetRowKey, type DataGridGroupBy, DataGridGroupChangeDetail, DataGridGroupChangeEvent, type DataGridGroupLabel, type DataGridInteractionMode, DataGridRowActivateDetail, DataGridRowActivateEvent, type DataGridRowLook, DataGridSelectDetail, DataGridSelectEvent, type DataGridSelectionMode, DataGridSortDetail, type DataGridSortDirection, DataGridSortEvent, type DataGridSortState, DataGridViewportChangeDetail, DataGridViewportChangeEvent, type DataListSearchAdapterOptions, type DataListSearchItem, DataProviderResult, DataTableElement, DataTableElementEventMap, DataTableRow, DataTableRowClickDetail, DataTableRowClickEvent, type DetailFormatter, type DetailGroupBy, DetailListElement, DetailListElementEventMap, type DetailSortComparator, type DetailSortItem, type DetailSortMode, DiskIsometry, DisplayTextLogic, DistributeResult, DockAddPanelTarget, DockAxis, DockChangeDetail, DockChangeEvent, DockDirection, DockDragBoundaryDetail, DockDragBoundaryEvent, DockDropTarget, type DockDropZone, DockEdge, DockHostElement, DockHostElementEventMap, DockLayout, DockLeafContentRules, DockLeafInfo, DockLeafPlacementPolicy, DockLeafPlacementPolicyResolved, DockLeafRef, DockNeighbours, DockNode, DockOperation, DockPanelActivatedDetail, DockPanelActivatedEvent, DockPanelAddedDetail, DockPanelAddedEvent, DockPanelDragStartDetail, DockPanelDragStartEvent, DockPanelElement, DockPanelElementEventMap, DockPanelInit, DockPanelMovedDetail, DockPanelMovedEvent, DockPanelRemovedDetail, DockPanelRemovedEvent, DockPanelSnapshot, DockPanelTearOutDetail, DockPanelTearOutEvent, DockRect, DockSplitNode, DockStackEmptyDetail, DockStackEmptyEvent, DockStackNode, DockStackSnapshot, DockTabContextMenuDetail, DockTabContextMenuEvent, type DragSelectRect, DragSnappingFn, DragTarget, EMPTY_GROUP_LABEL, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, Endpoints, EntryMode, type FlatListActivateDetail, type FlatListActivateEvent, type FlatListBranchOrder, type FlatListContextMenuDetail, type FlatListContextMenuEvent, type FlatListDropDetail, type FlatListDropEvent, type FlatListEditCancelDetail, type FlatListEditCancelEvent, type FlatListEditCommitDetail, type FlatListEditCommitEvent, FlatListElement, type FlatListElementEventMap, type FlatListNavigateDetail, type FlatListNavigateEvent, type FlatListSelectDetail, type FlatListSelectEvent, FormElement, FormGroupElement, FormOptionsElement, FormPartElement, FormRowElement, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GeodesicSegment, type GlobalFormatter, type GridListActivateDetail, type GridListActivateEvent, type GridListCaptionAlign, type GridListCaptionBackdrop, type GridListCaptionPosition, type GridListCaptionStyle, type GridListDataAdapter, GridListElement, type GridListElementEventMap, type GridListFullElementEventMap, type GridListItemClickDetail, type GridListItemClickEvent, type GridListItemEventDetail, type GridListOrientation, type GridListSelectDetail, type GridListSelectEvent, type GridListTickleDetail, type GridListTickleEvent, type GridListViewportChangeDetail, type GridListViewportChangeEvent, GridMode, GridResolution, GroupNode, GroupedItemListerElement, type GroupedItemListerElementEventMap, type GroupedSelectDetail, type GroupedSelectEvent, HexChangeDetail, HexChangeEvent, type HighlightOptions, type HighlightTarget, type HyperbolicEdgeRenderContext, type HyperbolicEdgeRenderer, type HyperbolicFocusDetail, type HyperbolicFocusEvent, type HyperbolicInteractionMode, type HyperbolicLayoutEdge, type HyperbolicLayoutNode, type HyperbolicNodeShape, type Point as HyperbolicPoint, HyperbolicTreeListElement, HyperbolicTreeListElementEventMap, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IDataProvider, type IGroupedSubComponent, type IGroupedSubComponentEventMap, IcicleInteractionMode, IcicleOrientation, IcicleRect, IcicleTreeListElement, IcicleTreeListElementEventMap, IcicleValueAccessor, IcicleZoomDetail, IcicleZoomEvent, type IconChangedDetail, type IconChangedEvent, type IconEntry, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, type InputMode, type ItemDisplay, type ItemOrientation, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxRatingElement, IxfxTimelineElement, KeyedElementIndex, LIST_ITEM_MOTION_MS, LIST_SEARCH_COMMAND_IDS, LIST_SEARCH_MODES, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LaneData, LaneType, LayoutNode, LayoutSnapshot, LeafGeom, LedElement, LedMode, type ListActivateDetail, type ListActivateEvent, type ListContextMenuDetail, type ListContextMenuEvent, type ListDragEntry, type ListDragLeaveDetail, type ListDragLeaveEvent, type ListDragOverEvent, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragPreviewSourceResolver, ListDragSelectController, type ListDragSelectControllerConfig, type ListDragSource, type ListDropDetail, type ListDropEvent, type ListEditCancelDetail, type ListEditCancelEvent, type ListEditCommitDetail, type ListEditCommitEvent, type ListElementEventMap, type ListGroupBy, type ListGroupChangeDetail, type ListGroupChangeEvent, type ListGroupEventMap, ListGroupHeaderElement, type ListGroupInfo, type ListGroupLabel, type ListGroupPartition, type ListGroupToggleDetail, type ListGroupToggleEvent, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListItemMotionOptions, type ListItemOutResult, ListNativeDragController, type ListNativeDragControllerConfig, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSearchAdapter, ListSearchController, type ListSearchControllerOptions, type ListSearchHost, type ListSearchMode, type ListSelectDetail, type ListSelectEvent, ListSelectionController, type ListSelectionControllerConfig, type ListSelectionGesture, type ListSelectionMode, type ListSelectionModes, type ListTickleDetail, type ListTickleEvent, type ListViewportChangeDetail, type ListViewportChangeEvent, LoadChildrenCallback, MarkerStyle, index_d_exports as Menu, type TreeActivateDetail as MillerActivateDetail, TreeActivateDetail, type TreeActivateEvent as MillerActivateEvent, TreeActivateEvent, MillerBaseElement, MillerBaseElementEventMap, type TreeCollapseDetail as MillerCollapseDetail, TreeCollapseDetail, type TreeCollapseEvent as MillerCollapseEvent, TreeCollapseEvent, MillerConfig, type TreeExpandDetail as MillerExpandDetail, TreeExpandDetail, type TreeExpandEvent as MillerExpandEvent, TreeExpandEvent, MillerHeaderClickDetail, MillerHeaderClickEvent, MillerHeaderRightClickDetail, MillerHeaderRightClickEvent, type TreeItem as MillerItem, TreeItem, type TreeItemClickDetail as MillerItemClickDetail, TreeItemClickDetail, type TreeItemClickEvent as MillerItemClickEvent, TreeItemClickEvent, MillerItemDblClickDetail, MillerItemDblClickEvent, MillerItemRightClickDetail, MillerItemRightClickEvent, MillerItemState, MillerListElement, type TreeNode as MillerNode, TreeNode, MillerRebaseDetail, MillerRebaseEvent, type TreeSelectDetail as MillerSelectDetail, TreeSelectDetail, type TreeSelectEvent as MillerSelectEvent, TreeSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, TreeTickleDetail, type TreeTickleEvent as MillerTickleEvent, TreeTickleEvent, MillerTreeController, MillerTreeControllerOptions, type MulticolCategory, type MulticolColumnState, MulticolColumnsChangeDetail, MulticolColumnsChangeEvent, type MulticolColumnsChangeReason, type MulticolItem, MulticolListElement, MulticolListElementEventMap, type MulticolQuery, type MulticolSelectDetail, MulticolSelectEvent, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, NoneSelectEventDetail, Notification, NotificationContent, NotificationManager, NotificationPillElement, NotificationPillElementEventMap, NotificationRenderer, NotificationRendererHooks, NotificationType, NotifierOptions, type OklchValue, Orientation, PanTextElement, PanTextMode, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupElementEventMap, PanelGroupOrientation, PanelGroupReorderDetail, PanelGroupReorderEvent, PanelInfo, PanelNode, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PillPosition, PillQueueDisplay, PillRendererOptions, PillSafeArea, PillTapDetail, PillTapEvent, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramInteractionMode, PlotHistogramOrientation, PlotHistogramSelectionChangeDetail, PlotHistogramSelectionChangeEvent, PlotHistogramSelectionRange, PlotHistogramValueTooltips, PlotMultiAxis, PlotMultiAxisDataPointClickDetail, PlotMultiAxisDataPointClickEvent, PlotMultiAxisElementEventMap, PlotMultiAxisLayout, PlotSingleAxis, PlotSingleAxisElementEventMap, PlotSingleAxisPointerMoveDetail, PlotSingleAxisPointerMoveEvent, PlotXyAxis, PolarPad, PolarPadInputDetail, PolarPadInputEvent, PopupItem, RadialInputChangeDetail, RadialInputChangeEvent, RadialInputElement, RadialInputInputDetail, RadialInputInputEvent, RadioGroup, RadioGroupChangeDetail, RadioGroupChangeEvent, RadioGroupMode, RadioItem, RangeElement, RangeInput, RangeMultiElement, RangeMultiInputDetail, RangeMultiInputEvent, RatingChangeDetail, RatingChangeEvent, RatingElement, RatingElementEventMap, RatingInputEvent, RatingVariant, type Rect, RectangularSelectEventDetail, type RegisterListSearchCommandsOptions, RendererStyle, ResizeMode, SegmentIconLookupFn, SelectEventDetail, SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap, SelectionMode, ShapefillDisplay, ShapefillFillMode, ShapefillValueChangeDetail, ShapefillValueChangeEvent, ShapefillValueElement, ShapefillValueInputDetail, ShapefillValueInputEvent, SingleAxisAgeStyle, SingleAxisDrawStyle, SingleSelectEventDetail, SliderChangedField, SliderCrossover, SliderHandleKey, SliderInputChangeDetail, SliderInputChangeEvent, SliderInputElement, SliderInputElementEventMap, SliderInputInputDetail, SliderInputInputEvent, SliderLaneData, SliderLaneType, SliderMarkerStyle, SliderOrientation, SliderSingleStyle, SliderValueCFollow, SliderValueDrag, SliderValueMode, SlidingNumberElement, SlidingNumberTrend, SnackbarDismiss, SnackbarElement, SnackbarMode, SnackbarPlacement, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic, SnapshotNode, SortCompareFn, type SortDirection, SplitButton, SplitButtonMode, SplitButtonSelectDetail, SplitButtonSelectEvent, SplitChangeDetail, SplitChangeEvent, SplitCloseDetail, SplitCloseEvent, SplitCollapseDetail, SplitCollapseEvent, SplitExpandDetail, SplitExpandEvent, SplitLayoutElement, SplitLayoutElementEventMap, SplitPanelElement, SplitResizeDetail, SplitResizeEvent, type SubComponentActivateDetail, type SubComponentActivateEvent, type SubComponentFactory, type SubComponentItemClickDetail, type SubComponentItemClickEvent, type SubComponentSelectDetail, type SubComponentSelectEvent, type SubComponentTickleDetail, type SubComponentTickleEvent, SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent, SwitcherItem, Tab, TabAddOptions, TabController, TabControllerOptions, TabListChangeDetail, TabListChangeEvent, TabListDragMode, TabListElement, TabListItemElement, TabListReorderDetail, TabListReorderEvent, TabPanelElement, TabPanelsElement, TextShimmerElement, TickledController, type TickledControllerConfig, type TickledItem, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, TitlebarCloseEvent, TitlebarElement, TitlebarElementEventMap, TitlebarOrientation, TitlebarToggleDetail, TitlebarToggleEvent, TitlebarToggleInteraction, TitlebarVariant, ToolbarAlign, ToolbarElement, ToolbarElementEventMap, ToolbarGroupElement, ToolbarGroupReorderDetail, ToolbarGroupReorderEvent, ToolbarLayout, ToolbarLayoutSnapshot, ToolbarOrientation, ToolbarVerticalWriting, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeAnimation, TreeBaseElement, TreeBaseElementEventMap, type TreeCheckboxState, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeDndMode, TreeDragContext, TreeDragEndEvent, TreeDragOverEvent, TreeDragStartEvent, TreeDropApplyContext, TreeDropContext, TreeDropController, TreeDropControllerConfig, TreeDropDetail, TreeDropEvent, TreeDropPosition, TreeDropResolvedDrag, TreeDropRowInfo, TreeDropTarget, TreeDropVisibleRow, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeItemDblClickDetail, TreeItemDblClickEvent, type TreeKeyboardNavCallbacks, TreeKeyboardNavController, type TreeKeyboardNavControllerConfig, type TreeKeyboardNavItemId, TreeListAdapterOptions, TreeListElement, type TreeListSearchAdapterOptions, TreeNavigateOptions, TreeRevealMode, TreeSearchHost, TreeSelectionFilter, TreeVirtualize, type TreemapInteractionMode, TreemapListElement, TreemapListElementEventMap, type TreemapRect, type TreemapTilingMethod, type TreemapValueAccessor, TreemapZoomDetail, TreemapZoomEvent, TwoSplitLayoutElement, UserScale, ValueMode, VerticalListAdapterOptions, VerticalListElement, VerticalListElementEventMap, ViewRange, WhenSmall, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, addPanelToStack, animateListItemIn, animateListItemOut, applyAgeModification, applyHighlights, applyIsometry, applySnapshot, applyTreeDrop, attachTimelineInteractions, bottomDrawerCommandId, buildHighlightTargets, buildModel, captionForEntry, clampToDisk, clearHighlights, collectContainerNames, collectDataResult, collectPanelIds, collectStackPaths, composeIsometry, computeCanonicalPositions, computeColour, computeHyperbolicLayout, computeIcicleLayout, computeLeafGeoms, computeTreemapLayout, createAcCompletionProvider, createDataListSearchAdapter, createDefaultListDragPreview, createElementIncrSearch, createElementListSearchAdapter, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createSplit, createStack, createTreeListAdapter, createTreeListSearchAdapter, createVerticalListAdapter, decomposeViewIsometry, defaultGroupLabel, distribute, dropTargetFor, euclideanRadiusForHyperbolicDistance, extractStack, findEmptiedStacks, findHyperbolicIdOf, findHyperbolicKeyPath, findHyperbolicNode, findHyperbolicPath, findHyperbolicPathById, findIcicleNode, findIciclePath, findNode, findPanelNode, findParentOf, findStackOf, findStackPathByName, findTreemapNode, findTreemapPath, geodesicInterpolate, geodesicPath, geodesicSegment, getActiveDragPanelId, getIcon, getIconEntry, getIconFont, getLeafNeighbours, hasIcon, hyperbolicBranchId, hyperbolicChildIds, hyperbolicDistanceForEuclideanRadius, hyperbolicIdDepth, hyperbolicRelativeFrame, iconBus, identityIsometry, init, insertBeside, invertIsometry, isDragging, isHyperbolicDescendantId, isMultiMode, isSplit, isStack, keyForElement, listItemFadeKeyframes, listSearchStyles, mobiusAdd, mobiusFromOrigin, mobiusToOrigin, monitorIndeterminate, moveLeafNodeToEdge, moveLeafStep, norm, normalise, normaliseValue, normalize, panelGapIndex, parseColourScaleAttr, parseLayout, partitionByGroup, poincareDistance, pointerOverAnyHost, prefersReducedMotion, preserveRestoreWeights, pruneDraggedDescendants, readBaseColour, registerFontIcon, registerIcon, registerListSearchCommands, removePanelFromStack, resolveCssVars, resolveGrid, resolveGroupKey, resolveLeafPath, resolveTracks, rotationIsometry, serializeLayout, setActive, setIconFont, setPanelRestoreWeight, snapshotNonEmptyStacks, startListItemOutAnimation, svgToDataUri, swapLeaves, tickledItemStyles, tickledStyles, timelineStyles, toGroupKey, toSnapshot, toggleInSet, toolbarGapIndex, translationFromOrigin, viewIsometry, walk, wrapRoot };
+export { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent, type AcTokenAddDetail, type AcTokenAddEvent, AcTokenElement, type AcTokenElementEventMap, type AcTokenItem, type AcTokenRemoveDetail, type AcTokenRemoveEvent, type AcTokenStyle, type AcTokenStyleFn, type AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, AddItemOptions, Axis, BottomDrawerCloseEvent, BottomDrawerCommand, BottomDrawerElement, BottomDrawerElementEventMap, BottomDrawerResizeDetail, BottomDrawerResizeEvent, type BuiltInFormatterName, type BuiltInFormatterOptions, ButtonElement, ButtonElementEventMap, ButtonToggleDetail, ButtonToggleEvent, type CheckState, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, CheckedSelect, CheckedSelectChangeDetail, CheckedSelectChangeEvent, CheckedSelectEventMap, type CheckedSelectItem, ClickSnapMode, ColourMapConfig, ColourMode, ColourPicker, type ColourPickerChangeEvent, type ColourPickerEventDetail, type ColourPickerInputEvent, ColourPickerPopup, ColourResult, type ComputeHyperbolicLayoutOptions, ComputeIcicleLayoutOptions, ComputeSunburstLayoutOptions, type ComputeTreemapLayoutOptions, ConfigEntry, ContiguousSelectEventDetail, CrossoverBehaviour, CrumbDragStartDetail, CrumbDragStartEvent, CrumbDropDetail, CrumbDropEvent, CrumbExternalDropParser, CrumbNavChangeDetail, CrumbNavChangeEvent, CrumbNavExpandDetail, CrumbNavExpandEvent, CrumbNavNavigateDetail, CrumbNavNavigateEvent, CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent, type CrumbNavigationViewState, CrumbPathController, CrumbPathControllerOptions, CrumbPathElement, CrumbPathElementEventMap, CrumbSegment, CrumbSegmentDragData, CrumbSegmentDragLookupFn, CrumbSiblingLookupFn, type CssVars, CustomCheckboxOptions, DEFAULT_SIBLING_SPACING, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataGridCellClickDetail, DataGridCellClickEvent, DataGridCellEditDetail, DataGridCellEditEvent, type DataGridColumn, type DataGridColumnMenu, DataGridColumnReorderDetail, DataGridColumnReorderEvent, DataGridColumnResizeDetail, DataGridColumnResizeEvent, type DataGridColumnViewState, DataGridColumnVisibilityDetail, DataGridColumnVisibilityEvent, type DataGridDataType, type DataGridEditability, type DataGridEditorContext, type DataGridEditorFactory, type DataGridEditorType, DataGridElement, DataGridElementEventMap, type DataGridGetRowKey, type DataGridGroupBy, DataGridGroupChangeDetail, DataGridGroupChangeEvent, type DataGridGroupLabel, type DataGridInteractionMode, DataGridRowActivateDetail, DataGridRowActivateEvent, type DataGridRowLook, DataGridSelectDetail, DataGridSelectEvent, type DataGridSelectionMode, DataGridSortDetail, type DataGridSortDirection, DataGridSortEvent, type DataGridSortState, type DataGridViewState, DataGridViewportChangeDetail, DataGridViewportChangeEvent, type DataListSearchAdapterOptions, type DataListSearchItem, DataProviderResult, DataTableElement, DataTableElementEventMap, DataTableRow, DataTableRowClickDetail, DataTableRowClickEvent, type DetailFormatter, type DetailGroupBy, DetailListElement, DetailListElementEventMap, type DetailListViewState, type DetailSortComparator, type DetailSortItem, type DetailSortMode, DiskIsometry, DisplayTextLogic, DistributeResult, DockAddPanelTarget, DockAxis, DockChangeDetail, DockChangeEvent, DockDirection, DockDragBoundaryDetail, DockDragBoundaryEvent, DockDropTarget, type DockDropZone, DockEdge, DockHostElement, DockHostElementEventMap, DockHostViewState, DockLayout, DockLeafContentRules, DockLeafInfo, DockLeafPlacementPolicy, DockLeafPlacementPolicyResolved, DockLeafRef, DockNeighbours, DockNode, DockOperation, DockPanelActivatedDetail, DockPanelActivatedEvent, DockPanelAddedDetail, DockPanelAddedEvent, DockPanelDragStartDetail, DockPanelDragStartEvent, DockPanelElement, DockPanelElementEventMap, DockPanelInit, DockPanelMovedDetail, DockPanelMovedEvent, DockPanelRemovedDetail, DockPanelRemovedEvent, DockPanelSnapshot, DockPanelTearOutDetail, DockPanelTearOutEvent, DockRect, DockSplitNode, DockStackEmptyDetail, DockStackEmptyEvent, DockStackNode, DockStackSnapshot, DockTabContextMenuDetail, DockTabContextMenuEvent, type DragSelectRect, DragSnappingFn, DragTarget, EMPTY_FLAGS, EMPTY_GROUP_LABEL, EMPTY_KEYS, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, Endpoints, EntryMode, type FlatListActivateDetail, type FlatListActivateEvent, type FlatListBranchOrder, type FlatListContextMenuDetail, type FlatListContextMenuEvent, type FlatListDropDetail, type FlatListDropEvent, type FlatListEditCancelDetail, type FlatListEditCancelEvent, type FlatListEditCommitDetail, type FlatListEditCommitEvent, FlatListElement, type FlatListElementEventMap, type FlatListNavigateDetail, type FlatListNavigateEvent, type FlatListSelectDetail, type FlatListSelectEvent, type FlatListViewState, FormElement, FormGroupElement, FormOptionsElement, FormPartElement, FormRowElement, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GeodesicSegment, GetViewStateOptions, type GlobalFormatter, type GridListActivateDetail, type GridListActivateEvent, type GridListCaptionAlign, type GridListCaptionBackdrop, type GridListCaptionPosition, type GridListCaptionStyle, type GridListDataAdapter, GridListElement, type GridListElementEventMap, type GridListFullElementEventMap, type GridListItemClickDetail, type GridListItemClickEvent, type GridListItemEventDetail, type GridListOrientation, type GridListSelectDetail, type GridListSelectEvent, type GridListTickleDetail, type GridListTickleEvent, type GridListViewState, type GridListViewportChangeDetail, type GridListViewportChangeEvent, GridMode, GridResolution, GroupNode, GroupedItemListerElement, type GroupedItemListerElementEventMap, type GroupedSelectDetail, type GroupedSelectEvent, HexChangeDetail, HexChangeEvent, type HighlightOptions, type HighlightTarget, type HyperbolicEdgeRenderContext, type HyperbolicEdgeRenderer, type HyperbolicFocusDetail, type HyperbolicFocusEvent, type HyperbolicInteractionMode, type HyperbolicLayoutEdge, type HyperbolicLayoutNode, type HyperbolicNodeShape, type Point as HyperbolicPoint, HyperbolicTreeListElement, HyperbolicTreeListElementEventMap, type HyperbolicTreeListViewState, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IDataProvider, type IGroupedSubComponent, type IGroupedSubComponentEventMap, IcicleInteractionMode, IcicleOrientation, IcicleRect, IcicleTreeListElement, IcicleTreeListElementEventMap, IcicleValueAccessor, type IcicleViewState, IcicleZoomDetail, IcicleZoomEvent, type IconChangedDetail, type IconChangedEvent, type IconEntry, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, type InputMode, type ItemDisplay, type ItemOrientation, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxRatingElement, IxfxTimelineElement, KeyedElementIndex, LIST_ITEM_MOTION_MS, LIST_SEARCH_COMMAND_IDS, LIST_SEARCH_MODES, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LaneData, LaneType, LayoutNode, LayoutSnapshot, LeafGeom, LedElement, LedMode, type ListActivateDetail, type ListActivateEvent, type ListContextMenuDetail, type ListContextMenuEvent, type ListDragEntry, type ListDragLeaveDetail, type ListDragLeaveEvent, type ListDragOverEvent, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragPreviewSourceResolver, ListDragSelectController, type ListDragSelectControllerConfig, type ListDragSource, type ListDropDetail, type ListDropEvent, type ListEditCancelDetail, type ListEditCancelEvent, type ListEditCommitDetail, type ListEditCommitEvent, type ListElementEventMap, type ListGroupBy, type ListGroupChangeDetail, type ListGroupChangeEvent, type ListGroupEventMap, ListGroupHeaderElement, type ListGroupInfo, type ListGroupLabel, type ListGroupPartition, type ListGroupToggleDetail, type ListGroupToggleEvent, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListItemMotionOptions, type ListItemOutResult, ListNativeDragController, type ListNativeDragControllerConfig, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSearchAdapter, ListSearchController, type ListSearchControllerOptions, type ListSearchHost, type ListSearchMode, type ListSelectDetail, type ListSelectEvent, ListSelectionController, type ListSelectionControllerConfig, type ListSelectionGesture, type ListSelectionMode, type ListSelectionModes, type ListTickleDetail, type ListTickleEvent, type ListViewportChangeDetail, type ListViewportChangeEvent, LoadChildrenCallback, MAX_PENDING_KEYS, MarkerStyle, index_d_exports as Menu, type TreeActivateDetail as MillerActivateDetail, TreeActivateDetail, type TreeActivateEvent as MillerActivateEvent, TreeActivateEvent, MillerBaseElement, MillerBaseElementEventMap, type TreeCollapseDetail as MillerCollapseDetail, TreeCollapseDetail, type TreeCollapseEvent as MillerCollapseEvent, TreeCollapseEvent, type TreeExpandDetail as MillerExpandDetail, TreeExpandDetail, type TreeExpandEvent as MillerExpandEvent, TreeExpandEvent, MillerHeaderClickDetail, MillerHeaderClickEvent, MillerHeaderRightClickDetail, MillerHeaderRightClickEvent, type TreeItem as MillerItem, TreeItem, type TreeItemClickDetail as MillerItemClickDetail, TreeItemClickDetail, type TreeItemClickEvent as MillerItemClickEvent, TreeItemClickEvent, MillerItemDblClickDetail, MillerItemDblClickEvent, MillerItemRightClickDetail, MillerItemRightClickEvent, MillerItemState, MillerListElement, type MillerListViewState, type TreeNode as MillerNode, TreeNode, MillerRebaseDetail, MillerRebaseEvent, type TreeSelectDetail as MillerSelectDetail, TreeSelectDetail, type TreeSelectEvent as MillerSelectEvent, TreeSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, TreeTickleDetail, type TreeTickleEvent as MillerTickleEvent, TreeTickleEvent, MillerTreeController, MillerTreeControllerOptions, type MulticolCategory, type MulticolColumnState, MulticolColumnsChangeDetail, MulticolColumnsChangeEvent, type MulticolColumnsChangeReason, type MulticolItem, MulticolListElement, MulticolListElementEventMap, type MulticolListViewState, type MulticolQuery, type MulticolSelectDetail, MulticolSelectEvent, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, NoneSelectEventDetail, Notification, NotificationContent, NotificationManager, NotificationPillElement, NotificationPillElementEventMap, NotificationRenderer, NotificationRendererHooks, NotificationType, NotifierOptions, type OklchValue, Orientation, PanTextElement, PanTextMode, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupElementEventMap, PanelGroupOrientation, PanelGroupReorderDetail, PanelGroupReorderEvent, PanelInfo, PanelNode, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PendingFlags, PendingKeys, PillPosition, PillQueueDisplay, PillRendererOptions, PillSafeArea, PillTapDetail, PillTapEvent, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramInteractionMode, PlotHistogramOrientation, PlotHistogramSelectionChangeDetail, PlotHistogramSelectionChangeEvent, PlotHistogramSelectionRange, PlotHistogramValueTooltips, PlotMultiAxis, PlotMultiAxisDataPointClickDetail, PlotMultiAxisDataPointClickEvent, PlotMultiAxisElementEventMap, PlotMultiAxisLayout, PlotSingleAxis, PlotSingleAxisElementEventMap, PlotSingleAxisPointerMoveDetail, PlotSingleAxisPointerMoveEvent, PlotXyAxis, PolarPad, PolarPadInputDetail, PolarPadInputEvent, PopupItem, RadialInputChangeDetail, RadialInputChangeEvent, RadialInputElement, RadialInputInputDetail, RadialInputInputEvent, RadioGroup, RadioGroupChangeDetail, RadioGroupChangeEvent, RadioGroupMode, RadioItem, RangeElement, RangeInput, RangeMultiElement, RangeMultiInputDetail, RangeMultiInputEvent, RatingChangeDetail, RatingChangeEvent, RatingElement, RatingElementEventMap, RatingInputEvent, RatingVariant, type Rect, RectangularSelectEventDetail, type RegisterListSearchCommandsOptions, RendererStyle, ResizeMode, SCROLL_HOVER_SUPPRESS_ATTR, SUNBURST_PATH_SEPARATOR, ScrollAxis, type ScrollHoverGuard, type ScrollHoverGuardConfig, ScrollState, SegmentIconLookupFn, SelectEventDetail, SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap, SelectionMode, ShapefillDisplay, ShapefillFillMode, ShapefillValueChangeDetail, ShapefillValueChangeEvent, ShapefillValueElement, ShapefillValueInputDetail, ShapefillValueInputEvent, SingleAxisAgeStyle, SingleAxisDrawStyle, SingleSelectEventDetail, SliderChangedField, SliderCrossover, SliderHandleKey, SliderInputChangeDetail, SliderInputChangeEvent, SliderInputElement, SliderInputElementEventMap, SliderInputInputDetail, SliderInputInputEvent, SliderLaneData, SliderLaneType, SliderMarkerStyle, SliderOrientation, SliderSingleStyle, SliderValueCFollow, SliderValueDrag, SliderValueMode, SlidingNumberElement, SlidingNumberTrend, SnackbarDismiss, SnackbarElement, SnackbarMode, SnackbarPlacement, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic, SnapshotNode, SortCompareFn, type SortDirection, SplitButton, SplitButtonMode, SplitButtonSelectDetail, SplitButtonSelectEvent, SplitChangeDetail, SplitChangeEvent, SplitCloseDetail, SplitCloseEvent, SplitCollapseDetail, SplitCollapseEvent, SplitExpandDetail, SplitExpandEvent, SplitLayoutElement, SplitLayoutElementEventMap, SplitLayoutViewState, SplitPanelElement, SplitPanelViewState, SplitResizeDetail, SplitResizeEvent, type SubComponentActivateDetail, type SubComponentActivateEvent, type SubComponentFactory, type SubComponentItemClickDetail, type SubComponentItemClickEvent, type SubComponentSelectDetail, type SubComponentSelectEvent, type SubComponentTickleDetail, type SubComponentTickleEvent, SunburstArcVisual, SunburstInteractionMode, SunburstLabelPlacement, SunburstLayout, SunburstLayoutNode, SunburstRings, SunburstTreeListElement, SunburstTreeListElementEventMap, SunburstValueAccessor, SunburstValueFormatter, SunburstView, type SunburstViewState, SunburstZoomDetail, SunburstZoomEvent, SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent, SwitcherItem, Tab, TabAddOptions, TabController, TabControllerOptions, TabListChangeDetail, TabListChangeEvent, TabListDragMode, TabListElement, TabListItemElement, TabListReorderDetail, TabListReorderEvent, TabPanelElement, TabPanelsElement, TextShimmerElement, TickledController, type TickledControllerConfig, type TickledItem, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, TitlebarCloseEvent, TitlebarElement, TitlebarElementEventMap, TitlebarOrientation, TitlebarToggleDetail, TitlebarToggleEvent, TitlebarToggleInteraction, TitlebarVariant, ToolbarAlign, ToolbarElement, ToolbarElementEventMap, ToolbarGroupElement, ToolbarGroupReorderDetail, ToolbarGroupReorderEvent, ToolbarLayout, ToolbarLayoutSnapshot, ToolbarOrientation, ToolbarVerticalWriting, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeAnimation, TreeBaseElement, TreeBaseElementEventMap, type TreeCheckboxState, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeDndMode, TreeDragContext, TreeDragEndEvent, TreeDragOverEvent, TreeDragStartEvent, TreeDropApplyContext, TreeDropContext, TreeDropController, TreeDropControllerConfig, TreeDropDetail, TreeDropEvent, TreeDropPosition, TreeDropResolvedDrag, TreeDropRowInfo, TreeDropTarget, TreeDropVisibleRow, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeItemDblClickDetail, TreeItemDblClickEvent, type TreeKeyboardNavCallbacks, TreeKeyboardNavController, type TreeKeyboardNavControllerConfig, type TreeKeyboardNavItemId, TreeListAdapterOptions, TreeListElement, type TreeListSearchAdapterOptions, type TreeListViewState, TreeNavigateOptions, TreeRevealMode, TreeSearchHost, TreeSelectAllOptions, TreeSelectionFilter, TreeVirtualize, type TreemapInteractionMode, TreemapListElement, TreemapListElementEventMap, type TreemapListViewState, type TreemapRect, type TreemapTilingMethod, type TreemapValueAccessor, TreemapZoomDetail, TreemapZoomEvent, TwoSplitLayoutElement, TwoSplitLayoutViewState, TwoSplitPanelViewState, UserScale, VIEW_STATE_CHANGE, VIEW_STATE_VERSION, ValueMode, VerticalListAdapterOptions, VerticalListElement, VerticalListElementEventMap, type VerticalListViewState, ViewRange, ViewStateBase, ViewStateBinding, ViewStateChangeDetail, ViewStateChangeEvent, ViewStateChangeReason, ViewStateController, ViewStateControllerOptions, ViewStateful, WhenSmall, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, addPanelToStack, anchorFromRow, animateListItemIn, animateListItemOut, applyAgeModification, applyHighlights, applyIsometry, applySnapshot, applyTreeDrop, attachTimelineInteractions, bindViewState, bottomDrawerCommandId, buildHighlightTargets, buildModel, capFlags, capKeys, captionForEntry, captureElementScroll, clampToDisk, clearHighlights, collectContainerNames, collectDataResult, collectPanelIds, collectStackPaths, composeIsometry, computeCanonicalPositions, computeColour, computeHyperbolicLayout, computeIcicleLayout, computeLeafGeoms, computeSunburstLayout, computeTreemapLayout, createAcCompletionProvider, createDataListSearchAdapter, createDefaultListDragPreview, createElementIncrSearch, createElementListSearchAdapter, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createScrollHoverGuard, createSplit, createStack, createTreeListAdapter, createTreeListSearchAdapter, createValueResolver, createVerticalListAdapter, decomposeViewIsometry, defaultGroupLabel, defaultSunburstValueAccessor, distribute, dropTargetFor, euclideanRadiusForHyperbolicDistance, extractStack, findEmptiedStacks, findHyperbolicIdOf, findHyperbolicKeyPath, findHyperbolicNode, findHyperbolicPath, findHyperbolicPathById, findIcicleKeyPath, findIcicleNode, findIciclePath, findNode, findPanelNode, findParentOf, findStackOf, findStackPathByName, findSunburstId, findSunburstNodeById, findTreemapNode, findTreemapPath, flagsFromRecord, flagsToRecord, geodesicInterpolate, geodesicPath, geodesicSegment, getActiveDragPanelId, getIcon, getIconEntry, getIconFont, getLeafNeighbours, hasIcon, hyperbolicBranchId, hyperbolicChildIds, hyperbolicDistanceForEuclideanRadius, hyperbolicIdDepth, hyperbolicRelativeFrame, iconBus, identityIsometry, init, insertBeside, invertIsometry, isDragging, isHyperbolicDescendantId, isMultiMode, isSplit, isStack, isSunburstAncestorId, isViewStateful, keyForElement, keysAsFlags, keysToArray, listItemFadeKeyframes, listSearchStyles, mobiusAdd, mobiusFromOrigin, mobiusToOrigin, monitorIndeterminate, moveLeafNodeToEdge, moveLeafStep, norm, normalise, normaliseValue, normalize, onUserScrollIntent, panelGapIndex, parseColourScaleAttr, parseLayout, partitionByGroup, partitionFlags, partitionKeys, poincareDistance, pointerOverAnyHost, prefersReducedMotion, preserveRestoreWeights, pruneDraggedDescendants, readBaseColour, registerFontIcon, registerIcon, registerListSearchCommands, removePanelFromStack, resolveCssVars, resolveGrid, resolveGroupKey, resolveIcicleKeyPath, resolveLeafPath, resolveTracks, restoreElementScroll, rotationIsometry, scrollToOffset, serializeLayout, setActive, setIconFont, setPanelRestoreWeight, snapshotNonEmptyStacks, startListItemOutAnimation, sunburstChildId, sunburstHasChildren, sunburstIdToPath, sunburstParentId, sunburstPathToId, svgToDataUri, swapLeaves, tickledItemStyles, tickledStyles, timelineStyles, toGroupKey, toSnapshot, toggleInSet, toolbarGapIndex, translationFromOrigin, viewIsometry, walk, withoutFlag, wrapRoot };