@ixfx/components 0.7.0 → 0.7.1

package/dist/index.js

@@ -3,21 +3,21 @@ import { t as TickledController } from "./tickled-controller-h9GmJ_bU.js";
 import { t as themeFallbacks } from "./fallbacks-DNI9xt0F.js";
 import { t as popupSurfaceStyles } from "./popup-D80sj2QC.js";
 import { n as safeCustomElement, t as __decorate } from "./decorate-VRK8rslU.js";
-import { a as svgToDataUri, i as registerIcon, n as hasIcon, r as iconBus, t as getIcon } from "./registry-CkW7q09Q.js";
-import { t as IxfxIconElement } from "./icon-CvnPanhA.js";
+import { a as iconBus, c as setIconFont, i as hasIcon, l as svgToDataUri, n as getIconEntry, o as registerFontIcon, r as getIconFont, s as registerIcon, t as getIcon } from "./registry-BEtb8_wB.js";
+import { t as IxfxIconElement } from "./icon-DcEEGQa_.js";
 import { AcTextElement } from "./ac-text.js";
 import { t as DataController } from "./data-controller-DOlmqNKb.js";
 import { n as createIncrSearch, r as createFuzzySearch, t as createElementIncrSearch } from "./element-search-Y8SRfPGM.js";
 import { n as createAcCompletionProvider, t as IncrSearchTreeController } from "./incr-search-vCzuao-2.js";
 import { AcTokenElement } from "./ac-token.js";
-import { i as ICON_CLOSE, n as ICON_CHECK, r as ICON_CHEVRON_DOWN, t as ICON_CARET_RIGHT } from "./defaults-BkWCPJFL.js";
+import { i as ICON_CLOSE, n as ICON_CHECK, r as ICON_CHEVRON_DOWN, t as ICON_CARET_RIGHT } from "./defaults-BJwDsMH4.js";
 import "./icons.js";
 import { t as prominenceStyles } from "./prominence-DlFShic3.js";
-import { n as buttonStyles, t as ButtonElement } from "./button-Dat2yHAU.js";
+import { n as buttonStyles, t as ButtonElement } from "./button-DsFbV4XD.js";
 import { n as ListSelectionController, t as VerticalListElement } from "./vertical-list-ClnqTkF3.js";
-import "./menu-item-B-zYrTTi.js";
+import "./menu-item-D2S4i8u1.js";
 import { Checkbox } from "./checkbox.js";
