@ixfx/components 0.3.2 → 0.4.0

package/bundle/index.d.ts

@@ -1,5 +1,5 @@
 import { FzfOptions } from "fzf";
-import { CommandRegistry, KeyboardManager } from "@clinth/ui-commands";
+import { CommandId, CommandRegistry, KeyboardManager } from "@clinth/ui-commands";
 
 //#region node_modules/.pnpm/@lit+reactive-element@2.1.2/node_modules/@lit/reactive-element/development/css-tag.d.ts
 /**
@@ -1054,7 +1054,7 @@ declare class IxfxIconElement extends LitElement {
   disconnectedCallback(): void;
   protected render(): typeof nothing | TemplateResult<1>;
   protected updated(changed: Map<string, unknown>): void;
-  static styles: CSSResult;
+  static styles: CSSResult[];
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -1163,7 +1163,6 @@ type AcTokenItem = {
   readonly data?: unknown;
   readonly positions?: ReadonlySet<number>;
 };
-type AcTokenCompletionProvider = (token: string, signal: AbortSignal) => Promise<AcTokenItem[]> | AcTokenItem[];
 type AcTokenizerFn = (text: string) => string[];
 type AcTokensChangeDetail = {
   readonly tokens: readonly AcTokenItem[];
@@ -1185,6 +1184,64 @@ interface AcTokenElementEventMap {
   'ac-token-remove': AcTokenRemoveEvent;
 }
 //#endregion
+//#region src/common/data-provider.d.ts
+/**
+ * Shared data-provider contract used by components that render a list of items.
+ *
+ * A provider is a simple callable — the consuming component (via DataController)
+ * manages the request lifecycle, cancellation, and reactive state.
+ */
+/**
+ * One batch of items within a streaming provider response.
+ *
+ * For sync and async one-shot providers, the DataController synthesises a single
+ * DataBatch internally — you only need this type when writing a streaming provider.
+ */
+type DataBatch<T> = {
+  /** Items delivered in this batch. */readonly items: readonly T[];
+  /**
+   * When true, replace all previously accumulated items with this batch instead
+   * of appending. Useful for re-ranked or filtered results mid-stream.
+   * Default: false (append).
+   */
+  replace?: boolean;
+  /**
+   * Provider's current estimate of the total number of items that will be
+   * delivered across all batches. Enables progress percentage in the consumer.
+   * May be refined in subsequent batches as the estimate improves.
+   * Omit when the total is unknown.
+   */
+  total?: number;
+};
+/**
+ * The three return modes a provider may use.
+ * DataController normalises all three — callers can mix modes freely.
+ *
+ * - `readonly T[]`                  — sync, items available immediately
+ * - `Promise<readonly T[]>`         — async one-shot, resolves to the full result
+ * - `AsyncIterable<DataBatch<T>>`   — streaming, batches arrive over time
+ */
+type DataProviderResult<T> = readonly T[] | Promise<readonly T[]> | AsyncIterable<DataBatch<T>>;
+/**
+ * A data provider callable.
+ *
+ * @typeParam TQuery - The input that scopes the request (e.g. `string` for
+ *   autocomplete, `{ node, depth }` for a tree branch, `void` for a plain list).
+ * @typeParam TItem  - The item type produced.
+ *
+ * The AbortSignal is cancelled when the consumer supersedes the request (e.g.
+ * a new query arrives before the previous one completes). Streaming providers
+ * should check `signal.aborted` between yields or pass the signal to their
+ * underlying fetch calls.
+ */
+type IDataProvider<TQuery, TItem> = (query: TQuery, signal: AbortSignal) => DataProviderResult<TItem>;
+/**
+ * Collects all items from any DataProviderResult into a flat array.
+ * Useful for components that need a complete list before rendering (e.g. tree branches).
+ * Respects the AbortSignal — stops accumulating if cancelled mid-stream.
+ */
+declare function collectDataResult<T>(result: DataProviderResult<T>, signal: AbortSignal): Promise<readonly T[]>;
+//#endregion
 //#region src/ac-token/ac-token.d.ts
 /**
  * Token/tag input with per-token autocomplete suggestions.
@@ -1205,7 +1262,7 @@ interface AcTokenElementEventMap {
 declare class AcTokenElement extends LitElement {
   #private;
   /** Provides completion results for the current draft token. */
-  completionProvider: AcTokenCompletionProvider | undefined;
+  completionProvider: IDataProvider<string, AcTokenItem> | undefined;
   /** Custom tokenizer — defaults to splitting on space, comma, semicolon. */
   tokenizer: AcTokenizerFn | undefined;
   /** Placeholder text shown when no tokens or draft text are present. */
@@ -1219,12 +1276,16 @@ declare class AcTokenElement extends LitElement {
    * When false (default), typing text and pressing Enter commits it as-is.
    */
   strict: boolean;
+  /**
+   * When false (default), tokens that have already been committed are
+   * filtered out of the suggestion list. Set to true to show all
+   * suggestions including duplicates.
+   */
+  allowDuplicates: boolean;
   private _tokens;
   private _draft;
   private _selectedTokenIndex;
-  private _suggestions;
   private _isOpen;
-  private _isLoading;
   private _tickled;
   constructor();
   get tokens(): readonly AcTokenItem[];
@@ -1498,10 +1559,10 @@ declare global {
   }
 } //# sourceMappingURL=split-button.d.ts.map
 //#endregion
