@ixfx/components 0.6.2 → 0.7.1

package/dist/index.d.ts

@@ -1,31 +1,35 @@
-import { t as IxfxIconElement } from "./icon-DpA9x2Ve.js";
+import { t as IxfxIconElement } from "./icon-CDGprSdE.js";
 import { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent } from "./ac-text.js";
 import { i as collectDataResult, n as DataProviderResult, r as IDataProvider, t as DataBatch } from "./data-provider-BAn_-oR1.js";
-import { a as AcTokenItem, c as AcTokenizerFn, i as AcTokenElementEventMap, l as AcTokensChangeDetail, n as AcTokenAddDetail, o as AcTokenRemoveDetail, r as AcTokenAddEvent, s as AcTokenRemoveEvent, t as AcTokenElement, u as AcTokensChangeEvent } from "./ac-token-BAa6ke09.js";
+import { a as AcTokenItem, c as AcTokenizerFn, i as AcTokenElementEventMap, l as AcTokensChangeDetail, n as AcTokenAddDetail, o as AcTokenRemoveDetail, r as AcTokenAddEvent, s as AcTokenRemoveEvent, t as AcTokenElement, u as AcTokensChangeEvent } from "./ac-token--_vCHXWw.js";
 import { ButtonElement } from "./button.js";
 import { Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap } from "./checkbox.js";
 import { a as ColourPickerInputEvent, i as ColourPickerEventDetail, n as ColourPicker, o as OklchValue, r as ColourPickerChangeEvent, t as ColourPickerPopup } from "./index-tq6f8007.js";
 import { t as LabelledRangeInput } from "./index-CoqtMSd9.js";
 import { a as TreeItem, i as TreeInteractionMode, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-Bc23SI94.js";
 import { _ as TreeDataModelOptions, a as TreeComponent, c as TreeExpandEvent, d as TreeSearchHost, f as TreeSelectDetail, g as TreeDataModel, h as TreeTickleEvent, i as TreeCollapseEvent, l as TreeItemClickDetail, m as TreeTickleDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeSelectEvent, r as TreeCollapseDetail, s as TreeExpandDetail, t as TreeActivateDetail, u as TreeItemClickEvent } from "./tree-component-BvV4muxx.js";
-import "./menu-item-Bs2MYyHq.js";
+import "./menu-item-CZi9vy5O.js";
 import { FuzzySearchResult, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, Orientation, SelectionMode } from "./narrowed-text.js";
 import { CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent } from "./crumbs.js";
 import { ConfigEntry, DataDisplayComponent, FormattingOptions, RendererStyle } from "./data-display.js";
-import { _ as DataGridSortDetail, a as DataGridColumnReorderDetail, c as DataGridColumnResizeEvent, d as DataGridElement, f as DataGridElementEventMap, g as DataGridSelectEvent, h as DataGridSelectDetail, i as DataGridCellEditEvent, l as DataGridColumnVisibilityDetail, m as DataGridGroupChangeEvent, n as DataGridCellClickEvent, o as DataGridColumnReorderEvent, p as DataGridGroupChangeDetail, r as DataGridCellEditDetail, s as DataGridColumnResizeDetail, t as DataGridCellClickDetail, u as DataGridColumnVisibilityEvent, v as DataGridSortEvent } from "./data-grid-C8qIo1-u.js";
-import { t as index_d_exports } from "./index-CKtLhgYj.js";
-import { DisplayTextLogic, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EntryMode } from "./editable-label.js";
+import { _ as DataGridSortDetail, a as DataGridColumnReorderDetail, c as DataGridColumnResizeEvent, d as DataGridElement, f as DataGridElementEventMap, g as DataGridSelectEvent, h as DataGridSelectDetail, i as DataGridCellEditEvent, l as DataGridColumnVisibilityDetail, m as DataGridGroupChangeEvent, n as DataGridCellClickEvent, o as DataGridColumnReorderEvent, p as DataGridGroupChangeDetail, r as DataGridCellEditDetail, s as DataGridColumnResizeDetail, t as DataGridCellClickDetail, u as DataGridColumnVisibilityEvent, v as DataGridSortEvent } from "./data-grid-Bh4YrQGK.js";
+import { t as index_d_exports } from "./index-9AhaHIT2.js";
+import { a as EditableMode, i as EditableLabelChangeEvent, n as EditableLabel, o as EntryMode, r as EditableLabelChangeDetail, t as DisplayTextLogic } from "./editable-label-rzXkjf1H.js";
 import { FormElement } from "./form.js";
-import { a as ListItemClickDetail, c as ListSelectEvent, d as ListTickleEvent, i as ListInteractionMode, l as ListSelectionMode, n as ListActivateEvent, o as ListItemClickEvent, r as ListElementEventMap, s as ListSelectDetail, t as ListActivateDetail, u as ListTickleDetail } from "./types-DlVNJez_.js";
-import { a as IGroupedSubComponent, c as SubComponentActivateEvent, d as SubComponentItemClickEvent, f as SubComponentSelectDetail, h as SubComponentTickleEvent, i as GroupedSelectEvent, l as SubComponentFactory, m as SubComponentTickleDetail, n as GroupedItemListerElementEventMap, o as IGroupedSubComponentEventMap, p as SubComponentSelectEvent, r as GroupedSelectDetail, s as SubComponentActivateDetail, t as GroupedItemListerElement, u as SubComponentItemClickDetail } from "./grouped-item-lister-_pMDwIo1.js";
+import { a as ListItemClickDetail, c as ListSelectEvent, d as ListTickleEvent, i as ListInteractionMode, l as ListSelectionMode, n as ListActivateEvent, o as ListItemClickEvent, r as ListElementEventMap, s as ListSelectDetail, t as ListActivateDetail, u as ListTickleDetail } from "./list-selection-types-DSuRNWpx.js";
+import { a as IGroupedSubComponent, c as SubComponentActivateEvent, d as SubComponentItemClickEvent, f as SubComponentSelectDetail, h as SubComponentTickleEvent, i as GroupedSelectEvent, l as SubComponentFactory, m as SubComponentTickleDetail, n as GroupedItemListerElementEventMap, o as IGroupedSubComponentEventMap, p as SubComponentSelectEvent, r as GroupedSelectDetail, s as SubComponentActivateDetail, t as GroupedItemListerElement, u as SubComponentItemClickDetail } from "./grouped-item-lister-DnWB-eFT.js";
+import { a as TitlebarToggleDetail, c as TitlebarVariant, i as TitlebarOrientation, n as TitlebarElement, o as TitlebarToggleEvent, r as TitlebarElementEventMap, s as TitlebarToggleInteraction, t as TitlebarCloseEvent } from "./titlebar-Bj5pfdw_.js";
 import { PanelCloseEvent, PanelElement, PanelElementEventMap, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant } from "./panel.js";
 import { a as NoneSelectEventDetail, c as SingleSelectEventDetail, i as IxfxHexEditorElement, n as HexChangeDetail, o as RectangularSelectEventDetail, r as HexChangeEvent, s as SelectEventDetail, t as ContiguousSelectEventDetail } from "./hex-editor-Caq8vNQk.js";
-import { a as iconBus, c as ICON_CARET_RIGHT, d as ICON_CLOSE, i as hasIcon, l as ICON_CHECK, n as IconChangedEvent, o as registerIcon, r as getIcon, s as svgToDataUri, t as IconChangedDetail, u as ICON_CHEVRON_DOWN } from "./index-BtGFYfaK.js";
+import { a as getIconEntry, c as iconBus, d as setIconFont, f as svgToDataUri, g as ICON_CLOSE, h as ICON_CHEVRON_DOWN, i as getIcon, l as registerFontIcon, m as ICON_CHECK, n as IconChangedEvent, o as getIconFont, p as ICON_CARET_RIGHT, r as IconEntry, s as hasIcon, t as IconChangedDetail, u as registerIcon } from "./index-CS9yM8L-.js";
 import { _ as IncrSearchChangeCallback, a as createFuzzySearch, b as IncrSearchState, c as IncrSearchTreeController, d as ElementIncrSearchOptions, f as FuzzySearch, g as IncrSearch, h as HighlightTarget, i as clearHighlights, l as IncrSearchTreeOptions, m as HighlightOptions, n as applyHighlights, o as ElementIncrSearch, p as FuzzySearchOptions, r as buildHighlightTargets, s as createElementIncrSearch, t as createIncrSearch, u as createAcCompletionProvider, v as IncrSearchOptions, y as IncrSearchResult } from "./index-Cu5i8zZY.js";
-import { n as WheelNudgeConsumerType, t as WheelDirection } from "./wheel-nudge-DGrNzWuE.js";
 import { AddItemOptions, CustomCheckboxOptions, VerticalListElement } from "./vertical-list.js";
+import { _ as SplitExpandEvent, a as LayoutNode, b as SplitResizeEvent, c as PanelNode, d as SplitChangeEvent, f as SplitCloseDetail, g as SplitExpandDetail, h as SplitCollapseEvent, i as GroupNode, l as SnapshotNode, m as SplitCollapseDetail, n as SplitPanelElement, o as LayoutSnapshot, p as SplitCloseEvent, r as Axis, s as PanelInfo, t as SplitLayoutElement, u as SplitChangeDetail, v as SplitLayoutElementEventMap, x as WhenSmall, y as SplitResizeDetail } from "./split-layout-JK3xWVX2.js";
+import { a as TabListReorderDetail, i as TabListElement, n as TabListChangeEvent, o as TabListReorderEvent, r as TabListDragMode, s as TabListItemElement, t as TabListChangeDetail } from "./tab-list-CGyPt07Z.js";
+import { n as EditableNumber, t as LabelledSliderInput } from "./index-CG2vIgPv.js";
 import { a as RadialInputChangeDetail, c as RadialInputInputEvent, i as MarkerStyle, l as ValueMode, n as LaneData, o as RadialInputChangeEvent, r as LaneType, s as RadialInputInputDetail, t as RadialInputElement } from "./radial-input-DXMN55Nz.js";
 import { LabelledRadialInput } from "./labelled-radial-input.js";
+import { _ as SliderValueMode, a as SliderInputChangeDetail, c as SliderInputInputDetail, d as SliderLaneType, f as SliderMarkerStyle, g as SliderValueDrag, h as SliderValueCFollow, i as SliderHandleKey, l as SliderInputInputEvent, m as SliderSingleStyle, n as SliderChangedField, o as SliderInputChangeEvent, p as SliderOrientation, r as SliderCrossover, s as SliderInputElementEventMap, t as SliderInputElement, u as SliderLaneData } from "./slider-input-BfRUW2ZB.js";
 import { LedElement } from "./led.js";
 import { MillerBaseElement, MillerBaseElementEventMap, MillerConfig, MillerHeaderClickDetail, MillerHeaderClickEvent, MillerHeaderRightClickDetail, MillerHeaderRightClickEvent, MillerItemDblClickDetail, MillerItemDblClickEvent, MillerItemRightClickDetail, MillerItemRightClickEvent, MillerItemState, MillerListElement, MillerSelectionMode, MillerTreeController, MillerTreeControllerOptions } from "./miller.js";
 import { a as Notification, c as NotificationRendererHooks, i as PillTapEvent, l as NotificationType, n as NotificationPillElementEventMap, o as NotificationContent, r as PillTapDetail, s as NotificationRenderer, t as NotificationPillElement, u as NotifierOptions } from "./notification-pill-DyZydXoZ.js";
@@ -35,17 +39,14 @@ import { n as TooltipElement, r as TooltipOrientations, t as FormatValueForHuman
 import { RangeInput } from "./range-input.js";
 import { RangeElement } from "./range.js";
 import { SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap } from "./select-horiz.js";
-import { _ as SliderValueMode, a as SliderInputChangeDetail, c as SliderInputInputDetail, d as SliderLaneType, f as SliderMarkerStyle, g as SliderValueDrag, h as SliderValueCFollow, i as SliderHandleKey, l as SliderInputInputEvent, m as SliderSingleStyle, n as SliderChangedField, o as SliderInputChangeEvent, p as SliderOrientation, r as SliderCrossover, s as SliderInputElementEventMap, t as SliderInputElement, u as SliderLaneData } from "./slider-input-XppH3vcy.js";
 import { SnackbarDismiss, SnackbarElement, SnackbarMode, SnackbarPlacement } from "./snackbar.js";
 import { ClickSnapMode, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic } from "./snap-container.js";
-import { SplitLayoutElement } from "./split-layout.js";
 import { SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent } from "./swipe.js";
-import { a as TabListReorderDetail, i as TabListElement, n as TabListChangeEvent, o as TabListReorderEvent, r as TabListDragMode, s as TabListItemElement, t as TabListChangeDetail } from "./tab-list-D_1cYhB_.js";
 import { A as TimelineTrackReorderEvent, C as TimelineEventResizeEvent, D as TimelineTickleChangeEvent, E as TimelineTickleChangeDetail, F as TrackHeightMode, I as TrackLayout, L as UserScale, M as TimelineTrackResizeEvent, N as TimelineTrackSelectDetail, O as TimelineTrack, P as TimelineTrackSelectEvent, R as ViewRange, S as TimelineEventResizeDetail, T as TimelineSelectionChangeEvent, _ as TimelineDraggingEvent, a as CssVars, b as TimelineEventMoveDetail, c as resolveGrid, d as DragSnappingFn, f as DragTarget, g as TimelineDraggingDetail, h as TimelineDraggingCallbackDetail, i as TimelineTrackTabElement, j as TimelineTrackResizeDetail, k as TimelineTrackReorderDetail, l as TimelineController, m as GridResolution, n as attachTimelineInteractions, o as Rect, p as GridMode, r as IxfxTimelineElement, s as resolveCssVars, t as timelineStyles, u as TimelineControllerConfig, v as TimelineElementEventMap, w as TimelineSelectionChangeDetail, x as TimelineEventMoveEvent, y as TimelineEvent } from "./index-BeuCXtiO.js";
 import { Effect, TransitoryLabelElement } from "./transitory-label.js";
 import { TreeBaseElement, TreeBaseElementEventMap, TreeCheckboxState, TreeConfig, TreeController, TreeControllerOptions, TreeListElement } from "./tree.js";
 import { XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent } from "./xy-pad.js";
-import { CSSResult, LitElement, PropertyValues, ReactiveController, ReactiveControllerHost } from "lit";
+import { LitElement, PropertyValues, ReactiveController, ReactiveControllerHost } from "lit";
 import { CommandId, CommandRegistry, KeyboardManager } from "@clinth/ui-commands";
 //#region src/button/radio-group.d.ts
 type RadioGroupMode = `compact` | `max`;
@@ -314,76 +315,787 @@ declare class CrumbPathController {
   disconnect(): void;
 }
 //#endregion
-//#region src/editable-label/editable-number.d.ts
-declare const EditableNumber_base: (new (...args: any[]) => WheelNudgeConsumerType<EditableLabel>) & typeof EditableLabel;
-declare class EditableNumber extends EditableNumber_base {
+//#region src/detail-list/types.d.ts
+/** Sort direction applied to the item columns. */
+type DetailSortMode = `none` | `ascending` | `descending`;
+/** Per-item view of a row passed to `sortComparator`. */
+type DetailSortItem = {
+  readonly element: HTMLElement;
+  readonly data: unknown;
+  readonly label: string;
+};
+/** Custom comparator — return negative when `a` sorts before `b`. */
+type DetailSortComparator = (a: DetailSortItem, b: DetailSortItem) => number;
+/** Turns one object item into row content — a plain string or a DOM node. */
+type DetailFormatter = (item: unknown, index: number) => string | Node;
+//#endregion
+//#region src/detail-list/detail-list.d.ts
+/**
+ * A list that scales horizontally, not vertically.
+ *
+ * Items are laid out in equal-width columns; they flow top→bottom down a
+ * column, then wrap to the top of the next column to the right. The
+ * component has a fixed vertical extent and scrolls horizontally.
+ *
+ * Selection semantics match `ixfx-vertical-list` — same modes, same
+ * `list-*` events, same keyboard gestures — but navigation is a 2-D grid
+ * (Up/Down move within a column, Left/Right jump columns).
+ *
+ * Items come from any of three sources (later writes win):
+ * 1. declarative `<li>` children in light DOM,
+ * 2. `addItem()` / `setItems()`,
+ * 3. an `items` array of objects rendered via `displayProperty` /
+ *    `formatter`, optionally streamed in via a `provider`.
+ */
+declare class DetailListElement extends LitElement {
   #private;
-  min?: number;
-  max?: number;
-  step?: number;
-  /** Quantised stops for keyboard nudging. Overrides `step` when > 1. */
-  stops?: number;
-  dragSensitivity: number;
-  fillStyle?: `linear` | `circular`;
-  linearStyle?: `range` | `bipolar` | `unipolar`;
-  circularStyle?: `grow` | `offset` | `dot`;
-  noDrag: boolean;
-  precision: number;
-  constructor();
-  render(): import("lit").TemplateResult<1>;
-  private _stopNativeInput;
+  selectionMode: ListSelectionMode;
+  interactionMode: ListInteractionMode;
+  sort: DetailSortMode;
+  sortBy: string;
+  sortComparator: DetailSortComparator | undefined;
+  items: readonly unknown[];
+  provider: IDataProvider<void, unknown> | undefined;
+  displayProperty: string;
+  formatter: DetailFormatter | undefined;
+  iconProperty: string;
+  keyProperty: string;
+  filterPredicate: ((el: Element) => boolean) | undefined;
+  /**
+   * Whether keyboard navigation wraps from last to first and vice versa.
+   * - 'stop' (default): navigation stops at the boundary
+   * - 'wrap': navigation wraps around
+   */
+  itemWrap: `stop` | `wrap`;
+  /** Optional renderer for the checkbox shown in `checked` interactionMode. */
+  checkboxRenderer: ((checked: boolean) => unknown) | CustomCheckboxOptions | undefined;
+  private _searchVisible;
+  private _searchQuery;
+  private _searchInputEl;
+  private _listEl;
+  private readonly selection;
+  private tickled;
   connectedCallback(): void;
   disconnectedCallback(): void;
-  private _handleMouseEnter;
-  private _handleMouseLeave;
-  /** Click just focuses; edit mode is entered by pressing a key while focused. */
-  protected _handleClick: () => void;
-  /** Suppress auto-edit-on-focus from editor mode; keydown handles it instead. */
-  protected _handleFocus: () => void;
-  /** Override to use .number instead of .content for text display */
-  protected get _contentEl(): HTMLElement | undefined;
-  firstUpdated(changedProperties: Map<string, unknown>): void;
-  protected _onUserInteraction(): void;
-  private _onValueChange;
-  updated(changedProperties: Map<string, unknown>): void;
-  private _updateValueCss;
-  protected _getDisplayText(): string;
-  protected _tryCommit(): void;
-  protected _handleBeforeInput: (e: InputEvent) => void;
-  protected _handleKeydown: (e: KeyboardEvent) => 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>;
+  /**
+   * Force an immediate geometry recompute. Called automatically on resize,
+   * DOM changes, sort/filter/search changes — only needed when layout is
+   * changed by outside forces (e.g. an external font load).
+   */
+  refreshLayout(): void;
+  addItem(item: Element | string, options?: AddItemOptions): void;
+  removeItem(item: Element): void;
+  clearItems(): void;
+  /**
+   * Replace the entire item list in one call.
+   * Equivalent to `clearItems()` followed by `addItem()` for each element.
+   */
+  setItems(items: readonly Element[]): void;
+  /**
+   * Get the source object behind an `<li>` built from an `items` array or
+   * provider. Returns `undefined` for declarative / programmatic elements.
+   */
+  getItemData(item: HTMLLIElement): unknown;
+  /** Dispatch a command to this list. No-op by default (grouped-lister parity). */
+  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;
+  selectedFilter(kind: `selected` | `checked` | `either`): Generator<Element>;
+  private _getVisibleItems;
+  private _isCheckable;
+  private _setLabel;
+  private _syncItemStates;
+  private _syncCheckboxes;
+  /**
+   * Native checkbox cell: a span that stretches to the row's full cross-axis
+   * (so the entire column height is a click target) with a real `<input>`
+   * centred inside. The span owns the click; the input is purely visual and
+   * has `pointer-events:none` so a single click produces one toggle.
+   */
+  private _createNativeCheckboxCell;
+  /** Custom checkbox cell: same shape as the native cell; renderer content inside. */
+  private _createCustomCheckbox;
+  private _findListItem;
+  private _dispatch;
+  private _openSearch;
+  private _closeSearch;
+  private _onPointerOver;
+  private _onPointerLeave;
   private _onKeyDown;
-  private _handleArrowKey;
+  private _onClick;
+  private _onDblClick;
+  private _onWheel;
+  private _activateItem;
+  private _onSearchInput;
+  private _onSearchKeydown;
+  static styles: import("lit").CSSResult[];
+  render(): import("lit").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-detail-list': DetailListElement;
+  }
+  interface HTMLElementEventMap extends ListElementEventMap {}
+}
+//#endregion
+//#region src/dock/types.d.ts
+/** Axis values used by `ixfx-split-layout` — stored verbatim in the model. */
+type DockAxis = `row` | `column`;
+type DockLayout = {
+  readonly version: 1;
+  readonly root: DockNode;
+};
+type DockNode = DockSplitNode | DockStackNode;
+/**
+ * N-ary split node, rendered as a single `ixfx-split-layout`.
+ * `direction` uses the element's flexbox sense: `row` places children
+ * side-by-side, `column` stacks them vertically.
+ */
+interface DockSplitNode {
+  kind: `split`;
+  direction: DockAxis;
+  /** Flex weights, parallel to `children`. Need not sum to 1. */
+  sizes: number[];
+  /** Two or more children (post-normalize). */
+  children: DockNode[];
+}
+interface DockStackNode {
+  kind: `stack`;
+  /** Panel-ids in tab order. */
+  panels: string[];
+  /** Active panel-id (empty when the stack is empty). */
+  active: string;
+  /**
+   * App-defined container name (e.g. `primary-sidebar`). Must be unique
+   * within a layout; lookups resolve to the first match in tree order.
+   * Survives serialization and `normalize()` (named empty stacks are kept).
+   */
+  name?: string;
+  /**
+   * Hide tab labels in this leaf's strip (icon-only tabs). Passed down to
+   * the leaf's `ixfx-tab-list` as `hide-labels`.
+   */
+  hideLabels?: boolean;
+  /** Whole stack collapsed to its titlebar / strip. */
+  collapsed?: boolean;
+  /** Size to restore into the parent split on expand. */
+  preCollapseSize?: string;
+}
+type DockOperation = `tabs` | `split-horizontal` | `split-vertical`;
+interface DockPanelDragStartDetail {
+  readonly panelId: string;
+  readonly pointerId: number;
+  readonly clientX: number;
+  readonly clientY: number;
+}
+type DockPanelDragStartEvent = CustomEvent<DockPanelDragStartDetail>;
+interface DockChangeDetail {
+  readonly layout: DockLayout;
+}
+type DockChangeEvent = CustomEvent<DockChangeDetail>;
+interface DockPanelAddedDetail {
+  readonly panelId: string;
+}
+type DockPanelAddedEvent = CustomEvent<DockPanelAddedDetail>;
+interface DockPanelRemovedDetail {
+  readonly panelId: string;
+}
+type DockPanelRemovedEvent = CustomEvent<DockPanelRemovedDetail>;
+interface DockPanelActivatedDetail {
+  readonly panelId: string;
+}
+type DockPanelActivatedEvent = CustomEvent<DockPanelActivatedDetail>;
+type DockPanelInit = {
+  panelId: string;
+  title?: string;
+  iconName?: string;
+  closable?: boolean;
+  collapsible?: boolean;
+  /** Content kind for leaf placement rules (default `'any'`). */
+  kind?: string;
+};
+/**
+ * Placement rules for one named leaf. A panel kind is accepted when it is
+ * not denied and (when an allowlist is present) it is allowed. `'any'` is
+ * the default panel kind and matches literally — it is not a wildcard.
+ */
+interface DockLeafContentRules {
+  /** Exclusive allowlist, or null when unrestricted. `[]` seals the leaf. */
+  readonly allow: readonly string[] | null;
+  /** Denylist (empty when nothing is denied). */
+  readonly deny: readonly string[];
+}
+/**
+ * Reference to a stack leaf: either its container `name` or its numeric
+ * `path` in the layout tree (e.g. `[0, 1]`). Names resolve first-match in
+ * tree order; paths are validated against the current model.
+ */
+type DockLeafRef = string | readonly number[];
+type DockDirection = `up` | `down` | `left` | `right`;
+type DockEdge = `top` | `bottom` | `left` | `right`;
+/** A neighbouring leaf: `name` is null for unnamed leaves. */
+interface DockLeafInfo {
+  readonly name: string | null;
+  /** Path of the leaf in the current model (positional — may shift after mutations). */
+  readonly path: number[];
+}
+/** Geometric neighbours of a leaf, as flat lists (most-overlapping first). */
+interface DockNeighbours {
+  readonly above: DockLeafInfo[];
+  readonly below: DockLeafInfo[];
+  readonly left: DockLeafInfo[];
+  readonly right: DockLeafInfo[];
+}
+type DockAddPanelTarget = {
+  /**
+   * Name of a named stack leaf (`DockStackNode.name`). Takes precedence over
+   * `stack` when both are given. Unknown names fall back to the first stack.
+   */
+  container?: string;
+  /** A panel-id in the target stack (legacy lookup). */
+  stack?: string;
+  index?: number;
+  op?: DockOperation;
+};
+/**
+ * Plain, structured-clone-safe description of a panel. Enough to recreate an
+ * `ixfx-dock-panel` in another document / process (e.g. a new Electron
+ * `BrowserWindow`). `contentHTML` is a best-effort capture of the panel's
+ * light-DOM markup at snapshot time — apps whose panels hold live state or
+ * framework-managed DOM should rebuild the body from their own model instead
+ * and ignore this field.
+ */
+interface DockPanelSnapshot {
+  panelId: string;
+  title: string;
+  iconName: string;
+  closable: boolean;
+  collapsible: boolean;
+  /** Content kind for leaf placement rules (`'any'` when unset). */
+  kind: string;
+  /** The panel's `accepts` restriction token string (may be empty). */
+  accepts: string;
+  /** Best-effort `innerHTML` of the panel element at capture time. */
+  contentHTML: string;
+}
+/**
+ * Serializable result of hit-testing a point against a host — what a drop
+ * there would do. Returned by `queryDropTarget()` / `previewExternalDrop()`
+ * so a coordinator (in-page or over IPC) can reason about the outcome without
+ * a live `DockDropZone` (which carries element references).
+ */
+interface DockDropTarget {
+  operation: DockOperation;
+  /** Path of the target stack in the host model; `[]` = the host root. */
+  targetPath: number[];
+  side: `before` | `after`;
+  /** Tab insertion index for `tabs` drops. */
+  gapIndex?: number;
+}
+interface DockPanelTearOutDetail {
+  readonly panelId: string;
+  /** Snapshot captured from the source panel at release. */
+  readonly snapshot: DockPanelSnapshot;
+  /** Pointer position in the source window's viewport at release. */
+  readonly clientX: number;
+  readonly clientY: number;
+  /** Pointer position in screen coordinates at release — for window placement. */
+  readonly screenX: number;
+  readonly screenY: number;
+}
+type DockPanelTearOutEvent = CustomEvent<DockPanelTearOutDetail>;
+interface DockDragBoundaryDetail {
+  readonly panelId: string;
+  readonly clientX: number;
+  readonly clientY: number;
+  readonly screenX: number;
+  readonly screenY: number;
+}
+/** `dock-panel-drag-out` / `dock-panel-drag-in`. */
+type DockDragBoundaryEvent = CustomEvent<DockDragBoundaryDetail>;
+//#endregion
+//#region src/dock/dock-panel.d.ts
+interface DockPanelElementEventMap {
+  'dock-panel-drag-start': DockPanelDragStartEvent;
+  'toggle': TitlebarToggleEvent;
+  'close': TitlebarCloseEvent;
+}
+/**
+ * Leaf content + metadata + drag handle. Renders `ixfx-titlebar` chrome when
+ * standalone (`presentation="solo"`) and content only when docked
+ * (`presentation="tabbed"` — the host's tab strip carries the title chrome).
+ * Adds `panel-id` and the titlebar drag handle. Works standalone outside a
+ * host (the drag-start event has no listener and is inert).
+ */
+declare class DockPanelElement extends LitElement {
+  /** Stable identity: model key, slot name suffix, serialization id. */
+  panelId: string;
   /**
-   * Apply a signed delta to the current value, clamp/snap/format, and fire
-   * `input`/`change`. Shared between arrow-key handler and the wheel handler.
+   * Display text (tab label, titlebar). Stored in the `label` attribute —
+   * deliberately not `title`, so browsers never tooltip it.
    */
-  private _applyDelta;
-  _shouldHandleWheel(): boolean;
-  _applyWheelDelta(direction: WheelDirection, event: WheelEvent): void;
+  title: string;
+  iconName: string;
+  closable: boolean;
+  collapsible: boolean;
+  /**
+   * Content kind for the host's leaf placement rules
+   * (`setLeafExclusiveContents` / `setLeafDenyContents`). Matched literally;
+   * defaults to `'any'`.
+   */
+  kind: string;
+  /**
+   * Per-panel restriction when this panel is itself a drop target (solo
+   * leaf). Space-separated `tabs` / `horizontal` / `vertical` / `all`;
+   * `none` rejects everything; default is unrestricted.
+   */
+  accepts: string;
+  /**
+   * Host-controlled. Docked panels are always `tabbed` (content only — the
+   * leaf's tab strip carries the title chrome). `solo` (full titlebar chrome)
+   * applies to panels outside a host or not currently docked.
+   */
+  presentation: `solo` | `tabbed`;
+  /** Solo-mode collapse state, mirrored from the titlebar. */
+  private _collapsed;
+  private _dragPointerId;
+  private _dragStartX;
+  private _dragStartY;
+  private _dragStarted;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
   private _onPointerDown;
   private _onPointerMove;
   private _onPointerUp;
-  private _interceptClick;
-  private _parseValue;
-  /**
-   * Formats the stored value for display, inferring decimal places from the value
-   * string itself. This preserves typed precision (e.g. "0.1234" stays "0.1234")
-   * and also respects trailing zeros written by drag storage (e.g. "5.0" stays "5.0").
-   */
-  private _formatDisplay;
-  private _clamp;
-  private _snap;
-  private _inferDecimals;
-  private _formatNumber;
-  /** Returns a 0..1 fraction for the given value within [min, max]. */
-  private _normalizedValue;
-  static styles: CSSResult[];
+  private _teardownDragListeners;
+  /** Clicks that begin on the close / caret buttons or the toolbar are not drags. */
+  private _isDragHandle;
+  private _dispatchDragStart;
+  private _onTitlebarToggle;
+  private _onTitlebarClose;
+  protected render(): import("lit").TemplateResult<1>;
+  static styles: import("lit").CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-dock-panel': DockPanelElement;
+  }
+}
+interface DockPanelElement {
+  addEventListener: (<K extends keyof DockPanelElementEventMap>(type: K, listener: (this: DockPanelElement, event: DockPanelElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+//#region src/dock/dock-host.d.ts
+interface DockHostElementEventMap {
+  'dock-change': DockChangeEvent;
+  'dock-panel-added': DockPanelAddedEvent;
+  'dock-panel-removed': DockPanelRemovedEvent;
+  'dock-panel-activated': DockPanelActivatedEvent;
+  'dock-panel-drag-start': DockPanelDragStartEvent;
+  /** Panel released outside every host — request to move it to a new window. */
+  'dock-panel-tear-out': DockPanelTearOutEvent;
+  /** Drag pointer left every host's bounds during a drag. */
+  'dock-panel-drag-out': DockDragBoundaryEvent;
+  /** Drag pointer re-entered a host's bounds after being outside. */
+  'dock-panel-drag-in': DockDragBoundaryEvent;
+}
+declare class DockHostElement extends LitElement {
+  /** Initial layout as `DockLayout` JSON. Absent ⇒ all pooled panels go into one root stack. */
+  layout: string | null;
+  /**
+   * Space-separated drop operations this host allows: `tabs`, `horizontal`,
+   * `vertical`, and convenience `all`. `""` / `none` ⇒ nothing may be dropped.
+   */
+  accepts: string;
+  /** Finest-grained veto, consulted per candidate zone. */
+  canAccept: ((panelId: string, op: DockOperation) => boolean) | undefined;
+  private _model;
+  private _pool;
+  private _dropZone;
+  private _dragActive;
+  private _junctions;
+  /** panelId → toolbar nodes currently moved out into a tab item. */
+  private _toolbarsOut;
+  /**
+   * Placement policy per named leaf: `{ allow, deny }` kind sets.
+   * Host-level only — never serialized into the layout, but kept across
+   * `loadLayout()` calls. Existing panels are grandfathered; rules govern
+   * future placements (drags, `addPanel`, re-homing).
+   */
+  private _leafContentRules;
+  private _tabDragPending;
+  private _junctionsKey;
+  private _junctionsRaf;
+  private _hostResizeObserver;
+  /** `toolbar-<name>` slot names currently provided as light-DOM children. */
+  private _toolbarSlots;
+  private _toolbarObserver;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  private _onDragStart;
+  willUpdate(changed: Map<string, unknown>): void;
+  updated(changed: Map<string, unknown>): void;
+  private _buildInitialModel;
+  /** Ensure every pooled panel element appears in the model (appended to the first stack). */
+  private _mergePoolIntoModel;
+  private _scanPanels;
+  /** Refresh the set of provided `toolbar-<name>` slots; re-render on change. */
+  private _scanToolbarSlots;
+  private _findPanelEl;
+  private _firstStack;
+  private _appendPanelToFirstStack;
+  /** Normalized content kind of a panel (`'any'` when unknown/unset). */
+  private _panelKind;
+  /** Whether `kind` may live in `stack` under the current leaf rules. */
+  private _stackAllowsKind;
+  /** First stack (tree order) whose rules admit `kind`, else the first stack. */
+  private _firstStackAllowing;
+  private _onPoolSlotChange;
+  private _syncPool;
+  /** Serialize the current layout, folding live split weights from the DOM. */
+  saveLayout(): DockLayout;
+  loadLayout(layout: DockLayout): void;
+  /**
+   * Dock a panel. Returns false (without touching the DOM) when the
+   * explicitly targeted container denies the panel's `kind`.
+   */
+  addPanel(panel: DockPanelElement | DockPanelInit, target?: DockAddPanelTarget): boolean;
+  /** Whether the stack at `stackPath` admits `kind` under the leaf rules. */
+  private _stackAllowsKindAt;
+  removePanel(panelId: string): boolean;
+  activatePanel(panelId: string): boolean;
+  getPanelIds(): string[];
+  /** Names of every named stack leaf, in tree order. */
+  getContainerNames(): string[];
+  /**
+   * Snapshot of a named container (`{ name, panels, active }`), or null when
+   * no stack carries that name. First match wins when duplicated.
+   */
+  getContainer(name: string): {
+    name: string;
+    panels: string[];
+    active: string;
+  } | null;
+  /** Panel-ids in a named container, in tab order (`[]` when unknown/empty). */
+  getContainerPanels(name: string): string[];
+  /** Panel elements in a named container, in tab order — for iterating children. */
+  getContainerElements(name: string): DockPanelElement[];
+  /**
+   * Restrict a named container to only the given panel kinds — e.g.
+   * `setLeafExclusiveContents('editor', ['document'])`. `tabs` drops,
+   * `addPanel`, and re-homing into the leaf then refuse other kinds, while
+   * edge splits beside the leaf stay allowed (they create a new leaf).
+   * 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
+   * serialized.
+   */
+  setLeafExclusiveContents(name: string, kinds: readonly string[]): void;
+  /**
+   * Forbid the given panel kinds in a named container — e.g.
+   * `setLeafDenyContents('footer', ['files', 'document'])`. Everything else
+   * stays admitted. Pass `[]` to lift the denial. See
+   * {@link setLeafExclusiveContents} for scope/ordering notes.
+   */
+  setLeafDenyContents(name: string, kinds: readonly string[]): void;
+  /** Remove every content rule for a named container. */
+  clearLeafContentRestrictions(name: string): void;
+  /** Copy of a container's rules, or null when unrestricted. */
+  getLeafContentRestrictions(name: string): DockLeafContentRules | null;
+  /**
+   * Geometric neighbours of a leaf (`name` or numeric `path`) — what sits
+   * above / below / left / right of it on screen. Each entry is
+   * `{ name, path }` (`name` is null for unnamed leaves), ordered
+   * most-overlapping first. Returns null when the leaf is unknown.
+   */
+  getNeighbours(leaf: DockLeafRef): DockNeighbours | null;
+  /**
+   * Move a leaf one position in `direction`, swapping with the neighbour it
+   * shares the longest edge with (both keep the remaining structure intact).
+   * Returns false when the leaf is unknown or nothing adjoins that way.
+   */
+  moveLeaf(leaf: DockLeafRef, direction: DockDirection): boolean;
+  /**
+   * Move a leaf to an edge of the overall layout (e.g. toggle a sidebar from
+   * `left` to `right`). The rest of the layout stays intact as a single
+   * subtree and the leaf keeps its absolute size along the target axis.
+   * Returns false when the leaf is unknown or the layout holds one leaf.
+   */
+  moveLeafToEdge(leaf: DockLeafRef, edge: DockEdge): boolean;
+  /**
+   * Capture a structured-clone-safe {@link DockPanelSnapshot} of a panel
+   * (identity, chrome attributes, and a best-effort `innerHTML`). Returns
+   * null when no such panel element is known to this host.
+   */
+  getPanelSnapshot(panelId: string): DockPanelSnapshot | null;
+  /**
+   * {@link getPanelSnapshot} + {@link removePanel} in one step: take the
+   * snapshot, then drop the panel (and its element) from this host. Call this
+   * from a `dock-panel-tear-out` handler once the receiving window has
+   * recreated the panel.
+   */
+  detachPanel(panelId: string): DockPanelSnapshot | null;
+  /**
+   * Hit-test viewport coordinates against this host and return a plain,
+   * serializable {@link DockDropTarget} (no element references) — or null when
+   * the point is outside the host or the resulting zone is disallowed by
+   * `accepts` / `canAccept`. Pure query: no model mutation, no overlay.
+   *
+   * `panelId` is passed to `canAccept`; use any stable id for an external
+   * panel (defaults to `"__external__"`). `kind` covers leaf content rules
+   * for panels unknown to this host (defaults to `'any'`).
+   */
+  queryDropTarget(clientX: number, clientY: number, panelId?: string, kind?: string): DockDropTarget | null;
+  /**
+   * Like {@link queryDropTarget}, but also shows the drop overlay so an
+   * external (cross-window) drag gets the same visual feedback as an in-page
+   * one. Call on every pointer update from the outer coordinator, then
+   * {@link endExternalDrop} when the drag leaves or ends.
+   */
+  previewExternalDrop(clientX: number, clientY: number, panelId?: string, kind?: string): DockDropTarget | null;
+  /** Clear any overlay left by {@link previewExternalDrop}. */
+  endExternalDrop(): void;
+  /**
+   * Recreate a panel from a {@link DockPanelSnapshot} (or a bare
+   * {@link DockPanelInit}) and dock it. With `at` viewport coordinates the
+   * panel lands where a drop there would put it (respecting `accepts` /
+   * `canAccept` and leaf content rules); without them, or when the point
+   * misses the host, it goes into the first stack admitting its kind.
+   * Returns the created element, or null when a panel
+   * with that id is already docked here.
+   */
+  acceptExternalPanel(snapshot: DockPanelSnapshot | DockPanelInit, at?: {
+    clientX: number;
+    clientY: number;
+  }): DockPanelElement | null;
+  /**
+   * Hit-test a pointer position against this host's leaves and edges. Returns
+   * a zone with rects relative to the host, or null when the pointer is
+   * outside the host or the candidate zone is disallowed.
+   */
+  computeDropZone(clientX: number, clientY: number, panelId: string, kind?: string): DockDropZone | null;
+  private _zoneAllowed;
+  /**
+   * Apply a drop. `sourceHost` differs from `this` when the drag crossed
+   * hosts; the panel element is adopted into this host first.
+   */
+  handleDrop(panelId: string, zone: DockDropZone, sourceHost?: DockHostElement): void;
+  /**
+   * Move `panelId` (already present somewhere in the model) to the position
+   * described by `zone`. Shared by in-page drops and external panel adoption.
+   */
+  private _applyZone;
+  /**
+   * Move a panel element out of this host into `target`, dropping it from
+   * this host's model. Used for cross-host drags.
+   */
+  releasePanel(panelId: string, target: DockHostElement): void;
+  /** Adopt a panel element from another host (the one sanctioned reparent). */
+  adoptPanelElement(el: DockPanelElement): void;
+  setDragActive(active: boolean): void;
+  setDropZone(zone: DockDropZone | null): void;
+  private _scheduleJunctions;
+  /**
+   * Find points where a parent split's gutter line meets a nested split's
+   * gutter (T and + crossings). Each junction handle starts both gutter drags
+   * at once, like a corner resize in VS Code.
+   */
+  private _computeJunctions;
+  private _onJunctionPointerDown;
+  /** Fold live weights from each rendered `ixfx-split-layout` into the model. */
+  private _foldLiveWeights;
+  private _onSplitWeightsChanged;
+  private _onSplitCollapsed;
+  private _onSplitClose;
+  private _onTabChange;
+  private _onStripPointerDown;
+  private _onTabDragMove;
+  private _onTabDragUp;
+  private _teardownTabDragListeners;
+  /** After a dock drag from a tab/titlebar, swallow the trailing click so it cannot re-select or toggle. */
+  private _suppressNextClick;
+  private _removeFromModel;
+  /** Normalize, re-render, and announce the structural change. */
+  private _commit;
+  private _syncSlots;
+  /**
+   * Per-panel toolbar routing: docked panels render content-only, so the
+   * active panel's toolbar nodes live in its generated tab item (shown
+   * right-aligned while active). Node moves preserve element state. Panels
+   * outside the model keep their toolbar in their own (solo) chrome.
+   */
+  private _syncToolbars;
+  private _returnToolbar;
+  private _returnAllToolbars;
+  private _emitChange;
+  protected render(): import("lit").TemplateResult<1>;
+  private _renderNode;
+  private _renderSplit;
+  private _renderLeaf;
+  private _renderTabItem;
+  private _stripCaretRect;
+  static styles: import("lit").CSSResult[];
 }
 declare global {
   interface HTMLElementTagNameMap {
-    'ixfx-editable-number': EditableNumber;
+    'ixfx-dock-host': DockHostElement;
   }
 }
+interface DockHostElement {
+  addEventListener: (<K extends keyof DockHostElementEventMap>(type: K, listener: (this: DockHostElement, event: DockHostElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+//#region src/dock/dock-drag.d.ts
+interface Rect$1 {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+interface DockDropZone {
+  /** Host whose model would receive the drop. */
+  readonly host: DockHostElement;
+  readonly operation: DockOperation;
+  /** Path of the target stack (`[]` = the host root). */
+  readonly targetPath: number[];
+  readonly side: `before` | `after`;
+  /** Insert position for `tabs` drops (panel index in the target stack). */
+  readonly gapIndex?: number;
+  /** Highlight rect, relative to the host. */
+  readonly rect: Rect$1;
+  /** Optional insertion caret for strip gaps, relative to the host. */
+  readonly caretRect?: Rect$1;
+}
+/** True when the point lies within the bounding box of any registered host. */
+declare function pointerOverAnyHost(clientX: number, clientY: number): boolean;
+declare function isDragging(): boolean;
+declare function getActiveDragPanelId(): string | null;
+//#endregion
+//#region src/dock/dock-model.d.ts
+/**
+ * The dock model is a plain mutable tree owned exclusively by the host
+ * element. Mutators below change the tree in place; the host calls
+ * `normalize(root)` then `requestUpdate()` after batching mutations.
+ */
+declare function isSplit(node: DockNode): node is DockSplitNode;
+declare function isStack(node: DockNode): node is DockStackNode;
+declare function createEmptyStack(): DockStackNode;
+declare function createEmptyLayout(): DockLayout;
+declare function createStack(panels: string[], active?: string, name?: string): DockStackNode;
+declare function createSplit(direction: DockAxis, children: DockNode[], sizes?: number[]): DockSplitNode;
+/**
+ * Runs after every mutation:
+ * - stack `active` fixed to a member of `panels` (or `''` when empty)
+ * - empty *unnamed* stacks removed from their parent split (and their
+ *   `sizes` entry); named empty stacks are kept so the name stays addressable
+ * - splits with ≤1 child replaced by that child (spliced into the parent)
+ * - a child split whose direction equals its parent's is flattened into it,
+ *   spreading its sizes across the slot it vacated
+ * - `sizes` kept parallel to `children` (padded with the mean weight)
+ * - an empty root collapses to a single empty stack
+ */
+declare function normalize(root: DockNode): DockNode;
+declare function findNode(root: DockNode, path: number[]): DockNode | null;
+/** Parent split of the node at `path`; null when path is empty or malformed. */
+declare function findParentOf(root: DockNode, path: number[]): DockSplitNode | null;
+/** Path of the stack containing `panelId`, or null. */
+declare function findStackOf(root: DockNode, panelId: string): number[] | null;
+declare function collectPanelIds(root: DockNode): string[];
+/**
+ * Path of the first stack (tree order) whose `name` matches, or null.
+ * Names are expected to be unique per layout; duplicates resolve first-wins.
+ */
+declare function findStackPathByName(root: DockNode, name: string): number[] | null;
+/** Names of every named stack leaf, in tree order. */
+declare function collectContainerNames(root: DockNode): string[];
+/**
+ * Paths of every stack leaf, in tree order. `[]` is the root itself when it
+ * is a stack.
+ */
+declare function collectStackPaths(root: DockNode): number[][];
+declare function addPanelToStack(stack: DockStackNode, panelId: string, index?: number): void;
+declare function removePanelFromStack(stack: DockStackNode, panelId: string): void;
+declare function setActive(stack: DockStackNode, panelId: string): boolean;
+/**
+ * Insert `node` beside the child at `targetPath`, into the parent split when
+ * its direction matches `direction`, otherwise wrap the target in a new split.
+ * `side` selects before/after; the neighbour's weight is split 50/50.
+ * Returns the path of the inserted node, or null.
+ */
+declare function insertBeside(root: DockNode, targetPath: number[], direction: DockAxis, newNode: DockNode, side: `before` | `after`): number[] | null;
+/**
+ * Wrap the whole root in a new split of `direction`, replacing it in place so
+ * the caller's reference stays valid. Returns true on success.
+ */
+declare function wrapRoot(root: DockNode, direction: DockAxis, newNode: DockNode, side: `before` | `after`): boolean;
+/**
+ * Remove the stack at `stackPath` from the tree. Its panels are moved into
+ * `fallbackStack` (if given and still attached) so they are not silently
+ * lost; otherwise they are dropped from the model (elements return to the
+ * pool). Returns the removed stack.
+ */
+declare function extractStack(root: DockNode, stackPath: number[], fallbackStack?: DockStackNode): DockStackNode | null;
+interface DockRect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+interface LeafGeom {
+  path: number[];
+  name: string | null;
+  rect: DockRect;
+}
+/**
+ * Resolve a {@link DockLeafRef} to a stack path. Strings match container
+ * `name` first-wins; arrays must index an existing stack leaf. Returns null
+ * when unresolvable.
+ */
+declare function resolveLeafPath(root: DockNode, ref: DockLeafRef): number[] | null;
+/** Absolute (unit-square) rect of every stack leaf, in tree order. */
+declare function computeLeafGeoms(root: DockNode): LeafGeom[];
+/**
+ * Geometric neighbours of a leaf — what the user sees above / below / left /
+ * right of it. Each list holds `{ name, path }` (name is null for unnamed
+ * leaves), ordered most-overlapping first. Returns null when `ref` is
+ * unresolvable.
+ */
+declare function getLeafNeighbours(root: DockNode, ref: DockLeafRef): DockNeighbours | null;
+/**
+ * Exchange two leaves' positions in the tree, each carrying its size slot so
+ * the remaining structure and proportions are untouched. Returns false when
+ * either path is not a stack leaf.
+ */
+declare function swapLeaves(root: DockNode, pathA: number[], pathB: number[]): boolean;
+/**
+ * Move a leaf one position in `direction`, swapping with the neighbour it
+ * shares the longest edge with. Returns false when `ref` is unresolvable or
+ * nothing adjoins in that direction. Run `normalize()` afterwards.
+ */
+declare function moveLeafStep(root: DockNode, ref: DockLeafRef, direction: DockDirection): boolean;
+/**
+ * Move a leaf to an edge of the overall layout, keeping the rest of the
+ * tree intact as a single subtree and preserving the leaf's absolute size
+ * along the target axis. Returns false when `ref` is unresolvable or the
+ * layout holds a single leaf. Run `normalize()` afterwards (also safe to
+ * call it twice — the host's commit does).
+ */
+declare function moveLeafNodeToEdge(root: DockNode, ref: DockLeafRef, edge: DockEdge): boolean;
+declare function serializeLayout(root: DockNode): DockLayout;
+/**
+ * Parse layout JSON, validate loosely, and normalize. Returns null when the
+ * JSON is malformed or the root is missing/invalid.
+ */
+declare function parseLayout(json: string): DockLayout | null;
 //#endregion
 //#region src/form/form-group.d.ts
 declare class FormGroupElement extends LitElement {
@@ -560,6 +1272,7 @@ declare class PanelGroupElement extends LitElement {
   orientation: PanelGroupOrientation;
   variant: PanelVariant;
   toggleInteraction: PanelToggleInteraction;
+  collapsible: boolean;
   allowMultiple: boolean;
   gap: string;
   private _panels;
@@ -761,6 +1474,24 @@ declare global {
   }
 }
 //#endregion
+//#region src/split-layout/split-model.d.ts
+declare function buildModel(rootEl: HTMLElement): GroupNode;
+declare function normalise(group: GroupNode): GroupNode;
+interface DistributeResult {
+  sizesPx: number[];
+  belowMin: number[];
+}
+declare function distribute(sizesPx: number[], gutterIndex: number, deltaPx: number, constraints: Array<{
+  minPx: number;
+  maxPx: number | null;
+  fixedPx: number | null;
+  whenSmall: WhenSmall;
+}>): DistributeResult;
+declare function resolveTracks(group: GroupNode, _containerPx: number): string;
+declare function toSnapshot(group: GroupNode): LayoutSnapshot;
+declare function applySnapshot(group: GroupNode, snapshot: LayoutSnapshot): GroupNode;
+declare function walk(group: GroupNode, visitor: (node: LayoutNode, path: number[]) => void): void;
+//#endregion
 //#region src/tabs/tab-panel.d.ts
 declare class TabPanelElement extends LitElement {
   render(): import("lit").TemplateResult<1>;
@@ -956,12 +1687,14 @@ declare global {
 type ToolbarOrientation = `horizontal` | `vertical-left` | `vertical-right`;
 type ToolbarLayout = `one-line` | `wrap`;
 type ToolbarVerticalWriting = `auto` | `up` | `down` | `none`;
+type ToolbarAlign = `near` | `far`;
 //#endregion
 //#region src/toolbar/toolbar.d.ts
 declare class ToolbarElement extends LitElement {
   orientation: ToolbarOrientation;
   layout: ToolbarLayout;
   verticalWriting: ToolbarVerticalWriting;
+  toolbarAlign: ToolbarAlign;
   showGroupLabels: boolean;
   invisibleGroups: boolean;
   private _overflowCount;
@@ -992,11 +1725,68 @@ declare global {
   }
 }
 //#endregion
+//#region src/twosplit-layout/split-layout.d.ts
+/**
+ * Lays out two elements within a container, with a bar to resize them
+ * proportionally.
+ *
+ * Events
+ * ixfx-split-collapsed: Dispatched when a panel is collapsed/uncollapsed via drag.
+ *   detail: { panel: 'A' | 'B', collapsed: boolean }
+ *
+ * Attributes
+ * layout: `vertical`|`horizontal`
+ * sizeA/B: CSS size of section A or B. Can use relative or absolute values
+ * fixedA/B: If _true_ size will be calculated in pixels. By default (_false_) it uses % of whole
+ * collapsible: If _true_, panels can be collapsed by dragging to edge (default: false)
+ * minSizeA/B: Minimum size for panel A or B (e.g., "100px" or "20%"). Default: none
+ * maxSizeA/B: Maximum size for panel A or B (e.g., "200px" or "80%"). Default: none
+ *
+ * CSS variables
+ * --handle-size: 2px;              // Width/height of split bar
+ * --handle-colour: var(--surface-5);     // Colour of handle
+ * --handle-hover-colour: var(--surface-6); // Colour of handle when hovering
+ * --handle-active-colour: var(--accent);    // Colour of handle when being used
+ * --handle-bg: var(--handle-colour); // Background of grab handle rectangle
+ * --handle-grab-colour: var(--surface-muted-text); // Colour of grab handle dots
+ * --handle-grab-dot-size: 3px;      // Diameter of grab handle dots
+ * --handle-grab-size: 16px;         // Length of grab handle
+ * --handle-grab-thickness: 8px;     // Thickness of grab handle
+ */
+declare class TwoSplitLayoutElement extends LitElement {
+  #private;
+  layout: `vertical` | `horizontal`;
+  sizeA: string;
+  sizeB: string;
+  fixedA: boolean;
+  fixedB: boolean;
+  collapsible: boolean;
+  collapsedA: boolean;
+  collapsedB: boolean;
+  minSizeA: string;
+  maxSizeA: string;
+  minSizeB: string;
+  maxSizeB: string;
+  private _hasCorner;
+  private get showGrabHandle();
+  disconnectedCallback(): void;
+  firstUpdated(): void;
+  updated(changedProperties: Map<string, unknown>): void;
+  getZone(): HTMLElement | undefined;
+  render(): import("lit").TemplateResult<1>;
+  static styles: import("lit").CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "ixfx-twosplit-layout": TwoSplitLayoutElement;
+  }
+}
+//#endregion
 //#region src/util/checkbox.d.ts
 declare function monitorIndeterminate(targetElOrQuery: string | HTMLElement, watchedElsOrQueries: Array<string | HTMLElement>): () => void;
 //#endregion
 //#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 AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, AddItemOptions, 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, CustomCheckboxOptions, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataGridCellClickDetail, DataGridCellClickEvent, DataGridCellEditDetail, DataGridCellEditEvent, DataGridColumnReorderDetail, DataGridColumnReorderEvent, DataGridColumnResizeDetail, DataGridColumnResizeEvent, DataGridColumnVisibilityDetail, DataGridColumnVisibilityEvent, DataGridElement, DataGridElementEventMap, DataGridGroupChangeDetail, DataGridGroupChangeEvent, DataGridSelectDetail, DataGridSelectEvent, DataGridSortDetail, DataGridSortEvent, DataProviderResult, DisplayTextLogic, DragSnappingFn, DragTarget, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, Endpoints, EntryMode, FormElement, FormGroupElement, FormPartElement, 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, IxfxRatingElement, 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, Notification, NotificationContent, NotificationManager, NotificationPillElement, NotificationPillElementEventMap, NotificationRenderer, NotificationRendererHooks, NotificationType, NotifierOptions, type OklchValue, Orientation, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupOrientation, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PillPosition, PillQueueDisplay, PillRendererOptions, PillSafeArea, PillTapDetail, PillTapEvent, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramOrientation, 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, RendererStyle, ResizeMode, SelectEventDetail, SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap, SelectionMode, 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, SortCompareFn, 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, Tab, TabAddOptions, TabController, TabControllerOptions, TabListChangeDetail, TabListChangeEvent, TabListDragMode, TabListElement, TabListItemElement, TabListReorderDetail, TabListReorderEvent, TabPanelElement, TabPanelsElement, TextShimmerElement, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, ToolbarElement, ToolbarGroupElement, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeBaseElement, TreeBaseElementEventMap, TreeCheckboxState, 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, createPillRenderer, createTreeListAdapter, createVerticalListAdapter, 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, AddItemOptions, Axis, 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, CustomCheckboxOptions, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataGridCellClickDetail, DataGridCellClickEvent, DataGridCellEditDetail, DataGridCellEditEvent, DataGridColumnReorderDetail, DataGridColumnReorderEvent, DataGridColumnResizeDetail, DataGridColumnResizeEvent, DataGridColumnVisibilityDetail, DataGridColumnVisibilityEvent, DataGridElement, DataGridElementEventMap, DataGridGroupChangeDetail, DataGridGroupChangeEvent, DataGridSelectDetail, DataGridSelectEvent, DataGridSortDetail, DataGridSortEvent, DataProviderResult, type DetailFormatter, DetailListElement, type DetailSortComparator, type DetailSortItem, type DetailSortMode, DisplayTextLogic, DistributeResult, DockAddPanelTarget, DockAxis, DockChangeDetail, DockChangeEvent, DockDirection, DockDragBoundaryDetail, DockDragBoundaryEvent, DockDropTarget, type DockDropZone, DockEdge, DockHostElement, DockHostElementEventMap, DockLayout, DockLeafContentRules, DockLeafInfo, DockLeafRef, DockNeighbours, DockNode, DockOperation, DockPanelActivatedDetail, DockPanelActivatedEvent, DockPanelAddedDetail, DockPanelAddedEvent, DockPanelDragStartDetail, DockPanelDragStartEvent, DockPanelElement, DockPanelElementEventMap, DockPanelInit, DockPanelRemovedDetail, DockPanelRemovedEvent, DockPanelSnapshot, DockPanelTearOutDetail, DockPanelTearOutEvent, DockRect, DockSplitNode, DockStackNode, DragSnappingFn, DragTarget, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, Endpoints, EntryMode, FormElement, FormGroupElement, FormPartElement, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GridMode, GridResolution, GroupNode, 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 IconEntry, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxRatingElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LaneData, LaneType, LayoutNode, LayoutSnapshot, LeafGeom, 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, Notification, NotificationContent, NotificationManager, NotificationPillElement, NotificationPillElementEventMap, NotificationRenderer, NotificationRendererHooks, NotificationType, NotifierOptions, type OklchValue, Orientation, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupOrientation, PanelInfo, PanelNode, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PillPosition, PillQueueDisplay, PillRendererOptions, PillSafeArea, PillTapDetail, PillTapEvent, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramOrientation, 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, RendererStyle, ResizeMode, SelectEventDetail, SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap, SelectionMode, 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, 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, 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, ToolbarGroupElement, ToolbarLayout, ToolbarOrientation, ToolbarVerticalWriting, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeBaseElement, TreeBaseElementEventMap, TreeCheckboxState, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeListAdapterOptions, TreeListElement, TreeSearchHost, TreeSelectionFilter, TwoSplitLayoutElement, UserScale, ValueMode, VerticalListAdapterOptions, VerticalListElement, ViewRange, WhenSmall, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, addPanelToStack, applyAgeModification, applyHighlights, applySnapshot, attachTimelineInteractions, buildHighlightTargets, buildModel, clearHighlights, collectContainerNames, collectDataResult, collectPanelIds, collectStackPaths, computeColour, computeLeafGeoms, createAcCompletionProvider, createElementIncrSearch, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createSplit, createStack, createTreeListAdapter, createVerticalListAdapter, distribute, extractStack, findNode, findParentOf, findStackOf, findStackPathByName, getActiveDragPanelId, getIcon, getIconEntry, getIconFont, getLeafNeighbours, hasIcon, iconBus, init, insertBeside, isDragging, isSplit, isStack, monitorIndeterminate, moveLeafNodeToEdge, moveLeafStep, normalise, normalize, parseColourScaleAttr, parseLayout, pointerOverAnyHost, readBaseColour, registerFontIcon, registerIcon, removePanelFromStack, resolveCssVars, resolveGrid, resolveLeafPath, resolveTracks, serializeLayout, setActive, setIconFont, svgToDataUri, swapLeaves, timelineStyles, toSnapshot, walk, wrapRoot };
 //# sourceMappingURL=index.d.ts.map