-import { n as ColourPicker, t as ColourPickerPopup } from "./colour-picker-BSDBL-QL.js";
+import { n as ColourPicker, t as ColourPickerPopup } from "./colour-picker-Ddsk-7E_.js";
 import { LabelledRangeInput } from "./labelled-range-input.js";
 import { t as collectDataResult } from "./data-provider-35TyWclX.js";
 import { i as TreeDataModel, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-Ch4W8qXQ.js";
@@ -26,7 +26,7 @@ import { NarrowedTextElement } from "./narrowed-text.js";
 import { CrumbNavigationElement } from "./crumbs.js";
 import { DataDisplayComponent } from "./data-display.js";
 import { t as createDragGhost } from "./drag-ghost-DtSDvjri.js";
-import { t as menu_exports } from "./menu-BjRvlgPy.js";
+import { t as menu_exports } from "./menu-CXDFJxNm.js";
 import { DataGridElement } from "./data-grid.js";
 import { a as distribute, c as toSnapshot, i as buildModel, l as walk, n as SplitPanelElement, o as normalise, r as applySnapshot, s as resolveTracks, t as SplitLayoutElement } from "./split-layout-BFSbUZQv.js";
 import { TabListElement } from "./tabs.js";
@@ -36,14 +36,14 @@ import { n as EditableNumber, t as LabelledSliderInput } from "./labelled-slider
 import { t as FormElement } from "./form-CsXJX15p.js";
 import { PanelElement } from "./panel.js";
 import { GroupedItemListerElement } from "./grouped-item-lister.js";
-import { t as IxfxHexEditorElement } from "./hex-editor-Bk6rxhfg.js";
+import { t as IxfxHexEditorElement } from "./hex-editor-BiRfwTz1.js";
 import { t as RadialInputElement } from "./radial-input-Dp5qz0ly.js";
 import { LabelledRadialInput } from "./labelled-radial-input.js";
 import { t as SliderInputElement } from "./slider-input-De4eoT11.js";
 import { LedElement } from "./led.js";
 import { MillerBaseElement, MillerListElement, MillerTreeController } from "./miller.js";
 import { NotificationPillElement } from "./notifier.js";
-import { a as TooltipElement, c as computeColour, i as PlotMultiAxis, l as parseColourScaleAttr, n as PlotSingleAxis, o as PlotDataSeries, r as PlotHistogram, s as applyAgeModification, t as PlotXyAxis, u as readBaseColour } from "./xy-axis-CxHC8z5E.js";
+import { a as TooltipElement, c as computeColour, i as PlotMultiAxis, l as parseColourScaleAttr, n as PlotSingleAxis, o as PlotDataSeries, r as PlotHistogram, s as applyAgeModification, t as PlotXyAxis, u as readBaseColour } from "./xy-axis-DWizs0bt.js";
 import { PolarPad } from "./polar-pad.js";
 import { t as tooltipValueStyles } from "./tooltip-CJt3WLmN.js";
 import { RangeInput } from "./range-input.js";
@@ -2526,10 +2526,11 @@ function unregisterDockHost(host) {
 * Begin a dock-panel drag. Called by hosts in response to their own
 * `dock-panel-drag-start` events (titlebar or tab-item handles).
 */
-function startDrag(panelId, sourceHost, pointerId, clientX, clientY) {
+function startDrag(panelId, sourceHost, pointerId, clientX, clientY, kind) {
 	if (activeDrag !== null);
 	activeDrag = {
 		panelId,
+		kind,
 		sourceHost,
 		pointerId,
 		ghost: createGhostForPanel(sourceHost, panelId),
@@ -2602,7 +2603,7 @@ function onKeyDown(event) {
 }
 function findDropZone(drag, clientX, clientY) {
 	for (const host of dragHosts) {
-		const zone = host.computeDropZone(clientX, clientY, drag.panelId);
+		const zone = host.computeDropZone(clientX, clientY, drag.panelId, drag.kind);
 		if (zone !== null) return zone;
 	}
 	return null;
@@ -2690,12 +2691,15 @@ function createEmptyLayout() {
 		root: createEmptyStack()
 	};
 }
-function createStack(panels, active) {
-	return {
+function createStack(panels, active, name) {
+	const stack = {
 		kind: `stack`,
 		panels: [...panels],
 		active: active ?? panels[0] ?? ``
 	};
+	const trimmed = name?.trim();
+	if (trimmed) stack.name = trimmed;
+	return stack;
 }
 function createSplit(direction, children, sizes) {
 	const mean = children.length > 0 ? 1 / children.length : 1;
@@ -2709,7 +2713,8 @@ function createSplit(direction, children, sizes) {
 /**
 * Runs after every mutation:
 * - stack `active` fixed to a member of `panels` (or `''` when empty)
-* - empty stacks removed from their parent split (and their `sizes` entry)
+* - 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
@@ -2718,13 +2723,14 @@ function createSplit(direction, children, sizes) {
 */
 function normalize(root) {
 	if (isStack(root)) {
+		sanitizeStackName(root);
 		if (!root.panels.includes(root.active)) root.active = root.panels[0] ?? ``;
 		return root;
 	}
 	for (let i = root.children.length - 1; i >= 0; i--) {
 		normalize(root.children[i]);
 		const child = root.children[i];
-		if (isStack(child) && child.panels.length === 0) {
+		if (isStack(child) && child.panels.length === 0 && !child.name) {
 			root.children.splice(i, 1);
 			root.sizes.splice(i, 1);
 			continue;
@@ -2758,17 +2764,36 @@ function replaceNodeContents(target, source) {
 		const t = target;
 		t.panels = source.panels;
 		t.active = source.active;
+		if (source.name !== void 0) t.name = source.name;
+		else delete t.name;
+		if (source.hideLabels !== void 0) t.hideLabels = source.hideLabels;
+		else delete t.hideLabels;
 		delete t.collapsed;
 		delete t.preCollapseSize;
+		if (source.collapsed !== void 0) t.collapsed = source.collapsed;
+		if (source.preCollapseSize !== void 0) t.preCollapseSize = source.preCollapseSize;
 	} else {
 		target.kind = `split`;
 		const t = target;
 		t.direction = source.direction;
 		t.children = source.children;
 		t.sizes = source.sizes;
+		const stale = t;
+		delete stale.panels;
+		delete stale.active;
+		delete stale.name;
+		delete stale.collapsed;
+		delete stale.preCollapseSize;
 	}
 	return target;
 }
+/** Trim `name`; drop it when empty / non-string so lookups stay predictable. */
+function sanitizeStackName(stack) {
+	if (stack.name === void 0) return;
+	const trimmed = typeof stack.name === `string` ? stack.name.trim() : ``;
+	if (trimmed) stack.name = trimmed;
+	else delete stack.name;
+}
 function findNode(root, path) {
 	let current = root;
 	for (const index of path) {
@@ -2802,6 +2827,36 @@ function collectPanelIds(root) {
 	return root.children.flatMap(collectPanelIds);
 }
 /**
+* Path of the first stack (tree order) whose `name` matches, or null.
+* Names are expected to be unique per layout; duplicates resolve first-wins.
+*/
+function findStackPathByName(root, name) {
+	const wanted = name.trim();
+	if (!wanted) return null;
+	return findStackPathByNameInner(root, wanted, []);
+}
+function findStackPathByNameInner(node, name, path) {
+	if (isStack(node)) return node.name === name ? path : null;
+	for (let i = 0; i < node.children.length; i++) {
+		const found = findStackPathByNameInner(node.children[i], name, [...path, i]);
+		if (found !== null) return found;
+	}
+	return null;
+}
+/** Names of every named stack leaf, in tree order. */
+function collectContainerNames(root) {
+	const out = [];
+	const visit = (node) => {
+		if (isStack(node)) {
+			if (node.name) out.push(node.name);
+			return;
+		}
+		node.children.forEach(visit);
+	};
+	visit(root);
+	return out;
+}
+/**
 * Paths of every stack leaf, in tree order. `[]` is the root itself when it
 * is a stack.
 */
@@ -2916,6 +2971,251 @@ function extractStack(root, stackPath, fallbackStack) {
 	normalize(root);
 	return stack;
 }
+/** Tolerance for edge-touch comparisons in unit-square geometry. */
+const GEOM_EPS = 1e-9;
+function pathsEqual(a, b) {
+	return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+/**
+* 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.
+*/
+function resolveLeafPath(root, ref) {
+	if (typeof ref === `string`) return findStackPathByName(root, ref);
+	if (!Array.isArray(ref)) return null;
+	let current = root;
+	for (const index of ref) {
+		if (!Number.isInteger(index) || index < 0) return null;
+		if (!isSplit(current)) return null;
+		const next = current.children[index];
+		if (!next) return null;
+		current = next;
+	}
+	return isStack(current) ? [...ref] : null;
+}
+/** Absolute (unit-square) rect of every stack leaf, in tree order. */
+function computeLeafGeoms(root) {
+	const out = [];
+	const visit = (node, path, rect) => {
+		if (isStack(node)) {
+			out.push({
+				path,
+				name: node.name ?? null,
+				rect
+			});
+			return;
+		}
+		const total = node.sizes.reduce((sum, w) => sum + w, 0);
+		const safe = total > 0 ? total : node.children.length || 1;
+		let offset = 0;
+		node.children.forEach((child, i) => {
+			const frac = (node.sizes[i] ?? safe / node.children.length) / safe;
+			if (node.direction === `row`) {
+				const w = rect.w * frac;
+				visit(child, [...path, i], {
+					x: rect.x + offset,
+					y: rect.y,
+					w,
+					h: rect.h
+				});
+				offset += w;
+			} else {
+				const h = rect.h * frac;
+				visit(child, [...path, i], {
+					x: rect.x,
+					y: rect.y + offset,
+					w: rect.w,
+					h
+				});
+				offset += h;
+			}
+		});
+	};
+	visit(root, [], {
+		x: 0,
+		y: 0,
+		w: 1,
+		h: 1
+	});
+	return out;
+}
+function intervalOverlap(a0, a1, b0, b1) {
+	return Math.min(a1, b1) - Math.max(a0, b0);
+}
+/**
+* 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.
+*/
+function getLeafNeighbours(root, ref) {
+	const path = resolveLeafPath(root, ref);
+	if (path === null) return null;
+	const geoms = computeLeafGeoms(root);
+	const self = geoms.find((g) => pathsEqual(g.path, path));
+	if (!self) return null;
+	const s = self.rect;
+	const above = [];
+	const below = [];
+	const left = [];
+	const right = [];
+	geoms.forEach((g, order) => {
+		if (g === self) return;
+		const r = g.rect;
+		const info = {
+			name: g.name,
+			path: [...g.path]
+		};
+		if (Math.abs(r.y + r.h - s.y) < GEOM_EPS) {
+			const o = intervalOverlap(r.x, r.x + r.w, s.x, s.x + s.w);
+			if (o > GEOM_EPS) above.push({
+				info,
+				overlap: o,
+				order
+			});
+		}
+		if (Math.abs(s.y + s.h - r.y) < GEOM_EPS) {
+			const o = intervalOverlap(r.x, r.x + r.w, s.x, s.x + s.w);
+			if (o > GEOM_EPS) below.push({
+				info,
+				overlap: o,
+				order
+			});
+		}
+		if (Math.abs(r.x + r.w - s.x) < GEOM_EPS) {
+			const o = intervalOverlap(r.y, r.y + r.h, s.y, s.y + s.h);
+			if (o > GEOM_EPS) left.push({
+				info,
+				overlap: o,
+				order
+			});
+		}
+		if (Math.abs(s.x + s.w - r.x) < GEOM_EPS) {
+			const o = intervalOverlap(r.y, r.y + r.h, s.y, s.y + s.h);
+			if (o > GEOM_EPS) right.push({
+				info,
+				overlap: o,
+				order
+			});
+		}
+	});
+	const rank = (hits) => hits.sort((a, b) => b.overlap - a.overlap || a.order - b.order).map((h) => h.info);
+	return {
+		above: rank(above),
+		below: rank(below),
+		left: rank(left),
+		right: rank(right)
+	};
+}
+/**
+* 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.
+*/
+function swapLeaves(root, pathA, pathB) {
+	if (pathsEqual(pathA, pathB)) return false;
+	const nodeA = findNode(root, pathA);
+	const nodeB = findNode(root, pathB);
+	if (nodeA === null || nodeB === null || !isStack(nodeA) || !isStack(nodeB)) return false;
+	const parentA = findParentOf(root, pathA);
+	const parentB = findParentOf(root, pathB);
+	if (parentA === null || parentB === null) return false;
+	const indexA = pathA[pathA.length - 1];
+	const indexB = pathB[pathB.length - 1];
+	if (parentA === parentB) {
+		const p = parentA;
+		[p.children[indexA], p.children[indexB]] = [p.children[indexB], p.children[indexA]];
+		[p.sizes[indexA], p.sizes[indexB]] = [p.sizes[indexB] ?? 1, p.sizes[indexA] ?? 1];
+		return true;
+	}
+	const carriedNode = parentA.children[indexA];
+	const carriedSize = parentA.sizes[indexA] ?? 1;
+	parentA.children[indexA] = parentB.children[indexB];
+	parentA.sizes[indexA] = parentB.sizes[indexB] ?? 1;
+	parentB.children[indexB] = carriedNode;
+	parentB.sizes[indexB] = carriedSize;
+	return true;
+}
+/**
+* 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.
+*/
+function moveLeafStep(root, ref, direction) {
+	const path = resolveLeafPath(root, ref);
+	if (path === null) return false;
+	const neighbours = getLeafNeighbours(root, ref);
+	if (neighbours === null) return false;
+	const list = direction === `up` ? neighbours.above : direction === `down` ? neighbours.below : direction === `left` ? neighbours.left : neighbours.right;
+	if (list.length === 0) return false;
+	return swapLeaves(root, path, list[0].path);
+}
+/**
+* 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).
+*/
+function moveLeafNodeToEdge(root, ref, edge) {
+	const path = resolveLeafPath(root, ref);
+	if (path === null || path.length === 0) return false;
+	const self = computeLeafGeoms(root).find((g) => pathsEqual(g.path, path));
+	if (!self) return false;
+	const horizontal = edge === `left` || edge === `right`;
+	const frac = Math.min(Math.max(horizontal ? self.rect.w : self.rect.h, .05), .95);
+	if (!(frac > 0) || frac >= 1) return false;
+	const parent = findParentOf(root, path);
+	if (parent === null) return false;
+	const [node] = parent.children.splice(path[path.length - 1], 1);
+	parent.sizes.splice(path[path.length - 1], 1);
+	if (!node) return false;
+	normalize(root);
+	const atStart = edge === `left` || edge === `top`;
+	const direction = horizontal ? `row` : `column`;
+	if (isStack(root)) {
+		const rest = root;
+		const remaining = {
+			kind: `stack`,
+			panels: [...rest.panels],
+			active: rest.active
+		};
+		if (rest.name !== void 0) remaining.name = rest.name;
+		if (rest.collapsed !== void 0) remaining.collapsed = rest.collapsed;
+		if (rest.preCollapseSize !== void 0) remaining.preCollapseSize = rest.preCollapseSize;
+		replaceNodeContents(root, {
+			kind: `split`,
+			direction,
+			children: atStart ? [node, remaining] : [remaining, node],
+			sizes: atStart ? [frac, 1 - frac] : [1 - frac, frac]
+		});
+		return true;
+	}
+	if (isSplit(root) && root.direction === direction) {
+		const size = frac * (root.sizes.reduce((total, w) => total + w, 0) || root.children.length || 1) / (1 - frac);
+		const at = atStart ? 0 : root.children.length;
+		root.children.splice(at, 0, node);
+		root.sizes.splice(at, 0, size);
+		return true;
+	}
+	if (isSplit(root)) {
+		const inner = {
+			kind: `split`,
+			direction: root.direction,
+			children: root.children,
+			sizes: root.sizes
+		};
+		replaceNodeContents(root, {
+			kind: `split`,
+			direction,
+			children: atStart ? [node, inner] : [inner, node],
+			sizes: atStart ? [frac, 1 - frac] : [1 - frac, frac]
+		});
+		return true;
+	}
+	return false;
+}
 function serializeLayout(root) {
 	return {
 		version: 1,
@@ -2929,6 +3229,8 @@ function serializeNode(node) {
 			panels: [...node.panels],
 			active: node.active
 		};
+		if (node.name !== void 0) out.name = node.name;
+		if (node.hideLabels !== void 0) out.hideLabels = node.hideLabels;
 		if (node.collapsed !== void 0) out.collapsed = node.collapsed;
 		if (node.preCollapseSize !== void 0) out.preCollapseSize = node.preCollapseSize;
 		return out;
@@ -2971,9 +3273,13 @@ let TabListItemElement = class TabListItemElement extends LitElement {
 		this.registry = void 0;
 		this._compact = false;
 		this._hasToolbarContent = false;
+		this._labelObserver = null;
 		this._onToolbarSlotChange = () => {
 			this._updateToolbarContent();
 		};
+		this._onLabelSlotChange = () => {
+			this._syncLabelSizer();
+		};
 	}
 	connectedCallback() {
 		super.connectedCallback();
@@ -2982,6 +3288,13 @@ let TabListItemElement = class TabListItemElement extends LitElement {
 		});
 		this._resizeObserver.observe(this);
 		(this.shadowRoot?.querySelector(`slot[name="toolbar"]`))?.addEventListener(`slotchange`, this._onToolbarSlotChange);
+		(this.shadowRoot?.querySelector(`slot:not([name])`))?.addEventListener(`slotchange`, this._onLabelSlotChange);
+		this._labelObserver = new MutationObserver(() => this._syncLabelSizer());
+		this._labelObserver.observe(this, {
+			childList: true,
+			characterData: true,
+			subtree: true
+		});
 	}
 	disconnectedCallback() {
 		super.disconnectedCallback();
@@ -2989,7 +3302,10 @@ let TabListItemElement = class TabListItemElement extends LitElement {
 		this._resizeObserver = void 0;
 		this._commandCleanup?.();
 		this._commandCleanup = void 0;
+		this._labelObserver?.disconnect();
+		this._labelObserver = null;
 		(this.shadowRoot?.querySelector(`slot[name="toolbar"]`))?.removeEventListener(`slotchange`, this._onToolbarSlotChange);
+		(this.shadowRoot?.querySelector(`slot:not([name])`))?.removeEventListener(`slotchange`, this._onLabelSlotChange);
 	}
 	updated(changed) {
 		super.updated(changed);
@@ -3012,12 +3328,25 @@ let TabListItemElement = class TabListItemElement extends LitElement {
 			if (id === this.commandActive) this.click();
 		});
 	}
+	/**
+	* Mirror the default-slot text into `.label[data-label]` for the `::after`
+	* width sizer. Slotted toolbar content is excluded.
+	*/
+	_syncLabelSizer() {
+		const slot = this.shadowRoot?.querySelector(`slot:not([name])`);
+		const label = this.shadowRoot?.querySelector(`.label`);
+		if (slot === null || slot === void 0 || label === null || label === void 0) return;
+		const text = slot.assignedNodes().filter((node) => !(node instanceof HTMLElement && node.hasAttribute(`slot`))).map((node) => node.textContent ?? ``).join(``);
+		if (text) label.setAttribute(`data-label`, text);
+		else label.removeAttribute(`data-label`);
+	}
 	_updateToolbarContent() {
 		const slot = this.shadowRoot?.querySelector(`slot[name="toolbar"]`);
 		this._hasToolbarContent = (slot?.assignedElements().length ?? 0) > 0;
 	}
 	firstUpdated() {
 		this._updateToolbarContent();
+		this._syncLabelSizer();
 	}
 	render() {
 		const showLabel = !this.hideLabels || !this.iconName;
@@ -3059,15 +3388,21 @@ let TabListItemElement = class TabListItemElement extends LitElement {
 			css`
       :host {
         --selected-tab-color: var(--ixfx-selected-tab-color, var(--surface-2-text));
+        --selected-tab-icon-color: var(--ixfx-selected-tab-icon-color, var(--accent));
         --selected-tab-border-width: var(--ixfx-selected-tab-border-width, 1px);
         --selected-tab-weight: var(--ixfx-selected-tab-weight, bold);
+        --selected-tab-text-decoration: var(--ixfx-selected-tab-text-decoration, none);
+        --selected-tab-text-decoration-color: var(--ixfx-selected-tab-text-decoration-color, var(--accent));
+        --selected-tab-text-decoration-thickness: var(--ixfx-selected-tab-text-decoration-thickness, 0px);
+        --selected-tab-text-decoration-offset: var(--ixfx-selected-tab-text-decoration-offset, 2px);
         --selected-background: var(--ixfx-tab-selected-background, var(--surface-5));
         --tab-padding: var(--ixfx-tab-padding, var(--space-s));
         display: inline-flex;
         min-width: 0;
         user-select: none;
         box-sizing: border-box;
-        font-size: var(--text-xs);
+        font-size: var(--text-m);
+        color: inherit;
         /* No explicit height: items stretch (align-self: stretch via the
            list's flex container) so every tab in a strip shares one height
            even when toolbars give some items taller content. */
@@ -3082,7 +3417,18 @@ let TabListItemElement = class TabListItemElement extends LitElement {
         font-weight: 500;
         border: var(--selected-tab-border-width) solid transparent;
         gap: var(--space-s);
+        transition: background var(--transition, 0.15s);
+      }
+
+      /* Hover ("tickle") background. When --ixfx-tab-hover-background is
+         unset each state keeps its resting background, so existing
+         consumers see no change. */
+      :host(:hover:not([selected])) > div {
+        background: var(--ixfx-tab-hover-background, transparent);
+      }
 
+      :host([selected]:hover) > div {
+        background: var(--ixfx-tab-hover-background, var(--selected-background));
       }
 
       :host([selected]) > div {
@@ -3096,6 +3442,13 @@ let TabListItemElement = class TabListItemElement extends LitElement {
         border-radius:var(--radius-m);
       }
 
+      :host([selected]) .label {
+        text-decoration: var(--selected-tab-text-decoration);
+        text-decoration-color: var(--selected-tab-text-decoration-color);
+        text-decoration-thickness: var(--selected-tab-text-decoration-thickness);
+        text-decoration-offset: var(--selected-tab-text-decoration-offset);
+      }
+
       .label {
         overflow: var(--allow-overflow, hidden);
         text-overflow: ellipsis;
@@ -3104,10 +3457,29 @@ let TabListItemElement = class TabListItemElement extends LitElement {
         flex: 1 1 auto;
       }
 
+      /* Width sizer: an invisible copy of the label, always set at the
+         selected weight, so activating a tab (bold) never shifts the strip.
+         Text is mirrored from the default slot via the data-label attribute
+         (see _syncLabelSizer). */
+      .label::after {
+        content: attr(data-label);
+        display: block;
+        height: 0;
+        overflow: hidden;
+        visibility: hidden;
+        font-weight: var(--selected-tab-weight);
+      }
+
       ixfx-icon {
         flex-shrink: 0;
       }
 
+      /* Leading icon (direct child — not close/toolbar icons) picks up the
+         accent when selected, so icon-only tabs read as active. */
+      :host([selected]) > div > ixfx-icon {
+        color: var(--selected-tab-icon-color);
+      }
+
       .actions {
         display: flex;
         align-items: center;
@@ -3203,6 +3575,7 @@ let DockPanelElement = class DockPanelElement extends LitElement {
 		this.iconName = ``;
 		this.closable = false;
 		this.collapsible = false;
+		this.kind = `any`;
 		this.accepts = ``;
 		this.presentation = `solo`;
 		this._collapsed = false;
@@ -3256,6 +3629,10 @@ let DockPanelElement = class DockPanelElement extends LitElement {
 	}
 	connectedCallback() {
 		super.connectedCallback();
+		if (this.hasAttribute(`title`)) {
+			if (!this.hasAttribute(`label`)) this.title = this.getAttribute(`title`) ?? ``;
+			this.removeAttribute(`title`);
+		}
 		this.addEventListener(`pointerdown`, this._onPointerDown);
 	}
 	disconnectedCallback() {
@@ -3347,13 +3724,20 @@ __decorate([property({
 	attribute: `panel-id`,
 	reflect: true
 })], DockPanelElement.prototype, "panelId", void 0);
-__decorate([property({ type: String })], DockPanelElement.prototype, "title", void 0);
+__decorate([property({
+	type: String,
+	attribute: `label`
+})], DockPanelElement.prototype, "title", void 0);
 __decorate([property({
 	type: String,
 	attribute: `icon-name`
 })], DockPanelElement.prototype, "iconName", void 0);
 __decorate([property({ type: Boolean })], DockPanelElement.prototype, "closable", void 0);
 __decorate([property({ type: Boolean })], DockPanelElement.prototype, "collapsible", void 0);
+__decorate([property({
+	type: String,
+	reflect: true
+})], DockPanelElement.prototype, "kind", void 0);
 __decorate([property({
 	type: String,
 	attribute: `accepts`
@@ -3385,13 +3769,16 @@ let DockHostElement = class DockHostElement extends LitElement {
 		this._dragActive = false;
 		this._junctions = [];
 		this._toolbarsOut = /* @__PURE__ */ new Map();
+		this._leafContentRules = /* @__PURE__ */ new Map();
 		this._tabDragPending = null;
 		this._junctionsKey = ``;
 		this._junctionsRaf = null;
 		this._hostResizeObserver = null;
+		this._toolbarSlots = /* @__PURE__ */ new Set();
+		this._toolbarObserver = null;
 		this._onDragStart = (event) => {
 			const { panelId, pointerId, clientX, clientY } = event.detail;
-			startDrag(panelId, this, pointerId, clientX, clientY);
+			startDrag(panelId, this, pointerId, clientX, clientY, this._findPanelEl(panelId)?.kind);
 		};
 		this._onPoolSlotChange = () => {
 			this._syncPool();
@@ -3438,11 +3825,12 @@ let DockHostElement = class DockHostElement extends LitElement {
 			const pathStr = this.shadowRoot?.getElementById(detail.id)?.getAttribute(`data-dock-path`);
 			if (pathStr === null || pathStr === void 0) return;
 			const path = parsePath(pathStr);
-			const paths = collectStackPaths(this._model).filter((p) => p.join(`-`) !== path.join(`-`));
-			const fallbackNode = paths.length > 0 ? findNode(this._model, paths[0]) : null;
-			const fallback = fallbackNode !== null && isStack(fallbackNode) ? fallbackNode : void 0;
+			const closing = findNode(this._model, path);
+			if (closing === null || !isStack(closing)) return;
+			const moving = [...closing.panels];
 			this._returnAllToolbars();
-			extractStack(this._model, path, fallback);
+			extractStack(this._model, path);
+			for (const panelId of moving) addPanelToStack(this._firstStackAllowing(this._panelKind(panelId)), panelId);
 			this._commit();
 		};
 		this._onTabChange = (event, path) => {
@@ -3507,11 +3895,21 @@ let DockHostElement = class DockHostElement extends LitElement {
 		this.addEventListener(`dock-panel-drag-start`, this._onDragStart);
 		this._hostResizeObserver = new ResizeObserver(() => this._scheduleJunctions());
 		this._hostResizeObserver.observe(this);
+		this._scanToolbarSlots();
+		this._toolbarObserver = new MutationObserver(() => this._scanToolbarSlots());
+		this._toolbarObserver.observe(this, {
+			childList: true,
+			subtree: true,
+			attributes: true,
+			attributeFilter: [`slot`]
+		});
 	}
 	disconnectedCallback() {
 		super.disconnectedCallback();
 		unregisterDockHost(this);
 		this.removeEventListener(`dock-panel-drag-start`, this._onDragStart);
+		this._toolbarObserver?.disconnect();
+		this._toolbarObserver = null;
 		this._hostResizeObserver?.disconnect();
 		this._hostResizeObserver = null;
 		if (this._junctionsRaf !== null) {
@@ -3564,6 +3962,19 @@ let DockHostElement = class DockHostElement extends LitElement {
 	_scanPanels() {
 		return Array.from(this.children).filter((el) => el instanceof HTMLElement && el.tagName === `IXFX-DOCK-PANEL` && Boolean(el.panelId));
 	}
+	/** Refresh the set of provided `toolbar-<name>` slots; re-render on change. */
+	_scanToolbarSlots() {
+		const found = /* @__PURE__ */ new Set();
+		for (const child of this.children) {
+			if (!(child instanceof HTMLElement)) continue;
+			const slot = child.getAttribute(`slot`) ?? ``;
+			if (slot.startsWith(`toolbar-`) && slot.length > `toolbar-`.length) found.add(slot);
+		}
+		if (found.size !== this._toolbarSlots.size || [...found].some((s) => !this._toolbarSlots.has(s))) {
+			this._toolbarSlots = found;
+			this.requestUpdate();
+		}
+	}
 	_findPanelEl(panelId) {
 		return this._pool.find((p) => p.panelId === panelId) ?? this._scanPanels().find((p) => p.panelId === panelId);
 	}
@@ -3577,7 +3988,33 @@ let DockHostElement = class DockHostElement extends LitElement {
 		return fresh;
 	}
 	_appendPanelToFirstStack(panelId) {
-		addPanelToStack(this._model.kind === `stack` ? this._model : this._firstStack(), panelId);
+		const kind = this._panelKind(panelId);
+		if (this._model.kind === `stack` && this._stackAllowsKind(this._model, kind)) {
+			addPanelToStack(this._model, panelId);
+			return;
+		}
+		addPanelToStack(this._firstStackAllowing(kind), panelId);
+	}
+	/** Normalized content kind of a panel (`'any'` when unknown/unset). */
+	_panelKind(panelId) {
+		return normalizeKind(this._findPanelEl(panelId)?.kind);
+	}
+	/** Whether `kind` may live in `stack` under the current leaf rules. */
+	_stackAllowsKind(stack, kind) {
+		if (stack.name === void 0) return true;
+		const rules = this._leafContentRules.get(stack.name);
+		if (rules === void 0) return true;
+		if (rules.deny.has(kind)) return false;
+		return rules.allow === null || rules.allow.has(kind);
+	}
+	/** First stack (tree order) whose rules admit `kind`, else the first stack. */
+	_firstStackAllowing(kind) {
+		for (const path of collectStackPaths(this._model)) {
+			const node = findNode(this._model, path);
+			if (node !== null && isStack(node) && this._stackAllowsKind(node, kind)) return node;
+		}
+		console.warn(`[ixfx-dock-host] no leaf admits kind "${kind}", using first stack`);
+		return this._firstStack();
 	}
 	_syncPool() {
 		const current = this._scanPanels();
@@ -3619,7 +4056,34 @@ let DockHostElement = class DockHostElement extends LitElement {
 		this.requestUpdate();
 		this._emitChange();
 	}
+	/**
+	* Dock a panel. Returns false (without touching the DOM) when the
+	* explicitly targeted container denies the panel's `kind`.
+	*/
 	addPanel(panel, target) {
+		const kind = panel instanceof HTMLElement ? normalizeKind(panel.kind) : normalizeKind(panel.kind);
+		const op = target?.op ?? `tabs`;
+		let stackPath = null;
+		let splitTarget = null;
+		if (target?.container !== void 0) {
+			const namedPath = findStackPathByName(this._model, target.container);
+			if (namedPath === null) console.warn(`[ixfx-dock-host] addPanel: unknown container "${target.container}", appending to first admitting stack`);
+			else if (op === `tabs` && !this._stackAllowsKindAt(namedPath, kind)) {
+				console.warn(`[ixfx-dock-host] addPanel: container "${target.container}" does not admit kind "${kind}"`);
+				return false;
+			} else stackPath = namedPath;
+		} else if (target?.stack) {
+			const found = findStackOf(this._model, target.stack);
+			if (found === null) console.warn(`[ixfx-dock-host] addPanel: unknown stack panel "${target.stack}", appending to first admitting stack`);
+			else if (op === `tabs` && !this._stackAllowsKindAt(found, kind)) {
+				console.warn(`[ixfx-dock-host] addPanel: target stack does not admit kind "${kind}"`);
+				return false;
+			} else stackPath = found;
+		}
+		if (stackPath !== null && op !== `tabs`) {
+			splitTarget = stackPath;
+			stackPath = null;
+		}
 		let el;
 		if (panel instanceof HTMLElement) el = panel;
 		else {
@@ -3629,19 +4093,16 @@ let DockHostElement = class DockHostElement extends LitElement {
 			if (panel.iconName !== void 0) el.iconName = panel.iconName;
 			if (panel.closable !== void 0) el.closable = panel.closable;
 			if (panel.collapsible !== void 0) el.collapsible = panel.collapsible;
+			if (panel.kind !== void 0) el.kind = panel.kind;
 		}
 		if (el.parentElement !== this) this.appendChild(el);
 		if (!this._pool.some((p) => p.panelId === el.panelId)) this._pool = [...this._pool, el];
 		this._returnAllToolbars();
-		const op = target?.op ?? `tabs`;
-		if (target?.stack) {
-			const stackPath = findStackOf(this._model, target.stack);
-			if (stackPath !== null) {
-				if (op === `tabs`) {
-					const stack = findNode(this._model, stackPath);
-					if (stack !== null && isStack(stack)) addPanelToStack(stack, el.panelId, target.index);
-				} else insertBeside(this._model, stackPath, opToDirection(op), createStack([el.panelId]), `after`);
-			}
+		if (collectPanelIds(this._model).includes(el.panelId)) this._removeFromModel(el.panelId);
+		if (splitTarget !== null) insertBeside(this._model, splitTarget, opToDirection(op), createStack([el.panelId]), `after`);
+		else if (stackPath !== null) {
+			const stack = findNode(this._model, stackPath);
+			if (stack !== null && isStack(stack)) addPanelToStack(stack, el.panelId, target?.index);
 		} else this._appendPanelToFirstStack(el.panelId);
 		normalize(this._model);
 		this.requestUpdate();
@@ -3651,6 +4112,12 @@ let DockHostElement = class DockHostElement extends LitElement {
 			composed: true
 		}));
 		this._emitChange();
+		return true;
+	}
+	/** Whether the stack at `stackPath` admits `kind` under the leaf rules. */
+	_stackAllowsKindAt(stackPath, kind) {
+		const stack = findNode(this._model, stackPath);
+		return stack !== null && isStack(stack) && this._stackAllowsKind(stack, kind);
 	}
 	removePanel(panelId) {
 		if (!collectPanelIds(this._model).includes(panelId)) return false;
@@ -3686,6 +4153,123 @@ let DockHostElement = class DockHostElement extends LitElement {
 	getPanelIds() {
 		return collectPanelIds(this._model);
 	}
+	/** Names of every named stack leaf, in tree order. */
+	getContainerNames() {
+		return collectContainerNames(this._model);
+	}
+	/**
+	* Snapshot of a named container (`{ name, panels, active }`), or null when
+	* no stack carries that name. First match wins when duplicated.
+	*/
+	getContainer(name) {
+		const path = findStackPathByName(this._model, name);
+		if (path === null) return null;
+		const node = findNode(this._model, path);
+		if (node === null || !isStack(node) || node.name === void 0) return null;
+		return {
+			name: node.name,
+			panels: [...node.panels],
+			active: node.active
+		};
+	}
+	/** Panel-ids in a named container, in tab order (`[]` when unknown/empty). */
+	getContainerPanels(name) {
+		return this.getContainer(name)?.panels ?? [];
+	}
+	/** Panel elements in a named container, in tab order — for iterating children. */
+	getContainerElements(name) {
+		return this.getContainerPanels(name).map((id) => this._findPanelEl(id)).filter((el) => el !== void 0);
+	}
+	/**
+	* 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, kinds) {
+		const key = name.trim();
+		if (!key) {
+			console.warn(`[ixfx-dock-host] setLeafExclusiveContents: empty container name`);
+			return;
+		}
+		const allow = new Set(kinds.map((k) => k.trim()).filter((k) => k.length > 0));
+		const entry = this._leafContentRules.get(key) ?? {
+			allow: null,
+			deny: /* @__PURE__ */ new Set()
+		};
+		entry.allow = allow;
+		this._leafContentRules.set(key, entry);
+		if (findStackPathByName(this._model, key) === null) console.warn(`[ixfx-dock-host] setLeafExclusiveContents: no container named "${key}" yet; rule stored`);
+	}
+	/**
+	* 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, kinds) {
+		const key = name.trim();
+		if (!key) {
+			console.warn(`[ixfx-dock-host] setLeafDenyContents: empty container name`);
+			return;
+		}
+		const deny = new Set(kinds.map((k) => k.trim()).filter((k) => k.length > 0));
+		const entry = this._leafContentRules.get(key) ?? {
+			allow: null,
+			deny: /* @__PURE__ */ new Set()
+		};
+		entry.deny = deny;
+		if (entry.allow === null && entry.deny.size === 0) this._leafContentRules.delete(key);
+		else this._leafContentRules.set(key, entry);
+		if (findStackPathByName(this._model, key) === null) console.warn(`[ixfx-dock-host] setLeafDenyContents: no container named "${key}" yet; rule stored`);
+	}
+	/** Remove every content rule for a named container. */
+	clearLeafContentRestrictions(name) {
+		this._leafContentRules.delete(name.trim());
+	}
+	/** Copy of a container's rules, or null when unrestricted. */
+	getLeafContentRestrictions(name) {
+		const rules = this._leafContentRules.get(name.trim());
+		if (rules === void 0) return null;
+		return {
+			allow: rules.allow === null ? null : [...rules.allow],
+			deny: [...rules.deny]
+		};
+	}
+	/**
+	* 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) {
+		return getLeafNeighbours(this._model, leaf);
+	}
+	/**
+	* 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, direction) {
+		if (!moveLeafStep(this._model, leaf, direction)) return false;
+		this._commit();
+		return true;
+	}
+	/**
+	* 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, edge) {
+		if (!moveLeafNodeToEdge(this._model, leaf, edge)) return false;
+		this._commit();
+		return true;
+	}
 	/**
 	* Capture a structured-clone-safe {@link DockPanelSnapshot} of a panel
 	* (identity, chrome attributes, and a best-effort `innerHTML`). Returns
@@ -3700,6 +4284,7 @@ let DockHostElement = class DockHostElement extends LitElement {
 			iconName: el.iconName,
 			closable: el.closable,
 			collapsible: el.collapsible,
+			kind: normalizeKind(el.kind),
 			accepts: el.accepts,
 			contentHTML: el.innerHTML
 		};
@@ -3723,10 +4308,11 @@ let DockHostElement = class DockHostElement extends LitElement {
 	* `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__"`).
+	* panel (defaults to `"__external__"`). `kind` covers leaf content rules
+	* for panels unknown to this host (defaults to `'any'`).
 	*/
-	queryDropTarget(clientX, clientY, panelId = `__external__`) {
-		const zone = this.computeDropZone(clientX, clientY, panelId);
+	queryDropTarget(clientX, clientY, panelId = `__external__`, kind) {
+		const zone = this.computeDropZone(clientX, clientY, panelId, kind);
 		return zone === null ? null : zoneToTarget(zone);
 	}
 	/**
@@ -3735,9 +4321,9 @@ let DockHostElement = class DockHostElement extends LitElement {
 	* one. Call on every pointer update from the outer coordinator, then
 	* {@link endExternalDrop} when the drag leaves or ends.
 	*/
-	previewExternalDrop(clientX, clientY, panelId = `__external__`) {
+	previewExternalDrop(clientX, clientY, panelId = `__external__`, kind) {
 		this.setDragActive(true);
-		const zone = this.computeDropZone(clientX, clientY, panelId);
+		const zone = this.computeDropZone(clientX, clientY, panelId, kind);
 		this.setDropZone(zone);
 		return zone === null ? null : zoneToTarget(zone);
 	}
@@ -3750,8 +4336,9 @@ let DockHostElement = class DockHostElement extends LitElement {
 	* 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`); without them, or when the point misses the host, it goes
-	* into the first stack. Returns the created element, or null when a panel
+	* `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, at) {
@@ -3762,6 +4349,7 @@ let DockHostElement = class DockHostElement extends LitElement {
 		if (snapshot.iconName !== void 0) el.iconName = snapshot.iconName;
 		if (snapshot.closable !== void 0) el.closable = snapshot.closable;
 		if (snapshot.collapsible !== void 0) el.collapsible = snapshot.collapsible;
+		if (`kind` in snapshot && snapshot.kind !== void 0) el.kind = snapshot.kind;
 		if (`accepts` in snapshot && snapshot.accepts) el.setAttribute(`accepts`, snapshot.accepts);
 		if (`contentHTML` in snapshot && snapshot.contentHTML) el.innerHTML = snapshot.contentHTML;
 		this._returnAllToolbars();
@@ -3787,9 +4375,10 @@ let DockHostElement = class DockHostElement extends LitElement {
 	* 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, clientY, panelId) {
+	computeDropZone(clientX, clientY, panelId, kind) {
 		const hostRect = this.getBoundingClientRect();
 		if (clientX < hostRect.left || clientX > hostRect.right || clientY < hostRect.top || clientY > hostRect.bottom) return null;
+		const resolvedKind = kind?.trim() ? kind.trim() : this._panelKind(panelId);
 		const rel = (r) => ({
 			x: r.left - hostRect.left,
 			y: r.top - hostRect.top,
@@ -3817,7 +4406,7 @@ let DockHostElement = class DockHostElement extends LitElement {
 						rect: rel(leafRect),
 						caretRect: this._stripCaretRect(strip, gapIndex, hostRect)
 					};
-					return this._zoneAllowed(panelId, zone) ? zone : null;
+					return this._zoneAllowed(panelId, zone, resolvedKind) ? zone : null;
 				}
 			}
 			const relX = (clientX - leafRect.left) / Math.max(leafRect.width, 1);
@@ -3831,7 +4420,7 @@ let DockHostElement = class DockHostElement extends LitElement {
 					gapIndex: stack.panels.length,
 					rect: rel(leafRect)
 				};
-				return this._zoneAllowed(panelId, zone) ? zone : null;
+				return this._zoneAllowed(panelId, zone, resolvedKind) ? zone : null;
 			}
 			const r = rel(leafRect);
 			let operation;
@@ -3877,7 +4466,7 @@ let DockHostElement = class DockHostElement extends LitElement {
 				side,
 				rect: zoneRect
 			};
-			return this._zoneAllowed(panelId, zone) ? zone : null;
+			return this._zoneAllowed(panelId, zone, resolvedKind) ? zone : null;
 		}
 		const fromLeft = clientX - hostRect.left;
 		const fromRight = hostRect.right - clientX;
@@ -3933,15 +4522,18 @@ let DockHostElement = class DockHostElement extends LitElement {
 			side,
 			rect: zoneRect
 		};
-		return this._zoneAllowed(panelId, zone) ? zone : null;
+		return this._zoneAllowed(panelId, zone, resolvedKind) ? zone : null;
 	}
-	_zoneAllowed(panelId, zone) {
+	_zoneAllowed(panelId, zone, kind) {
 		if (!tokenAllows(this.accepts, operationToToken(zone.operation))) return false;
 		const stack = findNode(this._model, zone.targetPath);
 		if (stack !== null && isStack(stack) && stack.panels.length === 1) {
 			const target = this._findPanelEl(stack.panels[0]);
 			if (target && !panelAllows(target.accepts, operationToToken(zone.operation))) return false;
 		}
+		if (zone.operation === `tabs` && stack !== null && isStack(stack)) {
+			if (!this._stackAllowsKind(stack, kind?.trim() ? kind.trim() : this._panelKind(panelId))) return false;
+		}
 		if (this.canAccept && !this.canAccept(panelId, zone.operation)) return false;
 		return true;
 	}
@@ -3956,22 +4548,32 @@ let DockHostElement = class DockHostElement extends LitElement {
 			this._appendPanelToFirstStack(panelId);
 			normalize(this._model);
 		}
-		this._applyZone(panelId, zone);
+		this._applyZone(panelId, zone, sourceHost === void 0 || sourceHost === this);
 		this._commit();
 	}
 	/**
 	* Move `panelId` (already present somewhere in the model) to the position
 	* described by `zone`. Shared by in-page drops and external panel adoption.
 	*/
-	_applyZone(panelId, zone) {
+	_applyZone(panelId, zone, transferName = false) {
 		const sourcePath = findStackOf(this._model, panelId);
+		let vacated = null;
 		if (sourcePath !== null) {
 			const source = findNode(this._model, sourcePath);
-			if (source !== null && isStack(source)) removePanelFromStack(source, panelId);
+			if (source !== null && isStack(source)) {
+				removePanelFromStack(source, panelId);
+				if (source.panels.length === 0) vacated = source;
+			}
 		}
 		if (zone.operation === `tabs`) {
 			const target = findNode(this._model, zone.targetPath);
-			if (target !== null && isStack(target)) addPanelToStack(target, panelId, zone.gapIndex);
+			if (target !== null && isStack(target)) {
+				addPanelToStack(target, panelId, zone.gapIndex);
+				if (transferName && vacated !== null && vacated !== target && vacated.name !== void 0 && target.name === void 0) {
+					target.name = vacated.name;
+					delete vacated.name;
+				}
+			}
 		} else insertBeside(this._model, zone.targetPath, opToDirection(zone.operation), createStack([panelId]), zone.side);
 	}
 	/**
@@ -4107,16 +4709,6 @@ let DockHostElement = class DockHostElement extends LitElement {
 		};
 		window.addEventListener(`click`, swallow, true);
 	}
-	_splitStack(path, op) {
-		const stack = findNode(this._model, path);
-		if (stack === null || !isStack(stack) || stack.panels.length === 0) return;
-		const activeId = stack.active;
-		this._returnAllToolbars();
-		removePanelFromStack(stack, activeId);
-		normalize(this._model);
-		insertBeside(this._model, path, opToDirection(op), createStack([activeId]), `after`);
-		this._commit();
-	}
 	_removeFromModel(panelId) {
 		const stackPath = findStackOf(this._model, panelId);
 		if (stackPath === null) return;
@@ -4247,6 +4839,7 @@ let DockHostElement = class DockHostElement extends LitElement {
         id=${`dock-leaf-${pathStr}`}
         class="leaf"
         data-dock-path=${pathStr}
+        data-dock-name=${stack.name ?? nothing}
         size=${size === void 0 ? nothing : String(size)}
         min=${collapsible ? `1px` : nothing}
         when-small=${collapsible ? `collapse` : nothing}
@@ -4258,26 +4851,19 @@ let DockHostElement = class DockHostElement extends LitElement {
           <slot name="empty"><span>Drop panels here</span></slot>
         </div>
       `);
+		const toolbarSlot = stack.name !== void 0 && this._toolbarSlots.has(`toolbar-${stack.name}`) ? html`<slot name="toolbar-${stack.name}" slot="toolbar"></slot>` : nothing;
 		return leafAttrs(html`
       <ixfx-tab-list
         class="strip"
         orientation="horizontal"
+        scrollable
+        shrink
+        ?hide-labels=${stack.hideLabels === true}
         @change=${(e) => this._onTabChange(e, path)}
         @pointerdown=${this._onStripPointerDown}
       >
         ${repeat(stack.panels, (id) => id, (id) => this._renderTabItem(stack, id))}
-        <div slot="toolbar" class="group-toolbar">
-          <button
-            class="chrome-btn"
-            title="Split horizontally (top/bottom)"
-            @click=${() => this._splitStack(path, `split-horizontal`)}
-          >↕</button>
-          <button
-            class="chrome-btn"
-            title="Split vertically (left/right)"
-            @click=${() => this._splitStack(path, `split-vertical`)}
-          >↔</button>
-        </div>
+        ${toolbarSlot}
       </ixfx-tab-list>
       <div class="leaf-body">
         <slot name="dock-panel-${stack.active}"></slot>
@@ -4357,9 +4943,14 @@ let DockHostElement = class DockHostElement extends LitElement {
       .strip {
         flex-shrink: 0;
         border: 0;
-        /* The leaf background shows through selected tabs; the accent
-           underline indicator carries the selection. */
+        /* The leaf background shows through selected tabs; a text underline
+           (not the border indicator) carries the selection. */
         --ixfx-tab-selected-background: transparent;
+        --ixfx-selected-tab-border-width: 0;
+        --ixfx-selected-tab-text-decoration: underline;
+        --ixfx-selected-tab-text-decoration-thickness: 2px;
+        --ixfx-selected-tab-text-decoration-offset: 4px;
+        --ixfx-tab-hover-background: var(--surface-4);
       }
 
       /* Uniform tab height: a panel toolbar button would otherwise inflate
@@ -4368,6 +4959,11 @@ let DockHostElement = class DockHostElement extends LitElement {
         height: var(--dock-tab-height, 30px);
       }
 
+      /* Breathing room between strip toolbars and the leaf edge. */
+      .strip::part(list-toolbar) {
+        padding-right: var(--space-xs);
+      }
+
       .leaf-body {
         flex: 1;
         min-height: 0;
@@ -4389,38 +4985,6 @@ let DockHostElement = class DockHostElement extends LitElement {
         margin: var(--space-s);
       }
 
-      .group-toolbar {
-        display: flex;
-        gap: 2px;
-        padding: 0 var(--space-xs);
-      }
-
-      .chrome-btn {
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        width: 1.6em;
-        height: 1.6em;
-        padding: 0;
-        background: none;
-        border: none;
-        border-radius: var(--radius-s);
-        color: inherit;
-        cursor: pointer;
-        opacity: var(--prominence-idle-opacity);
-        transition: background var(--transition), opacity var(--transition);
-      }
-
-      .chrome-btn:hover {
-        background: var(--surface-5);
-        opacity: var(--prominence-tickled-opacity);
-      }
-
-      .chrome-btn:focus-visible {
-        outline: 2px solid var(--accent);
-        outline-offset: 1px;
-      }
-
       .overlay {
         position: absolute;
         inset: 0;
@@ -4537,6 +5101,10 @@ function zoneToTarget(zone) {
 function cloneNode(node) {
 	return JSON.parse(JSON.stringify(node));
 }
+/** Panel content kind, normalized (`'any'` when unset/blank). */
+function normalizeKind(kind) {
+	return (kind?.trim() ?? ``) || `any`;
+}
 function parsePath(pathStr) {
 	return pathStr.length === 0 ? [] : pathStr.split(`-`).filter((s) => s.length > 0).map(Number);
 }
@@ -7900,6 +8468,6 @@ function init() {
 	console.log(`Init`);
 }
 //#endregion
-export { AcTextElement, AcTokenElement, ButtonElement, Checkbox, ColourPicker, ColourPickerPopup, CrumbNavigationElement, CrumbPathController, CrumbPathElement, DataController, DataDisplayComponent, DataGridElement, DetailListElement, DockHostElement, DockPanelElement, EditableLabel, EditableNumber, FormElement, FormGroupElement, FormPartElement, GroupedItemListerElement, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, IxfxHexEditorElement, IxfxIconElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LedElement, menu_exports as Menu, MillerBaseElement, MillerListElement, MillerTreeController, NarrowedTextElement, NotificationManager, NotificationPillElement, PanelElement, PanelGroupElement, PlotDataSeries, PlotHistogram, PlotMultiAxis, PlotSingleAxis, PlotXyAxis, PolarPad, RadialInputElement, RadioGroup, RangeElement, RangeInput, RangeMultiElement, RatingElement, SelectHorizElement, SliderInputElement, SlidingNumberElement, SnackbarElement, SnapContainer, SplitButton, SplitLayoutElement, SplitPanelElement, SwipeElement, TabController, TabListElement, TabListItemElement, TabPanelElement, TabPanelsElement, TextShimmerElement, TimelineController, TimelineTrackTabElement, TitlebarElement, ToolbarElement, ToolbarGroupElement, TooltipElement, TransitoryLabelElement, TreeBaseElement, TreeController, TreeDataModel, TreeListElement, TwoSplitLayoutElement, VerticalListElement, XyPad, addPanelToStack, applyAgeModification, applyHighlights, applySnapshot, attachTimelineInteractions, buildHighlightTargets, buildModel, clearHighlights, collectDataResult, collectPanelIds, collectStackPaths, computeColour, createAcCompletionProvider, createElementIncrSearch, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createSplit, createStack, createTreeListAdapter, createVerticalListAdapter, distribute, extractStack, findNode, findParentOf, findStackOf, getActiveDragPanelId, getIcon, hasIcon, iconBus, init, insertBeside, isDragging, isSplit, isStack, monitorIndeterminate, normalise, normalize, parseColourScaleAttr, parseLayout, pointerOverAnyHost, readBaseColour, registerIcon, removePanelFromStack, resolveCssVars, resolveGrid, resolveTracks, serializeLayout, setActive, svgToDataUri, timelineStyles, toSnapshot, walk, wrapRoot };
+export { AcTextElement, AcTokenElement, ButtonElement, Checkbox, ColourPicker, ColourPickerPopup, CrumbNavigationElement, CrumbPathController, CrumbPathElement, DataController, DataDisplayComponent, DataGridElement, DetailListElement, DockHostElement, DockPanelElement, EditableLabel, EditableNumber, FormElement, FormGroupElement, FormPartElement, GroupedItemListerElement, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, IxfxHexEditorElement, IxfxIconElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LedElement, menu_exports as Menu, MillerBaseElement, MillerListElement, MillerTreeController, NarrowedTextElement, NotificationManager, NotificationPillElement, PanelElement, PanelGroupElement, PlotDataSeries, PlotHistogram, PlotMultiAxis, PlotSingleAxis, PlotXyAxis, PolarPad, RadialInputElement, RadioGroup, RangeElement, RangeInput, RangeMultiElement, RatingElement, SelectHorizElement, SliderInputElement, SlidingNumberElement, SnackbarElement, SnapContainer, SplitButton, SplitLayoutElement, SplitPanelElement, SwipeElement, TabController, TabListElement, TabListItemElement, TabPanelElement, TabPanelsElement, TextShimmerElement, TimelineController, TimelineTrackTabElement, TitlebarElement, ToolbarElement, ToolbarGroupElement, TooltipElement, TransitoryLabelElement, TreeBaseElement, TreeController, TreeDataModel, TreeListElement, TwoSplitLayoutElement, VerticalListElement, XyPad, 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.js.map