@dashfoo/core 0.5.2 → 1.1.0

package/dist/index.js

@@ -1,7 +1,21 @@
 import { z } from "zod";
 import { assign, emit, setup } from "xstate";
 
+//#region src/lib/clamp-selected.ts
+/** In `lib/` because both the parse boundary and `normalize` need it, and
+* importing it from either would close a module cycle. */
+const clampSelected = (length, selected) => {
+	if (length === 0) return 0;
+	const base = Number.isFinite(selected) ? Math.trunc(selected) : 0;
+	if (base < 0) return 0;
+	if (base > length - 1) return length - 1;
+	return base;
+};
+
+//#endregion
 //#region src/model/schema.ts
+/** Weights are relative shares of a row, not percentages. */
+const DEFAULT_WEIGHT = 1;
 const jsonValueSchema = z.lazy(() => z.union([
 	z.string(),
 	z.number(),
@@ -44,7 +58,11 @@ const tabNodeSchema = z.object({
 	name: z.string(),
 	type: z.literal("tab")
 });
-const tabsetNodeSchema = z.object({
+/**
+* Kept pre-transform so `node-attrs` can `.pick()` from it: a pipe has no
+* `.pick`, and `.partial()` over a defaulted field still fills the default in.
+*/
+const tabsetNodeObjectSchema = z.object({
 	children: z.array(tabNodeSchema),
 	enableClose: z.boolean().optional(),
 	enableMaximize: z.boolean().optional(),
@@ -54,18 +72,25 @@ const tabsetNodeSchema = z.object({
 	name: z.string().optional(),
 	selected: z.number().int(),
 	type: z.literal("tabset"),
-	weight: z.number().optional()
+	weight: z.number().default(1)
 });
-const rowNodeSchema = z.lazy(() => z.object({
-	children: z.array(z.union([rowNodeSchema, tabsetNodeSchema])),
+const tabsetNodeSchema = tabsetNodeObjectSchema.transform((tabset) => ({
+	...tabset,
+	selected: clampSelected(tabset.children.length, tabset.selected)
+}));
+/** The getter's explicit return type is required: without it, TS7023. */
+const rowNodeSchema = z.object({
+	get children() {
+		return z.array(z.union([rowNodeSchema, tabsetNodeSchema]));
+	},
 	id: z.string(),
 	max: dimensionSchema.optional(),
 	min: dimensionSchema.optional(),
 	orientation: orientationSchema,
 	snap: snapSchema.optional(),
 	type: z.literal("row"),
-	weight: z.number().optional()
-}));
+	weight: z.number().default(1)
+});
 const geometrySchema = z.object({
 	height: z.number(),
 	left: z.number(),
@@ -95,7 +120,7 @@ const globalAttributesSchema = z.object({
 });
 const dashfooSchema = z.object({
 	activeTabsetId: z.string().optional(),
-	floats: z.array(floatNodeSchema).optional(),
+	floats: z.array(floatNodeSchema).default(() => []),
 	global: globalAttributesSchema,
 	layout: rowNodeSchema,
 	maximizedTabsetId: z.string().optional(),
@@ -103,7 +128,7 @@ const dashfooSchema = z.object({
 });
 
 //#endregion
-//#region src/state/actions.ts
+//#region src/state/node-attrs.ts
 const mutableTabAttrsSchema = tabNodeSchema.pick({
 	config: true,
 	enableClose: true,
@@ -111,14 +136,14 @@ const mutableTabAttrsSchema = tabNodeSchema.pick({
 	enableRename: true,
 	name: true
 }).partial();
-const mutableTabsetAttrsSchema = tabsetNodeSchema.pick({
+/** `weight` is re-declared, not picked: `.partial()` over a defaulted field still injects the default. */
+const mutableTabsetAttrsSchema = tabsetNodeObjectSchema.pick({
 	enableClose: true,
 	enableMaximize: true,
 	max: true,
 	min: true,
-	selected: true,
-	weight: true
-}).partial();
+	selected: true
+}).extend({ weight: z.number() }).partial();
 const mutableRowAttrsSchema = z.object({
 	max: dimensionSchema.optional(),
 	min: dimensionSchema.optional(),
@@ -126,11 +151,14 @@ const mutableRowAttrsSchema = z.object({
 	snap: snapSchema.optional(),
 	weight: z.number()
 }).partial();
-const mutableNodeAttrsSchema = z.union([
-	mutableTabAttrsSchema,
-	mutableTabsetAttrsSchema,
-	mutableRowAttrsSchema
-]);
+/**
+* Merged, not a union: a union of all-optional members matches its first member
+* and strips the rest. The reducer enforces which keys a given node accepts.
+*/
+const mutableNodeAttrsSchema = mutableTabAttrsSchema.extend(mutableTabsetAttrsSchema.shape).extend(mutableRowAttrsSchema.shape);
+
+//#endregion
+//#region src/state/actions.ts
 const dockLocationSchema = z.enum([
 	"center",
 	"split-bottom",
@@ -155,7 +183,6 @@ const actionSchema = z.discriminatedUnion("type", [
 		type: z.literal("moveNode")
 	}),
 	z.object({
-		index: z.number().int().optional(),
 		location: dockLocationSchema,
 		sourceId: z.string(),
 		targetId: z.string(),
@@ -243,19 +270,12 @@ const createTabId = () => createNodeId("tab");
 
 //#endregion
 //#region src/model/tree.ts
-const collectRoots = (model) => [model.layout, ...(model.floats ?? []).map((float) => float.layout)];
-const findFloat = (model, floatId) => (model.floats ?? []).find((float) => float.id === floatId);
+const collectRoots = (model) => [model.layout, ...model.floats.map((float) => float.layout)];
+const findFloat = (model, floatId) => model.floats.find((float) => float.id === floatId);
 /**
-* Depth-first pre-order over one root: the row itself, then each child in
-* order, descending into nested rows and into a tabset's tabs. Returning a
-* defined value from `visit` stops the walk and becomes the result, so one
-* traversal serves both find-first and collect-all.
-*
-* Every query below used to carry its own copy of this recursion, and they had
-* drifted in child order: some scanned a row's own tabsets before descending,
-* others interleaved. With unique ids all orders agree, so they now share this
-* one; a model with duplicate ids (which the builder and the parser both warn
-* about) can see a different duplicate win than it did before.
+* Depth-first pre-order; a defined `visit` result stops the walk. With unique
+* ids the order is immaterial, but a duplicate-id model (which the builder and
+* the parser both warn about) resolves to whichever copy this reaches first.
 */
 const walk = (row, visit, parent, index = -1) => {
 	const atRoot = visit({
@@ -286,7 +306,20 @@ const walk = (row, visit, parent, index = -1) => {
 		}
 	}
 };
-const locate = (row, id) => walk(row, (found) => found.node.id === id ? found : void 0);
+const isRow = (node) => node.type === "row";
+const isTab = (node) => node.type === "tab";
+const isTabset = (node) => node.type === "tabset";
+/** Predicate-first, so an id shared across node kinds resolves the same way here as anywhere else. */
+const locate = (model, id, is) => {
+	for (const root of collectRoots(model)) {
+		const found = walk(root, ({ index, node, parent }) => node.id === id && is(node) ? {
+			index,
+			node,
+			parent
+		} : void 0);
+		if (found) return found;
+	}
+};
 const collectTabsetsInRow = (row, acc) => {
 	walk(row, ({ node }) => {
 		if (node.type === "tabset") acc.push(node);
@@ -298,41 +331,28 @@ const collectTabsets = (model) => {
 	return acc;
 };
 const getFirstTabset = (model) => collectTabsets(model)[0];
-const findTabset = (model, tabsetId) => collectTabsets(model).find((tabset) => tabset.id === tabsetId);
-const findTabInContainer = (container, tabId) => {
-	const index = container.children.findIndex((tab) => tab.id === tabId);
-	if (index === -1) return;
-	const tab = container.children.at(index);
-	if (!tab) return;
-	return {
-		container,
-		index,
-		tab
-	};
-};
+const findTabset = (model, tabsetId) => locate(model, tabsetId, isTabset)?.node;
 const findTab = (model, tabId) => {
-	for (const tabset of collectTabsets(model)) {
-		const found = findTabInContainer(tabset, tabId);
-		if (found) return found;
-	}
-};
-const findRow = (row, id) => {
-	const found = locate(row, id)?.node;
-	return found?.type === "row" ? found : void 0;
+	const found = locate(model, tabId, isTab);
+	return found?.parent?.type === "tabset" ? {
+		container: found.parent,
+		index: found.index,
+		tab: found.node
+	} : void 0;
 };
-const findAttributedNodeInRow = (row, id) => locate(row, id)?.node;
+const findRow = (model, id) => locate(model, id, isRow)?.node;
 const findAttributedNode = (model, id) => {
 	for (const root of collectRoots(model)) {
-		const found = findAttributedNodeInRow(root, id);
+		const found = walk(root, ({ node }) => node.id === id ? node : void 0);
 		if (found) return found;
 	}
 };
 const findRootContaining = (model, nodeId) => {
-	for (const root of collectRoots(model)) if (findAttributedNodeInRow(root, nodeId)) return root;
+	for (const root of collectRoots(model)) if (walk(root, ({ node }) => node.id === nodeId ? true : void 0)) return root;
 };
-const findTabsetParent = (row, tabsetId) => {
-	const found = locate(row, tabsetId);
-	return found?.node.type === "tabset" && found.parent?.type === "row" ? {
+const findTabsetParent = (model, tabsetId) => {
+	const found = locate(model, tabsetId, isTabset);
+	return found?.parent?.type === "row" ? {
 		index: found.index,
 		parent: found.parent
 	} : void 0;
@@ -344,7 +364,7 @@ const collectIdsInRow = (row, acc) => {
 };
 const findDuplicateIds = (model) => {
 	const ids = [];
-	for (const float of model.floats ?? []) ids.push(float.id);
+	for (const float of model.floats) ids.push(float.id);
 	for (const root of collectRoots(model)) collectIdsInRow(root, ids);
 	const seen = /* @__PURE__ */ new Set();
 	const duplicates = /* @__PURE__ */ new Set();
@@ -377,7 +397,8 @@ const tabset = (children, options = {}) => {
 		...max === void 0 ? {} : { max: toDimension(max) },
 		...min === void 0 ? {} : { min: toDimension(min) },
 		id: options.id ?? createNodeId("tabset"),
-		selected: options.selected ?? 0
+		selected: clampSelected(children.length, options.selected ?? 0),
+		weight: options.weight ?? 1
 	};
 };
 const row = (children, options = {}) => {
@@ -389,7 +410,8 @@ const row = (children, options = {}) => {
 		...max === void 0 ? {} : { max: toDimension(max) },
 		...min === void 0 ? {} : { min: toDimension(min) },
 		id: options.id ?? createNodeId("row"),
-		orientation: options.orientation ?? "row"
+		orientation: options.orientation ?? "row",
+		weight: options.weight ?? 1
 	};
 };
 const floatNode = (layout, geometry, options = {}) => ({
@@ -404,6 +426,7 @@ const model = (layout, options = {}) => {
 		layout,
 		version: 1,
 		...options,
+		floats: options.floats ?? [],
 		global: options.global ?? {}
 	};
 	const duplicates = findDuplicateIds(built);
@@ -411,6 +434,12 @@ const model = (layout, options = {}) => {
 	return built;
 };
 
+//#endregion
+//#region src/lib/assert-never.ts
+const assertNever = (value) => {
+	throw new Error(`Unhandled variant: ${JSON.stringify(value)}`);
+};
+
 //#endregion
 //#region src/geometry/geometry.ts
 const DEFAULT_BAND_FRACTION = .22;
@@ -431,15 +460,22 @@ const closestEdge = (d) => {
 	if (min === d.top) return "top";
 	return "bottom";
 };
+const splitEdge = (location) => {
+	switch (location) {
+		case "center": return;
+		case "split-bottom": return "bottom";
+		case "split-left": return "left";
+		case "split-right": return "right";
+		case "split-top": return "top";
+		default: return assertNever(location);
+	}
+};
 const resolveDockTarget = (pointer, rect, opts) => {
 	const band = opts?.bandFraction ?? DEFAULT_BAND_FRACTION;
-	if (rect.width <= 0 || rect.height <= 0) return { kind: "tab" };
+	if (rect.width <= 0 || rect.height <= 0) return "center";
 	const distances = edgeDistances(pointer, rect);
-	if (Math.min(distances.left, distances.right, distances.top, distances.bottom) > band) return { kind: "tab" };
-	return {
-		edge: closestEdge(distances),
-		kind: "split"
-	};
+	if (Math.min(distances.left, distances.right, distances.top, distances.bottom) > band) return "center";
+	return `split-${closestEdge(distances)}`;
 };
 const dockZonePolygons = (rect, opts) => {
 	const { height: h, width: w, x, y } = rect;
@@ -564,7 +600,7 @@ const zoneRect = (rect, location) => {
 			y: rect.y
 		};
 		case "center": return rect;
-		default: return rect;
+		default: return assertNever(location);
 	}
 };
 
@@ -588,21 +624,20 @@ const resolveSnapTargets = (config, panelCount) => {
 	}
 	return [...targets].toSorted((a, b) => a - b);
 };
-const snapEnabled = (config) => config !== null && ((config.step ?? 0) > 0 || config.divisions === "panels" || typeof config.divisions === "number" && config.divisions >= 2);
+const resolveSnapGrid = (config, panelCount) => ({
+	targets: config === null ? [] : resolveSnapTargets(config, panelCount),
+	threshold: config?.threshold ?? 4
+});
+const snapEnabled = (grid) => grid.targets.length > 0;
 const nearestTarget = (position, targets) => targets.reduce((best, target) => {
 	if (best === void 0 || Math.abs(target - position) < Math.abs(best - position)) return target;
 	return best;
 }, void 0);
-const snapSizes = (sizes, boundaryIndex, config) => {
-	const threshold = config.threshold ?? 4;
+const snapSizes = (sizes, boundaryIndex, grid) => {
+	const { targets, threshold } = grid;
 	const left = sizes[boundaryIndex];
 	const right = sizes[boundaryIndex + 1];
-	if (boundaryIndex < 0 || left === void 0 || right === void 0) return {
-		sizes,
-		snapped: false
-	};
-	const targets = resolveSnapTargets(config, sizes.length);
-	if (targets.length === 0) return {
+	if (boundaryIndex < 0 || left === void 0 || right === void 0 || targets.length === 0) return {
 		sizes,
 		snapped: false
 	};
@@ -626,32 +661,30 @@ const snapSizes = (sizes, boundaryIndex, config) => {
 		snapped: true
 	};
 };
+const decideSnap = (sizes, boundaryIndex, grid) => {
+	if (boundaryIndex === null || !snapEnabled(grid)) return { kind: "inactive" };
+	const { sizes: snappedSizes, snapped } = snapSizes(sizes, boundaryIndex, grid);
+	return snapped ? {
+		kind: "engage",
+		sizes: snappedSizes
+	} : { kind: "clear" };
+};
+const settleSnap = (sizes, boundaryIndex, grid) => {
+	const decision = decideSnap(sizes, boundaryIndex, grid);
+	return decision.kind === "engage" ? decision.sizes : sizes;
+};
 
 //#endregion
 //#region src/model/invariants.ts
-const clampSelected = (length, selected) => {
-	if (length === 0) return 0;
-	const base = Number.isFinite(selected) ? Math.trunc(selected) : 0;
-	if (base < 0) return 0;
-	if (base > length - 1) return length - 1;
-	return base;
-};
-const normalizeTabset = (tabset) => ({
-	...tabset,
-	selected: clampSelected(tabset.children.length, tabset.selected)
-});
 /**
-* A row that collapses to a single child hands its slot in the parent to
-* that child, so the slot's sizing constraints have to travel with it.
-* Dropping them silently widens a pinned sidebar, and `normalize` runs on
-* load and on every persist, so the loss is permanent.
-*
-* `snap` only exists on rows, so it is carried only to a row survivor.
+* The survivor takes over the collapsed row's slot, so it has to take the slot's
+* sizing too: dropping it widens a pinned sidebar, permanently, since this runs
+* on every persist. `snap` is row-only, so it travels only to a row survivor.
 */
 const inheritSlot = (row, survivor) => {
 	const sized = {
 		...survivor,
-		...row.weight === void 0 ? {} : { weight: row.weight },
+		weight: row.weight,
 		...row.min === void 0 ? {} : { min: row.min },
 		...row.max === void 0 ? {} : { max: row.max }
 	};
@@ -661,14 +694,18 @@ const inheritSlot = (row, survivor) => {
 	};
 	return sized;
 };
-const normalizeRowChildren = (children) => {
+/** Records the id of every tabset it keeps, in document order. */
+const normalizeRowChildren = (children, keptTabsetIds) => {
 	const out = [];
 	for (const child of children) {
 		if (child.type === "tabset") {
-			if (child.children.length > 0) out.push(normalizeTabset(child));
+			if (child.children.length > 0) {
+				out.push(child);
+				keptTabsetIds.push(child.id);
+			}
 			continue;
 		}
-		const grandchildren = normalizeRowChildren(child.children);
+		const grandchildren = normalizeRowChildren(child.children, keptTabsetIds);
 		if (grandchildren.length === 0) continue;
 		if (grandchildren.length === 1) {
 			const only = grandchildren[0];
@@ -682,9 +719,8 @@ const normalizeRowChildren = (children) => {
 	}
 	return out;
 };
-const rowContainsTabset = (row) => row.children.some((child) => child.type === "tabset" ? true : rowContainsTabset(child));
-const normalizeLayout = (root) => {
-	let children = normalizeRowChildren(root.children);
+const normalizeLayout = (root, keptTabsetIds) => {
+	let children = normalizeRowChildren(root.children, keptTabsetIds);
 	let orientation = root.orientation;
 	let inner = children[0];
 	while (children.length === 1 && inner?.type === "row") {
@@ -699,87 +735,111 @@ const normalizeLayout = (root) => {
 	};
 };
 const normalize = (model) => {
-	const layout = normalizeLayout(model.layout);
-	const healedFloats = [];
-	for (const float of model.floats ?? []) {
-		const floatLayout = normalizeLayout(float.layout);
-		if (rowContainsTabset(floatLayout)) healedFloats.push({
-			...float,
-			layout: floatLayout
-		});
+	const mainTabsetIds = [];
+	const layout = normalizeLayout(model.layout, mainTabsetIds);
+	const floats = [];
+	const floatTabsetIds = [];
+	for (const float of model.floats) {
+		const ownTabsetIds = [];
+		const floatLayout = normalizeLayout(float.layout, ownTabsetIds);
+		if (floatLayout.children.length > 0) {
+			floats.push({
+				...float,
+				layout: floatLayout
+			});
+			floatTabsetIds.push(...ownTabsetIds);
+		}
 	}
-	const floats = healedFloats.length > 0 ? healedFloats : void 0;
-	const withRoots = {
-		...model,
-		floats,
-		layout
-	};
-	const tabsetIds = new Set(collectTabsets(withRoots).map((tabset) => tabset.id));
-	const firstTabsetId = collectTabsets(withRoots)[0]?.id;
-	const activeTabsetId = model.activeTabsetId !== void 0 && tabsetIds.has(model.activeTabsetId) ? model.activeTabsetId : firstTabsetId;
-	const maximizedTabsetId = model.maximizedTabsetId !== void 0 && tabsetIds.has(model.maximizedTabsetId) ? model.maximizedTabsetId : void 0;
+	const mainIds = new Set(mainTabsetIds);
+	const liveIds = /* @__PURE__ */ new Set([...mainTabsetIds, ...floatTabsetIds]);
+	const firstTabsetId = mainTabsetIds[0] ?? floatTabsetIds[0];
+	const activeTabsetId = model.activeTabsetId !== void 0 && liveIds.has(model.activeTabsetId) ? model.activeTabsetId : firstTabsetId;
+	const maximizedTabsetId = model.maximizedTabsetId !== void 0 && mainIds.has(model.maximizedTabsetId) ? model.maximizedTabsetId : void 0;
 	return {
-		...withRoots,
+		...model,
 		activeTabsetId,
+		floats,
+		layout,
 		maximizedTabsetId
 	};
 };
 
 //#endregion
 //#region src/state/surgery.ts
-const removeTabsetReturning = (row, tabsetId) => {
-	const found = findTabsetParent(row, tabsetId);
+const removeTabsetReturning = (model, tabsetId) => {
+	const found = findTabsetParent(model, tabsetId);
 	if (!found) return;
 	const [removed] = found.parent.children.splice(found.index, 1);
 	return removed?.type === "tabset" ? removed : void 0;
 };
-const removeTabset = (row, tabsetId) => removeTabsetReturning(row, tabsetId) !== void 0;
-const splitOrientation = (location) => location === "split-left" || location === "split-right" ? "row" : "column";
-const splitsBefore = (location) => location === "split-left" || location === "split-top";
+/** Total, so a sixth `DockLocation` is a compile error here rather than a wrong default. */
+const SPLIT_PLACEMENT = {
+	"split-bottom": {
+		before: false,
+		orientation: "column"
+	},
+	"split-left": {
+		before: true,
+		orientation: "row"
+	},
+	"split-right": {
+		before: false,
+		orientation: "row"
+	},
+	"split-top": {
+		before: true,
+		orientation: "column"
+	}
+};
 const placeBesideTarget = (draft, placed, targetId, location) => {
 	const targetTabset = findTabset(draft, targetId);
-	const found = findTabsetParent(findRootContaining(draft, targetId) ?? draft.layout, targetId);
-	if (!targetTabset || !found) return;
-	const orientation = splitOrientation(location);
-	const before = splitsBefore(location);
+	const found = findTabsetParent(draft, targetId);
+	if (!targetTabset || !found) return false;
+	const { before, orientation } = SPLIT_PLACEMENT[location];
 	if (found.parent.orientation === orientation) {
-		const targetWeight = targetTabset.weight ?? 100;
-		targetTabset.weight = targetWeight / 2;
-		placed.weight = targetWeight / 2;
+		const half = targetTabset.weight / 2;
+		targetTabset.weight = half;
+		placed.weight = half;
 		found.parent.children.splice(before ? found.index : found.index + 1, 0, placed);
 	} else {
-		const targetWeight = targetTabset.weight;
-		targetTabset.weight = 50;
-		placed.weight = 50;
 		const newRow = {
 			children: before ? [placed, targetTabset] : [targetTabset, placed],
 			id: createNodeId("row"),
 			orientation,
-			type: "row"
+			type: "row",
+			weight: targetTabset.weight
 		};
-		if (targetWeight !== void 0) newRow.weight = targetWeight;
+		targetTabset.weight = 50;
+		placed.weight = 50;
 		found.parent.children.splice(found.index, 1, newRow);
 	}
 	draft.activeTabsetId = placed.id;
+	return true;
 };
 const insertTab = (draft, tab, target) => {
 	const { id: targetId, index, location } = target;
 	const targetTabset = findTabset(draft, targetId);
-	if (!targetTabset) return;
+	if (!targetTabset) return false;
 	if (location === "center") {
-		const at = index ?? targetTabset.children.length;
+		const at = Math.min(Math.max(index ?? targetTabset.children.length, 0), targetTabset.children.length);
 		targetTabset.children.splice(at, 0, tab);
 		targetTabset.selected = at;
-		return;
+		return true;
 	}
 	const newTabset = {
 		children: [tab],
 		id: createNodeId("tabset"),
 		selected: 0,
 		type: "tabset",
-		weight: 50
+		weight: 1
 	};
-	placeBesideTarget(draft, newTabset, targetId, location);
+	return placeBesideTarget(draft, newTabset, targetId, location);
+};
+/** Re-clamps here rather than leaving the whole tree to be re-walked afterwards. */
+const detachTab = (container, index) => {
+	const removed = container.children.splice(index, 1).at(0);
+	container.selected = clampSelected(container.children.length, container.selected);
+	return removed;
 };
 const mergeTabsInto = (target, tabs, selectedOffset) => {
 	const mergeStart = target.children.length;
@@ -791,17 +851,20 @@ const wrapTabInLayout = (tab) => ({
 		children: [tab],
 		id: createNodeId("tabset"),
 		selected: 0,
-		type: "tabset"
+		type: "tabset",
+		weight: 1
 	}],
 	id: createNodeId("row"),
 	orientation: "row",
-	type: "row"
+	type: "row",
+	weight: 1
 });
 const wrapTabsetInLayout = (tabset) => ({
 	children: [tabset],
 	id: createNodeId("row"),
 	orientation: "row",
-	type: "row"
+	type: "row",
+	weight: 1
 });
 
 //#endregion
@@ -824,20 +887,20 @@ const pushFloat = (draft, layout, geometry, floatId) => {
 		geometry: geometry ?? DEFAULT_FLOAT_GEOMETRY,
 		id: floatId ?? createNodeId("float"),
 		layout,
-		name: uniqueFloatName("Panel", draft.floats ?? []),
+		name: uniqueFloatName("Panel", draft.floats),
 		type: "float"
 	};
-	draft.floats = [...draft.floats ?? [], float];
+	draft.floats = [...draft.floats, float];
 	const tabsets = [];
 	collectTabsetsInRow(layout, tabsets);
 	const first = tabsets.at(0);
 	if (first) draft.activeTabsetId = first.id;
 };
 const floatTabsetById = (draft, tabsetId, geometry, floatId) => {
-	const root = findRootContaining(draft, tabsetId);
-	if (!root) return;
-	const detached = removeTabsetReturning(root, tabsetId);
-	if (detached) pushFloat(draft, wrapTabsetInLayout(detached), geometry, floatId);
+	const detached = removeTabsetReturning(draft, tabsetId);
+	if (!detached) return false;
+	pushFloat(draft, wrapTabsetInLayout(detached), geometry, floatId);
+	return true;
 };
 const resolveMainTarget = (draft, targetId) => {
 	const mainTabsets = [];
@@ -853,168 +916,185 @@ const resolveMainTarget = (draft, targetId) => {
 	return mainTabsets[0];
 };
 const dockFloat = (draft, floatId, targetId, location) => {
-	const floats = draft.floats ?? [];
-	const index = floats.findIndex((float) => float.id === floatId);
-	if (index === -1) return;
-	const float = floats.splice(index, 1).at(0);
-	draft.floats = floats;
-	if (!float) return;
+	const index = draft.floats.findIndex((float) => float.id === floatId);
+	const float = draft.floats.at(index);
+	if (index === -1 || !float) return false;
 	const tabsets = [];
 	collectTabsetsInRow(float.layout, tabsets);
 	const tabs = tabsets.flatMap((tabset) => tabset.children);
-	if (tabs.length === 0) return;
+	if (tabs.length === 0) return false;
 	const leadTabset = tabsets.at(0);
 	const selectedOffset = leadTabset ? clampSelected(leadTabset.children.length, leadTabset.selected) : 0;
 	const target = resolveMainTarget(draft, targetId);
+	draft.floats.splice(index, 1);
 	if (!target) {
 		draft.layout = float.layout;
 		draft.activeTabsetId = leadTabset?.id;
-		return;
+		return true;
 	}
 	if (location === "center") {
 		mergeTabsInto(target, tabs, selectedOffset);
 		draft.activeTabsetId = target.id;
-		return;
+		return true;
 	}
-	const where = location ?? "split-right";
 	const placed = tabsets.length === 1 && leadTabset ? leadTabset : {
 		children: tabs,
 		id: createNodeId("tabset"),
 		selected: selectedOffset,
-		type: "tabset"
+		type: "tabset",
+		weight: 1
 	};
-	placed.weight = 50;
-	placeBesideTarget(draft, placed, target.id, where);
+	return placeBesideTarget(draft, placed, target.id, location ?? "split-right");
 };
 
 //#endregion
 //#region src/state/reducer.ts
-const assertNever = (value) => {
-	throw new Error(`Unhandled action: ${JSON.stringify(value)}`);
+const parseNodeAttrs = (node, attrs) => {
+	switch (node.type) {
+		case "row": return mutableRowAttrsSchema.parse(attrs);
+		case "tab": return mutableTabAttrsSchema.parse(attrs);
+		case "tabset": {
+			const parsed = mutableTabsetAttrsSchema.parse(attrs);
+			return parsed.selected === void 0 ? parsed : {
+				...parsed,
+				selected: clampSelected(node.children.length, parsed.selected)
+			};
+		}
+		default: return assertNever(node);
+	}
 };
+const sameGeometry = (a, b) => a.height === b.height && a.left === b.left && a.top === b.top && a.width === b.width;
+const alreadyApplied = (target, attrs) => {
+	const current = new Map(Object.entries(target));
+	return Object.entries(attrs).every(([key, value]) => Object.is(current.get(key), value));
+};
+/** Reports whether it changed anything, so `history.dispatch` can skip a no-op. */
 const applyAction = (draft, action) => {
 	switch (action.type) {
-		case "addNode":
-			insertTab(draft, action.tab, {
-				id: action.targetId,
-				index: action.index,
-				location: action.location
-			});
-			return;
+		case "addNode": return insertTab(draft, action.tab, {
+			id: action.targetId,
+			index: action.index,
+			location: action.location
+		});
 		case "adjustSplit": {
-			const row = findRow(findRootContaining(draft, action.rowId) ?? draft.layout, action.rowId);
-			if (!row) return;
+			const row = findRow(draft, action.rowId);
+			if (!row) return false;
+			let changed = false;
 			for (let index = 0; index < action.weights.length; index++) {
 				const child = row.children.at(index);
 				const weight = action.weights[index];
-				if (!child || weight === void 0) continue;
+				if (!child || weight === void 0 || child.weight === weight) continue;
 				child.weight = weight;
+				changed = true;
 			}
-			return;
+			return changed;
 		}
 		case "deleteTab": {
 			const location = findTab(draft, action.tabId);
-			if (location) location.container.children.splice(location.index, 1);
-			return;
-		}
-		case "deleteTabset": {
-			const root = findRootContaining(draft, action.tabsetId);
-			if (root) removeTabset(root, action.tabsetId);
-			return;
+			if (!location) return false;
+			detachTab(location.container, location.index);
+			return true;
 		}
-		case "dockFloat":
-			dockFloat(draft, action.floatId, action.targetId, action.location);
-			return;
+		case "deleteTabset": return removeTabsetReturning(draft, action.tabsetId) !== void 0;
+		case "dockFloat": return dockFloat(draft, action.floatId, action.targetId, action.location);
 		case "floatTab": {
 			const location = findTab(draft, action.tabId);
-			if (!location) return;
-			const removed = location.container.children.splice(location.index, 1).at(0);
-			if (removed) pushFloat(draft, wrapTabInLayout(removed), action.geometry, action.floatId);
-			return;
+			if (!location) return false;
+			const removed = detachTab(location.container, location.index);
+			if (!removed) return false;
+			pushFloat(draft, wrapTabInLayout(removed), action.geometry, action.floatId);
+			return true;
 		}
-		case "floatTabset":
-			floatTabsetById(draft, action.tabsetId, action.geometry, action.floatId);
-			return;
+		case "floatTabset": return floatTabsetById(draft, action.tabsetId, action.geometry, action.floatId);
 		case "moveFloat": {
 			const float = findFloat(draft, action.floatId);
-			if (float) float.geometry = action.geometry;
-			return;
+			if (!float || sameGeometry(float.geometry, action.geometry)) return false;
+			float.geometry = action.geometry;
+			return true;
 		}
 		case "moveNode": {
 			const source = findTab(draft, action.sourceId);
-			if (!source) return;
-			const removed = source.container.children.splice(source.index, 1).at(0);
-			if (!removed) return;
-			insertTab(draft, removed, {
+			if (!source || !findTabset(draft, action.targetId)) return false;
+			const removed = detachTab(source.container, source.index);
+			if (!removed) return false;
+			return insertTab(draft, removed, {
 				id: action.targetId,
 				index: action.index,
 				location: action.location
 			});
-			return;
 		}
 		case "moveTabset": {
-			if (action.sourceId === action.targetId) return;
+			if (action.sourceId === action.targetId) return false;
 			const source = findTabset(draft, action.sourceId);
-			if (!source) return;
+			const target = findTabset(draft, action.targetId);
+			if (!source || !target) return false;
 			if (action.location === "center") {
-				const target = findTabset(draft, action.targetId);
-				if (target) {
-					mergeTabsInto(target, source.children, clampSelected(source.children.length, source.selected));
-					const sourceRoot = findRootContaining(draft, action.sourceId);
-					if (sourceRoot) removeTabset(sourceRoot, action.sourceId);
-				}
-				return;
+				mergeTabsInto(target, source.children, clampSelected(source.children.length, source.selected));
+				removeTabsetReturning(draft, action.sourceId);
+				return true;
 			}
-			if (action.location.startsWith("split-")) {
-				const sourceRoot = findRootContaining(draft, action.sourceId);
-				const detached = sourceRoot ? removeTabsetReturning(sourceRoot, action.sourceId) : void 0;
-				if (detached) placeBesideTarget(draft, detached, action.targetId, action.location);
-			}
-			return;
+			const detached = removeTabsetReturning(draft, action.sourceId);
+			return detached ? placeBesideTarget(draft, detached, action.targetId, action.location) : false;
 		}
 		case "renameFloat": {
 			const float = findFloat(draft, action.floatId);
-			if (float) {
-				const others = (draft.floats ?? []).filter((other) => other.id !== action.floatId);
-				float.name = uniqueFloatName(action.name, others);
-			}
-			return;
+			if (!float) return false;
+			const others = draft.floats.filter((other) => other.id !== action.floatId);
+			const name = uniqueFloatName(action.name, others);
+			if (float.name === name) return false;
+			float.name = name;
+			return true;
 		}
 		case "renameTab": {
 			const location = findTab(draft, action.tabId);
-			if (location) location.tab.name = action.name;
-			return;
+			if (!location || location.tab.name === action.name) return false;
+			location.tab.name = action.name;
+			return true;
 		}
 		case "selectTab": {
 			const tabset = findTabset(draft, action.tabsetId);
-			if (tabset) tabset.selected = action.index;
-			return;
+			if (!tabset) return false;
+			const selected = clampSelected(tabset.children.length, action.index);
+			if (tabset.selected === selected) return false;
+			tabset.selected = selected;
+			return true;
 		}
 		case "setActiveTabset":
-			if (findTabset(draft, action.tabsetId)) draft.activeTabsetId = action.tabsetId;
-			return;
+			if (draft.activeTabsetId === action.tabsetId || !findTabset(draft, action.tabsetId)) return false;
+			draft.activeTabsetId = action.tabsetId;
+			return true;
 		case "setFloatMinimized": {
 			const float = findFloat(draft, action.floatId);
-			if (float) float.minimized = action.minimized;
-			return;
+			if (!float || (float.minimized ?? false) === action.minimized) return false;
+			float.minimized = action.minimized;
+			return true;
+		}
+		case "setMaximizedTabset": {
+			const next = action.tabsetId ?? void 0;
+			if (draft.maximizedTabsetId === next) return false;
+			draft.maximizedTabsetId = next;
+			return true;
 		}
-		case "setMaximizedTabset":
-			draft.maximizedTabsetId = action.tabsetId ?? void 0;
-			return;
 		case "updateGlobalAttributes":
+			if (alreadyApplied(draft.global, action.attrs)) return false;
 			Object.assign(draft.global, action.attrs);
-			return;
+			return true;
 		case "updateNodeAttributes": {
 			const node = findAttributedNode(draft, action.nodeId);
-			if (node) Object.assign(node, action.attrs);
-			return;
+			if (!node) return false;
+			const parsed = parseNodeAttrs(node, action.attrs);
+			if (alreadyApplied(node, parsed)) return false;
+			Object.assign(node, parsed);
+			return true;
 		}
-		default: assertNever(action);
+		default: return assertNever(action);
 	}
 };
+/** Identity-equal output means "no edit". A rejected action skips `normalize`, so
+* pass a model that has already been through it. */
 const reducer = (model, action) => {
 	const draft = structuredClone(model);
-	applyAction(draft, action);
+	if (!applyAction(draft, action)) return model;
 	return normalize(draft);
 };
 
@@ -1028,8 +1108,14 @@ const createHistory = (present) => ({
 });
 const canUndo = (history) => history.past.length > 0;
 const canRedo = (history) => history.future.length > 0;
+/**
+* An action that changed nothing is not an edit: recording it would spend an
+* undo slot and clear a redo stack the user just built. Not coalescing (ADR
+* 0002): two distinct edits are still two entries.
+*/
 const dispatch = (history, action) => {
 	const present = reducer(history.present, action);
+	if (Object.is(present, history.present)) return history;
 	return {
 		future: [],
 		past: [...history.past, history.present].slice(-100),
@@ -1075,25 +1161,50 @@ const dashfooMachine = setup({ types: {
 
 //#endregion
 //#region src/machines/drag-dock-machine.ts
-const requireDrop = (context) => {
-	if (context.subject === null || context.intent === null) throw new Error("drop requires a subject and a drop intent");
+/** One definition of both "is this drop valid" and "what does it do", so the guard and the emit agree. */
+const dropAction = (drag) => {
+	if (drag.kind !== "dragging" || drag.drop === null) return null;
+	const { intent, scope } = drag.drop;
+	const { subject } = drag;
+	if (subject.kind === "external") return {
+		action: {
+			index: intent.index,
+			location: intent.location,
+			tab: subject.tab,
+			targetId: intent.targetId,
+			type: "addNode"
+		},
+		scope
+	};
+	if (subject.kind === "tabset") return {
+		action: {
+			location: intent.location,
+			sourceId: subject.id,
+			targetId: intent.targetId,
+			type: "moveTabset"
+		},
+		scope
+	};
 	return {
-		intent: context.intent,
-		subject: context.subject
+		action: {
+			index: intent.index,
+			location: intent.location,
+			sourceId: subject.id,
+			targetId: intent.targetId,
+			type: "moveNode"
+		},
+		scope
 	};
 };
 const dragDockMachine = setup({
-	guards: { hasValidDrop: ({ context }) => context.subject !== null && context.intent !== null },
+	guards: { hasValidDrop: ({ context }) => dropAction(context.drag) !== null },
 	types: {
 		context: {},
 		emitted: {},
 		events: {}
 	}
 }).createMachine({
-	context: {
-		intent: null,
-		subject: null
-	},
+	context: { drag: { kind: "idle" } },
 	id: "dragDock",
 	initial: "idle",
 	states: {
@@ -1101,36 +1212,30 @@ const dragDockMachine = setup({
 			CANCEL: { target: "idle" },
 			DROP: [{
 				actions: emit(({ context }) => {
-					const { intent, subject } = requireDrop(context);
+					const resolved = dropAction(context.drag);
+					if (resolved === null) throw new Error("drop requires a subject and a resolved drop target");
 					return {
-						action: subject.kind === "external" ? {
-							index: intent.index,
-							location: intent.location,
-							tab: subject.tab,
-							targetId: intent.targetId,
-							type: "addNode"
-						} : {
-							index: intent.index,
-							location: intent.location,
-							sourceId: subject.id,
-							targetId: intent.targetId,
-							type: subject.kind === "tabset" ? "moveTabset" : "moveNode"
-						},
+						action: resolved.action,
+						scope: resolved.scope,
 						type: "COMMIT"
 					};
 				}),
 				guard: "hasValidDrop",
 				target: "idle"
 			}, { target: "idle" }],
-			OVER: { actions: assign({ intent: ({ event }) => event.intent }) }
+			OVER: { actions: assign({ drag: ({ context, event }) => context.drag.kind === "dragging" ? {
+				...context.drag,
+				drop: event.drop
+			} : context.drag }) }
 		} },
 		idle: {
-			entry: assign({
-				intent: null,
-				subject: null
-			}),
+			entry: assign({ drag: { kind: "idle" } }),
 			on: { START: {
-				actions: assign({ subject: ({ event }) => event.subject }),
+				actions: assign({ drag: ({ event }) => ({
+					drop: null,
+					kind: "dragging",
+					subject: event.subject
+				}) }),
 				target: "dragging"
 			} }
 		}
@@ -1164,12 +1269,13 @@ const stackModel = (model, orientation = "column") => {
 			children,
 			id: model.layout.id,
 			orientation,
-			type: "row"
+			type: "row",
+			weight: model.layout.weight
 		},
 		maximizedTabsetId: void 0
 	});
 };
 
 //#endregion
-export { DEFAULT_SNAP_THRESHOLD, HISTORY_LIMIT, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, dimensionSchema, dispatch, dockLocationSchema, dockZonePolygons, dragDockMachine, edgeSchema, findAttributedNode, findDuplicateIds, findFloat, findRootContaining, findRow, findTab, findTabset, findTabsetParent, floatNode, floatNodeSchema, fromJSON, geometrySchema, getFirstTabset, globalAttributesSchema, jsonValueSchema, model, mutableNodeAttrsSchema, normalize, orientationSchema, parseModel, redo, reducer, resolveDockTarget, resolveSnapTargets, row, rowNodeSchema, snapEnabled, snapSchema, snapSizes, stackModel, tab, tabNodeSchema, tabset, tabsetNodeSchema, toJSON, undo, unitSchema, zoneRect };
+export { DEFAULT_SNAP_THRESHOLD, DEFAULT_WEIGHT, HISTORY_LIMIT, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, decideSnap, dimensionSchema, dispatch, dockLocationSchema, dockZonePolygons, dragDockMachine, dropAction, edgeSchema, findAttributedNode, findDuplicateIds, findFloat, findRootContaining, findRow, findTab, findTabset, findTabsetParent, floatNode, floatNodeSchema, fromJSON, geometrySchema, getFirstTabset, globalAttributesSchema, jsonValueSchema, model, mutableNodeAttrsSchema, normalize, orientationSchema, parseModel, redo, reducer, resolveDockTarget, resolveSnapGrid, resolveSnapTargets, row, rowNodeSchema, settleSnap, snapEnabled, snapSchema, snapSizes, splitEdge, stackModel, tab, tabNodeSchema, tabset, tabsetNodeObjectSchema, tabsetNodeSchema, toJSON, undo, unitSchema, zoneRect };
 //# sourceMappingURL=index.js.map