-//#region src/checkbox.d.ts
+//#region src/checkbox/checkbox.d.ts
 declare class Checkbox extends LitElement {
   #private;
-  static styles: CSSResult;
+  static styles: CSSResult[];
   checked: boolean;
   disabled: boolean;
   indeterminate: boolean;
@@ -1556,7 +1617,38 @@ declare global {
   }
 } //# sourceMappingURL=types.d.ts.map
 //#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.12/node_modules/@ixfx/collections/dist/index-rrpZOWbs.d.ts
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/angles.d.ts
+/**
+* A angle with unit.
+* - [Degrees](https://en.wikipedia.org/wiki/Degree_(angle)): 0..360
+* - [Radians](https://en.wikipedia.org/wiki/Radian): 0...2Pi
+* - [Gradians](https://en.wikipedia.org/wiki/Gradian): 0..400
+* - [Turns](https://en.wikipedia.org/wiki/Turn_(angle)): 0..1
+*
+*
+* ```
+*             100 grad
+*             1/4 turn
+*              90 deg
+*             PI/2 rad
+*                |
+*  Pi rad        |        0 or 2PI rad
+*  180deg -------+------- 0 or 360 deg
+*  1/2 turn      |        0 or 1 turn
+*  200 grad      |        0 or 400 grad
+*                |
+*             270 deg
+*            3PI/2 rad
+*             3/4 turn
+*             300 grad
+* ```
+*/
+type Angle = {
+  value: number;
+  unit: `deg` | `rad` | `turn` | `grad`;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/index-rrpZOWbs.d.ts
 /**
 * Traversable Tree.
 *
@@ -1584,7 +1676,7 @@ type TraversableTree<TValue> = {
   getIdentity: () => any;
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+random@0.56.12/node_modules/@ixfx/random/dist/index.d.ts
+//#region node_modules/.pnpm/@ixfx+random@0.56.13/node_modules/@ixfx/random/dist/index.d.ts
 //#region src/types.d.ts
 /**
 * A random source.
@@ -1593,32 +1685,7 @@ type TraversableTree<TValue> = {
 */
 type RandomSource = () => number;
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/index.d.ts
-type Angle = {
-  value: number;
-  unit: `deg` | `rad` | `turn` | `grad`;
-};
-/**
-* Parses CSS-style angle strings into an 'Angle' type. By default assumes degrees.
-* 
-* ```js
-* angleParse(`100`);     // { value: 100, unit: `deg` }
-* angleParse(100);       // { value: 100, unit: `deg` }
-* angleParse(`100deg`);  // { value: 100, unit: `deg` }
-* 
-* // More exotic units:
-* angleParse(`100rad`);  // { value: 100, unit: `rad` }
-* angleParse(`100turn`); // { value: 100, unit: `turn` }
-* angleParse(`100grad`); // { value: 100, unit: `grad` }
-* ```
-* 
-* Once parsed in this format, use {@link angleConvert} to convert to
-* a different unit.
-* @param value 
-* @returns 
-*/
-//#endregion
-//#region node_modules/.pnpm/@ixfx+visual@0.56.12/node_modules/@ixfx/visual/dist/index-a3KMyMEu.d.ts
+//#region node_modules/.pnpm/@ixfx+visual@0.56.13/node_modules/@ixfx/visual/dist/index-a3KMyMEu.d.ts
 //#region src/colour/types.d.ts
 type HslBase = {
   /**
@@ -2843,6 +2910,80 @@ declare global {
   }
 }
 //#endregion
+//#region src/common/data-controller.d.ts
+type DataControllerOptions = {
+  /**
+   * Clear accumulated items immediately when request() is called.
+   * When false, stale items remain visible while the new request is in-flight
+   * (useful for re-query-on-keystroke patterns — avoids a blank flash).
+   * Default: true.
+   */
+  clearOnRequest?: boolean;
+  /**
+   * Called when the provider throws or rejects. Useful for logging without
+   * coupling the error to render logic.
+   */
+  onError?: (err: unknown) => void;
+};
+/**
+ * Lit ReactiveController that manages one active data provider request at a time.
+ *
+ * Handles all three provider return modes (sync, async one-shot, streaming),
+ * tracks progress, and cancels in-flight requests when a new one starts.
+ * Calls host.requestUpdate() on every state change so the component re-renders
+ * automatically.
+ *
+ * @typeParam TQuery - The query/scope type passed to the provider.
+ * @typeParam TItem  - The item type produced by the provider.
+ *
+ * @example
+ * ```ts
+ * class MyList extends LitElement {
+ *   #data = new DataController<string, MyItem>(this, myProvider);
+ *
+ *   protected override render() {
+ *     return html`
+ *       ${this.#data.loading ? html`<span>Loading…</span>` : nothing}
+ *       ${this.#data.items.map(item => html`<div>${item.label}</div>`)}
+ *     `;
+ *   }
+ * }
+ * ```
+ */
+declare class DataController<TQuery, TItem> implements ReactiveController {
+  #private;
+  constructor(host: ReactiveControllerHost, provider?: IDataProvider<TQuery, TItem>, options?: DataControllerOptions);
+  hostConnected(): void;
+  hostDisconnected(): void;
+  get provider(): IDataProvider<TQuery, TItem> | undefined;
+  set provider(value: IDataProvider<TQuery, TItem> | undefined);
+  /** The currently accumulated items. */
+  get items(): readonly TItem[];
+  /** True while a provider call is pending or a stream is still open. */
+  get loading(): boolean;
+  /** Number of items accumulated so far in the current request. */
+  get loaded(): number;
+  /**
+   * Provider's latest estimate of the total number of items expected.
+   * Undefined when the provider has not reported a total.
+   */
+  get total(): number | undefined;
+  /**
+   * Progress as a 0–1 value, or undefined when total is unknown.
+   * Derived from loaded / total.
+   */
+  get progress(): number | undefined;
+  /** The last error thrown by the provider, or undefined if the last request succeeded. */
+  get error(): unknown;
+  /**
+   * Cancel any in-flight request and start a new one.
+   * Clears items immediately unless clearOnRequest was set to false.
+   */
+  request(query: TQuery): void;
+  /** Abort any in-flight request without issuing a new one. */
+  cancel(): void;
+}
+//#endregion
 //#region src/common/types.d.ts
 /**
  * Canonical shared types for all tree-like components (ixfx-tree-list, ixfx-miller-list,
@@ -2872,8 +3013,12 @@ type TreeNode = {
 /**
  * Callback invoked when a node's children need to be loaded.
  * The AbortSignal is cancelled if the request is superseded (e.g. node collapsed before load completes).
+ * May return children synchronously, as a promise, or as a streaming async iterable of batches.
  */
-type LoadChildrenCallback = (node: TreeNode, depth: number, signal: AbortSignal) => TreeNode[] | Promise<TreeNode[]>;
+type LoadChildrenCallback = IDataProvider<{
+  node: TreeNode;
+  depth: number;
+}, TreeNode>;
 /**
  * Predicate used by search/filter controllers to determine whether a node should be visible.
  * Receives depth so column-scoped filtering (e.g. in ixfx-miller-list) is possible.
@@ -3405,21 +3550,26 @@ declare class CrumbPathController {
   disconnect(): void;
 }
 //#endregion
-//#region src/data-display.d.ts
+//#region src/data-display/data-display.d.ts
+type RendererStyle = `led` | `plot` | `plot-xy` | `plot-heat` | `plot-histogram` | `time-elapsed` | `hide`;
+type ConfigEntry = readonly [path: string, style: RendererStyle, options?: Record<string, unknown>];
 type FormattingOptions = {
   readonly precision?: number;
   readonly roundNumbers?: number;
 };
 declare class DataDisplayComponent extends LitElement {
-  static styles: CSSResult;
+  #private;
+  static styles: CSSResult[];
+  automap: boolean;
   previousValue: Record<string, unknown> | undefined;
   _container: HTMLElement;
   constructor();
   connectedCallback(): void;
+  configure(config: ConfigEntry[]): void;
   formatValue(v: unknown, options?: FormattingOptions): string;
   displayData(o: Record<string, unknown> | unknown[]): void;
-  getOrCreate(path: string, init?: (parent: HTMLElement) => void): HTMLElement;
   updateData(value: Record<string, unknown>): void;
+  getOrCreate(path: string, init?: (parent: HTMLElement) => void): HTMLElement;
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -3560,146 +3710,781 @@ declare global {
   }
 } //# sourceMappingURL=editable-number.d.ts.map
 //#endregion
-//#region src/hex/types.d.ts
-type BytePos = number;
-type SingleSelection = {
-  readonly kind: `single`;
-  readonly pos: BytePos;
+//#region src/vertical-list/types.d.ts
+type ListSelectionMode = `none` | `single` | `multiple`;
+/**
+ * Controls how pointer and keyboard gestures map to selection changes.
+ *
+ * - `implicit`  — click always replaces selection (no modifier support)
+ * - `standard`  — click replaces; Ctrl/Cmd+click toggles; Shift+click range-selects (multiple only)
+ * - `manual`    — no auto-selection; drive state via select()/deselect()/clearSelection()
+ * - `checked`   — every click toggles; implies multiple selection regardless of selectionMode
+ * - `vscode`    — like standard for clicks; Shift+Arrow extends range from the keyboard anchor
+ *
+ * Switching interactionMode clears the current selection.
+ */
+type ListInteractionMode = `implicit` | `standard` | `manual` | `checked` | `vscode`;
+type ListSelectDetail = {
+  readonly selected: ReadonlySet<Element>;
+  readonly previous: ReadonlySet<Element>;
 };
-type ContiguousSelection = {
-  readonly kind: `contiguous`;
-  readonly start: BytePos;
-  readonly end: BytePos;
+type ListTickleDetail = {
+  readonly item: Element;
 };
-type RectangularSelection = {
-  readonly kind: `rectangular`;
-  readonly x: number;
-  readonly y: number;
-  readonly width: number;
-  readonly height: number;
+type ListActivateDetail = {
+  readonly item: Element;
 };
-type Selection = SingleSelection | ContiguousSelection | RectangularSelection | null;
-type DiffEntry = {
-  readonly before: number;
-  readonly after: number;
+type ListItemClickDetail = {
+  readonly item: Element;
 };
-type Diff = ReadonlyMap<BytePos, DiffEntry>;
-type ColourScheme = `ascii` | `shade`;
-//#endregion
-//#region src/hex/hex-editor.d.ts
-declare class IxfxHexEditorElement extends LitElement {
-  columns: number;
-  colourScheme: ColourScheme;
-  showChangeset: boolean;
-  hideOffsetCol: boolean;
-  hideHexCol: boolean;
-  hideTextCol: boolean;
-  private _selection;
-  private _scrollTop;
-  private _editState;
-  private _containerH;
-  private _shadeMap;
-  private _focusSide;
-  private _store;
-  private _undoStack;
-  private _copyBuffer;
-  private _rowHeight;
-  private _dragStart;
-  private _dragAnchor;
-  private _rectAnchorX;
-  private _rectAnchorY;
-  private _rectAnchorXFromKeyboard;
-  private _rectAnchorYFromKeyboard;
-  private _initialSelectionPoint;
-  private _currentCursorPoint;
-  private _pointerMode;
-  private _currentDragDiff;
-  private _shiftClickTarget;
-  static styles: CSSResult;
-  setData(data: Uint8Array): void;
-  undo(): void;
-  redo(): void;
-  recomputeColours(): void;
-  selectedBytes(): Generator<{
-    selection_index: number;
-    array_index: number;
-    value: number;
-  }>;
-  containsPosition(pos: number): boolean;
-  selectSingle(position: number): void;
-  selectContiguous(start: number, end: number): void;
-  selectRectangular(x: number, y: number, width: number, height: number): void;
-  clearSelection(): void;
-  getSelection(): Selection;
-  protected firstUpdated(): void;
-  private _onScroll;
-  private _onPointerDown;
-  private _onPointerMove;
-  private _onPointerUp;
-  private _onKeyDown;
-  private _handleBackspace;
-  private _handleValueEntry;
-  private _commitDecimalValue;
-  private _advanceCursor;
-  private _dispatchChangeEvent;
-  private _dispatchSelectEvent;
-  private _copy;
-  private _paste;
-  private _parseHexString;
-  private _getColHeaders;
-  private _isRowShaded;
-  private _isHexShaded;
-  private _isTextShaded;
-  protected render(): TemplateResult<1>;
-  private _renderRow;
-  private _renderColumn;
-  private _renderHexCell;
-  private _renderTextChar;
+type ListSelectEvent = CustomEvent<ListSelectDetail>;
+type ListTickleEvent = CustomEvent<ListTickleDetail>;
+type ListActivateEvent = CustomEvent<ListActivateDetail>;
+type ListItemClickEvent = CustomEvent<ListItemClickDetail>;
+interface ListElementEventMap {
+  'list-select': ListSelectEvent;
+  'list-tickle': ListTickleEvent;
+  'list-activate': ListActivateEvent;
+  'list-item-click': ListItemClickEvent;
 }
-type HexChangeDetail = {
-  readonly diff: Diff;
-};
-type HexChangeEvent = CustomEvent<HexChangeDetail>;
-type SingleSelectEventDetail = {
-  readonly type: `single`;
-  readonly position: number;
-};
-type ContiguousSelectEventDetail = {
-  readonly type: `contiguous`;
-  readonly start: number;
-  readonly end: number;
-};
-type RectangularSelectEventDetail = {
-  readonly type: `rectangular`;
-  readonly x: number;
-  readonly y: number;
-  readonly width: number;
-  readonly height: number;
-};
-type NoneSelectEventDetail = {
-  readonly type: `none`;
-};
-type SelectEventDetail = SingleSelectEventDetail | ContiguousSelectEventDetail | RectangularSelectEventDetail | NoneSelectEventDetail;
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-hex-editor': IxfxHexEditorElement;
-  }
-} //# sourceMappingURL=hex-editor.d.ts.map
 //#endregion
-//#region src/icons/defaults.d.ts
+//#region src/grouped-item-lister/types.d.ts
 /**
- * Chevron pointing down. Used for split-button dropdown toggle.
- * fill="currentColor" so it inherits CSS color.
+ * Fired when the selection set changes by any means.
+ * Event name: `select`
  */
-declare const ICON_CHEVRON_DOWN = "<svg viewBox=\"0 0 20 20\" fill=\"currentColor\" aria-hidden=\"true\"><path d=\"M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z\"/></svg>";
+type SubComponentSelectDetail<T> = {
+  readonly selected: ReadonlySet<T>;
+  readonly previous: ReadonlySet<T>;
+};
 /**
- * Caret pointing right. Used for tree-basic expand indicator as a CSS mask.
- * fill="black" is correct for CSS mask-image use (shape only, color comes from background-color).
+ * Fired when an item is explicitly activated (double-click or Enter key).
+ * Event name: `activate`
  */
-declare const ICON_CARET_RIGHT = "<svg viewBox=\"0 0 24 24\" fill=\"black\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 7l6 5-6 5V7z\"/></svg>";
+type SubComponentActivateDetail<T> = {
+  readonly item: T;
+};
 /**
- * Checkmark. Useful for menu-check-item or confirmation states.
- * fill="currentColor" so it inherits CSS color.
+ * Fired on a raw pointer click before any selection change.
+ * Event name: `item-click`
+ */
+type SubComponentItemClickDetail<T> = {
+  readonly item: T;
+};
+/**
+ * Fired when the pointer hovers over an item or the keyboard cursor moves to it.
+ * Event name: `tickle`
+ */
+type SubComponentTickleDetail<T> = {
+  readonly item: T;
+};
+type SubComponentSelectEvent<T> = CustomEvent<SubComponentSelectDetail<T>>;
+type SubComponentActivateEvent<T> = CustomEvent<SubComponentActivateDetail<T>>;
+type SubComponentItemClickEvent<T> = CustomEvent<SubComponentItemClickDetail<T>>;
+type SubComponentTickleEvent<T> = CustomEvent<SubComponentTickleDetail<T>>;
+interface IGroupedSubComponentEventMap<T> {
+  'select': SubComponentSelectEvent<T>;
+  'activate': SubComponentActivateEvent<T>;
+  'item-click': SubComponentItemClickEvent<T>;
+  'tickle': SubComponentTickleEvent<T>;
+}
+/**
+ * Contract that sub-components passed to `ixfx-grouped-item-lister` must satisfy.
+ *
+ * All four events (`select`, `activate`, `item-click`, `tickle`) must bubble and be composed
+ * so they propagate through the lister's light DOM to external listeners.
+ */
+interface IGroupedSubComponent<T> extends HTMLElement {
+  /** Replace the full item list. Called whenever the lister's items or grouping changes. */
+  setItems(items: readonly T[]): void;
+  /** Clear the current selection without firing a `select` event (avoids re-entrant loops). */
+  clearSelection(): void;
+  /** The current selection set. */
+  readonly selectedItems: ReadonlySet<T>;
+  /** Controls how many items can be selected simultaneously. */
+  selectionMode: ListSelectionMode;
+  /**
+   * Forward a command (e.g. sort-order change) to this sub-component.
+   * Uses `CommandId` from `@clinth/ui-commands` for interoperability.
+   */
+  dispatch(commandId: CommandId, args?: Record<string, unknown>): void;
+  addEventListener<K extends keyof IGroupedSubComponentEventMap<T>>(type: K, listener: (event: IGroupedSubComponentEventMap<T>[K]) => void, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+/**
+ * Factory that creates a sub-component for a given group.
+ * Called once per group (or once with `undefined` in ungrouped mode).
+ */
+type SubComponentFactory<T> = (groupKey: string | undefined) => HTMLElement & IGroupedSubComponent<T>;
+/**
+ * Fired by `ixfx-grouped-item-lister` after any sub-component fires `select`.
+ * Carries the full cross-group selection union and the key of the group whose
+ * selection just changed (or `undefined` in ungrouped mode).
+ */
+type GroupedSelectDetail<T> = {
+  readonly selected: ReadonlySet<T>;
+  readonly groupKey: string | undefined;
+};
+type GroupedSelectEvent<T> = CustomEvent<GroupedSelectDetail<T>>;
+interface GroupedItemListerElementEventMap<T> {
+  'grouped-select': GroupedSelectEvent<T>;
+}
+//#endregion
+//#region src/panel/panel.d.ts
+type PanelOrientation = `horizontal` | `vertical`;
+type PanelVariant = `titlebar` | `midline`;
+type PanelToggleInteraction = `implicit` | `explicit` | `disabled`;
+interface PanelToggleDetail {
+  readonly collapsed: boolean;
+}
+type PanelToggleEvent = CustomEvent<PanelToggleDetail>;
+type PanelCloseEvent = CustomEvent<void>;
+interface PanelElementEventMap {
+  toggle: PanelToggleEvent;
+  close: PanelCloseEvent;
+}
+declare class PanelElement extends LitElement {
+  collapsed: boolean;
+  orientation: PanelOrientation;
+  closable: boolean;
+  title: string;
+  iconName: string;
+  toggleInteraction: PanelToggleInteraction;
+  variant: PanelVariant;
+  private _isVertical;
+  private _onToggleClick;
+  private _onCloseClick;
+  private _getCaretIcon;
+  protected updated(changed: Map<string, unknown>): void;
+  protected render(): TemplateResult<1>;
+  static styles: CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-panel': PanelElement;
+  }
+}
+interface PanelElement {
+  addEventListener: (<K extends keyof PanelElementEventMap>(type: K, listener: (this: PanelElement, event: PanelElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+//#region src/grouped-item-lister/grouped-item-lister.d.ts
+declare class GroupedItemListerElement<T = unknown> extends LitElement {
+  #private;
+  grouped: boolean;
+  crossGroupSelection: boolean;
+  get groupBy(): ((item: T) => string) | undefined;
+  set groupBy(value: ((item: T) => string) | undefined);
+  get factory(): SubComponentFactory<T> | undefined;
+  set factory(value: SubComponentFactory<T> | undefined);
+  get provider(): IDataProvider<void, T> | undefined;
+  set provider(value: IDataProvider<void, T> | undefined);
+  /** The union of all selected items across every sub-component. */
+  get selectedItems(): ReadonlySet<T>;
+  /**
+   * Forward a command to all live sub-components.
+   * Use this to propagate changes like sort order, filter state, or view mode.
+   */
+  dispatch(commandId: CommandId, args?: Record<string, unknown>): void;
+  protected createRenderRoot(): this;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  protected updated(changed: PropertyValues): void;
+  protected render(): typeof nothing | TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-grouped-item-lister': GroupedItemListerElement;
+  }
+}
+interface GroupedItemListerElement<T> {
+  addEventListener<K extends keyof GroupedItemListerElementEventMap<T>>(type: K, listener: (this: GroupedItemListerElement<T>, event: GroupedItemListerElementEventMap<T>[K]) => void, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+//#endregion
+//#region src/interaction/tickled-controller.d.ts
+/**
+ * Represents an item that can be tickled (highlighted via hover or keyboard navigation)
+ */
+type TickledItem<T = unknown> = {
+  /**
+   * Unique identifier for the item (e.g., index, id, path)
+   */
+  readonly id: T;
+  /**
+   * Whether the item is currently enabled/interactive
+   */
+  readonly enabled?: boolean;
+};
+/**
+ * Input mode determines which mechanism controls the tickled state
+ */
+type InputMode = `keyboard` | `mouse`;
+/**
+ * Configuration for TickledController
+ */
+type TickledControllerConfig<T> = {
+  /**
+   * Function to retrieve all items that can be tickled
+   */
+  getItems: () => ReadonlyArray<TickledItem<T>>;
+  /**
+   * Optional callback when an item becomes tickled
+   * Use this for side effects like opening submenus
+   * @param id - The id of the newly tickled item, or undefined if nothing is tickled
+   */
+  onTickle?: (id: T | undefined) => void;
+  /**
+   * Optional callback fired after any state change (tickled id or input mode)
+   * Use this to sync DOM attributes for slotted content that can't use reactive rendering
+   *
+   * For components that render items directly, this is usually not needed as
+   * Lit's reactive rendering will handle updates automatically via requestUpdate()
+   *
+   * @example
+   * ```ts
+   * onStateChange: () => {
+   *   // Sync data-tickled attributes for slotted items
+   *   const items = this.getItems();
+   *   items.forEach((item, i) => {
+   *     if (this.tickled.isTickled(i)) {
+   *       item.setAttribute('data-tickled', '');
+   *     } else {
+   *       item.removeAttribute('data-tickled');
+   *     }
+   *   });
+   * }
+   * ```
+   */
+  onStateChange?: () => void;
+  /**
+   * Optional initial input mode (defaults to 'mouse')
+   */
+  initialInputMode?: InputMode;
+};
+/**
+ * ReactiveController that manages "tickled" state for interactive lists.
+ *
+ * A "tickled" item is one that is under active attention via hover (mouse mode)
+ * or keyboard focus (keyboard mode). Only one item can be tickled at a time.
+ *
+ * The input mode determines which mechanism controls tickled state:
+ * - Mouse mode: hover controls tickled, keyboard navigation ignored
+ * - Keyboard mode: keyboard navigation controls tickled, hover ignored
+ *
+ * Last interaction wins - any mouse hover switches to mouse mode, any keyboard
+ * navigation switches to keyboard mode.
+ *
+ * ## Global Mouse Tracking
+ *
+ * This controller uses a singleton global `pointermove` listener to track actual
+ * mouse movement. This prevents `pointerenter` events caused by content scrolling
+ * from incorrectly switching to mouse mode when the user is actually using keyboard
+ * navigation.
+ *
+ * @example
+ * ```ts
+ * class MyList extends LitElement {
+ *   private tickled = new TickledController(this, {
+ *     getItems: () => this.items.map((item, i) => ({ id: i, enabled: !item.disabled })),
+ *     onTickle: (id) => {
+ *       // Optional: perform side effect when item is tickled
+ *       console.log('Tickled item:', id);
+ *     }
+ *   });
+ *
+ *   render() {
+ *     return html`
+ *       <ul @pointerleave=${(e) => this.tickled.handlePointerLeave(e)}>
+ *         ${this.items.map((item, i) => html`
+ *           <li
+ *             class="item ${this.tickled.isTickled(i) ? 'tickled' : ''}"
+ *             @pointerenter=${() => this.tickled.handlePointerEnter(i)}
+ *           >${item.label}</li>
+ *         `)}
+ *       </ul>
+ *     `;
+ *   }
+ *
+ *   private handleKeyDown(e: KeyboardEvent) {
+ *     if (e.key === 'ArrowDown') {
+ *       this.tickled.handleKeyboardNavigation('next');
+ *     } else if (e.key === 'ArrowUp') {
+ *       this.tickled.handleKeyboardNavigation('previous');
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class TickledController<T = number> implements ReactiveController {
+  private host;
+  private config;
+  private _tickledId;
+  private _inputMode;
+  private static _lastMouseClientX;
+  private static _lastMouseClientY;
+  private static _mouseMovedSinceKeyboard;
+  private static _globalListenerAttached;
+  constructor(host: ReactiveControllerHost, config: TickledControllerConfig<T>);
+  hostConnected(): void;
+  hostDisconnected(): void;
+  /**
+   * Get the current input mode
+   */
+  get inputMode(): InputMode;
+  /**
+   * Get the currently tickled item id
+   */
+  get tickledId(): T | undefined;
+  /**
+   * Check if a specific item is tickled
+   */
+  isTickled(id: T): boolean;
+  /**
+   * Handle global pointer move event.
+   * Called automatically by the global listener.
+   * Tracks mouse movement to distinguish real hover from content scrolling.
+   */
+  private static handleGlobalPointerMove;
+  /**
+   * Check if actual mouse movement has occurred since last keyboard interaction.
+   * Used to distinguish real hover/leave from content-scrolling-induced events.
+   */
+  static get hasMouseMovedSinceKeyboard(): boolean;
+  /**
+   * Handle pointer enter event on an item (mouse hover).
+   * Only processes if actual mouse movement is detected (not content scrolling).
+   * Switches to mouse mode and tickles the item.
+   */
+  handlePointerEnter(id: T): void;
+  /**
+   * Handle pointer leave event on an item.
+   * Only clears tickled state if actual mouse movement is detected.
+   * @param _e The pointer event (not used, but kept for API compatibility)
+   */
+  handlePointerLeave(_e: PointerEvent): void;
+  /**
+   * Handle keyboard navigation.
+   * Switches to keyboard mode and moves tickled state.
+   *
+   * @param direction - 'next', 'previous', 'first', 'last', or specific id
+   */
+  handleKeyboardNavigation(direction: `next` | `previous` | `first` | `last` | T): void;
+  /**
+   * Manually set the tickled item (useful for programmatic control).
+   * Does NOT change input mode.
+   */
+  setTickled(id: T | undefined): void;
+  /**
+   * Clear the tickled state (e.g., on pointer leave).
+   * Note: For pointer leave events, prefer using handlePointerLeave() which
+   * checks for actual mouse movement.
+   */
+  clearTickled(): void;
+  /**
+   * Manually set the input mode.
+   * When switching to keyboard mode, resets the mouse movement tracking.
+   */
+  setInputMode(mode: InputMode): void;
+}
+//#endregion
+//#region src/tree/tree-base.d.ts
+declare class TreeBaseElement extends LitElement implements TreeComponent, TreeSearchHost {
+  #private;
+  root: TreeNode | undefined;
+  model: TreeDataModel | undefined;
+  /** Callback to lazily load children for a node. Superseded by `model` when both are set. */
+  loadChildren: LoadChildrenCallback | undefined;
+  exclusivity: TreeExclusivity;
+  selectionFilter: TreeSelectionFilter;
+  /** Controls how pointer/keyboard gestures map to selection changes. Default: `'standard'`. */
+  interactionMode: TreeInteractionMode;
+  selectedNode: TreeNode | undefined;
+  protected _selectedNodes: Set<TreeNode>;
+  get selectedNodes(): ReadonlySet<TreeNode>;
+  filterPredicate: TreeFilterPredicate | undefined;
+  disableKeyboardNavigation: boolean;
+  protected _expandedKeys: Set<string>;
+  protected tickled: TickledController<string>;
+  protected _focusedDepth: number;
+  updated(changedProps: PropertyValues): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  getConfig(): TreeConfig;
+  setConfig(config: Partial<TreeConfig>): void;
+  select(node: TreeNode): void;
+  deselect(node: TreeNode): void;
+  clearSelection(): void;
+  navigateTo(keys: readonly string[]): boolean;
+  navigateToNode(predicate: (node: TreeNode) => boolean): boolean;
+  getNodes(): ReadonlyArray<{
+    node: TreeNode;
+    depth: number;
+  }>;
+  protected renderNodeContent(node: TreeNode, _depth: number): TemplateResult | typeof nothing;
+  protected _handleItemClick(node: TreeNode, depth: number, event?: MouseEvent): void;
+  protected _handleCheckboxClick(event: MouseEvent, node: TreeNode, _depth: number): void;
+  protected _isSelected(node: TreeNode): boolean;
+  protected _isFocused(node: TreeNode): boolean;
+  protected _isExpanded(node: TreeNode): boolean;
+  protected get _pendingNode(): TreeNode | undefined;
+  protected renderLoadingIndicator(): TemplateResult | typeof nothing;
+  protected render(): TemplateResult<1>;
+  protected _renderNode(node: TreeNode, depth: number): TemplateResult;
+  static styles: CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-tree-base': TreeBaseElement;
+  }
+}
+interface TreeBaseElementEventMap extends TreeComponentEventMap {
+  'item-click': TreeItemClickEvent;
+  'expand': TreeExpandEvent;
+  'collapse': TreeCollapseEvent;
+  'select': TreeSelectEvent;
+  'tickle': TreeTickleEvent;
+  'activate': TreeActivateEvent;
+}
+interface TreeBaseElement {
+  addEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+  removeEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);
+}
+//#endregion
+//#region src/tree/tree-list.d.ts
+declare class TreeListElement extends TreeBaseElement {
+  #private;
+  protected render(): TemplateResult<1>;
+  protected renderNodeContent(node: TreeNode, depth: number): TemplateResult;
+  protected _renderNode(node: TreeNode, depth: number): TemplateResult;
+  static styles: CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-tree-list': TreeListElement;
+  }
+}
+interface TreeListElement {
+  addEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeListElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+//#region src/grouped-item-lister/tree-list-adapter.d.ts
+type TreeListAdapterOptions<T> = {
+  /**
+   * Returns the direct children of an item to build the tree hierarchy.
+   * Omit for flat item lists — all items become leaf nodes at the root level.
+   */
+  getChildren?: (item: T) => readonly T[]; /** Forwarded to the inner ixfx-tree-list. Default: `'standard'`. */
+  interactionMode?: TreeInteractionMode;
+  /**
+   * Controls which node types are selectable.
+   * Forwarded to the inner ixfx-tree-list. Default: `'all'`.
+   */
+  selectionFilter?: TreeSelectionFilter;
+  /**
+   * Controls how expanding one node affects its siblings.
+   * Forwarded to the inner ixfx-tree-list. Default: `'none'`.
+   */
+  exclusivity?: TreeExclusivity;
+  /**
+   * Called when a command is dispatched via `ixfx-grouped-item-lister.dispatch()`.
+   * Receives the inner `TreeBaseElement` (undefined until the first `setItems()` call)
+   * so the handler can sort, filter, or otherwise manipulate the tree directly.
+   */
+  onDispatch?: (commandId: CommandId, args: Record<string, unknown> | undefined, tree: TreeBaseElement | undefined) => void;
+};
+/**
+ * Creates an `HTMLElement` that implements `IGroupedSubComponent<T>` by wrapping
+ * an `ixfx-tree-list` internally.
+ *
+ * `toTreeItem` converts each item `T` to display metadata (`key`, `label`, etc).
+ * The adapter stores the original `T` in `TreeItem.data` and uses it to map
+ * tree-node selections back to typed values.
+ *
+ * Unlike `createVerticalListAdapter`, items can be hierarchical: provide
+ * `options.getChildren` to return each item's children and the adapter will
+ * recursively build the `TreeNode` tree. Omit it for a flat list of leaf nodes.
+ *
+ * The four interface events (`select`, `activate`, `item-click`, `tickle`) are
+ * intercepted at the tree level, re-typed from `TreeNode` → `T`, and re-dispatched
+ * on the adapter element so `ixfx-grouped-item-lister` can identify the source.
+ *
+ * @example Flat item list:
+ * ```ts
+ * lister.factory = () =>
+ *   createTreeListAdapter<FileItem>(item => ({ key: item.id, label: item.name, isLeaf: true }));
+ * ```
+ *
+ * @example Hierarchical items:
+ * ```ts
+ * lister.factory = () =>
+ *   createTreeListAdapter<Category>(
+ *     cat => ({ key: cat.id, label: cat.name }),
+ *     { getChildren: cat => cat.subCategories },
+ *   );
+ * ```
+ */
+declare function createTreeListAdapter<T>(toTreeItem: (item: T) => Omit<TreeItem, 'data'>, options?: TreeListAdapterOptions<T>): HTMLElement & IGroupedSubComponent<T>;
+//#endregion
+//#region src/vertical-list/vertical-list.d.ts
+declare class VerticalListElement extends LitElement {
+  #private;
+  selectionMode: ListSelectionMode;
+  interactionMode: ListInteractionMode;
+  filterPredicate: ((el: Element) => boolean) | undefined;
+  private _selectedItems;
+  private _searchVisible;
+  private _searchQuery;
+  private _searchInputEl;
+  private tickled;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  firstUpdated(): void;
+  updated(changed: PropertyValues): void;
+  /** The most recently selected item, or `undefined` if nothing is selected. */
+  get selectedItem(): Element | undefined;
+  /** The full current selection set (read-only). */
+  get selectedItems(): ReadonlySet<Element>;
+  addItem(item: Element | string): void;
+  removeItem(item: Element): void;
+  clearItems(): void;
+  /**
+   * Replace the entire item list in one call.
+   * Equivalent to `clearItems()` followed by `addItem()` for each element.
+   * Preserves `interactionMode` checkbox wrapping.
+   */
+  setItems(items: readonly Element[]): void;
+  /**
+   * Dispatch a command to this list. No-op by default.
+   * Intended for use with `ixfx-grouped-item-lister`'s `dispatch()` method,
+   * which forwards commands to all sub-components.
+   */
+  dispatch(_commandId: CommandId, _args?: Record<string, unknown>): void;
+  select(item: Element): void;
+  selectMany(items: Iterable<Element>): void;
+  deselect(item: Element): void;
+  clearSelection(): void;
+  selectAll(): void;
+  private _replaceSelection;
+  private _toggleItem;
+  private _rangeSelectTo;
+  private _clearSelection;
+  private _selectAll;
+  private _handleClickSelection;
+  private _handleSpaceKey;
+  private _getVisibleItems;
+  private _syncItemStates;
+  private _syncCheckboxes;
+  private _findListItem;
+  private _dispatch;
+  private _openSearch;
+  private _closeSearch;
+  private _onPointerOver;
+  private _onPointerLeave;
+  private _onKeyDown;
+  private _onClick;
+  private _onDblClick;
+  private _activateItem;
+  private _onSearchInput;
+  private _onSearchKeydown;
+  static styles: CSSResult[];
+  render(): TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-vertical-list': VerticalListElement;
+  }
+  interface HTMLElementEventMap extends ListElementEventMap {}
+} //# sourceMappingURL=vertical-list.d.ts.map
+//#endregion
+//#region src/grouped-item-lister/vertical-list-adapter.d.ts
+type VerticalListAdapterOptions = {
+  /** Initial selection mode forwarded to the inner ixfx-vertical-list. Default: `'single'`. */selectionMode?: ListSelectionMode; /** Interaction mode forwarded to the inner ixfx-vertical-list. Default: `'standard'`. */
+  interactionMode?: ListInteractionMode;
+  /**
+   * Called when a command is dispatched via `ixfx-grouped-item-lister.dispatch()`.
+   *
+   * Receives the current inner `VerticalListElement` (undefined until the first
+   * `setItems()` call) so the handler can sort, filter, or otherwise mutate the
+   * list directly.
+   *
+   * @example Sort items alphabetically by text content:
+   * ```ts
+   * onDispatch: (id, _args, list) => {
+   *   if (id !== 'sort-alpha' || !list) return;
+   *   const rows = [...list.querySelectorAll<HTMLElement>('li')];
+   *   rows.sort((a, b) => (a.textContent ?? '').localeCompare(b.textContent ?? ''));
+   *   for (const row of rows) list.appendChild(row);
+   * }
+   * ```
+   */
+  onDispatch?: (commandId: CommandId, args: Record<string, unknown> | undefined, list: VerticalListElement | undefined) => void;
+};
+/**
+ * Creates an `HTMLElement` that implements `IGroupedSubComponent<T>` by wrapping
+ * an `ixfx-vertical-list` internally.
+ *
+ * Items are typed as `T`. The `renderItem` function converts each item to a DOM
+ * element (typically an `<li>`) that `ixfx-vertical-list` renders and handles
+ * pointer/keyboard interaction for.
+ *
+ * The returned element bridges the `list-*` event names fired by
+ * `ixfx-vertical-list` to the `select / activate / item-click / tickle` names
+ * required by `IGroupedSubComponent`, and maps element-based selection sets back
+ * to typed `T` values.
+ *
+ * @example Basic usage with ixfx-grouped-item-lister:
+ * ```ts
+ * lister.factory = () =>
+ *   createVerticalListAdapter<MyItem>(item => {
+ *     const li = document.createElement('li');
+ *     li.textContent = item.label;
+ *     return li;
+ *   });
+ * ```
+ */
+declare function createVerticalListAdapter<T>(renderItem: (item: T) => Element, options?: VerticalListAdapterOptions): HTMLElement & IGroupedSubComponent<T>;
+//#endregion
+//#region src/hex/types.d.ts
+type BytePos = number;
+type SingleSelection = {
+  readonly kind: `single`;
+  readonly pos: BytePos;
+};
+type ContiguousSelection = {
+  readonly kind: `contiguous`;
+  readonly start: BytePos;
+  readonly end: BytePos;
+};
+type RectangularSelection = {
+  readonly kind: `rectangular`;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+};
+type Selection = SingleSelection | ContiguousSelection | RectangularSelection | null;
+type DiffEntry = {
+  readonly before: number;
+  readonly after: number;
+};
+type Diff = ReadonlyMap<BytePos, DiffEntry>;
+type ColourScheme = `ascii` | `shade`;
+//#endregion
+//#region src/hex/hex-editor.d.ts
+declare class IxfxHexEditorElement extends LitElement {
+  columns: number;
+  colourScheme: ColourScheme;
+  showChangeset: boolean;
+  hideOffsetCol: boolean;
+  hideHexCol: boolean;
+  hideTextCol: boolean;
+  private _selection;
+  private _scrollTop;
+  private _editState;
+  private _containerH;
+  private _shadeMap;
+  private _focusSide;
+  private _store;
+  private _undoStack;
+  private _copyBuffer;
+  private _rowHeight;
+  private _dragStart;
+  private _dragAnchor;
+  private _rectAnchorX;
+  private _rectAnchorY;
+  private _rectAnchorXFromKeyboard;
+  private _rectAnchorYFromKeyboard;
+  private _initialSelectionPoint;
+  private _currentCursorPoint;
+  private _pointerMode;
+  private _currentDragDiff;
+  private _shiftClickTarget;
+  static styles: CSSResult;
+  setData(data: Uint8Array): void;
+  undo(): void;
+  redo(): void;
+  recomputeColours(): void;
+  selectedBytes(): Generator<{
+    selection_index: number;
+    array_index: number;
+    value: number;
+  }>;
+  containsPosition(pos: number): boolean;
+  selectSingle(position: number): void;
+  selectContiguous(start: number, end: number): void;
+  selectRectangular(x: number, y: number, width: number, height: number): void;
+  clearSelection(): void;
+  getSelection(): Selection;
+  protected firstUpdated(): void;
+  private _onScroll;
+  private _onPointerDown;
+  private _onPointerMove;
+  private _onPointerUp;
+  private _onKeyDown;
+  private _handleBackspace;
+  private _handleValueEntry;
+  private _commitDecimalValue;
+  private _advanceCursor;
+  private _dispatchChangeEvent;
+  private _dispatchSelectEvent;
+  private _copy;
+  private _paste;
+  private _parseHexString;
+  private _getColHeaders;
+  private _isRowShaded;
+  private _isHexShaded;
+  private _isTextShaded;
+  protected render(): TemplateResult<1>;
+  private _renderRow;
+  private _renderColumn;
+  private _renderHexCell;
+  private _renderTextChar;
+}
+type HexChangeDetail = {
+  readonly diff: Diff;
+};
+type HexChangeEvent = CustomEvent<HexChangeDetail>;
+type SingleSelectEventDetail = {
+  readonly type: `single`;
+  readonly position: number;
+};
+type ContiguousSelectEventDetail = {
+  readonly type: `contiguous`;
+  readonly start: number;
+  readonly end: number;
+};
+type RectangularSelectEventDetail = {
+  readonly type: `rectangular`;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+};
+type NoneSelectEventDetail = {
+  readonly type: `none`;
+};
+type SelectEventDetail = SingleSelectEventDetail | ContiguousSelectEventDetail | RectangularSelectEventDetail | NoneSelectEventDetail;
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-hex-editor': IxfxHexEditorElement;
+  }
+} //# sourceMappingURL=hex-editor.d.ts.map
+//#endregion
+//#region src/icons/defaults.d.ts
+/**
+ * Chevron pointing down. Used for split-button dropdown toggle.
+ * fill="currentColor" so it inherits CSS color.
+ */
+declare const ICON_CHEVRON_DOWN = "<svg viewBox=\"0 0 20 20\" fill=\"currentColor\" aria-hidden=\"true\"><path d=\"M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z\"/></svg>";
+/**
+ * Caret pointing right. Used for tree-basic expand indicator as a CSS mask.
+ * fill="black" is correct for CSS mask-image use (shape only, color comes from background-color).
+ */
+declare const ICON_CARET_RIGHT = "<svg viewBox=\"0 0 24 24\" fill=\"black\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 7l6 5-6 5V7z\"/></svg>";
+/**
+ * Checkmark. Useful for menu-check-item or confirmation states.
+ * fill="currentColor" so it inherits CSS color.
  */
 declare const ICON_CHECK = "<svg viewBox=\"0 0 24 24\" fill=\"currentColor\" aria-hidden=\"true\"><path d=\"M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z\"/></svg>";
 /**
@@ -3967,7 +4752,7 @@ declare global {
   }
 } //# sourceMappingURL=labelled-radial-input.d.ts.map
 //#endregion
-//#region src/led.d.ts
+//#region src/led/led.d.ts
 declare class LedElement extends LitElement {
   #private;
   value: number;
@@ -4094,7 +4879,7 @@ declare global {
 //#endregion
 //#region src/menu/menu-separator.d.ts
 declare class MenuSeparator extends LitElement {
-  static styles: CSSResult;
+  static styles: CSSResult[];
   render(): TemplateResult<1>;
 }
 declare global {
@@ -4106,7 +4891,7 @@ declare global {
 //#region src/menu/menu-header.d.ts
 declare class MenuHeader extends LitElement {
   label: string;
-  static styles: CSSResult;
+  static styles: CSSResult[];
   render(): TemplateResult<1>;
 }
 declare global {
@@ -4218,192 +5003,6 @@ type MillerItemState = {
   isLeaf: boolean;
 };
 //#endregion
-//#region src/interaction/tickled-controller.d.ts
-/**
- * Represents an item that can be tickled (highlighted via hover or keyboard navigation)
- */
-type TickledItem<T = unknown> = {
-  /**
-   * Unique identifier for the item (e.g., index, id, path)
-   */
-  readonly id: T;
-  /**
-   * Whether the item is currently enabled/interactive
-   */
-  readonly enabled?: boolean;
-};
-/**
- * Input mode determines which mechanism controls the tickled state
- */
-type InputMode = `keyboard` | `mouse`;
-/**
- * Configuration for TickledController
- */
-type TickledControllerConfig<T> = {
-  /**
-   * Function to retrieve all items that can be tickled
-   */
-  getItems: () => ReadonlyArray<TickledItem<T>>;
-  /**
-   * Optional callback when an item becomes tickled
-   * Use this for side effects like opening submenus
-   * @param id - The id of the newly tickled item, or undefined if nothing is tickled
-   */
-  onTickle?: (id: T | undefined) => void;
-  /**
-   * Optional callback fired after any state change (tickled id or input mode)
-   * Use this to sync DOM attributes for slotted content that can't use reactive rendering
-   *
-   * For components that render items directly, this is usually not needed as
-   * Lit's reactive rendering will handle updates automatically via requestUpdate()
-   *
-   * @example
-   * ```ts
-   * onStateChange: () => {
-   *   // Sync data-tickled attributes for slotted items
-   *   const items = this.getItems();
-   *   items.forEach((item, i) => {
-   *     if (this.tickled.isTickled(i)) {
-   *       item.setAttribute('data-tickled', '');
-   *     } else {
-   *       item.removeAttribute('data-tickled');
-   *     }
-   *   });
-   * }
-   * ```
-   */
-  onStateChange?: () => void;
-  /**
-   * Optional initial input mode (defaults to 'mouse')
-   */
-  initialInputMode?: InputMode;
-};
-/**
- * ReactiveController that manages "tickled" state for interactive lists.
- *
- * A "tickled" item is one that is under active attention via hover (mouse mode)
- * or keyboard focus (keyboard mode). Only one item can be tickled at a time.
- *
- * The input mode determines which mechanism controls tickled state:
- * - Mouse mode: hover controls tickled, keyboard navigation ignored
- * - Keyboard mode: keyboard navigation controls tickled, hover ignored
- *
- * Last interaction wins - any mouse hover switches to mouse mode, any keyboard
- * navigation switches to keyboard mode.
- *
- * ## Global Mouse Tracking
- *
- * This controller uses a singleton global `pointermove` listener to track actual
- * mouse movement. This prevents `pointerenter` events caused by content scrolling
- * from incorrectly switching to mouse mode when the user is actually using keyboard
- * navigation.
- *
- * @example
- * ```ts
- * class MyList extends LitElement {
- *   private tickled = new TickledController(this, {
- *     getItems: () => this.items.map((item, i) => ({ id: i, enabled: !item.disabled })),
- *     onTickle: (id) => {
- *       // Optional: perform side effect when item is tickled
- *       console.log('Tickled item:', id);
- *     }
- *   });
- *
- *   render() {
- *     return html`
- *       <ul @pointerleave=${(e) => this.tickled.handlePointerLeave(e)}>
- *         ${this.items.map((item, i) => html`
- *           <li
- *             class="item ${this.tickled.isTickled(i) ? 'tickled' : ''}"
- *             @pointerenter=${() => this.tickled.handlePointerEnter(i)}
- *           >${item.label}</li>
- *         `)}
- *       </ul>
- *     `;
- *   }
- *
- *   private handleKeyDown(e: KeyboardEvent) {
- *     if (e.key === 'ArrowDown') {
- *       this.tickled.handleKeyboardNavigation('next');
- *     } else if (e.key === 'ArrowUp') {
- *       this.tickled.handleKeyboardNavigation('previous');
- *     }
- *   }
- * }
- * ```
- */
-declare class TickledController<T = number> implements ReactiveController {
-  private host;
-  private config;
-  private _tickledId;
-  private _inputMode;
-  private static _lastMouseClientX;
-  private static _lastMouseClientY;
-  private static _mouseMovedSinceKeyboard;
-  private static _globalListenerAttached;
-  constructor(host: ReactiveControllerHost, config: TickledControllerConfig<T>);
-  hostConnected(): void;
-  hostDisconnected(): void;
-  /**
-   * Get the current input mode
-   */
-  get inputMode(): InputMode;
-  /**
-   * Get the currently tickled item id
-   */
-  get tickledId(): T | undefined;
-  /**
-   * Check if a specific item is tickled
-   */
-  isTickled(id: T): boolean;
-  /**
-   * Handle global pointer move event.
-   * Called automatically by the global listener.
-   * Tracks mouse movement to distinguish real hover from content scrolling.
-   */
-  private static handleGlobalPointerMove;
-  /**
-   * Check if actual mouse movement has occurred since last keyboard interaction.
-   * Used to distinguish real hover/leave from content-scrolling-induced events.
-   */
-  static get hasMouseMovedSinceKeyboard(): boolean;
-  /**
-   * Handle pointer enter event on an item (mouse hover).
-   * Only processes if actual mouse movement is detected (not content scrolling).
-   * Switches to mouse mode and tickles the item.
-   */
-  handlePointerEnter(id: T): void;
-  /**
-   * Handle pointer leave event on an item.
-   * Only clears tickled state if actual mouse movement is detected.
-   * @param _e The pointer event (not used, but kept for API compatibility)
-   */
-  handlePointerLeave(_e: PointerEvent): void;
-  /**
-   * Handle keyboard navigation.
-   * Switches to keyboard mode and moves tickled state.
-   *
-   * @param direction - 'next', 'previous', 'first', 'last', or specific id
-   */
-  handleKeyboardNavigation(direction: `next` | `previous` | `first` | `last` | T): void;
-  /**
-   * Manually set the tickled item (useful for programmatic control).
-   * Does NOT change input mode.
-   */
-  setTickled(id: T | undefined): void;
-  /**
-   * Clear the tickled state (e.g., on pointer leave).
-   * Note: For pointer leave events, prefer using handlePointerLeave() which
-   * checks for actual mouse movement.
-   */
-  clearTickled(): void;
-  /**
-   * Manually set the input mode.
-   * When switching to keyboard mode, resets the mouse movement tracking.
-   */
-  setInputMode(mode: InputMode): void;
-}
-//#endregion
 //#region src/miller/miller-base.d.ts
 /**
  * Base class for Miller column components. Handles column lifecycle,
@@ -4639,66 +5238,28 @@ type MillerTreeControllerOptions<T> = {
  * Children are populated lazily: the controller provides a `loadChildren`
  * callback that synchronously reads from the underlying tree.
  *
- * Call `disconnect()` to remove all event listeners and release resources.
- */
-declare class MillerTreeController<T> {
-  #private;
-  constructor(root: TraversableTree<T>, element: MillerBaseElement, options: MillerTreeControllerOptions<T>);
-  /**
-   * Wire up the controller: sets `element.root` and provides `loadChildren` callback.
-   * Safe to call again after `disconnect()`.
-   */
-  connect(): void;
-  /** Remove all event listeners and release internal state. */
-  disconnect(): void;
-  /**
-   * Navigate the component to the first node (depth-first) in the ixfx tree
-   * whose value satisfies `predicate`.
-   *
-   * Any ancestor `MillerNode`s with unloaded children are populated
-   * synchronously before calling `element.navigateTo()`.
-   *
-   * Returns `false` if no matching node is found.
-   */
-  navigateToValue(predicate: (value: T) => boolean): boolean;
-}
-//#endregion
-//#region src/panel/panel.d.ts
-type PanelOrientation = `horizontal` | `vertical`;
-type PanelVariant = `titlebar` | `midline`;
-type PanelToggleInteraction = `implicit` | `explicit` | `disabled`;
-interface PanelToggleDetail {
-  readonly collapsed: boolean;
-}
-type PanelToggleEvent = CustomEvent<PanelToggleDetail>;
-type PanelCloseEvent = CustomEvent<void>;
-interface PanelElementEventMap {
-  toggle: PanelToggleEvent;
-  close: PanelCloseEvent;
-}
-declare class PanelElement extends LitElement {
-  collapsed: boolean;
-  orientation: PanelOrientation;
-  closable: boolean;
-  title: string;
-  iconName: string;
-  toggleInteraction: PanelToggleInteraction;
-  variant: PanelVariant;
-  private _isVertical;
-  private _onToggleClick;
-  private _onCloseClick;
-  private _getCaretIcon;
-  protected updated(changed: Map<string, unknown>): void;
-  protected render(): TemplateResult<1>;
-  static styles: CSSResult;
-}
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-panel': PanelElement;
-  }
-}
-interface PanelElement {
-  addEventListener: (<K extends keyof PanelElementEventMap>(type: K, listener: (this: PanelElement, event: PanelElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+ * Call `disconnect()` to remove all event listeners and release resources.
+ */
+declare class MillerTreeController<T> {
+  #private;
+  constructor(root: TraversableTree<T>, element: MillerBaseElement, options: MillerTreeControllerOptions<T>);
+  /**
+   * Wire up the controller: sets `element.root` and provides `loadChildren` callback.
+   * Safe to call again after `disconnect()`.
+   */
+  connect(): void;
+  /** Remove all event listeners and release internal state. */
+  disconnect(): void;
+  /**
+   * Navigate the component to the first node (depth-first) in the ixfx tree
+   * whose value satisfies `predicate`.
+   *
+   * Any ancestor `MillerNode`s with unloaded children are populated
+   * synchronously before calling `element.navigateTo()`.
+   *
+   * Returns `false` if no matching node is found.
+   */
+  navigateToValue(predicate: (value: T) => boolean): boolean;
 }
 //#endregion
 //#region src/panel/panel-group.d.ts
@@ -4780,6 +5341,85 @@ declare class PlotDataSeries {
   clear(): void;
 }
 //#endregion
+//#region src/plots/multi-axis.d.ts
+type PlotMultiAxisLayout = `overlap` | `horizontal` | `vertical` | `grid`;
+type PlotMultiAxisDataPointClickDetail = {
+  readonly value: number;
+  readonly index: number;
+  readonly series: string;
+};
+type PlotMultiAxisDataPointClickEvent = CustomEvent<PlotMultiAxisDataPointClickDetail>;
+interface PlotMultiAxisElementEventMap {
+  'plot-datapoint-click': PlotMultiAxisDataPointClickEvent;
+}
+declare class PlotMultiAxis extends LitElement {
+  #private;
+  layout: PlotMultiAxisLayout;
+  gridMinWidth: number;
+  /** Override to customize tooltip value display. */
+  valueFormat: (v: number | undefined) => string;
+  addData(data: Record<string, number>): void;
+  addData(name: string, value: number): void;
+  styleSeries(name: string, styles: Record<string, string>): void;
+  clear(): void;
+  clearSeries(name: string): void;
+  get series(): string[];
+  protected render(): TemplateResult<1>;
+  static styles: CSSResult;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-plot-multi-axis': PlotMultiAxis;
+  }
+}
+interface PlotMultiAxis {
+  addEventListener: {
+    <K extends keyof PlotMultiAxisElementEventMap>(type: K, listener: (this: PlotMultiAxis, event: PlotMultiAxisElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+  };
+}
+//#endregion
+//#region src/plots/plot-histogram.d.ts
+type PlotHistogramOrientation = 'horizontal' | 'vertical';
+type PlotHistogramBucketClickDetail = {
+  readonly bucketIndex: number;
+  readonly valueMin: number;
+  readonly valueMax: number;
+  readonly relativeValue: number;
+};
+type PlotHistogramBucketClickEvent = CustomEvent<PlotHistogramBucketClickDetail>;
+interface PlotHistogramElementEventMap {
+  'plot-bucket-click': PlotHistogramBucketClickEvent;
+}
+declare class PlotHistogram extends LitElement {
+  #private;
+  orientation: PlotHistogramOrientation;
+  resolution: number;
+  min?: number;
+  max?: number;
+  capacity: number;
+  title: string;
+  paused: boolean;
+  private _width;
+  private _height;
+  add(v: number): void;
+  set(values: number[]): void;
+  clear(): void;
+  protected firstUpdated(_changed: PropertyValues): void;
+  protected updated(changed: PropertyValues): void;
+  render(): TemplateResult<1>;
+  static styles: CSSResult;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-plot-histogram': PlotHistogram;
+  }
+}
+interface PlotHistogram {
+  addEventListener<K extends keyof PlotHistogramElementEventMap>(type: K, listener: (this: PlotHistogram, event: PlotHistogramElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+//#endregion
 //#region src/plots/single-axis.d.ts
 type SingleAxisDrawStyle = `line-sharp` | `line-round` | `circles` | `squares` | `vbar` | `hbar` | `hist-bottom` | `hist-top` | `hist-middle`;
 type SingleAxisAgeStyle = `none` | `opacity` | `desaturation` | `size`;
@@ -4805,6 +5445,10 @@ declare class PlotSingleAxis extends LitElement {
   private _height;
   /** Override to customize tooltip label. */
   valueFormat: (v: number | undefined) => string;
+  get values(): readonly number[];
+  get dataCount(): number;
+  getValueAt(index: number): number | undefined;
+  getIndexFromClientX(clientX: number): number;
   add(v: number): void;
   set(values: number[]): void;
   clear(): void;
@@ -4813,11 +5457,27 @@ declare class PlotSingleAxis extends LitElement {
   render(): TemplateResult<1>;
   static styles: CSSResult;
 }
+type PlotSingleAxisPointerMoveDetail = {
+  readonly clientX: number;
+  readonly clientY: number;
+  readonly index: number;
+};
+type PlotSingleAxisPointerMoveEvent = CustomEvent<PlotSingleAxisPointerMoveDetail>;
+interface PlotSingleAxisElementEventMap {
+  'plot-pointer-move': PlotSingleAxisPointerMoveEvent;
+  'plot-pointer-leave': Event;
+}
 declare global {
   interface HTMLElementTagNameMap {
     'ixfx-plot-single-axis': PlotSingleAxis;
   }
-} //# sourceMappingURL=single-axis.d.ts.map
+}
+interface PlotSingleAxis {
+  addEventListener: {
+    <K extends keyof PlotSingleAxisElementEventMap>(type: K, listener: (this: PlotSingleAxis, event: PlotSingleAxisElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+  };
+}
 //#endregion
 //#region src/plots/xy-axis.d.ts
 type XyDrawStyle = `circles` | `squares`;
@@ -4861,7 +5521,7 @@ declare global {
 //#endregion
 //#region src/polar-pad/polar-pad.d.ts
 declare class PolarPad extends LitElement {
-  static styles: CSSResult;
+  static styles: CSSResult[];
   /** Current angle in degrees. 0 = right, increases clockwise. */
   angle: number;
   /** Current radius 0–1. 0 = origin, 1 = edge. */
@@ -5065,7 +5725,7 @@ declare global {
 declare class SelectHorizontalElement extends LitElement {
   editMode: boolean;
   render(): TemplateResult<1>;
-  static styles: CSSResult;
+  static styles: CSSResult[];
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -5161,7 +5821,7 @@ declare class SplitLayoutElement extends LitElement {
   updated(changedProperties: Map<string, unknown>): void;
   getZone(): HTMLElement | undefined;
   render(): TemplateResult<1>;
-  static styles: CSSResult;
+  static styles: CSSResult[];
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -5264,7 +5924,7 @@ declare class TabListElement extends LitElement {
   updated(changedProperties: PropertyValues): void;
   getSelectedElement(): TabListItemElement | undefined;
   selectElement(el: HTMLElement): void;
-  static styles: CSSResult;
+  static styles: CSSResult[];
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -5275,7 +5935,7 @@ declare global {
 //#region src/tabs/tab-panel.d.ts
 declare class TabPanelElement extends LitElement {
   render(): TemplateResult<1>;
-  static styles: CSSResult;
+  static styles: CSSResult[];
 }
 declare global {
   interface HTMLElementTagNameMap {
@@ -5730,69 +6390,6 @@ declare global {
   }
 } //# sourceMappingURL=transitory-label.d.ts.map
 //#endregion
-//#region src/tree/tree-base.d.ts
-declare class TreeBaseElement extends LitElement implements TreeComponent, TreeSearchHost {
-  #private;
-  root: TreeNode | undefined;
-  model: TreeDataModel | undefined;
-  /** Callback to lazily load children for a node. Superseded by `model` when both are set. */
-  loadChildren: LoadChildrenCallback | undefined;
-  exclusivity: TreeExclusivity;
-  selectionFilter: TreeSelectionFilter;
-  /** Controls how pointer/keyboard gestures map to selection changes. Default: `'standard'`. */
-  interactionMode: TreeInteractionMode;
-  selectedNode: TreeNode | undefined;
-  protected _selectedNodes: Set<TreeNode>;
-  get selectedNodes(): ReadonlySet<TreeNode>;
-  filterPredicate: TreeFilterPredicate | undefined;
-  disableKeyboardNavigation: boolean;
-  protected _expandedKeys: Set<string>;
-  protected tickled: TickledController<string>;
-  protected _focusedDepth: number;
-  updated(changedProps: PropertyValues): void;
-  connectedCallback(): void;
-  disconnectedCallback(): void;
-  getConfig(): TreeConfig;
-  setConfig(config: Partial<TreeConfig>): void;
-  select(node: TreeNode): void;
-  deselect(node: TreeNode): void;
-  clearSelection(): void;
-  navigateTo(keys: readonly string[]): boolean;
-  navigateToNode(predicate: (node: TreeNode) => boolean): boolean;
-  getNodes(): ReadonlyArray<{
-    node: TreeNode;
-    depth: number;
-  }>;
-  protected renderNodeContent(node: TreeNode, _depth: number): TemplateResult | typeof nothing;
-  protected _handleItemClick(node: TreeNode, depth: number, event?: MouseEvent): void;
-  protected _handleCheckboxClick(event: MouseEvent, node: TreeNode, _depth: number): void;
-  protected _isSelected(node: TreeNode): boolean;
-  protected _isFocused(node: TreeNode): boolean;
-  protected _isExpanded(node: TreeNode): boolean;
-  protected get _pendingNode(): TreeNode | undefined;
-  protected renderLoadingIndicator(): TemplateResult | typeof nothing;
-  protected render(): TemplateResult<1>;
-  protected _renderNode(node: TreeNode, depth: number): TemplateResult;
-  static styles: CSSResult[];
-}
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-tree-base': TreeBaseElement;
-  }
-}
-interface TreeBaseElementEventMap extends TreeComponentEventMap {
-  'item-click': TreeItemClickEvent;
-  'expand': TreeExpandEvent;
-  'collapse': TreeCollapseEvent;
-  'select': TreeSelectEvent;
-  'tickle': TreeTickleEvent;
-  'activate': TreeActivateEvent;
-}
-interface TreeBaseElement {
-  addEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
-  removeEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);
-}
-//#endregion
 //#region src/tree/tree-controller.d.ts
 type TreeControllerOptions<T> = {
   valueToItem: (value: T, node: TraversableTree<T>) => TreeItem;
@@ -5805,124 +6402,10 @@ declare class TreeController<T> {
   navigateToValue(predicate: (value: T) => boolean): boolean;
 }
 //#endregion
-//#region src/tree/tree-list.d.ts
-declare class TreeListElement extends TreeBaseElement {
-  #private;
-  protected render(): TemplateResult<1>;
-  protected renderNodeContent(node: TreeNode, depth: number): TemplateResult;
-  protected _renderNode(node: TreeNode, depth: number): TemplateResult;
-  static styles: CSSResult[];
-}
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-tree-list': TreeListElement;
-  }
-}
-interface TreeListElement {
-  addEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeListElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
-}
-//#endregion
 //#region src/util/checkbox.d.ts
 declare function monitorIndeterminate(targetElOrQuery: string | HTMLElement, watchedElsOrQueries: Array<string | HTMLElement>): () => void;
 //#endregion
-//#region src/vertical-list/types.d.ts
-type ListSelectionMode = `none` | `single` | `multiple`;
-/**
- * Controls how pointer and keyboard gestures map to selection changes.
- *
- * - `implicit`  — click always replaces selection (no modifier support)
- * - `standard`  — click replaces; Ctrl/Cmd+click toggles; Shift+click range-selects (multiple only)
- * - `manual`    — no auto-selection; drive state via select()/deselect()/clearSelection()
- * - `checked`   — every click toggles; implies multiple selection regardless of selectionMode
- * - `vscode`    — like standard for clicks; Shift+Arrow extends range from the keyboard anchor
- *
- * Switching interactionMode clears the current selection.
- */
-type ListInteractionMode = `implicit` | `standard` | `manual` | `checked` | `vscode`;
-type ListSelectDetail = {
-  readonly selected: ReadonlySet<Element>;
-  readonly previous: ReadonlySet<Element>;
-};
-type ListTickleDetail = {
-  readonly item: Element;
-};
-type ListActivateDetail = {
-  readonly item: Element;
-};
-type ListItemClickDetail = {
-  readonly item: Element;
-};
-type ListSelectEvent = CustomEvent<ListSelectDetail>;
-type ListTickleEvent = CustomEvent<ListTickleDetail>;
-type ListActivateEvent = CustomEvent<ListActivateDetail>;
-type ListItemClickEvent = CustomEvent<ListItemClickDetail>;
-interface ListElementEventMap {
-  'list-select': ListSelectEvent;
-  'list-tickle': ListTickleEvent;
-  'list-activate': ListActivateEvent;
-  'list-item-click': ListItemClickEvent;
-}
-//#endregion
-//#region src/vertical-list/vertical-list.d.ts
-declare class VerticalListElement extends LitElement {
-  #private;
-  selectionMode: ListSelectionMode;
-  interactionMode: ListInteractionMode;
-  filterPredicate: ((el: Element) => boolean) | undefined;
-  private _selectedItems;
-  private _searchVisible;
-  private _searchQuery;
-  private _searchInputEl;
-  private tickled;
-  connectedCallback(): void;
-  disconnectedCallback(): void;
-  firstUpdated(): void;
-  updated(changed: PropertyValues): void;
-  /** The most recently selected item, or `undefined` if nothing is selected. */
-  get selectedItem(): Element | undefined;
-  /** The full current selection set (read-only). */
-  get selectedItems(): ReadonlySet<Element>;
-  addItem(item: Element | string): void;
-  removeItem(item: Element): void;
-  clearItems(): void;
-  select(item: Element): void;
-  selectMany(items: Iterable<Element>): void;
-  deselect(item: Element): void;
-  clearSelection(): void;
-  selectAll(): void;
-  private _replaceSelection;
-  private _toggleItem;
-  private _rangeSelectTo;
-  private _clearSelection;
-  private _selectAll;
-  private _handleClickSelection;
-  private _handleSpaceKey;
-  private _getVisibleItems;
-  private _syncItemStates;
-  private _syncCheckboxes;
-  private _findListItem;
-  private _dispatch;
-  private _openSearch;
-  private _closeSearch;
-  private _onPointerOver;
-  private _onPointerLeave;
-  private _onKeyDown;
-  private _onClick;
-  private _onDblClick;
-  private _activateItem;
-  private _onSearchInput;
-  private _onSearchKeydown;
-  static styles: CSSResult;
-  render(): TemplateResult<1>;
-}
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-vertical-list': VerticalListElement;
-  }
-  interface HTMLElementEventMap extends ListElementEventMap {}
-} //# sourceMappingURL=vertical-list.d.ts.map
-//#endregion
-//#region src/xy-pad.d.ts
+//#region src/xy-pad/xy-pad.d.ts
 declare class XyPad extends LitElement {
   static styles: CSSResult[];
   xMin: number;
@@ -6001,5 +6484,5 @@ interface XyPad {
 //#region src/index.d.ts
 declare function init(): void;
 //#endregion
-export { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent, type AcTokenAddDetail, type AcTokenAddEvent, type AcTokenCompletionProvider, AcTokenElement, type AcTokenElementEventMap, type AcTokenItem, type AcTokenRemoveDetail, type AcTokenRemoveEvent, type AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, ButtonElement, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, ClickSnapMode, ColourMapConfig, ColourMode, ColourPicker, type ColourPickerChangeEvent, type ColourPickerEventDetail, type ColourPickerInputEvent, ColourPickerPopup, ColourResult, ContiguousSelectEventDetail, CrossoverBehaviour, CrumbNavChangeDetail, CrumbNavChangeEvent, CrumbNavExpandDetail, CrumbNavExpandEvent, CrumbNavNavigateDetail, CrumbNavNavigateEvent, CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent, CrumbPathController, CrumbPathControllerOptions, CrumbPathElement, CrumbPathElementEventMap, CrumbSegment, CrumbSiblingLookupFn, type CssVars, DataDisplayComponent, DisplayTextLogic, DragSnappingFn, DragTarget, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, Endpoints, EntryMode, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GridMode, GridResolution, HexChangeDetail, HexChangeEvent, type HighlightOptions, type HighlightTarget, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, type IconChangedDetail, type IconChangedEvent, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LaneData, LaneType, LedElement, type ListActivateDetail, type ListActivateEvent, type ListElementEventMap, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListSelectDetail, type ListSelectEvent, type ListSelectionMode, type ListTickleDetail, type ListTickleEvent, 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, type TreeSelectDetail as MillerSelectDetail, TreeSelectDetail, type TreeSelectEvent as MillerSelectEvent, TreeSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, TreeTickleDetail, type TreeTickleEvent as MillerTickleEvent, TreeTickleEvent, MillerTreeController, MillerTreeControllerOptions, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, NoneSelectEventDetail, type OklchValue, Orientation, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupOrientation, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PlotDataSeries, PlotDataSeriesOptions, PlotSingleAxis, PlotXyAxis, PolarPad, PolarPadInputDetail, PolarPadInputEvent, PopupItem, RadialInputChangeDetail, RadialInputChangeEvent, RadialInputElement, RadialInputInputDetail, RadialInputInputEvent, RadioGroup, RadioGroupChangeDetail, RadioGroupChangeEvent, RadioGroupMode, RadioItem, RangeElement, RangeInput, RangeMultiElement, RangeMultiInputDetail, RangeMultiInputEvent, type Rect, RectangularSelectEventDetail, ResizeMode, SelectEventDetail, SelectHorizontalElement, SelectionMode, SingleAxisAgeStyle, SingleAxisDrawStyle, SingleSelectEventDetail, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic, SplitButton, SplitButtonMode, SplitButtonSelectDetail, SplitButtonSelectEvent, SplitLayoutElement, SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent, SwitcherItem, TabListChangeDetail, TabListChangeEvent, TabListElement, TabListItemElement, TabPanelElement, TabPanelsElement, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeBaseElement, TreeBaseElementEventMap, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeListElement, TreeSearchHost, TreeSelectionFilter, UserScale, ValueMode, VerticalListElement, ViewRange, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, applyAgeModification, applyHighlights, attachTimelineInteractions, buildHighlightTargets, clearHighlights, computeColour, createAcCompletionProvider, createElementIncrSearch, createFuzzySearch, createIncrSearch, getIcon, hasIcon, iconBus, init, monitorIndeterminate, parseColourScaleAttr, readBaseColour, registerIcon, resolveCssVars, resolveGrid, svgToDataUri, timelineStyles };
+export { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent, type AcTokenAddDetail, type AcTokenAddEvent, AcTokenElement, type AcTokenElementEventMap, type AcTokenItem, type AcTokenRemoveDetail, type AcTokenRemoveEvent, type AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, ButtonElement, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, ClickSnapMode, ColourMapConfig, ColourMode, ColourPicker, type ColourPickerChangeEvent, type ColourPickerEventDetail, type ColourPickerInputEvent, ColourPickerPopup, ColourResult, ConfigEntry, ContiguousSelectEventDetail, CrossoverBehaviour, CrumbNavChangeDetail, CrumbNavChangeEvent, CrumbNavExpandDetail, CrumbNavExpandEvent, CrumbNavNavigateDetail, CrumbNavNavigateEvent, CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent, CrumbPathController, CrumbPathControllerOptions, CrumbPathElement, CrumbPathElementEventMap, CrumbSegment, CrumbSiblingLookupFn, type CssVars, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataProviderResult, DisplayTextLogic, DragSnappingFn, DragTarget, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, Endpoints, EntryMode, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GridMode, GridResolution, GroupedItemListerElement, type GroupedItemListerElementEventMap, type GroupedSelectDetail, type GroupedSelectEvent, HexChangeDetail, HexChangeEvent, type HighlightOptions, type HighlightTarget, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IDataProvider, type IGroupedSubComponent, type IGroupedSubComponentEventMap, type IconChangedDetail, type IconChangedEvent, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LaneData, LaneType, LedElement, type ListActivateDetail, type ListActivateEvent, type ListElementEventMap, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListSelectDetail, type ListSelectEvent, type ListSelectionMode, type ListTickleDetail, type ListTickleEvent, 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, type TreeSelectDetail as MillerSelectDetail, TreeSelectDetail, type TreeSelectEvent as MillerSelectEvent, TreeSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, TreeTickleDetail, type TreeTickleEvent as MillerTickleEvent, TreeTickleEvent, MillerTreeController, MillerTreeControllerOptions, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, NoneSelectEventDetail, type OklchValue, Orientation, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupOrientation, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramOrientation, 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, type Rect, RectangularSelectEventDetail, RendererStyle, ResizeMode, SelectEventDetail, SelectHorizontalElement, SelectionMode, SingleAxisAgeStyle, SingleAxisDrawStyle, SingleSelectEventDetail, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic, SplitButton, SplitButtonMode, SplitButtonSelectDetail, SplitButtonSelectEvent, SplitLayoutElement, type SubComponentActivateDetail, type SubComponentActivateEvent, type SubComponentFactory, type SubComponentItemClickDetail, type SubComponentItemClickEvent, type SubComponentSelectDetail, type SubComponentSelectEvent, type SubComponentTickleDetail, type SubComponentTickleEvent, SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent, SwitcherItem, TabListChangeDetail, TabListChangeEvent, TabListElement, TabListItemElement, TabPanelElement, TabPanelsElement, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeBaseElement, TreeBaseElementEventMap, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeListAdapterOptions, TreeListElement, TreeSearchHost, TreeSelectionFilter, UserScale, ValueMode, VerticalListAdapterOptions, VerticalListElement, ViewRange, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, applyAgeModification, applyHighlights, attachTimelineInteractions, buildHighlightTargets, clearHighlights, collectDataResult, computeColour, createAcCompletionProvider, createElementIncrSearch, createFuzzySearch, createIncrSearch, createTreeListAdapter, createVerticalListAdapter, getIcon, hasIcon, iconBus, init, monitorIndeterminate, parseColourScaleAttr, readBaseColour, registerIcon, resolveCssVars, resolveGrid, svgToDataUri, timelineStyles };
 //# sourceMappingURL=index.d.ts.map